github-issue-tower-defence-management 1.146.0 → 1.146.2

package/src/adapter/entry-points/console/consoleDataDelivery.test.ts

@@ -9,31 +9,31 @@ import { recordDoneProjectItemId } from './consoleDoneStore';
 
 describe('parseConsoleDataRoute', () => {
   it('parses a list route', () => {
-    expect(parseConsoleDataRoute('/projects/umino/prs/list.json')).toEqual({
+    expect(parseConsoleDataRoute('/projects/acme/prs/list.json')).toEqual({
       kind: 'list',
-      pjcode: 'umino',
+      pjcode: 'acme',
       tab: 'prs',
     });
   });
 
   it('parses a list route for todo-by-human', () => {
     expect(
-      parseConsoleDataRoute('/projects/umino/todo-by-human/list.json'),
-    ).toEqual({ kind: 'list', pjcode: 'umino', tab: 'todo-by-human' });
+      parseConsoleDataRoute('/projects/acme/todo-by-human/list.json'),
+    ).toEqual({ kind: 'list', pjcode: 'acme', tab: 'todo-by-human' });
   });
 
   it('parses a list route for todo-by-agent', () => {
     expect(
-      parseConsoleDataRoute('/projects/umino/todo-by-agent/list.json'),
-    ).toEqual({ kind: 'list', pjcode: 'umino', tab: 'todo-by-agent' });
+      parseConsoleDataRoute('/projects/acme/todo-by-agent/list.json'),
+    ).toEqual({ kind: 'list', pjcode: 'acme', tab: 'todo-by-agent' });
   });
 
   it('parses a detail route', () => {
     expect(
-      parseConsoleDataRoute('/projects/umino/triage/detail/123.json'),
+      parseConsoleDataRoute('/projects/acme/triage/detail/123.json'),
     ).toEqual({
       kind: 'detail',
-      pjcode: 'umino',
+      pjcode: 'acme',
       tab: 'triage',
       key: '123.json',
     });
@@ -41,49 +41,47 @@ describe('parseConsoleDataRoute', () => {
 
   it('parses an in-tmux route', () => {
     expect(
-      parseConsoleDataRoute('/projects/umino/in-tmux-by-human/list.json'),
+      parseConsoleDataRoute('/projects/acme/in-tmux-by-human/list.json'),
     ).toEqual({
       kind: 'in-tmux',
-      pjcode: 'umino',
+      pjcode: 'acme',
       relativePath: 'list.json',
     });
   });
 
   it('parses a nested in-tmux route', () => {
     expect(
-      parseConsoleDataRoute('/projects/umino/in-tmux-by-human/sub/data.json'),
+      parseConsoleDataRoute('/projects/acme/in-tmux-by-human/sub/data.json'),
     ).toEqual({
       kind: 'in-tmux',
-      pjcode: 'umino',
+      pjcode: 'acme',
       relativePath: 'sub/data.json',
     });
   });
 
   it('rejects unknown tabs', () => {
     expect(
-      parseConsoleDataRoute('/projects/umino/unknown/list.json'),
+      parseConsoleDataRoute('/projects/acme/unknown/list.json'),
     ).toBeNull();
   });
 
   it('rejects a non-projects prefix', () => {
-    expect(parseConsoleDataRoute('/other/umino/prs/list.json')).toBeNull();
+    expect(parseConsoleDataRoute('/other/acme/prs/list.json')).toBeNull();
   });
 
   it('rejects dot segments in pjcode or tab', () => {
     expect(parseConsoleDataRoute('/projects/../prs/list.json')).toBeNull();
-    expect(parseConsoleDataRoute('/projects/umino/../list.json')).toBeNull();
+    expect(parseConsoleDataRoute('/projects/acme/../list.json')).toBeNull();
   });
 
   it('rejects a non-json detail key', () => {
     expect(
-      parseConsoleDataRoute('/projects/umino/prs/detail/123.txt'),
+      parseConsoleDataRoute('/projects/acme/prs/detail/123.txt'),
     ).toBeNull();
   });
 
   it('rejects an empty in-tmux relative path', () => {
-    expect(
-      parseConsoleDataRoute('/projects/umino/in-tmux-by-human'),
-    ).toBeNull();
+    expect(parseConsoleDataRoute('/projects/acme/in-tmux-by-human')).toBeNull();
   });
 });
 
@@ -107,72 +105,72 @@ describe('buildConsoleDataResponse', () => {
   it('returns 404 when the list file is absent', () => {
     const response = buildConsoleDataResponse(baseDir, {
       kind: 'list',
-      pjcode: 'umino',
+      pjcode: 'acme',
       tab: 'prs',
     });
     expect(response.statusCode).toBe(404);
   });
 
   it('serves a list file and applies the done exclusion', () => {
-    writeJson('umino/prs/list.json', {
-      pjcode: 'umino',
+    writeJson('acme/prs/list.json', {
+      pjcode: 'acme',
       items: [
         { projectItemId: 'PVTI_1', title: 'keep' },
         { projectItemId: 'PVTI_2', title: 'drop' },
       ],
     });
-    recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_2');
+    recordDoneProjectItemId(baseDir, 'acme', 'prs', 'PVTI_2');
     const response = buildConsoleDataResponse(baseDir, {
       kind: 'list',
-      pjcode: 'umino',
+      pjcode: 'acme',
       tab: 'prs',
     });
     expect(response.statusCode).toBe(200);
     const parsed: unknown = JSON.parse(response.body);
     expect(parsed).toEqual({
-      pjcode: 'umino',
+      pjcode: 'acme',
       items: [{ projectItemId: 'PVTI_1', title: 'keep' }],
     });
   });
 
   it('applies the done exclusion to the workflow-blocker list', () => {
-    writeJson('umino/workflow-blocker/list.json', {
-      pjcode: 'umino',
+    writeJson('acme/workflow-blocker/list.json', {
+      pjcode: 'acme',
       items: [
         { projectItemId: 'PVTI_1', title: 'keep' },
         { projectItemId: 'PVTI_2', title: 'processed blocker' },
       ],
     });
-    recordDoneProjectItemId(baseDir, 'umino', 'workflow-blocker', 'PVTI_2');
+    recordDoneProjectItemId(baseDir, 'acme', 'workflow-blocker', 'PVTI_2');
     const response = buildConsoleDataResponse(baseDir, {
       kind: 'list',
-      pjcode: 'umino',
+      pjcode: 'acme',
       tab: 'workflow-blocker',
     });
     expect(response.statusCode).toBe(200);
     const parsed: unknown = JSON.parse(response.body);
     expect(parsed).toEqual({
-      pjcode: 'umino',
+      pjcode: 'acme',
       items: [{ projectItemId: 'PVTI_1', title: 'keep' }],
     });
   });
 
   it('serves a list file without an items array unchanged', () => {
-    writeJson('umino/prs/list.json', { pjcode: 'umino' });
+    writeJson('acme/prs/list.json', { pjcode: 'acme' });
     const response = buildConsoleDataResponse(baseDir, {
       kind: 'list',
-      pjcode: 'umino',
+      pjcode: 'acme',
       tab: 'prs',
     });
     expect(response.statusCode).toBe(200);
-    expect(JSON.parse(response.body)).toEqual({ pjcode: 'umino' });
+    expect(JSON.parse(response.body)).toEqual({ pjcode: 'acme' });
   });
 
   it('serves a detail file without exclusion', () => {
-    writeJson('umino/triage/detail/123.json', { number: 123 });
+    writeJson('acme/triage/detail/123.json', { number: 123 });
     const response = buildConsoleDataResponse(baseDir, {
       kind: 'detail',
-      pjcode: 'umino',
+      pjcode: 'acme',
       tab: 'triage',
       key: '123.json',
     });
@@ -183,7 +181,7 @@ describe('buildConsoleDataResponse', () => {
   it('returns 404 when the detail file is absent', () => {
     const response = buildConsoleDataResponse(baseDir, {
       kind: 'detail',
-      pjcode: 'umino',
+      pjcode: 'acme',
       tab: 'triage',
       key: '404.json',
     });
@@ -191,10 +189,10 @@ describe('buildConsoleDataResponse', () => {
   });
 
   it('serves an in-tmux file', () => {
-    writeJson('umino/in-tmux-by-human/list.json', { items: [] });
+    writeJson('acme/in-tmux-by-human/list.json', { items: [] });
     const response = buildConsoleDataResponse(baseDir, {
       kind: 'in-tmux',
-      pjcode: 'umino',
+      pjcode: 'acme',
       relativePath: 'list.json',
     });
     expect(response.statusCode).toBe(200);
@@ -204,7 +202,7 @@ describe('buildConsoleDataResponse', () => {
   it('returns 404 when the in-tmux file is absent', () => {
     const response = buildConsoleDataResponse(baseDir, {
       kind: 'in-tmux',
-      pjcode: 'umino',
+      pjcode: 'acme',
       relativePath: 'missing.json',
     });
     expect(response.statusCode).toBe(404);

package/src/adapter/entry-points/console/consoleDoneStore.test.ts

@@ -25,48 +25,48 @@ describe('consoleDoneStore', () => {
 
   describe('doneFilePathForTab', () => {
     it('places the done file under pjcode/tab', () => {
-      expect(doneFilePathForTab(baseDir, 'umino', 'prs')).toBe(
-        path.join(baseDir, 'umino', 'prs', CONSOLE_DONE_FILE_NAME),
+      expect(doneFilePathForTab(baseDir, 'acme', 'prs')).toBe(
+        path.join(baseDir, 'acme', 'prs', CONSOLE_DONE_FILE_NAME),
       );
     });
   });
 
   describe('readDoneProjectItemIds', () => {
     it('returns an empty array when the file is absent', () => {
-      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([]);
+      expect(readDoneProjectItemIds(baseDir, 'acme', 'prs')).toEqual([]);
     });
 
     it('returns the persisted project item ids', () => {
-      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_1');
-      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_2');
-      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([
+      recordDoneProjectItemId(baseDir, 'acme', 'prs', 'PVTI_1');
+      recordDoneProjectItemId(baseDir, 'acme', 'prs', 'PVTI_2');
+      expect(readDoneProjectItemIds(baseDir, 'acme', 'prs')).toEqual([
         'PVTI_1',
         'PVTI_2',
       ]);
     });
 
     it('returns an empty array for malformed json', () => {
-      const filePath = doneFilePathForTab(baseDir, 'umino', 'prs');
+      const filePath = doneFilePathForTab(baseDir, 'acme', 'prs');
       fs.mkdirSync(path.dirname(filePath), { recursive: true });
       fs.writeFileSync(filePath, '{ not json');
-      expect(() => readDoneProjectItemIds(baseDir, 'umino', 'prs')).toThrow();
+      expect(() => readDoneProjectItemIds(baseDir, 'acme', 'prs')).toThrow();
     });
 
     it('returns an empty array when projectItemIds is not an array', () => {
-      const filePath = doneFilePathForTab(baseDir, 'umino', 'prs');
+      const filePath = doneFilePathForTab(baseDir, 'acme', 'prs');
       fs.mkdirSync(path.dirname(filePath), { recursive: true });
       fs.writeFileSync(filePath, JSON.stringify({ projectItemIds: 'x' }));
-      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([]);
+      expect(readDoneProjectItemIds(baseDir, 'acme', 'prs')).toEqual([]);
     });
 
     it('filters out non-string entries', () => {
-      const filePath = doneFilePathForTab(baseDir, 'umino', 'prs');
+      const filePath = doneFilePathForTab(baseDir, 'acme', 'prs');
       fs.mkdirSync(path.dirname(filePath), { recursive: true });
       fs.writeFileSync(
         filePath,
         JSON.stringify({ projectItemIds: ['PVTI_1', 1, null, ''] }),
       );
-      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([
+      expect(readDoneProjectItemIds(baseDir, 'acme', 'prs')).toEqual([
         'PVTI_1',
       ]);
     });
@@ -74,14 +74,14 @@ describe('consoleDoneStore', () => {
 
   describe('recordDoneProjectItemId', () => {
     it('does not record an empty id', () => {
-      recordDoneProjectItemId(baseDir, 'umino', 'prs', '');
-      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([]);
+      recordDoneProjectItemId(baseDir, 'acme', 'prs', '');
+      expect(readDoneProjectItemIds(baseDir, 'acme', 'prs')).toEqual([]);
     });
 
     it('does not duplicate an already recorded id', () => {
-      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_1');
-      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_1');
-      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([
+      recordDoneProjectItemId(baseDir, 'acme', 'prs', 'PVTI_1');
+      recordDoneProjectItemId(baseDir, 'acme', 'prs', 'PVTI_1');
+      expect(readDoneProjectItemIds(baseDir, 'acme', 'prs')).toEqual([
         'PVTI_1',
       ]);
     });
@@ -89,9 +89,9 @@ describe('consoleDoneStore', () => {
 
   describe('recordDoneProjectItemIdAcrossTabs', () => {
     it('records the id into every tab done file', () => {
-      recordDoneProjectItemIdAcrossTabs(baseDir, 'umino', 'PVTI_99');
+      recordDoneProjectItemIdAcrossTabs(baseDir, 'acme', 'PVTI_99');
       for (const tab of CONSOLE_DONE_TAB_NAMES) {
-        expect(readDoneProjectItemIds(baseDir, 'umino', tab)).toEqual([
+        expect(readDoneProjectItemIds(baseDir, 'acme', tab)).toEqual([
           'PVTI_99',
         ]);
       }
@@ -103,32 +103,32 @@ describe('consoleDoneStore', () => {
 
     it('includes the workflow-blocker tab so processed blockers are excluded', () => {
       expect(CONSOLE_DONE_TAB_NAMES).toContain('workflow-blocker');
-      recordDoneProjectItemIdAcrossTabs(baseDir, 'umino', 'PVTI_7');
+      recordDoneProjectItemIdAcrossTabs(baseDir, 'acme', 'PVTI_7');
       expect(
-        readDoneProjectItemIds(baseDir, 'umino', 'workflow-blocker'),
+        readDoneProjectItemIds(baseDir, 'acme', 'workflow-blocker'),
       ).toEqual(['PVTI_7']);
     });
   });
 
   describe('resetDoneProjectItemIds', () => {
     it('clears an accumulated done file to an empty record', () => {
-      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_1');
-      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_2');
-      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_3');
-      resetDoneProjectItemIds(baseDir, 'umino', 'prs');
-      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([]);
+      recordDoneProjectItemId(baseDir, 'acme', 'prs', 'PVTI_1');
+      recordDoneProjectItemId(baseDir, 'acme', 'prs', 'PVTI_2');
+      recordDoneProjectItemId(baseDir, 'acme', 'prs', 'PVTI_3');
+      resetDoneProjectItemIds(baseDir, 'acme', 'prs');
+      expect(readDoneProjectItemIds(baseDir, 'acme', 'prs')).toEqual([]);
     });
 
     it('writes an empty record when no done file exists yet', () => {
-      resetDoneProjectItemIds(baseDir, 'umino', 'prs');
-      const filePath = doneFilePathForTab(baseDir, 'umino', 'prs');
+      resetDoneProjectItemIds(baseDir, 'acme', 'prs');
+      const filePath = doneFilePathForTab(baseDir, 'acme', 'prs');
       const raw: unknown = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
       expect(raw).toEqual({ projectItemIds: [] });
     });
 
     it('does not leave a temp file behind', () => {
-      resetDoneProjectItemIds(baseDir, 'umino', 'prs');
-      const filePath = doneFilePathForTab(baseDir, 'umino', 'prs');
+      resetDoneProjectItemIds(baseDir, 'acme', 'prs');
+      const filePath = doneFilePathForTab(baseDir, 'acme', 'prs');
       expect(fs.existsSync(`${filePath}.tmp`)).toBe(false);
     });
   });
@@ -137,11 +137,11 @@ describe('consoleDoneStore', () => {
     it('clears the done file of every tab including in-tmux-by-human', () => {
       expect(CONSOLE_DONE_TAB_NAMES).toContain('in-tmux-by-human');
       for (const tab of CONSOLE_DONE_TAB_NAMES) {
-        recordDoneProjectItemId(baseDir, 'umino', tab, 'PVTI_1');
+        recordDoneProjectItemId(baseDir, 'acme', tab, 'PVTI_1');
       }
-      resetDoneProjectItemIdsAcrossTabs(baseDir, 'umino');
+      resetDoneProjectItemIdsAcrossTabs(baseDir, 'acme');
       for (const tab of CONSOLE_DONE_TAB_NAMES) {
-        expect(readDoneProjectItemIds(baseDir, 'umino', tab)).toEqual([]);
+        expect(readDoneProjectItemIds(baseDir, 'acme', tab)).toEqual([]);
       }
     });
   });

package/src/adapter/entry-points/console/consoleGithubTokenResolver.test.ts

@@ -0,0 +1,135 @@
+import {
+  createConsoleGithubTokenResolver,
+  createConsoleIssueRepositoryResolver,
+  extractRepositoryOwner,
+} from './consoleGithubTokenResolver';
+
+describe('createConsoleIssueRepositoryResolver', () => {
+  it('builds the issue repository from the token of the owner in the url', () => {
+    const resolve = createConsoleIssueRepositoryResolver<string>(
+      (repositoryOwner) => `token-of-${repositoryOwner}`,
+      (githubToken) => `repository-with-${githubToken}`,
+    );
+
+    expect(
+      resolve('https://github.com/meta-site/hr-audit-mock/issues/178'),
+    ).toBe('repository-with-token-of-meta-site');
+  });
+
+  it('throws when the repository owner cannot be read from the url', () => {
+    const resolve = createConsoleIssueRepositoryResolver<string>(
+      (repositoryOwner) => `token-of-${repositoryOwner}`,
+      (githubToken) => `repository-with-${githubToken}`,
+    );
+
+    expect(() => resolve('https://github.com/meta-site/hr-audit-mock')).toThrow(
+      'The repository owner cannot be read from the operated url: https://github.com/meta-site/hr-audit-mock',
+    );
+  });
+});
+
+describe('extractRepositoryOwner', () => {
+  it('should return the owner of an issue url', () => {
+    expect(
+      extractRepositoryOwner(
+        'https://github.com/meta-site/hr-audit-mock/issues/178',
+      ),
+    ).toBe('meta-site');
+  });
+
+  it('should return the owner of a pull request url', () => {
+    expect(
+      extractRepositoryOwner(
+        'https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/pull/1399',
+      ),
+    ).toBe('HiromiShikata');
+  });
+
+  it('should return null for a url that is not an issue or a pull request', () => {
+    expect(
+      extractRepositoryOwner('https://github.com/meta-site/hr-audit-mock'),
+    ).toBeNull();
+  });
+});
+
+describe('createConsoleGithubTokenResolver', () => {
+  it('should return the default token for an owner that has no token file configured', () => {
+    const resolve = createConsoleGithubTokenResolver(
+      'default-token',
+      null,
+      () => {
+        throw new Error('must not read any file');
+      },
+    );
+
+    expect(resolve('HiromiShikata')).toBe('default-token');
+  });
+
+  it('should return the token read from the file configured for that owner', () => {
+    const resolve = createConsoleGithubTokenResolver(
+      'default-token',
+      { 'meta-site': '/creds/meta-site-token.txt' },
+      (filePath) =>
+        filePath === '/creds/meta-site-token.txt'
+          ? 'fine-grained-token\n'
+          : (() => {
+              throw new Error(`unexpected file path: ${filePath}`);
+            })(),
+    );
+
+    expect(resolve('meta-site')).toBe('fine-grained-token');
+  });
+
+  it('should keep using the default token for the other owners when one owner has a token file', () => {
+    const resolve = createConsoleGithubTokenResolver(
+      'default-token',
+      { 'meta-site': '/creds/meta-site-token.txt' },
+      () => 'fine-grained-token',
+    );
+
+    expect(resolve('X-Mile')).toBe('default-token');
+  });
+
+  it('should read the token file only once per owner', () => {
+    let readCount = 0;
+    const resolve = createConsoleGithubTokenResolver(
+      'default-token',
+      { 'meta-site': '/creds/meta-site-token.txt' },
+      () => {
+        readCount += 1;
+        return 'fine-grained-token';
+      },
+    );
+
+    resolve('meta-site');
+    resolve('meta-site');
+
+    expect(readCount).toBe(1);
+  });
+
+  it('should throw when the configured token file contains no token', () => {
+    const resolve = createConsoleGithubTokenResolver(
+      'default-token',
+      { 'meta-site': '/creds/meta-site-token.txt' },
+      () => '  \n',
+    );
+
+    expect(() => resolve('meta-site')).toThrow(
+      'The GitHub token file configured for repository owner "meta-site" contains no token: /creds/meta-site-token.txt',
+    );
+  });
+
+  it('should surface the read failure when the configured token file cannot be read', () => {
+    const resolve = createConsoleGithubTokenResolver(
+      'default-token',
+      { 'meta-site': '/creds/meta-site-token.txt' },
+      () => {
+        throw new Error('ENOENT: no such file or directory');
+      },
+    );
+
+    expect(() => resolve('meta-site')).toThrow(
+      'ENOENT: no such file or directory',
+    );
+  });
+});

package/src/adapter/entry-points/console/consoleGithubTokenResolver.ts

@@ -0,0 +1,55 @@
+export type ConsoleGithubTokenResolver = (repositoryOwner: string) => string;
+
+export type GithubTokenFileReader = (filePath: string) => string;
+
+export const extractRepositoryOwner = (
+  issueOrPullRequestUrl: string,
+): string | null => {
+  const match = issueOrPullRequestUrl.match(
+    /^https:\/\/github\.com\/([A-Za-z0-9._-]+)\/[A-Za-z0-9._-]+\/(?:issues|pull)\/\d+/,
+  );
+  return match ? match[1] : null;
+};
+
+export const createConsoleIssueRepositoryResolver = <IssueRepositoryType>(
+  resolveGithubToken: ConsoleGithubTokenResolver,
+  buildIssueRepositoryForToken: (githubToken: string) => IssueRepositoryType,
+): ((issueOrPullRequestUrl: string) => IssueRepositoryType) => {
+  return (issueOrPullRequestUrl: string): IssueRepositoryType => {
+    const repositoryOwner = extractRepositoryOwner(issueOrPullRequestUrl);
+    if (repositoryOwner === null) {
+      throw new Error(
+        `The repository owner cannot be read from the operated url: ${issueOrPullRequestUrl}`,
+      );
+    }
+    return buildIssueRepositoryForToken(resolveGithubToken(repositoryOwner));
+  };
+};
+
+export const createConsoleGithubTokenResolver = (
+  defaultToken: string,
+  githubTokenFilePathByRepositoryOwner: Record<string, string> | null,
+  readTokenFile: GithubTokenFileReader,
+): ConsoleGithubTokenResolver => {
+  const resolvedTokenByRepositoryOwner = new Map<string, string>();
+  return (repositoryOwner: string): string => {
+    const alreadyResolved = resolvedTokenByRepositoryOwner.get(repositoryOwner);
+    if (alreadyResolved !== undefined) {
+      return alreadyResolved;
+    }
+    const filePath = githubTokenFilePathByRepositoryOwner
+      ? githubTokenFilePathByRepositoryOwner[repositoryOwner]
+      : undefined;
+    if (filePath === undefined) {
+      return defaultToken;
+    }
+    const token = readTokenFile(filePath).trim();
+    if (token.length === 0) {
+      throw new Error(
+        `The GitHub token file configured for repository owner "${repositoryOwner}" contains no token: ${filePath}`,
+      );
+    }
+    resolvedTokenByRepositoryOwner.set(repositoryOwner, token);
+    return token;
+  };
+};

package/src/adapter/entry-points/console/consoleItemUrlLookup.test.ts

@@ -15,7 +15,7 @@ describe('findConsoleItemUrl', () => {
   });
 
   const writeList = (tab: string, items: unknown): void => {
-    const dir = path.join(baseDir, 'umino', tab);
+    const dir = path.join(baseDir, 'acme', tab);
     fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(path.join(dir, 'list.json'), JSON.stringify({ items }));
   };
@@ -23,14 +23,14 @@ describe('findConsoleItemUrl', () => {
   it('returns the stored url when the requested url is listed in a tab', () => {
     writeList('prs', [{ url: 'https://github.com/o/r/issues/1' }]);
     expect(
-      findConsoleItemUrl(baseDir, 'umino', 'https://github.com/o/r/issues/1'),
+      findConsoleItemUrl(baseDir, 'acme', 'https://github.com/o/r/issues/1'),
     ).toBe('https://github.com/o/r/issues/1');
   });
 
   it('returns null when no tab lists the requested url', () => {
     writeList('prs', [{ url: 'https://github.com/o/r/issues/1' }]);
     expect(
-      findConsoleItemUrl(baseDir, 'umino', 'https://github.com/o/r/issues/2'),
+      findConsoleItemUrl(baseDir, 'acme', 'https://github.com/o/r/issues/2'),
     ).toBeNull();
   });
 
@@ -41,12 +41,12 @@ describe('findConsoleItemUrl', () => {
   });
 
   it('ignores a tab file that is not valid json', () => {
-    const dir = path.join(baseDir, 'umino', 'triage');
+    const dir = path.join(baseDir, 'acme', 'triage');
     fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(path.join(dir, 'list.json'), 'not json');
     writeList('prs', [{ url: 'https://github.com/o/r/issues/1' }]);
     expect(
-      findConsoleItemUrl(baseDir, 'umino', 'https://github.com/o/r/issues/1'),
+      findConsoleItemUrl(baseDir, 'acme', 'https://github.com/o/r/issues/1'),
     ).toBe('https://github.com/o/r/issues/1');
   });
 
@@ -57,7 +57,7 @@ describe('findConsoleItemUrl', () => {
       { url: 'https://github.com/o/r/pull/9' },
     ]);
     expect(
-      findConsoleItemUrl(baseDir, 'umino', 'https://github.com/o/r/pull/9'),
+      findConsoleItemUrl(baseDir, 'acme', 'https://github.com/o/r/pull/9'),
     ).toBe('https://github.com/o/r/pull/9');
   });
 });