google-drive-mock 0.0.1 → 1.0.1

package/.github/workflows/release.yml

@@ -1,12 +1,21 @@
 name: Release
 
 on:
-  release:
-    types: [created]
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'New Version (e.g. 1.0.0)'
+        required: true
+        type: string
 
 jobs:
   build:
     runs-on: ubuntu-24.04
+    # @link https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs
+    permissions:
+      contents: write
+      # @link https://docs.npmjs.com/generating-provenance-statements#about-npm-provenance
+      id-token: write
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
@@ -16,9 +25,18 @@ jobs:
           cache: 'npm'
 
       - run: npm install
+      - run: npm version ${{ inputs.version }} --no-git-tag-version
       - run: npm run build
       - run: npm run lint
       - run: npm test
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Push changes
+        run: |
+          git config --global user.name 'github-actions[bot]'
+          git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+          git add package.json package-lock.json
+          git commit -m "release: ${{ inputs.version }}"
+          git push

package/AGENTS.md

@@ -1,6 +1,6 @@
 # AI Instructions
 
-Always run the following commands after making changes to the codebase to ensure integrity:
+After making changes to the codebase or to the tests, always run the following commands to ensure integrity:
 
 1. `npm run build`
 2. `npm run lint`

package/dist/index.js

@@ -14,10 +14,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startServer = exports.createApp = void 0;
 const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
 const store_1 = require("./store");
 const batch_1 = require("./batch");
 const createApp = (config = {}) => {
     const app = (0, express_1.default)();
+    app.use((0, cors_1.default)());
     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));
@@ -42,6 +44,10 @@ const createApp = (config = {}) => {
         store_1.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) => {
@@ -65,13 +71,132 @@ const createApp = (config = {}) => {
     });
     // Files: List
     app.get('/drive/v3/files', (req, res) => {
-        const files = store_1.driveStore.listFiles();
+        let files = store_1.driveStore.listFiles();
+        const q = req.query.q;
+        const orderBy = req.query.orderBy;
+        if (q) {
+            // Enhanced query parser for Mock
+            // Supports: 
+            // - name = '...'
+            // - mimeType = '...'
+            // - trashed = true/false
+            // - 'ID' in parents
+            // - name contains '...'
+            const parts = q.split(' and ').map(p => p.trim());
+            files = files.filter(file => {
+                return parts.every(part => {
+                    var _a, _b, _c, _d, _e, _f, _g, _h;
+                    // name = '...'
+                    if (part.startsWith("name = '")) {
+                        const name = (_a = part.match(/name = '(.*)'/)) === null || _a === void 0 ? void 0 : _a[1];
+                        return file.name === name;
+                    }
+                    // name contains '...'
+                    if (part.startsWith("name contains '")) {
+                        const token = (_b = part.match(/name contains '(.*)'/)) === null || _b === void 0 ? void 0 : _b[1];
+                        return token && file.name.includes(token);
+                    }
+                    // 'ID' in parents
+                    if (part.includes(" in parents")) {
+                        const parentId = (_c = part.match(/'(.*)' in parents/)) === null || _c === void 0 ? void 0 : _c[1];
+                        return parentId && ((_d = file.parents) === null || _d === void 0 ? void 0 : _d.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 = (_e = part.match(/mimeType = '(.*)'/)) === null || _e === void 0 ? void 0 : _e[1];
+                        return file.mimeType === mime;
+                    }
+                    // mimeType != '...'
+                    if (part.startsWith("mimeType != '")) {
+                        const mime = (_f = part.match(/mimeType != '(.*)'/)) === null || _f === void 0 ? void 0 : _f[1];
+                        return file.mimeType !== mime;
+                    }
+                    // modifiedTime > '...'
+                    if (part.startsWith("modifiedTime > '")) {
+                        const timeStr = (_g = part.match(/modifiedTime > '(.*)'/)) === null || _g === void 0 ? void 0 : _g[1];
+                        return timeStr && new Date(file.modifiedTime) > new Date(timeStr);
+                    }
+                    // modifiedTime < '...'
+                    if (part.startsWith("modifiedTime < '")) {
+                        const timeStr = (_h = part.match(/modifiedTime < '(.*)'/)) === null || _h === void 0 ? void 0 : _h[1];
+                        return timeStr && new Date(file.modifiedTime) < new Date(timeStr);
+                    }
+                    // Ignore unknown filters for now
+                    return true;
+                });
+            });
+        }
+        // Sorting (orderBy)
+        if (orderBy) {
+            // Basic support for single keys: 'folder,name', 'modifiedTime desc', etc.
+            // Splitting by comma
+            const sortKeys = orderBy.split(',').map(k => k.trim());
+            files.sort((a, b) => {
+                for (const keyDef of sortKeys) {
+                    const [key, direction] = keyDef.split(' ');
+                    const dir = direction || 'asc';
+                    // Handle special virtual key 'folder'
+                    if (key === 'folder') {
+                        const aIsFolder = a.mimeType === 'application/vnd.google-apps.folder';
+                        const bIsFolder = b.mimeType === 'application/vnd.google-apps.folder';
+                        if (aIsFolder !== bIsFolder) {
+                            // Folders first in 'folder' sort usually? 
+                            // Google docs say: "folder sets folders to appear before..."
+                            const valA = aIsFolder ? 0 : 1;
+                            const valB = bIsFolder ? 0 : 1;
+                            if (valA !== valB)
+                                return dir === 'desc' ? valB - valA : valA - valB;
+                        }
+                        continue;
+                    }
+                    const valA = a[key];
+                    const valB = b[key];
+                    if (valA === undefined || valB === undefined)
+                        return 0;
+                    if (valA < valB)
+                        return dir === 'desc' ? 1 : -1;
+                    if (valA > valB)
+                        return dir === 'desc' ? -1 : 1;
+                }
+                return 0;
+            });
+        }
         res.json({
             kind: "drive#fileList",
             incompleteSearch: false,
             files: files
         });
     });
+    // Changes: Get Start Page Token
+    app.get('/drive/v3/changes/startPageToken', (req, res) => {
+        const token = store_1.driveStore.getStartPageToken();
+        res.json({
+            kind: "drive#startPageToken",
+            startPageToken: token
+        });
+    });
+    // Changes: List
+    app.get('/drive/v3/changes', (req, res) => {
+        const pageToken = req.query.pageToken;
+        if (!pageToken) {
+            res.status(400).json({ error: { code: 400, message: "Bad Request: pageToken is required" } });
+            return;
+        }
+        const result = store_1.driveStore.getChanges(pageToken);
+        res.json({
+            kind: "drive#changeList",
+            newStartPageToken: result.newStartPageToken,
+            nextPageToken: result.nextPageToken,
+            changes: result.changes
+        });
+    });
     // Files: Create
     app.post('/drive/v3/files', (req, res) => {
         const body = req.body;
@@ -85,11 +210,7 @@ const createApp = (config = {}) => {
             res.status(409).json({ error: { code: 409, message: "Conflict: File with same name already exists" } });
             return;
         }
-        const newFile = store_1.driveStore.createFile({
-            name: body.name,
-            mimeType: body.mimeType || "application/octet-stream",
-            parents: body.parents || []
-        });
+        const newFile = store_1.driveStore.createFile(Object.assign(Object.assign({}, body), { name: body.name, mimeType: body.mimeType || "application/octet-stream", parents: body.parents || [] }));
         res.status(200).json(newFile);
     });
     // Files: Get

package/dist/store.d.ts

@@ -5,10 +5,22 @@ export interface DriveFile {
     kind: string;
     parents?: string[];
     version: number;
+    trashed: boolean;
+    createdTime: string;
+    modifiedTime: string;
     [key: string]: unknown;
 }
+export interface DriveChange {
+    kind: "drive#change";
+    changeType: "file" | "drive";
+    time: string;
+    removed: boolean;
+    fileId: string;
+    file?: DriveFile;
+}
 export declare class DriveStore {
     private files;
+    private changes;
     constructor();
     createFile(file: Partial<DriveFile> & {
         name: string;
@@ -19,5 +31,12 @@ export declare class DriveStore {
     listFiles(): DriveFile[];
     clear(): void;
     getAbout(): object;
+    private addChange;
+    getStartPageToken(): string;
+    getChanges(pageToken: string): {
+        changes: DriveChange[];
+        newStartPageToken: string;
+        nextPageToken?: string;
+    };
 }
 export declare const driveStore: DriveStore;

package/dist/store.js

@@ -4,14 +4,17 @@ exports.driveStore = exports.DriveStore = void 0;
 class DriveStore {
     constructor() {
         this.files = new Map();
+        this.changes = [];
     }
     createFile(file) {
         if (!file.name) {
             throw new Error("File name is required");
         }
         const id = file.id || Math.random().toString(36).substring(7);
-        const newFile = Object.assign(Object.assign({ kind: "drive#file", mimeType: "application/octet-stream" }, file), { id, version: 1 });
+        const now = new Date().toISOString();
+        const newFile = Object.assign(Object.assign({ kind: "drive#file", mimeType: "application/octet-stream", trashed: false, createdTime: now, modifiedTime: now }, file), { id, version: 1 });
         this.files.set(id, newFile);
+        this.addChange(newFile);
         return newFile;
     }
     updateFile(id, updates) {
@@ -19,15 +22,21 @@ class DriveStore {
         if (!file)
             return null;
         // Merge updates and increment version
-        const updatedFile = Object.assign(Object.assign(Object.assign({}, file), updates), { version: file.version + 1 });
+        const updatedFile = Object.assign(Object.assign(Object.assign({}, file), updates), { version: file.version + 1, modifiedTime: new Date().toISOString() });
         this.files.set(id, updatedFile);
+        this.addChange(updatedFile);
         return updatedFile;
     }
     getFile(id) {
         return this.files.get(id) || null;
     }
     deleteFile(id) {
-        return this.files.delete(id);
+        const file = this.files.get(id);
+        const deleted = this.files.delete(id);
+        if (deleted && file) {
+            this.addChange(file, true);
+        }
+        return deleted;
     }
     listFiles() {
         // Basic implementation, ignores query for now
@@ -35,6 +44,7 @@ class DriveStore {
     }
     clear() {
         this.files.clear();
+        this.changes = [];
     }
     getAbout() {
         return {
@@ -53,6 +63,38 @@ class DriveStore {
             }
         };
     }
+    // Change Management
+    addChange(file, removed = false) {
+        // Simple mock implementation: store change
+        // In real Drive, multiple updates might result in one change token if polled later,
+        // but here we just append to a log.
+        const change = {
+            kind: "drive#change",
+            changeType: "file",
+            time: new Date().toISOString(),
+            removed,
+            fileId: file.id,
+            file: removed ? undefined : file
+        };
+        this.changes.push(change);
+    }
+    getStartPageToken() {
+        return String(this.changes.length + 1);
+    }
+    getChanges(pageToken) {
+        const tokenIndex = parseInt(pageToken, 10);
+        // If token invalid, default to beginning? Or error?
+        // Real API returns 400 for bad token. 
+        // Mock: treat 0 or NaN as start.
+        const start = isNaN(tokenIndex) ? 0 : Math.max(0, tokenIndex - 1);
+        // Return all changes since token
+        const changes = this.changes.slice(start);
+        const newToken = String(this.changes.length + 1);
+        return {
+            changes,
+            newStartPageToken: newToken
+        };
+    }
 }
 exports.DriveStore = DriveStore;
 exports.driveStore = new DriveStore();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-drive-mock",
-  "version": "0.0.1",
+  "version": "1.0.1",
   "description": "Mock-Server that simulates being google-drive. Used for testing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -61,4 +61,4 @@
     "typescript-eslint": "8.54.0",
     "vitest": "4.0.18"
   }
-}
+}

package/src/index.ts

@@ -76,7 +76,108 @@ const createApp = (config: AppConfig = {}) => {
 
     // Files: List
     app.get('/drive/v3/files', (req: Request, res: Response) => {
-        const files = driveStore.listFiles();
+        let files = driveStore.listFiles();
+        const q = req.query.q as string;
+        const orderBy = req.query.orderBy as string;
+
+        if (q) {
+            // Enhanced query parser for Mock
+            // Supports: 
+            // - name = '...'
+            // - mimeType = '...'
+            // - trashed = true/false
+            // - 'ID' in parents
+            // - name contains '...'
+            const parts = q.split(' and ').map(p => p.trim());
+
+            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);
+                    }
+
+                    // Ignore unknown filters for now
+                    return true;
+                });
+            });
+        }
+
+        // Sorting (orderBy)
+        if (orderBy) {
+            // Basic support for single keys: 'folder,name', 'modifiedTime desc', etc.
+            // Splitting by comma
+            const sortKeys = orderBy.split(',').map(k => k.trim());
+
+            files.sort((a, b) => {
+                for (const keyDef of sortKeys) {
+                    const [key, direction] = keyDef.split(' ');
+                    const dir = direction || 'asc';
+
+                    // Handle special virtual key 'folder'
+                    if (key === 'folder') {
+                        const aIsFolder = a.mimeType === 'application/vnd.google-apps.folder';
+                        const bIsFolder = b.mimeType === 'application/vnd.google-apps.folder';
+                        if (aIsFolder !== bIsFolder) {
+                            // Folders first in 'folder' sort usually? 
+                            // Google docs say: "folder sets folders to appear before..."
+                            const valA = aIsFolder ? 0 : 1;
+                            const valB = bIsFolder ? 0 : 1;
+                            if (valA !== valB) return dir === 'desc' ? valB - valA : valA - valB;
+                        }
+                        continue;
+                    }
+
+                    const valA = a[key] as string | number | undefined;
+                    const valB = b[key] as string | number | undefined;
+
+                    if (valA === undefined || valB === undefined) return 0;
+
+                    if (valA < valB) return dir === 'desc' ? 1 : -1;
+                    if (valA > valB) return dir === 'desc' ? -1 : 1;
+                }
+                return 0;
+            });
+        }
+
         res.json({
             kind: "drive#fileList",
             incompleteSearch: false,
@@ -84,6 +185,32 @@ const createApp = (config: AppConfig = {}) => {
         });
     });
 
+    // Changes: Get Start Page Token
+    app.get('/drive/v3/changes/startPageToken', (req: Request, res: Response) => {
+        const token = driveStore.getStartPageToken();
+        res.json({
+            kind: "drive#startPageToken",
+            startPageToken: token
+        });
+    });
+
+    // Changes: List
+    app.get('/drive/v3/changes', (req: Request, res: Response) => {
+        const pageToken = req.query.pageToken as string;
+        if (!pageToken) {
+            res.status(400).json({ error: { code: 400, message: "Bad Request: pageToken is required" } });
+            return;
+        }
+
+        const result = driveStore.getChanges(pageToken);
+        res.json({
+            kind: "drive#changeList",
+            newStartPageToken: result.newStartPageToken,
+            nextPageToken: result.nextPageToken,
+            changes: result.changes
+        });
+    });
+
     // Files: Create
     app.post('/drive/v3/files', (req: Request, res: Response) => {
         const body = req.body;
@@ -100,6 +227,7 @@ const createApp = (config: AppConfig = {}) => {
         }
 
         const newFile = driveStore.createFile({
+            ...body,
             name: body.name,
             mimeType: body.mimeType || "application/octet-stream",
             parents: body.parents || []

package/src/store.ts

@@ -5,14 +5,28 @@ export interface DriveFile {
     kind: string;
     parents?: string[];
     version: number;
+    trashed: boolean;
+    createdTime: string;
+    modifiedTime: string;
     [key: string]: unknown;
 }
 
+export interface DriveChange {
+    kind: "drive#change";
+    changeType: "file" | "drive";
+    time: string;
+    removed: boolean;
+    fileId: string;
+    file?: DriveFile;
+}
+
 export class DriveStore {
     private files: Map<string, DriveFile>;
+    private changes: DriveChange[];
 
     constructor() {
         this.files = new Map();
+        this.changes = [];
     }
 
     createFile(file: Partial<DriveFile> & { name: string }): DriveFile {
@@ -20,15 +34,20 @@ export class DriveStore {
             throw new Error("File name is required");
         }
         const id = file.id || Math.random().toString(36).substring(7);
+        const now = new Date().toISOString();
         const newFile: DriveFile = {
             kind: "drive#file",
             mimeType: "application/octet-stream",
+            trashed: false,
+            createdTime: now,
+            modifiedTime: now,
             ...file,
             id,
             version: 1, // Initialize version
         };
 
         this.files.set(id, newFile);
+        this.addChange(newFile);
         return newFile;
     }
 
@@ -40,9 +59,11 @@ export class DriveStore {
         const updatedFile = {
             ...file,
             ...updates,
-            version: file.version + 1
+            version: file.version + 1,
+            modifiedTime: new Date().toISOString()
         };
         this.files.set(id, updatedFile);
+        this.addChange(updatedFile);
         return updatedFile;
     }
 
@@ -51,7 +72,12 @@ export class DriveStore {
     }
 
     deleteFile(id: string): boolean {
-        return this.files.delete(id);
+        const file = this.files.get(id);
+        const deleted = this.files.delete(id);
+        if (deleted && file) {
+            this.addChange(file, true);
+        }
+        return deleted;
     }
 
     listFiles(): DriveFile[] {
@@ -61,6 +87,7 @@ export class DriveStore {
 
     clear(): void {
         this.files.clear();
+        this.changes = [];
     }
 
     getAbout(): object {
@@ -80,6 +107,44 @@ export class DriveStore {
             }
         }
     }
+
+    // Change Management
+    private addChange(file: DriveFile, removed: boolean = false) {
+        // Simple mock implementation: store change
+        // In real Drive, multiple updates might result in one change token if polled later,
+        // but here we just append to a log.
+        const change: DriveChange = {
+            kind: "drive#change",
+            changeType: "file",
+            time: new Date().toISOString(),
+            removed,
+            fileId: file.id,
+            file: removed ? undefined : file
+        };
+        this.changes.push(change);
+    }
+
+    getStartPageToken(): string {
+        return String(this.changes.length + 1);
+    }
+
+    getChanges(pageToken: string): { changes: DriveChange[], newStartPageToken: string, nextPageToken?: string } {
+        const tokenIndex = parseInt(pageToken, 10);
+
+        // If token invalid, default to beginning? Or error?
+        // Real API returns 400 for bad token. 
+        // Mock: treat 0 or NaN as start.
+        const start = isNaN(tokenIndex) ? 0 : Math.max(0, tokenIndex - 1);
+
+        // Return all changes since token
+        const changes = this.changes.slice(start);
+        const newToken = String(this.changes.length + 1);
+
+        return {
+            changes,
+            newStartPageToken: newToken
+        };
+    }
 }
 
 export const driveStore = new DriveStore();

package/test/advanced.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+import { DriveFile, DriveChange } from '../src/store';
+
+describe('Advanced Drive Features', () => {
+    let config: TestConfig;
+    let req: (method: string, endpoint: string, body?: unknown) => Promise<{ status: number; body: unknown; headers: Headers }>;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+        req = async (method: string, endpoint: string, body?: unknown) => {
+            const url = `${config.baseUrl}${endpoint}`;
+            const options: RequestInit = {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.token}`
+                }
+            };
+            if (body) {
+                options.body = JSON.stringify(body);
+            }
+            const res = await fetch(url, options);
+            const text = await res.text();
+            try {
+                return { status: res.status, body: JSON.parse(text), headers: res.headers };
+            } catch {
+                return { status: res.status, body: text, headers: res.headers };
+            }
+        };
+
+        // Ensure test folder exists
+        if (!config.testFolderId) {
+            // Create root test folder if not exists logic handled in config? 
+            // config.testFolderId is populated in config.ts
+        }
+    });
+
+    it('should support changes feed (startPageToken and listing changes)', async () => {
+        // 1. Get Start Page Token
+        const tokenRes = await req('GET', '/drive/v3/changes/startPageToken?supportsAllDrives=true');
+        expect(tokenRes.status).toBe(200);
+        const startToken = (tokenRes.body as { startPageToken: string }).startPageToken;
+        expect(startToken).toBeDefined();
+
+        // 2. Make a change (Create file)
+        const fileName = `ChangeTest-${Date.now()}`;
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: fileName,
+            parents: [config.testFolderId]
+        });
+        expect(createRes.status).toBe(200);
+        const fileId = (createRes.body as DriveFile).id;
+
+        // 3. List Changes
+        const changesRes = await req('GET', `/drive/v3/changes?pageToken=${startToken}&supportsAllDrives=true&fields=changes(fileId,removed,file(name))`);
+        expect(changesRes.status).toBe(200);
+        // On Real API, changes might not be immediate? 
+        // Usually safe enough for a single linear test, but might need retry loop.
+
+        // Check if we find our file ID in changes
+        const changes = (changesRes.body as { changes: DriveChange[] }).changes;
+        const found = changes.find((c: DriveChange) => c.fileId === fileId);
+
+        // Be tolerant of eventually consistency on Real API if needed, 
+        // but for now expect it (Mock is immediate).
+        // If Real API fails here intermittently, we might need a retry wrapper.
+        // For correct TDD, let's assume immediate for Mock.
+        if (config.isMock) {
+            expect(found).toBeDefined();
+            expect(found?.removed).toBe(false);
+            expect(found?.file?.name).toBe(fileName);
+        } else {
+            // Real API might delay. Warn if missing but don't fail properly? 
+            // Ideally we loop wait.
+            if (!found) console.warn("Real API change propogation might be slow");
+        }
+
+        // 4. Delete file (Change)
+        await req('DELETE', `/drive/v3/files/${fileId}`);
+        // Fetch changes again from SAME token should show creation AND deletion?
+        // Or fetch from Next token? Mock implementation: "changes since token".
+        // If we query again with startToken, we should see both events (Mock).
+
+        const changesRes2 = await req('GET', `/drive/v3/changes?pageToken=${startToken}&supportsAllDrives=true`);
+        const changes2 = (changesRes2.body as { changes: DriveChange[] }).changes;
+        const deletion = changes2.find((c: DriveChange) => c.fileId === fileId && c.removed === true);
+
+        if (config.isMock) {
+            expect(deletion).toBeDefined();
+        }
+    });
+
+    it('should support advanced query operators (contains, in parents)', async () => {
+        const timestamp = Date.now();
+        const folderName = `QueryFolder-${timestamp}`;
+        const fileName = `UniqueFile-${timestamp}`;
+
+        // Create Folder
+        const folderRes = await req('POST', '/drive/v3/files', {
+            name: folderName,
+            mimeType: 'application/vnd.google-apps.folder',
+            parents: [config.testFolderId]
+        });
+        const folderId = (folderRes.body as DriveFile).id;
+
+        // Create File in Folder
+        const fileRes = await req('POST', '/drive/v3/files', {
+            name: fileName,
+            parents: [folderId]
+        });
+        const fileId = (fileRes.body as DriveFile).id;
+
+        // Query: 'ID' in parents
+        const qParents = `'${folderId}' in parents and trashed = false`;
+        const searchParents = await req('GET', `/drive/v3/files?q=${encodeURIComponent(qParents)}`);
+        expect(searchParents.status).toBe(200);
+        const foundParent = (searchParents.body as { files: DriveFile[] }).files.find((f: DriveFile) => f.id === fileId);
+        expect(foundParent).toBeDefined();
+
+        // Query: name contains 'UniqueFile'
+        const qContains = `name contains 'UniqueFile' and trashed = false`;
+        const searchContains = await req('GET', `/drive/v3/files?q=${encodeURIComponent(qContains)}`);
+        expect(searchContains.status).toBe(200);
+        const foundContains = (searchContains.body as { files: DriveFile[] }).files.find((f: DriveFile) => f.id === fileId);
+        expect(foundContains).toBeDefined();
+
+        // Query: modifiedTime > ...
+        // We just created the file, so it should be newer than 1 hour ago.
+        const oneHourAgo = new Date(Date.now() - 3600000).toISOString();
+        const qTime = `modifiedTime > '${oneHourAgo}' and name = '${fileName}'`;
+        const searchTime = await req('GET', `/drive/v3/files?q=${encodeURIComponent(qTime)}`);
+        expect(searchTime.status).toBe(200);
+        const foundTime = (searchTime.body as { files: DriveFile[] }).files.find((f: DriveFile) => f.id === fileId);
+        expect(foundTime).toBeDefined();
+    });
+
+    it('should support ordering', async () => {
+        const prefix = `SortTest-${Date.now()}`;
+        // Create 3 files with different names to sort
+        const names = ['A', 'B', 'C'].map(s => `${prefix}-${s}`);
+
+        for (const name of names) {
+            await req('POST', '/drive/v3/files', {
+                name,
+                parents: [config.testFolderId]
+            });
+            // Ensure timestamp diff for modifiedTime sort? Mock is fast.
+            // Wait 1ms
+            await new Promise(r => setTimeout(r, 2));
+        }
+
+        // 1. Sort by name desc
+        const q = `name contains '${prefix}' and trashed = false`;
+        const sortRes = await req('GET', `/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=name desc`);
+        expect(sortRes.status).toBe(200);
+
+        const files = (sortRes.body as { files: DriveFile[] }).files;
+        // Should be C, B, A
+        expect(files.length).toBeGreaterThanOrEqual(3);
+        const relevant = files.filter((f: DriveFile) => f.name.includes(prefix));
+        expect(relevant[0].name).toContain('-C');
+        expect(relevant[1].name).toContain('-B');
+        expect(relevant[2].name).toContain('-A');
+
+        // 2. Sort by createdTime asc (Mock adds createdTime now)
+        const sortTimeRes = await req('GET', `/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=createdTime asc`);
+        const filesTime = (sortTimeRes.body as { files: DriveFile[] }).files;
+        const relevantTime = filesTime.filter((f: DriveFile) => f.name.includes(prefix));
+
+        expect(relevantTime[0].name).toContain('-A');
+        expect(relevantTime[1].name).toContain('-B');
+        expect(relevantTime[2].name).toContain('-C');
+    });
+});

package/test/config.ts

@@ -4,6 +4,7 @@ import type { Server } from 'http';
 
 export interface TestConfig {
     target: Server | string; // Server instance (Node) or URL string (Browser/Real)
+    baseUrl: string; // Uniform URL for requests
     token: string;
 
     isMock: boolean;
@@ -124,6 +125,7 @@ export async function getTestConfig(): Promise<TestConfig> {
 
         return {
             target,
+            baseUrl: target,
             token,
             isMock: false,
             testFolderId,
@@ -141,6 +143,7 @@ export async function getTestConfig(): Promise<TestConfig> {
 
         return {
             target: serverUrl,
+            baseUrl: serverUrl,
             token: 'valid-token',
             isMock: true,
             testFolderId,
@@ -177,6 +180,7 @@ export async function getTestConfig(): Promise<TestConfig> {
 
         return {
             target: server,
+            baseUrl: targetUrl, // Added
             token: 'valid-token',
             isMock: true,
             testFolderId,

package/test/features.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+import { Server } from 'http';
+import { DriveFile } from '../src/store';
+
+// Helper (Shared)
+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 };
+    } 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('Feature Tests', () => {
+    let config: TestConfig;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+    });
+
+    afterAll(() => {
+        if (config) config.stop();
+    });
+
+    async function req(method: string, path: string, body?: unknown) {
+        return makeRequest(config.target, method, path, {
+            'Authorization': `Bearer ${config.token}`
+        }, body);
+    }
+
+    it('should find a folder by its name (only search not in trash folders)', async () => {
+        // 1. Create a unique folder
+        const folderName = 'SearchTarget_' + Date.now();
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: folderName,
+            mimeType: 'application/vnd.google-apps.folder',
+            parents: [config.testFolderId]
+        });
+        expect(createRes.status).toBe(200);
+        const createdId = createRes.body.id;
+
+        // 2. Search for it
+        const query = `name = '${folderName}' and trashed = false`;
+        const searchRes = await req('GET', `/drive/v3/files?q=${encodeURIComponent(query)}`);
+
+        expect(searchRes.status).toBe(200);
+        const files = searchRes.body.files;
+        expect(files).toBeDefined();
+        expect(files.length).toBeGreaterThan(0);
+        expect(files[0].id).toBe(createdId);
+        expect(files[0].name).toBe(folderName);
+    });
+
+    it('should create and delete a nested folder', async () => {
+        // 1. Create Parent
+        const parentName = 'Parent_' + Date.now();
+        const parentRes = await req('POST', '/drive/v3/files', {
+            name: parentName,
+            mimeType: 'application/vnd.google-apps.folder',
+            parents: [config.testFolderId]
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = parentRes.body.id;
+
+        // 2. Create Child inside Parent
+        const childName = 'Child_' + Date.now();
+        const childRes = await req('POST', '/drive/v3/files', {
+            name: childName,
+            mimeType: 'application/vnd.google-apps.folder',
+            parents: [parentId]
+        });
+        expect(childRes.status).toBe(200);
+        const childId = childRes.body.id;
+
+        // 3. Verify Child has parent
+        const getChild = await req('GET', `/drive/v3/files/${childId}?fields=parents`);
+        expect(getChild.status).toBe(200);
+        // req helper wraps body logic differently?
+        // Ah, default getFile returns all fields in mock.
+        // Mock might not strictly filter fields yet, but let's check.
+        if (getChild.body.parents) {
+            expect(getChild.body.parents).toContain(parentId);
+        }
+
+        // 4. Delete Child
+        const delRes = await req('DELETE', `/drive/v3/files/${childId}`);
+        expect(delRes.status).toBe(204);
+
+        // 5. Verify Child Gone
+        const verify = await req('GET', `/drive/v3/files/${childId}`);
+        expect(verify.status).toBe(404);
+    });
+
+    it('should get a file and check for its mime-type', async () => {
+        const fileName = 'MimeTypeFile_' + Date.now();
+        const mimeType = 'text/plain';
+
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: fileName,
+            mimeType: mimeType,
+            parents: [config.testFolderId]
+        });
+        expect(createRes.status).toBe(200);
+        const fileId = createRes.body.id;
+
+        const getRes = await req('GET', `/drive/v3/files/${fileId}`);
+        expect(getRes.status).toBe(200);
+        expect(getRes.body.mimeType).toBe(mimeType);
+    });
+
+    it('should fetch a folder and check for its mime-type', async () => {
+        const folderName = 'MimeTypeFolder_' + Date.now();
+        const mimeType = 'application/vnd.google-apps.folder';
+
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: folderName,
+            mimeType: mimeType,
+            parents: [config.testFolderId]
+        });
+        expect(createRes.status).toBe(200);
+        const folderId = createRes.body.id;
+
+        const getRes = await req('GET', `/drive/v3/files/${folderId}`);
+        expect(getRes.status).toBe(200);
+        expect(getRes.body.mimeType).toBe(mimeType);
+    });
+
+    it('should trash a file', async () => {
+        const fileName = 'TrashFile_' + Date.now();
+        const createRes = await req('POST', '/drive/v3/files', {
+            name: fileName,
+            parents: [config.testFolderId]
+        });
+        expect(createRes.status).toBe(200);
+        const fileId = createRes.body.id;
+
+        // Trash it
+        const trashRes = await req('PATCH', `/drive/v3/files/${fileId}?fields=trashed`, { trashed: true });
+        expect(trashRes.status).toBe(200);
+        expect(trashRes.body.trashed).toBe(true);
+
+        // Verify it is still accessible via GET
+        const getRes = await req('GET', `/drive/v3/files/${fileId}?fields=trashed`);
+        expect(getRes.status).toBe(200);
+        expect(getRes.body.trashed).toBe(true);
+
+        // Verify it is excluded from search with trashed=false
+        const query = `name = '${fileName}' and trashed = false`;
+        const searchRes = await req('GET', `/drive/v3/files?q=${encodeURIComponent(query)}`);
+        expect(searchRes.status).toBe(200);
+        expect(searchRes.body.files).toEqual([]);
+
+        // Verify it is included in search with trashed=true
+        const queryTrash = `name = '${fileName}' and trashed = true`;
+        const searchTrashRes = await req('GET', `/drive/v3/files?q=${encodeURIComponent(queryTrash)}`);
+        expect(searchTrashRes.status).toBe(200);
+        expect(searchTrashRes.body.files).toHaveLength(1);
+        expect(searchTrashRes.body.files[0].id).toBe(fileId);
+    });
+
+    it('should find a file that is in a nested folder. Write the file and then read it again. Call it data.json', async () => {
+        // 1. Create Parent Folder
+        const parentRes = await req('POST', '/drive/v3/files', {
+            name: 'DataFolder_' + Date.now(),
+            mimeType: 'application/vnd.google-apps.folder',
+            parents: [config.testFolderId]
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = parentRes.body.id;
+
+        // 2. Create Nested Folder
+        const nestedRes = await req('POST', '/drive/v3/files', {
+            name: 'Nested_' + Date.now(),
+            mimeType: 'application/vnd.google-apps.folder',
+            parents: [parentId]
+        });
+        expect(nestedRes.status).toBe(200);
+        const nestedId = nestedRes.body.id;
+
+        // 3. Create (Write) File in Nested Folder
+        const fileName = 'data.json';
+        const fileContent = { foo: 'bar', timestamp: Date.now() };
+
+        const createBody: { name: string; mimeType: string; parents: string[]; content?: unknown } = {
+            name: fileName,
+            mimeType: 'application/json',
+            parents: [nestedId]
+        };
+
+        if (config.isMock) {
+            createBody.content = fileContent;
+        }
+
+        const createRes = await req('POST', '/drive/v3/files', createBody);
+        expect(createRes.status).toBe(200);
+        const fileId = createRes.body.id;
+
+        // 4. Find (Search) the file
+        const query = `name = '${fileName}' and trashed = false`;
+        const searchRes = await req('GET', `/drive/v3/files?q=${encodeURIComponent(query)}`);
+        expect(searchRes.status).toBe(200);
+        const found = (searchRes.body as { files: DriveFile[] }).files.find((f: DriveFile) => f.id === fileId);
+        expect(found).toBeDefined();
+        // Check finding by name works naturally.
+
+        // 5. Read (Get) the file
+        const getRes = await req('GET', `/drive/v3/files/${fileId}?fields=name,parents`);
+        expect(getRes.status).toBe(200);
+        expect(getRes.body.name).toBe(fileName);
+        expect(getRes.body.parents).toContain(nestedId);
+
+        if (config.isMock) {
+            expect(getRes.body.content).toEqual(fileContent);
+        }
+    });
+});