google-drive-mock 1.0.13 → 1.1.1

package/test/batch_insert_download.test.ts

@@ -0,0 +1,150 @@
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+describe('Batch Insert and Download Test', () => {
+    let config: TestConfig;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+    });
+
+    afterAll(() => {
+        if (config) config.stop();
+    });
+
+    // Helper from user request (adapted)
+    async function insertDocumentFiles<RxDocType>(
+        googleDriveOptions: { apiEndpoint: string, authToken: string },
+        init: { docsFolderId: string },
+        primaryPath: string,
+        docs: RxDocType[]
+    ) {
+        const boundary = "batch_" + Math.random().toString(16).slice(2);
+
+
+
+        const parts = docs.map((doc, i) => {
+            const id = (doc as Record<string, unknown>)[primaryPath] as string;
+            const body = JSON.stringify({
+                name: id + '.json',
+                mimeType: 'application/json',
+                parents: [init.docsFolderId],
+            });
+
+            return (
+                `--${boundary}\r\n` +
+                `Content-Type: application/http\r\n` +
+                `Content-ID: <item-${i}>\r\n\r\n` +
+                `POST /drive/v3/files HTTP/1.1\r\n` +
+                `Content-Type: application/json; charset=UTF-8\r\n\r\n` +
+                `${body}\r\n`
+            );
+        });
+        const batchBody = parts.join("") + `--${boundary}--`;
+        const res = await fetch(googleDriveOptions.apiEndpoint + "/batch/drive/v3", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${googleDriveOptions.authToken}`,
+                "Content-Type": `multipart/mixed; boundary=${boundary}`,
+            },
+            body: batchBody,
+        });
+
+
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`GDR13: Batch insert failed. Status: ${res.status}. Error: ${text}`);
+        }
+        const text = await res.text();
+        console.log('Batch Response:', text.substring(0, 1000)); // Log snippet
+        return text;
+    }
+
+    it('should insert docs using batch POST and download them', async () => {
+        const docCount = 3;
+        const docs = [];
+        for (let i = 0; i < docCount; i++) {
+            docs.push({ id: `item_${Date.now()}_${i}`, data: `Data ${i}` });
+        }
+
+        console.log('Inserting docs via batch POST...');
+        const batchResponse = await insertDocumentFiles(
+            { apiEndpoint: config.baseUrl, authToken: config.token },
+            { docsFolderId: config.testFolderId },
+            'id',
+            docs
+        );
+
+        // Parse IDs from batch response?
+        // The user snippet returns raw text.
+        // We usually rely on create returning the created file metadata (including ID).
+        // Let's parse the response to get the IDs.
+
+        const boundaryMatch = (batchResponse.match(/boundary=(.+)/) || [])[1];
+        let boundary = boundaryMatch;
+        // Or inspect Content-Type header from response? Ideally yes but user helper returns body text.
+        // Let's try to detect boundary from body first line if not found?
+        // But headers are gone.
+
+        // Wait, the user helper receives the Response object and returns text().
+        // We lose headers :(.
+        // Let's assume boundary from body first line.
+        const firstLine = batchResponse.trim().split(/\r?\n/)[0];
+        if (firstLine.startsWith('--')) {
+            boundary = firstLine.substring(2).trim();
+        } else {
+            // Maybe no boundary in body if empty? unlikely for batch.
+        }
+
+        if (!boundary) throw new Error('Could not detect boundary in batch response');
+
+        const parts = batchResponse.split(`--${boundary}`);
+        const createdIds: string[] = [];
+
+        for (const part of parts) {
+            if (!part.trim() || part.trim() === '--') continue;
+            // Find JSON body
+            const jsonStart = part.indexOf('{');
+            const jsonEnd = part.lastIndexOf('}');
+            if (jsonStart !== -1 && jsonEnd !== -1) {
+                try {
+                    const jsonStr = part.substring(jsonStart, jsonEnd + 1);
+                    const file = JSON.parse(jsonStr);
+                    if (file.id) {
+                        createdIds.push(file.id);
+                    }
+
+                } catch {
+                    // ignore parse errors
+                }
+            }
+        }
+
+        expect(createdIds.length).toBe(docCount);
+        console.log(`Created ${createdIds.length} files. Downloading...`);
+
+        for (const fileId of createdIds) {
+            const downloadUrl = `${config.baseUrl}/drive/v3/files/${encodeURIComponent(fileId)}?alt=media&supportsAllDrives=true`;
+            // console.log(`Downloading ${fileId} from ${downloadUrl}`);
+
+            const res = await fetch(downloadUrl, {
+                headers: { Authorization: `Bearer ${config.token}` }
+            });
+
+            if (!res.ok) {
+                throw new Error(`Download failed for ${fileId}: ${res.status} ${await res.text()}`);
+            }
+
+
+            const text = await res.text();
+            // console.log(`Content for ${fileId}:`, text);
+
+            // Expect empty content for metadata-only insert? 
+            // Or maybe Drive defaults to empty JSON object '{}'?
+            // Real API behavior for empty file created via metadata POST: 0 bytes.
+            expect(text).toBe('');
+        }
+
+    }, 30000);
+});

package/test/concurrent_fetch.test.ts

@@ -41,13 +41,12 @@ export async function batchFetchDocumentContentsRaw(
     }
 
     // This will be a multipart/mixed body that you must parse yourself.
-    return await res.text();
+    const text = await res.text();
+    console.log('############################# text:');
+    console.log(text);
+    return text;
 }
 
-/**
- * Parses a multipart/mixed response body from Google Drive Batch API.
- * Returns an array of objects containing { status, headers, body }.
- */
 /**
  * Parses a multipart/mixed response body from Google Drive Batch API.
  * Returns an array of objects containing { status, headers, body }.
@@ -135,7 +134,15 @@ describe('Batch Fetch Test', () => {
         if (config) config.stop();
     });
 
-    async function uploadJsonFile(name: string, content: unknown): Promise<string> {
+
+    interface TestContent {
+        index: number;
+        timestamp: number;
+        msg: string;
+        random: number;
+    }
+
+    async function uploadJsonFile(name: string, content: TestContent): Promise<string> {
         const metadata = {
             name: name,
             parents: [config.testFolderId],
@@ -175,13 +182,13 @@ describe('Batch Fetch Test', () => {
     it('should fetch content of many files in a single batch request', async () => {
         const fileCount = 5;
         const fileIds: string[] = [];
-        const expectedContents: Record<string, unknown> = {};
+        const expectedContents: Record<string, TestContent> = {};
 
         console.log(`Creating ${fileCount} files...`);
 
         for (let i = 0; i < fileCount; i++) {
             const fileName = `BatchFile_${i}_${Date.now()}.json`;
-            const content = { index: i, timestamp: Date.now(), msg: `Hello World ${i}`, random: Math.random() };
+            const content: TestContent = { index: i, timestamp: Date.now(), msg: `Hello World ${i}`, random: Math.random() };
 
             const id = await uploadJsonFile(fileName, content);
             fileIds.push(id);
@@ -215,7 +222,7 @@ describe('Batch Fetch Test', () => {
         expect(parsedResults.length).toBe(fileCount);
 
         for (const result of parsedResults) {
-            let content = result.body;
+            let content = result.body as TestContent;
 
 
             // All environments (Mock and Real) must return 302 Redirect for alt=media in batch
@@ -236,7 +243,7 @@ describe('Batch Fetch Test', () => {
             });
 
             if (!res.ok) throw new Error(`Failed to follow redirect: ${res.status} ${await res.text()}`);
-            content = await res.json();
+            content = await res.json() as TestContent;
 
 
             const expected = Object.values(expectedContents).find(c => c.index === content.index);

package/test/dates_and_sorting.test.ts

@@ -319,7 +319,6 @@ describe('Date Updates and Sorting', () => {
                 throw new Error(`Create failed: ${createRes.status} ${text}`);
             }
             const file = await createRes.json();
-            console.log('Explicit Time Check File:', JSON.stringify(file, null, 2));
             if (!file.modifiedTime) throw new Error('modifiedTime missing from response');
             const modifiedTimeCreate = new Date(file.modifiedTime).getTime();
 
@@ -468,7 +467,6 @@ describe('Date Updates and Sorting', () => {
                 body: 'Time Check Separate'
             });
             const file = await createRes.json();
-            console.log('Explicit Time Check File:', JSON.stringify(file, null, 2));
             if (!file.modifiedTime) throw new Error('modifiedTime missing from response');
             const modifiedTimeCreate = new Date(file.modifiedTime).getTime();
 

package/test/folder_query.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+const randomString = () => Math.random().toString(36).substring(7);
+
+describe('Folder Query Investigation', () => {
+    let config: TestConfig;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+        headers = {
+            Authorization: `Bearer ${config.token}`
+        };
+    });
+
+    it('should return files in a folder with specific query parameters', async () => {
+        // 1. Create a parent folder
+        const parentRes = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'QueryTestParams_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = (await parentRes.json()).id;
+
+        // 2. Create a few files in the folder
+        const file1 = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'file1',
+                parents: [parentId]
+            })
+        }).then(res => res.json());
+
+        const file2 = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'file2',
+                parents: [parentId]
+            })
+        }).then(res => res.json());
+
+        // Wait for consistency
+        await new Promise(r => setTimeout(r, 2000));
+
+        // 3. Run the user's specific query
+        const queryParts = [
+            `'${parentId}' in parents`,
+            `and trashed = false`
+        ];
+
+        // Optional: Add modifiedTime check if needed, but let's start with basic structure
+        // const checkpoint = { modifiedTime: '...' };
+        // if (checkpoint) {
+        //     queryParts.push(`and modifiedTime >= '${checkpoint.modifiedTime}'`);
+        // }
+
+        const batchSize = 10;
+        const params = new URLSearchParams({
+            q: queryParts.join(' '),
+            pageSize: (batchSize + 10) + '',
+            orderBy: "modifiedTime asc,name asc",
+            fields: "files(id,name,mimeType,parents,modifiedTime,size)",
+            supportsAllDrives: "true",
+            includeItemsFromAllDrives: "true",
+        });
+
+        const url =
+            config.baseUrl +
+            "/drive/v3/files?" +
+            params.toString();
+
+        console.log('Requesting URL:', url);
+
+        const res = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+            },
+        });
+
+        if (res.status !== 200) {
+            console.error('Error response:', await res.text());
+        }
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        console.log('Found files:', data.files.length);
+        const ids = data.files.map((f: { id: string }) => f.id);
+        expect(ids).toContain(file1.id);
+        expect(ids).toContain(file2.id);
+
+        // Check if fields are returned
+        const f1 = data.files.find((f: { id: string }) => f.id === file1.id) as Record<string, unknown>;
+        expect(f1.name).toBeDefined();
+        expect(f1.modifiedTime).toBeDefined();
+        expect(f1.parents).toBeDefined();
+        expect(f1.parents).toContain(parentId);
+
+        // Strict key check
+        const expectedKeys = ['id', 'name', 'mimeType', 'parents', 'modifiedTime', 'size'].sort();
+        const actualKeys = Object.keys(f1).sort();
+
+        // Log for debugging if they don't match (Vitest will show diff)
+        if (JSON.stringify(actualKeys) !== JSON.stringify(expectedKeys)) {
+            console.log('Keys mismatch! Actual:', actualKeys);
+        }
+        expect(actualKeys).toEqual(expectedKeys);
+
+    }, 60000);
+
+    it('should return files with modifiedTime filter', async () => {
+        const parentRes = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'QueryTestTime_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        const parentId = (await parentRes.json()).id;
+
+        // Create file 1 (Old)
+        const file1 = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'file1_old', parents: [parentId] })
+        }).then(res => res.json());
+
+        // Wait to ensure distinct modifiedTime
+        await new Promise(r => setTimeout(r, 1500));
+
+        // Checkpoint time
+        const checkpointTime = new Date().toISOString();
+
+        await new Promise(r => setTimeout(r, 1500));
+
+        // Create file 2 (New)
+        const file2 = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'file2_new', parents: [parentId] })
+        }).then(res => res.json());
+
+        // Query: parent + trashed + modifiedTime >= checkpoint
+        const queryParts = [
+            `'${parentId}' in parents`,
+            `and trashed = false`,
+            `and modifiedTime >= '${checkpointTime}'`
+        ];
+
+        const params = new URLSearchParams({
+            q: queryParts.join(' '),
+            pageSize: '10',
+            orderBy: "modifiedTime asc,name asc",
+            fields: "files(id,name,mimeType,parents,modifiedTime,size)",
+            supportsAllDrives: "true",
+            includeItemsFromAllDrives: "true",
+        });
+
+        const url = `${config.baseUrl}/drive/v3/files?${params.toString()}`;
+        const res = await fetch(url, { headers: { Authorization: `Bearer ${config.token}` } });
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        const ids = data.files.map((f: { id: string }) => f.id);
+
+        // Should contain file2 (New), but NOT file1 (Old)
+        expect(ids).toContain(file2.id);
+        expect(ids).not.toContain(file1.id);
+    }, 60000);
+});