refactor: address review feedback

Author: RahulGautamSingh

lib/modules/platform/azure/index.spec.ts

@@ -11,6 +11,7 @@ import {
   GitVersionType,
   PullRequestStatus,
 } from 'azure-devops-node-api/interfaces/GitInterfaces.js';
+import type { IWorkItemTrackingApi } from 'azure-devops-node-api/WorkItemTrackingApi.js';
 import type { Mocked, MockedObject } from 'vitest';
 import { vi } from 'vitest';
 import { mockDeep } from 'vitest-mock-extended';
@@ -2108,6 +2109,7 @@ describe('modules/platform/azure/index', () => {
   });
 
   it('findIssue returns null if not found', async () => {
+    await initRepo({ repository: 'some/repo' });
     azureApi.workItemTrackingApi.mockImplementationOnce(
       () =>
         ({
@@ -2121,33 +2123,32 @@ describe('modules/platform/azure/index', () => {
   it('findIssue return first issue if multiple found', async () => {
     await initRepo({ repository: 'some/repo' });
 
-    azureApi.workItemTrackingApi.mockImplementationOnce(
-      () =>
-        ({
-          queryByWiql: vi.fn().mockResolvedValue({
-            workItems: [{ id: 123 }, { id: 456 }],
-          }),
-          getWorkItems: vi.fn().mockResolvedValue([
-            {
-              id: 123,
-              fields: {
-                'System.Title': 'The title',
-                'System.WorkItemType': 'Issue',
-                'System.State': 'Active',
-                'System.Description': 'fake',
-              },
+    azureApi.workItemTrackingApi.mockResolvedValueOnce(
+      partial<IWorkItemTrackingApi>({
+        queryByWiql: vi.fn().mockResolvedValue({
+          workItems: [{ id: 123 }, { id: 456 }],
+        }),
+        getWorkItems: vi.fn().mockResolvedValue([
+          {
+            id: 123,
+            fields: {
+              'System.Title': 'The title',
+              'System.WorkItemType': 'Issue',
+              'System.State': 'Active',
+              'System.Description': 'fake',
             },
-            {
-              id: 456,
-              fields: {
-                'System.Title': 'The title',
-                'System.WorkItemType': 'Issue',
-                'System.State': 'New',
-                'System.Description': 'another fake description',
-              },
+          },
+          {
+            id: 456,
+            fields: {
+              'System.Title': 'The title',
+              'System.WorkItemType': 'Issue',
+              'System.State': 'New',
+              'System.Description': 'another fake description',
             },
-          ]),
-        }) as any,
+          },
+        ]),
+      }),
     );
     const res = await azure.findIssue('The title');
     expect(res).toMatchObject({
@@ -2580,6 +2581,7 @@ describe('modules/platform/azure/index', () => {
   });
 
   it('getIssueList handles empty wiql result', async () => {
+    await initRepo({ repository: 'some/repo' });
     azureApi.workItemTrackingApi.mockImplementation(
       () =>
         ({

lib/modules/platform/azure/index.ts

@@ -70,6 +70,7 @@ interface User {
 }
 
 let config: Config = {} as any;
+let issueService: IssueService;
 
 const defaults: {
   endpoint?: string;
@@ -80,25 +81,6 @@ const defaults: {
 
 export const id = 'azure';
 
-function createIssueOperations(config: Config): {
-  findIssue: (title: string) => Promise<Issue | null>;
-  ensureIssueClosing: (title: string) => Promise<void>;
-  ensureIssue: (
-    issueConfig: EnsureIssueConfig,
-  ) => Promise<EnsureIssueResult | null>;
-  getIssueList: (titleFilter?: string) => Promise<Issue[]>;
-} {
-  const service = new IssueService(config);
-
-  return {
-    findIssue: (title: string) => service.findIssue(title),
-    ensureIssueClosing: (title: string) => service.ensureIssueClosing(title),
-    ensureIssue: (issueConfig: EnsureIssueConfig) =>
-      service.ensureIssue(issueConfig),
-    getIssueList: (titleFilter?: string) => service.getIssueList(titleFilter),
-  };
-}
-
 export function initPlatform({
   endpoint,
   token,
@@ -241,6 +223,7 @@ export async function initRepo({
   config.repoId = repo.id!;
 
   config.project = repo.project!.name!;
+  issueService = new IssueService(config);
   config.owner = '?owner?';
   logger.debug(`${repository} owner = ${config.owner}`);
   const defaultBranch = repo.defaultBranch.replace('refs/heads/', '');
@@ -891,21 +874,21 @@ export function maxBodyLength(): number {
 }
 
 export async function findIssue(title: string): Promise<Issue | null> {
-  return await createIssueOperations(config).findIssue(title);
+  return await issueService.findIssue(title);
 }
 
 export async function ensureIssue(
   issueConfig: EnsureIssueConfig,
 ): Promise<EnsureIssueResult | null> {
-  return await createIssueOperations(config).ensureIssue(issueConfig);
+  return await issueService.ensureIssue(issueConfig);
 }
 
 export async function ensureIssueClosing(title: string): Promise<void> {
-  return await createIssueOperations(config).ensureIssueClosing(title);
+  return await issueService.ensureIssueClosing(title);
 }
 
 export async function getIssueList(titleFilter?: string): Promise<Issue[]> {
-  return await createIssueOperations(config).getIssueList(titleFilter);
+  return await issueService.getIssueList(titleFilter);
 }
 
 async function getUserIds(users: string[]): Promise<User[]> {

lib/modules/platform/azure/issue.spec.ts

@@ -1,49 +1,29 @@
-import type { Mocked, MockedObject } from 'vitest';
 import { vi } from 'vitest';
 import { mockDeep } from 'vitest-mock-extended';
-import type { logger as _logger } from '../../../logger/index.ts';
-import type * as _hostRules from '../../../util/host-rules.ts';
-import type { Platform } from '../types.ts';
+import { logger } from '../../../logger/index.ts';
+import * as hostRules from '../../../util/host-rules.ts';
+import * as azureApi from './azure-got-wrapper.ts';
 import { IssueService } from './issue.ts';
 import type { Config } from './types.ts';
 
-vi.mock('./azure-got-wrapper', () => mockDeep());
-vi.mock('./azure-helper', () => mockDeep());
-vi.mock('../../../util/host-rules', () => mockDeep());
-vi.mock('../../../util/sanitize', () =>
+vi.mock('./azure-got-wrapper.ts', () => mockDeep());
+vi.mock('./azure-helper.ts', () => mockDeep());
+vi.mock('../../../util/host-rules.ts', () => mockDeep());
+vi.mock('../../../logger/index.ts', () => mockDeep());
+vi.mock('../../../util/sanitize.ts', () =>
   mockDeep({ sanitize: (s: string) => s }),
 );
-vi.mock('./util', () => ({
+vi.mock('./util.ts', () => ({
   getWorkItemTitle: vi.fn((title: string) => `[Renovate] ${title}`),
 }));
 
 describe('modules/platform/azure/issue', () => {
-  let hostRules: Mocked<typeof _hostRules>;
-  let azure: Platform;
-  let azureApi: Mocked<typeof import('./azure-got-wrapper.ts')>;
-  let logger: MockedObject<typeof _logger>;
   let config: Config;
   let issueService: IssueService;
 
-  beforeEach(async () => {
-    // reset module
-    vi.resetModules();
-    hostRules = await vi.importMock('../../../util/host-rules.ts');
-    azure = await vi.importActual('./index.ts');
-    azureApi = await vi.importMock('./azure-got-wrapper.ts');
-    logger = (
-      await vi.importMock<typeof import('../../../logger/index.ts')>(
-        '../../../logger/index.ts',
-      )
-    ).logger;
-    hostRules.find.mockReturnValue({
-      token: 'token',
-    });
-
-    await azure.initPlatform({
-      endpoint: 'https://dev.azure.com/renovate12345',
-      token: 'token',
-    });
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(hostRules.find).mockReturnValue({ token: 'token' });
 
     config = {
       repository: 'test/repo',
@@ -683,68 +663,4 @@ describe('modules/platform/azure/issue', () => {
       expect(result).toBe('created');
     });
   });
-
-  describe('integration with main azure Platform', () => {
-    it('getIssueList should work interface', async () => {
-      azureApi.workItemTrackingApi.mockImplementation(
-        () =>
-          ({
-            queryByWiql: vi.fn().mockResolvedValue({
-              workItems: [],
-            }),
-          }) as any,
-      );
-
-      const result = await azure.getIssueList();
-      expect(result).toEqual([]);
-    });
-
-    it('findIssue should work', async () => {
-      azureApi.workItemTrackingApi.mockImplementation(
-        () =>
-          ({
-            queryByWiql: vi.fn().mockResolvedValue({
-              workItems: [],
-            }),
-          }) as any,
-      );
-
-      const result = await azure.findIssue('Test Issue');
-      expect(result).toBeNull();
-    });
-
-    it('ensureIssue should work', async () => {
-      azureApi.workItemTrackingApi.mockImplementation(
-        () =>
-          ({
-            queryByWiql: vi.fn().mockResolvedValue({
-              workItems: [],
-            }),
-            createWorkItem: vi.fn().mockResolvedValue({ id: 123 }),
-          }) as any,
-      );
-
-      const result = await azure.ensureIssue({
-        title: 'Test Issue',
-        body: 'Test body content',
-      });
-
-      expect(result).toEqual('created');
-    });
-
-    it('ensureIssueClosing should work', async () => {
-      azureApi.workItemTrackingApi.mockImplementation(
-        () =>
-          ({
-            queryByWiql: vi.fn().mockResolvedValue({
-              workItems: [],
-            }),
-          }) as any,
-      );
-
-      await expect(
-        azure.ensureIssueClosing('Test Issue'),
-      ).resolves.not.toThrow();
-    });
-  });
 });