@zze/mock-server 0.2.4

package/dist/admin/__tests__/admin-router.test.js

@@ -0,0 +1,621 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const supertest_1 = __importDefault(require("supertest"));
+const mock_server_app_js_1 = require("../../server/mock-server-app.js");
+// Test fixtures
+const mockEndpoints = [
+    {
+        id: 'get-users',
+        path: '/users',
+        method: 'GET',
+        scenarios: [
+            { id: 'success', name: 'Success', status: 200, body: [] },
+            { id: 'error', name: 'Error', status: 500, body: { error: 'Failed' } },
+        ],
+        defaultScenarioId: 'success',
+    },
+    {
+        id: 'get-products',
+        path: '/products',
+        method: 'GET',
+        scenarios: [
+            { id: 'list', name: 'Product List', status: 200, body: [] },
+            { id: 'empty', name: 'Empty', status: 200, body: [] },
+        ],
+        defaultScenarioId: 'list',
+    },
+];
+const mockFlows = [
+    {
+        id: 'admin-flow',
+        name: 'Admin Flow',
+        description: 'Flow for admin users',
+        endpointScenarios: {
+            'get-users': 'success',
+            'get-products': 'list',
+        },
+    },
+    {
+        id: 'error-flow',
+        name: 'Error Flow',
+        endpointScenarios: {
+            'get-users': 'error',
+        },
+    },
+];
+(0, vitest_1.describe)('Admin Router', () => {
+    let serverApp;
+    (0, vitest_1.beforeEach)(() => {
+        serverApp = new mock_server_app_js_1.MockServerApp({ port: 0 });
+        serverApp.registerConfig(mockEndpoints, mockFlows);
+    });
+    (0, vitest_1.afterEach)(async () => {
+        if (serverApp.isRunning()) {
+            await serverApp.stop();
+        }
+    });
+    (0, vitest_1.describe)('GET /mock-admin/api/config', () => {
+        (0, vitest_1.it)('should return all endpoints and flows', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .get('/mock-admin/api/config')
+                .expect(200);
+            (0, vitest_1.expect)(res.body.endpoints).toHaveLength(2);
+            (0, vitest_1.expect)(res.body.flows).toHaveLength(2);
+        });
+        (0, vitest_1.it)('should return endpoint details', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .get('/mock-admin/api/config')
+                .expect(200);
+            const usersEndpoint = res.body.endpoints.find((e) => e.id === 'get-users');
+            (0, vitest_1.expect)(usersEndpoint).toBeDefined();
+            (0, vitest_1.expect)(usersEndpoint.path).toBe('/users');
+            (0, vitest_1.expect)(usersEndpoint.method).toBe('GET');
+            (0, vitest_1.expect)(usersEndpoint.scenarios).toHaveLength(2);
+            (0, vitest_1.expect)(usersEndpoint.defaultScenarioId).toBe('success');
+        });
+        (0, vitest_1.it)('should return scenario summary without body', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .get('/mock-admin/api/config')
+                .expect(200);
+            const usersEndpoint = res.body.endpoints.find((e) => e.id === 'get-users');
+            const successScenario = usersEndpoint.scenarios.find((s) => s.id === 'success');
+            (0, vitest_1.expect)(successScenario.id).toBe('success');
+            (0, vitest_1.expect)(successScenario.name).toBe('Success');
+            (0, vitest_1.expect)(successScenario.status).toBe(200);
+            (0, vitest_1.expect)(successScenario.body).toBeUndefined(); // Body not included
+        });
+        (0, vitest_1.it)('should return flow details', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .get('/mock-admin/api/config')
+                .expect(200);
+            const adminFlow = res.body.flows.find((f) => f.id === 'admin-flow');
+            (0, vitest_1.expect)(adminFlow).toBeDefined();
+            (0, vitest_1.expect)(adminFlow.name).toBe('Admin Flow');
+            (0, vitest_1.expect)(adminFlow.description).toBe('Flow for admin users');
+            (0, vitest_1.expect)(adminFlow.endpointScenarios).toEqual({
+                'get-users': 'success',
+                'get-products': 'list',
+            });
+        });
+    });
+    (0, vitest_1.describe)('GET /mock-admin/api/state', () => {
+        (0, vitest_1.it)('should return initial state', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .get('/mock-admin/api/state')
+                .expect(200);
+            (0, vitest_1.expect)(res.body.activeFlowId).toBeNull();
+            (0, vitest_1.expect)(res.body.activeScenarios).toEqual({});
+        });
+        (0, vitest_1.it)('should return state with active scenario', async () => {
+            serverApp.getStateManager().activateScenario('get-users', 'error');
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .get('/mock-admin/api/state')
+                .expect(200);
+            (0, vitest_1.expect)(res.body.activeScenarios).toEqual({ 'get-users': 'error' });
+        });
+        (0, vitest_1.it)('should return state with active flow', async () => {
+            serverApp.getStateManager().activateFlow('admin-flow');
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .get('/mock-admin/api/state')
+                .expect(200);
+            (0, vitest_1.expect)(res.body.activeFlowId).toBe('admin-flow');
+        });
+    });
+    (0, vitest_1.describe)('POST /mock-admin/api/scenarios/activate', () => {
+        (0, vitest_1.it)('should activate a scenario', async () => {
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/scenarios/activate')
+                .send({ endpointId: 'get-users', scenarioId: 'error' })
+                .expect(204);
+            const state = serverApp.getStateManager().getState();
+            (0, vitest_1.expect)(state.activeScenarios['get-users']).toBe('error');
+        });
+        (0, vitest_1.it)('should affect mock API responses', async () => {
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/scenarios/activate')
+                .send({ endpointId: 'get-users', scenarioId: 'error' })
+                .expect(204);
+            await (0, supertest_1.default)(serverApp.getApp())
+                .get('/api/users')
+                .expect(500);
+        });
+        (0, vitest_1.it)('should return 400 for invalid endpoint', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/scenarios/activate')
+                .send({ endpointId: 'nonexistent', scenarioId: 'success' })
+                .expect(400);
+            (0, vitest_1.expect)(res.body.error).toContain('not found');
+        });
+        (0, vitest_1.it)('should return 400 for invalid scenario', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/scenarios/activate')
+                .send({ endpointId: 'get-users', scenarioId: 'nonexistent' })
+                .expect(400);
+            (0, vitest_1.expect)(res.body.error).toContain('not found');
+        });
+        (0, vitest_1.it)('should return 400 for missing endpointId', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/scenarios/activate')
+                .send({ scenarioId: 'success' })
+                .expect(400);
+            (0, vitest_1.expect)(res.body.error).toBe('Invalid request body');
+        });
+        (0, vitest_1.it)('should return 400 for missing scenarioId', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/scenarios/activate')
+                .send({ endpointId: 'get-users' })
+                .expect(400);
+            (0, vitest_1.expect)(res.body.error).toBe('Invalid request body');
+        });
+    });
+    (0, vitest_1.describe)('POST /mock-admin/api/flows/activate', () => {
+        (0, vitest_1.it)('should activate a flow', async () => {
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows/activate')
+                .send({ flowId: 'admin-flow' })
+                .expect(204);
+            const state = serverApp.getStateManager().getState();
+            (0, vitest_1.expect)(state.activeFlowId).toBe('admin-flow');
+        });
+        (0, vitest_1.it)('should deactivate flow with null', async () => {
+            serverApp.getStateManager().activateFlow('admin-flow');
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows/activate')
+                .send({ flowId: null })
+                .expect(204);
+            const state = serverApp.getStateManager().getState();
+            (0, vitest_1.expect)(state.activeFlowId).toBeNull();
+        });
+        (0, vitest_1.it)('should affect mock API responses', async () => {
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows/activate')
+                .send({ flowId: 'error-flow' })
+                .expect(204);
+            await (0, supertest_1.default)(serverApp.getApp())
+                .get('/api/users')
+                .expect(500);
+        });
+        (0, vitest_1.it)('should return 400 for invalid flow', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows/activate')
+                .send({ flowId: 'nonexistent' })
+                .expect(400);
+            (0, vitest_1.expect)(res.body.error).toContain('not found');
+        });
+        (0, vitest_1.it)('should return 400 for missing flowId', async () => {
+            const res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows/activate')
+                .send({})
+                .expect(400);
+            (0, vitest_1.expect)(res.body.error).toBe('Invalid request body');
+        });
+    });
+    (0, vitest_1.describe)('POST /mock-admin/api/reset', () => {
+        (0, vitest_1.it)('should reset all state', async () => {
+            serverApp.getStateManager().activateFlow('admin-flow');
+            serverApp.getStateManager().activateScenario('get-users', 'error');
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/reset')
+                .expect(204);
+            const state = serverApp.getStateManager().getState();
+            (0, vitest_1.expect)(state.activeFlowId).toBeNull();
+            (0, vitest_1.expect)(state.activeScenarios).toEqual({});
+        });
+        (0, vitest_1.it)('should restore default scenarios', async () => {
+            serverApp.getStateManager().activateScenario('get-users', 'error');
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/reset')
+                .expect(204);
+            // Should now return success (default)
+            await (0, supertest_1.default)(serverApp.getApp())
+                .get('/api/users')
+                .expect(200);
+        });
+    });
+    (0, vitest_1.describe)('integration with mock API', () => {
+        (0, vitest_1.it)('should allow full workflow: activate scenario, test, reset', async () => {
+            // Initial state - success
+            await (0, supertest_1.default)(serverApp.getApp())
+                .get('/api/users')
+                .expect(200);
+            // Activate error scenario
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/scenarios/activate')
+                .send({ endpointId: 'get-users', scenarioId: 'error' })
+                .expect(204);
+            // Now returns error
+            await (0, supertest_1.default)(serverApp.getApp())
+                .get('/api/users')
+                .expect(500);
+            // Reset
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/reset')
+                .expect(204);
+            // Back to success
+            await (0, supertest_1.default)(serverApp.getApp())
+                .get('/api/users')
+                .expect(200);
+        });
+        (0, vitest_1.it)('should allow full workflow: activate flow, test, deactivate', async () => {
+            // Activate error flow
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows/activate')
+                .send({ flowId: 'error-flow' })
+                .expect(204);
+            // Now returns error
+            await (0, supertest_1.default)(serverApp.getApp())
+                .get('/api/users')
+                .expect(500);
+            // Deactivate flow
+            await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows/activate')
+                .send({ flowId: null })
+                .expect(204);
+            // Back to success
+            await (0, supertest_1.default)(serverApp.getApp())
+                .get('/api/users')
+                .expect(200);
+        });
+    });
+    (0, vitest_1.describe)('Endpoint CRUD operations', () => {
+        let mockConfigWriter;
+        let onConfigChangeCalled;
+        (0, vitest_1.beforeEach)(() => {
+            onConfigChangeCalled = false;
+            mockConfigWriter = {
+                writeEndpoint: vitest_1.vi.fn().mockResolvedValue({ success: true, filePath: '/test/endpoint.json' }),
+                writeFlow: vitest_1.vi.fn().mockResolvedValue({ success: true, filePath: '/test/flow.json' }),
+                deleteEndpoint: vitest_1.vi.fn().mockResolvedValue({ success: true }),
+                deleteFlow: vitest_1.vi.fn().mockResolvedValue({ success: true }),
+                getEndpointFilePath: vitest_1.vi.fn().mockReturnValue('/test/endpoint.json'),
+                getFlowFilePath: vitest_1.vi.fn().mockReturnValue('/test/flow.json'),
+                findEndpointFile: vitest_1.vi.fn().mockResolvedValue(null),
+                findFlowFile: vitest_1.vi.fn().mockResolvedValue(null),
+            };
+            serverApp.setConfigWriter(mockConfigWriter, async () => {
+                onConfigChangeCalled = true;
+            });
+        });
+        (0, vitest_1.describe)('POST /mock-admin/api/endpoints', () => {
+            (0, vitest_1.it)('should create a new endpoint', async () => {
+                const newEndpoint = {
+                    id: 'new-endpoint',
+                    path: '/new',
+                    method: 'POST',
+                    scenarios: [
+                        { id: 'success', name: 'Success', status: 201, body: { created: true } },
+                    ],
+                    defaultScenarioId: 'success',
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/endpoints')
+                    .send(newEndpoint)
+                    .expect(201);
+                (0, vitest_1.expect)(res.body.id).toBe('new-endpoint');
+                (0, vitest_1.expect)(res.body.filePath).toBeDefined();
+                (0, vitest_1.expect)(mockConfigWriter.writeEndpoint).toHaveBeenCalledWith(newEndpoint);
+                (0, vitest_1.expect)(onConfigChangeCalled).toBe(true);
+            });
+            (0, vitest_1.it)('should return 409 if endpoint already exists', async () => {
+                const existingEndpoint = {
+                    id: 'get-users',
+                    path: '/users',
+                    method: 'GET',
+                    scenarios: [{ id: 's', name: 'S', status: 200, body: {} }],
+                    defaultScenarioId: 's',
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/endpoints')
+                    .send(existingEndpoint)
+                    .expect(409);
+                (0, vitest_1.expect)(res.body.error).toContain('already exists');
+            });
+            (0, vitest_1.it)('should return 400 for invalid endpoint', async () => {
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/endpoints')
+                    .send({ id: 'test' }) // Missing required fields
+                    .expect(400);
+                (0, vitest_1.expect)(res.body.error).toBe('Invalid request body');
+            });
+        });
+        (0, vitest_1.describe)('PUT /mock-admin/api/endpoints/:id', () => {
+            (0, vitest_1.it)('should update an existing endpoint', async () => {
+                const updatedEndpoint = {
+                    id: 'get-users',
+                    path: '/users/updated',
+                    method: 'GET',
+                    scenarios: [
+                        { id: 'success', name: 'Success', status: 200, body: { updated: true } },
+                    ],
+                    defaultScenarioId: 'success',
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .put('/mock-admin/api/endpoints/get-users')
+                    .send(updatedEndpoint)
+                    .expect(200);
+                (0, vitest_1.expect)(res.body.id).toBe('get-users');
+                (0, vitest_1.expect)(mockConfigWriter.writeEndpoint).toHaveBeenCalledWith(updatedEndpoint);
+                (0, vitest_1.expect)(onConfigChangeCalled).toBe(true);
+            });
+            (0, vitest_1.it)('should return 404 if endpoint not found', async () => {
+                const endpoint = {
+                    id: 'nonexistent',
+                    path: '/test',
+                    method: 'GET',
+                    scenarios: [{ id: 's', name: 'S', status: 200, body: {} }],
+                    defaultScenarioId: 's',
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .put('/mock-admin/api/endpoints/nonexistent')
+                    .send(endpoint)
+                    .expect(404);
+                (0, vitest_1.expect)(res.body.error).toContain('not found');
+            });
+            (0, vitest_1.it)('should return 400 if ID in body does not match URL', async () => {
+                const endpoint = {
+                    id: 'different-id',
+                    path: '/users',
+                    method: 'GET',
+                    scenarios: [{ id: 's', name: 'S', status: 200, body: {} }],
+                    defaultScenarioId: 's',
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .put('/mock-admin/api/endpoints/get-users')
+                    .send(endpoint)
+                    .expect(400);
+                (0, vitest_1.expect)(res.body.error).toContain('must match');
+            });
+        });
+        (0, vitest_1.describe)('DELETE /mock-admin/api/endpoints/:id', () => {
+            (0, vitest_1.it)('should delete an existing endpoint', async () => {
+                await (0, supertest_1.default)(serverApp.getApp())
+                    .delete('/mock-admin/api/endpoints/get-users')
+                    .expect(204);
+                (0, vitest_1.expect)(mockConfigWriter.deleteEndpoint).toHaveBeenCalledWith('get-users');
+                (0, vitest_1.expect)(onConfigChangeCalled).toBe(true);
+            });
+            (0, vitest_1.it)('should return 404 if endpoint not found', async () => {
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .delete('/mock-admin/api/endpoints/nonexistent')
+                    .expect(404);
+                (0, vitest_1.expect)(res.body.error).toContain('not found');
+            });
+        });
+    });
+    (0, vitest_1.describe)('Flow CRUD operations', () => {
+        let mockConfigWriter;
+        let onConfigChangeCalled;
+        (0, vitest_1.beforeEach)(() => {
+            onConfigChangeCalled = false;
+            mockConfigWriter = {
+                writeEndpoint: vitest_1.vi.fn().mockResolvedValue({ success: true, filePath: '/test/endpoint.json' }),
+                writeFlow: vitest_1.vi.fn().mockResolvedValue({ success: true, filePath: '/test/flow.json' }),
+                deleteEndpoint: vitest_1.vi.fn().mockResolvedValue({ success: true }),
+                deleteFlow: vitest_1.vi.fn().mockResolvedValue({ success: true }),
+                getEndpointFilePath: vitest_1.vi.fn().mockReturnValue('/test/endpoint.json'),
+                getFlowFilePath: vitest_1.vi.fn().mockReturnValue('/test/flow.json'),
+                findEndpointFile: vitest_1.vi.fn().mockResolvedValue(null),
+                findFlowFile: vitest_1.vi.fn().mockResolvedValue(null),
+            };
+            serverApp.setConfigWriter(mockConfigWriter, async () => {
+                onConfigChangeCalled = true;
+            });
+        });
+        (0, vitest_1.describe)('POST /mock-admin/api/flows', () => {
+            (0, vitest_1.it)('should create a new flow', async () => {
+                const newFlow = {
+                    id: 'new-flow',
+                    name: 'New Flow',
+                    endpointScenarios: { 'get-users': 'success' },
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/flows')
+                    .send(newFlow)
+                    .expect(201);
+                (0, vitest_1.expect)(res.body.id).toBe('new-flow');
+                (0, vitest_1.expect)(res.body.filePath).toBeDefined();
+                (0, vitest_1.expect)(mockConfigWriter.writeFlow).toHaveBeenCalledWith(newFlow);
+                (0, vitest_1.expect)(onConfigChangeCalled).toBe(true);
+            });
+            (0, vitest_1.it)('should return 409 if flow already exists', async () => {
+                const existingFlow = {
+                    id: 'admin-flow',
+                    name: 'Admin Flow',
+                    endpointScenarios: {},
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/flows')
+                    .send(existingFlow)
+                    .expect(409);
+                (0, vitest_1.expect)(res.body.error).toContain('already exists');
+            });
+        });
+        (0, vitest_1.describe)('PUT /mock-admin/api/flows/:id', () => {
+            (0, vitest_1.it)('should update an existing flow', async () => {
+                const updatedFlow = {
+                    id: 'admin-flow',
+                    name: 'Updated Admin Flow',
+                    endpointScenarios: { 'get-users': 'error' },
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .put('/mock-admin/api/flows/admin-flow')
+                    .send(updatedFlow)
+                    .expect(200);
+                (0, vitest_1.expect)(res.body.id).toBe('admin-flow');
+                (0, vitest_1.expect)(mockConfigWriter.writeFlow).toHaveBeenCalledWith(updatedFlow);
+                (0, vitest_1.expect)(onConfigChangeCalled).toBe(true);
+            });
+            (0, vitest_1.it)('should return 404 if flow not found', async () => {
+                const flow = {
+                    id: 'nonexistent',
+                    name: 'Test',
+                    endpointScenarios: {},
+                };
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .put('/mock-admin/api/flows/nonexistent')
+                    .send(flow)
+                    .expect(404);
+                (0, vitest_1.expect)(res.body.error).toContain('not found');
+            });
+        });
+        (0, vitest_1.describe)('DELETE /mock-admin/api/flows/:id', () => {
+            (0, vitest_1.it)('should delete an existing flow', async () => {
+                await (0, supertest_1.default)(serverApp.getApp())
+                    .delete('/mock-admin/api/flows/admin-flow')
+                    .expect(204);
+                (0, vitest_1.expect)(mockConfigWriter.deleteFlow).toHaveBeenCalledWith('admin-flow');
+                (0, vitest_1.expect)(onConfigChangeCalled).toBe(true);
+            });
+            (0, vitest_1.it)('should return 404 if flow not found', async () => {
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .delete('/mock-admin/api/flows/nonexistent')
+                    .expect(404);
+                (0, vitest_1.expect)(res.body.error).toContain('not found');
+            });
+            (0, vitest_1.it)('should deactivate flow if it was active', async () => {
+                // Activate the flow first
+                await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/flows/activate')
+                    .send({ flowId: 'admin-flow' })
+                    .expect(204);
+                // Verify it's active
+                const stateBefore = await (0, supertest_1.default)(serverApp.getApp())
+                    .get('/mock-admin/api/state')
+                    .expect(200);
+                (0, vitest_1.expect)(stateBefore.body.activeFlowId).toBe('admin-flow');
+                // Delete the flow
+                await (0, supertest_1.default)(serverApp.getApp())
+                    .delete('/mock-admin/api/flows/admin-flow')
+                    .expect(204);
+                // Verify it's deactivated
+                const stateAfter = await (0, supertest_1.default)(serverApp.getApp())
+                    .get('/mock-admin/api/state')
+                    .expect(200);
+                (0, vitest_1.expect)(stateAfter.body.activeFlowId).toBeNull();
+            });
+        });
+        (0, vitest_1.describe)('POST /mock-admin/api/flows/:id/duplicate', () => {
+            (0, vitest_1.it)('should duplicate an existing flow', async () => {
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/flows/admin-flow/duplicate')
+                    .send({ newId: 'admin-flow-copy' })
+                    .expect(201);
+                (0, vitest_1.expect)(res.body.id).toBe('admin-flow-copy');
+                (0, vitest_1.expect)(res.body.filePath).toBeDefined();
+                (0, vitest_1.expect)(mockConfigWriter.writeFlow).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                    id: 'admin-flow-copy',
+                    name: 'Admin Flow (Copy)',
+                    endpointScenarios: { 'get-users': 'success', 'get-products': 'list' },
+                }));
+                (0, vitest_1.expect)(onConfigChangeCalled).toBe(true);
+            });
+            (0, vitest_1.it)('should allow custom name for duplicate', async () => {
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/flows/admin-flow/duplicate')
+                    .send({ newId: 'admin-flow-v2', newName: 'Admin Flow V2' })
+                    .expect(201);
+                (0, vitest_1.expect)(res.body.id).toBe('admin-flow-v2');
+                (0, vitest_1.expect)(mockConfigWriter.writeFlow).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                    id: 'admin-flow-v2',
+                    name: 'Admin Flow V2',
+                }));
+            });
+            (0, vitest_1.it)('should return 404 if source flow not found', async () => {
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/flows/nonexistent/duplicate')
+                    .send({ newId: 'new-flow' })
+                    .expect(404);
+                (0, vitest_1.expect)(res.body.error).toContain('not found');
+            });
+            (0, vitest_1.it)('should return 409 if new ID already exists', async () => {
+                const res = await (0, supertest_1.default)(serverApp.getApp())
+                    .post('/mock-admin/api/flows/admin-flow/duplicate')
+                    .send({ newId: 'error-flow' }) // Already exists
+                    .expect(409);
+                (0, vitest_1.expect)(res.body.error).toContain('already exists');
+            });
+        });
+    });
+    (0, vitest_1.describe)('CRUD operations without ConfigWriter', () => {
+        (0, vitest_1.it)('should return 501 for endpoint CRUD when ConfigWriter not configured', async () => {
+            const endpoint = {
+                id: 'test',
+                path: '/test',
+                method: 'GET',
+                scenarios: [{ id: 's', name: 'S', status: 200, body: {} }],
+                defaultScenarioId: 's',
+            };
+            // POST
+            let res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/endpoints')
+                .send(endpoint)
+                .expect(501);
+            (0, vitest_1.expect)(res.body.error).toContain('not available');
+            // PUT
+            res = await (0, supertest_1.default)(serverApp.getApp())
+                .put('/mock-admin/api/endpoints/get-users')
+                .send({ ...endpoint, id: 'get-users' })
+                .expect(501);
+            (0, vitest_1.expect)(res.body.error).toContain('not available');
+            // DELETE
+            res = await (0, supertest_1.default)(serverApp.getApp())
+                .delete('/mock-admin/api/endpoints/get-users')
+                .expect(501);
+            (0, vitest_1.expect)(res.body.error).toContain('not available');
+        });
+        (0, vitest_1.it)('should return 501 for flow CRUD when ConfigWriter not configured', async () => {
+            const flow = {
+                id: 'test',
+                name: 'Test',
+                endpointScenarios: {},
+            };
+            // POST
+            let res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows')
+                .send(flow)
+                .expect(501);
+            (0, vitest_1.expect)(res.body.error).toContain('not available');
+            // PUT
+            res = await (0, supertest_1.default)(serverApp.getApp())
+                .put('/mock-admin/api/flows/admin-flow')
+                .send({ ...flow, id: 'admin-flow' })
+                .expect(501);
+            (0, vitest_1.expect)(res.body.error).toContain('not available');
+            // DELETE
+            res = await (0, supertest_1.default)(serverApp.getApp())
+                .delete('/mock-admin/api/flows/admin-flow')
+                .expect(501);
+            (0, vitest_1.expect)(res.body.error).toContain('not available');
+            // Duplicate
+            res = await (0, supertest_1.default)(serverApp.getApp())
+                .post('/mock-admin/api/flows/admin-flow/duplicate')
+                .send({ newId: 'new' })
+                .expect(501);
+            (0, vitest_1.expect)(res.body.error).toContain('not available');
+        });
+    });
+});