@auto-engineer/narrative 0.13.0 → 0.13.2

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

@@ -1,231 +1,424 @@
-import { describe, expect, it, beforeEach } from 'vitest';
+import { describe, expect, it } 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', () => {
-    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, it } from '../narrative.js';
-import { experience } from '../fluent-builder.js';
-
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
-  });
-});
-
-flow('Create Survey', 'MPviTMrQC', () => {
-  experience('Create Survey Form', 'slice2').client(() => {
-    specs(() => {
-      it('allow entering survey title');
+    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: [],
     });
-  });
-});
-
-flow('Response Analytics', 'eME978Euk', () => {
-  experience('Response Rate Charts', 'slice3').client(() => {
-    specs(() => {
-      it('show daily response rate charts');
-    });
-  });
-});`;
-        const multipleFlowsIncomplete = `
-import { flow, specs, it } from '../narrative.js';
-import { experience } from '../fluent-builder.js';
-
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
-  });
-});
-
-flow('Create Survey', () => {
-  experience('Create Survey Form', 'slice2').client(() => {
-    specs(() => {
-      it('allow entering survey title');
+    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: [],
     });
-  });
-});
-
-flow('Response Analytics', 'eME978Euk', () => {
-  experience('Response Rate Charts', 'slice3').client(() => {
-    specs(() => {
-      it('show daily response rate charts');
-    });
-  });
-});`;
-        const multipleFlowsSliceMissing = `
-import { flow, specs, it } from '../narrative.js';
-import { experience } from '../fluent-builder.js';
-
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
-  });
-});
-
-flow('Create Survey', 'MPviTMrQC', () => {
-  experience('Create Survey Form').client(() => {
-    specs(() => {
-      it('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', 'eME978Euk', () => {
-  experience('Response Rate Charts', 'slice3').client(() => {
-    specs(() => {
-      it('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);
-        }
+    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: [],
+    });
+    it('should return false for models without IDs', () => {
+        const model = createModelWithoutIds();
+        expect(hasAllIds(model)).toBe(false);
     });
-    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();
+    it('should return true for models with complete IDs', () => {
+        const model = createModelWithoutIds();
         const modelWithIds = addAutoIds(model);
         expect(hasAllIds(modelWithIds)).toBe(true);
     });
-    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);
-        }
+    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', 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);
+    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', 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;
+    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 = '';
         }
-        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);
+        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 = '';
+        }
+        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 = '';
+        }
+        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);
     });
 });
 //# sourceMappingURL=hasAllIds.specs.js.map