google-drive-mock 1.0.2 → 1.0.4

package/AGENTS.md

@@ -7,3 +7,8 @@ After making changes to the codebase or to the tests, always run the following c
 3. `npm test`
 4. `npm test:browser`
 5. `npm test:real`
+
+## Remember
+
+Whenever the `npm test:real` fails, fix the tests to match the "real" backend.
+Ensure that the behavior of the mock is exactly equal to the "real" backend.

package/dist/index.js

@@ -20,6 +20,7 @@ const batch_1 = require("./batch");
 const createApp = (config = {}) => {
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
+    app.set('etag', false); // Disable default ETag generation to match Real API behavior
     app.use((req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
         if (config.serverLagBefore && config.serverLagBefore > 0) {
             yield new Promise(resolve => setTimeout(resolve, config.serverLagBefore));
@@ -277,7 +278,20 @@ const createApp = (config = {}) => {
         }
         // Create File
         // Ensure name uniqueness check if needed (reusing logic from normal create)
-        const existing = store_1.driveStore.listFiles().find(f => f.name === metadata.name);
+        const existing = store_1.driveStore.listFiles().find(f => {
+            if (f.name !== metadata.name)
+                return false;
+            // Filter trashed?
+            if (f.trashed)
+                return false;
+            const newParents = metadata.parents || [];
+            const existingParents = f.parents || [];
+            // If both new and existing have NO parents, they are both in root -> Conflict
+            if (newParents.length === 0 && existingParents.length === 0)
+                return true;
+            // Check intersection of parents
+            return newParents.some((p) => existingParents.includes(p));
+        });
         if (existing) {
             res.status(409).json({ error: { code: 409, message: "Conflict: File with same name already exists" } });
             return;
@@ -293,7 +307,17 @@ const createApp = (config = {}) => {
             return;
         }
         // Enforce Unique Name Constraint (Mock Behavior customization)
-        const existing = store_1.driveStore.listFiles().find(f => f.name === body.name);
+        const existing = store_1.driveStore.listFiles().find(f => {
+            if (f.name !== body.name)
+                return false;
+            if (f.trashed)
+                return false;
+            const newParents = body.parents || [];
+            const existingParents = f.parents || [];
+            if (newParents.length === 0 && existingParents.length === 0)
+                return true;
+            return newParents.some((p) => existingParents.includes(p));
+        });
         if (existing) {
             res.status(409).json({ error: { code: 409, message: "Conflict: File with same name already exists" } });
             return;
@@ -313,12 +337,16 @@ const createApp = (config = {}) => {
             res.status(404).json({ error: { code: 404, message: "File not found" } });
             return;
         }
-        const etag = `"${file.version}"`;
-        res.setHeader('ETag', etag);
+        // Mock does not return ETag header because Real API (v3) does not return it by default/in this context.
+        // res.setHeader('ETag', etag);
+        // Real API also ignores If-None-Match if ETag is not supported?
+        // match behavior: do nothing.
+        /*
         if (req.headers['if-none-match'] === etag) {
             res.status(304).end();
             return;
         }
+        */
         res.json(file);
     });
     // Files: Update
@@ -337,6 +365,8 @@ const createApp = (config = {}) => {
         // Note: Real Google Drive API V3 was observed to allow overwrites (status 200) 
         // on PATCH even with mismatching If-Match headers (likely due to ETag generation nuances).
         // Relaxing Mock to match Real API behavior (Last Write Wins).
+        // Real API V3 observed behavior: Ignores If-Match (Last Write Wins).
+        // Mock matches this.
         /*
         const existingFile = driveStore.getFile(fileId);
         if (existingFile) {
@@ -362,7 +392,9 @@ const createApp = (config = {}) => {
             return;
         }
         // Check for Precondition (If-Match)
-        const existingFile = store_1.driveStore.getFile(fileId);
+        // Real API behavior: Ignores If-Match (returns 204 even on mismatch)
+        /*
+        const existingFile = driveStore.getFile(fileId);
         if (existingFile) {
             const ifMatch = req.headers['if-match'];
             if (ifMatch && ifMatch !== '*' && ifMatch !== `"${existingFile.version}"`) {
@@ -370,6 +402,7 @@ const createApp = (config = {}) => {
                 return;
             }
         }
+        */
         const deleted = store_1.driveStore.deleteFile(fileId);
         if (!deleted) {
             // According to Google API, delete might return 404 if not found, or 204 if successful (or 200). 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-drive-mock",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Mock-Server that simulates being google-drive. Used for testing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -11,6 +11,7 @@ interface AppConfig {
 const createApp = (config: AppConfig = {}) => {
     const app = express();
     app.use(cors());
+    app.set('etag', false); // Disable default ETag generation to match Real API behavior
 
     app.use(async (req, res, next) => {
         if (config.serverLagBefore && config.serverLagBefore > 0) {
@@ -300,7 +301,21 @@ const createApp = (config: AppConfig = {}) => {
 
         // Create File
         // Ensure name uniqueness check if needed (reusing logic from normal create)
-        const existing = driveStore.listFiles().find(f => f.name === metadata.name);
+        const existing = driveStore.listFiles().find(f => {
+            if (f.name !== metadata.name) return false;
+            // Filter trashed?
+            if (f.trashed) return false;
+
+            const newParents = metadata.parents || [];
+            const existingParents = f.parents || [];
+
+            // If both new and existing have NO parents, they are both in root -> Conflict
+            if (newParents.length === 0 && existingParents.length === 0) return true;
+
+            // Check intersection of parents
+            return newParents.some((p: string) => existingParents.includes(p));
+        });
+
         if (existing) {
             res.status(409).json({ error: { code: 409, message: "Conflict: File with same name already exists" } });
             return;
@@ -323,7 +338,18 @@ const createApp = (config: AppConfig = {}) => {
         }
 
         // Enforce Unique Name Constraint (Mock Behavior customization)
-        const existing = driveStore.listFiles().find(f => f.name === body.name);
+        const existing = driveStore.listFiles().find(f => {
+            if (f.name !== body.name) return false;
+            if (f.trashed) return false;
+
+            const newParents = body.parents || [];
+            const existingParents = f.parents || [];
+
+            if (newParents.length === 0 && existingParents.length === 0) return true;
+
+            return newParents.some((p: string) => existingParents.includes(p));
+        });
+
         if (existing) {
             res.status(409).json({ error: { code: 409, message: "Conflict: File with same name already exists" } });
             return;
@@ -353,13 +379,17 @@ const createApp = (config: AppConfig = {}) => {
             return;
         }
 
-        const etag = `"${file.version}"`;
-        res.setHeader('ETag', etag);
+        // Mock does not return ETag header because Real API (v3) does not return it by default/in this context.
+        // res.setHeader('ETag', etag);
 
+        // Real API also ignores If-None-Match if ETag is not supported?
+        // match behavior: do nothing.
+        /*
         if (req.headers['if-none-match'] === etag) {
             res.status(304).end();
             return;
         }
+        */
 
         res.json(file);
     });
@@ -382,6 +412,8 @@ const createApp = (config: AppConfig = {}) => {
         // Note: Real Google Drive API V3 was observed to allow overwrites (status 200) 
         // on PATCH even with mismatching If-Match headers (likely due to ETag generation nuances).
         // Relaxing Mock to match Real API behavior (Last Write Wins).
+        // Real API V3 observed behavior: Ignores If-Match (Last Write Wins).
+        // Mock matches this.
         /*
         const existingFile = driveStore.getFile(fileId);
         if (existingFile) {
@@ -411,6 +443,8 @@ const createApp = (config: AppConfig = {}) => {
             return;
         }
         // Check for Precondition (If-Match)
+        // Real API behavior: Ignores If-Match (returns 204 even on mismatch)
+        /*
         const existingFile = driveStore.getFile(fileId);
         if (existingFile) {
             const ifMatch = req.headers['if-match'];
@@ -419,6 +453,7 @@ const createApp = (config: AppConfig = {}) => {
                 return;
             }
         }
+        */
 
         const deleted = driveStore.deleteFile(fileId);
 

package/test/etag.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+import { Server } from 'http';
+
+// Helper to handle both Server (Node) and URL (Browser)
+async function makeRequest(
+    target: Server | string,
+    method: string,
+    path: string,
+    headers: Record<string, string>,
+    body?: unknown
+) {
+    if (typeof target === 'string') {
+        const url = `${target}${path}`;
+        const fetchOptions: RequestInit = {
+            method: method,
+            headers: headers
+        };
+        if (body) {
+            if (typeof body === 'string') {
+                fetchOptions.body = body;
+            } else {
+                fetchOptions.body = JSON.stringify(body);
+                if (!headers['Content-Type']) {
+                    headers['Content-Type'] = 'application/json';
+                }
+            }
+        }
+
+        const res = await fetch(url, fetchOptions);
+
+        const resBody = res.headers.get('content-type')?.includes('application/json')
+            ? await res.json()
+            : await res.text();
+
+        return { status: res.status, body: resBody, headers: res.headers };
+    } else {
+        const addr = target.address();
+        const port = typeof addr === 'object' && addr ? addr.port : 0;
+        const baseUrl = `http://localhost:${port}`;
+
+        return makeRequest(baseUrl, method, path, headers, body);
+    }
+}
+
+describe('ETag and If-Match Support', () => {
+    let config: TestConfig;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+    });
+
+    afterAll(() => {
+        if (config) config.stop();
+    });
+
+    async function req(method: string, path: string, body?: unknown, customHeaders: Record<string, string> = {}) {
+        const headers = {
+            'Authorization': `Bearer ${config.token}`,
+            ...customHeaders
+        };
+        return makeRequest(config.target, method, path, headers, body);
+    }
+
+    it('should NOT return ETag header when getting a file (Parity with Real API)', async () => {
+        // Create file
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: 'ETag Test File',
+            mimeType: 'text/plain',
+            parents: [config.testFolderId]
+        });
+        expect(createRes.status).toBe(200);
+        const fileId = createRes.body.id;
+
+        // Get file
+        const getRes = await req('GET', `/drive/v3/files/${fileId}?fields=*`);
+
+        expect(getRes.status).toBe(200);
+        // Real API v3 does not return 'etag' header in this context.
+        expect(getRes.headers.get('etag')).toBeFalsy();
+    });
+
+    it('should ignore If-Match (return 200) even if valid (Parity with Real API)', async () => {
+        // Create file
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: 'If-Match Success File',
+            parents: [config.testFolderId]
+        });
+        const fileId = createRes.body.id;
+
+        // Even if we send a "valid" hypothetical etag, it should pass (200)
+        // because Real API allows overwrites and seems to ignore If-Match if no ETag is present/supported.
+        const updateRes = await req('PATCH', `/drive/v3/files/${fileId}`, {
+            name: 'Updated Name'
+        }, {
+            'If-Match': '"1"'
+        });
+
+        expect(updateRes.status).toBe(200);
+        expect(updateRes.body.name).toBe('Updated Name');
+    });
+
+    it('should ignore If-Match (return 200) if If-Match does not match (Parity with Real API)', async () => {
+        // Create file
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: 'If-Match Fail File',
+            parents: [config.testFolderId]
+        });
+        const fileId = createRes.body.id;
+
+        // Update with incorrect If-Match
+        const updateRes = await req('PATCH', `/drive/v3/files/${fileId}`, {
+            name: 'Should Update Anyway'
+        }, {
+            'If-Match': '"invalid-tag"'
+        });
+
+        // Real API returns 200 (Last Write Wins)
+        expect(updateRes.status).toBe(200);
+        expect(updateRes.body.name).toBe('Should Update Anyway');
+    });
+
+    it('should allow PATCH if If-Match is * (Wildcard)', async () => {
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: 'Wildcard File',
+            parents: [config.testFolderId]
+        });
+        const fileId = createRes.body.id;
+
+        const updateRes = await req('PATCH', `/drive/v3/files/${fileId}`, {
+            name: 'Wildcard Updated'
+        }, {
+            'If-Match': '*'
+        });
+
+        expect(updateRes.status).toBe(200);
+        expect(updateRes.body.name).toBe('Wildcard Updated');
+    });
+
+    it('should allow DELETE if If-Match matches (Parity)', async () => {
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: 'Delete Success File',
+            parents: [config.testFolderId]
+        });
+        const fileId = createRes.body.id;
+
+        const deleteRes = await req('DELETE', `/drive/v3/files/${fileId}`, undefined, {
+            'If-Match': '"1"'
+        });
+
+        expect(deleteRes.status).toBe(204);
+        const verifyRes = await req('GET', `/drive/v3/files/${fileId}`);
+        expect(verifyRes.status).toBe(404);
+    });
+
+    it('should allow DELETE (204) if If-Match does not match (Parity)', async () => {
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: 'Delete Fail File',
+            parents: [config.testFolderId]
+        });
+        const fileId = createRes.body.id;
+
+        const deleteRes = await req('DELETE', `/drive/v3/files/${fileId}`, undefined, {
+            'If-Match': '"wrong-tag"'
+        });
+
+        // Real API returns 204 (Delete succeeded despite If-Match header)
+        expect(deleteRes.status).toBe(204);
+
+        const verifyRes = await req('GET', `/drive/v3/files/${fileId}`);
+        expect(verifyRes.status).toBe(404);
+    });
+});

package/test/routines.test.ts

@@ -140,26 +140,10 @@ describe('Complex Routines', () => {
                         return false;
                     }
 
-                    // EXPECT SUCCESS (Overwrite) -> Google Drive doesn't enforced lock on this.
+                    // Real API behavior (as observed) allows overwrite (Last Write Wins)
+                    // Mock now aligned to this.
                     expect(failUpdate.status).toBe(200);
                     return false; // Loop continues until we decide to release or successful acquire?
-                    // Wait, if we overwrote it, we broke the lock.
-                    // The test logic was: "Client B fails to write -> Lock works".
-                    // Now: "Client B OVERWRITES -> Lock failed".
-                    // We need to adjust the test goal. 
-                    // If we expect overwrite, then Client B *Successfully Acquired* (by stealing)?
-                    // Or we just verify behavior.
-
-                    // Let's change the test to:
-                    // Client B tries to acquire.
-                    // If file exists, it overwrites it.
-                    // This is NOT a lock simulation anymore. 
-
-                    // Actually, let's keep the structure but change expectation.
-                    // If overwrite succeeds, Client B effectively "won" but incorrectly.
-
-                    // For the sake of "passing tests against real API", we assert 200.
-                    return false; // Keep waiting? No, if we overwrote, we are done?
                 } else {
                     // Lock released, try to Acquire
                     const acquire = await req('POST', '/drive/v3/files', {

package/test/upload.test.ts

@@ -87,4 +87,86 @@ describe('Multipart Upload Feature', () => {
             expect(file['content']).toEqual(jsonContent);
         }
     });
+    it('should allow creating files with the same name in different folders (multipart)', async () => {
+        // 1. Create Parent A
+        const parentResA = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                name: 'FolderA_' + Date.now(),
+                mimeType: 'application/vnd.google-apps.folder',
+                parents: [config.testFolderId]
+            })
+        });
+        const parentIdA = (await parentResA.json()).id;
+
+        // 2. Create Parent B
+        const parentResB = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                name: 'FolderB_' + Date.now(),
+                mimeType: 'application/vnd.google-apps.folder',
+                parents: [config.testFolderId]
+            })
+        });
+        const parentIdB = (await parentResB.json()).id;
+
+        const commonFileName = 'DuplicateName.json';
+        const content = { foo: 'bar' };
+
+        // Helper to do multipart upload
+        const uploadFile = async (parentId: string) => {
+            const metadata = {
+                name: commonFileName,
+                parents: [parentId],
+                mimeType: 'application/json'
+            };
+
+            const multipartBoundary = '-------UniqueBoundary' + Date.now();
+            const delimiter = '\r\n--' + multipartBoundary + '\r\n';
+            const closeDelim = '\r\n--' + multipartBoundary + '--';
+
+            const body = delimiter +
+                'Content-Type: application/json\r\n\r\n' +
+                JSON.stringify(metadata) +
+                delimiter +
+                'Content-Type: application/json\r\n\r\n' +
+                JSON.stringify(content) +
+                closeDelim;
+
+            const url = `${config.baseUrl}/upload/drive/v3/files?uploadType=multipart&fields=id`;
+            return fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: 'Bearer ' + config.token,
+                    'Content-Type': 'multipart/related; boundary="' + multipartBoundary + '"'
+                },
+                body
+            });
+        };
+
+        // 3. Upload to Folder A
+        const resA = await uploadFile(parentIdA);
+        expect(resA.status).toBe(200);
+        const fileA = await resA.json();
+
+        // 4. Upload to Folder B (Should succeed)
+        const resB = await uploadFile(parentIdB);
+
+        if (!resB.ok) {
+            console.log('Duplicate upload failed:', resB.status, await resB.text());
+        }
+        expect(resB.status).toBe(200);
+        const fileB = await resB.json();
+
+        // IDs must be different
+        expect(fileA.id).not.toBe(fileB.id);
+    });
 });