@auto-engineer/narrative 0.13.0 → 0.13.2

package/src/id/hasAllIds.specs.ts

@@ -1,267 +1,444 @@
-import { describe, expect, it, beforeEach } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { hasAllIds, addAutoIds } from './index';
-import { getNarratives } from '../getNarratives';
-import { InMemoryFileStore, type IFileStore } from '@auto-engineer/file-store';
-import * as flowApi from '../narrative';
-import * as fluent from '../fluent-builder';
-import * as dataBuilders from '../data-narrative-builders';
-import * as typesApi from '../types';
-import gql from 'graphql-tag';
-
-const importMap = {
-  '../flow': flowApi,
-  '../fluent-builder': fluent,
-  '../data-flow-builders': dataBuilders,
-  '../types': typesApi,
-  'graphql-tag': gql,
-};
+import type { Model } from '../index';
 
 describe('hasAllIds', () => {
-  let vfs: IFileStore;
-  const root = '/test';
-
-  beforeEach(async () => {
-    vfs = new InMemoryFileStore();
-
-    const flowWithoutIds = `
-import { flow, specs, rule, example } from '../narrative';
-import { command } from '../fluent-builder';
-
-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';
-import { command } from '../fluent-builder';
-
-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';
-import { experience } from '../fluent-builder';
-
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
+  const createModelWithoutIds = (): Model => ({
+    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('Create Survey', 'MPviTMrQC', () => {
-  experience('Create Survey Form', 'slice2').client(() => {
-    specs(() => {
-      it('allow entering survey title');
-    });
+  const createModelWithIds = (): Model => ({
+    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 createModelWithFullIds = (): Model => ({
+    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: [],
   });
-});`;
-
-    const multipleFlowsIncomplete = `
-import { flow, specs, it } from '../narrative';
-import { experience } from '../fluent-builder';
 
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
+  const createMultipleFlowsModel = (includeAllIds: boolean, includeAllSliceIds: boolean): Model => ({
+    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('Create Survey', () => {
-  experience('Create Survey Form', 'slice2').client(() => {
-    specs(() => {
-      it('allow entering survey title');
-    });
+  it('should return false for models without IDs', () => {
+    const model = createModelWithoutIds();
+    expect(hasAllIds(model)).toBe(false);
   });
-});
 
-flow('Response Analytics', 'eME978Euk', () => {
-  experience('Response Rate Charts', 'slice3').client(() => {
-    specs(() => {
-      it('show daily response rate charts');
-    });
+  it('should return true for models with complete IDs', () => {
+    const model = createModelWithoutIds();
+    const modelWithIds = addAutoIds(model);
+    expect(hasAllIds(modelWithIds)).toBe(true);
   });
-});`;
 
-    const multipleFlowsSliceMissing = `
-import { flow, specs, it } from '../narrative';
-import { experience } from '../fluent-builder';
-
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
+  it('should return true for flows that already have IDs', () => {
+    const model = createModelWithIds();
+    expect(hasAllIds(model)).toBe(true);
   });
-});
 
-flow('Create Survey', 'MPviTMrQC', () => {
-  experience('Create Survey Form').client(() => {
-    specs(() => {
-      it('allow entering survey title');
-    });
+  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);
   });
-});
 
-flow('Response Analytics', 'eME978Euk', () => {
-  experience('Response Rate Charts', 'slice3').client(() => {
-    specs(() => {
-      it('show daily response rate charts');
-    });
+  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(hasAllIds(modifiedModel)).toBe(false);
   });
-});`;
 
-    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 true when multiple flows with same sourceFile all have IDs', () => {
+    const model = createMultipleFlowsModel(true, true);
+    expect(hasAllIds(model)).toBe(true);
   });
-  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 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 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 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 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 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 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 = '';
+  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 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 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(found).toBe(true);
+    expect(hasAllIds(modifiedModel)).toBe(false);
   });
 
-  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 if step with error is missing an ID', () => {
+    const model: 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 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 if client it spec is missing an ID', () => {
+    const model: 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 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();
+  it('should return false if client describe spec is missing an ID', () => {
+    const model: 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);
+  });
 
-    const homepageFlows = model.narratives.filter(
-      (f) => f.sourceFile !== undefined && f.sourceFile.includes('homepage-slice-missing.narrative.ts'),
-    );
-    expect(homepageFlows.length).toBe(3);
+  it('should return false if nested client it spec is missing an ID', () => {
+    const model: 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);
+  });
 
-    const homepageModel = { ...model, narratives: homepageFlows };
-    expect(hasAllIds(homepageModel)).toBe(false);
+  it('should return true for client specs with all IDs', () => {
+    const model: 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);
   });
 });