google-drive-mock 1.1.6 → 1.2.0

package/test/check_empty.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+describe('Check Mock Drive Empty', () => {
+    let config: TestConfig;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+    });
+
+    afterAll(() => {
+        if (config) config.stop();
+    });
+
+    it('should be empty (no files left except possibly google-drive-mock root)', async () => {
+        const headers = { 'Authorization': `Bearer ${config.token}` };
+        const res = await fetch(`${config.baseUrl}/drive/v3/files?supportsAllDrives=true&includeItemsFromAllDrives=true`, { headers });
+        expect(res.status).toBe(200);
+        const data = await res.json();
+        
+        const files = data.files || [];
+        
+        if (!config.baseUrl.includes('googleapis')) {
+            const nonRootFiles = files.filter((f: { name: string; id: string }) => f.name !== 'google-drive-mock');
+            if (nonRootFiles.length > 0) {
+                console.error('LOCKED/LEAKED FILES FOUND:', JSON.stringify(nonRootFiles, null, 2));
+                expect(nonRootFiles.length).toBe(0);
+            }
+            // Clean up the google-drive-mock folder if it exists
+            const rootFolder = files.find((f: { name: string; id: string }) => f.name === 'google-drive-mock');
+            if (rootFolder) {
+                const delRes = await fetch(`${config.baseUrl}/drive/v3/files/${rootFolder.id}`, {
+                    method: 'DELETE',
+                    headers
+                });
+                expect([204, 404]).toContain(delRes.status);
+                
+                // Verify absolutely no files exist now
+                const checkRes = await fetch(`${config.baseUrl}/drive/v3/files?supportsAllDrives=true&includeItemsFromAllDrives=true`, { headers });
+                expect(checkRes.status).toBe(200);
+                const checkData = await checkRes.json();
+                expect(checkData.files || []).toEqual([]);
+            }
+        } else {
+            const q = `'${config.testFolderId}' in parents and trashed = false`;
+            const childrenRes = await fetch(`${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&supportsAllDrives=true&includeItemsFromAllDrives=true`, { headers });
+            expect(childrenRes.status).toBe(200);
+            const childrenData = await childrenRes.json();
+            const children = childrenData.files || [];
+            expect(children.length).toBe(0);
+
+            // Delete the test folder itself on the real API
+            const delRes = await fetch(`${config.baseUrl}/drive/v3/files/${config.testFolderId}`, {
+                method: 'DELETE',
+                headers
+            });
+            expect([204, 404]).toContain(delRes.status);
+        }
+    });
+});

package/test/complex_query.test.ts

@@ -1,5 +1,6 @@
 
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, expect, beforeAll, afterAll } from 'vitest';
+import { it } from './config';;
 import { getTestConfig, TestConfig } from './config';
 
 describe('Complex Query Support', () => {

package/test/concurrent_fetch.test.ts

@@ -1,5 +1,6 @@
 
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, expect, beforeAll, afterAll } from 'vitest';
+import { it } from './config';;
 import { getTestConfig, TestConfig } from './config';
 
 // --- User's Logic (Batch Fetch) ---

package/test/config.ts

@@ -1,6 +1,7 @@
 // Note: We avoid static imports of node-only modules to support browser mode.
 // Types are fine.
 import type { Server } from 'http';
+import { it as vitestIt, test as vitestTest, afterAll } from 'vitest';
 
 
 /**
@@ -14,6 +15,9 @@ export interface TestConfig {
     testFolderId: string;
     stop: () => void;
     clear: () => Promise<void>;
+    createdFiles: string[];
+    trackFile: (id: string | undefined | null) => void;
+    cleanup: () => Promise<void>;
 }
 
 async function ensureTestFolder(target: string, token: string, folderName: string): Promise<string> {
@@ -69,6 +73,88 @@ async function ensureTestFolder(target: string, token: string, folderName: strin
     return created.id;
 }
 
+let activeConfig: TestConfig | undefined;
+
+function wrapTestConfig(config: {
+    target: Server | string;
+    baseUrl: string;
+    token: string;
+    testFolderId: string;
+    stop: () => void;
+    clear: () => Promise<void>;
+}): TestConfig {
+    const createdFiles: string[] = [];
+    const configWithTracking: TestConfig = {
+        ...config,
+        createdFiles,
+        trackFile: (id) => {
+            if (id && typeof id === 'string' && !createdFiles.includes(id) && id !== config.testFolderId) {
+                createdFiles.push(id);
+            }
+        },
+        cleanup: async () => {
+            const headers = { 'Authorization': `Bearer ${config.token}` };
+            // Delete in reverse order of creation (children before parents)
+            const idsToDelete = [...createdFiles].reverse();
+            for (const id of idsToDelete) {
+                try {
+                    await fetch(`${config.baseUrl}/drive/v3/files/${id}`, {
+                        method: 'DELETE',
+                        headers
+                    });
+                } catch {
+                    // ignore network error
+                }
+            }
+            createdFiles.length = 0; // empty the list
+        }
+    };
+
+    // Patch globalThis.fetch to automatically track created files
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+        const res = await originalFetch(input, init);
+        const method = init?.method?.toUpperCase() || 'GET';
+        if (['POST', 'PUT', 'PATCH'].includes(method)) {
+            try {
+                const urlStr = typeof input === 'string' ? input : (input instanceof URL ? input.toString() : input.url);
+                if (urlStr.includes('/files') || urlStr.includes('/upload') || urlStr.includes('/batch')) {
+                    const clone = res.clone();
+                    const contentType = clone.headers.get('content-type') || '';
+                    if (contentType.includes('application/json')) {
+                        const body = await clone.json();
+                        if (body && typeof body === 'object') {
+                            if (body.id && (body.kind === 'drive#file' || !body.kind)) {
+                                configWithTracking.trackFile(body.id);
+                            }
+                            if (body.files && Array.isArray(body.files)) {
+                                for (const f of body.files) {
+                                    if (f.id) configWithTracking.trackFile(f.id);
+                                }
+                            }
+                        }
+                    } else {
+                        const text = await clone.text();
+                        const matches = text.match(/"id"\s*:\s*"([^"]+)"/g);
+                        if (matches) {
+                            for (const match of matches) {
+                                const id = match.replace(/"id"\s*:\s*"/, '').replace(/"/, '');
+                                configWithTracking.trackFile(id);
+                            }
+                        }
+                    }
+                }
+            } catch {
+                // ignore tracking errors
+            }
+        }
+        return res;
+    };
+
+    activeConfig = configWithTracking;
+    return configWithTracking;
+}
+
 export async function getTestConfig(): Promise<TestConfig> {
     const isBrowser = typeof window !== 'undefined';
     // For browser compatibility, we can't access process.env.TEST_TARGET easily
@@ -129,25 +215,26 @@ export async function getTestConfig(): Promise<TestConfig> {
         // Ensure scope folder
         const testFolderId = await ensureTestFolder(target, token, 'google-drive-mock');
 
-        return {
+        return wrapTestConfig({
             target,
             baseUrl: target,
             token,
             testFolderId,
             stop: () => { },
             clear: async () => { }
-        };
+        });
     }
 
     if (isBrowser) {
         console.log('Running tests against MOCK Google Drive API (Browser)');
-        const serverUrl = 'http://localhost:3000';
+        const port = process.env.PORT || '3000';
+        const serverUrl = `http://localhost:${port}`;
         // In Mock mode, we can just use a random folder ID or create one if Mock supports it.
         // Mock supports folders. Let's create one to be safe and rigorous.
         const token = 'valid-token';
         const testFolderId = await ensureTestFolder(serverUrl, token, 'google-drive-mock');
 
-        return {
+        return wrapTestConfig({
             target: serverUrl,
             baseUrl: serverUrl,
             token,
@@ -158,8 +245,28 @@ export async function getTestConfig(): Promise<TestConfig> {
                 // We re-create the folder after clear in store or ensure checking logic handles it.
                 await ensureTestFolder(serverUrl, token, 'google-drive-mock');
             }
-        };
+        });
     } else {
+        const useSharedMock = process.env.USE_SHARED_MOCK === 'true';
+        if (useSharedMock) {
+            console.log('Running tests against MOCK Google Drive API (Shared Node)');
+            const port = process.env.PORT || '3000';
+            const targetUrl = `http://localhost:${port}`;
+            const token = 'valid-token';
+            const testFolderId = await ensureTestFolder(targetUrl, token, 'google-drive-mock');
+
+            return wrapTestConfig({
+                target: targetUrl,
+                baseUrl: targetUrl,
+                token,
+                testFolderId,
+                stop: () => { },
+                clear: async () => {
+                    // Do not clear in parallel tests to avoid state corruption
+                }
+            });
+        }
+
         console.log('Running tests against MOCK Google Drive API (Node)');
         const { startServer } = await import('../src/index');
         const { driveStore } = await import('../src/store');
@@ -179,7 +286,7 @@ export async function getTestConfig(): Promise<TestConfig> {
         // Create Folder in Mock
         const testFolderId = await ensureTestFolder(targetUrl, 'valid-token', 'google-drive-mock');
 
-        return {
+        return wrapTestConfig({
             target: server,
             baseUrl: targetUrl, // Added
             token: 'valid-token',
@@ -193,6 +300,56 @@ export async function getTestConfig(): Promise<TestConfig> {
                 // We must re-create the folder after clear
                 await ensureTestFolder(targetUrl, 'valid-token', 'google-drive-mock');
             }
-        };
+        });
     }
 }
+
+export async function cleanupCreatedFiles() {
+    if (activeConfig) {
+        await activeConfig.cleanup();
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function wrapTestFunction(vitestFn: any): any {
+    const proxy = new Proxy(vitestFn, {
+        apply(target, thisArg, argArray) {
+            const [name, fn, timeout] = argArray;
+            if (typeof fn === 'function') {
+                return target.call(thisArg, name, async (...args: any[]) => {
+                    try {
+                        return await fn(...args);
+                    } finally {
+                        await cleanupCreatedFiles();
+                    }
+                }, timeout);
+            }
+            return target.apply(thisArg, argArray as any);
+        },
+        get(target, prop, receiver) {
+            const val = Reflect.get(target, prop, receiver);
+            if (typeof val === 'function') {
+                return wrapTestFunction(val);
+            }
+            return val;
+        }
+    });
+    return proxy;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+export const it = wrapTestFunction(vitestIt) as typeof vitestIt;
+export const test = wrapTestFunction(vitestTest) as typeof vitestTest;
+
+afterAll(async () => {
+    if (activeConfig && activeConfig.testFolderId) {
+        try {
+            await fetch(`${activeConfig.baseUrl}/drive/v3/files/${activeConfig.testFolderId}`, {
+                method: 'DELETE',
+                headers: { 'Authorization': `Bearer ${activeConfig.token}` }
+            });
+        } catch {
+            // ignore cleanup error
+        }
+    }
+});

package/test/dates_and_sorting.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, expect, beforeAll, afterAll } from 'vitest';
+import { it } from './config';;
 import { getTestConfig, TestConfig } from './config';
 
 describe('Date Updates and Sorting', () => {

package/test/etag.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, expect, beforeAll, afterAll } from 'vitest';
+import { it } from './config';;
 import { getTestConfig, TestConfig } from './config';
 import { Server } from 'http';
 
@@ -63,9 +64,10 @@ describe('ETag and If-Match Support', () => {
     }
 
     it('should return ETag header when getting a file (V2 Parity)', async () => {
+        const title = `ETag Test File V2 ${Math.random().toString(36).substring(7)}`;
         // Create file using V2 endpoint
         const createRes = await req('POST', '/drive/v2/files', {
-            title: 'ETag Test File V2', // V2 uses 'title', not 'name'
+            title, // V2 uses 'title', not 'name'
             mimeType: 'text/plain',
             parents: [{ id: config.testFolderId }] // V2 parents is a list of ParentReferences
         });
@@ -85,9 +87,10 @@ describe('ETag and If-Match Support', () => {
     });
 
     it('should support If-Match on UPDATE (V2 Parity)', async () => {
+        const title = `If-Match V2 File ${Math.random().toString(36).substring(7)}`;
         // Create file
         const createRes = await req('POST', '/drive/v2/files', {
-            title: 'If-Match V2 File',
+            title,
             parents: [{ id: config.testFolderId }]
         });
         const fileId = createRes.body.id;
@@ -129,8 +132,9 @@ describe('ETag and If-Match Support', () => {
     });
 
     it('should support If-Match on DELETE (V2 Parity)', async () => {
+        const title = `Delete V2 File ${Math.random().toString(36).substring(7)}`;
         const createRes = await req('POST', '/drive/v2/files', {
-            title: 'Delete V2 File',
+            title,
             parents: [{ id: config.testFolderId }]
         });
         const fileId = createRes.body.id;

package/test/features.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, expect, beforeAll, afterAll } from 'vitest';
+import { it } from './config';;
 import { getTestConfig, TestConfig } from './config';
 import { Server } from 'http';
 import { DriveFile } from '../src/store';

package/test/folder_query.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect, beforeAll } from 'vitest';
+import { describe, expect, beforeAll } from 'vitest';
+import { it } from './config';;
 import { getTestConfig, TestConfig } from './config';
 
 const randomString = () => Math.random().toString(36).substring(7);

package/test/folder_search.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect, beforeAll } from 'vitest';
+import { describe, expect, beforeAll } from 'vitest';
+import { it } from './config';;
 import { getTestConfig, TestConfig } from './config';
 
 const randomString = () => Math.random().toString(36).substring(7);