@zohodesk/testinglibrary 0.1.9 → 0.1.12-experimental

package/build/test/core/dataGenerator/__tests__/DataGenerator.test.js

@@ -0,0 +1,311 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _DataGenerator = _interopRequireDefault(require("../../../../../src/core/dataGenerator/DataGenerator"));
+var _Authenticator = _interopRequireDefault(require("../../../../../src/core/dataGenerator/authenticator/Authenticator"));
+jest.mock('fs');
+jest.mock('../../../../../src/core/dataGenerator/authenticator/Authenticator');
+const GENERATORS_JSON = {
+  generators: {
+    myGenerator: [{
+      type: 'dynamic',
+      generatorOperationId: 'applicationDriver.rpc.desk.Service.createTicket',
+      name: 'myGenerator',
+      params: {
+        status: 'Open'
+      },
+      dataPath: '$.response.body:$'
+    }]
+  }
+};
+function makeActorInfo(overrides = {}) {
+  return {
+    email: 'test@example.com',
+    password: 'testpass',
+    'data-generator': {
+      account: {
+        storeVariables: {
+          orgId: '12345'
+        },
+        authentications: ['org-oauth'],
+        org_oauth: {
+          clientId: 'cid',
+          clientSecret: 'sec',
+          refreshToken: 'rt'
+        }
+      }
+    },
+    ...overrides
+  };
+}
+describe('DataGenerator.generate() — v2 payload structure', () => {
+  let dataGenerator;
+  let mockRequestPost;
+  let mockPage;
+  let testInfo;
+  beforeEach(() => {
+    dataGenerator = new _DataGenerator.default();
+    mockRequestPost = jest.fn().mockResolvedValue({
+      ok: () => true,
+      status: () => 200,
+      text: async () => '',
+      json: async () => ({
+        data: '12345',
+        logs: []
+      })
+    });
+    mockPage = {
+      request: {
+        post: mockRequestPost
+      }
+    };
+    testInfo = {
+      file: '/project/tests/ticket/my.feature',
+      title: 'suite / My Scenario'
+    };
+    _fs.default.existsSync.mockReturnValue(true);
+    _fs.default.readFileSync.mockReturnValue(JSON.stringify(GENERATORS_JSON));
+
+    // Authenticator passthrough — returns the payload untouched
+    _Authenticator.default.mockImplementation(() => ({
+      constructPayload: jest.fn().mockImplementation(payload => Promise.resolve(payload))
+    }));
+    process.env.DG_SERVICE_DOMAIN = 'https://dg-service.example.com';
+    process.env.DG_SERVICE_API_PATH = '/api/v2/data-generator/generate-data';
+    process.env.domain = 'https://app.example.com/agent';
+    process.env.DG_IAM_DOMAIN = 'https://iam.example.com';
+  });
+  afterEach(() => {
+    delete process.env.DG_SERVICE_DOMAIN;
+    delete process.env.DG_SERVICE_API_PATH;
+    delete process.env.domain;
+    delete process.env.DG_IAM_DOMAIN;
+  });
+  it('should POST to the v2 endpoint URL', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const [url] = mockRequestPost.mock.calls[0];
+    expect(url).toBe('https://dg-service.example.com/api/v2/data-generator/generate-data');
+  });
+  it('should send scenario.name instead of scenario_name', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.scenario).toEqual({
+      name: 'My Scenario'
+    });
+    expect(payload.scenario_name).toBeUndefined();
+  });
+  it('should include mode: "template"', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.mode).toBe('template');
+  });
+  it('should send spec.templates instead of data_generation_templates', async () => {
+    var _payload$spec;
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(Array.isArray((_payload$spec = payload.spec) === null || _payload$spec === void 0 ? void 0 : _payload$spec.templates)).toBe(true);
+    expect(payload.data_generation_templates).toBeUndefined();
+  });
+  it('should send environment instead of environmentDetails', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.environment).toEqual({
+      host: 'https://app.example.com',
+      iam_url: 'https://iam.example.com'
+    });
+    expect(payload.environmentDetails).toBeUndefined();
+  });
+  it('should translate v1 generator fields to v2 inside spec.templates', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const template = mockRequestPost.mock.calls[0][1].data.spec.templates[0];
+    expect(template.type).toBe('dynamic');
+    expect(template.generatorOperationId).toBe('applicationDriver.rpc.desk.Service.createTicket');
+    expect(template.inputs).toEqual({
+      status: 'Open'
+    });
+    expect(template.params).toBeUndefined();
+    expect(template.dataPath).toBe('$.response.body:$');
+  });
+  it('should include account with email and password from actorInfo', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.account.email).toBe('test@example.com');
+    expect(payload.account.password).toBe('testpass');
+    expect(payload.account.storeVariables).toEqual({
+      orgId: '12345'
+    });
+    expect(payload.account.authentications).toEqual(['org-oauth']);
+  });
+  it('should return the full response from the DG service', async () => {
+    const result = await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    expect(result).toEqual({
+      data: '12345',
+      logs: []
+    });
+  });
+  it('should merge datatable values into template inputs after v1→v2 translation', async () => {
+    const dataTable = [{
+      DG_API_NAME: 'myGenerator',
+      subject: 'Test Ticket',
+      priority: 'High'
+    }];
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', dataTable, mockPage);
+    const template = mockRequestPost.mock.calls[0][1].data.spec.templates[0];
+    expect(template.inputs.subject).toBe('Test Ticket');
+    expect(template.inputs.priority).toBe('High');
+    expect(template.inputs.status).toBe('Open');
+  });
+  it('should build v2 payload for API type generator', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'API', 'applicationDriver.rpc.desk.Service.getTicket', 'My Scenario', [], mockPage);
+    const template = mockRequestPost.mock.calls[0][1].data.spec.templates[0];
+    expect(template.type).toBe('dynamic');
+    expect(template.generatorOperationId).toBe('applicationDriver.rpc.desk.Service.getTicket');
+    expect(template.dataPath).toBe('$.response.body:$');
+  });
+  it('should throw DataGeneratorConfigurationError when data-generator config is absent', async () => {
+    const actorWithoutConfig = {
+      email: 'test@example.com',
+      profile: 'admin'
+    };
+    await expect(dataGenerator.generate(testInfo, actorWithoutConfig, 'template', 'myGenerator', 'My Scenario', [], mockPage)).rejects.toThrow('Data Generator configuration is missing');
+  });
+  it('should throw DataGeneratorConfigurationError when account is absent from data-generator config', async () => {
+    const actorWithoutAccount = {
+      email: 'test@example.com',
+      profile: 'admin',
+      'data-generator': {}
+    };
+    await expect(dataGenerator.generate(testInfo, actorWithoutAccount, 'template', 'myGenerator', 'My Scenario', [], mockPage)).rejects.toThrow('Missing "account"');
+  });
+  it('should throw when page is null and the HTTP request cannot be made', async () => {
+    await expect(dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], null)).rejects.toThrow();
+  });
+  it('should throw GeneratorError when the generator name is not found in generators.json', async () => {
+    await expect(dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'unknownGenerator', 'My Scenario', [], mockPage)).rejects.toThrow('Generator "unknownGenerator" could not be found');
+  });
+  it('should use portalDomain when any generatorOperationId starts with "portal."', async () => {
+    _fs.default.readFileSync.mockReturnValue(JSON.stringify({
+      generators: {
+        portalGen: [{
+          type: 'dynamic',
+          generatorOperationId: 'portal.rpc.Service.create',
+          name: 'portalGen'
+        }]
+      }
+    }));
+    process.env.portalDomain = 'https://portal.example.com/portal';
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'portalGen', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.environment.host).toBe('https://portal.example.com');
+    delete process.env.portalDomain;
+  });
+  it('should fall back to domain when operationId starts with "portal." but portalDomain is not set', async () => {
+    _fs.default.readFileSync.mockReturnValue(JSON.stringify({
+      generators: {
+        portalGen: [{
+          type: 'dynamic',
+          generatorOperationId: 'portal.rpc.Service.create',
+          name: 'portalGen'
+        }]
+      }
+    }));
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'portalGen', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.environment.host).toBe('https://app.example.com');
+  });
+});
+describe('DataGenerator.generate() — v1 payload structure (DG_SERVICE_API_PATH contains /v1/)', () => {
+  let dataGenerator;
+  let mockRequestPost;
+  let mockPage;
+  let testInfo;
+  beforeEach(() => {
+    dataGenerator = new _DataGenerator.default();
+    mockRequestPost = jest.fn().mockResolvedValue({
+      ok: () => true,
+      status: () => 200,
+      text: async () => '',
+      json: async () => ({
+        data: '12345',
+        logs: []
+      })
+    });
+    mockPage = {
+      request: {
+        post: mockRequestPost
+      }
+    };
+    testInfo = {
+      file: '/project/tests/ticket/my.feature',
+      title: 'suite / My Scenario'
+    };
+    _fs.default.existsSync.mockReturnValue(true);
+    _fs.default.readFileSync.mockReturnValue(JSON.stringify(GENERATORS_JSON));
+    _Authenticator.default.mockImplementation(() => ({
+      constructPayload: jest.fn().mockImplementation(payload => Promise.resolve(payload))
+    }));
+    process.env.DG_SERVICE_DOMAIN = 'https://dg-service.example.com';
+    process.env.DG_SERVICE_API_PATH = '/api/v1/data-generator/generate-data';
+    process.env.domain = 'https://app.example.com/agent';
+    process.env.DG_IAM_DOMAIN = 'https://iam.example.com';
+  });
+  afterEach(() => {
+    delete process.env.DG_SERVICE_DOMAIN;
+    delete process.env.DG_SERVICE_API_PATH;
+    delete process.env.domain;
+    delete process.env.DG_IAM_DOMAIN;
+  });
+  it('should use scenario_name instead of scenario object', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.scenario_name).toBe('My Scenario');
+    expect(payload.scenario).toBeUndefined();
+  });
+  it('should use data_generation_templates instead of spec.templates', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(Array.isArray(payload.data_generation_templates)).toBe(true);
+    expect(payload.spec).toBeUndefined();
+    expect(payload.mode).toBeUndefined();
+  });
+  it('should use environmentDetails instead of environment', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.environmentDetails).toEqual({
+      host: 'https://app.example.com',
+      iam_url: 'https://iam.example.com'
+    });
+    expect(payload.environment).toBeUndefined();
+  });
+  it('should NOT translate params to inputs in templates', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const template = mockRequestPost.mock.calls[0][1].data.data_generation_templates[0];
+    expect(template.params).toEqual({
+      status: 'Open'
+    });
+    expect(template.inputs).toBeUndefined();
+  });
+  it('should include account with email and password from actorInfo', async () => {
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'myGenerator', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.account.email).toBe('test@example.com');
+    expect(payload.account.password).toBe('testpass');
+  });
+  it('should use portalDomain in environmentDetails when operationId starts with "portal."', async () => {
+    _fs.default.readFileSync.mockReturnValue(JSON.stringify({
+      generators: {
+        portalGen: [{
+          type: 'dynamic',
+          generatorOperationId: 'portal.rpc.Service.create',
+          name: 'portalGen'
+        }]
+      }
+    }));
+    process.env.portalDomain = 'https://portal.example.com/portal';
+    await dataGenerator.generate(testInfo, makeActorInfo(), 'template', 'portalGen', 'My Scenario', [], mockPage);
+    const payload = mockRequestPost.mock.calls[0][1].data;
+    expect(payload.environmentDetails.host).toBe('https://portal.example.com');
+    delete process.env.portalDomain;
+  });
+});

package/build/test/core/dataGenerator/__tests__/DataGeneratorHelper.test.js

@@ -0,0 +1,204 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _path = _interopRequireDefault(require("path"));
+var _DataGeneratorHelper = require("../../../../../src/core/dataGenerator/DataGeneratorHelper");
+const moduleDir = _path.default.join('/repo', 'test-slices', 'uat', 'modules', 'data-generator');
+const specFor = (generatedDir, fileName) => _path.default.join('/repo', 'test-slices', 'uat', generatedDir, 'modules', 'data-generator', 'feature-files', fileName);
+describe('translateGeneratorsToV2', () => {
+  it('should preserve type "dynamic" unchanged', () => {
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)([{
+      type: 'dynamic',
+      generatorOperationId: 'some.method',
+      name: 'gen1'
+    }]);
+    expect(result[0].type).toBe('dynamic');
+  });
+  it('should preserve type "remote" unchanged', () => {
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)([{
+      type: 'remote',
+      generatorMethod: 'some.method',
+      inputs: {
+        a: '1'
+      }
+    }]);
+    expect(result[0].type).toBe('remote');
+  });
+  it('should preserve generatorOperationId unchanged', () => {
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)([{
+      type: 'dynamic',
+      generatorOperationId: 'desk.Service.create',
+      name: 'gen1'
+    }]);
+    expect(result[0].generatorOperationId).toBe('desk.Service.create');
+  });
+  it('should rename params to inputs', () => {
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)([{
+      type: 'dynamic',
+      generatorOperationId: 'method',
+      params: {
+        key: 'value'
+      }
+    }]);
+    expect(result[0].inputs).toEqual({
+      key: 'value'
+    });
+    expect(result[0].params).toBeUndefined();
+  });
+  it('should not overwrite existing inputs when params is also present', () => {
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)([{
+      type: 'dynamic',
+      generatorOperationId: 'method',
+      params: {
+        a: '1'
+      },
+      inputs: {
+        b: '2'
+      }
+    }]);
+    expect(result[0].inputs).toEqual({
+      b: '2'
+    });
+  });
+  it('should preserve dataPath unchanged', () => {
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)([{
+      type: 'dynamic',
+      generatorOperationId: 'method',
+      dataPath: '$.response.body:$'
+    }]);
+    expect(result[0].dataPath).toBe('$.response.body:$');
+  });
+  it('should preserve name and other custom fields', () => {
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)([{
+      type: 'dynamic',
+      generatorOperationId: 'method',
+      name: 'myGen',
+      customField: 'abc'
+    }]);
+    expect(result[0].name).toBe('myGen');
+    expect(result[0].customField).toBe('abc');
+  });
+  it('should translate multiple generators independently without changing type or operationId', () => {
+    const generators = [{
+      type: 'dynamic',
+      generatorOperationId: 'method.one',
+      params: {
+        x: '1'
+      },
+      name: 'gen1'
+    }, {
+      type: 'remote',
+      generatorMethod: 'method.two',
+      inputs: {
+        y: '2'
+      },
+      name: 'gen2'
+    }];
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)(generators);
+    expect(result[0]).toMatchObject({
+      type: 'dynamic',
+      generatorOperationId: 'method.one',
+      inputs: {
+        x: '1'
+      },
+      name: 'gen1'
+    });
+    expect(result[1]).toMatchObject({
+      type: 'remote',
+      generatorMethod: 'method.two',
+      inputs: {
+        y: '2'
+      },
+      name: 'gen2'
+    });
+  });
+  it('should handle generators with no v1 fields as a passthrough', () => {
+    const generator = {
+      type: 'remote',
+      generatorMethod: 'some.method',
+      name: 'noop'
+    };
+    const result = (0, _DataGeneratorHelper.translateGeneratorsToV2)([generator]);
+    expect(result[0]).toEqual({
+      type: 'remote',
+      generatorMethod: 'some.method',
+      name: 'noop'
+    });
+  });
+});
+describe('processGenerator', () => {
+  it('should return generators unchanged when no dataTable is provided', async () => {
+    const generators = [{
+      type: 'dynamic',
+      name: 'gen1'
+    }];
+    const result = await (0, _DataGeneratorHelper.processGenerator)(generators, null);
+    expect(result).toEqual(generators);
+  });
+  it('should merge matching datatable row values into generator params', async () => {
+    const generators = [{
+      type: 'dynamic',
+      name: 'gen1'
+    }];
+    const dataTable = [{
+      DG_API_NAME: 'gen1',
+      subject: 'My Ticket',
+      status: 'Open'
+    }];
+    const result = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
+    expect(result[0].params).toEqual({
+      subject: 'My Ticket',
+      status: 'Open'
+    });
+  });
+  it('should not merge rows whose DG_API_NAME does not match the generator name', async () => {
+    const generators = [{
+      type: 'dynamic',
+      name: 'gen1'
+    }];
+    const dataTable = [{
+      DG_API_NAME: 'gen2',
+      subject: 'My Ticket'
+    }];
+    const result = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
+    expect(result[0].params).toBeUndefined();
+  });
+  it('should skip empty string values from the datatable', async () => {
+    const generators = [{
+      type: 'dynamic',
+      name: 'gen1'
+    }];
+    const dataTable = [{
+      DG_API_NAME: 'gen1',
+      subject: '',
+      priority: 'High'
+    }];
+    const result = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
+    expect(result[0].params.subject).toBeUndefined();
+    expect(result[0].params.priority).toBe('High');
+  });
+});
+describe('getFeatureNameFromSpec', () => {
+  it('strips the generated spec suffix', () => {
+    expect((0, _DataGeneratorHelper.getFeatureNameFromSpec)(specFor('.features-gen', 'GetDepartment.feature.spec.js'))).toBe('GetDepartment');
+  });
+  it('keeps dots that belong to the feature name', () => {
+    expect((0, _DataGeneratorHelper.getFeatureNameFromSpec)(specFor('.features-gen', 'Get.Department.feature.spec.js'))).toBe('Get.Department');
+  });
+});
+describe('getGeneratorFilePath', () => {
+  it('strips the playwright-bdd output folder', async () => {
+    await expect((0, _DataGeneratorHelper.getGeneratorFilePath)(specFor('.features-gen', 'GetDepartment.feature.spec.js'))).resolves.toBe(_path.default.join(moduleDir, 'feature-files', 'GetDepartment.feature.spec.js'));
+  });
+  it('leaves a path without a generated folder untouched', async () => {
+    const plainPath = _path.default.join(moduleDir, 'feature-files', 'GetDepartment.feature.spec.js');
+    await expect((0, _DataGeneratorHelper.getGeneratorFilePath)(plainPath)).resolves.toBe(plainPath);
+  });
+});
+describe('getGeneratorFilePaths', () => {
+  const generatorDir = _path.default.join(moduleDir, 'data-generators');
+  it('returns the per-feature file before the legacy shared file', async () => {
+    const candidates = await (0, _DataGeneratorHelper.getGeneratorFilePaths)(specFor('.features-gen', 'GetDepartment.feature.spec.js'));
+    expect(candidates).toEqual([_path.default.join(generatorDir, 'GetDepartment.generators.json'), _path.default.join(generatorDir, 'generators.json')]);
+  });
+});

package/build/test/core/dataGenerator/__tests__/DataGeneratorResolution.test.js

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _DataGenerator = _interopRequireDefault(require("../../../../../src/core/dataGenerator/DataGenerator"));
+var _DataGeneratorHelper = require("../../../../../src/core/dataGenerator/DataGeneratorHelper");
+var _DataGeneratorError = require("../../../../../src/core/dataGenerator/DataGeneratorError");
+// The framework resolves its own package name at runtime inside a consumer slice, so it is not
+// installed here. Only the helper used by DataGenerator is needed for generator resolution.
+jest.mock('@zohodesk/testinglibrary/helpers', () => ({
+  getUserForSelectedEditionAndProfile: jest.fn()
+}), {
+  virtual: true
+});
+
+// Real path resolution is what these tests exercise; only the outbound call is stubbed, so
+// generate() runs to completion and the resolved generator is observable in the request payload.
+jest.mock('../../../../../src/core/dataGenerator/DataGeneratorHelper', () => ({
+  ...jest.requireActual('../../../../../src/core/dataGenerator/DataGeneratorHelper'),
+  makeRequest: jest.fn()
+}));
+const moduleDir = _path.default.join('/repo', 'test-slices', 'uat', 'modules', 'data-generator');
+const generatorDir = _path.default.join(moduleDir, 'data-generators');
+const perFeatureFile = _path.default.join(generatorDir, 'GetDepartment.generators.json');
+const legacyFile = _path.default.join(generatorDir, 'generators.json');
+const testInfo = {
+  file: _path.default.join('/repo', 'test-slices', 'uat', '.features-gen', 'modules', 'data-generator', 'feature-files', 'GetDepartment.feature.spec.js')
+};
+const actorInfo = {
+  email: 'user@example.com',
+  password: 'secret',
+  'data-generator': {
+    account: {}
+  }
+};
+
+// The generator name is identical in both files; only `name` marks which file it came from.
+const generatorEntry = source => [{
+  type: 'dynamic',
+  name: `CreateAccount_${source}`,
+  generatorOperationId: 'support.Account.createAccount',
+  dataPath: '$.response.body:$'
+}];
+const fileWithGenerator = (generatorName, source) => JSON.stringify({
+  generators: {
+    [generatorName]: generatorEntry(source)
+  }
+});
+
+// Backs fs with an in-memory file map keyed by absolute path.
+const mockFiles = files => {
+  jest.spyOn(_fs.default, 'existsSync').mockImplementation(filePath => filePath in files);
+  jest.spyOn(_fs.default, 'readFileSync').mockImplementation(filePath => {
+    if (!(filePath in files)) {
+      throw new Error(`ENOENT: ${filePath}`);
+    }
+    return files[filePath];
+  });
+};
+const generate = () => new _DataGenerator.default().generate(testInfo, actorInfo, 'GENERATOR', 'CreateAccountRecord', 'scenario', null, null);
+
+// The templates sent to the data-generator service are the generators that resolution selected.
+const resolvedGeneratorNames = () => {
+  expect(_DataGeneratorHelper.makeRequest).toHaveBeenCalledTimes(1);
+  const [, apiPayload] = _DataGeneratorHelper.makeRequest.mock.calls[0];
+  return apiPayload.data_generation_templates.map(template => template.name);
+};
+describe('DataGenerator generator file resolution', () => {
+  beforeEach(() => {
+    process.env.domain = 'https://desk.example.com';
+    process.env.DG_SERVICE_API_PATH = '/api/v1/data-generator/generate-data';
+    _DataGeneratorHelper.makeRequest.mockResolvedValue({
+      data: {}
+    });
+    // Failed lookups are the expected outcome in some cases here; keep their output off the report.
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+  afterEach(() => {
+    delete process.env.domain;
+    delete process.env.DG_SERVICE_API_PATH;
+    jest.restoreAllMocks();
+  });
+  it('uses the generator from the per-feature file over the legacy shared file', async () => {
+    mockFiles({
+      [perFeatureFile]: fileWithGenerator('CreateAccountRecord', 'perFeature'),
+      [legacyFile]: fileWithGenerator('CreateAccountRecord', 'legacy')
+    });
+    await generate();
+    expect(resolvedGeneratorNames()).toEqual(['CreateAccount_perFeature']);
+    expect(_fs.default.readFileSync).not.toHaveBeenCalledWith(legacyFile, 'utf8');
+  });
+  it('uses the legacy shared file when the per-feature file is absent', async () => {
+    mockFiles({
+      [legacyFile]: fileWithGenerator('CreateAccountRecord', 'legacy')
+    });
+    await generate();
+    expect(resolvedGeneratorNames()).toEqual(['CreateAccount_legacy']);
+  });
+  it('falls back to the legacy file when the per-feature file lacks the requested generator', async () => {
+    mockFiles({
+      [perFeatureFile]: fileWithGenerator('SomeOtherGenerator', 'perFeature'),
+      [legacyFile]: fileWithGenerator('CreateAccountRecord', 'legacy')
+    });
+    await generate();
+    expect(resolvedGeneratorNames()).toEqual(['CreateAccount_legacy']);
+  });
+  it('throws a GeneratorError listing every path tried when no file has the generator', async () => {
+    mockFiles({});
+    await expect(generate()).rejects.toThrow(_DataGeneratorError.GeneratorError);
+    await expect(generate()).rejects.toThrow(perFeatureFile);
+    await expect(generate()).rejects.toThrow(legacyFile);
+    expect(_DataGeneratorHelper.makeRequest).not.toHaveBeenCalled();
+  });
+
+  // Regression: a generator file missing the top-level "generators" key used to raise a
+  // TypeError instead of the framework's own GeneratorError.
+  it('throws a GeneratorError when a generator file has no generators key', async () => {
+    mockFiles({
+      [perFeatureFile]: JSON.stringify({})
+    });
+    await expect(generate()).rejects.toThrow(_DataGeneratorError.GeneratorError);
+    expect(_DataGeneratorHelper.makeRequest).not.toHaveBeenCalled();
+  });
+});