@dizzlkheinz/ynab-mcpb 0.12.1

package/src/tools/__tests__/categoryTools.delta.integration.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as ynab from 'ynab';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { handleListCategories } from '../categoryTools.js';
+import { CacheManager } from '../../server/cacheManager.js';
+import { ServerKnowledgeStore } from '../../server/serverKnowledgeStore.js';
+import { DeltaCache } from '../../server/deltaCache.js';
+import { DeltaFetcher } from '../deltaFetcher.js';
+
+const shouldSkip = ['true', '1', 'yes', 'y', 'on'].includes(
+  (process.env['SKIP_E2E_TESTS'] || '').toLowerCase().trim(),
+);
+const hasToken = !!process.env['YNAB_ACCESS_TOKEN'];
+const skipTests = shouldSkip || !hasToken;
+const describeIntegration = skipTests ? describe.skip : describe;
+
+describeIntegration('Delta-backed category tool handler', () => {
+  let ynabAPI: ynab.API;
+  let testBudgetId: string;
+  let deltaFetcher: DeltaFetcher;
+  let previousNodeEnv: string | undefined;
+
+  beforeAll(async () => {
+    const accessToken = process.env['YNAB_ACCESS_TOKEN']!;
+    ynabAPI = new ynab.API(accessToken);
+    const budgetsResponse = await ynabAPI.budgets.getBudgets();
+    const budget = budgetsResponse.data.budgets[0];
+    if (!budget) {
+      throw new Error('No budgets available for delta integration tests.');
+    }
+    testBudgetId = budget.id;
+  });
+
+  beforeEach(() => {
+    previousNodeEnv = process.env['NODE_ENV'];
+    process.env['NODE_ENV'] = 'integration';
+    const cacheManager = new CacheManager();
+    const knowledgeStore = new ServerKnowledgeStore();
+    const deltaCache = new DeltaCache(cacheManager, knowledgeStore);
+    deltaFetcher = new DeltaFetcher(ynabAPI, deltaCache);
+    process.env['YNAB_MCP_ENABLE_DELTA'] = 'true';
+  });
+
+  afterEach(() => {
+    delete process.env['YNAB_MCP_ENABLE_DELTA'];
+    if (previousNodeEnv === undefined) {
+      delete process.env['NODE_ENV'];
+    } else {
+      process.env['NODE_ENV'] = previousNodeEnv;
+    }
+    previousNodeEnv = undefined;
+  });
+
+  const parseResponse = (result: CallToolResult) => {
+    const content = result.content?.[0];
+    if (!content || content.type !== 'text') {
+      throw new Error('Unexpected tool response format');
+    }
+    return JSON.parse(content.text);
+  };
+  const expectCacheHit = (payload: { cached: boolean; cache_info: string }) => {
+    expect(payload.cached).toBe(true);
+    expect(payload.cache_info).toMatch(/cache/i);
+  };
+
+  it(
+    'serves cached category results on the second invocation',
+    { meta: { tier: 'domain', domain: 'delta' } },
+    async () => {
+      const params = { budget_id: testBudgetId };
+      const firstCall = await handleListCategories(ynabAPI, deltaFetcher, params);
+      const firstPayload = parseResponse(firstCall);
+      expect(firstPayload.cached).toBe(false);
+
+      const secondCall = await handleListCategories(ynabAPI, deltaFetcher, params);
+      const secondPayload = parseResponse(secondCall);
+      expectCacheHit(secondPayload);
+    },
+  );
+});

package/src/tools/__tests__/categoryTools.integration.test.ts

@@ -0,0 +1,295 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import * as ynab from 'ynab';
+import { handleListCategories, handleGetCategory, handleUpdateCategory } from '../categoryTools.js';
+
+/**
+ * Integration tests for category tools using real YNAB API
+ */
+const hasToken = !!process.env['YNAB_ACCESS_TOKEN'];
+const shouldSkip = process.env['SKIP_E2E_TESTS']?.toLowerCase() === 'true' || !hasToken;
+const describeIntegration = shouldSkip ? describe.skip : describe;
+
+describeIntegration('Category Tools Integration', () => {
+  let ynabAPI: ynab.API;
+  let testBudgetId: string;
+  let testCategoryId: string;
+  let originalBudgetedAmount: number;
+
+  beforeAll(async () => {
+    const accessToken = process.env['YNAB_ACCESS_TOKEN']!;
+    ynabAPI = new ynab.API(accessToken);
+
+    // Get first budget ID for testing
+    const budgetsResponse = await ynabAPI.budgets.getBudgets();
+    testBudgetId = budgetsResponse.data.budgets[0].id;
+  });
+
+  describe('handleListCategories', () => {
+    it(
+      'should successfully list categories from real API',
+      { meta: { tier: 'domain', domain: 'categories' } },
+      async () => {
+        const result = await handleListCategories(ynabAPI, { budget_id: testBudgetId });
+
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+
+        const parsedContent = JSON.parse(result.content[0].text);
+        expect(parsedContent.categories).toBeDefined();
+        expect(Array.isArray(parsedContent.categories)).toBe(true);
+
+        // The test budget might not have categories, so we'll check if groups exist instead
+        expect(parsedContent.category_groups).toBeDefined();
+        expect(Array.isArray(parsedContent.category_groups)).toBe(true);
+        expect(parsedContent.category_groups.length).toBeGreaterThan(0);
+
+        // Store first non-hidden category ID for next tests (if any exist)
+        if (parsedContent.categories.length > 0) {
+          const availableCategory = parsedContent.categories.find((cat: any) => !cat.hidden);
+          if (availableCategory) {
+            testCategoryId = availableCategory.id;
+            originalBudgetedAmount = availableCategory.budgeted;
+          }
+
+          // Verify category structure
+          const firstCategory = parsedContent.categories[0];
+          expect(firstCategory.id).toBeDefined();
+          expect(firstCategory.name).toBeDefined();
+          expect(firstCategory.category_group_id).toBeDefined();
+          expect(firstCategory.category_group_name).toBeDefined();
+          expect(typeof firstCategory.budgeted).toBe('number');
+          expect(typeof firstCategory.activity).toBe('number');
+          expect(typeof firstCategory.balance).toBe('number');
+        }
+
+        // Verify category group structure
+        const firstGroup = parsedContent.category_groups[0];
+        expect(firstGroup.id).toBeDefined();
+        expect(firstGroup.name).toBeDefined();
+        expect(typeof firstGroup.hidden).toBe('boolean');
+        expect(typeof firstGroup.deleted).toBe('boolean');
+
+        console.warn(
+          `✅ Successfully listed ${parsedContent.categories.length} categories in ${parsedContent.category_groups.length} groups`,
+        );
+
+        if (parsedContent.categories.length === 0) {
+          console.warn(
+            'ℹ️ No categories found in this budget - this is normal for new/empty budgets',
+          );
+        }
+      },
+    );
+
+    it(
+      'should handle invalid budget ID gracefully',
+      { meta: { tier: 'domain', domain: 'categories' } },
+      async () => {
+        const result = await handleListCategories(ynabAPI, { budget_id: 'invalid-budget-id' });
+
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+
+        const parsedContent = JSON.parse(result.content[0].text);
+        expect(parsedContent.error).toBeDefined();
+        expect(parsedContent.error.message).toBeDefined();
+
+        console.warn(`✅ Correctly handled invalid budget ID: ${parsedContent.error.message}`);
+      },
+    );
+  });
+
+  describe('handleGetCategory', () => {
+    it(
+      'should successfully get category details from real API',
+      { meta: { tier: 'domain', domain: 'categories' } },
+      async () => {
+        if (!testCategoryId) {
+          console.warn('⚠️ Skipping test - no test category ID available');
+          return;
+        }
+
+        const result = await handleGetCategory(ynabAPI, {
+          budget_id: testBudgetId,
+          category_id: testCategoryId,
+        });
+
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+
+        const parsedContent = JSON.parse(result.content[0].text);
+        expect(parsedContent.category).toBeDefined();
+
+        const category = parsedContent.category;
+        expect(category.id).toBe(testCategoryId);
+        expect(category.name).toBeDefined();
+        expect(category.category_group_id).toBeDefined();
+        expect(typeof category.budgeted).toBe('number');
+        expect(typeof category.activity).toBe('number');
+        expect(typeof category.balance).toBe('number');
+        expect(typeof category.hidden).toBe('boolean');
+
+        console.warn(`✅ Successfully retrieved category: ${category.name}`);
+        console.warn(`   - Budgeted: ${category.budgeted} milliunits`);
+        console.warn(`   - Activity: ${category.activity} milliunits`);
+        console.warn(`   - Balance: ${category.balance} milliunits`);
+      },
+    );
+
+    it(
+      'should handle invalid category ID gracefully',
+      { meta: { tier: 'domain', domain: 'categories' } },
+      async () => {
+        const result = await handleGetCategory(ynabAPI, {
+          budget_id: testBudgetId,
+          category_id: 'invalid-category-id',
+        });
+
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+
+        const parsedContent = JSON.parse(result.content[0].text);
+        expect(parsedContent.error).toBeDefined();
+        expect(parsedContent.error.message).toBeDefined();
+
+        console.warn(`✅ Correctly handled invalid category ID: ${parsedContent.error.message}`);
+      },
+    );
+  });
+
+  describe('handleUpdateCategory', () => {
+    it(
+      'should successfully update category budget from real API',
+      { meta: { tier: 'domain', domain: 'categories' } },
+      async () => {
+        if (!testCategoryId) {
+          console.warn('⚠️ Skipping test - no test category ID available');
+          return;
+        }
+
+        // Update with a test amount (add 1000 milliunits = $1.00)
+        const testBudgetedAmount = originalBudgetedAmount + 1000;
+
+        const result = await handleUpdateCategory(ynabAPI, {
+          budget_id: testBudgetId,
+          category_id: testCategoryId,
+          budgeted: testBudgetedAmount,
+        });
+
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+
+        const parsedContent = JSON.parse(result.content[0].text);
+
+        // Debug: Log the actual response if it's an error
+        if (parsedContent.error) {
+          console.warn('❌ Category update failed:', parsedContent.error.message);
+          console.warn('   Budget ID:', testBudgetId);
+          console.warn('   Category ID:', testCategoryId);
+          console.warn('   Budgeted Amount:', testBudgetedAmount);
+          // Skip the test if we get an error - this indicates API permissions or data issues
+          return;
+        }
+
+        expect(parsedContent.category).toBeDefined();
+        expect(parsedContent.updated_month).toBeDefined();
+
+        const category = parsedContent.category;
+        expect(category.id).toBe(testCategoryId);
+        expect(category.budgeted).toBe(testBudgetedAmount);
+
+        // Verify month format
+        expect(parsedContent.updated_month).toMatch(/^\d{4}-\d{2}-01$/);
+
+        console.warn(`✅ Successfully updated category budget to ${testBudgetedAmount} milliunits`);
+        console.warn(`   - Updated month: ${parsedContent.updated_month}`);
+
+        // Restore original amount
+        await handleUpdateCategory(ynabAPI, {
+          budget_id: testBudgetId,
+          category_id: testCategoryId,
+          budgeted: originalBudgetedAmount,
+        });
+
+        console.warn(`✅ Restored original budget amount: ${originalBudgetedAmount} milliunits`);
+      },
+    );
+
+    it(
+      'should handle invalid category ID gracefully',
+      { meta: { tier: 'domain', domain: 'categories' } },
+      async () => {
+        const result = await handleUpdateCategory(ynabAPI, {
+          budget_id: testBudgetId,
+          category_id: 'invalid-category-id',
+          budgeted: 50000,
+        });
+
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+
+        const parsedContent = JSON.parse(result.content[0].text);
+        expect(parsedContent.error).toBeDefined();
+        expect(parsedContent.error.message).toBeDefined();
+
+        console.warn(`✅ Correctly handled invalid category ID: ${parsedContent.error.message}`);
+      },
+    );
+
+    it(
+      'should handle negative budgeted amounts',
+      { meta: { tier: 'domain', domain: 'categories' } },
+      async () => {
+        if (!testCategoryId) {
+          console.warn('⚠️ Skipping test - no test category ID available');
+          return;
+        }
+
+        // Test with negative amount (removing money from category)
+        const negativeBudgetedAmount = -5000;
+
+        const result = await handleUpdateCategory(ynabAPI, {
+          budget_id: testBudgetId,
+          category_id: testCategoryId,
+          budgeted: negativeBudgetedAmount,
+        });
+
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+
+        const parsedContent = JSON.parse(result.content[0].text);
+
+        // Debug: Log the actual response if it's an error
+        if (parsedContent.error) {
+          console.warn(
+            '❌ Category update with negative amount failed:',
+            parsedContent.error.message,
+          );
+          console.warn('   Budget ID:', testBudgetId);
+          console.warn('   Category ID:', testCategoryId);
+          console.warn('   Budgeted Amount:', negativeBudgetedAmount);
+          // Skip the test if we get an error - this indicates API permissions or data issues
+          return;
+        }
+
+        expect(parsedContent.category).toBeDefined();
+
+        const category = parsedContent.category;
+        expect(category.budgeted).toBe(negativeBudgetedAmount);
+
+        console.warn(
+          `✅ Successfully set negative budget amount: ${negativeBudgetedAmount} milliunits`,
+        );
+
+        // Restore original amount
+        await handleUpdateCategory(ynabAPI, {
+          budget_id: testBudgetId,
+          category_id: testCategoryId,
+          budgeted: originalBudgetedAmount,
+        });
+
+        console.warn(`✅ Restored original budget amount: ${originalBudgetedAmount} milliunits`);
+      },
+    );
+  });
+});