gogcli-mcp 2.28.0 → 2.29.0

package/tests/tools/utils.test.ts

@@ -123,6 +123,147 @@ describe('runOrDiagnose', () => {
     expect(parsed.internalDateDisplay).toBeDefined();
   });
 
+  // Formatting whitespace is roughly a fifth of a large gog response and
+  // carries no information: gog pretty-prints its --json output, and nothing
+  // downstream reads the indent. Measured at 18.6% of a 19 KB `drive ls`.
+  it('minifies gog\'s pretty-printed JSON on the normal path', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{\n  "a": 1,\n  "b": [\n    2,\n    3\n  ]\n}');
+    const result = await runOrDiagnose(['drive', 'ls'], {});
+    expect(result.content[0].text).toBe('{"a":1,"b":[2,3]}');
+  });
+
+  // Only FORMATTING whitespace goes. Whitespace inside a value is content —
+  // the blank line between paragraphs of a mail body — and JSON.stringify
+  // leaves every byte of it alone. A regex over the serialised text would
+  // corrupt exactly the payloads this is meant to shrink.
+  it('preserves whitespace INSIDE string values', async () => {
+    const body = 'Hi,\n\n  indented quote\n\nthanks';
+    vi.mocked(runner.run).mockResolvedValue(JSON.stringify({ body }, null, 2));
+    const result = await runOrDiagnose(['gmail', 'get'], {});
+    expect(JSON.parse(result.content[0].text as string).body).toBe(body);
+  });
+
+  // ofw-mcp emits paging state before its data array so a truncated read still
+  // sees it; the same reasoning applies to gog's nextPageToken. JSON.stringify
+  // preserves insertion order, so minifying must not reorder anything.
+  it('preserves key order', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{\n  "nextPageToken": "t",\n  "files": []\n}');
+    const result = await runOrDiagnose(['drive', 'ls'], {});
+    expect(result.content[0].text).toBe('{"nextPageToken":"t","files":[]}');
+  });
+
+  // gog does not always answer in JSON — `gog auth list` is plain text, and an
+  // empty body is legal. Minification must pass anything unparseable through
+  // untouched rather than mangling it or throwing.
+  it('passes non-JSON output through untouched', async () => {
+    for (const text of ['user@gmail.com\nother@gmail.com', '', '   ', 'not json {']) {
+      vi.mocked(runner.run).mockResolvedValue(text);
+      const result = await runOrDiagnose(['auth', 'list'], {});
+      expect(result.content[0].text).toBe(text);
+    }
+  });
+
+  // Brace-prefixed but unparseable — a truncated response from a killed gog, or
+  // a JSON prelude followed by garbage. It passes the `^[[{]` guard and then
+  // fails JSON.parse, and the only safe answer is the original bytes: a caller
+  // debugging a malformed payload needs to see what actually arrived.
+  //
+  // This path IS reachable through other suites today (gog_docs_structure feeds
+  // exactly this shape), but incidental coverage is not the same as a pinned
+  // behaviour — change that unrelated fixture and this branch goes dark, and
+  // the failure surfaces on whatever PR touched the fixture.
+  it('passes brace-prefixed but unparseable output through untouched', async () => {
+    for (const text of ['{"truncated": ', '[{"a":1},', '{not: json}']) {
+      vi.mocked(runner.run).mockResolvedValue(text);
+      const result = await runOrDiagnose(['drive', 'ls'], {});
+      expect(result.content[0].text).toBe(text);
+      expect(result.isError).toBeUndefined();
+    }
+  });
+
+  // The lossless dumps are the rung a person reaches for when a payload is not
+  // what they expected, and indentation is most of what makes an unfamiliar
+  // shape legible — the same asymmetry mcp-utils' viewResult applies to `raw`.
+  it('does NOT minify a lossless response', async () => {
+    const raw = '{\n  "id": "m1"\n}';
+    vi.mocked(runner.run).mockResolvedValue(raw);
+    const result = await runOrDiagnose(['gmail', 'raw', 'm1'], { lossless: true });
+    expect(result.content[0].text).toBe(raw);
+  });
+
+  // A Google field mask is applied UPSTREAM, inside the API, so a mask this
+  // wrapper gets wrong is a hard 400 rather than a thin record. That makes the
+  // fallback the thing that keeps compact-by-default survivable: the same role
+  // mcp-utils' projectOrRaw plays for a projection done locally.
+  it('applies a compact field mask when one is given', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'nextPageToken,files(id)' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'ls', '--fields=nextPageToken,files(id)'],
+      expect.objectContaining({ fieldsMask: 'nextPageToken,files(id)' }),
+    );
+  });
+
+  it('retries UNPROJECTED when Google rejects the mask', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('Google API error (400 invalidParameter): Invalid field selection id'))
+      .mockResolvedValueOnce('{"files":[{"id":"f1"}]}');
+    const result = await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'files(bogus)' });
+    expect(runner.run).toHaveBeenNthCalledWith(1, ['drive', 'ls', '--fields=files(bogus)'], expect.anything());
+    expect(runner.run).toHaveBeenNthCalledWith(2, ['drive', 'ls'], expect.anything());
+    // The caller gets the whole payload, not an error: a projection that trips
+    // returns everything rather than taking the tool call down.
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toBe('{"files":[{"id":"f1"}]}');
+  });
+
+  // The fallback must not swallow real failures — a missing file is not a bad
+  // mask, and retrying it would just spend a second call to fail identically.
+  it('does NOT retry an error that is not a rejected mask', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('File not found'))
+      .mockResolvedValueOnce('user@gmail.com');
+    const result = await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'files(id)' });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenNthCalledWith(2, ['drive', 'ls'], expect.anything());
+  });
+
+  // The second compact mechanism. `--fields` is a projection Google performs;
+  // this one is performed here, for the tools whose gog subcommand accepts no
+  // mask at all. Both surface through the same `view` vocabulary.
+  it('strips media keys when asked, and minifies the result', async () => {
+    vi.mocked(runner.run).mockResolvedValue(
+      '{\n  "id": "f1",\n  "thumbnailLink": "https://lh3.googleusercontent.com/x=s220",\n  "webViewLink": "https://docs.google.com/d/f1"\n}',
+    );
+    const result = await runOrDiagnose(['drive', 'get', 'f1'], { stripMedia: true });
+    expect(result.content[0].text).toBe('{"id":"f1","webViewLink":"https://docs.google.com/d/f1"}');
+  });
+
+  // webViewLink is the one URL a caller acts on and it sits in the same object
+  // as thumbnailLink. Stripping it would empty the response of the useful half.
+  it('keeps webViewLink and hasThumbnail while stripping the thumbnail', async () => {
+    vi.mocked(runner.run).mockResolvedValue(
+      JSON.stringify({ files: [{ id: 'f1', hasThumbnail: false, thumbnailLink: 'https://x/y=s220', webViewLink: 'https://docs/f1' }] }),
+    );
+    const result = await runOrDiagnose(['drive', 'search', 'q'], { stripMedia: true });
+    const parsed = JSON.parse(result.content[0].text as string);
+    expect(parsed.files[0]).toEqual({ id: 'f1', hasThumbnail: false, webViewLink: 'https://docs/f1' });
+  });
+
+  it('does not strip media unless asked', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"thumbnailLink":"https://x/y=s220"}');
+    const result = await runOrDiagnose(['drive', 'get', 'f1'], {});
+    expect(result.content[0].text).toBe('{"thumbnailLink":"https://x/y=s220"}');
+  });
+
+  // Non-JSON must survive the strip path exactly as it survives minification —
+  // the guard is shared, so a regression here would be silent.
+  it('passes non-JSON through untouched even when stripping is on', async () => {
+    vi.mocked(runner.run).mockResolvedValue('user@gmail.com');
+    const result = await runOrDiagnose(['auth', 'list'], { stripMedia: true });
+    expect(result.content[0].text).toBe('user@gmail.com');
+  });
+
   it('appends auth list on non-auth failure', async () => {
     vi.mocked(runner.run)
       .mockRejectedValueOnce(new Error('Doc not found'))