@izara_project/izara-core-generate-service-code 1.0.64 → 1.0.66

package/test/relationshipApplicationArtifacts.test.js

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test, { after } from 'node:test';
+
+import { generateRelationshipApplicationArtifacts } from '../src/emit/relationship/generateRelationshipApplicationArtifacts.js';
+
+const roots = new Set();
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('emits relationship action and complete handlers with data-first function YAML', async () => {
+  const rootPath = await createProject(true);
+  const result = await generateRelationshipApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  assert.equal(result.files.length, 40);
+  assert.ok(result.files.every(file => !file.path.includes('/Process')));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/GetRelationship/source/GetRelationship_HdrDsq.js'), 'utf8'),
+    /import GetRelationship/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/CreateRelationshipComplete_HdrSqs.js'), 'utf8'),
+    /import CreateRelationshipComplete/
+  );
+  const yaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-relationships.yml'), 'utf8');
+  assert.match(yaml, /GetRelHdrApi:/);
+  assert.doesNotMatch(yaml, /handler: .*\/Process/);
+  assert.match(yaml, /CreateRelHdrSqs:[\s\S]*?iz_resourcePrefix}CreateRelationshipHdrSqs\n/);
+  assert.doesNotMatch(yaml, /Process(?:Create|Update|Delete|Get|Change|Move)Relationship/);
+  assert.match(yaml, /path: \/orders\/orderCustomer\/get/);
+  assert.match(yaml, /CreateRelationshipHdrWbs:[\s\S]*websocket:/);
+  assert.ok(yaml.indexOf('CreateRelationshipHdrWbs:') < yaml.indexOf('CreateRelHdrSqs:'));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/CreateRelationship_HdrWbs.js'), 'utf8'),
+    /import CreateRelationship from '\.\/CreateRelationship_WbsMain\.js'/
+  );
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/ProcessCreateRelationship_Main.js')));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/CreateRelationship_Main.js'), 'utf8'),
+    /export default async function createRelationship/
+  );
+  assert.match(yaml, /CreateRelationshipCompleteHdrSqs:/);
+});
+
+test('removes managed relationship artifacts after relationships are removed', async () => {
+  const rootPath = await createProject(true);
+  await generateRelationshipApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+  await rm(join(rootPath, 'app/src/schemas/RelationshipSchemas/OrderCustomer.js'));
+
+  assert.deepEqual((await generateRelationshipApplicationArtifacts(rootPath)).files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/CreateRelationship_Main.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-relationships.yml')));
+});
+
+async function createProject(withRelationship) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-relationship-application-'));
+  roots.add(rootPath);
+  const relationshipDirectory = join(rootPath, 'app/src/schemas/RelationshipSchemas');
+  await mkdir(relationshipDirectory, { recursive: true });
+  if (withRelationship) {
+    await writeFile(
+      join(relationshipDirectory, 'OrderCustomer.js'),
+      "export default { relationshipTag: 'orderCustomer', links: [] };\n"
+    );
+  }
+  return rootPath;
+}

package/test/resourceArtifacts.test.js

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test, { after } from 'node:test';
+
+import { generateResourceArtifacts } from '../src/emit/resource/generateResourceArtifacts.js';
+
+const roots = new Set();
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('emits queues, topics, tables, and IAM roles from schema data', async () => {
+  const rootPath = await createProject();
+  const result = await generateResourceArtifacts(rootPath);
+
+  assert.equal(result.files.length, 4);
+  const resources = await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8');
+  assert.match(resources, /InCreate:/);
+  for (const queueName of ['FindDataHdrSqs', 'ProcessLogicalHdrSqs', 'PaginateProcessLogicalHdrDsq', 'PaginateProcessLogicalHdrSqs']) {
+    assert.match(resources, new RegExp(`^  ${queueName}:`, 'm'));
+  }
+  assert.match(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-dynamoDB-table.yml'), 'utf8'),
+    /OrdersTable:/
+  );
+  const iam = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8');
+  assert.match(iam, /FlowObjectsRole:/);
+  assert.match(iam, /FlowRelationshipRole:/);
+  assert.match(iam, /FlowRbacRole:/);
+  assert.match(iam, /sqs:ReceiveMessage/);
+  assert.match(iam, /sns:Publish/);
+  assert.doesNotMatch(roleBlock(iam, 'WebSocketMainRole'), /Orders|RolePermissions|CreateHdrSqs/);
+  assert.match(roleBlock(iam, 'WebSocketMainRole'), /UserUploadRecords|WebSocketTask|WebSocketCompleteHdrSqs/);
+  assert.doesNotMatch(roleBlock(iam, 'FlowRbacRole'), /Orders|ProcessCreateRelationshipHdrSqs/);
+  assert.match(roleBlock(iam, 'FlowRbacRole'), /RolePermissions|ProcessCreateTargetRoleHdrSqs/);
+  assert.match(resources, /^  CreateRelationshipHdrSqs:/m);
+  assert.equal((resources.match(/^  CreateRelationshipHdrSqs:/gm) ?? []).length, 1);
+  assert.match(resources, /^  CreateRelationshipCompleteHdrSqs:/m);
+  assert.match(resources, /^  GetRelationshipHdrDsq:/m);
+  assert.doesNotMatch(resources, /Process(?:Create|Update|Delete|Get|Change|Move)Relationship/);
+  const relationshipRole = roleBlock(iam, 'FlowRelationshipRole');
+  assert.match(relationshipRole, /CreateRelationshipHdrSqs/);
+  assert.match(relationshipRole, /CreateRelationshipCompleteHdrSqs/);
+  assert.match(relationshipRole, /GetRelationshipHdrDsq/);
+  assert.doesNotMatch(relationshipRole, /Process(?:Create|Update|Delete|Get|Change|Move)Relationship/);
+  assert.match(roleBlock(iam, 'RegisterRole'), /s3:GetObject/);
+  assert.doesNotMatch(roleBlock(iam, 'RegisterRole'), /dynamodb:|sqs:|sns:/);
+  assert.doesNotMatch(iam, /s3:GetObjectVersion|s3:ListBucket|sqs:DeleteMessageBatch|sqs:GetQueueUrl/);
+  assert.match(iam, /#<#\/\w+StatementHookCode#>\n\n  \w+Role:/);
+  for (const filePath of [
+    'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml',
+    'resource/sls_yaml/generatedCode/source/generated-sns-out.yml',
+    'resource/sls_yaml/generatedCode/source/generated-dynamoDB-table.yml',
+    'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+  ]) {
+    assert.doesNotMatch(await readFile(join(rootPath, filePath), 'utf8'), /\n\n$/);
+  }
+});
+
+test('emits one before-logical queue for flows that share an action', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'BeforeLogical.js'),
+    "export default [{ flowTag: 'first', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical' } }, { flowTag: 'second', event: ['extTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical' } }];\n"
+  );
+
+  await generateResourceArtifacts(rootPath);
+
+  const resources = await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8');
+  assert.equal((resources.match(/^  CreateBeforeLogicalHdrSqs:/gm) ?? []).length, 1);
+  assert.match(resources, /SubscriptionOutFirstToCreateBeforeLogical:/);
+  assert.match(resources, /SubscriptionOutSecondToCreateBeforeLogical:/);
+});
+
+test('emits the shared WebSocket completion queue and output-topic subscriptions', async () => {
+  const rootPath = await createProject();
+  await generateResourceArtifacts(rootPath);
+
+  const resources = await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8');
+  assert.match(resources, /^  WebSocketCompleteHdrSqs:/m);
+  assert.match(resources, /SubscriptionToOutCustomWebSocketComplete:/);
+  const iam = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8');
+  for (const roleName of ['WebSocketMainRole', 'FlowObjectsRole', 'FlowRelationshipRole', 'FlowRbacRole', 'CustomRole', 'UploadRole']) {
+    const role = roleBlock(iam, roleName);
+    assert.match(role, /execute-api:ManageConnections/);
+    assert.match(role, /arn:aws:execute-api:\$\{self:custom\.iz_region\}:\$\{self:custom\.iz_accountId\}:\$\{self:custom\.iz_webSocketHostId\}\/\*/);
+  }
+  assert.match(resources, /SubscriptionToOutCreateRelationshipWebSocketComplete:/);
+});
+
+test('scopes stored-cache permissions to the flow object table', async () => {
+  const rootPath = await createProject();
+  await writeFile(join(rootPath, 'app/src/schemas/ObjectSchemas/Cache.js'), "export default { objectType: 'cache', storageResources: { main: { storageType: 'dynamoDB', tableName: 'CurrentData' } } };\n");
+  await writeFile(join(rootPath, 'app/src/schemas/FlowSchemas/Cache.js'), "export default { flowTag: 'cacheFlow', event: ['lambdaSyncApi'], statusType: 'storedCache', objType: { objectType: 'cache' } };\n");
+
+  await generateResourceArtifacts(rootPath);
+
+  const iam = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8');
+  const role = roleBlock(iam, 'CacheFlowRole');
+  assert.match(role, /CurrentData/);
+  assert.doesNotMatch(role, /Orders|WebSocketTask/);
+});
+
+function roleBlock(iam, roleName) {
+  const match = iam.match(new RegExp(`^  ${roleName}:\\n(?:(?!^  [A-Za-z][A-Za-z0-9]*Role:\\n)[\\s\\S])*`, 'm'));
+  assert.ok(match, `Missing ${roleName} in generated IAM`);
+  return match[0];
+}
+
+async function createProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-resource-'));
+  roots.add(rootPath);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await Promise.all(['ObjectSchemas', 'RelationshipSchemas', 'FlowSchemas'].map(directory => mkdir(join(schemas, directory), { recursive: true })));
+  await writeFile(join(schemas, 'ObjectSchemas/Order.js'), "export default { objectType: 'order', generatedBy: 'userGenerated', addOnDataStructure: [{ type: 'rbac' }], identifiers: [{ type: 'partitionKey', fieldName: 'orderId' }], storageResources: { main: { storageType: 'dynamoDB', tableName: 'Orders' } } };\n");
+  await writeFile(join(schemas, 'RelationshipSchemas/OrderCustomer.js'), "export default { relationshipTag: 'orderCustomer', links: [] };\n");
+  await writeFile(join(schemas, 'FlowSchemas/Custom.js'), "export default { flowTag: 'custom', event: ['ownTopic'], outputTopic: true };\n");
+  await writeFile(join(schemas, 'FlowSchemas/Upload.js'), "export default { flowTag: 'upload', event: ['s3'] };\n");
+  return rootPath;
+}

package/jsconfig.json

@@ -1,9 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": "src",
-    "paths": {
-      "#libs/*": ["libs/*"]
-    }
-  },
-  "include": ["src"]
-}

package/src/__tests__/getIntTestConfig.test.js

@@ -1,51 +0,0 @@
-import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
-import path from 'path';
-import fs from 'fs';
-import os from 'os';
-import libs from '../generateResources/IntTest/libs/libs.js';
-import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
-
-const { getIntTestConfig } = libs;
-
-describe('getIntTestConfig path resolution', () => {
-  let originalGetDataFromPath;
-  let passedArgs;
-
-  beforeEach(() => {
-    originalGetDataFromPath = getObjectSchema.getDataFromPath;
-    passedArgs = null;
-    getObjectSchema.getDataFromPath = async (_izContext, folderName, rootFolderPath, options) => {
-      passedArgs = { folderName, rootFolderPath, options };
-      return [];
-    };
-  });
-
-  afterEach(() => {
-    getObjectSchema.getDataFromPath = originalGetDataFromPath;
-  });
-
-  it('Case 1: should resolve correctly when rootPath includes generateIntegrationTest', async () => {
-    const rootPath = '/home/ironfist/Pong/Izara Project/Izara-Market-Product/izara-market-products-sell-offer-price-pong/app/src/generateIntegrationTest/';
-    await getIntTestConfig({ logger: console }, 'generateIntegrationTest/libs/', rootPath);
-    
-    expect(passedArgs).not.toBeNull();
-    expect(passedArgs.folderName).toBe('libs');
-    expect(passedArgs.rootFolderPath).toBe('/home/ironfist/Pong/Izara Project/Izara-Market-Product/izara-market-products-sell-offer-price-pong/app/src/generateIntegrationTest');
-  });
-
-  it('Case 2: should resolve correctly when rootPath is repo root with app/src/... structure', async () => {
-    const tmpDir = path.join(os.tmpdir(), 'get-int-test-config-scratch');
-    fs.mkdirSync(tmpDir, { recursive: true });
-    fs.mkdirSync(path.join(tmpDir, 'app', 'src', 'generateIntegrationTest', 'libs'), { recursive: true });
-
-    try {
-      await getIntTestConfig({ logger: console }, 'generateIntegrationTest/libs/', tmpDir);
-      
-      expect(passedArgs).not.toBeNull();
-      expect(passedArgs.folderName).toBe('libs');
-      expect(passedArgs.rootFolderPath).toBe(path.join(tmpDir, 'app', 'src', 'generateIntegrationTest'));
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-});

package/src/__tests__/intTestGeneratorShared.test.cjs

@@ -1,169 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-let getIntTestOutputPath;
-let runTemplateItems;
-
-const tempDirs = [];
-
-beforeAll(async () => {
-  ({ getIntTestOutputPath, runTemplateItems } =
-    await import('../intTestGeneratorShared.js'));
-});
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('getIntTestOutputPath', () => {
-  it('uses app/src when app directory exists', () => {
-    const rootPath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-output-app-')
-    );
-    tempDirs.push(rootPath);
-    fs.mkdirSync(path.join(rootPath, 'app'));
-
-    expect(getIntTestOutputPath(rootPath)).toBe(
-      path.join(rootPath, 'app', 'src', 'generateIntegrationTest')
-    );
-  });
-
-  it('falls back to src when app directory is missing', () => {
-    const rootPath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-output-src-')
-    );
-    tempDirs.push(rootPath);
-
-    expect(getIntTestOutputPath(rootPath)).toBe(
-      path.join(rootPath, 'src', 'generateIntegrationTest')
-    );
-  });
-
-  it('detects app from project root even when output path is different', () => {
-    const projectRootPath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-output-project-root-')
-    );
-    const outputPath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-output-custom-')
-    );
-    tempDirs.push(projectRootPath, outputPath);
-    fs.mkdirSync(path.join(projectRootPath, 'app'));
-
-    expect(getIntTestOutputPath(outputPath, projectRootPath)).toBe(
-      path.join(outputPath, 'app', 'src', 'generateIntegrationTest')
-    );
-  });
-});
-
-describe('runTemplateItems', () => {
-  it('skips empty array items', async () => {
-    const writeSource = jest.fn();
-
-    await runTemplateItems([[]], {
-      writeSource,
-      errorPrefix: 'IntTest resource'
-    });
-
-    expect(writeSource).not.toHaveBeenCalled();
-  });
-
-  it('validates items before writing', async () => {
-    const writeSource = jest.fn()
-      .mockResolvedValueOnce([true, {}])
-      .mockResolvedValueOnce([true, {}]);
-
-    await runTemplateItems([
-      {
-        templatePath: '/tmp/template.ejs',
-        templateData: { ok: true },
-        setting: { savePath: '/tmp/out' }
-      }
-    ], {
-      writeSource,
-      errorPrefix: 'IntTest resource'
-    });
-
-    expect(writeSource).toHaveBeenNthCalledWith(1, expect.any(Object), {
-      checkCreateSourcePass: true
-    });
-    expect(writeSource).toHaveBeenNthCalledWith(2, expect.any(Object), {
-      checkCreateSourcePass: false
-    });
-  });
-
-  it('preserves configured files when clearing a save path', async () => {
-    const savePath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-preserve-save-path-')
-    );
-    tempDirs.push(savePath);
-    fs.writeFileSync(path.join(savePath, 'saveConfig.js'), 'keep');
-    fs.writeFileSync(path.join(savePath, 'old.js'), 'remove');
-    fs.mkdirSync(path.join(savePath, 'nested'));
-    fs.writeFileSync(path.join(savePath, 'nested', 'stale.json'), '{}');
-
-    const writeSource = jest.fn()
-      .mockResolvedValueOnce([true, {}])
-      .mockImplementationOnce(async ({ setting }) => {
-        fs.writeFileSync(path.join(setting.savePath, 'IntTestPath.js'), 'new');
-        return [true, {}];
-      });
-
-    await runTemplateItems([
-      {
-        templatePath: '/tmp/template.ejs',
-        templateData: { ok: true },
-        setting: {
-          savePath,
-          preserveFileNames: ['saveConfig.js']
-        }
-      }
-    ], {
-      writeSource,
-      errorPrefix: 'IntTest resource'
-    });
-
-    expect(fs.existsSync(path.join(savePath, 'saveConfig.js'))).toBe(true);
-    expect(fs.readFileSync(path.join(savePath, 'saveConfig.js'), 'utf8')).toBe('keep');
-    expect(fs.existsSync(path.join(savePath, 'old.js'))).toBe(false);
-    expect(fs.existsSync(path.join(savePath, 'nested'))).toBe(false);
-    expect(fs.existsSync(path.join(savePath, 'IntTestPath.js'))).toBe(true);
-  });
-
-  it('does not clear save path when cleanSavePath is false', async () => {
-    const savePath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-no-clean-save-path-')
-    );
-    tempDirs.push(savePath);
-    fs.writeFileSync(path.join(savePath, 'config.json'), 'keep');
-    fs.mkdirSync(path.join(savePath, 'nested-dir'));
-    fs.writeFileSync(path.join(savePath, 'nested-dir', 'file.json'), '{}');
-
-    const writeSource = jest.fn()
-      .mockResolvedValueOnce([true, {}])
-      .mockImplementationOnce(async ({ setting }) => {
-        fs.writeFileSync(path.join(setting.savePath, 'IntTestPath.js'), 'new');
-        return [true, {}];
-      });
-
-    await runTemplateItems([
-      {
-        templatePath: '/tmp/template.ejs',
-        templateData: { ok: true },
-        setting: {
-          savePath,
-          cleanSavePath: false
-        }
-      }
-    ], {
-      writeSource,
-      errorPrefix: 'IntTest resource'
-    });
-
-    expect(fs.existsSync(path.join(savePath, 'config.json'))).toBe(true);
-    expect(fs.existsSync(path.join(savePath, 'nested-dir'))).toBe(true);
-    expect(fs.existsSync(path.join(savePath, 'IntTestPath.js'))).toBe(true);
-  });
-});

package/src/__tests__/pathIntTest.test.js

@@ -1,103 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-import generatePathIntTest from '../generateResources/IntTest/generateTests/pathIntTest/pathIntTest.js';
-
-describe('generatePathIntTest', () => {
-  it('creates IntTestPath data from generated files in the new folder structure', async () => {
-    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'int-test-path-'));
-    const srcPath = path.join(rootPath, 'app', 'src', 'generateIntegrationTest');
-    const serviceTag = 'svc-demo';
-
-    fs.mkdirSync(path.join(srcPath, serviceTag, 'orderCreate', 'caseA'), { recursive: true });
-    fs.mkdirSync(path.join(srcPath, serviceTag, 'orderCreate', 'orderCreate'), { recursive: true });
-    fs.mkdirSync(path.join(srcPath, serviceTag, 'shared'), { recursive: true });
-
-    fs.writeFileSync(path.join(srcPath, serviceTag, 'orderCreate', 'caseA', 'events.json'), '{}');
-    fs.writeFileSync(path.join(srcPath, serviceTag, 'orderCreate', 'orderCreate', 'tests.json'), '{}');
-    fs.writeFileSync(path.join(srcPath, serviceTag, 'shared', 'resources.json'), '{}');
-    fs.writeFileSync(path.join(srcPath, serviceTag, 'ignore.txt'), 'ignore');
-
-    try {
-      const result = await generatePathIntTest({}, srcPath, {
-        serviceTag,
-        s3Prefix: 'demo-prefix'
-      });
-
-      expect(result).toEqual({
-        templateData: {
-          intTestPaths: [
-            'test_config/demo-prefix/svc-demo/orderCreate/caseA/',
-            'test_config/demo-prefix/svc-demo/orderCreate/orderCreate/',
-            'test_config/demo-prefix/svc-demo/shared/'
-          ]
-        },
-        templatePath: expect.stringContaining('template.ejs'),
-        setting: {
-          generateHookFile: false,
-          savePath: path.join(srcPath, './libs/'),
-          saveFileName: 'IntTestPath',
-          fileExtension: '.js',
-          isAppend: false,
-          cleanSavePath: false
-        }
-      });
-    } finally {
-      fs.rmSync(rootPath, { recursive: true, force: true });
-    }
-  });
-
-  it('preserves test case folder name prefix even if it contains the serviceTag', async () => {
-    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'int-test-path-nested-'));
-    const srcPath = path.join(rootPath, 'app', 'src', 'generateIntegrationTest');
-    const serviceTag = 'SellOfferManager';
-
-    // Mock folder structure similar to the issue reported
-    const nestedTestFolder = path.join(srcPath, serviceTag, 'IntegrationTest_SellOfferManager_ProcessCalCombinedPricingHdrSqs__case_BasicCase');
-    fs.mkdirSync(nestedTestFolder, { recursive: true });
-    fs.writeFileSync(path.join(nestedTestFolder, 'events.json'), '{}');
-
-    try {
-      const result = await generatePathIntTest({}, srcPath, {
-        serviceTag,
-        s3Prefix: 'PongDev'
-      });
-
-      expect(result).toEqual({
-        templateData: {
-          intTestPaths: [
-            'test_config/PongDev/SellOfferManager/IntegrationTest_SellOfferManager_ProcessCalCombinedPricingHdrSqs__case_BasicCase/'
-          ]
-        },
-        templatePath: expect.stringContaining('template.ejs'),
-        setting: {
-          generateHookFile: false,
-          savePath: path.join(srcPath, './libs/'),
-          saveFileName: 'IntTestPath',
-          fileExtension: '.js',
-          isAppend: false,
-          cleanSavePath: false
-        }
-      });
-    } finally {
-      fs.rmSync(rootPath, { recursive: true, force: true });
-    }
-  });
-
-  it('returns empty when no generated files exist for the service tag', async () => {
-    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'int-test-path-empty-'));
-    const srcPath = path.join(rootPath, 'src', 'generateIntegrationTest');
-    fs.mkdirSync(srcPath, { recursive: true });
-
-    try {
-      await expect(generatePathIntTest({}, srcPath, {
-        serviceTag: 'missing-service',
-        s3Prefix: 'demo-prefix'
-      })).resolves.toEqual([]);
-    } finally {
-      fs.rmSync(rootPath, { recursive: true, force: true });
-    }
-  });
-});