google-drive-mock 1.0.9 → 1.0.11

package/src/routes/v3.ts

@@ -21,55 +21,67 @@ export const createV3Router = () => {
 
         if (q) {
             // Enhanced query parser for Mock
-            const parts = q.split(' and ').map(p => p.trim());
-
+            const orParts = q.split(' or ');
             files = files.filter(file => {
-                return parts.every(part => {
-                    // name = '...'
-                    if (part.startsWith("name = '")) {
-                        const name = part.match(/name = '(.*)'/)?.[1];
-                        return file.name === name;
-                    }
-                    // name contains '...'
-                    if (part.startsWith("name contains '")) {
-                        const token = part.match(/name contains '(.*)'/)?.[1];
-                        return token && file.name.includes(token);
-                    }
-                    // 'ID' in parents
-                    if (part.includes(" in parents")) {
-                        const parentId = part.match(/'(.*)' in parents/)?.[1];
-                        return parentId && file.parents?.includes(parentId);
-                    }
-                    // trashed = ...
-                    if (part === "trashed = false") {
-                        return file.trashed !== true;
-                    }
-                    if (part === "trashed = true") {
-                        return file.trashed === true;
-                    }
-                    // mimeType = '...'
-                    if (part.startsWith("mimeType = '")) {
-                        const mime = part.match(/mimeType = '(.*)'/)?.[1];
-                        return file.mimeType === mime;
-                    }
-                    // mimeType != '...'
-                    if (part.startsWith("mimeType != '")) {
-                        const mime = part.match(/mimeType != '(.*)'/)?.[1];
-                        return file.mimeType !== mime;
-                    }
-                    // modifiedTime > '...'
-                    if (part.startsWith("modifiedTime > '")) {
-                        const timeStr = part.match(/modifiedTime > '(.*)'/)?.[1];
-                        return timeStr && new Date(file.modifiedTime) > new Date(timeStr);
-                    }
-                    // modifiedTime < '...'
-                    if (part.startsWith("modifiedTime < '")) {
-                        const timeStr = part.match(/modifiedTime < '(.*)'/)?.[1];
-                        return timeStr && new Date(file.modifiedTime) < new Date(timeStr);
-                    }
+                return orParts.some(orPart => {
+                    const andParts = orPart.split(' and ').map(p => p.trim());
+                    return andParts.every(part => {
+                        // name = '...'
+                        if (part.startsWith("name = '")) {
+                            const name = part.match(/name = '(.*)'/)?.[1];
+                            // Handle escaped quotes if simple match fails, but simple regex here might be enough for now
+                            // The user does name.replace("'", "\\'") but the regex (.*) is greedy and might consume escaped quotes correctly-ish
+                            // but we are stripping the outer quotes.
+                            // If user sends: name = 'foo\'bar', regex captures: foo\'bar
+                            // We need to unescape? The user sends escaped string for the Query Parser.
+                            // Drive API expects the string inside quotes to be the value.
+                            // If `name = 'a\'b'`, the value is `a'b`.
+                            // JSON.parse(`"${name}"`) might decode it if we treat it as JSON string? Use simple replace for now.
+                            const finalName = name ? name.replace(/\\'/g, "'") : name;
+                            return file.name === finalName;
+                        }
+                        // name contains '...'
+                        if (part.startsWith("name contains '")) {
+                            const token = part.match(/name contains '(.*)'/)?.[1];
+                            const finalToken = token ? token.replace(/\\'/g, "'") : token;
+                            return finalToken && file.name.includes(finalToken);
+                        }
+                        // 'ID' in parents
+                        if (part.includes(" in parents")) {
+                            const parentId = part.match(/'(.*)' in parents/)?.[1];
+                            return parentId && file.parents?.includes(parentId);
+                        }
+                        // trashed = ...
+                        if (part === "trashed = false") {
+                            return file.trashed !== true;
+                        }
+                        if (part === "trashed = true") {
+                            return file.trashed === true;
+                        }
+                        // mimeType = '...'
+                        if (part.startsWith("mimeType = '")) {
+                            const mime = part.match(/mimeType = '(.*)'/)?.[1];
+                            return file.mimeType === mime;
+                        }
+                        // mimeType != '...'
+                        if (part.startsWith("mimeType != '")) {
+                            const mime = part.match(/mimeType != '(.*)'/)?.[1];
+                            return file.mimeType !== mime;
+                        }
+                        // modifiedTime > '...'
+                        if (part.startsWith("modifiedTime > '")) {
+                            const timeStr = part.match(/modifiedTime > '(.*)'/)?.[1];
+                            return timeStr && new Date(file.modifiedTime) > new Date(timeStr);
+                        }
+                        // modifiedTime < '...'
+                        if (part.startsWith("modifiedTime < '")) {
+                            const timeStr = part.match(/modifiedTime < '(.*)'/)?.[1];
+                            return timeStr && new Date(file.modifiedTime) < new Date(timeStr);
+                        }
 
-                    // Ignore unknown filters for now
-                    return true;
+                        // Ignore unknown filters for now
+                        return true;
+                    });
                 });
             });
         }
@@ -143,8 +155,25 @@ export const createV3Router = () => {
     // Upload Files Route
     app.post('/upload/drive/v3/files', (req: Request, res: Response) => {
         const uploadType = req.query.uploadType;
-        if (uploadType !== 'multipart') {
-            res.status(400).json({ error: { code: 400, message: "Only uploadType=multipart is supported in this mock route" } });
+        if (uploadType !== 'multipart' && uploadType !== 'media') {
+            res.status(400).json({ error: { code: 400, message: "Only uploadType=multipart or uploadType=media is supported in this mock route" } });
+            return;
+        }
+
+        if (uploadType === 'media') {
+            const rawBody = req.body;
+            // Handle edge case where express.json() parses empty body as {}
+            if (req.headers['content-length'] === '0' && JSON.stringify(rawBody) === '{}') {
+                // Empty body
+            }
+
+            const newFile = driveStore.createFile({
+                name: "Untitled",
+                mimeType: req.headers['content-type'] || "application/octet-stream",
+                parents: [],
+                content: typeof rawBody === 'string' ? rawBody : JSON.stringify(rawBody) // Handle body if parsed
+            });
+            res.status(200).json(newFile);
             return;
         }
 
@@ -214,23 +243,6 @@ export const createV3Router = () => {
             content = contentPart.body;
         }
 
-        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 (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;
-        }
-
         const newFile = driveStore.createFile({
             ...metadata,
             content: content
@@ -266,8 +278,81 @@ export const createV3Router = () => {
             return;
         }
 
-        // Add multipart support if needed, but media is primary for now
-        res.status(400).json({ error: { code: 400, message: "Only uploadType=media is currently supported for V3 PATCH upload" } });
+        const contentTypeHeader = req.headers['content-type'];
+        const contentType = Array.isArray(contentTypeHeader) ? contentTypeHeader[0] : contentTypeHeader;
+
+        // Check for multipart
+        if (contentType && contentType.includes('multipart/related')) {
+            const boundaryMatch = contentType.match(/boundary=(.+)/);
+            if (!boundaryMatch) {
+                res.status(400).json({ error: { code: 400, message: "Multipart boundary missing" } });
+                return;
+            }
+            let boundary = boundaryMatch[1];
+            if (boundary.startsWith('"') && boundary.endsWith('"')) {
+                boundary = boundary.substring(1, boundary.length - 1);
+            }
+
+            const rawBody = req.body;
+            if (typeof rawBody !== 'string') {
+                res.status(400).json({ error: { code: 400, message: "Body parsing failed" } });
+                return;
+            }
+
+            const parts = rawBody.split(`--${boundary}`);
+            const validParts = parts.filter(p => p.trim() !== '' && p.trim() !== '--');
+
+            if (validParts.length < 2) {
+                res.status(400).json({ error: { code: 400, message: "Invalid multipart body: expected at least metadata and content" } });
+                return;
+            }
+
+            const parsePart = (rawPart: string) => {
+                const splitIndex = rawPart.indexOf('\r\n\r\n');
+                if (splitIndex === -1) return null;
+                const headers = rawPart.substring(0, splitIndex).trim();
+                const body = rawPart.substring(splitIndex + 4);
+                return {
+                    headers,
+                    body: body.replace(/\r\n$/, '') // Remove trailing CRLF from part body
+                };
+            };
+
+            const metadataPart = parsePart(validParts[0]);
+            const contentPart = parsePart(validParts[1]);
+
+            if (!metadataPart || !contentPart) {
+                res.status(400).json({ error: { code: 400, message: "Failed to parse parts" } });
+                return;
+            }
+
+            let metadata;
+            try {
+                metadata = JSON.parse(metadataPart.body);
+            } catch {
+                res.status(400).json({ error: { code: 400, message: "Invalid JSON in metadata part" } });
+                return;
+            }
+
+            let content;
+            try {
+                content = JSON.parse(contentPart.body);
+            } catch {
+                content = contentPart.body;
+            }
+
+            // Perform update
+            const updatedFile = driveStore.updateFile(fileId, {
+                ...metadata,
+                content: content,
+                modifiedTime: new Date().toISOString()
+            });
+
+            res.status(200).json(updatedFile);
+            return;
+        }
+
+        res.status(400).json({ error: { code: 400, message: "Only uploadType=media or multipart/related is supported for V3 PATCH upload" } });
     });
 
     // Files: Create (Standard)

package/src/store.ts

@@ -1,3 +1,5 @@
+import * as crypto from 'crypto';
+
 export interface DriveFile {
     id: string;
     name: string;
@@ -9,6 +11,8 @@ export interface DriveFile {
     trashed: boolean;
     createdTime: string;
     modifiedTime: string;
+    size: string;
+    md5Checksum: string;
     [key: string]: unknown;
 }
 
@@ -46,22 +50,45 @@ export class DriveStore {
         this.changes = [];
     }
 
+    private calculateStats(content: unknown): { size: string, md5Checksum: string } {
+        let buffer: Buffer;
+        if (typeof content === 'string') {
+            buffer = Buffer.from(content);
+        } else if (content === undefined || content === null) {
+            buffer = Buffer.from('');
+        } else {
+            buffer = Buffer.from(JSON.stringify(content));
+        }
+
+        return {
+            size: String(buffer.length),
+            md5Checksum: crypto.createHash('md5').update(buffer).digest('hex')
+        };
+    }
+
     createFile(file: Partial<DriveFile> & { name: string }): DriveFile {
         if (!file.name) {
             throw new Error("File name is required");
         }
         const id = file.id || Math.random().toString(36).substring(7);
         const now = new Date().toISOString();
+
+        const stats = this.calculateStats(file.content);
+
         const newFile: DriveFile = {
             kind: "drive#file",
             mimeType: "application/octet-stream",
             trashed: false,
             createdTime: now,
             modifiedTime: now,
+
             ...file,
             id,
             version: 1, // Initialize version
             etag: "1", // Initialize etag
+            // Ensure calculated stats override provided ones
+            size: stats.size,
+            md5Checksum: stats.md5Checksum
         };
 
         this.files.set(id, newFile);
@@ -73,11 +100,18 @@ export class DriveStore {
         const file = this.files.get(id);
         if (!file) return null;
 
+        // If content is being updated, recalculate stats
+        let statsUpdates = {};
+        if (updates.content !== undefined) {
+            statsUpdates = this.calculateStats(updates.content);
+        }
+
         // Merge updates and increment version
         const newVersion = file.version + 1;
         const updatedFile = {
             ...file,
             ...updates,
+            ...statsUpdates,
             version: newVersion,
             etag: String(newVersion),
             modifiedTime: new Date().toISOString()

package/test/batch_and_query.test.ts

@@ -0,0 +1,206 @@
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+describe('Batch and Complex Query Operations', () => {
+    let config: TestConfig;
+    let createdFileIds: string[] = [];
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+    });
+
+    afterAll(async () => {
+        // Cleanup if needed
+        if (config) config.stop();
+    });
+
+    it('should perform bulk insert using batch API', async () => {
+        const docs = [
+            { id: 'bulk1', content: '{"foo":1}' },
+            { id: 'bulk2', content: '{"bar":2}' }
+        ];
+        const boundary = "batch_" + Math.random().toString(16).slice(2);
+
+        // Ensure we have a valid folder ID. Using root or a test folder from config.
+        const targetFolderId = config.testFolderId;
+
+        const parts = docs.map((doc, i) => {
+            const id = doc.id;
+            const body = JSON.stringify({
+                name: id + '.json',
+                mimeType: 'application/json',
+                parents: [targetFolderId],
+            });
+
+            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 url = config.baseUrl + "/batch/drive/v3";
+        console.log('Sending batch insert request to:', url);
+
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+                "Content-Type": `multipart/mixed; boundary=${boundary}`,
+            },
+            body: batchBody,
+        });
+
+        expect(res.status).toBe(200);
+
+        const contentType = res.headers.get('content-type');
+        expect(contentType).toContain('multipart/mixed');
+
+        const text = await res.text();
+        console.log('Batch Insert Response:', text);
+
+        // Verify operations succeeded
+        expect(text).toContain('HTTP/1.1 200 OK');
+
+        // Extract IDs for later use in update tests
+        // This is a bit hacky parsing but sufficient for test
+        // Responses are JSON inside multipart
+        // We can list files to get IDs reliably
+        const listRes = await fetch(config.baseUrl + `/drive/v3/files?q='${targetFolderId}'+in+parents`, {
+            headers: { Authorization: `Bearer ${config.token}` }
+        });
+        const listData = await listRes.json();
+        const files = listData.files.filter((f: { name: string; id: string }) => f.name === 'bulk1.json' || f.name === 'bulk2.json');
+        expect(files.length).toBe(2);
+        createdFileIds = files.map((f: { id: string }) => f.id);
+    });
+
+    it('should perform bulk find using complex query', async () => {
+        // Ensure the files exist from previous test
+        expect(createdFileIds.length).toBe(2);
+        const docIds = ['bulk1', 'bulk2'];
+
+        const fileNames = docIds.map(id => id + '.json');
+        let q = fileNames
+            .map(name => `name = '${name.replace("'", "\\'")}'`)
+            .join(' or ');
+        q += ' and trashed = false';
+        q += ' and \'' + config.testFolderId + '\' in parents';
+
+        console.log('Bulk Find Query:', q);
+
+        const params = new URLSearchParams({
+            q,
+            fields: "nextPageToken, files(id,name,mimeType,parents,modifiedTime,size)",
+            includeItemsFromAllDrives: "true",
+            supportsAllDrives: "true",
+        });
+        const url = config.baseUrl + '/drive/v3/files?' + params.toString();
+        const res = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+            },
+        });
+
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        // Should find both files
+        expect(data.files).toBeDefined();
+        // Depending on query parsing logic, it might find one or both or none if logic is broken
+        // The expectation is that this query works "like" finding specific files in a folder
+        const foundNames = data.files.map((f: { name: string }) => f.name);
+        expect(foundNames).toContain('bulk1.json');
+        expect(foundNames).toContain('bulk2.json');
+        expect(data.files.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('should perform bulk update using batch API', async () => {
+        expect(createdFileIds.length).toBe(2);
+
+        interface DocUpdate {
+            id: string;
+            newName: string;
+        }
+        const docs: DocUpdate[] = [
+            { id: 'bulk1', newName: 'bulk1_updated' },
+            { id: 'bulk2', newName: 'bulk2_updated' }
+        ];
+
+        // Map doc ID to file ID (assuming order or searching)
+        // For simplicity, we'll fetch IDs again or use stored ones knowing names match
+        // Let's assume createdFileIds corresponds to 'bulk1.json' and 'bulk2.json' somehow
+        // But better to use exact mapping.
+
+        // Re-fetch to be sure of mapping
+        const listRes = await fetch(config.baseUrl + `/drive/v3/files?q='${config.testFolderId}'+in+parents`, {
+            headers: { Authorization: `Bearer ${config.token}` }
+        });
+        const listData = await listRes.json();
+        const fileIdByDocId: Record<string, string> = {};
+        for (const f of listData.files) {
+            if (f.name === 'bulk1.json') fileIdByDocId['bulk1'] = f.id;
+            if (f.name === 'bulk2.json') fileIdByDocId['bulk2'] = f.id;
+        }
+
+        const boundary = "batch_" + Math.random().toString(16).slice(2);
+
+        const parts = docs.map((doc, i) => {
+            const id = doc.id;
+            const fileId = fileIdByDocId[id];
+            if (!fileId) throw new Error(`File ID not found for ${id}`);
+
+            const body = JSON.stringify({
+                name: doc.newName + '.json',
+                mimeType: "application/json",
+                // parents: [config.testFolderId], // Optional in update usually
+            });
+
+            return (
+                `--${boundary}\r\n` +
+                `Content-Type: application/http\r\n` +
+                `Content-ID: <item-${i}>\r\n\r\n` +
+                `PATCH /drive/v3/files/${encodeURIComponent(fileId)}?supportsAllDrives=true&fields=id,name,mimeType,parents 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 url = config.baseUrl + "/batch/drive/v3";
+        console.log('Sending batch update request to:', url);
+
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+                "Content-Type": `multipart/mixed; boundary=${boundary}`,
+            },
+            body: batchBody,
+        });
+
+        expect(res.status).toBe(200);
+        const text = await res.text();
+        console.log('Batch Update Response:', text);
+
+        expect(text).toContain('HTTP/1.1 200 OK');
+
+        // Verify updates
+        const verifyRes = await fetch(config.baseUrl + `/drive/v3/files?q='${config.testFolderId}'+in+parents`, {
+            headers: { Authorization: `Bearer ${config.token}` }
+        });
+        const verifyData = await verifyRes.json();
+        const names = verifyData.files.map((f: { name: string }) => f.name);
+        expect(names).toContain('bulk1_updated.json');
+        expect(names).toContain('bulk2_updated.json');
+        expect(names).not.toContain('bulk1.json');
+    });
+});