@caleuche/cli 0.5.3 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @caleuche/cli
 
+## 0.6.0
+
+### Minor Changes
+
+- 2758d63: Add test override functionality
+
+### Patch Changes
+
+- Updated dependencies [2758d63]
+  - @caleuche/core@0.6.0
+
 ## 0.5.3
 
 ### Patch Changes

package/README.md

@@ -58,6 +58,7 @@ che batch <batch-file> [options]
 **Options:**
 
 - `-d, --output-dir <outputDir>`: Base output directory for all compiled samples (defaults to the batch file's directory)
+- `-t, --test-overrides <json>`: JSON string with test overrides to generate test samples in a `test/` subfolder (e.g., `'{"key": "value"}'`)
 
 The batch command is ideal for generating multiple variations of samples, such as producing the same template with development and production configurations, or creating examples across different scenarios.
 
@@ -532,6 +533,9 @@ samples:  # (required) List of templates to compile
           value: variant-name
         tags:  # (optional) Override or add tags for this variant
           key: value
+        testOverrides:  # (optional) Test overrides for this variant
+          input:
+            key: test-value
 ```
 
 **Fields:**
@@ -548,6 +552,7 @@ samples:  # (required) List of templates to compile
       - An object with `type: "path"` and `value` pointing to a data file
       - An object with `type: "reference"` and `value` naming a variant
     - `tags`: Optional metadata to add/override for this specific variant
+    - `testOverrides`: Optional test parameter overrides. When specified, a `test/` subfolder is generated with samples using overridden input values.
 
 **Input Types:**
 
@@ -577,6 +582,55 @@ After compilation, the output directory will contain:
 
 3. **Tags file** (when tags are defined): `tags.yaml` containing the metadata
 
+4. **Test subfolder** (when test overrides are defined): `test/` directory containing samples compiled with test-specific input overrides
+
+### Test Overrides
+
+Test overrides allow you to generate test variants of your samples with modified input values. This is useful for creating samples with test-specific configurations, mock endpoints, or test credentials.
+
+**Precedence (most specific wins):**
+1. Variant-level `testOverrides` (highest priority)
+2. Sample-level `testOverrides` (in sample.yaml)
+3. Command-level `--test-overrides` (lowest priority)
+
+Overrides are merged, so you can set base test values at the command level and override specific values at the variant level.
+
+**Example: Command-level test overrides**
+
+```bash
+che batch ./batch.yaml -t '{"endpoint": "https://test-api.example.com", "apiKey": "test-key"}'
+```
+
+This generates a `test/` subfolder for each sample with `endpoint` and `apiKey` overridden.
+
+**Example: Variant-level test overrides in batch.yaml**
+
+```yaml
+samples:
+  - templatePath: ./my-sample
+    variants:
+      - output: ./output/default
+        input:
+          type: object
+          properties:
+            endpoint: https://endpoint.com
+        testOverrides:
+          input:
+            endpoint: https://test-endpoint.com
+```
+
+**Output structure with test overrides:**
+
+```
+output/
+  default/
+    sample.py
+    requirements.txt
+    test/
+      sample.py         # Uses test endpoint and model
+      requirements.txt
+```
+
 ## License
 
 MIT

package/dist/batch.js

@@ -66,11 +66,37 @@ function resolveVariantDefinition(variant, variantRegistry, workingDirectory) {
         return null;
     }
 }
+/**
+ * Resolves the effective testOverrides by merging with precedence:
+ * variant-level > sample-level > command-level
+ */
+function resolveTestOverrides(commandLevelOverrides, sampleLevelOverrides, variantLevelOverrides) {
+    if (!commandLevelOverrides && !sampleLevelOverrides && !variantLevelOverrides) {
+        return undefined;
+    }
+    const mergedInput = {
+        ...(commandLevelOverrides || {}),
+        ...(sampleLevelOverrides?.input || {}),
+        ...(variantLevelOverrides?.input || {}),
+    };
+    return { input: mergedInput };
+}
 function batchCompile(batchFile, options) {
     if (!(0, utils_1.isFile)(batchFile)) {
         console.error(`Batch file "${batchFile}" does not exist or is not a file.`);
         process.exit(1);
     }
+    // Parse command-level test overrides if provided
+    let commandTestOverrides;
+    if (options.testOverrides) {
+        try {
+            commandTestOverrides = JSON.parse(options.testOverrides);
+        }
+        catch (e) {
+            console.error(`Failed to parse --test-overrides JSON: ${options.testOverrides}`);
+            process.exit(1);
+        }
+    }
     const workingDirectory = (0, utils_1.getAbsoluteDirectoryPath)(batchFile);
     console.log(`Working directory: ${workingDirectory}`);
     const batchDefinition = (0, utils_1.parse)(batchFile);
@@ -98,9 +124,10 @@ function batchCompile(batchFile, options) {
                 process.exit(1);
             }
             sample.tags = variant.tags;
+            sample.testOverrides = resolveTestOverrides(commandTestOverrides, sample.testOverrides, variant.testOverrides);
             const effectiveOutputPath = path_1.default.join(options?.outputDir || workingDirectory, variant.output);
             if (!(0, common_1.compileAndWriteOutput)(sample, resolvedVariant.properties, effectiveOutputPath, {
-                project: sample.dependencies && sample.dependencies.length > 0,
+                project: (sample.dependencies?.length ?? 0) > 0,
             })) {
                 console.error(`Sample: ${sampleDefinition.templatePath}, Variant: ${JSON.stringify(variant)}`);
                 process.exit(1);

package/dist/common.js

@@ -48,9 +48,9 @@ function compileAndWriteOutput(sample, input, outputPath, options) {
         return false;
     }
     try {
-        (0, utils_1.createOutputDirectory)(outputPath);
         for (const { fileName, content } of output.items) {
             const itemOutputPath = path_1.default.join(outputPath, fileName);
+            (0, utils_1.createOutputDirectory)(path_1.default.dirname(itemOutputPath));
             fs_1.default.writeFileSync(itemOutputPath, content);
         }
     }

package/dist/index.js

@@ -20,5 +20,6 @@ commander_1.program
     .command("batch")
     .argument("<batch-file>", "Path to the batch file")
     .option("-d, --output-dir <outputDir>", "Output directory for compiled samples")
+    .option("-t, --test-overrides <json>", 'JSON string with test overrides, e.g. \'{"input": {"key": "value"}}\'')
     .action(batch_1.batchCompile);
 commander_1.program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caleuche/cli",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "main": "dist/index.js",
   "bin": {
     "che": "dist/index.js"
@@ -19,7 +19,7 @@
   "license": "MIT",
   "description": "Caleuche CLI",
   "dependencies": {
-    "@caleuche/core": "^0.5.0",
+    "@caleuche/core": "^0.6.0",
     "commander": "^14.0.0",
     "yaml": "^2.8.0"
   },

package/src/batch.ts

@@ -80,14 +80,48 @@ function resolveVariantDefinition(
   }
 }
 
+/**
+ * Resolves the effective testOverrides by merging with precedence:
+ * variant-level > sample-level > command-level
+ */
+function resolveTestOverrides(
+  commandLevelOverrides: Record<string, any> | undefined,
+  sampleLevelOverrides: { input: Record<string, any> } | undefined,
+  variantLevelOverrides: { input: Record<string, any> } | undefined,
+): { input: Record<string, any> } | undefined {
+  if (!commandLevelOverrides && !sampleLevelOverrides && !variantLevelOverrides) {
+    return undefined;
+  }
+
+  const mergedInput: Record<string, any> = {
+    ...(commandLevelOverrides || {}),
+    ...(sampleLevelOverrides?.input || {}),
+    ...(variantLevelOverrides?.input || {}),
+  };
+
+  return { input: mergedInput };
+}
+
 export function batchCompile(
   batchFile: string,
-  options: { outputDir?: string },
+  options:{ outputDir?: string; testOverrides?: string },
 ) {
   if (!isFile(batchFile)) {
     console.error(`Batch file "${batchFile}" does not exist or is not a file.`);
     process.exit(1);
   }
+
+  // Parse command-level test overrides if provided
+  let commandTestOverrides: Record<string, any> | undefined;
+  if (options.testOverrides) {
+    try {
+      commandTestOverrides = JSON.parse(options.testOverrides);
+    } catch (e) {
+      console.error(`Failed to parse --test-overrides JSON: ${options.testOverrides}`);
+      process.exit(1);
+    }
+  }
+
   const workingDirectory = getAbsoluteDirectoryPath(batchFile);
   console.log(`Working directory: ${workingDirectory}`);
   const batchDefinition = parse<BatchCompileDescription>(batchFile);
@@ -130,6 +164,12 @@ export function batchCompile(
 
       sample.tags = variant.tags;
 
+      sample.testOverrides = resolveTestOverrides(
+        commandTestOverrides,
+        sample.testOverrides,
+        variant.testOverrides,
+      );
+
       const effectiveOutputPath = path.join(
         options?.outputDir || workingDirectory,
         variant.output,
@@ -141,7 +181,7 @@ export function batchCompile(
           resolvedVariant.properties,
           effectiveOutputPath,
           {
-            project: sample.dependencies && sample.dependencies.length > 0,
+            project: (sample.dependencies?.length ?? 0) > 0,
           },
         )
       ) {

package/src/common.ts

@@ -54,10 +54,9 @@ export function compileAndWriteOutput(
   }
 
   try {
-    createOutputDirectory(outputPath);
-
     for (const { fileName, content } of output.items) {
       const itemOutputPath = path.join(outputPath, fileName);
+      createOutputDirectory(path.dirname(itemOutputPath));
       fs.writeFileSync(itemOutputPath, content);
     }
   } catch {

package/src/index.ts

@@ -37,6 +37,10 @@ program
     "-d, --output-dir <outputDir>",
     "Output directory for compiled samples",
   )
+  .option(
+    "-t, --test-overrides <json>",
+    'JSON string with test overrides, e.g. \'{"input": {"key": "value"}}\'',
+  )
   .action(batchCompile);
 
 program.parse();

package/src/interfaces.ts

@@ -18,10 +18,15 @@ type SampleVariantInput =
   | SampleVariantInputReference
   | SampleVariantInputPath;
 
+interface TestOverrides {
+  input: Record<string, any>;
+}
+
 interface SampleVariantConfig {
   output: string;
   input: SampleVariantInput | string;
   tags?: Record<string, any>;
+  testOverrides?: TestOverrides;
 }
 
 interface SampleDefinition {

package/test/bach.test.ts

@@ -402,4 +402,267 @@ describe("batchCompile", () => {
       `,
     );
   });
+
+  describe("testOverrides", () => {
+    it("should exit if --test-overrides JSON is invalid", () => {
+      const batchFilePath = getPath("batch.yaml");
+      const batchFileContent = multiline`
+        samples:
+          - templatePath: sample.yaml
+            variants:
+              - output: out
+                input:
+                  type: object
+                  properties:
+                    var: value
+      `;
+      fs.writeFileSync(batchFilePath, batchFileContent);
+      const sampleFilePath = getPath("sample.yaml");
+      const sampleContent = multiline`
+        template: sample.js.template
+        type: javascript
+        dependencies:
+        input:
+          - name: var
+            type: string
+            required: true
+      `;
+      fs.writeFileSync(sampleFilePath, sampleContent);
+
+      expect(() => {
+        batchCompile(batchFilePath, { testOverrides: "invalid json" });
+      }).toThrow("process.exit");
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Failed to parse --test-overrides JSON: invalid json",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should pass command-level testOverrides to sample", () => {
+      mockCompileSample.mockReturnValue({
+        items: [{ fileName: "sample.js", content: "code" }],
+      });
+      const batchFilePath = getPath("batch.yaml");
+      const batchFileContent = multiline`
+        samples:
+          - templatePath: sample.yaml
+            variants:
+              - output: out
+                input:
+                  type: object
+                  properties:
+                    var: value
+      `;
+      fs.writeFileSync(batchFilePath, batchFileContent);
+      const sampleFilePath = getPath("sample.yaml");
+      const sampleContent = multiline`
+        template: sample.js.template
+        type: javascript
+        dependencies:
+        input:
+          - name: var
+            type: string
+            required: true
+      `;
+      fs.writeFileSync(sampleFilePath, sampleContent);
+
+      batchCompile(batchFilePath, {
+        testOverrides: '{"endpoint": "https://test.com"}',
+      });
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        expect.objectContaining({
+          testOverrides: { input: { endpoint: "https://test.com" } },
+        }),
+        expect.any(Object),
+        expect.any(Object),
+      );
+    });
+
+    it("should pass variant-level testOverrides to sample", () => {
+      mockCompileSample.mockReturnValue({
+        items: [{ fileName: "sample.js", content: "code" }],
+      });
+      const batchFilePath = getPath("batch.yaml");
+      const batchFileContent = multiline`
+        samples:
+          - templatePath: sample.yaml
+            variants:
+              - output: out
+                input:
+                  type: object
+                  properties:
+                    var: value
+                testOverrides:
+                  input:
+                    endpoint: https://variant-test.com
+      `;
+      fs.writeFileSync(batchFilePath, batchFileContent);
+      const sampleFilePath = getPath("sample.yaml");
+      const sampleContent = multiline`
+        template: sample.js.template
+        type: javascript
+        dependencies:
+        input:
+          - name: var
+            type: string
+            required: true
+      `;
+      fs.writeFileSync(sampleFilePath, sampleContent);
+
+      batchCompile(batchFilePath, {});
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        expect.objectContaining({
+          testOverrides: { input: { endpoint: "https://variant-test.com" } },
+        }),
+        expect.any(Object),
+        expect.any(Object),
+      );
+    });
+
+    it("should merge testOverrides with variant-level taking precedence over command-level", () => {
+      mockCompileSample.mockReturnValue({
+        items: [{ fileName: "sample.js", content: "code" }],
+      });
+      const batchFilePath = getPath("batch.yaml");
+      const batchFileContent = multiline`
+        samples:
+          - templatePath: sample.yaml
+            variants:
+              - output: out
+                input:
+                  type: object
+                  properties:
+                    var: value
+                testOverrides:
+                  input:
+                    endpoint: https://variant-wins.com
+                    variantOnly: true
+      `;
+      fs.writeFileSync(batchFilePath, batchFileContent);
+      const sampleFilePath = getPath("sample.yaml");
+      const sampleContent = multiline`
+        template: sample.js.template
+        type: javascript
+        dependencies:
+        input:
+          - name: var
+            type: string
+            required: true
+      `;
+      fs.writeFileSync(sampleFilePath, sampleContent);
+
+      batchCompile(batchFilePath, {
+        testOverrides: '{"endpoint": "https://command-level.com", "commandOnly": "value"}',
+      });
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        expect.objectContaining({
+          testOverrides: {
+            input: {
+              endpoint: "https://variant-wins.com",
+              commandOnly: "value",
+              variantOnly: true,
+            },
+          },
+        }),
+        expect.any(Object),
+        expect.any(Object),
+      );
+    });
+
+    it("should merge testOverrides with sample-level in precedence chain", () => {
+      mockCompileSample.mockReturnValue({
+        items: [{ fileName: "sample.js", content: "code" }],
+      });
+      const batchFilePath = getPath("batch.yaml");
+      const batchFileContent = multiline`
+        samples:
+          - templatePath: sample.yaml
+            variants:
+              - output: out
+                input:
+                  type: object
+                  properties:
+                    var: value
+                testOverrides:
+                  input:
+                    variantKey: variantValue
+      `;
+      fs.writeFileSync(batchFilePath, batchFileContent);
+      const sampleFilePath = getPath("sample.yaml");
+      const sampleContent = multiline`
+        template: sample.js.template
+        type: javascript
+        dependencies:
+        input:
+          - name: var
+            type: string
+            required: true
+        testOverrides:
+          input:
+            sampleKey: sampleValue
+            variantKey: sampleShouldLose
+      `;
+      fs.writeFileSync(sampleFilePath, sampleContent);
+
+      batchCompile(batchFilePath, {
+        testOverrides: '{"commandKey": "commandValue", "sampleKey": "commandShouldLose"}',
+      });
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        expect.objectContaining({
+          testOverrides: {
+            input: {
+              commandKey: "commandValue",
+              sampleKey: "sampleValue",
+              variantKey: "variantValue",
+            },
+          },
+        }),
+        expect.any(Object),
+        expect.any(Object),
+      );
+    });
+
+    it("should not set testOverrides when none are provided", () => {
+      mockCompileSample.mockReturnValue({
+        items: [{ fileName: "sample.js", content: "code" }],
+      });
+      const batchFilePath = getPath("batch.yaml");
+      const batchFileContent = multiline`
+        samples:
+          - templatePath: sample.yaml
+            variants:
+              - output: out
+                input:
+                  type: object
+                  properties:
+                    var: value
+      `;
+      fs.writeFileSync(batchFilePath, batchFileContent);
+      const sampleFilePath = getPath("sample.yaml");
+      const sampleContent = multiline`
+        template: sample.js.template
+        type: javascript
+        dependencies:
+        input:
+          - name: var
+            type: string
+            required: true
+      `;
+      fs.writeFileSync(sampleFilePath, sampleContent);
+
+      batchCompile(batchFilePath, {});
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        expect.objectContaining({
+          testOverrides: undefined,
+        }),
+        expect.any(Object),
+        expect.any(Object),
+      );
+    });
+  });
 });