Create test case cli

src/cli.ts

@@ -38,6 +38,7 @@ import {
 } from "./tools";
 import { init, switchTestTarget } from "./tools/init";
 import { update } from "./tools/update";
+import { create } from "./tools/yamlMutations/create";
 import { edit } from "./tools/yamlMutations/edit";
 import { version } from "./version";
 
@@ -402,6 +403,24 @@ export const buildCmd = (): CompletableCommand => {
     .addOption(testTargetIdOption)
     .action(addTestTargetWrapper(pushTestTarget));
 
+  // noinspection RequiredAttributes
+  createCommandWithCommonOptions(program, "create-test-case")
+    .completer(testTargetIdCompleter)
+    .description("Create a new test case")
+    .helpGroup("test-cases")
+    .addOption(testTargetIdOption)
+    .requiredOption(
+      "-n, --name <string>",
+      "The name of the test case you want to create",
+    )
+    .addOption(
+      new Option(
+        "-d, --dependency-path <path>",
+        "The path of to test case you want to use as dependency",
+      ),
+    )
+    .action(addTestTargetWrapper(create));
+
   // noinspection RequiredAttributes
   createCommandWithCommonOptions(program, "edit-test-case")
     .completer(testTargetIdCompleter)

src/tools/sync/yaml.ts

@@ -201,6 +201,15 @@ export const readTestCasesFromDir = (startDir: string): SyncTestCase[] => {
   return testCases;
 };
 
+export const loadTestCase = (testCasePath: string): SyncTestCase => {
+  try {
+    const content = fs.readFileSync(testCasePath, "utf8");
+    return yaml.parse(content);
+  } catch (error) {
+    throw new Error(`Could not parse ${testCasePath}: ${error}`);
+  }
+};
+
 export const cleanupFilesystem = ({
   newTestCases,
   destination,

src/tools/yamlMutations/create.ts

@@ -0,0 +1,180 @@
+import path from "node:path";
+
+import { createTwoFilesPatch } from "diff";
+import open from "open";
+import yaml from "yaml";
+
+import { OCTOMIND_FOLDER_NAME } from "../../constants";
+import {
+  findOctomindFolder,
+  getAbsoluteFilePathInOctomindRoot,
+} from "../../helpers";
+import { BASE_URL, client, handleError } from "../client";
+import { checkForConsistency } from "../sync/consistency";
+import { draftPush } from "../sync/push";
+import { SyncDataByStableId, SyncTestCase } from "../sync/types";
+import {
+  buildFilename,
+  buildFolderName,
+  loadTestCase,
+  readTestCasesFromDir,
+  writeSingleTestCaseYaml,
+} from "../sync/yaml";
+import { getRelevantTestCases } from "./getRelevantTestCases";
+import { waitForLocalChangesToBeFinished } from "./waitForLocalChanges";
+
+type CreateOptions = {
+  testTargetId: string;
+  name: string;
+  dependencyPath?: string;
+};
+
+const getDependencyTestCases = async ({
+  octomindRoot,
+  dependencyPath,
+}: {
+  octomindRoot: string;
+  dependencyPath: string;
+}): Promise<{
+  dependencyTestCase: SyncTestCase;
+  relevantTestCases: SyncTestCase[];
+}> => {
+  const dependencyFilePath = await getAbsoluteFilePathInOctomindRoot({
+    octomindRoot,
+    filePath: dependencyPath,
+  });
+
+  if (!dependencyFilePath) {
+    throw new Error(
+      `Could not find dependency test case ${dependencyPath} in folder ${octomindRoot}`,
+    );
+  }
+  const dependencyTestCase = loadTestCase(dependencyFilePath);
+
+  const testCases = readTestCasesFromDir(octomindRoot);
+  const testCasesById = Object.fromEntries(testCases.map((tc) => [tc.id, tc]));
+
+  const relevantTestCases = getRelevantTestCases(
+    testCasesById,
+    dependencyTestCase,
+  );
+  return { dependencyTestCase, relevantTestCases };
+};
+
+const openBrowser = async ({
+  versionId,
+  testTargetId,
+}: {
+  versionId: string;
+  testTargetId: string;
+}): Promise<void> => {
+  const parsedBaseUrl = URL.parse(BASE_URL);
+  const localEditingUrl = new URL(
+    `${parsedBaseUrl?.protocol}//${parsedBaseUrl?.host}/testtargets/${testTargetId}/testcases/${versionId}/localEdit`,
+  );
+
+  await open(localEditingUrl.href);
+
+  console.log(
+    `Navigating to local url, open it manually if a browser didn't open already: ${localEditingUrl}`,
+  );
+};
+
+const writeOutput = async ({
+  testCaseFilePath,
+  createResult,
+}: {
+  testCaseFilePath: string;
+  createResult: SyncTestCase | "cancelled";
+}): Promise<void> => {
+  if (createResult === "cancelled") {
+    console.log("Cancelled editing test case, exiting");
+    return;
+  }
+
+  await writeSingleTestCaseYaml(testCaseFilePath, createResult);
+
+  const diff = createTwoFilesPatch(
+    "old.yaml",
+    "new.yaml",
+    "",
+    yaml.stringify(createResult),
+  );
+
+  console.log(`Created test case successfully`);
+  console.log(diff);
+};
+
+export const create = async (options: CreateOptions): Promise<void> => {
+  const octomindRoot = await findOctomindFolder();
+  if (!octomindRoot) {
+    throw new Error(
+      `Could not find ${OCTOMIND_FOLDER_NAME} folder, make sure to pull before trying to create a test case`,
+    );
+  }
+
+  let dependencyId: string | undefined = undefined;
+  const testCasesToPush: SyncTestCase[] = [];
+  if (options.dependencyPath) {
+    const { dependencyTestCase, relevantTestCases } =
+      await getDependencyTestCases({
+        octomindRoot,
+        dependencyPath: options.dependencyPath,
+      });
+    dependencyId = dependencyTestCase.id;
+    testCasesToPush.push(...relevantTestCases);
+  }
+
+  const newTestCase: SyncTestCase = {
+    version: "1",
+    id: crypto.randomUUID(),
+    dependencyId,
+    elements: [],
+    runStatus: "OFF",
+    description: options.name,
+    prompt: "",
+    localEditingStatus: "IN_PROGRESS" as const,
+  };
+  testCasesToPush.push(newTestCase);
+  checkForConsistency(testCasesToPush);
+
+  const response = await draftPush(
+    {
+      testCases: testCasesToPush,
+    },
+    {
+      testTargetId: options.testTargetId,
+      client,
+      onError: handleError,
+    },
+  );
+
+  if (!response) {
+    throw new Error(
+      `Could not create new test case with id '${newTestCase.id}'`,
+    );
+  }
+  const syncData = response.syncDataByStableId[newTestCase.id];
+  if (!syncData) {
+    throw new Error(`Could not create test case with id '${newTestCase.id}'`);
+  }
+
+  await openBrowser({
+    versionId: syncData.versionId,
+    testTargetId: options.testTargetId,
+  });
+  const createResult = await waitForLocalChangesToBeFinished(
+    syncData.versionId,
+    newTestCase,
+    { testTargetId: options.testTargetId },
+  );
+
+  const testCaseFolder = buildFolderName(
+    newTestCase,
+    testCasesToPush,
+    octomindRoot,
+  );
+  const newTestCaseName = buildFilename(newTestCase, octomindRoot);
+  const newTestCasePath = path.join(testCaseFolder, newTestCaseName);
+  await writeOutput({ createResult, testCaseFilePath: newTestCasePath });
+};

src/tools/yamlMutations/edit.ts

@@ -1,21 +1,20 @@
-import fs from "fs";
-
 import { createTwoFilesPatch } from "diff";
 import open from "open";
-import ora from "ora";
 import yaml from "yaml";
 
 import { OCTOMIND_FOLDER_NAME } from "../../constants";
 import {
   findOctomindFolder,
   getAbsoluteFilePathInOctomindRoot,
-  sleep,
 } from "../../helpers";
 import { BASE_URL, client, handleError } from "../client";
 import { checkForConsistency } from "../sync/consistency";
 import { draftPush } from "../sync/push";
-import { SyncTestCase } from "../sync/types";
-import { readTestCasesFromDir, writeSingleTestCaseYaml } from "../sync/yaml";
+import {
+  loadTestCase,
+  readTestCasesFromDir,
+  writeSingleTestCaseYaml,
+} from "../sync/yaml";
 import { getRelevantTestCases } from "./getRelevantTestCases";
 import { waitForLocalChangesToBeFinished } from "./waitForLocalChanges";
 
@@ -24,15 +23,6 @@ type EditOptions = {
   filePath: string;
 };
 
-const loadTestCase = (testCasePath: string): SyncTestCase => {
-  try {
-    const content = fs.readFileSync(testCasePath, "utf8");
-    return yaml.parse(content);
-  } catch (error) {
-    throw new Error(`Could not parse ${testCasePath}: ${error}`);
-  }
-};
-
 export const edit = async (options: EditOptions): Promise<void> => {
   const octomindRoot = await findOctomindFolder();
   if (!octomindRoot) {

tests/mocks.ts

@@ -3,7 +3,7 @@ import {
   TestCaseResponse,
   TestReport,
 } from "../src/tools";
-import { SyncTestCase } from "../src/tools/sync/types";
+import { SyncDataByStableId, SyncTestCase } from "../src/tools/sync/types";
 
 export const createMockSyncTestCase = (
   overrides?: Partial<SyncTestCase>,
@@ -76,3 +76,18 @@ export const createMockTestReport = (
   updatedAt: new Date().toISOString(),
   ...overrides,
 });
+
+export const createMockDraftPushResponse = (
+  testCaseId: string,
+  overrides?: Partial<SyncDataByStableId[string]>,
+): {
+  success: boolean;
+  versionIds: string[];
+  syncDataByStableId: SyncDataByStableId;
+} => ({
+  success: true,
+  versionIds: [],
+  syncDataByStableId: {
+    [testCaseId]: { versionId: "version-123", ...overrides },
+  },
+});