@doingdev/opencode-claude-manager-plugin 0.1.65 → 0.1.66

package/dist/test/claude-agent-sdk-adapter.test.js

@@ -1,707 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { ClaudeAgentSdkAdapter } from '../src/claude/claude-agent-sdk-adapter.js';
-import { ToolApprovalManager } from '../src/claude/tool-approval-manager.js';
-function createFakeQuery(messages) {
-    return {
-        async *[Symbol.asyncIterator]() {
-            for (const message of messages) {
-                yield message;
-            }
-        },
-        close() {
-            return undefined;
-        },
-        supportedCommands: async () => [
-            {
-                name: 'review',
-                description: 'Review changes',
-                argumentHint: '<path>',
-            },
-        ],
-        supportedAgents: async () => [
-            {
-                name: 'researcher',
-                description: 'Looks around the repo',
-                model: 'claude-sonnet-4-5',
-            },
-        ],
-        supportedModels: async () => [{ value: 'claude-sonnet-4-5' }],
-    };
-}
-describe('ClaudeAgentSdkAdapter', () => {
-    it('normalizes streamed Claude session events', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([
-                { type: 'system', subtype: 'init', session_id: 'ses_123' },
-                {
-                    type: 'assistant',
-                    session_id: 'ses_123',
-                    message: {
-                        content: [{ type: 'text', text: 'Working through the task.' }],
-                    },
-                },
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    session_id: 'ses_123',
-                    is_error: false,
-                    result: 'Done.',
-                    num_turns: 2,
-                    total_cost_usd: 0.42,
-                },
-            ]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const result = await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Do the thing',
-            includePartialMessages: true,
-        });
-        expect(result.sessionId).toBe('ses_123');
-        expect(result.finalText).toBe('Done.');
-        expect(result.events.map((event) => event.type)).toEqual(['init', 'assistant', 'result']);
-    });
-    it('splits assistant turns into text and tool_call events', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([
-                { type: 'system', subtype: 'init', session_id: 'ses_tool' },
-                {
-                    type: 'assistant',
-                    session_id: 'ses_tool',
-                    message: {
-                        content: [
-                            { type: 'text', text: 'Searching.' },
-                            {
-                                type: 'tool_use',
-                                name: 'Grep',
-                                id: 'toolu_1',
-                                input: { pattern: 'foo', path: '.' },
-                            },
-                        ],
-                    },
-                },
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    session_id: 'ses_tool',
-                    is_error: false,
-                    result: 'Found.',
-                    num_turns: 1,
-                    total_cost_usd: 0.02,
-                },
-            ]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const result = await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Search',
-            includePartialMessages: true,
-        });
-        expect(result.events.map((e) => e.type)).toEqual(['init', 'assistant', 'tool_call', 'result']);
-        expect(result.events[2]).toMatchObject({ type: 'tool_call' });
-        expect(result.events[2]?.text).toContain('Grep');
-        expect(result.events[2]?.text).toContain('toolu_1');
-    });
-    it('emits user messages with tool_result content', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([
-                { type: 'system', subtype: 'init', session_id: 'ses_u' },
-                {
-                    type: 'user',
-                    session_id: 'ses_u',
-                    parent_tool_use_id: null,
-                    message: {
-                        role: 'user',
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: 'toolu_1',
-                                content: 'file.ts:42: match',
-                            },
-                        ],
-                    },
-                },
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    session_id: 'ses_u',
-                    is_error: false,
-                    result: 'OK',
-                    num_turns: 1,
-                    total_cost_usd: 0,
-                },
-            ]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const result = await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Run',
-            includePartialMessages: true,
-        });
-        expect(result.events.map((e) => e.type)).toEqual(['init', 'user', 'result']);
-        expect(result.events[1]?.text).toContain('tool_result:toolu_1');
-        expect(result.events[1]?.text).toContain('file.ts');
-    });
-    it('drops stream_event payloads when includePartialMessages is false', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([
-                { type: 'system', subtype: 'init', session_id: 'ses_123' },
-                {
-                    type: 'stream_event',
-                    session_id: 'ses_123',
-                    event: {
-                        type: 'content_block_delta',
-                        delta: { text: 'Partial output' },
-                    },
-                },
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    session_id: 'ses_123',
-                    is_error: false,
-                    result: 'Done.',
-                    num_turns: 1,
-                    total_cost_usd: 0.01,
-                },
-            ]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const result = await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Do the thing',
-            includePartialMessages: false,
-        });
-        expect(result.events.map((event) => event.type)).toEqual(['init', 'result']);
-    });
-    it('collapses partials and drops them before the final result', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([
-                { type: 'system', subtype: 'init', session_id: 'ses_123' },
-                {
-                    type: 'stream_event',
-                    session_id: 'ses_123',
-                    event: {
-                        type: 'content_block_delta',
-                        delta: { text: 'Partial ' },
-                    },
-                },
-                {
-                    type: 'stream_event',
-                    session_id: 'ses_123',
-                    event: {
-                        type: 'content_block_delta',
-                        delta: { text: 'output' },
-                    },
-                },
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    session_id: 'ses_123',
-                    is_error: false,
-                    result: 'Done.',
-                    num_turns: 1,
-                    total_cost_usd: 0.01,
-                },
-            ]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const result = await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Do the thing',
-            includePartialMessages: true,
-        });
-        expect(result.events.map((event) => event.type)).toEqual(['init', 'result']);
-    });
-    it('ignores structural stream events without text payloads', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([
-                { type: 'system', subtype: 'init', session_id: 'ses_123' },
-                {
-                    type: 'stream_event',
-                    session_id: 'ses_123',
-                    event: { type: 'message_start' },
-                },
-                {
-                    type: 'stream_event',
-                    session_id: 'ses_123',
-                    event: {
-                        type: 'content_block_delta',
-                        delta: { text: 'Partial output' },
-                    },
-                },
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    session_id: 'ses_123',
-                    is_error: false,
-                    result: 'Done.',
-                    num_turns: 1,
-                    total_cost_usd: 0.01,
-                },
-            ]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const result = await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Do the thing',
-            includePartialMessages: true,
-        });
-        expect(result.events.map((event) => event.type)).toEqual(['init', 'result']);
-    });
-    it('defaults permissionMode to acceptEdits when omitted', async () => {
-        let capturedPermissionMode;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedPermissionMode = params.options?.permissionMode;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_pm',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Do the thing',
-        });
-        expect(capturedPermissionMode).toBe('acceptEdits');
-    });
-    it('merges Skill into allowedTools for SDK Agent Skills', async () => {
-        let capturedAllowed;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedAllowed = params.options?.allowedTools;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_skill',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Use a skill',
-        });
-        expect(capturedAllowed).toEqual(['Skill']);
-    });
-    it('appends Skill once when allowedTools is provided', async () => {
-        let capturedAllowed;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedAllowed = params.options?.allowedTools;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_skill',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'x',
-            allowedTools: ['Read', 'Grep'],
-        });
-        expect(capturedAllowed).toEqual(['Read', 'Grep', 'Skill']);
-    });
-    it('does not add Skill when Skill is disallowed', async () => {
-        let capturedAllowed;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedAllowed = params.options?.allowedTools;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_skill',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'x',
-            disallowedTools: ['Skill'],
-        });
-        expect(capturedAllowed).toBeUndefined();
-    });
-    it('extracts full usage from result with camelCase modelUsage', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([
-                { type: 'system', subtype: 'init', session_id: 'ses_usage' },
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    session_id: 'ses_usage',
-                    is_error: false,
-                    result: 'Done.',
-                    num_turns: 5,
-                    total_cost_usd: 1.23,
-                    usage: { input_tokens: 50_000, output_tokens: 8_000 },
-                    modelUsage: {
-                        'claude-opus-4-6': { contextWindow: 200_000 },
-                    },
-                },
-            ]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const result = await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Do work',
-        });
-        expect(result.turns).toBe(5);
-        expect(result.totalCostUsd).toBe(1.23);
-        expect(result.inputTokens).toBe(50_000);
-        expect(result.outputTokens).toBe(8_000);
-        expect(result.contextWindowSize).toBe(200_000);
-    });
-    it('extracts usage from snake_case model_usage fallback', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([
-                {
-                    type: 'result',
-                    subtype: 'success',
-                    session_id: 'ses_snake',
-                    is_error: false,
-                    result: 'Ok.',
-                    num_turns: 1,
-                    total_cost_usd: 0.01,
-                    usage: { input_tokens: 1000, output_tokens: 200 },
-                    model_usage: {
-                        'claude-sonnet-4-5': { context_window: 180_000 },
-                    },
-                },
-            ]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const result = await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'x',
-        });
-        expect(result.inputTokens).toBe(1000);
-        expect(result.outputTokens).toBe(200);
-        expect(result.contextWindowSize).toBe(180_000);
-    });
-    it('denies write tools when restrictWriteTools is true', async () => {
-        let capturedCanUseTool;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedCanUseTool = params.options?.canUseTool;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_rw',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Investigate',
-            restrictWriteTools: true,
-        });
-        expect(capturedCanUseTool).toBeDefined();
-        const editResult = await capturedCanUseTool('Edit', { file_path: 'x.ts' }, {});
-        expect(editResult.behavior).toBe('deny');
-        const writeResult = await capturedCanUseTool('Write', { file_path: 'y.ts' }, {});
-        expect(writeResult.behavior).toBe('deny');
-        const multiEditResult = await capturedCanUseTool('MultiEdit', { file_path: 'z.ts' }, {});
-        expect(multiEditResult.behavior).toBe('deny');
-        const readResult = await capturedCanUseTool('Read', { file_path: 'a.ts' }, {});
-        expect(readResult.behavior).toBe('allow');
-        const grepResult = await capturedCanUseTool('Grep', { pattern: 'foo', path: '.' }, {});
-        expect(grepResult.behavior).toBe('allow');
-    });
-    it('denies destructive bash commands when restrictWriteTools is true', async () => {
-        let capturedCanUseTool;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedCanUseTool = params.options?.canUseTool;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_bash',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Check',
-            restrictWriteTools: true,
-        });
-        expect(capturedCanUseTool).toBeDefined();
-        const sedResult = await capturedCanUseTool('Bash', { command: "sed -i 's/old/new/' file.ts" }, {});
-        expect(sedResult.behavior).toBe('deny');
-        const echoResult = await capturedCanUseTool('Bash', { command: 'echo "data" > out.txt' }, {});
-        expect(echoResult.behavior).toBe('deny');
-        const gitCommitResult = await capturedCanUseTool('Bash', { command: 'git commit -m "fix"' }, {});
-        expect(gitCommitResult.behavior).toBe('deny');
-        const lsResult = await capturedCanUseTool('Bash', { command: 'ls -la src/' }, {});
-        expect(lsResult.behavior).toBe('allow');
-        const catResult = await capturedCanUseTool('Bash', { command: 'cat src/index.ts' }, {});
-        expect(catResult.behavior).toBe('allow');
-        const gitLogResult = await capturedCanUseTool('Bash', { command: 'git log --oneline -10' }, {});
-        expect(gitLogResult.behavior).toBe('allow');
-    });
-    it('allows Playwriter-style bash commands when restrictWriteTools is true', async () => {
-        let capturedCanUseTool;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedCanUseTool = params.options?.canUseTool;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_playwriter',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Run Playwriter tests',
-            restrictWriteTools: true,
-        });
-        expect(capturedCanUseTool).toBeDefined();
-        // Non-destructive Playwriter commands must be allowed
-        const playwriterResult = await capturedCanUseTool('Bash', { command: 'playwriter session new' }, {});
-        expect(playwriterResult.behavior).toBe('allow');
-        const npxResult = await capturedCanUseTool('Bash', { command: 'npx playwriter session new' }, {});
-        expect(npxResult.behavior).toBe('allow');
-        const listResult = await capturedCanUseTool('Bash', { command: 'playwriter session list' }, {});
-        expect(listResult.behavior).toBe('allow');
-        // Destructive commands must still be denied
-        const rmResult = await capturedCanUseTool('Bash', { command: 'rm -rf /tmp/screenshots' }, {});
-        expect(rmResult.behavior).toBe('deny');
-        const redirectResult = await capturedCanUseTool('Bash', { command: 'echo "data" > out.txt' }, {});
-        expect(redirectResult.behavior).toBe('deny');
-    });
-    it('allows write tools when restrictWriteTools is false', async () => {
-        let capturedCanUseTool;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedCanUseTool = params.options?.canUseTool;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_free',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Implement',
-            restrictWriteTools: false,
-        });
-        expect(capturedCanUseTool).toBeUndefined();
-    });
-    it('passes through explicit permissionMode', async () => {
-        let capturedPermissionMode;
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: (params) => {
-                capturedPermissionMode = params.options?.permissionMode;
-                return createFakeQuery([
-                    {
-                        type: 'result',
-                        subtype: 'success',
-                        session_id: 'ses_pm',
-                        is_error: false,
-                        result: 'ok',
-                        num_turns: 1,
-                        total_cost_usd: 0,
-                    },
-                ]);
-            },
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        await adapter.runSession({
-            cwd: '/tmp/project',
-            prompt: 'Do the thing',
-            permissionMode: 'plan',
-        });
-        expect(capturedPermissionMode).toBe('plan');
-    });
-    describe('debug log', () => {
-        let tmpDir;
-        afterEach(async () => {
-            if (tmpDir) {
-                await rm(tmpDir, { recursive: true, force: true });
-            }
-        });
-        it('appends a tool_denied entry when restrictWriteTools denies a write tool', async () => {
-            tmpDir = await mkdtemp(join(tmpdir(), 'adapter-log-'));
-            const logPath = join(tmpDir, '.claude-manager', 'debug.log');
-            let capturedCanUseTool;
-            const adapter = new ClaudeAgentSdkAdapter({
-                query: (params) => {
-                    capturedCanUseTool = params.options?.canUseTool;
-                    return createFakeQuery([
-                        {
-                            type: 'result',
-                            subtype: 'success',
-                            session_id: 'ses_log',
-                            is_error: false,
-                            result: 'ok',
-                            num_turns: 1,
-                            total_cost_usd: 0,
-                        },
-                    ]);
-                },
-                listSessions: async () => [],
-                getSessionMessages: async () => [],
-            }, undefined, logPath);
-            await adapter.runSession({ cwd: '/tmp/project', prompt: 'Test', restrictWriteTools: true });
-            expect(capturedCanUseTool).toBeDefined();
-            const result = await capturedCanUseTool('Edit', { file_path: 'x.ts' }, {});
-            expect(result.behavior).toBe('deny');
-            const content = await readFile(logPath, 'utf8');
-            const entry = JSON.parse(content.trim().split('\n')[0]);
-            expect(entry.type).toBe('tool_denied');
-            expect(entry.toolName).toBe('Edit');
-            expect(entry.reason).toBe('restrictWriteTools');
-            expect(typeof entry.ts).toBe('string');
-        });
-        it('appends a tool_denied entry when the approval manager denies a tool', async () => {
-            tmpDir = await mkdtemp(join(tmpdir(), 'adapter-log-policy-'));
-            const logPath = join(tmpDir, '.claude-manager', 'debug.log');
-            const approvalManager = new ToolApprovalManager({
-                rules: [
-                    {
-                        id: 'deny-bash',
-                        toolPattern: 'Bash',
-                        inputPattern: 'rm -rf /',
-                        action: 'deny',
-                        denyMessage: 'rm -rf / is not allowed',
-                    },
-                ],
-                enabled: true,
-            });
-            let capturedCanUseTool;
-            const adapter = new ClaudeAgentSdkAdapter({
-                query: (params) => {
-                    capturedCanUseTool = params.options?.canUseTool;
-                    return createFakeQuery([
-                        {
-                            type: 'result',
-                            subtype: 'success',
-                            session_id: 'ses_policy',
-                            is_error: false,
-                            result: 'ok',
-                            num_turns: 1,
-                            total_cost_usd: 0,
-                        },
-                    ]);
-                },
-                listSessions: async () => [],
-                getSessionMessages: async () => [],
-            }, approvalManager, logPath);
-            await adapter.runSession({ cwd: '/tmp/project', prompt: 'Test' });
-            expect(capturedCanUseTool).toBeDefined();
-            const result = await capturedCanUseTool('Bash', { command: 'rm -rf /' }, {});
-            expect(result.behavior).toBe('deny');
-            const content = await readFile(logPath, 'utf8');
-            const entry = JSON.parse(content.trim().split('\n')[0]);
-            expect(entry.type).toBe('tool_denied');
-            expect(entry.toolName).toBe('Bash');
-            expect(entry.reason).toBe('approvalPolicy');
-            expect(typeof entry.ts).toBe('string');
-        });
-        it('does not create a log file when no debugLogPath is provided', async () => {
-            tmpDir = await mkdtemp(join(tmpdir(), 'adapter-no-log-'));
-            let capturedCanUseTool;
-            const adapter = new ClaudeAgentSdkAdapter({
-                query: (params) => {
-                    capturedCanUseTool = params.options?.canUseTool;
-                    return createFakeQuery([
-                        {
-                            type: 'result',
-                            subtype: 'success',
-                            session_id: 'ses_nolog',
-                            is_error: false,
-                            result: 'ok',
-                            num_turns: 1,
-                            total_cost_usd: 0,
-                        },
-                    ]);
-                },
-                listSessions: async () => [],
-                getSessionMessages: async () => [],
-            });
-            await adapter.runSession({ cwd: '/tmp/project', prompt: 'Test', restrictWriteTools: true });
-            const result = await capturedCanUseTool('Edit', { file_path: 'x.ts' }, {});
-            expect(result.behavior).toBe('deny');
-            // No log file should exist
-            await expect(readFile(join(tmpDir, 'debug.log'), 'utf8')).rejects.toThrow();
-        });
-    });
-});