fix: CF integration tests and sonar issues (#3739)

* test: add cf integration test

* refactor: improve create service

* test: add tests

* chore: add cset

* refactor: rename method

* refactor: rename method

Author: nikmace

.changeset/perfect-monkeys-sleep.md

@@ -0,0 +1,6 @@
+---
+'@sap-ux/generator-adp': patch
+'@sap-ux/adp-tooling': patch
+---
+
+fix: CF integration tests and sonar issues

packages/adp-tooling/src/cf/app/html5-repo.ts

@@ -5,7 +5,7 @@ import type { ToolsLogger } from '@sap-ux/logger';
 import type { Manifest } from '@sap-ux/project-access';
 
 import { t } from '../../i18n';
-import { createService, getServiceInstanceKeys } from '../services/api';
+import { getServiceNameByTags, getServiceInstanceKeys, createServiceInstance } from '../services/api';
 import type { HTML5Content, ServiceKeys, Uaa, CfAppParams } from '../../types';
 
 const HTML5_APPS_REPO_RUNTIME = 'html5-apps-repo-runtime';
@@ -75,16 +75,10 @@ export async function getHtml5RepoCredentials(spaceGuid: string, logger: ToolsLo
             logger
         );
         if (!serviceKeys?.credentials?.length) {
-            await createService(
-                spaceGuid,
-                'app-runtime',
-                HTML5_APPS_REPO_RUNTIME,
-                ['html5-apps-repo-rt'],
-                undefined,
-                undefined,
-                undefined,
+            const serviceName = await getServiceNameByTags(spaceGuid, ['html5-apps-repo-rt']);
+            await createServiceInstance('app-runtime', HTML5_APPS_REPO_RUNTIME, serviceName, {
                 logger
-            );
+            });
             serviceKeys = await getServiceInstanceKeys({ names: [HTML5_APPS_REPO_RUNTIME] }, logger);
             if (!serviceKeys?.credentials?.length) {
                 logger.debug(t('error.noUaaCredentialsFoundForHtml5Repo'));

packages/adp-tooling/src/cf/project/yaml.ts

@@ -28,7 +28,6 @@ interface AdjustMtaYamlParams {
     appRouterType: AppRouterType;
     businessSolutionName: string;
     businessService: string;
-    spaceGuid: string;
 }
 
 /**
@@ -418,7 +417,7 @@ function adjustMtaYamlFlpModule(yamlContent: MtaYaml, projectName: string, busin
  * @returns {Promise<void>} The promise.
  */
 export async function adjustMtaYaml(
-    { projectPath, moduleName, appRouterType, businessSolutionName, businessService, spaceGuid }: AdjustMtaYamlParams,
+    { projectPath, moduleName, appRouterType, businessSolutionName, businessService }: AdjustMtaYamlParams,
     memFs: Editor,
     templatePathOverwrite?: string,
     logger?: ToolsLogger
@@ -456,15 +455,7 @@ export async function adjustMtaYaml(
     // should go last since it sorts the modules (workaround, should be removed after fixed in deployment module)
     adjustMtaYamlFlpModule(yamlContent, projectName, businessService);
 
-    await createServices(
-        projectPath,
-        yamlContent,
-        initialServices,
-        timestamp,
-        spaceGuid,
-        templatePathOverwrite,
-        logger
-    );
+    await createServices(yamlContent, initialServices, timestamp, templatePathOverwrite, logger);
 
     const updatedYamlContent = yaml.dump(yamlContent);
 

packages/adp-tooling/src/cf/services/api.ts

@@ -28,6 +28,12 @@ interface FDCResponse {
     results: CFApp[];
 }
 
+interface CreateServiceOptions {
+    xsSecurityProjectName?: string;
+    templatePathOverwrite?: string;
+    logger?: ToolsLogger;
+}
+
 const PARAM_MAP: Map<string, string> = new Map([
     ['spaceGuids', 'space_guids'],
     ['planNames', 'service_plan_names'],
@@ -133,57 +139,38 @@ export async function getFDCApps(appHostIds: string[], cfConfig: CfConfig, logge
 }
 
 /**
- * Creates a service.
+ * Creates a service instance.
  *
- * @param {string} spaceGuid - The space GUID.
- * @param {string} plan - The plan.
+ * @param {string} plan - The service plan.
  * @param {string} serviceInstanceName - The service instance name.
- * @param {string[]} tags - The tags.
- * @param {string} [serviceName] - The service name.
- * @param {object} [security] - Security configuration.
- * @param {string | null} security.filePath - The security file path.
- * @param {string} [security.xsappname] - The XS app name.
- * @param {string} [templatePathOverwrite] - The template path overwrite.
- * @param {ToolsLogger} [logger] - The logger.
+ * @param {string} serviceName - The service name.
+ * @param {CreateServiceOptions} [options] - Additional options.
+ * @returns {Promise<void>} The promise.
  */
-export async function createService(
-    spaceGuid: string,
+export async function createServiceInstance(
     plan: string,
     serviceInstanceName: string,
-    tags: string[],
-    serviceName: string | undefined,
-    security?: {
-        filePath: string | null;
-        xsappname?: string;
-    },
-    templatePathOverwrite?: string,
-    logger?: ToolsLogger
+    serviceName: string,
+    options?: CreateServiceOptions
 ): Promise<void> {
+    const { xsSecurityProjectName, templatePathOverwrite, logger } = options ?? {};
+
     try {
-        const { filePath, xsappname } = security ?? {};
-        if (!serviceName) {
-            const json: CfAPIResponse<CfServiceOffering> = await requestCfApi<CfAPIResponse<CfServiceOffering>>(
-                `/v3/service_offerings?per_page=1000&space_guids=${spaceGuid}`
-            );
-            const serviceOffering = json?.resources?.find(
-                (resource: CfServiceOffering) => resource.tags && tags.every((tag) => resource.tags?.includes(tag))
-            );
-            serviceName = serviceOffering?.name;
-        }
         logger?.log(
             `Creating service instance '${serviceInstanceName}' of service '${serviceName}' with '${plan}' plan`
         );
 
-        const commandParameters: string[] = ['create-service', serviceName ?? '', plan, serviceInstanceName];
-        if (filePath) {
+        const commandParameters: string[] = ['create-service', serviceName, plan, serviceInstanceName];
+
+        if (xsSecurityProjectName) {
             let xsSecurity = null;
             try {
                 const baseTmplPath = path.join(__dirname, '../../../templates');
                 const templatePath = templatePathOverwrite ?? baseTmplPath;
                 const filePath = path.resolve(templatePath, 'cf/xs-security.json');
                 const xsContent = fs.readFileSync(filePath, 'utf-8');
                 xsSecurity = JSON.parse(xsContent) as unknown as { xsappname?: string };
-                xsSecurity.xsappname = xsappname;
+                xsSecurity.xsappname = xsSecurityProjectName;
             } catch (err) {
                 logger?.error(`Failed to parse xs-security.json file: ${err}`);
                 throw new Error(t('error.xsSecurityJsonCouldNotBeParsed'));
@@ -200,53 +187,64 @@ export async function createService(
     }
 }
 
+/**
+ * Gets the service name by tags.
+ *
+ * @param {string} spaceGuid - The space GUID.
+ * @param {string[]} tags - The service tags for discovery.
+ * @returns {Promise<string>} The service name.
+ */
+export async function getServiceNameByTags(spaceGuid: string, tags: string[]): Promise<string> {
+    const json: CfAPIResponse<CfServiceOffering> = await requestCfApi<CfAPIResponse<CfServiceOffering>>(
+        `/v3/service_offerings?per_page=1000&space_guids=${spaceGuid}`
+    );
+    const serviceOffering = json?.resources?.find(
+        (resource: CfServiceOffering) => resource.tags && tags.every((tag) => resource.tags?.includes(tag))
+    );
+    return serviceOffering?.name ?? '';
+}
+
 /**
  * Creates the services.
  *
- * @param {string} projectPath - The project path.
  * @param {MtaYaml} yamlContent - The YAML content.
  * @param {string[]} initialServices - The initial services.
  * @param {string} timestamp - The timestamp.
- * @param {string} spaceGuid - The space GUID.
  * @param {string} [templatePathOverwrite] - The template path overwrite.
  * @param {ToolsLogger} logger - The logger.
  * @returns {Promise<void>} The promise.
  */
 export async function createServices(
-    projectPath: string,
     yamlContent: MtaYaml,
     initialServices: string[],
     timestamp: string,
-    spaceGuid: string,
     templatePathOverwrite?: string,
     logger?: ToolsLogger
 ): Promise<void> {
     const excludeServices = new Set([...initialServices, 'portal', 'html5-apps-repo']);
-    const xsSecurityPath = path.join(projectPath, 'xs-security.json');
     const xsSecurityProjectName = getProjectNameForXsSecurity(yamlContent, timestamp);
     for (const resource of yamlContent.resources ?? []) {
         if (!excludeServices.has(resource?.parameters?.service ?? '')) {
             if (resource?.parameters?.service === 'xsuaa') {
-                await createService(
-                    spaceGuid,
+                await createServiceInstance(
                     resource.parameters['service-plan'] ?? '',
                     resource.parameters['service-name'] ?? '',
-                    [],
                     resource.parameters.service,
-                    { filePath: xsSecurityPath, xsappname: xsSecurityProjectName },
-                    templatePathOverwrite,
-                    logger
+                    {
+                        xsSecurityProjectName,
+                        templatePathOverwrite,
+                        logger
+                    }
                 );
             } else {
-                await createService(
-                    spaceGuid,
+                await createServiceInstance(
                     resource.parameters['service-plan'] ?? '',
                     resource.parameters['service-name'] ?? '',
-                    [],
-                    resource.parameters.service,
-                    { filePath: null, xsappname: xsSecurityProjectName },
-                    templatePathOverwrite,
-                    logger
+                    resource.parameters.service ?? '',
+                    {
+                        templatePathOverwrite,
+                        logger
+                    }
                 );
             }
         }

packages/adp-tooling/src/writer/cf.ts

@@ -38,8 +38,7 @@ export async function generateCf(
             moduleName: app.id,
             appRouterType: cf.approuter,
             businessSolutionName: cf.businessSolutionName ?? '',
-            businessService: cf.businessService,
-            spaceGuid: cf.space.GUID
+            businessService: cf.businessService
         },
         fs,
         config.options?.templatePathOverwrite,

packages/adp-tooling/test/unit/cf/app/html5-repo.test.ts

@@ -6,21 +6,22 @@ import type { Manifest } from '@sap-ux/project-access';
 
 import { initI18n, t } from '../../../../src/i18n';
 import type { CfAppParams, ServiceKeys, Uaa } from '../../../../src/types';
-import { createService, getServiceInstanceKeys } from '../../../../src/cf/services/api';
+import { getServiceNameByTags, createServiceInstance, getServiceInstanceKeys } from '../../../../src/cf/services/api';
 import { downloadAppContent, downloadZip, getHtml5RepoCredentials, getToken } from '../../../../src/cf/app/html5-repo';
 
-// Mock dependencies
 jest.mock('axios');
 jest.mock('adm-zip');
 jest.mock('../../../../src/cf/services/api', () => ({
     ...jest.requireActual('../../../../src/cf/services/api'),
-    createService: jest.fn(),
+    getServiceNameByTags: jest.fn(),
+    createServiceInstance: jest.fn(),
     getServiceInstanceKeys: jest.fn()
 }));
 
 const mockAxios = axios as jest.Mocked<typeof axios>;
 const mockAdmZip = AdmZip as jest.MockedClass<typeof AdmZip>;
-const mockCreateService = createService as jest.MockedFunction<typeof createService>;
+const mockGetServiceNameByTags = getServiceNameByTags as jest.MockedFunction<typeof getServiceNameByTags>;
+const mockCreateServiceInstance = createServiceInstance as jest.MockedFunction<typeof createServiceInstance>;
 const mockGetServiceInstanceKeys = getServiceInstanceKeys as jest.MockedFunction<typeof getServiceInstanceKeys>;
 
 describe('HTML5 Repository', () => {
@@ -166,27 +167,28 @@ describe('HTML5 Repository', () => {
                 },
                 mockLogger
             );
-            expect(mockCreateService).not.toHaveBeenCalled();
+            expect(mockGetServiceNameByTags).not.toHaveBeenCalled();
+            expect(mockCreateServiceInstance).not.toHaveBeenCalled();
         });
 
         test('should create service when no credentials found', async () => {
             mockGetServiceInstanceKeys
                 .mockResolvedValueOnce({ credentials: [], serviceInstance: { guid: '', name: '' } })
                 .mockResolvedValueOnce(mockServiceKeys);
-            mockCreateService.mockResolvedValue(undefined);
+            mockGetServiceNameByTags.mockResolvedValue('html5-apps-repo-rt');
+            mockCreateServiceInstance.mockResolvedValue(undefined);
 
             const result = await getHtml5RepoCredentials('test-space-guid', mockLogger);
 
             expect(result).toBe(mockServiceKeys);
-            expect(mockCreateService).toHaveBeenCalledWith(
-                'test-space-guid',
+            expect(mockGetServiceNameByTags).toHaveBeenCalledWith('test-space-guid', ['html5-apps-repo-rt']);
+            expect(mockCreateServiceInstance).toHaveBeenCalledWith(
                 'app-runtime',
                 'html5-apps-repo-runtime',
-                ['html5-apps-repo-rt'],
-                undefined,
-                undefined,
-                undefined,
-                mockLogger
+                'html5-apps-repo-rt',
+                {
+                    logger: mockLogger
+                }
             );
             expect(mockGetServiceInstanceKeys).toHaveBeenCalledTimes(2);
         });
@@ -195,7 +197,8 @@ describe('HTML5 Repository', () => {
             mockGetServiceInstanceKeys
                 .mockResolvedValueOnce({ credentials: [], serviceInstance: { guid: '', name: '' } })
                 .mockResolvedValueOnce({ credentials: [], serviceInstance: { guid: '', name: '' } });
-            mockCreateService.mockResolvedValue(undefined);
+            mockGetServiceNameByTags.mockResolvedValue('html5-apps-repo-rt');
+            mockCreateServiceInstance.mockResolvedValue(undefined);
 
             await expect(getHtml5RepoCredentials('test-space-guid', mockLogger)).rejects.toThrow(
                 t('error.cannotFindHtml5RepoRuntime')