microsoft-onedrive-mock 1.0.0

package/test/basics.test.ts

@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { setupTestEnvironment } from './config';
+
+describe('OneDrive Basics', () => {
+    let env: Awaited<ReturnType<typeof setupTestEnvironment>>;
+    let baseUrl: string;
+    let token: string;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        env = await setupTestEnvironment();
+        baseUrl = env.baseUrl;
+        token = env.token;
+        headers = { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' };
+    });
+
+    afterAll(async () => {
+        if (env) env.close();
+    });
+
+    beforeEach(async () => {
+        await env.clear();
+    });
+
+    it('should get drive root', async () => {
+        const res = await fetch(`${baseUrl}/v1.0/me/drive/root`, { headers });
+        if (res.status !== 200) console.log("ROOT ERROR:", await res.text());
+        expect(res.status).toBe(200);
+        const data = await res.json();
+        expect(data.id).toBeDefined();
+        expect(data.name).toBe('root');
+    });
+
+    it('should create a new folder and verify it appears in children', async () => {
+        const folderName = 'TestFolder_' + Date.now();
+        const folderRes = await fetch(`${baseUrl}/v1.0/me/drive/items/root/children`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                name: folderName,
+                folder: {},
+                '@microsoft.graph.conflictBehavior': 'rename'
+            })
+        });
+
+        if (folderRes.status !== 201) console.log("FOLDER ERROR:", await folderRes.text());
+        expect(folderRes.status).toBe(201);
+        const folderData = await folderRes.json();
+        expect(folderData.name).toBe(folderName);
+        expect(folderData.id).toBeDefined();
+
+        // List children
+        const listRes = await fetch(`${baseUrl}/v1.0/me/drive/items/root/children`, { headers });
+        const listData = await listRes.json();
+        expect(listData.value).toBeDefined();
+        expect(listData.value.find((i: any) => i.id === folderData.id)).toBeDefined();
+    });
+
+    it('should upload a new file via PUT and download it via GET', async () => {
+        const filename = 'test-file-' + Date.now() + '.txt';
+        const content = 'Hello World One Drive!';
+
+        const putRes = await fetch(`${baseUrl}/v1.0/me/drive/items/root:/${filename}:/content`, {
+            method: 'PUT',
+            headers: {
+                ...headers,
+                'Content-Type': 'text/plain'
+            },
+            body: content
+        });
+
+        if (putRes.status !== 201) console.log("PUT ERROR:", await putRes.text());
+        expect(putRes.status).toBe(201); // 201 Created for new file
+        const fileData = await putRes.json();
+        expect(fileData.id).toBeDefined();
+        expect(fileData.name).toBe(filename);
+
+        // Upload again to same path should update (200 OK)
+        const putRes2 = await fetch(`${baseUrl}/v1.0/me/drive/items/root:/${filename}:/content`, {
+            method: 'PUT',
+            headers: {
+                ...headers,
+                'Content-Type': 'text/plain'
+            },
+            body: 'Updated Content'
+        });
+        expect(putRes2.status).toBe(200);
+
+        // Download content via item id
+        const dlRes = await fetch(`${baseUrl}/v1.0/me/drive/items/${fileData.id}/content`, { headers });
+        expect(dlRes.status).toBe(200);
+        const dlText = await dlRes.text();
+        expect(dlText).toBe('Updated Content');
+    });
+
+    it('should handle delta queries', async () => {
+        const res1 = await fetch(`${baseUrl}/v1.0/me/drive/root/delta`, { headers });
+        const delta1 = await res1.json();
+        expect(delta1.value).toBeDefined();
+        expect(delta1['@odata.deltaLink']).toBeDefined();
+
+        const deltaFilename = 'delta-file-' + Date.now() + '.txt';
+
+        // Create a file
+        await fetch(`${baseUrl}/v1.0/me/drive/items/root:/${deltaFilename}:/content`, {
+            method: 'PUT',
+            headers: { ...headers, 'Content-Type': 'text/plain' },
+            body: 'delta'
+        });
+
+        const tokenUrl = delta1['@odata.deltaLink'];
+
+        const res2 = await fetch(tokenUrl, { headers });
+        const delta2 = await res2.json();
+        expect(delta2.value.length).toBeGreaterThan(0);
+        expect(delta2.value.find((i: any) => i.name === deltaFilename)).toBeDefined();
+    });
+});

package/test/batch.test.ts

@@ -0,0 +1,75 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { setupTestEnvironment } from './config';
+
+describe('OneDrive Batch Requests', () => {
+    let env: Awaited<ReturnType<typeof setupTestEnvironment>>;
+    let baseUrl: string;
+    let token: string;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        env = await setupTestEnvironment();
+        baseUrl = env.baseUrl;
+        token = env.token;
+        headers = { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' };
+    });
+
+    afterAll(async () => {
+        if (env) env.close();
+    });
+
+    beforeEach(async () => {
+        await env.clear();
+    });
+
+    it('should execute a batch of requests', async () => {
+        const batchFolderName = 'BatchFolder_' + Date.now();
+        const batchPayload = {
+            requests: [
+                {
+                    id: "1",
+                    method: "GET",
+                    url: "/me/drive/root"
+                },
+                {
+                    id: "2",
+                    method: "POST",
+                    url: "/me/drive/items/root/children",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: {
+                        name: batchFolderName,
+                        folder: {}
+                    }
+                }
+            ]
+        };
+
+        const res = await fetch(`${baseUrl}/v1.0/$batch`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(batchPayload)
+        });
+
+        if (res.status !== 200) console.log("BATCH ERROR:", await res.text());
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        expect(data.responses).toBeDefined();
+        expect(Array.isArray(data.responses)).toBe(true);
+        expect(data.responses.length).toBe(2);
+
+        const res1 = data.responses.find((r: any) => r.id === "1");
+        const res2 = data.responses.find((r: any) => r.id === "2");
+
+        expect(res1.status).toBe(200);
+        expect(res1.body.id).toBeDefined();
+        expect(res1.body.name).toBe('root');
+
+        expect(res2.status).toBe(201);
+        expect(res2.body.name).toBe(batchFolderName);
+        expect(res2.body.folder).toBeDefined();
+    });
+});

package/test/config.ts

@@ -0,0 +1,63 @@
+// Note: We avoid static imports of node-only modules to support browser mode.
+// Types are fine.
+
+export const getAuthToken = () => {
+    if (typeof process !== 'undefined' && process.env.TEST_TARGET === 'real') {
+        const token = process.env.ONEDRIVE_TOKEN || process.env.GRAPH_TOKEN;
+        if (!token) throw new Error("Real API test requires ONEDRIVE_TOKEN or GRAPH_TOKEN in env");
+        return token;
+    }
+    return 'valid-token';
+};
+
+export const setupTestEnvironment = async () => {
+    const isBrowser = typeof window !== 'undefined';
+    const isReal = typeof process !== 'undefined' && process.env.TEST_TARGET === 'real';
+
+    if (isReal) {
+        console.log("Running tests against REAL Microsoft Graph API");
+        return {
+            baseUrl: 'https://graph.microsoft.com',
+            token: getAuthToken(),
+            close: () => { },
+            clear: async () => { } // Real API clear not implemented
+        };
+    }
+
+    if (isBrowser) {
+        console.log("Running tests against MOCK Server (Browser)");
+        const serverUrl = 'http://localhost:3006';
+        return {
+            baseUrl: serverUrl,
+            token: 'valid-token',
+            close: () => { },
+            clear: async () => {
+                await fetch(`${serverUrl}/debug/clear`, { method: 'POST' });
+            }
+        };
+    } else {
+        console.log("Running tests against MOCK Server (Node)");
+        const { startServer } = await import('../src/index');
+        const { driveStore } = await import('../src/store');
+
+        const server = startServer(0, 'localhost', { serverLagBefore: 5, serverLagAfter: 5 });
+
+        await new Promise<void>((resolve) => {
+            if (server.listening) return resolve();
+            server.on('listening', resolve);
+        });
+
+        const addr = server.address();
+        const port = typeof addr === 'object' && addr && 'port' in addr ? addr.port : 0;
+        const baseUrl = `http://localhost:${port}`;
+
+        return {
+            baseUrl,
+            token: 'valid-token',
+            close: () => server.close(),
+            clear: async () => {
+                driveStore.clear();
+            }
+        };
+    }
+};

package/test/etag.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { setupTestEnvironment } from './config';
+
+describe('ETag and Conditional Operations (If-Match)', () => {
+    let env: Awaited<ReturnType<typeof setupTestEnvironment>>;
+    let baseUrl: string;
+    let token: string;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        env = await setupTestEnvironment();
+        baseUrl = env.baseUrl;
+        token = env.token;
+        headers = { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' };
+    });
+
+    afterAll(async () => {
+        if (env) env.close();
+    });
+
+    beforeEach(async () => {
+        await env.clear();
+    });
+
+    it('should support If-Match on PUT content update', async () => {
+        const filename = 'etag-test-' + Date.now() + '.txt';
+
+        // 1. Create file
+        const putRes = await fetch(`${baseUrl}/v1.0/me/drive/items/root:/${filename}:/content`, {
+            method: 'PUT',
+            headers: { ...headers, 'Content-Type': 'text/plain' },
+            body: 'Initial content'
+        });
+        expect(putRes.status).toBe(201);
+        const fileData = await putRes.json();
+        const etag = fileData.eTag;
+        const fileId = fileData.id;
+        expect(etag).toBeDefined();
+
+        // 2. Update with Wrong ETag
+        const invalidEtag = etag.replace(/.$/, '0'); // Change last char
+        const updateFail = await fetch(`${baseUrl}/v1.0/me/drive/items/${fileId}/content`, {
+            method: 'PUT',
+            headers: { ...headers, 'Content-Type': 'text/plain', 'If-Match': invalidEtag },
+            body: 'Should fail'
+        });
+
+        // Mock vs Real Parity verification
+        // Graph API uses 412 (Precondition Failed) when ETags do not match
+        expect(updateFail.status).toBe(412);
+
+        // Verify content did not change
+        const checkRes = await fetch(`${baseUrl}/v1.0/me/drive/items/${fileId}/content`, { headers });
+        expect(await checkRes.text()).toBe('Initial content');
+
+        // 3. Update with Correct ETag
+        const updateSuccess = await fetch(`${baseUrl}/v1.0/me/drive/items/${fileId}/content`, {
+            method: 'PUT',
+            headers: { ...headers, 'Content-Type': 'text/plain', 'If-Match': etag },
+            body: 'Updated content'
+        });
+        expect(updateSuccess.status).toBe(200);
+
+        // 4. Verify new ETag is different
+        const newFileData = await updateSuccess.json();
+        expect(newFileData.eTag).toBeDefined();
+        expect(newFileData.eTag).not.toBe(etag);
+    });
+});

package/test/search.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { setupTestEnvironment } from './config';
+
+describe('Folder Search Parity', () => {
+    let env: Awaited<ReturnType<typeof setupTestEnvironment>>;
+    let baseUrl: string;
+    let token: string;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        env = await setupTestEnvironment();
+        baseUrl = env.baseUrl;
+        token = env.token;
+        headers = { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' };
+    });
+
+    afterAll(async () => {
+        if (env) env.close();
+    });
+
+    beforeEach(async () => {
+        await env.clear();
+    });
+
+    it('should validate search functionality (empty string handling)', async () => {
+        // Due to project guidelines requiring < 10s test timeouts, we cannot wait for Microsoft Graph
+        // to index newly created files, which natively takes 15-60 seconds.
+        // Instead, we validate that the search endpoint correctly routes, authenticates,
+        // and returns the exact identical array shape for a guaranteed empty query.
+        const uniqueString = Date.now().toString();
+        const searchName = 'NonExistent_' + uniqueString;
+
+        const searchRes = await fetch(`${baseUrl}/v1.0/me/drive/root/search(q='${searchName}')`, { headers });
+        expect(searchRes.status).toBe(200);
+
+        const searchData = await searchRes.json();
+        expect(searchData.value).toBeDefined();
+
+        // Both Mock and Real API should instantly return an empty array
+        expect(Array.isArray(searchData.value)).toBe(true);
+        expect(searchData.value.length).toBe(0);
+    });
+
+    it('should respect $select fields during search routing', async () => {
+        const searchName = 'SelectSearchTarget_' + Date.now().toString();
+
+        // Search for the uniquely missing file with ?$select=id
+        const searchRes = await fetch(`${baseUrl}/v1.0/me/drive/root/search(q='${searchName}')?$select=id`, { headers });
+        expect(searchRes.status).toBe(200);
+
+        const data = await searchRes.json();
+
+        expect(data.value).toBeDefined();
+        expect(Array.isArray(data.value)).toBe(true);
+        expect(data.value.length).toBe(0);
+    });
+});

package/test/select.test.ts

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { setupTestEnvironment } from './config';
+
+describe('Field Selection Parity ($select)', () => {
+    let env: Awaited<ReturnType<typeof setupTestEnvironment>>;
+    let baseUrl: string;
+    let token: string;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        env = await setupTestEnvironment();
+        baseUrl = env.baseUrl;
+        token = env.token;
+        headers = { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' };
+    });
+
+    afterAll(async () => {
+        if (env) env.close();
+    });
+
+    it('should return only requested fields using $select on item get', async () => {
+        // 1. Get root, but only strictly its name and id (filtering out size, folder, parentReference, etc)
+        const res = await fetch(`${baseUrl}/v1.0/me/drive/root?$select=id,name`, { headers });
+        expect(res.status).toBe(200);
+
+        const data = await res.json();
+
+        // Ensure id and name are there
+        expect(data.id).toBeDefined();
+        expect(data.name).toBe('root');
+
+        // Ensure nothing else got leaked
+        // Ensure nothing else got leaked
+        // NOTE: Graph API might occasionally append OData annotations implicitly like @odata.context. 
+        // We will assert the base structure without extra root keys like size or folder.
+        expect(data.size).toBeUndefined();
+        expect(data.folder).toBeUndefined();
+        expect(data.parentReference).toBeUndefined();
+        expect(data.fileSystemInfo).toBeUndefined();
+    });
+
+    it('should return only requested fields in list arrays', async () => {
+        // Create a subfolder to exist in children
+        const folderName = 'SelectTestFolder_' + Date.now();
+        await fetch(`${baseUrl}/v1.0/me/drive/items/root/children`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ name: folderName, folder: {} })
+        });
+
+        // 2. Get children with $select bounds
+        const res = await fetch(`${baseUrl}/v1.0/me/drive/items/root/children?$select=id,name`, { headers });
+        expect(res.status).toBe(200);
+
+        const data = await res.json();
+        expect(data.value).toBeDefined();
+        expect(data.value.length).toBeGreaterThan(0);
+
+        const testFolder = data.value.find((i: any) => i.name === folderName);
+        expect(testFolder).toBeDefined();
+
+        // Deeply check that testFolder inside the array respect limits
+        expect(testFolder.id).toBeDefined();
+        expect(testFolder.size).toBeUndefined();
+        expect(testFolder.folder).toBeUndefined();
+    });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "declaration": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.test.ts"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,33 @@
+import { defineConfig } from 'vitest/config';
+import { playwright } from '@vitest/browser-playwright';
+import dotenv from 'dotenv';
+import path from 'path';
+
+// Load .ENV file if it exists
+dotenv.config({ path: path.resolve(__dirname, '.ENV') });
+
+
+export default defineConfig({
+    define: {
+        'process.env.ONEDRIVE_TOKEN': JSON.stringify(process.env.ONEDRIVE_TOKEN),
+        'process.env.TEST_TARGET': JSON.stringify(process.env.TEST_TARGET),
+        'process.env.BROWSER_ENABLED': JSON.stringify(process.env.BROWSER_ENABLED),
+    },
+    test: {
+        env: {
+            // Inject these variables into the browser environment
+            ONEDRIVE_TOKEN: process.env.ONEDRIVE_TOKEN,
+            TEST_TARGET: process.env.TEST_TARGET,
+            BROWSER_ENABLED: process.env.BROWSER_ENABLED
+        },
+        browser: {
+            enabled: process.env.BROWSER_ENABLED === 'true',
+            provider: playwright(),
+            instances: [
+                { browser: 'chromium' }
+            ],
+            headless: true,
+            screenshotFailures: false,
+        },
+    },
+});