github-issue-tower-defence-management 2.19.1 → 2.19.3

package/src/adapter/repositories/GoogleSpreadsheetRepository.integration.test.ts

@@ -1,265 +0,0 @@
-import dotenv from 'dotenv';
-import { google } from 'googleapis';
-import { GoogleSpreadsheetRepository } from './GoogleSpreadsheetRepository';
-import { LocalStorageRepository } from './LocalStorageRepository';
-
-dotenv.config();
-
-const GOOGLE_SERVICE_ACCOUNT_KEY = process.env.GOOGLE_SERVICE_ACCOUNT_KEY;
-
-const integrationTestIsRequired =
-  process.env.GOOGLE_SHEETS_INTEGRATION_REQUIRED === 'true';
-
-const credentialIsMissingWhileRequired =
-  integrationTestIsRequired && !GOOGLE_SERVICE_ACCOUNT_KEY;
-
-describe('GoogleSpreadsheetRepository integration test credential', () => {
-  test('is available whenever these integration tests are required to run', () => {
-    expect(
-      credentialIsMissingWhileRequired
-        ? 'GOOGLE_SERVICE_ACCOUNT_KEY is absent while GOOGLE_SHEETS_INTEGRATION_REQUIRED is true, so the Google Sheets integration tests would silently skip and prove nothing'
-        : 'the Google Sheets integration tests either hold their credential or are not required in this context',
-    ).toBe(
-      'the Google Sheets integration tests either hold their credential or are not required in this context',
-    );
-  });
-});
-
-const describeWhenCredentials =
-  GOOGLE_SERVICE_ACCOUNT_KEY && integrationTestIsRequired
-    ? describe
-    : describe.skip;
-
-describeWhenCredentials('GoogleSpreadsheetRepository integration tests', () => {
-  jest.setTimeout(60 * 1000);
-  jest.retryTimes(3, { logErrorsBeforeRetry: true });
-
-  const localStorageRepository = new LocalStorageRepository();
-  const spreadsheetId = '1N_3y0y46v5tHbra5YSm6PldflcsF1bkfeWDdQ3MRuXM';
-  const spreadsheetUrl = `https://docs.google.com/spreadsheets/d/${spreadsheetId}/edit?gid=0#gid=0`;
-  const repository = new GoogleSpreadsheetRepository(
-    localStorageRepository,
-    GOOGLE_SERVICE_ACCOUNT_KEY,
-  );
-
-  const scratchSheetNamePrefix = 'IntegrationScratch_';
-  const scratchSheetName = `${scratchSheetNamePrefix}${Date.now()}_${process.pid}`;
-  const abandonedScratchSheetAgeMilliseconds = 2 * 60 * 60 * 1000;
-  const rawSheetsClientKeyFile =
-    './tmp/integration-test-service-account-key.json';
-
-  const createRawSheetsClient = () => {
-    if (!GOOGLE_SERVICE_ACCOUNT_KEY) {
-      throw new Error(
-        'GOOGLE_SERVICE_ACCOUNT_KEY is required to run the Google Sheets integration tests',
-      );
-    }
-    localStorageRepository.write(
-      rawSheetsClientKeyFile,
-      GOOGLE_SERVICE_ACCOUNT_KEY,
-    );
-    const auth = new google.auth.GoogleAuth({
-      keyFile: rawSheetsClientKeyFile,
-      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
-    });
-    return google.sheets({ version: 'v4', auth });
-  };
-
-  const listSheetTitles = async (): Promise<string[]> => {
-    const response = await createRawSheetsClient().spreadsheets.get({
-      spreadsheetId,
-    });
-    return (response.data.sheets ?? [])
-      .map((sheet) => sheet.properties?.title)
-      .filter((title): title is string => typeof title === 'string');
-  };
-
-  const deleteSheetsByTitle = async (titles: string[]): Promise<void> => {
-    if (titles.length === 0) {
-      return;
-    }
-    const sheetsClient = createRawSheetsClient();
-    const response = await sheetsClient.spreadsheets.get({ spreadsheetId });
-    const sheetIds = (response.data.sheets ?? [])
-      .filter((sheet) => {
-        const title = sheet.properties?.title;
-        return typeof title === 'string' && titles.includes(title);
-      })
-      .map((sheet) => sheet.properties?.sheetId)
-      .filter((sheetId): sheetId is number => typeof sheetId === 'number');
-    if (sheetIds.length === 0) {
-      return;
-    }
-    await sheetsClient.spreadsheets.batchUpdate({
-      spreadsheetId,
-      requestBody: {
-        requests: sheetIds.map((sheetId) => ({ deleteSheet: { sheetId } })),
-      },
-    });
-  };
-
-  const findAbandonedScratchSheetTitles = async (): Promise<string[]> => {
-    const titles = await listSheetTitles();
-    return titles
-      .filter((title) => title.startsWith(scratchSheetNamePrefix))
-      .filter((title) => title !== scratchSheetName)
-      .filter((title) => {
-        const createdAtMilliseconds = Number(
-          title.slice(scratchSheetNamePrefix.length).split('_')[0],
-        );
-        return (
-          Number.isFinite(createdAtMilliseconds) &&
-          Date.now() - createdAtMilliseconds >
-            abandonedScratchSheetAgeMilliseconds
-        );
-      });
-  };
-
-  beforeEach(async () => {
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-  });
-
-  afterAll(async () => {
-    const abandonedTitles = await findAbandonedScratchSheetTitles();
-    await deleteSheetsByTitle([scratchSheetName, ...abandonedTitles]);
-  });
-
-  describe('getSpreadsheetId', () => {
-    test('extracts the spreadsheet id from the spreadsheet url', () => {
-      expect(repository.getSpreadsheetId(spreadsheetUrl)).toBe(spreadsheetId);
-    });
-  });
-
-  describe('getSheet', () => {
-    const testCases: [string, string[][] | null][] = [
-      ['SheetUndefined', null],
-      ['SheetSingleCell', [['test']]],
-      [
-        'SheetMultipleRows',
-        [
-          ['1', '2'],
-          ['3', '4'],
-        ],
-      ],
-    ];
-
-    test.each(testCases)(
-      'gets sheet %s',
-      async (sheetName: string, expected: string[][] | null) => {
-        const result = await repository.getSheet(spreadsheetUrl, sheetName);
-        expect(result).toEqual(expected);
-      },
-    );
-
-    test('returns null for non-existent sheet', async () => {
-      const result = await repository.getSheet(
-        spreadsheetUrl,
-        'NonExistentSheet',
-      );
-      expect(result).toBeNull();
-    });
-
-    test('rejects with the Google Sheets not-found status when the spreadsheet does not exist', async () => {
-      const missingSpreadsheetId =
-        '1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
-      const missingSpreadsheetUrl = `https://docs.google.com/spreadsheets/d/${missingSpreadsheetId}/edit`;
-
-      await expect(
-        repository.getSheet(missingSpreadsheetUrl, 'Sheet1'),
-      ).rejects.toMatchObject({ status: 404 });
-    });
-  });
-
-  describe('createNewSheetIfNotExists', () => {
-    test('creates the sheet and stays idempotent on a second call', async () => {
-      await deleteSheetsByTitle([scratchSheetName]);
-      expect(await listSheetTitles()).not.toContain(scratchSheetName);
-
-      await repository.createNewSheetIfNotExists(
-        spreadsheetUrl,
-        scratchSheetName,
-      );
-      expect(await listSheetTitles()).toContain(scratchSheetName);
-      expect(
-        await repository.getSheet(spreadsheetUrl, scratchSheetName),
-      ).toBeNull();
-
-      await repository.createNewSheetIfNotExists(
-        spreadsheetUrl,
-        scratchSheetName,
-      );
-      const titlesAfterSecondCall = await listSheetTitles();
-      expect(
-        titlesAfterSecondCall.filter((title) => title === scratchSheetName)
-          .length,
-      ).toBe(1);
-    });
-  });
-
-  describe('appendSheetValues', () => {
-    test('appends rows to a sheet it creates and keeps the earlier rows', async () => {
-      await deleteSheetsByTitle([scratchSheetName]);
-
-      await repository.appendSheetValues(spreadsheetUrl, scratchSheetName, [
-        ['firstRowFirstColumn', 'firstRowSecondColumn'],
-      ]);
-      expect(
-        await repository.getSheet(spreadsheetUrl, scratchSheetName),
-      ).toEqual([['firstRowFirstColumn', 'firstRowSecondColumn']]);
-
-      await repository.appendSheetValues(spreadsheetUrl, scratchSheetName, [
-        ['secondRowFirstColumn', 'secondRowSecondColumn'],
-        ['thirdRowFirstColumn', 'thirdRowSecondColumn'],
-      ]);
-      expect(
-        await repository.getSheet(spreadsheetUrl, scratchSheetName),
-      ).toEqual([
-        ['firstRowFirstColumn', 'firstRowSecondColumn'],
-        ['secondRowFirstColumn', 'secondRowSecondColumn'],
-        ['thirdRowFirstColumn', 'thirdRowSecondColumn'],
-      ]);
-    });
-  });
-
-  describe('updateCell', () => {
-    test('creates the sheet when missing, writes a cell, and overwrites it', async () => {
-      await deleteSheetsByTitle([scratchSheetName]);
-
-      await repository.updateCell(
-        spreadsheetUrl,
-        scratchSheetName,
-        0,
-        0,
-        'firstValue',
-      );
-      expect(
-        await repository.getSheet(spreadsheetUrl, scratchSheetName),
-      ).toEqual([['firstValue']]);
-
-      await repository.updateCell(
-        spreadsheetUrl,
-        scratchSheetName,
-        0,
-        0,
-        'updatedValue',
-      );
-      expect(
-        await repository.getSheet(spreadsheetUrl, scratchSheetName),
-      ).toEqual([['updatedValue']]);
-
-      await repository.updateCell(
-        spreadsheetUrl,
-        scratchSheetName,
-        2,
-        2,
-        'thirdRowThirdColumn',
-      );
-      const sheet = await repository.getSheet(spreadsheetUrl, scratchSheetName);
-      if (!sheet) {
-        throw new Error('Sheet not found');
-      }
-      expect(sheet[0][0]).toBe('updatedValue');
-      expect(sheet[2][2]).toBe('thirdRowThirdColumn');
-    });
-  });
-});

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

@@ -1,431 +0,0 @@
-import { GoogleSpreadsheetRepository } from './GoogleSpreadsheetRepository';
-import { describe, test, expect, jest, beforeEach } from '@jest/globals';
-import { LocalStorageRepository } from './LocalStorageRepository';
-
-type SpreadsheetGetResponse = {
-  status: number;
-  data: {
-    sheets?: Array<{
-      properties?: { title?: string | null } | null;
-    }> | null;
-  };
-};
-
-type ValuesGetResponse = {
-  status: number;
-  data: { values?: unknown[][] | null };
-};
-
-type SimpleResponse = { status: number; data: unknown };
-
-describe('GoogleSpreadsheetRepository', () => {
-  const localStorageRepository = new LocalStorageRepository();
-  const spreadsheetUrl =
-    'https://docs.google.com/spreadsheets/d/1N_3y0y46v5tHbra5YSm6PldflcsF1bkfeWDdQ3MRuXM/edit?gid=0#gid=0';
-
-  const mockSpreadsheetsGet =
-    jest.fn<
-      (params: { spreadsheetId: string }) => Promise<SpreadsheetGetResponse>
-    >();
-  const mockSpreadsheetsValuesGet =
-    jest.fn<
-      (params: {
-        spreadsheetId: string;
-        range: string;
-      }) => Promise<ValuesGetResponse>
-    >();
-  const mockSpreadsheetsValuesUpdate =
-    jest.fn<
-      (params: {
-        spreadsheetId: string;
-        range: string;
-        valueInputOption: string;
-        requestBody: { values: string[][] };
-      }) => Promise<SimpleResponse>
-    >();
-  const mockSpreadsheetsValuesAppend =
-    jest.fn<
-      (params: {
-        spreadsheetId: string;
-        range: string;
-        valueInputOption: string;
-        requestBody: { values: string[][] };
-      }) => Promise<SimpleResponse>
-    >();
-  const mockSpreadsheetsBatchUpdate = jest.fn<
-    (params: {
-      spreadsheetId: string;
-      requestBody: {
-        requests: Array<{ addSheet?: { properties?: { title?: string } } }>;
-      };
-    }) => Promise<SimpleResponse>
-  >();
-
-  const mockSheetsClient = {
-    spreadsheets: {
-      get: mockSpreadsheetsGet,
-      values: {
-        get: mockSpreadsheetsValuesGet,
-        update: mockSpreadsheetsValuesUpdate,
-        append: mockSpreadsheetsValuesAppend,
-      },
-      batchUpdate: mockSpreadsheetsBatchUpdate,
-    },
-  };
-
-  const repository = new GoogleSpreadsheetRepository(
-    localStorageRepository,
-    'dummy-service-account-key',
-    () => mockSheetsClient,
-  );
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('getSpreadsheetId', () => {
-    const testCases: [string, string][] = [
-      [
-        'https://docs.google.com/spreadsheets/d/1234567890abcdef/edit#gid=0',
-        '1234567890abcdef',
-      ],
-      [
-        'https://docs.google.com/spreadsheets/d/abcdef1234567890/edit',
-        'abcdef1234567890',
-      ],
-    ];
-
-    test.each(testCases)(
-      'given %s returns %s',
-      (input: string, expected: string) => {
-        expect(repository.getSpreadsheetId(input)).toBe(expected);
-      },
-    );
-  });
-
-  describe('getSheet', () => {
-    test('returns null when sheet is not in spreadsheet', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: { sheets: [] },
-      });
-
-      const result = await repository.getSheet(
-        spreadsheetUrl,
-        'NonExistentSheet',
-      );
-
-      expect(result).toBeNull();
-    });
-
-    test('returns null when sheet name does not match', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: {
-          sheets: [{ properties: { title: 'OtherSheet' } }],
-        },
-      });
-
-      const result = await repository.getSheet(
-        spreadsheetUrl,
-        'SheetUndefined',
-      );
-
-      expect(result).toBeNull();
-    });
-
-    test('returns single cell value', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: {
-          sheets: [{ properties: { title: 'SheetSingleCell' } }],
-        },
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: { values: [['test']] },
-      });
-
-      const result = await repository.getSheet(
-        spreadsheetUrl,
-        'SheetSingleCell',
-      );
-
-      expect(result).toEqual([['test']]);
-    });
-
-    test('returns multiple rows', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: {
-          sheets: [{ properties: { title: 'SheetMultipleRows' } }],
-        },
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: {
-          values: [
-            ['1', '2'],
-            ['3', '4'],
-          ],
-        },
-      });
-
-      const result = await repository.getSheet(
-        spreadsheetUrl,
-        'SheetMultipleRows',
-      );
-
-      expect(result).toEqual([
-        ['1', '2'],
-        ['3', '4'],
-      ]);
-    });
-
-    test('returns null when sheet has no values', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: {
-          sheets: [{ properties: { title: 'EmptySheet' } }],
-        },
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-
-      const result = await repository.getSheet(spreadsheetUrl, 'EmptySheet');
-
-      expect(result).toBeNull();
-    });
-
-    test('converts non-string cell values to strings', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: {
-          sheets: [{ properties: { title: 'MixedTypes' } }],
-        },
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: { values: [[1, true, 'text']] },
-      });
-
-      const result = await repository.getSheet(spreadsheetUrl, 'MixedTypes');
-
-      expect(result).toEqual([['1', 'true', 'text']]);
-    });
-
-    test('retries once after a quota error and returns the value on success', async () => {
-      mockSpreadsheetsGet
-        .mockRejectedValueOnce(
-          new Error('Quota exceeded for quota metric Read requests'),
-        )
-        .mockResolvedValueOnce({
-          status: 200,
-          data: {
-            sheets: [{ properties: { title: 'RetrySheet' } }],
-          },
-        });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: { values: [['retried']] },
-      });
-      const repositoryWithFastSleep = new GoogleSpreadsheetRepository(
-        localStorageRepository,
-        'dummy-service-account-key',
-        () => mockSheetsClient,
-        () => Promise.resolve(),
-      );
-
-      const result = await repositoryWithFastSleep.getSheet(
-        spreadsheetUrl,
-        'RetrySheet',
-      );
-
-      expect(result).toEqual([['retried']]);
-      expect(mockSpreadsheetsGet).toHaveBeenCalledTimes(2);
-    });
-
-    test('throws after exhausting all retries', async () => {
-      mockSpreadsheetsGet.mockRejectedValue(
-        new Error('Quota exceeded for quota metric Read requests'),
-      );
-      const repositoryWithFastSleep = new GoogleSpreadsheetRepository(
-        localStorageRepository,
-        'dummy-service-account-key',
-        () => mockSheetsClient,
-        () => Promise.resolve(),
-      );
-
-      await expect(
-        repositoryWithFastSleep.getSheet(spreadsheetUrl, 'AnySheet'),
-      ).rejects.toThrow('Quota exceeded');
-    });
-  });
-
-  describe('updateCell', () => {
-    beforeEach(() => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: {
-          sheets: [{ properties: { title: 'Sheet1' } }],
-        },
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: { values: [['existing']] },
-      });
-      mockSpreadsheetsValuesUpdate.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-    });
-
-    const testCases: [string, number, number, string, string][] = [
-      ['Sheet1', 0, 0, 'First Value', 'Sheet1!A1'],
-      ['Sheet1', 0, 0, 'Updated Value', 'Sheet1!A1'],
-      ['Sheet1', 1, 1, '123', 'Sheet1!B2'],
-      ['Sheet1', 2, 2, 'Test', 'Sheet1!C3'],
-    ];
-
-    test.each(testCases)(
-      'updates cell in sheet %s at row %d col %d with value %s using range %s',
-      async (sheetName, row, col, value, expectedRange) => {
-        await repository.updateCell(spreadsheetUrl, sheetName, row, col, value);
-
-        expect(mockSpreadsheetsValuesUpdate).toHaveBeenCalledWith(
-          expect.objectContaining({
-            range: expectedRange,
-            valueInputOption: 'RAW',
-            requestBody: { values: [[value]] },
-          }),
-        );
-      },
-    );
-  });
-
-  describe('appendSheetValues', () => {
-    test('appends to existing sheet starting after last row', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: {
-          sheets: [{ properties: { title: 'AppendTest' } }],
-        },
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: { values: [['Row1'], ['Row2']] },
-      });
-      mockSpreadsheetsValuesAppend.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-
-      await repository.appendSheetValues(spreadsheetUrl, 'AppendTest', [
-        ['NewRow'],
-      ]);
-
-      expect(mockSpreadsheetsValuesAppend).toHaveBeenCalledWith(
-        expect.objectContaining({
-          range: 'AppendTest!A3:A',
-          valueInputOption: 'RAW',
-          requestBody: { values: [['NewRow']] },
-        }),
-      );
-    });
-
-    test('appends multiple rows with correct values', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: {
-          sheets: [{ properties: { title: 'AppendTest' } }],
-        },
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: { values: [['Existing']] },
-      });
-      mockSpreadsheetsValuesAppend.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-
-      const newValues = [
-        ['Row1Col1', 'Row1Col2'],
-        ['Row2Col1', 'Row2Col2'],
-      ];
-      await repository.appendSheetValues(
-        spreadsheetUrl,
-        'AppendTest',
-        newValues,
-      );
-
-      expect(mockSpreadsheetsValuesAppend).toHaveBeenCalledWith(
-        expect.objectContaining({
-          requestBody: { values: newValues },
-        }),
-      );
-    });
-
-    test('does not recreate an existing sheet that holds no values', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: { sheets: [{ properties: { title: 'EmptyExistingSheet' } }] },
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-      mockSpreadsheetsValuesAppend.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-
-      await repository.appendSheetValues(spreadsheetUrl, 'EmptyExistingSheet', [
-        ['Row'],
-      ]);
-
-      expect(mockSpreadsheetsBatchUpdate).not.toHaveBeenCalled();
-      expect(mockSpreadsheetsValuesAppend).toHaveBeenCalledWith(
-        expect.objectContaining({
-          range: 'EmptyExistingSheet!A1:A',
-        }),
-      );
-    });
-
-    test('creates new sheet via batchUpdate when sheet does not exist', async () => {
-      mockSpreadsheetsGet.mockResolvedValue({
-        status: 200,
-        data: { sheets: [] },
-      });
-      mockSpreadsheetsBatchUpdate.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-      mockSpreadsheetsValuesGet.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-      mockSpreadsheetsValuesAppend.mockResolvedValue({
-        status: 200,
-        data: {},
-      });
-
-      await repository.appendSheetValues(spreadsheetUrl, 'NewSheet', [['Row']]);
-
-      expect(mockSpreadsheetsBatchUpdate).toHaveBeenCalledWith(
-        expect.objectContaining({
-          requestBody: {
-            requests: [{ addSheet: { properties: { title: 'NewSheet' } } }],
-          },
-        }),
-      );
-      expect(mockSpreadsheetsValuesAppend).toHaveBeenCalledWith(
-        expect.objectContaining({
-          range: 'NewSheet!A1:A',
-        }),
-      );
-    });
-  });
-});