github-issue-tower-defence-management 1.42.2 → 1.42.4

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

@@ -1,13 +1,56 @@
 import { GoogleSpreadsheetRepository } from './GoogleSpreadsheetRepository';
-import { describe, test, expect } from '@jest/globals';
+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 repository = new GoogleSpreadsheetRepository(localStorageRepository);
   const spreadsheetUrl =
     'https://docs.google.com/spreadsheets/d/1N_3y0y46v5tHbra5YSm6PldflcsF1bkfeWDdQ3MRuXM/edit?gid=0#gid=0';
 
+  const mockSpreadsheetsGet = jest.fn<() => Promise<SpreadsheetGetResponse>>();
+  const mockSpreadsheetsValuesGet = jest.fn<() => Promise<ValuesGetResponse>>();
+  const mockSpreadsheetsValuesUpdate = jest.fn<() => Promise<SimpleResponse>>();
+  const mockSpreadsheetsValuesAppend = jest.fn<() => Promise<SimpleResponse>>();
+  const mockSpreadsheetsBatchUpdate = jest.fn<() => 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][] = [
       [
@@ -29,96 +72,255 @@ describe('GoogleSpreadsheetRepository', () => {
   });
 
   describe('getSheet', () => {
-    const testCases: [string, string, string[][] | null][] = [
-      ['SheetUndefined', 'Undefined Sheet', null],
-      // ['SheetEmpty', 'Empty Sheet', []],
-      ['SheetSingleCell', 'Single Cell', [['test']]],
-      [
-        'SheetMultipleRows',
-        'Multiple Rows',
-        [
-          ['1', '2'],
-          ['3', '4'],
-        ],
-      ],
-    ];
+    test('returns null when sheet is not in spreadsheet', async () => {
+      mockSpreadsheetsGet.mockResolvedValue({
+        status: 200,
+        data: { sheets: [] },
+      });
 
-    test.each(testCases)(
-      'gets sheet %s with %s',
-      async (sheetName: string, _: 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('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']]);
+    });
   });
 
   describe('updateCell', () => {
-    const testCases: [string, number, number, string][] = [
-      ['Sheet1', 0, 0, 'First Value'],
-      ['Sheet1', 0, 0, 'Updated Value'],
-      ['Sheet1', 1, 1, '123'],
-      ['Sheet1', 2, 2, 'Test'],
+    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',
-      async (sheetName: string, row: number, col: number, value: string) => {
+      '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);
-        const result = await repository.getSheet(spreadsheetUrl, sheetName);
-        if (!result) {
-          throw new Error('Sheet not found');
-        }
-        expect(result[row][col]).toBe(value);
+
+        expect(mockSpreadsheetsValuesUpdate).toHaveBeenCalledWith(
+          expect.objectContaining({
+            range: expectedRange,
+            valueInputOption: 'RAW',
+            requestBody: { values: [[value]] },
+          }),
+        );
       },
     );
   });
 
   describe('appendSheetValues', () => {
-    const testCases: [string[][]][] = [
-      [[['Single Row']]],
-      [[['Multiple', 'Columns']]],
-      [
-        [
-          ['Row1Col1', 'Row1Col2'],
-          ['Row2Col1', 'Row2Col2'],
-        ],
-      ],
-    ];
+    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: {},
+      });
 
-    test.each(testCases)(
-      'appends values %j to sheet',
-      async (values: string[][]) => {
-        const sheetName = 'AppendTest';
-        const initialSheet = await repository.getSheet(
-          spreadsheetUrl,
-          sheetName,
-        );
-        const initialLength = initialSheet ? initialSheet.length : 0;
+      await repository.appendSheetValues(spreadsheetUrl, 'AppendTest', [
+        ['NewRow'],
+      ]);
 
-        await repository.appendSheetValues(spreadsheetUrl, sheetName, values);
+      expect(mockSpreadsheetsValuesAppend).toHaveBeenCalledWith(
+        expect.objectContaining({
+          range: 'AppendTest!A3:A',
+          valueInputOption: 'RAW',
+          requestBody: { values: [['NewRow']] },
+        }),
+      );
+    });
 
-        const updatedSheet = await repository.getSheet(
-          spreadsheetUrl,
-          sheetName,
-        );
-        expect(updatedSheet).not.toBeNull();
-        if (!updatedSheet) {
-          throw new Error('Sheet not found');
-        }
-        expect(updatedSheet.length).toBe(initialLength + values.length);
-
-        for (let i = 0; i < values.length; i++) {
-          expect(updatedSheet[initialLength + i]).toEqual(values[i]);
-        }
-      },
-    );
+    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('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',
+        }),
+      );
+    });
   });
 });

package/src/adapter/repositories/GoogleSpreadsheetRepository.ts

@@ -4,15 +4,93 @@ import { LocalStorageRepository } from './LocalStorageRepository';
 import dotenv from 'dotenv';
 dotenv.config();
 
+interface SheetsApiClient {
+  spreadsheets: {
+    get(params: { spreadsheetId: string }): Promise<{
+      status: number;
+      data: {
+        sheets?: Array<{
+          properties?: { title?: string | null } | null;
+        }> | null;
+      };
+    }>;
+    values: {
+      get(params: { spreadsheetId: string; range: string }): Promise<{
+        status: number;
+        data: { values?: unknown[][] | null };
+      }>;
+      update(params: {
+        spreadsheetId: string;
+        range: string;
+        valueInputOption: string;
+        requestBody: { values: string[][] };
+      }): Promise<{ status: number; data: unknown }>;
+      append(params: {
+        spreadsheetId: string;
+        range: string;
+        valueInputOption: string;
+        requestBody: { values: string[][] };
+      }): Promise<{ status: number; data: unknown }>;
+    };
+    batchUpdate(params: {
+      spreadsheetId: string;
+      requestBody: {
+        requests: Array<{ addSheet?: { properties?: { title?: string } } }>;
+      };
+    }): Promise<{ status: number; data: unknown }>;
+  };
+}
+
 export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
   keyFile = './tmp/service-account-key.json';
+  private readonly sheetsClient: SheetsApiClient;
 
   constructor(
     readonly localStorageRepository: LocalStorageRepository,
     serviceAccountKey: string = process.env.GOOGLE_SERVICE_ACCOUNT_KEY ||
       'dummy',
+    sheetsClientFactory?: () => SheetsApiClient,
   ) {
     this.localStorageRepository.write(this.keyFile, serviceAccountKey);
+    this.sheetsClient = sheetsClientFactory
+      ? sheetsClientFactory()
+      : (() => {
+          const auth = new google.auth.GoogleAuth({
+            keyFile: this.keyFile,
+            scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+          });
+          const googleSheets = google.sheets({ version: 'v4', auth });
+          return {
+            spreadsheets: {
+              get: (params: { spreadsheetId: string }) =>
+                googleSheets.spreadsheets.get(params),
+              values: {
+                get: (params: { spreadsheetId: string; range: string }) =>
+                  googleSheets.spreadsheets.values.get(params),
+                update: (params: {
+                  spreadsheetId: string;
+                  range: string;
+                  valueInputOption: string;
+                  requestBody: { values: string[][] };
+                }) => googleSheets.spreadsheets.values.update(params),
+                append: (params: {
+                  spreadsheetId: string;
+                  range: string;
+                  valueInputOption: string;
+                  requestBody: { values: string[][] };
+                }) => googleSheets.spreadsheets.values.append(params),
+              },
+              batchUpdate: (params: {
+                spreadsheetId: string;
+                requestBody: {
+                  requests: Array<{
+                    addSheet?: { properties?: { title?: string } };
+                  }>;
+                };
+              }) => googleSheets.spreadsheets.batchUpdate(params),
+            },
+          };
+        })();
   }
 
   getSpreadsheetId = (spreadsheetUrl: string): string => {
@@ -23,11 +101,7 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
     spreadsheetUrl: string,
     sheetName: string,
   ): Promise<string[][] | null> => {
-    const auth = new google.auth.GoogleAuth({
-      keyFile: this.keyFile,
-      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
-    });
-    const sheets = google.sheets({ version: 'v4', auth });
+    const sheets = this.sheetsClient;
     const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
     const responseSheet = await sheets.spreadsheets.get({
       spreadsheetId,
@@ -64,11 +138,7 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
     column: number,
     value: string,
   ): Promise<void> => {
-    const auth = new google.auth.GoogleAuth({
-      keyFile: this.keyFile,
-      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
-    });
-    const sheets = google.sheets({ version: 'v4', auth });
+    const sheets = this.sheetsClient;
     const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
     await this.createNewSheetIfNotExists(spreadsheetUrl, sheetName);
     const response = await sheets.spreadsheets.values.update({
@@ -89,11 +159,7 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
     spreadsheetUrl: string,
     sheetName: string,
   ): Promise<void> => {
-    const auth = new google.auth.GoogleAuth({
-      keyFile: this.keyFile,
-      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
-    });
-    const sheets = google.sheets({ version: 'v4', auth });
+    const sheets = this.sheetsClient;
     const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
     const sheet = await this.getSheet(spreadsheetUrl, sheetName);
     if (sheet !== null) {
@@ -125,11 +191,7 @@ export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
     sheetName: string,
     values: string[][],
   ): Promise<void> => {
-    const auth = new google.auth.GoogleAuth({
-      keyFile: this.keyFile,
-      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
-    });
-    const sheets = google.sheets({ version: 'v4', auth });
+    const sheets = this.sheetsClient;
     const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
     await this.createNewSheetIfNotExists(spreadsheetUrl, sheetName);
     const sheet = await this.getSheet(spreadsheetUrl, sheetName);