github-issue-tower-defence-management 1.154.1 → 1.156.0

package/src/adapter/repositories/githubGraphqlClient.test.ts

@@ -19,6 +19,7 @@ import {
   GITHUB_GRAPHQL_ENDPOINT,
   GITHUB_GRAPHQL_REQUEST_TIMEOUT_MS,
   RATE_LIMIT_SELECTION,
+  extractGraphqlCallSite,
   extractGraphqlOperationName,
   fetchGithubGraphql,
   injectRateLimitSelection,
@@ -117,39 +118,194 @@ describe('githubGraphqlClient', () => {
     });
   });
 
+  describe('extractGraphqlCallSite', () => {
+    it('names the nearest modules outside the graphql client', () => {
+      const stack = [
+        'Error',
+        '    at captureGraphqlCallSite (/app/bin/adapter/repositories/githubGraphqlClient.js:80:20)',
+        '    at postGithubGraphqlJson (/app/bin/adapter/repositories/githubGraphqlClient.js:120:22)',
+        '    at GraphqlProjectItemRepository.fetchProjectItemByUrl (/app/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:1042:11)',
+        '    at ApiV3CheerioRestIssueRepository.getIssueByUrl (/app/bin/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.js:813:11)',
+        '    at async ConvertCheckboxToIssueInStoryIssueUseCase.run (/app/bin/domain/usecases/ConvertCheckboxToIssueInStoryIssueUseCase.js:63:31)',
+        '    at async HandleScheduledEventUseCase.runSlowSweepUseCases (/app/bin/domain/usecases/HandleScheduledEventUseCase.js:552:5)',
+      ].join('\n');
+
+      expect(extractGraphqlCallSite(stack)).toBe(
+        'GraphqlProjectItemRepository<-ApiV3CheerioRestIssueRepository<-ConvertCheckboxToIssueInStoryIssueUseCase',
+      );
+    });
+
+    it('collapses the retry and fallback wrappers into their own module so the owning repository and use case are named', () => {
+      const stack = [
+        'Error',
+        '    at postGithubGraphqlJson (/app/bin/adapter/repositories/githubGraphqlClient.js:120:22)',
+        '    at callWithRateLimitRetry (/app/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:255:15)',
+        '    at callGraphql (/app/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:280:12)',
+        '    at callGraphqlWithHalvingFallback (/app/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:310:12)',
+        '    at GraphqlProjectItemRepository.fetchProjectItems (/app/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:410:11)',
+        '    at async StartPreparationUseCase.run (/app/bin/domain/usecases/StartPreparationUseCase.js:456:11)',
+      ].join('\n');
+
+      expect(extractGraphqlCallSite(stack)).toBe(
+        'GraphqlProjectItemRepository<-StartPreparationUseCase',
+      );
+    });
+
+    it('names the same call site whether or not the engine qualifies a nested helper with its class name', () => {
+      const frames = (nestedHelperFrameName: string): string =>
+        [
+          'Error',
+          '    at postGithubGraphqlJson (/app/bin/adapter/repositories/githubGraphqlClient.js:120:22)',
+          `    at ${nestedHelperFrameName} (/app/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:310:12)`,
+          '    at GraphqlProjectItemRepository.fetchProjectItems (/app/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:410:11)',
+          '    at async StartPreparationUseCase.run (/app/bin/domain/usecases/StartPreparationUseCase.js:456:11)',
+        ].join('\n');
+
+      expect(
+        extractGraphqlCallSite(frames('callGraphqlWithHalvingFallback')),
+      ).toBe('GraphqlProjectItemRepository<-StartPreparationUseCase');
+      expect(
+        extractGraphqlCallSite(
+          frames('GraphqlProjectItemRepository.callGraphqlWithHalvingFallback'),
+        ),
+      ).toBe('GraphqlProjectItemRepository<-StartPreparationUseCase');
+    });
+
+    it('names the module of a frame that carries a file location instead of a function name', () => {
+      const stack = [
+        'Error',
+        '    at postGithubGraphqlJson (/app/bin/adapter/repositories/githubGraphqlClient.js:120:22)',
+        '    at /app/bin/domain/usecases/AnonymousCaller.js:12:9',
+        '    at StartPreparationUseCase.run (/app/bin/domain/usecases/StartPreparationUseCase.js:456:11)',
+      ].join('\n');
+
+      expect(extractGraphqlCallSite(stack)).toBe(
+        'AnonymousCaller<-StartPreparationUseCase',
+      );
+    });
+
+    it('skips test runner and node internal frames so the caller of a test run is still named', () => {
+      const stack = [
+        'Error',
+        '    at postGithubGraphqlJson (/app/src/adapter/repositories/githubGraphqlClient.ts:139:42)',
+        '    at GraphqlProjectItemRepository.fetchProjectItems (/app/src/adapter/repositories/issue/GraphqlProjectItemRepository.ts:566:26)',
+        '    at Object.<anonymous> (/app/src/adapter/repositories/issue/GraphqlProjectItemRepository.test.ts:288:26)',
+        '    at Promise.finally.completed (/app/node_modules/jest-circus/build/jestAdapterInit.js:1561:28)',
+        '    at new Promise (<anonymous>)',
+        '    at processTicksAndRejections (node:internal/process/task_queues:104:5)',
+      ].join('\n');
+
+      expect(extractGraphqlCallSite(stack)).toBe(
+        'GraphqlProjectItemRepository',
+      );
+    });
+
+    it('names the caller when the package runs from inside node_modules, as the published build does', () => {
+      const packageRoot =
+        '/home/user/.local/share/tdpm/current/node_modules/github-issue-tower-defence-management';
+      const stack = [
+        'Error',
+        `    at captureGraphqlCallSite (${packageRoot}/bin/adapter/repositories/githubGraphqlClient.js:80:20)`,
+        `    at postGithubGraphqlJson (${packageRoot}/bin/adapter/repositories/githubGraphqlClient.js:120:22)`,
+        `    at GraphqlProjectItemRepository.fetchProjectItems (${packageRoot}/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:410:11)`,
+        `    at async StartPreparationUseCase.run (${packageRoot}/bin/domain/usecases/StartPreparationUseCase.js:456:11)`,
+      ].join('\n');
+
+      expect(
+        extractGraphqlCallSite(
+          stack,
+          `${packageRoot}/bin/adapter/repositories/githubGraphqlClient.js`,
+        ),
+      ).toBe('GraphqlProjectItemRepository<-StartPreparationUseCase');
+    });
+
+    it('names the caller when the published package sits under a scoped directory', () => {
+      const packageRoot = '/srv/app/node_modules/@hiromishikata/tdpm';
+      const stack = [
+        'Error',
+        `    at postGithubGraphqlJson (${packageRoot}/bin/adapter/repositories/githubGraphqlClient.js:120:22)`,
+        `    at GraphqlProjectItemRepository.fetchProjectItems (${packageRoot}/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:410:11)`,
+      ].join('\n');
+
+      expect(
+        extractGraphqlCallSite(
+          stack,
+          `${packageRoot}/bin/adapter/repositories/githubGraphqlClient.js`,
+        ),
+      ).toBe('GraphqlProjectItemRepository');
+    });
+
+    it('skips a dependency nested inside the installed package so no third party module is named', () => {
+      const packageRoot =
+        '/home/user/.local/share/tdpm/current/node_modules/github-issue-tower-defence-management';
+      const stack = [
+        'Error',
+        `    at postGithubGraphqlJson (${packageRoot}/bin/adapter/repositories/githubGraphqlClient.js:120:22)`,
+        `    at Object.ky (${packageRoot}/node_modules/ky/distribution/index.js:44:9)`,
+        `    at GraphqlProjectItemRepository.fetchProjectItems (${packageRoot}/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:410:11)`,
+      ].join('\n');
+
+      expect(
+        extractGraphqlCallSite(
+          stack,
+          `${packageRoot}/bin/adapter/repositories/githubGraphqlClient.js`,
+        ),
+      ).toBe('GraphqlProjectItemRepository');
+    });
+
+    it('returns unknown when no stack is available', () => {
+      expect(extractGraphqlCallSite(undefined)).toBe('unknown');
+    });
+
+    it('returns unknown when every frame is inside the graphql client', () => {
+      const stack = [
+        'Error',
+        '    at postGithubGraphqlJson (/app/bin/adapter/repositories/githubGraphqlClient.js:120:22)',
+      ].join('\n');
+
+      expect(extractGraphqlCallSite(stack)).toBe('unknown');
+    });
+  });
+
   describe('logGithubGraphqlCost', () => {
     it('logs one line with query name, cost and remaining', () => {
-      logGithubGraphqlCost(
-        'query GetProjectItems { x }',
-        { data: { rateLimit: { cost: 3, remaining: 4200 } } },
-        () => new Date('2026-08-14T09:00:00.000Z'),
-      );
+      logGithubGraphqlCost({
+        query: 'query GetProjectItems { x }',
+        responseBody: { data: { rateLimit: { cost: 3, remaining: 4200 } } },
+        callSite: 'GraphqlProjectItemRepository<-StartPreparationUseCase',
+        now: () => new Date('2026-08-14T09:00:00.000Z'),
+      });
       expect(consoleLogSpy).toHaveBeenCalledTimes(1);
       expect(consoleLogSpy).toHaveBeenCalledWith(
-        '2026-08-14T09:00:00.000Z githubGraphqlClient: query=GetProjectItems cost=3 remaining=4200',
+        '2026-08-14T09:00:00.000Z githubGraphqlClient: query=GetProjectItems cost=3 remaining=4200 caller=GraphqlProjectItemRepository<-StartPreparationUseCase',
       );
     });
 
     it('opens the line with the time the cost was charged, so a point maps to a rate-limit window', () => {
-      logGithubGraphqlCost(
-        'query GetProjectItems { x }',
-        { data: { rateLimit: { cost: 4, remaining: 4200 } } },
-        () => new Date('2026-08-14T23:45:12.345Z'),
-      );
+      logGithubGraphqlCost({
+        query: 'query GetProjectItems { x }',
+        responseBody: { data: { rateLimit: { cost: 4, remaining: 4200 } } },
+        callSite: 'GraphqlProjectItemRepository<-StartPreparationUseCase',
+        now: () => new Date('2026-08-14T23:45:12.345Z'),
+      });
       expect(consoleLogSpy).toHaveBeenCalledWith(
-        '2026-08-14T23:45:12.345Z githubGraphqlClient: query=GetProjectItems cost=4 remaining=4200',
+        '2026-08-14T23:45:12.345Z githubGraphqlClient: query=GetProjectItems cost=4 remaining=4200 caller=GraphqlProjectItemRepository<-StartPreparationUseCase',
       );
     });
 
     it('does not log when rateLimit is absent', () => {
-      logGithubGraphqlCost('query GetProjectItems { x }', {
-        data: { node: null },
+      logGithubGraphqlCost({
+        query: 'query GetProjectItems { x }',
+        responseBody: { data: { node: null } },
       });
       expect(consoleLogSpy).not.toHaveBeenCalled();
     });
 
     it('does not log when the body is not an object', () => {
-      logGithubGraphqlCost('query GetProjectItems { x }', undefined);
+      logGithubGraphqlCost({
+        query: 'query GetProjectItems { x }',
+        responseBody: undefined,
+      });
       expect(consoleLogSpy).not.toHaveBeenCalled();
     });
   });
@@ -183,7 +339,7 @@ describe('githubGraphqlClient', () => {
       expect(headers.Authorization).toBe('Bearer token-a');
       expect(consoleLogSpy).toHaveBeenCalledWith(
         expect.stringMatching(
-          /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z githubGraphqlClient: query=GetItem cost=1 remaining=4999$/,
+          /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z githubGraphqlClient: query=GetItem cost=1 remaining=4999 caller=\S+$/,
         ),
       );
     });
@@ -249,7 +405,7 @@ describe('githubGraphqlClient', () => {
       expect(sentBody.variables).toEqual({ a: 1 });
       expect(consoleLogSpy).toHaveBeenCalledWith(
         expect.stringMatching(
-          /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z githubGraphqlClient: query=PullRequestStatus cost=2 remaining=4321$/,
+          /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z githubGraphqlClient: query=PullRequestStatus cost=2 remaining=4321 caller=\S+$/,
         ),
       );
     });

package/src/adapter/repositories/githubGraphqlClient.ts

@@ -62,17 +62,121 @@ const extractRateLimit = (
   return { cost, remaining };
 };
 
-export const logGithubGraphqlCost = (
-  query: string,
-  responseBody: unknown,
-  now: () => Date = () => new Date(),
-): void => {
-  const rateLimit = extractRateLimit(responseBody);
+export const GRAPHQL_CALL_SITE_FRAME_COUNT = 3;
+
+export const GRAPHQL_CALL_SITE_SEPARATOR = '<-';
+
+export const UNKNOWN_GRAPHQL_CALL_SITE = 'unknown';
+
+const GRAPHQL_CLIENT_MODULE_NAME = 'githubGraphqlClient';
+
+const FRAME_LOCATION_PATTERN = /\(?([^()\s]+):\d+:\d+\)?$/;
+
+const MODULE_FILE_EXTENSION_PATTERN = /\.(?:[cm]?[jt]sx?)$/;
+
+const TEST_MODULE_SUFFIX_PATTERN = /\.(?:test|spec)$/;
+
+const NODE_MODULES_SEGMENT = '/node_modules/';
+
+const ownPackagePathPrefix = (modulePath: string): string | null => {
+  const segmentIndex = modulePath.lastIndexOf(NODE_MODULES_SEGMENT);
+  if (segmentIndex === -1) {
+    return null;
+  }
+  const packageRootIndex = segmentIndex + NODE_MODULES_SEGMENT.length;
+  const segments = modulePath.slice(packageRootIndex).split('/');
+  const nameSegmentCount = segments[0].startsWith('@') ? 2 : 1;
+  if (segments.length <= nameSegmentCount) {
+    return null;
+  }
+  return modulePath.slice(
+    0,
+    packageRootIndex + segments.slice(0, nameSegmentCount).join('/').length + 1,
+  );
+};
+
+const isInsideOwnPackage = (
+  location: string,
+  ownPackagePrefix: string | null,
+): boolean => {
+  if (ownPackagePrefix === null || !location.startsWith(ownPackagePrefix)) {
+    return false;
+  }
+  const pathBelowPackageRoot = `/${location.slice(ownPackagePrefix.length)}`;
+  return !pathBelowPackageRoot.includes(NODE_MODULES_SEGMENT);
+};
+
+const frameModuleName = (
+  frame: string,
+  ownPackagePrefix: string | null,
+): string | null => {
+  const match = frame.match(FRAME_LOCATION_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const location = match[1];
+  if (location.startsWith('node:')) {
+    return null;
+  }
+  if (
+    location.includes(NODE_MODULES_SEGMENT) &&
+    !isInsideOwnPackage(location, ownPackagePrefix)
+  ) {
+    return null;
+  }
+  const fileName = location.split('/').slice(-1)[0];
+  const moduleName = fileName
+    .replace(MODULE_FILE_EXTENSION_PATTERN, '')
+    .replace(TEST_MODULE_SUFFIX_PATTERN, '');
+  if (moduleName.length === 0 || moduleName === GRAPHQL_CLIENT_MODULE_NAME) {
+    return null;
+  }
+  return moduleName;
+};
+
+export const extractGraphqlCallSite = (
+  stack: string | undefined,
+  modulePath: string = __filename,
+): string => {
+  if (!stack) {
+    return UNKNOWN_GRAPHQL_CALL_SITE;
+  }
+  const ownPackagePrefix = ownPackagePathPrefix(modulePath);
+  const moduleNames = stack
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('at '))
+    .map((frame) => frameModuleName(frame, ownPackagePrefix))
+    .filter((moduleName): moduleName is string => moduleName !== null)
+    .filter(
+      (moduleName, index, allModuleNames) =>
+        allModuleNames[index - 1] !== moduleName,
+    );
+  if (moduleNames.length === 0) {
+    return UNKNOWN_GRAPHQL_CALL_SITE;
+  }
+  return moduleNames
+    .slice(0, GRAPHQL_CALL_SITE_FRAME_COUNT)
+    .join(GRAPHQL_CALL_SITE_SEPARATOR);
+};
+
+export const captureGraphqlCallSite = (): string =>
+  extractGraphqlCallSite(new Error().stack);
+
+export const logGithubGraphqlCost = (params: {
+  query: string;
+  responseBody: unknown;
+  callSite?: string;
+  now?: () => Date;
+}): void => {
+  const rateLimit = extractRateLimit(params.responseBody);
   if (!rateLimit) {
     return;
   }
+  const now = params.now ?? (() => new Date());
+  const callSite = params.callSite ?? UNKNOWN_GRAPHQL_CALL_SITE;
   console.log(
-    `${now().toISOString()} githubGraphqlClient: query=${extractGraphqlOperationName(query)} cost=${rateLimit.cost} remaining=${rateLimit.remaining}`,
+    `${now().toISOString()} githubGraphqlClient: query=${extractGraphqlOperationName(params.query)} cost=${rateLimit.cost} remaining=${rateLimit.remaining} caller=${callSite}`,
   );
 };
 
@@ -81,6 +185,7 @@ export const postGithubGraphqlJson = async <T>(params: {
   query: string;
   variables?: Record<string, unknown>;
 }): Promise<T> => {
+  const callSite = captureGraphqlCallSite();
   const response = await ky
     .post(GITHUB_GRAPHQL_ENDPOINT, {
       json: {
@@ -94,7 +199,11 @@ export const postGithubGraphqlJson = async <T>(params: {
       },
     })
     .json<T>();
-  logGithubGraphqlCost(params.query, response);
+  logGithubGraphqlCost({
+    query: params.query,
+    responseBody: response,
+    callSite,
+  });
   return response;
 };
 
@@ -104,6 +213,7 @@ export const fetchGithubGraphql = async (params: {
   variables?: Record<string, unknown>;
   timeoutMs?: number;
 }): Promise<Response> => {
+  const callSite = captureGraphqlCallSite();
   const response = await fetch(GITHUB_GRAPHQL_ENDPOINT, {
     method: 'POST',
     headers: {
@@ -123,7 +233,11 @@ export const fetchGithubGraphql = async (params: {
       .clone()
       .json()
       .catch((): null => null);
-    logGithubGraphqlCost(params.query, responseBody);
+    logGithubGraphqlCost({
+      query: params.query,
+      responseBody,
+      callSite,
+    });
   }
   return response;
 };

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.test.ts

@@ -4010,6 +4010,171 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     });
   });
 
+  describe('getOpenPullRequestCiStatus', () => {
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    const prUrl = 'https://github.com/HiromiShikata/test-repository/pull/42';
+
+    const jsonResponse = (body: unknown): Response =>
+      new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+    const openPullRequestBody = (mergeable: boolean | null): unknown => ({
+      html_url: prUrl,
+      state: 'open',
+      draft: false,
+      mergeable,
+      head: { ref: 'feature/x', sha: 'sha-1' },
+      base: { ref: 'main' },
+    });
+
+    const requestedUrl = (input: RequestInfo | URL): string => {
+      if (typeof input === 'string') {
+        return input;
+      }
+      if (input instanceof URL) {
+        return input.href;
+      }
+      return input.url;
+    };
+
+    const mockGitHubRest = (pullRequestBodies: unknown[]): string[] => {
+      const requestedUrls: string[] = [];
+      let pullRequestReadCount = 0;
+      jest
+        .spyOn(global, 'fetch')
+        .mockImplementation((input: RequestInfo | URL): Promise<Response> => {
+          const url = requestedUrl(input);
+          requestedUrls.push(url);
+          if (url.includes('/pulls/42')) {
+            const index = Math.min(
+              pullRequestReadCount,
+              pullRequestBodies.length - 1,
+            );
+            pullRequestReadCount += 1;
+            return Promise.resolve(jsonResponse(pullRequestBodies[index]));
+          }
+          if (url.includes('/rules/branches/')) {
+            return Promise.resolve(jsonResponse([]));
+          }
+          if (url.includes('/branches/')) {
+            return Promise.resolve(jsonResponse({}));
+          }
+          if (url.includes('/check-runs')) {
+            return Promise.resolve(
+              jsonResponse({
+                total_count: 1,
+                check_runs: [{ name: 'test', conclusion: 'success', id: 1 }],
+              }),
+            );
+          }
+          if (url.includes('/status')) {
+            return Promise.resolve(jsonResponse({ statuses: [] }));
+          }
+          return Promise.reject(new Error(`unexpected request: ${url}`));
+        });
+      return requestedUrls;
+    };
+
+    it('resolves every status field over REST without issuing a GraphQL request', async () => {
+      const requestedUrls = mockGitHubRest([openPullRequestBody(true)]);
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const status = await repository.getOpenPullRequestCiStatus(prUrl);
+
+      expect(status).toEqual({
+        url: prUrl,
+        isConflicted: false,
+        mergeable: 'MERGEABLE',
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      });
+      expect(
+        requestedUrls.filter((url) => url.includes('/graphql')),
+      ).toHaveLength(0);
+      expect(requestedUrls).toContain(
+        'https://api.github.com/repos/HiromiShikata/test-repository/pulls/42',
+      );
+    });
+
+    it('reports a conflicting pull request as conflicted', async () => {
+      mockGitHubRest([openPullRequestBody(false)]);
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const status = await repository.getOpenPullRequestCiStatus(prUrl);
+
+      expect(status?.isConflicted).toBe(true);
+      expect(status?.mergeable).toBe('CONFLICTING');
+    });
+
+    it('re-reads while GitHub is still computing mergeability and returns the settled value', async () => {
+      const requestedUrls = mockGitHubRest([
+        openPullRequestBody(null),
+        openPullRequestBody(true),
+      ]);
+
+      const { repository, sleep } = createApiV3CheerioRestIssueRepository();
+      const status = await repository.getOpenPullRequestCiStatus(prUrl);
+
+      expect(status?.mergeable).toBe('MERGEABLE');
+      expect(sleep).toHaveBeenCalledTimes(1);
+      const pullRequestReads = requestedUrls.filter((url) =>
+        url.endsWith('/pulls/42'),
+      );
+      expect(pullRequestReads).toHaveLength(2);
+    });
+
+    it('reports unknown mergeability rather than looping when GitHub never settles it', async () => {
+      const requestedUrls = mockGitHubRest([openPullRequestBody(null)]);
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const status = await repository.getOpenPullRequestCiStatus(prUrl);
+
+      expect(status?.mergeable).toBe('UNKNOWN');
+      expect(status?.isConflicted).toBe(false);
+      const pullRequestReads = requestedUrls.filter((url) =>
+        url.endsWith('/pulls/42'),
+      );
+      expect(pullRequestReads).toHaveLength(3);
+    });
+
+    it('returns null for a pull request that is no longer open', async () => {
+      mockGitHubRest([
+        {
+          html_url: prUrl,
+          state: 'closed',
+          draft: false,
+          mergeable: null,
+          head: { ref: 'feature/x', sha: 'sha-1' },
+          base: { ref: 'main' },
+        },
+      ]);
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+
+      expect(await repository.getOpenPullRequestCiStatus(prUrl)).toBeNull();
+    });
+
+    it('returns null for a url that is not a pull request', async () => {
+      const fetchSpy = jest.spyOn(global, 'fetch');
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+
+      expect(
+        await repository.getOpenPullRequestCiStatus(
+          'https://github.com/HiromiShikata/test-repository/issues/42',
+        ),
+      ).toBeNull();
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+  });
+
   const createApiV3CheerioRestIssueRepository = () => {
     const apiV3IssueRepository = mock<ApiV3IssueRepository>();
     const restIssueRepository = mock<RestIssueRepository>();