google-drive-mock 1.1.5 → 1.2.0

package/test/iterate_changes.test.ts

@@ -1,4 +1,6 @@
-import { describe, it, expect, beforeAll } from 'vitest';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, expect, beforeAll } from 'vitest';
+import { it } from './config';;
 import {
     getTestConfig,
     TestConfig
@@ -7,7 +9,7 @@ import { DriveFile } from '../src/store';
 
 const randomString = () => Math.random().toString(36).substring(7);
 
-const createFileWithContent = async (name: string, content: string, config: TestConfig) => {
+const createFileWithContent = async (name: string, content: string, config: TestConfig, parentId?: string) => {
     const res = await fetch(`${config.baseUrl}/upload/drive/v3/files?uploadType=media`, {
         method: 'POST',
         headers: {
@@ -24,7 +26,11 @@ const createFileWithContent = async (name: string, content: string, config: Test
     // actually, let's just use the patch to set name/metadata to ensure it's correct for the test.
 
     // Better: use multipart or just update after create.
-    await fetch(`${config.baseUrl}/drive/v3/files/${file.id}`, {
+    const patchUrl = parentId 
+        ? `${config.baseUrl}/drive/v3/files/${file.id}?addParents=${parentId}`
+        : `${config.baseUrl}/drive/v3/files/${file.id}`;
+
+    await fetch(patchUrl, {
         method: 'PATCH',
         headers: {
             'Authorization': `Bearer ${config.token}`,
@@ -52,61 +58,87 @@ describe('Iterate Changes Queries', () => {
     });
 
     it('should find files where last write time was greater than X, sorted by modifiedTime and id, with limit', async () => {
+        // 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: 'ParentFolder_GreaterThan_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = (await parentRes.json()).id;
+
         // Create 3 files with slight delays to ensure different modifiedTimes
-        const file1 = await createFileWithContent('file1', randomString(), config);
+        const file1 = await createFileWithContent('file1', randomString(), config, parentId);
         await new Promise(r => setTimeout(r, 1100)); // Ensure > 1s diff for reliable sorting if seconds resolution
-        const file2 = await createFileWithContent('file2', randomString(), config);
+        const file2 = await createFileWithContent('file2', randomString(), config, parentId);
         await new Promise(r => setTimeout(r, 1100));
-        const file3 = await createFileWithContent('file3', randomString(), config);
+        const file3 = await createFileWithContent('file3', randomString(), config, parentId);
 
         // Use file1's modifiedTime as the baseline (X)
         const timeX = file1.modifiedTime;
 
-        // Query: modifiedTime > X, orderBy modifiedTime asc, name asc (using name as proxy for ID stability in test if needed, but user asked for ID)
-        // User asked for: Sorted by write data and id. with limit
-        const q = `modifiedTime > '${timeX}' and trashed = false`;
+        // Query: modifiedTime > X, orderBy modifiedTime asc, name asc
+        const q = `modifiedTime > '${timeX}' and '${parentId}' in parents and trashed = false`;
         const orderBy = 'modifiedTime asc, name asc';
-        const pageSize = 1;
+
+        // Poll until the search index is fully updated and returns both expected files
+        let data2: any;
+        const url2 = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=2`;
+        for (let attempt = 1; attempt <= 15; attempt++) {
+            const res2 = await fetch(url2, { headers });
+            expect(res2.status).toBe(200);
+            data2 = await res2.json();
+            const ids = (data2.files || []).map((f: any) => f.id);
+            if (ids.includes(file2.id) && ids.includes(file3.id)) {
+                break;
+            }
+            await new Promise(r => setTimeout(r, 2000));
+        }
+
+        expect(data2.files.length).toBe(2);
+        expect(data2.files[0].id).toBe(file2.id);
+        expect(data2.files[1].id).toBe(file3.id);
 
         // First page
+        const pageSize = 1;
         const url1 = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=${pageSize}`;
         const res1 = await fetch(url1, { headers });
-        if (res1.status !== 200) {
-            const txt = await res1.text();
-            console.error('Error 1:', txt);
-        }
         expect(res1.status).toBe(200);
         const data1 = await res1.json();
 
         expect(data1.files.length).toBe(1);
         expect(data1.files[0].id).toBe(file2.id);
-
-        // If we want to simulate iteration, we would use nextPageToken or just offset logic if we supported it, 
-        // but here we just test that the query works and LIMIT works.
-
-        // Verify we can get the next one if we increase limit
-        const url2 = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=2`;
-        const res2 = await fetch(url2, { headers });
-        const data2 = await res2.json();
-        expect(data2.files.length).toBe(2);
-        expect(data2.files[0].id).toBe(file2.id);
-        expect(data2.files[1].id).toBe(file3.id);
     }, 60000);
 
     it('should find all files where write time was equal to X, sorted by name, with limit', async () => {
+        // 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: 'ParentFolder_EqualTime_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = (await parentRes.json()).id;
+
         // Create 3 files effectively at the "same" time.
         // To do this reliably on Real API, we create one, get its time, and then PATCH the others to have that same time (if possible).
         // However, Drive API might not allow arbitrary modifiedTime patching easily without setModifiedDate=true param or similar.
         // Actually, V3 supports modifying modifiedTime.
 
-        const file1 = await createFileWithContent('file_B_middle', randomString(), config);
+        const file1 = await createFileWithContent('file_B_middle', randomString(), config, parentId);
         // Get the time from file1 to use as target
         const timeXRes = await fetch(`${config.baseUrl}/drive/v3/files/${file1.id}?fields=modifiedTime`, { headers });
         const timeX = (await timeXRes.json()).modifiedTime;
 
         // Create two more files
-        const file2 = await createFileWithContent('file_A_first', randomString(), config);
-        const file3 = await createFileWithContent('file_C_last', randomString(), config);
+        const file2 = await createFileWithContent('file_A_first', randomString(), config, parentId);
+        const file3 = await createFileWithContent('file_C_last', randomString(), config, parentId);
 
         // Patch file2 and file3 to have the SAME modifiedTime as file1
         // We need to wait a bit to ensure they would naturally have different times if we didn't patch, 
@@ -117,16 +149,24 @@ describe('Iterate Changes Queries', () => {
         await fetch(`${config.baseUrl}/drive/v3/files/${file2.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
         await fetch(`${config.baseUrl}/drive/v3/files/${file3.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
 
-        const q = `modifiedTime = '${timeX}' and trashed = false`;
+        const q = `modifiedTime = '${timeX}' and '${parentId}' in parents and trashed = false`;
         const orderBy = 'name asc';
         const pageSize = 10;
 
+        let data: any;
         const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=${pageSize}&fields=files(id,name,modifiedTime)`;
-        const res = await fetch(url, { headers });
-        expect(res.status).toBe(200);
-        const data = await res.json();
+        
+        for (let attempt = 1; attempt <= 15; attempt++) {
+            const res = await fetch(url, { headers });
+            expect(res.status).toBe(200);
+            data = await res.json();
+            const relevantFiles = (data.files || []).filter((f: DriveFile) => [file1.id, file2.id, file3.id].includes(f.id));
+            if (relevantFiles.length === 3) {
+                break;
+            }
+            await new Promise(r => setTimeout(r, 2000));
+        }
 
-        // Should find all 3 files
         const relevantFiles = data.files.filter((f: DriveFile) => [file1.id, file2.id, file3.id].includes(f.id));
         expect(relevantFiles.length).toBe(3);
 
@@ -190,10 +230,19 @@ describe('Iterate Changes Queries', () => {
         const q = `modifiedTime = '${timeX}' and '${parentId}' in parents and trashed = false`;
         const orderBy = 'name asc';
 
+        let data: any;
         const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&fields=files(id,name,modifiedTime,parents)`;
-        const res = await fetch(url, { headers });
-        expect(res.status).toBe(200);
-        const data = await res.json();
+        
+        for (let attempt = 1; attempt <= 15; attempt++) {
+            const res = await fetch(url, { headers });
+            expect(res.status).toBe(200);
+            data = await res.json();
+            const ids = (data.files || []).map((f: DriveFile) => f.id);
+            if (ids.includes(file1.id) && ids.includes(file2.id) && ids.includes(file3.id)) {
+                break;
+            }
+            await new Promise(r => setTimeout(r, 2000));
+        }
 
         // 4. Verify results
         // Should find file1, file2, file3
@@ -213,21 +262,33 @@ describe('Iterate Changes Queries', () => {
     }, 60000);
 
     it('should find files where write time >= X, sorted by modifiedTime and name', async () => {
+        // 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: 'ParentFolder_GreaterOrEqual_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = (await parentRes.json()).id;
+
         // 1. Create file OLD (should be excluded)
-        const fileOld = await createFileWithContent('file_A_Old', randomString(), config);
+        const fileOld = await createFileWithContent('file_A_Old', randomString(), config, parentId);
 
         // Wait to ensure distinct time
         await new Promise(r => setTimeout(r, 1500));
 
         // 2. Create ISO-time target files (Equal Time)
         // We create one, get its time, then create another and patch it to match.
-        const fileMiddle1 = await createFileWithContent('file_B_Middle1', randomString(), config);
+        const fileMiddle1 = await createFileWithContent('file_B_Middle1', randomString(), config, parentId);
         // Get target time
         const timeXRes = await fetch(`${config.baseUrl}/drive/v3/files/${fileMiddle1.id}?fields=modifiedTime`, { headers });
         const timeX = (await timeXRes.json()).modifiedTime;
 
         // Create second middle file
-        const fileMiddle2 = await createFileWithContent('file_B_Middle2', randomString(), config);
+        const fileMiddle2 = await createFileWithContent('file_B_Middle2', randomString(), config, parentId);
 
         // Patch fileMiddle2 to match fileMiddle1 time
         await new Promise(r => setTimeout(r, 1100)); // Wait before patching to ensure it would be different otherwise
@@ -238,20 +299,26 @@ describe('Iterate Changes Queries', () => {
         await new Promise(r => setTimeout(r, 1500));
 
         // 3. Create file New (should be included, greater match logic)
-        const fileNew = await createFileWithContent('file_C_New', randomString(), config);
+        const fileNew = await createFileWithContent('file_C_New', randomString(), config, parentId);
 
         // 4. Query: modifiedTime >= timeX
         // Sort by modifiedTime asc, name asc
-        const q = `modifiedTime >= '${timeX}' and trashed = false`;
+        const q = `modifiedTime >= '${timeX}' and '${parentId}' in parents and trashed = false`;
         const orderBy = 'modifiedTime asc, name asc';
 
+        let data: any;
         const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&fields=files(id,name,modifiedTime)`;
-        const res = await fetch(url, { headers });
-        if (res.status !== 200) {
-            console.error('Error response:', await res.text());
+        
+        for (let attempt = 1; attempt <= 15; attempt++) {
+            const res = await fetch(url, { headers });
+            expect(res.status).toBe(200);
+            data = await res.json();
+            const relevantFiles = (data.files || []).filter((f: DriveFile) => [fileMiddle1.id, fileMiddle2.id, fileNew.id].includes(f.id));
+            if (relevantFiles.length === 3) {
+                break;
+            }
+            await new Promise(r => setTimeout(r, 2000));
         }
-        expect(res.status).toBe(200);
-        const data = await res.json();
 
         // 5. Verify results
         const resultIds = data.files.map((f: DriveFile) => f.id);
@@ -560,10 +627,19 @@ describe('Iterate Changes Queries', () => {
         const q = `modifiedTime > '${timeX}' and '${parentId}' in parents and trashed = false`;
         const orderBy = 'modifiedTime asc, name asc';
 
+        let data: any;
         const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&fields=files(id,name,parents,modifiedTime)`;
-        const res = await fetch(url, { headers });
-        expect(res.status).toBe(200);
-        const data = await res.json();
+        
+        for (let attempt = 1; attempt <= 15; attempt++) {
+            const res = await fetch(url, { headers });
+            expect(res.status).toBe(200);
+            data = await res.json();
+            const matchingFiles = (data.files || []).filter((f: DriveFile) => f.id === file2.id);
+            if (matchingFiles.length === 1) {
+                break;
+            }
+            await new Promise(r => setTimeout(r, 2000));
+        }
 
         const matchingFiles = data.files.filter((f: DriveFile) => f.id === file2.id);
         const nonMatchingFile1 = data.files.filter((f: DriveFile) => f.id === file1.id);
@@ -582,22 +658,39 @@ describe('Iterate Changes Queries', () => {
     }, 60000);
 
     it('should paginate through files using nextPageToken', async () => {
+        // 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: 'ParentFolder_PaginationToken_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = (await parentRes.json()).id;
+
         // Create files
         const totalFiles = 6;
         const baseName = 'PaginatedFile_' + randomString();
         for (let i = 0; i < totalFiles; i++) {
-            await createFileWithContent(`${baseName}_${i}`, `content_${i}`, config);
+            await createFileWithContent(`${baseName}_${i}`, `content_${i}`, config, parentId);
             // Small delay to ensure order if we sort by time, but we'll sort by name to be deterministic
         }
 
-        const q = `name contains '${baseName}' and trashed = false`;
+        const q = `'${parentId}' in parents and name contains '${baseName}' and trashed = false`;
         const orderBy = 'name asc';
         const pageSize = 2;
         const collectedFiles: DriveFile[] = [];
         let pageToken: string | undefined;
+        let pageCount = 0;
 
         // Iterate pages until no token
         do {
+            pageCount++;
+            if (pageCount > 50) {
+                throw new Error('Too many pages retrieved (infinite loop safety limit)');
+            }
             const url: string = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=${pageSize}` + (pageToken ? `&pageToken=${pageToken}` : '');
             const res = await fetch(url, { headers });
 
@@ -779,17 +872,23 @@ describe('Iterate Changes Queries', () => {
             }
         }
 
-        // Wait for potential eventual consistency/indexing
-        console.log('Waiting 5s for indexing...');
-        await new Promise(r => setTimeout(r, 5000));
-
-        // Get one file to check time
-        const listOne = await fetch(`${config.baseUrl}/drive/v3/files?q='${parentId}' in parents&pageSize=1&fields=files(modifiedTime)`, { headers });
-        const oneData = await listOne.json();
-        if (!oneData.files || oneData.files.length === 0) {
-            throw new Error('No files found in parent check!');
+        // Wait for indexing with retries
+        let refTime: string | undefined;
+        console.log('Waiting for indexing...');
+        for (let attempt = 0; attempt < 15; attempt++) {
+            const listOne = await fetch(`${config.baseUrl}/drive/v3/files?q='${parentId}' in parents&pageSize=${totalFiles}&fields=files(modifiedTime)`, { headers });
+            if (listOne.status === 200) {
+                const oneData = await listOne.json();
+                if (oneData.files && oneData.files.length === totalFiles) {
+                    refTime = oneData.files[0].modifiedTime;
+                    break;
+                }
+            }
+            await new Promise(r => setTimeout(r, 2000));
+        }
+        if (!refTime) {
+            throw new Error('All files not indexed in parent check!');
         }
-        const refTime = oneData.files[0].modifiedTime;
         console.log('Reference File Time:', refTime);
 
         // Filter: modifiedTime > refTime - 1 hour (to safely include all)
@@ -861,21 +960,23 @@ describe('Iterate Changes Queries', () => {
             expect(res.status).toBe(200);
         }
 
-        console.log('Waiting 5s for indexing (v2)...');
-        await new Promise(r => setTimeout(r, 5000));
-
-        // Get one file to check time (v2 uses modifiedDate)
-        // v2 list: items
-        const listOne = await fetch(`${config.baseUrl}/drive/v2/files?q='${parentId}' in parents&maxResults=1`, { headers });
-        if (listOne.status !== 200) {
-            console.error('v2 check failed:', await listOne.text());
+        // Wait for indexing with retries (v2)
+        let refTime: string | undefined;
+        console.log('Waiting for indexing (v2)...');
+        for (let attempt = 0; attempt < 15; attempt++) {
+            const listOne = await fetch(`${config.baseUrl}/drive/v2/files?q='${parentId}' in parents&maxResults=${totalFiles}`, { headers });
+            if (listOne.status === 200) {
+                const oneData = await listOne.json();
+                if (oneData.items && oneData.items.length === totalFiles) {
+                    refTime = oneData.items[0].modifiedDate;
+                    break;
+                }
+            }
+            await new Promise(r => setTimeout(r, 2000));
         }
-        const oneData = await listOne.json();
-
-        if (!oneData.items || oneData.items.length === 0) {
-            throw new Error('No files found in parent check v2!');
+        if (!refTime) {
+            throw new Error('All files not indexed in parent check v2!');
         }
-        const refTime = oneData.items[0].modifiedDate;
         console.log('Reference File Time v2:', refTime);
 
         // Filter: modifiedDate > refTime - 1 hour

package/test/latency.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect, afterAll, beforeAll } from 'vitest';
+import { describe, expect, afterAll, beforeAll } from 'vitest';
+import { it } from './config';;
 import { getTestConfig, TestConfig } from './config';
 
 // Helper (Shared)

package/test/mime_types.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('MIME Type Handling', () => {

package/test/missing_fields.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('Missing Fields Support (Size & MD5)', () => {

package/test/multipart_behavior.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('Multipart Upload Behavior (Conflicts, Overwrites, Replacements)', () => {

package/test/parallel_update.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('Parallel Content Update Test', () => {

package/test/parity_media_download.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';
 import { Server } from 'http';
 

package/test/routines.test.ts

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, it, expect, afterAll, beforeAll, vi } from 'vitest';
+import { describe, expect, afterAll, beforeAll, vi } from 'vitest';
+import { it } from './config';;
 import { waitUntil } from 'async-test-util';
 import { getTestConfig, TestConfig } from './config';
 
@@ -68,8 +69,9 @@ describe('Complex Routines', () => {
 
     it('Lifecycle: Create -> Update -> Read -> Delete', async () => {
         // 1. Create
+        const title = 'Lifecycle File ' + Math.random().toString(36).substring(7);
         const newFile = {
-            name: 'Lifecycle File',
+            name: title,
             mimeType: 'text/plain',
             parents: [config.testFolderId]
         };
@@ -78,14 +80,15 @@ describe('Complex Routines', () => {
         const fileId = createRes.body.id;
 
         // 2. Update
-        const updateRes = await req('PATCH', `/drive/v3/files/${fileId}`, { name: 'Lifecycle Updated' });
+        const updatedTitle = 'Lifecycle Updated ' + Math.random().toString(36).substring(7);
+        const updateRes = await req('PATCH', `/drive/v3/files/${fileId}`, { name: updatedTitle });
         expect(updateRes.status).toBe(200);
-        expect(updateRes.body.name).toBe('Lifecycle Updated');
+        expect(updateRes.body.name).toBe(updatedTitle);
 
         // 3. Read
         const readRes = await req('GET', `/drive/v3/files/${fileId}`);
         expect(readRes.status).toBe(200);
-        expect(readRes.body.name).toBe('Lifecycle Updated');
+        expect(readRes.body.name).toBe(updatedTitle);
 
         // 4. Delete
         const deleteRes = await req('DELETE', `/drive/v3/files/${fileId}`);
@@ -97,7 +100,7 @@ describe('Complex Routines', () => {
     });
 
     it('Transaction Simulation: Lock -> Wait -> Release', async () => {
-        const LOCK_FILE = 'transactions-lock-' + Date.now() + '.txt';
+        const LOCK_FILE = 'transactions-lock-' + Math.random().toString(36).substring(7) + '.txt';
 
         // Client A: Acquire Lock
         const createLock = await req('POST', '/drive/v3/files', {
@@ -113,7 +116,7 @@ describe('Complex Routines', () => {
         await Promise.all([
             // Client B
             waitUntil(async () => {
-                const check = await req('GET', '/drive/v3/files', null); // removed query q for simplicity logic match
+                const check = await req('GET', `/drive/v3/files?q=${encodeURIComponent(`name = '${LOCK_FILE}' and trashed = false`)}`, null);
                 // Actually to filter we can iterate body.files
 
                 const files = check.body.files || [];
@@ -166,11 +169,11 @@ describe('Complex Routines', () => {
     });
 
     it('Routine: Concurrent Create (Duplicates Allowed)', async () => {
-        const UNIQUE_FILE = 'unique.txt';
+        const UNIQUE_FILE = 'unique-' + Math.random().toString(36).substring(7) + '.txt';
 
         // 1. Clean
-        const check1 = await req('GET', '/drive/v3/files');
-        const existingFiles = check1.body.files.filter((f: any) => f.name === UNIQUE_FILE);
+        const check1 = await req('GET', `/drive/v3/files?q=${encodeURIComponent(`name = '${UNIQUE_FILE}' and trashed = false`)}`);
+        const existingFiles = (check1.body.files || []).filter((f: any) => f.name === UNIQUE_FILE);
         for (const file of existingFiles) {
             await req('DELETE', `/drive/v3/files/${file.id}`);
         }
@@ -196,8 +199,8 @@ describe('Complex Routines', () => {
         expect(statuses).toEqual([200, 200]);
 
         // Verify duplicates exist
-        const check3 = await req('GET', '/drive/v3/files');
-        const files = check3.body.files.filter((f: any) => f.name === UNIQUE_FILE);
+        const check3 = await req('GET', `/drive/v3/files?q=${encodeURIComponent(`name = '${UNIQUE_FILE}' and trashed = false`)}`);
+        const files = (check3.body.files || []).filter((f: any) => f.name === UNIQUE_FILE);
         expect(files.length).toBe(2);
     });
 });

package/test/upload.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('Multipart Upload Feature', () => {

package/test/url_parameters.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('URL Parameters Test', () => {

package/test/v2_basics.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,12 +64,13 @@ describe('Google Drive API V2 Basics', () => {
     }
 
     it('should create a file with V2 fields (title vs name)', async () => {
+        const title = 'V2 Created File ' + Math.random().toString(36).substring(7);
         const createRes = await req('POST', '/drive/v2/files', {
-            title: 'V2 Created File',
+            title,
             mimeType: 'text/plain'
         });
         expect(createRes.status).toBe(200);
-        expect(createRes.body.title).toBe('V2 Created File');
+        expect(createRes.body.title).toBe(title);
         expect(createRes.body.kind).toBe('drive#file');
         expect(createRes.body.id).toBeTruthy();
 
@@ -77,38 +79,43 @@ describe('Google Drive API V2 Basics', () => {
         // Verify with GET
         const getRes = await req('GET', `/drive/v2/files/${fileId}`);
         expect(getRes.status).toBe(200);
-        expect(getRes.body.title).toBe('V2 Created File');
+        expect(getRes.body.title).toBe(title);
     });
 
     it('should update a file using PUT', async () => {
         // Create
-        const createRes = await req('POST', '/drive/v2/files', { title: 'To Update' });
+        const title = 'To Update ' + Math.random().toString(36).substring(7);
+        const updatedTitle = 'Updated via PUT ' + Math.random().toString(36).substring(7);
+        const createRes = await req('POST', '/drive/v2/files', { title });
         const fileId = createRes.body.id;
 
         // Update
         const updateRes = await req('PUT', `/drive/v2/files/${fileId}`, {
-            title: 'Updated via PUT'
+            title: updatedTitle
         });
         expect(updateRes.status).toBe(200);
-        expect(updateRes.body.title).toBe('Updated via PUT');
+        expect(updateRes.body.title).toBe(updatedTitle);
     });
 
     it('should patch a file using PATCH', async () => {
         // Create
-        const createRes = await req('POST', '/drive/v2/files', { title: 'To Patch' });
+        const title = 'To Patch ' + Math.random().toString(36).substring(7);
+        const patchedTitle = 'Patched Title ' + Math.random().toString(36).substring(7);
+        const createRes = await req('POST', '/drive/v2/files', { title });
         const fileId = createRes.body.id;
 
         // Patch
         const patchRes = await req('PATCH', `/drive/v2/files/${fileId}`, {
-            title: 'Patched Title'
+            title: patchedTitle
         });
         expect(patchRes.status).toBe(200);
-        expect(patchRes.body.title).toBe('Patched Title');
+        expect(patchRes.body.title).toBe(patchedTitle);
     });
 
     it('should delete a file', async () => {
         // Create
-        const createRes = await req('POST', '/drive/v2/files', { title: 'To Delete' });
+        const title = 'To Delete ' + Math.random().toString(36).substring(7);
+        const createRes = await req('POST', '/drive/v2/files', { title });
         const fileId = createRes.body.id;
 
         // Delete
@@ -121,14 +128,16 @@ describe('Google Drive API V2 Basics', () => {
     });
 
     it('should handle V2 parent references correctly', async () => {
+        const parentTitle = 'V2 Parent Folder ' + Math.random().toString(36).substring(7);
+        const childTitle = 'V2 Child File ' + Math.random().toString(36).substring(7);
         const parentRes = await req('POST', '/drive/v2/files', {
-            title: 'V2 Parent Folder',
+            title: parentTitle,
             mimeType: 'application/vnd.google-apps.folder'
         });
         const parentId = parentRes.body.id;
 
         const childRes = await req('POST', '/drive/v2/files', {
-            title: 'V2 Child File',
+            title: childTitle,
             parents: [{ id: parentId }]
         });