@cspeach/cli 0.6.4 → 0.7.0

package/dist/tools/__tests__/registry-category.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { registerTool, listTools, getToolsByCategory } from '../index.js';
-import { TOOL_FLAG_PREFIX } from '../_flag.js';
-const FLAG = `${TOOL_FLAG_PREFIX}DEMO_NEW_TOOL`;
-beforeEach(() => { delete process.env[FLAG]; });
-afterEach(() => { delete process.env[FLAG]; });
-describe('Tool.category + getToolsByCategory', () => {
-    it('a tool registered without category defaults to "sap" (back-compat)', () => {
-        registerTool({
-            name: 'demo_legacy_tool',
-            description: 'legacy',
-            input_schema: { type: 'object', properties: {}, required: [] },
-            handler: async () => ({ content: 'ok' }),
-            isMutating: false,
-        });
-        const t = listTools().find((x) => x.name === 'demo_legacy_tool');
-        expect(t?.category).toBe('sap');
-    });
-    it('a tool registered with explicit category preserves it', () => {
-        registerTool({
-            name: 'demo_fs_tool',
-            description: 'fs',
-            input_schema: { type: 'object', properties: {}, required: [] },
-            handler: async () => ({ content: 'ok' }),
-            isMutating: false,
-            category: 'filesystem',
-        });
-        const t = listTools().find((x) => x.name === 'demo_fs_tool');
-        expect(t?.category).toBe('filesystem');
-        expect(getToolsByCategory('filesystem').map((x) => x.name)).toContain('demo_fs_tool');
-    });
-});
-describe('listTools — Phase 3 visibility gate', () => {
-    it('a flag-gated new tool is INVISIBLE when its env flag is unset', () => {
-        registerTool({
-            name: 'demo_new_tool',
-            description: 'gated',
-            input_schema: { type: 'object', properties: {}, required: [] },
-            handler: async () => ({ content: 'ok' }),
-            isMutating: false,
-            category: 'filesystem',
-            flagGated: true,
-        });
-        expect(listTools().some((t) => t.name === 'demo_new_tool')).toBe(false);
-    });
-    it('the same tool is VISIBLE when its env flag is on', () => {
-        process.env[FLAG] = 'on';
-        expect(listTools().some((t) => t.name === 'demo_new_tool')).toBe(true);
-    });
-    it('a tool without flagGated is ALWAYS visible (back-compat for existing 30+ tools)', () => {
-        registerTool({
-            name: 'demo_visible_no_flag',
-            description: 'always-visible',
-            input_schema: { type: 'object', properties: {}, required: [] },
-            handler: async () => ({ content: 'ok' }),
-            isMutating: false,
-        });
-        expect(listTools().some((t) => t.name === 'demo_visible_no_flag')).toBe(true);
-    });
-});

package/dist/tools/__tests__/sap-read-extras.test.js

@@ -1,196 +0,0 @@
-/**
- * Tests for the 8 additional read-only SAP tools added in Phase 3-Lite A.4:
- *   sap_class_includes, sap_inactive_objects, sap_syntax_check, sap_diff,
- *   sap_preview_change, sap_run_unit_test, sap_odata_test, sap_badi_list
- *
- * Pattern: partial mock as `{ method: vi.fn() } as unknown as AdtClient`.
- * Each tool gets a happy-path test and an error-path test (16 tests total).
- */
-import '../sap-read.js'; // triggers registration side-effect
-import { getTool } from '../index.js';
-import { describe, it, expect, vi } from 'vitest';
-// ---------------------------------------------------------------------------
-// Helper: build a minimal ToolContext stub
-// ---------------------------------------------------------------------------
-function makeCtx(adt) {
-    return {
-        adt: adt,
-        sapAlias: 'dev',
-        session: {},
-        cwd: '.',
-    };
-}
-// ---------------------------------------------------------------------------
-// 11. sap_class_includes
-// ---------------------------------------------------------------------------
-describe('sap_class_includes', () => {
-    it('returns JSON array when no includeType is given', async () => {
-        const adt = {
-            classIncludes: vi.fn().mockResolvedValue([{ name: 'definitions' }, { name: 'implementations' }]),
-        };
-        const tool = getTool('sap_class_includes');
-        const result = await tool.handler({ className: 'ZCL_FOO' }, makeCtx(adt));
-        expect(adt.classIncludes).toHaveBeenCalledWith('ZCL_FOO', undefined);
-        expect(JSON.parse(result.content)).toEqual([{ name: 'definitions' }, { name: 'implementations' }]);
-    });
-    it('propagates error when classIncludes throws', async () => {
-        const adt = {
-            classIncludes: vi.fn().mockRejectedValue(new Error('ADT 404')),
-        };
-        const tool = getTool('sap_class_includes');
-        await expect(tool.handler({ className: 'ZCL_MISSING' }, makeCtx(adt))).rejects.toThrow('ADT 404');
-    });
-});
-// ---------------------------------------------------------------------------
-// 12. sap_inactive_objects
-// ---------------------------------------------------------------------------
-describe('sap_inactive_objects', () => {
-    it('returns JSON list of inactive objects', async () => {
-        const adt = {
-            inactiveObjects: vi.fn().mockResolvedValue([{ name: 'ZCL_FOO', type: 'CLAS' }]),
-        };
-        const tool = getTool('sap_inactive_objects');
-        const result = await tool.handler({}, makeCtx(adt));
-        expect(adt.inactiveObjects).toHaveBeenCalledWith();
-        expect(JSON.parse(result.content)).toEqual([{ name: 'ZCL_FOO', type: 'CLAS' }]);
-    });
-    it('propagates error when inactiveObjects throws', async () => {
-        const adt = {
-            inactiveObjects: vi.fn().mockRejectedValue(new Error('ADT 503')),
-        };
-        const tool = getTool('sap_inactive_objects');
-        await expect(tool.handler({}, makeCtx(adt))).rejects.toThrow('ADT 503');
-    });
-});
-// ---------------------------------------------------------------------------
-// 13. sap_syntax_check
-// ---------------------------------------------------------------------------
-describe('sap_syntax_check', () => {
-    it('calls syntaxCheck with type first and returns JSON result', async () => {
-        const fakeSyntaxResult = { hasErrors: false, messages: [] };
-        const adt = {
-            syntaxCheck: vi.fn().mockResolvedValue(fakeSyntaxResult),
-        };
-        const tool = getTool('sap_syntax_check');
-        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO' }, makeCtx(adt));
-        expect(adt.syntaxCheck).toHaveBeenCalledWith('CLAS', 'ZCL_FOO');
-        expect(JSON.parse(result.content)).toEqual(fakeSyntaxResult);
-    });
-    it('propagates error when syntaxCheck throws', async () => {
-        const adt = {
-            syntaxCheck: vi.fn().mockRejectedValue(new Error('connection refused')),
-        };
-        const tool = getTool('sap_syntax_check');
-        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_FOO' }, makeCtx(adt))).rejects.toThrow('connection refused');
-    });
-});
-// ---------------------------------------------------------------------------
-// 14. sap_diff
-// ---------------------------------------------------------------------------
-describe('sap_diff', () => {
-    it('calls diff with type first and returns JSON result', async () => {
-        const fakeDiff = { unified: '--- a\n+++ b\n@@ -1 +1 @@\n-old\n+new' };
-        const adt = {
-            diff: vi.fn().mockResolvedValue(fakeDiff),
-        };
-        const tool = getTool('sap_diff');
-        const result = await tool.handler({ type: 'PROG', name: 'ZTEST', version1: 'old', version2: 'new' }, makeCtx(adt));
-        expect(adt.diff).toHaveBeenCalledWith('PROG', 'ZTEST', 'old', 'new');
-        expect(JSON.parse(result.content)).toEqual(fakeDiff);
-    });
-    it('propagates error when diff throws', async () => {
-        const adt = {
-            diff: vi.fn().mockRejectedValue(new Error('ADT 401')),
-        };
-        const tool = getTool('sap_diff');
-        await expect(tool.handler({ type: 'PROG', name: 'ZTEST' }, makeCtx(adt))).rejects.toThrow('ADT 401');
-    });
-});
-// ---------------------------------------------------------------------------
-// 15. sap_preview_change
-// ---------------------------------------------------------------------------
-describe('sap_preview_change', () => {
-    it('calls previewChange with type first and returns JSON result', async () => {
-        const fakeDiff = { unified: '@@ -1 +1 @@\n-old\n+new' };
-        const adt = {
-            previewChange: vi.fn().mockResolvedValue(fakeDiff),
-        };
-        const tool = getTool('sap_preview_change');
-        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO', newSource: 'CLASS ZCL_FOO...' }, makeCtx(adt));
-        expect(adt.previewChange).toHaveBeenCalledWith('CLAS', 'ZCL_FOO', 'CLASS ZCL_FOO...');
-        expect(JSON.parse(result.content)).toEqual(fakeDiff);
-    });
-    it('propagates error when previewChange throws', async () => {
-        const adt = {
-            previewChange: vi.fn().mockRejectedValue(new Error('object locked')),
-        };
-        const tool = getTool('sap_preview_change');
-        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_FOO', newSource: 'x' }, makeCtx(adt))).rejects.toThrow('object locked');
-    });
-});
-// ---------------------------------------------------------------------------
-// 16. sap_run_unit_test
-// ---------------------------------------------------------------------------
-describe('sap_run_unit_test', () => {
-    it('calls runUnitTest with type first and returns JSON result', async () => {
-        const fakeResult = { passed: 3, failed: 0, errors: 0, testClasses: [] };
-        const adt = {
-            runUnitTest: vi.fn().mockResolvedValue(fakeResult),
-        };
-        const tool = getTool('sap_run_unit_test');
-        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_ORDER' }, makeCtx(adt));
-        expect(adt.runUnitTest).toHaveBeenCalledWith('CLAS', 'ZCL_ORDER');
-        expect(JSON.parse(result.content)).toEqual(fakeResult);
-    });
-    it('propagates error when runUnitTest throws', async () => {
-        const adt = {
-            runUnitTest: vi.fn().mockRejectedValue(new Error('ADT 500')),
-        };
-        const tool = getTool('sap_run_unit_test');
-        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_ORDER' }, makeCtx(adt))).rejects.toThrow('ADT 500');
-    });
-});
-// ---------------------------------------------------------------------------
-// 17. sap_odata_test
-// ---------------------------------------------------------------------------
-describe('sap_odata_test', () => {
-    it('calls odataTest with correct args and returns JSON result', async () => {
-        const fakeResult = { status: 200, body: '<service/>' };
-        const adt = {
-            odataTest: vi.fn().mockResolvedValue(fakeResult),
-        };
-        const tool = getTool('sap_odata_test');
-        const result = await tool.handler({ servicePath: '/sap/opu/odata/sap/ZSALES_SRV', entity: 'SalesOrder', method: 'GET' }, makeCtx(adt));
-        expect(adt.odataTest).toHaveBeenCalledWith('/sap/opu/odata/sap/ZSALES_SRV', 'SalesOrder', 'GET');
-        expect(JSON.parse(result.content)).toEqual(fakeResult);
-    });
-    it('propagates error when odataTest throws', async () => {
-        const adt = {
-            odataTest: vi.fn().mockRejectedValue(new Error('service not found')),
-        };
-        const tool = getTool('sap_odata_test');
-        await expect(tool.handler({ servicePath: '/sap/opu/odata/sap/ZMISSING_SRV' }, makeCtx(adt))).rejects.toThrow('service not found');
-    });
-});
-// ---------------------------------------------------------------------------
-// 18. sap_badi_list
-// ---------------------------------------------------------------------------
-describe('sap_badi_list', () => {
-    it('calls badiList with correct args and returns JSON result', async () => {
-        const fakeResult = { badiDefinitions: [{ name: 'MD_PURCH_REQ_SAVE' }], enhancementSpots: [] };
-        const adt = {
-            badiList: vi.fn().mockResolvedValue(fakeResult),
-        };
-        const tool = getTool('sap_badi_list');
-        const result = await tool.handler({ query: 'MD_PURCH*', enhancementSpot: 'ES_MD_PURCH', maxResults: 25 }, makeCtx(adt));
-        expect(adt.badiList).toHaveBeenCalledWith('MD_PURCH*', 'ES_MD_PURCH', 25);
-        expect(JSON.parse(result.content)).toEqual(fakeResult);
-    });
-    it('propagates error when badiList throws', async () => {
-        const adt = {
-            badiList: vi.fn().mockRejectedValue(new Error('ADT 403')),
-        };
-        const tool = getTool('sap_badi_list');
-        await expect(tool.handler({ query: 'ZBADI*' }, makeCtx(adt))).rejects.toThrow('ADT 403');
-    });
-});