google-drive-mock 0.0.1

package/src/batch.ts

@@ -0,0 +1,286 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { driveStore } from './store';
+import { Request, Response } from 'express';
+
+interface BatchPart {
+    contentId: string;
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: any;
+}
+
+interface BatchResponse {
+    contentId: string;
+    statusCode: number;
+    body?: any;
+}
+
+export const handleBatchRequest = (req: Request, res: Response) => {
+    const contentType = req.headers['content-type'];
+    if (!contentType || !contentType.includes('multipart/mixed')) {
+        return res.status(400).send('Content-Type must be multipart/mixed');
+    }
+
+    const boundaryMatch = contentType.match(/boundary=(.+)/);
+    if (!boundaryMatch) {
+        return res.status(400).send('Multipart boundary missing');
+    }
+    let boundary = boundaryMatch[1];
+    // Boundaries in header can be quoted
+    if (boundary.startsWith('"') && boundary.endsWith('"')) {
+        boundary = boundary.substring(1, boundary.length - 1);
+    }
+
+    const rawBody = req.body;
+    if (typeof rawBody !== 'string') {
+        return res.status(400).send('Body parsing failed');
+    }
+
+    const parts = parseMultipart(rawBody, boundary);
+    const responses: BatchResponse[] = [];
+
+    for (const part of parts) {
+        const response = processPart(part);
+        responses.push(response);
+    }
+
+    const responseBoundary = `batch_${Math.random().toString(36).substring(2)}`;
+    const responseBody = buildMultipartResponse(responses, responseBoundary);
+
+    res.set('Content-Type', `multipart/mixed; boundary=${responseBoundary}`);
+    res.end(responseBody);
+};
+
+function parseMultipart(body: string, boundary: string): BatchPart[] {
+    const parts: BatchPart[] = [];
+    // Split by --boundary
+    // Note: The last part ends with --boundary--
+    const rawParts = body.split(`--${boundary}`);
+
+    for (const rawPart of rawParts) {
+        // Skip empty or end parts
+        if (rawPart.trim() === '' || rawPart.trim() === '--') continue;
+
+        // Parse outer headers
+        const sections = rawPart.trim().split(/\r?\n\r?\n/);
+        const headersSection = sections[0];
+        const rest = sections.slice(1);
+
+        let contentId = '';
+        const headerLines = headersSection.split(/\r?\n/);
+        for (const line of headerLines) {
+            if (line.toLowerCase().startsWith('content-id:')) {
+                contentId = line.split(':')[1].trim();
+            }
+        }
+
+        const httpContent = rest.join('\r\n\r\n'); // Reconstruct body if multiple parts? 
+
+        if (!httpContent && sections.length < 2) continue; // No body?
+
+        // Ideally, httpContent is the rest. 
+        // But if we split by double newline, we might have split the inner body too.
+        // Better: Find first double newline index manually.
+
+        // ... (Rewriting loop to be safer)
+
+        const firstDoubleNewline = rawPart.indexOf('\r\n\r\n');
+        const firstDoubleNewlineLF = rawPart.indexOf('\n\n');
+
+        let splitIndex = -1;
+        let splitLen = 0;
+
+        if (firstDoubleNewline !== -1) {
+            splitIndex = firstDoubleNewline;
+            splitLen = 4;
+        } else if (firstDoubleNewlineLF !== -1) {
+            splitIndex = firstDoubleNewlineLF;
+            splitLen = 2;
+        }
+
+        if (splitIndex === -1) continue;
+
+        const headersStr = rawPart.substring(0, splitIndex).trim();
+        const bodyStr = rawPart.substring(splitIndex + splitLen); // No trim on body?
+
+        // Parse outer headers
+        const hLines = headersStr.split(/\r?\n/);
+        for (const line of hLines) {
+            if (line.toLowerCase().startsWith('content-id:')) {
+                contentId = line.split(':')[1].trim();
+            }
+        }
+
+        if (!bodyStr) continue;
+
+        // Inner HTTP part
+        // Same logic for inner split
+        const innerSplitIndexCRLF = bodyStr.indexOf('\r\n\r\n');
+        const innerSplitIndexLF = bodyStr.indexOf('\n\n');
+
+        let innerSplitIndex = -1;
+        let innerSplitLen = 0;
+
+        if (innerSplitIndexCRLF !== -1) {
+            innerSplitIndex = innerSplitIndexCRLF;
+            innerSplitLen = 4;
+        } else if (innerSplitIndexLF !== -1 && (innerSplitIndexCRLF === -1 || innerSplitIndexLF < innerSplitIndexCRLF)) {
+            innerSplitIndex = innerSplitIndexLF;
+            innerSplitLen = 2;
+        }
+
+        // If NO header terminator found in inner body, maybe no headers? (But request line exists)
+        // Request line is mandatory.
+
+        let requestLine = '';
+        let innerHeadersStr = '';
+        let httpBody = '';
+
+        if (innerSplitIndex !== -1) {
+            const head = bodyStr.substring(0, innerSplitIndex);
+            httpBody = bodyStr.substring(innerSplitIndex + innerSplitLen);
+            const lines = head.split(/\r?\n/);
+            requestLine = lines[0];
+            innerHeadersStr = lines.slice(1).join('\n');
+        } else {
+            // Maybe no body? Just headers?
+            const lines = bodyStr.trim().split(/\r?\n/);
+            requestLine = lines[0];
+            innerHeadersStr = lines.slice(1).join('\n');
+            httpBody = '';
+        }
+
+        const [method, url] = requestLine.split(' ');
+
+        // Parse inner headers
+        const headers: Record<string, string> = {};
+        const innerHLines = innerHeadersStr.split(/\r?\n/);
+        for (const line of innerHLines) {
+            const [key, ...value] = line.split(':');
+            if (key) headers[key.toLowerCase()] = value.join(':').trim();
+        }
+
+        let parsedBody;
+        if (httpBody && httpBody.trim()) {
+            try {
+                parsedBody = JSON.parse(httpBody);
+            } catch {
+                parsedBody = httpBody;
+            }
+        }
+
+        // Clean URL (remove prefix if present, though clients usually send relative path)
+        // Ensure /drive/v3/files...
+
+        parts.push({
+            contentId,
+            method,
+            url,
+            headers,
+            body: parsedBody
+        });
+    }
+
+    return parts;
+}
+
+function processPart(part: BatchPart): BatchResponse {
+    // Simple logic dispatch
+    // We only support /drive/v3/files operations basically
+
+    // Helper to match URL (Simplified for mock)
+    const fileIdMatch = part.url.match(/\/drive\/v3\/files\/([^/?]+)/);
+    const filesListMatch = part.url.match(/\/drive\/v3\/files/); // Matches /drive/v3/files?q=... or just .../files
+    const aboutMatch = part.url.match(/\/drive\/v3\/about/);
+
+    try {
+        // GET File
+        if (part.method === 'GET' && fileIdMatch) {
+            const fileId = fileIdMatch[1];
+            const file = driveStore.getFile(fileId);
+            if (!file) return { contentId: part.contentId, statusCode: 404, body: { error: { code: 404, message: 'File not found' } } };
+            return { contentId: part.contentId, statusCode: 200, body: file };
+        }
+
+        // GET Files List
+        if (part.method === 'GET' && filesListMatch && !fileIdMatch) {
+            const files = driveStore.listFiles();
+            return {
+                contentId: part.contentId,
+                statusCode: 200,
+                body: {
+                    kind: "drive#fileList",
+                    incompleteSearch: false,
+                    files: files
+                }
+            };
+        }
+
+        // GET About
+        if (part.method === 'GET' && aboutMatch) {
+            const about = driveStore.getAbout();
+            return {
+                contentId: part.contentId,
+                statusCode: 200,
+                body: {
+                    kind: "drive#about",
+                    ...about
+                }
+            };
+        }
+
+        // POST Create File
+        if (part.method === 'POST' && filesListMatch) {
+            if (!part.body || !part.body.name) {
+                return { contentId: part.contentId, statusCode: 400, body: { error: { code: 400, message: 'Name required' } } };
+            }
+            const newFile = driveStore.createFile({
+                name: part.body.name,
+                mimeType: part.body.mimeType,
+                parents: part.body.parents
+            });
+            return { contentId: part.contentId, statusCode: 200, body: newFile };
+        }
+
+        if (part.method === 'PATCH' && fileIdMatch) {
+            const fileId = fileIdMatch[1];
+            const updated = driveStore.updateFile(fileId, part.body);
+            if (!updated) return { contentId: part.contentId, statusCode: 404, body: { error: { code: 404, message: 'File not found' } } };
+            return { contentId: part.contentId, statusCode: 200, body: updated };
+        }
+
+        if (part.method === 'DELETE' && fileIdMatch) {
+            const fileId = fileIdMatch[1];
+            const deleted = driveStore.deleteFile(fileId);
+            if (!deleted) return { contentId: part.contentId, statusCode: 404, body: { error: { code: 404, message: 'File not found' } } };
+            return { contentId: part.contentId, statusCode: 204 }; // No body
+        }
+
+        return { contentId: part.contentId, statusCode: 404, body: { error: { message: "Not handler found for batch request url " + part.url } } };
+
+    } catch (e: any) {
+        return { contentId: part.contentId, statusCode: 500, body: { error: { message: e.message } } };
+    }
+}
+
+function buildMultipartResponse(responses: BatchResponse[], boundary: string): string {
+    let output = '';
+
+    for (const response of responses) {
+        output += `--${boundary}\r\n`;
+        output += `Content-Type: application/http\r\n`;
+        output += `Content-ID: ${response.contentId}\r\n\r\n`;
+
+        output += `HTTP/1.1 ${response.statusCode} OK\r\n`; // Simplified status text
+        output += `Content-Type: application/json; charset=UTF-8\r\n\r\n`;
+
+        if (response.body) {
+            output += JSON.stringify(response.body) + '\r\n';
+        }
+        output += '\r\n';
+    }
+
+    output += `--${boundary}--`;
+    return output;
+}

package/src/index.ts

@@ -0,0 +1,219 @@
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import { driveStore } from './store';
+import { handleBatchRequest } from './batch';
+
+interface AppConfig {
+    serverLagBefore?: number;
+    serverLagAfter?: number;
+}
+
+const createApp = (config: AppConfig = {}) => {
+    const app = express();
+    app.use(cors());
+
+    app.use(async (req, res, next) => {
+        if (config.serverLagBefore && config.serverLagBefore > 0) {
+            await new Promise(resolve => setTimeout(resolve, config.serverLagBefore));
+        }
+
+        if (config.serverLagAfter && config.serverLagAfter > 0) {
+            const originalSend = res.send;
+            res.send = function (...args) {
+                setTimeout(() => {
+                    originalSend.apply(res, args);
+                }, config.serverLagAfter);
+                return res;
+            };
+        }
+        next();
+    });
+
+    app.use(express.json());
+    app.use(express.text({ type: 'multipart/mixed' }));
+
+    // Batch Route
+    app.post('/batch', handleBatchRequest);
+
+    // Debug Route (for testing)
+    app.post('/debug/clear', (req, res) => {
+        driveStore.clear();
+        res.status(200).send('Cleared');
+    });
+
+    // Health Check
+    app.get('/', (req, res) => {
+        res.status(200).send('OK');
+    });
+
+    // Auth Middleware
+    const validTokens = ['valid-token', 'another-valid-token'];
+    app.use((req, res, next) => {
+        const authHeader = req.headers.authorization;
+        if (!authHeader) {
+            res.status(401).json({ error: { code: 401, message: "Unauthorized: No token provided" } });
+            return;
+        }
+
+        const token = authHeader.split(' ')[1];
+        if (!validTokens.includes(token)) {
+            res.status(401).json({ error: { code: 401, message: "Unauthorized: Invalid token" } });
+            return;
+        }
+        next();
+    });
+
+    // Middleware to simulate some Google API behaviors (optional, can be expanded)
+
+    // About
+    app.get('/drive/v3/about', (req: Request, res: Response) => {
+        const about = driveStore.getAbout();
+        res.json({
+            kind: "drive#about",
+            ...about
+        });
+    });
+
+    // Files: List
+    app.get('/drive/v3/files', (req: Request, res: Response) => {
+        const files = driveStore.listFiles();
+        res.json({
+            kind: "drive#fileList",
+            incompleteSearch: false,
+            files: files
+        });
+    });
+
+    // Files: Create
+    app.post('/drive/v3/files', (req: Request, res: Response) => {
+        const body = req.body;
+        if (!body || !body.name) {
+            res.status(400).json({ error: { code: 400, message: "Bad Request: Name is required" } });
+            return;
+        }
+
+        // Enforce Unique Name Constraint (Mock Behavior customization)
+        const existing = driveStore.listFiles().find(f => f.name === body.name);
+        if (existing) {
+            res.status(409).json({ error: { code: 409, message: "Conflict: File with same name already exists" } });
+            return;
+        }
+
+        const newFile = driveStore.createFile({
+            name: body.name,
+            mimeType: body.mimeType || "application/octet-stream",
+            parents: body.parents || []
+        });
+
+        res.status(200).json(newFile);
+    });
+
+    // Files: Get
+    app.get('/drive/v3/files/:fileId', (req: Request, res: Response) => {
+        const fileId = req.params.fileId;
+        if (typeof fileId !== 'string') {
+            res.status(400).send("Invalid file ID");
+            return;
+        }
+        const file = driveStore.getFile(fileId);
+
+        if (!file) {
+            res.status(404).json({ error: { code: 404, message: "File not found" } });
+            return;
+        }
+
+        const etag = `"${file.version}"`;
+        res.setHeader('ETag', etag);
+
+        if (req.headers['if-none-match'] === etag) {
+            res.status(304).end();
+            return;
+        }
+
+        res.json(file);
+    });
+
+    // Files: Update
+    app.patch('/drive/v3/files/:fileId', (req: Request, res: Response) => {
+        const fileId = req.params.fileId;
+        if (typeof fileId !== 'string') {
+            res.status(400).send("Invalid file ID");
+            return;
+        }
+        const updates = req.body;
+
+        if (!updates) {
+            res.status(400).json({ error: { code: 400, message: "Bad Request: No updates provided" } });
+            return;
+        }
+
+        // Check for Precondition (If-Match)
+        // 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).
+        /*
+        const existingFile = driveStore.getFile(fileId);
+        if (existingFile) {
+            const ifMatch = req.headers['if-match'];
+            if (ifMatch && ifMatch !== '*' && ifMatch !== `"${existingFile.version}"`) {
+                res.status(412).json({ error: { code: 412, message: "Precondition Failed" } });
+                return;
+            }
+        }
+        */
+
+        const updatedFile = driveStore.updateFile(fileId, updates);
+
+        if (!updatedFile) {
+            res.status(404).json({ error: { code: 404, message: "File not found" } });
+            return;
+        }
+
+        res.json(updatedFile);
+    });
+
+    // Files: Delete
+    app.delete('/drive/v3/files/:fileId', (req: Request, res: Response) => {
+        const fileId = req.params.fileId;
+        if (typeof fileId !== 'string') {
+            res.status(400).send("Invalid file ID");
+            return;
+        }
+        // Check for Precondition (If-Match)
+        const existingFile = driveStore.getFile(fileId);
+        if (existingFile) {
+            const ifMatch = req.headers['if-match'];
+            if (ifMatch && ifMatch !== '*' && ifMatch !== `"${existingFile.version}"`) {
+                res.status(412).json({ error: { code: 412, message: "Precondition Failed" } });
+                return;
+            }
+        }
+
+        const deleted = driveStore.deleteFile(fileId);
+
+        if (!deleted) {
+            // According to Google API, delete might return 404 if not found, or 204 if successful (or 200). 
+            // Docs says "If successful, this method returns an empty response body." usually 204.
+            // But if not found:
+            res.status(404).json({ error: { code: 404, message: "File not found" } });
+            return;
+        }
+
+        res.status(204).send();
+    });
+
+    return app;
+};
+
+const startServer = (port: number, host: string = 'localhost', config: AppConfig = {}) => {
+    const app = createApp(config);
+    return app.listen(port, host, () => {
+        console.log(`Server is running on http://${host}:${port}`);
+    });
+};
+
+if (require.main === module) {
+    startServer(3000);
+}
+
+export { createApp, startServer };

package/src/store.ts

@@ -0,0 +1,85 @@
+export interface DriveFile {
+    id: string;
+    name: string;
+    mimeType: string;
+    kind: string;
+    parents?: string[];
+    version: number;
+    [key: string]: unknown;
+}
+
+export class DriveStore {
+    private files: Map<string, DriveFile>;
+
+    constructor() {
+        this.files = new Map();
+    }
+
+    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 newFile: DriveFile = {
+            kind: "drive#file",
+            mimeType: "application/octet-stream",
+            ...file,
+            id,
+            version: 1, // Initialize version
+        };
+
+        this.files.set(id, newFile);
+        return newFile;
+    }
+
+    updateFile(id: string, updates: Partial<DriveFile>): DriveFile | null {
+        const file = this.files.get(id);
+        if (!file) return null;
+
+        // Merge updates and increment version
+        const updatedFile = {
+            ...file,
+            ...updates,
+            version: file.version + 1
+        };
+        this.files.set(id, updatedFile);
+        return updatedFile;
+    }
+
+    getFile(id: string): DriveFile | null {
+        return this.files.get(id) || null;
+    }
+
+    deleteFile(id: string): boolean {
+        return this.files.delete(id);
+    }
+
+    listFiles(): DriveFile[] {
+        // Basic implementation, ignores query for now
+        return Array.from(this.files.values());
+    }
+
+    clear(): void {
+        this.files.clear();
+    }
+
+    getAbout(): object {
+        return {
+            user: {
+                displayName: "Mock User",
+                emailAddress: "mock@example.com",
+                kind: "drive#user",
+                me: true,
+                permissionId: "mock-permission-id"
+            },
+            storageQuota: {
+                limit: "10000000000",
+                usage: "0",
+                usageInDrive: "0",
+                usageInDriveTrash: "0"
+            }
+        }
+    }
+}
+
+export const driveStore = new DriveStore();