@auto-engineer/narrative 0.20.0 → 0.21.0

package/dist/src/id/hasAllIds.specs.js

@@ -1,424 +1,231 @@
-import { describe, expect, it } from 'vitest';
-import { addAutoIds, hasAllIds } from './index.js';
+import { describe, expect, it, beforeEach } from 'vitest';
+import { hasAllIds, addAutoIds } from './index.js';
+import { getNarratives } from '../getNarratives.js';
+import { InMemoryFileStore } from '@auto-engineer/file-store';
+import * as flowApi from '../narrative.js';
+import * as fluent from '../fluent-builder.js';
+import * as dataBuilders from '../data-narrative-builders.js';
+import * as typesApi from '../types.js';
+import gql from 'graphql-tag';
+const importMap = {
+    '../flow': flowApi,
+    '../fluent-builder': fluent,
+    '../data-flow-builders': dataBuilders,
+    '../types': typesApi,
+    'graphql-tag': gql,
+};
 describe('hasAllIds', () => {
-    const createModelWithoutIds = () => ({
-        variant: 'specs',
-        narratives: [
-            {
-                name: 'Test Flow Without IDs',
-                slices: [
-                    {
-                        type: 'command',
-                        name: 'Test slice without ID',
-                        client: { specs: [] },
-                        server: {
-                            description: 'Test server',
-                            specs: [
-                                {
-                                    type: 'gherkin',
-                                    feature: 'Test specs',
-                                    rules: [
-                                        {
-                                            name: 'Test rule without ID',
-                                            examples: [],
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    },
-                ],
-            },
-        ],
-        messages: [],
-        integrations: [],
-    });
-    const createModelWithIds = () => ({
-        variant: 'specs',
-        narratives: [
-            {
-                name: 'Test Flow with IDs',
-                id: 'FLOW-001',
-                slices: [
-                    {
-                        type: 'command',
-                        name: 'Test slice with ID',
-                        id: 'SLICE-001',
-                        client: { specs: [] },
-                        server: {
-                            description: 'Test server',
-                            specs: [
-                                {
-                                    id: 'SPEC-001',
-                                    type: 'gherkin',
-                                    feature: 'Test specs',
-                                    rules: [
-                                        {
-                                            id: 'RULE-001',
-                                            name: 'Test rule with ID',
-                                            examples: [],
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    },
-                ],
-            },
-        ],
-        messages: [],
-        integrations: [],
+    let vfs;
+    const root = '/test';
+    beforeEach(async () => {
+        vfs = new InMemoryFileStore();
+        const flowWithoutIds = `
+import { flow, specs, rule, example } from '../narrative.js';
+import { command } from '../fluent-builder.js';
+
+flow('Test Flow Without IDs', () => {
+  command('Test slice without ID')
+    .server(() => {
+      specs('Test specs', () => {
+        rule('Test rule without ID', () => {
+          example('Test example')
+            .when({ test: 'data' })
+            .then({ result: 'success' });
+        });
+      });
+    });
+});`;
+        const flowWithIds = `
+import { flow, specs, rule, example } from '../narrative.js';
+import { command } from '../fluent-builder.js';
+
+flow('Test Flow with IDs', 'FLOW-001', () => {
+  command('Test slice with ID', 'SLICE-001')
+    .server(() => {
+      specs('Test specs', () => {
+        rule('Test rule with ID', 'RULE-001', () => {
+          example('Test example')
+            .when({ test: 'data' })
+            .then({ result: 'success' });
+        });
+      });
+    });
+});`;
+        const multipleFlowsSameSource = `
+import { flow, specs, should } from '../narrative.js';
+import { experience } from '../fluent-builder.js';
+
+flow('Home Screen', 'AUTO-aifPcU3hw', () => {
+  experience('Active Surveys Summary', 'AUTO-slice1').client(() => {
+    specs(() => {
+      should('show active surveys summary');
+    });
+  });
+});
+
+flow('Create Survey', 'AUTO-MPviTMrQC', () => {
+  experience('Create Survey Form', 'AUTO-slice2').client(() => {
+    specs(() => {
+      should('allow entering survey title');
     });
-    const createModelWithFullIds = () => ({
-        variant: 'specs',
-        narratives: [
-            {
-                name: 'Test Flow with Full IDs',
-                id: 'FLOW-001',
-                slices: [
-                    {
-                        type: 'command',
-                        name: 'Test slice with ID',
-                        id: 'SLICE-001',
-                        client: { specs: [] },
-                        server: {
-                            description: 'Test server',
-                            specs: [
-                                {
-                                    id: 'SPEC-001',
-                                    type: 'gherkin',
-                                    feature: 'Test specs',
-                                    rules: [
-                                        {
-                                            id: 'RULE-001',
-                                            name: 'Test rule with ID',
-                                            examples: [
-                                                {
-                                                    id: 'EXAMPLE-001',
-                                                    name: 'Test example',
-                                                    steps: [
-                                                        {
-                                                            id: 'STEP-001',
-                                                            keyword: 'Given',
-                                                            text: 'TestState',
-                                                            docString: { value: 'test' },
-                                                        },
-                                                        {
-                                                            id: 'STEP-002',
-                                                            keyword: 'When',
-                                                            text: 'TestCommand',
-                                                        },
-                                                        {
-                                                            id: 'STEP-003',
-                                                            keyword: 'Then',
-                                                            text: 'TestEvent',
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    },
-                ],
-            },
-        ],
-        messages: [],
-        integrations: [],
+  });
+});
+
+flow('Response Analytics', 'AUTO-eME978Euk', () => {
+  experience('Response Rate Charts', 'AUTO-slice3').client(() => {
+    specs(() => {
+      should('show daily response rate charts');
+    });
+  });
+});`;
+        const multipleFlowsIncomplete = `
+import { flow, specs, should } from '../narrative.js';
+import { experience } from '../fluent-builder.js';
+
+flow('Home Screen', 'AUTO-aifPcU3hw', () => {
+  experience('Active Surveys Summary', 'AUTO-slice1').client(() => {
+    specs(() => {
+      should('show active surveys summary');
+    });
+  });
+});
+
+flow('Create Survey', () => {
+  experience('Create Survey Form', 'AUTO-slice2').client(() => {
+    specs(() => {
+      should('allow entering survey title');
     });
-    const createMultipleFlowsModel = (includeAllIds, includeAllSliceIds) => ({
-        variant: 'specs',
-        narratives: [
-            {
-                name: 'Home Screen',
-                id: 'aifPcU3hw',
-                sourceFile: '/path/to/homepage.narrative.ts',
-                slices: [
-                    {
-                        name: 'Active Surveys Summary',
-                        id: 'slice1',
-                        type: 'experience',
-                        client: { specs: [{ type: 'it', id: 'it1', title: 'show active surveys summary' }] },
-                    },
-                ],
-            },
-            {
-                name: 'Create Survey',
-                id: includeAllIds ? 'MPviTMrQC' : undefined,
-                sourceFile: '/path/to/homepage.narrative.ts',
-                slices: [
-                    {
-                        name: 'Create Survey Form',
-                        id: includeAllSliceIds ? 'slice2' : undefined,
-                        type: 'experience',
-                        client: { specs: [{ type: 'it', id: 'it2', title: 'allow entering survey title' }] },
-                    },
-                ],
-            },
-            {
-                name: 'Response Analytics',
-                id: 'eME978Euk',
-                sourceFile: '/path/to/homepage.narrative.ts',
-                slices: [
-                    {
-                        name: 'Response Rate Charts',
-                        id: 'slice3',
-                        type: 'experience',
-                        client: { specs: [{ type: 'it', id: 'it3', title: 'show daily response rate charts' }] },
-                    },
-                ],
-            },
-        ],
-        messages: [],
-        integrations: [],
+  });
+});
+
+flow('Response Analytics', 'AUTO-eME978Euk', () => {
+  experience('Response Rate Charts', 'AUTO-slice3').client(() => {
+    specs(() => {
+      should('show daily response rate charts');
+    });
+  });
+});`;
+        const multipleFlowsSliceMissing = `
+import { flow, specs, should } from '../narrative.js';
+import { experience } from '../fluent-builder.js';
+
+flow('Home Screen', 'AUTO-aifPcU3hw', () => {
+  experience('Active Surveys Summary', 'AUTO-slice1').client(() => {
+    specs(() => {
+      should('show active surveys summary');
+    });
+  });
+});
+
+flow('Create Survey', 'AUTO-MPviTMrQC', () => {
+  experience('Create Survey Form').client(() => {
+    specs(() => {
+      should('allow entering survey title');
     });
-    it('should return false for models without IDs', () => {
-        const model = createModelWithoutIds();
-        expect(hasAllIds(model)).toBe(false);
+  });
+});
+
+flow('Response Analytics', 'AUTO-eME978Euk', () => {
+  experience('Response Rate Charts', 'AUTO-slice3').client(() => {
+    specs(() => {
+      should('show daily response rate charts');
+    });
+  });
+});`;
+        const flowContent1 = new TextEncoder().encode(flowWithoutIds);
+        const flowContent2 = new TextEncoder().encode(flowWithIds);
+        const flowContent3 = new TextEncoder().encode(multipleFlowsSameSource);
+        const flowContent4 = new TextEncoder().encode(multipleFlowsIncomplete);
+        const flowContent5 = new TextEncoder().encode(multipleFlowsSliceMissing);
+        await vfs.write('/test/flow-without-ids.narrative.ts', flowContent1);
+        await vfs.write('/test/flow-with-ids.narrative.ts', flowContent2);
+        await vfs.write('/test/homepage.narrative.ts', flowContent3);
+        await vfs.write('/test/homepage-incomplete.narrative.ts', flowContent4);
+        await vfs.write('/test/homepage-slice-missing.narrative.ts', flowContent5);
+    });
+    it('should return false for models without IDs', async () => {
+        const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
+        const model = result.toModel();
+        const flowWithoutIds = model.narratives.find((f) => f.name === 'Test Flow Without IDs');
+        expect(flowWithoutIds).toBeDefined();
+        if (flowWithoutIds) {
+            const modelWithoutIds = { ...model, narratives: [flowWithoutIds] };
+            expect(hasAllIds(modelWithoutIds)).toBe(false);
+        }
     });
-    it('should return true for models with complete IDs', () => {
-        const model = createModelWithoutIds();
+    it('should return true for models with complete IDs', async () => {
+        const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
+        const model = result.toModel();
         const modelWithIds = addAutoIds(model);
         expect(hasAllIds(modelWithIds)).toBe(true);
     });
-    it('should return true for flows that already have IDs', () => {
-        const model = createModelWithIds();
-        expect(hasAllIds(model)).toBe(true);
-    });
-    it('should return false if any slice is missing an ID', () => {
-        const model = createModelWithIds();
-        const modifiedModel = structuredClone(model);
-        modifiedModel.narratives[0].slices[0].id = '';
-        expect(hasAllIds(modifiedModel)).toBe(false);
-    });
-    it('should return false if any rule is missing an ID', () => {
-        const model = createModelWithIds();
-        const modifiedModel = structuredClone(model);
-        const slice = modifiedModel.narratives[0].slices[0];
-        if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
-            slice.server.specs[0].rules[0].id = '';
+    it('should return true for flows that already have IDs', async () => {
+        const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
+        const model = result.toModel();
+        const testFlowWithIds = model.narratives.find((f) => f.name === 'Test Flow with IDs');
+        expect(testFlowWithIds).toBeDefined();
+        if (testFlowWithIds) {
+            const modelWithExistingIds = { ...model, narratives: [testFlowWithIds] };
+            expect(hasAllIds(modelWithExistingIds)).toBe(true);
         }
-        expect(hasAllIds(modifiedModel)).toBe(false);
-    });
-    it('should return true when multiple flows with same sourceFile all have IDs', () => {
-        const model = createMultipleFlowsModel(true, true);
-        expect(hasAllIds(model)).toBe(true);
-    });
-    it('should return false when any flow in multiple flows with same sourceFile is missing ID', () => {
-        const model = createMultipleFlowsModel(false, true);
-        expect(hasAllIds(model)).toBe(false);
     });
-    it('should return false when any slice in multiple flows with same sourceFile is missing ID', () => {
-        const model = createMultipleFlowsModel(true, false);
-        expect(hasAllIds(model)).toBe(false);
-    });
-    it('should return false if any spec is missing an ID', () => {
-        const model = createModelWithFullIds();
-        const modifiedModel = structuredClone(model);
-        const slice = modifiedModel.narratives[0].slices[0];
-        if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
-            slice.server.specs[0].id = '';
-        }
-        expect(hasAllIds(modifiedModel)).toBe(false);
-    });
-    it('should return false if any example is missing an ID', () => {
-        const model = createModelWithFullIds();
-        const modifiedModel = structuredClone(model);
-        const slice = modifiedModel.narratives[0].slices[0];
-        if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
-            slice.server.specs[0].rules[0].examples[0].id = '';
-        }
+    it('should return false if any slice is missing an ID', async () => {
+        const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
+        const model = result.toModel();
+        const modelWithIds = addAutoIds(model);
+        expect(modelWithIds.narratives.length).toBeGreaterThan(0);
+        expect(modelWithIds.narratives[0].slices.length).toBeGreaterThan(0);
+        const modifiedModel = structuredClone(modelWithIds);
+        modifiedModel.narratives[0].slices[0].id = '';
         expect(hasAllIds(modifiedModel)).toBe(false);
     });
-    it('should return false if any step is missing an ID', () => {
-        const model = createModelWithFullIds();
-        const modifiedModel = structuredClone(model);
-        const slice = modifiedModel.narratives[0].slices[0];
-        if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
-            slice.server.specs[0].rules[0].examples[0].steps[0].id = '';
+    it('should return false if any rule is missing an ID', async () => {
+        const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
+        const model = result.toModel();
+        const modelWithIds = addAutoIds(model);
+        let found = false;
+        for (const flow of modelWithIds.narratives) {
+            for (const slice of flow.slices) {
+                if ('server' in slice && slice.server?.specs?.rules !== undefined && slice.server.specs.rules.length > 0) {
+                    const modifiedModel = structuredClone(modelWithIds);
+                    const modifiedFlow = modifiedModel.narratives.find((f) => f.name === flow.name);
+                    const modifiedSlice = modifiedFlow?.slices.find((s) => s.name === slice.name);
+                    if (modifiedSlice && 'server' in modifiedSlice && modifiedSlice.server?.specs?.rules !== undefined) {
+                        modifiedSlice.server.specs.rules[0].id = '';
+                        expect(hasAllIds(modifiedModel)).toBe(false);
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (found)
+                break;
         }
-        expect(hasAllIds(modifiedModel)).toBe(false);
-    });
-    it('should return false if step with error is missing an ID', () => {
-        const model = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow',
-                    id: 'FLOW-001',
-                    slices: [
-                        {
-                            type: 'command',
-                            name: 'Test slice',
-                            id: 'SLICE-001',
-                            client: { specs: [] },
-                            server: {
-                                description: 'Test server',
-                                specs: [
-                                    {
-                                        id: 'SPEC-001',
-                                        type: 'gherkin',
-                                        feature: 'Test specs',
-                                        rules: [
-                                            {
-                                                id: 'RULE-001',
-                                                name: 'Test rule',
-                                                examples: [
-                                                    {
-                                                        id: 'EXAMPLE-001',
-                                                        name: 'Error example',
-                                                        steps: [
-                                                            {
-                                                                id: 'STEP-001',
-                                                                keyword: 'Given',
-                                                                text: 'TestState',
-                                                            },
-                                                            {
-                                                                keyword: 'Then',
-                                                                error: { type: 'ValidationError', message: 'Invalid input' },
-                                                            },
-                                                        ],
-                                                    },
-                                                ],
-                                            },
-                                        ],
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        expect(hasAllIds(model)).toBe(false);
-    });
-    it('should return false if client it spec is missing an ID', () => {
-        const model = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow',
-                    id: 'FLOW-001',
-                    slices: [
-                        {
-                            name: 'Test slice',
-                            id: 'SLICE-001',
-                            type: 'experience',
-                            client: {
-                                specs: [{ type: 'it', title: 'test without id' }],
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        expect(hasAllIds(model)).toBe(false);
-    });
-    it('should return false if client describe spec is missing an ID', () => {
-        const model = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow',
-                    id: 'FLOW-001',
-                    slices: [
-                        {
-                            name: 'Test slice',
-                            id: 'SLICE-001',
-                            type: 'experience',
-                            client: {
-                                specs: [
-                                    {
-                                        type: 'describe',
-                                        title: 'test describe without id',
-                                        children: [{ type: 'it', id: 'IT-001', title: 'nested it with id' }],
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        expect(hasAllIds(model)).toBe(false);
-    });
-    it('should return false if nested client it spec is missing an ID', () => {
-        const model = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow',
-                    id: 'FLOW-001',
-                    slices: [
-                        {
-                            name: 'Test slice',
-                            id: 'SLICE-001',
-                            type: 'experience',
-                            client: {
-                                specs: [
-                                    {
-                                        type: 'describe',
-                                        id: 'DESC-001',
-                                        title: 'test describe with id',
-                                        children: [{ type: 'it', title: 'nested it without id' }],
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        expect(hasAllIds(model)).toBe(false);
-    });
-    it('should return true for client specs with all IDs', () => {
-        const model = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow',
-                    id: 'FLOW-001',
-                    slices: [
-                        {
-                            name: 'Test slice',
-                            id: 'SLICE-001',
-                            type: 'experience',
-                            client: {
-                                specs: [
-                                    {
-                                        type: 'describe',
-                                        id: 'DESC-001',
-                                        title: 'test describe',
-                                        children: [
-                                            { type: 'it', id: 'IT-001', title: 'first it' },
-                                            {
-                                                type: 'describe',
-                                                id: 'DESC-002',
-                                                title: 'nested describe',
-                                                children: [{ type: 'it', id: 'IT-002', title: 'nested it' }],
-                                            },
-                                        ],
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        expect(hasAllIds(model)).toBe(true);
+        expect(found).toBe(true);
+    });
+    it('should return true when multiple flows with same sourceFile all have IDs', async () => {
+        const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
+        const model = result.toModel();
+        const homepageFlows = model.narratives.filter((f) => f.sourceFile !== undefined && f.sourceFile.includes('homepage.narrative.ts'));
+        expect(homepageFlows.length).toBe(3);
+        const homepageModel = { ...model, narratives: homepageFlows };
+        expect(hasAllIds(homepageModel)).toBe(true);
+    });
+    it('should return false when any flow in multiple flows with same sourceFile is missing ID', async () => {
+        const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
+        const model = result.toModel();
+        const homepageFlows = model.narratives.filter((f) => f.sourceFile !== undefined && f.sourceFile.includes('homepage-incomplete.narrative.ts'));
+        expect(homepageFlows.length).toBe(3);
+        const homepageModel = { ...model, narratives: homepageFlows };
+        expect(hasAllIds(homepageModel)).toBe(false);
+    });
+    it('should return false when any slice in multiple flows with same sourceFile is missing ID', async () => {
+        const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
+        const model = result.toModel();
+        const homepageFlows = model.narratives.filter((f) => f.sourceFile !== undefined && f.sourceFile.includes('homepage-slice-missing.narrative.ts'));
+        expect(homepageFlows.length).toBe(3);
+        const homepageModel = { ...model, narratives: homepageFlows };
+        expect(hasAllIds(homepageModel)).toBe(false);
     });
 });
 //# sourceMappingURL=hasAllIds.specs.js.map