@dizzlkheinz/ynab-mcpb 0.18.3 → 0.19.0

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

@@ -1,128 +1,145 @@
-import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
-import * as ynab from 'ynab';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { handleListAccounts } from '../accountTools.js';
-import { handleListTransactions } from '../transactionTools.js';
-import { CacheManager } from '../../server/cacheManager.js';
-import { ServerKnowledgeStore } from '../../server/serverKnowledgeStore.js';
-import { DeltaCache } from '../../server/deltaCache.js';
-import { DeltaFetcher } from '../deltaFetcher.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import * as ynab from "ynab";
+import { CacheManager } from "../../server/cacheManager.js";
+import { DeltaCache } from "../../server/deltaCache.js";
+import { ServerKnowledgeStore } from "../../server/serverKnowledgeStore.js";
+import { handleListAccounts } from "../accountTools.js";
+import { DeltaFetcher } from "../deltaFetcher.js";
+import { handleListTransactions } from "../transactionTools.js";
 
-const shouldSkip = ['true', '1', 'yes', 'y', 'on'].includes(
-  (process.env['SKIP_E2E_TESTS'] || '').toLowerCase().trim(),
+const shouldSkip = ["true", "1", "yes", "y", "on"].includes(
+	(process.env.SKIP_E2E_TESTS || "").toLowerCase().trim(),
 );
-const hasToken = !!process.env['YNAB_ACCESS_TOKEN'];
+const hasToken = !!process.env.YNAB_ACCESS_TOKEN;
 const skipTests = shouldSkip || !hasToken;
 const describeIntegration = skipTests ? describe.skip : describe;
 
-describeIntegration('Delta-backed account tool handlers', () => {
-  let ynabAPI: ynab.API;
-  let testBudgetId: string;
-  let testAccountId: string;
-  let deltaFetcher: DeltaFetcher;
-  let previousNodeEnv: string | undefined;
+describeIntegration("Delta-backed account tool handlers", () => {
+	let ynabAPI: ynab.API;
+	let testBudgetId: string;
+	let testAccountId: 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;
+	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;
 
-    const accountsResponse = await ynabAPI.accounts.getAccounts(testBudgetId);
-    const account = accountsResponse.data.accounts.find((acct) => !acct.closed);
-    if (!account) {
-      throw new Error('No open accounts available for delta integration tests.');
-    }
-    testAccountId = account.id;
-  });
+		const accountsResponse = await ynabAPI.accounts.getAccounts(testBudgetId);
+		const account = accountsResponse.data.accounts.find((acct) => !acct.closed);
+		if (!account) {
+			throw new Error(
+				"No open accounts available for delta integration tests.",
+			);
+		}
+		testAccountId = account.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';
-  });
+	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;
-  });
+	afterEach(() => {
+		process.env.YNAB_MCP_ENABLE_DELTA = undefined;
+		if (previousNodeEnv === undefined) {
+			process.env.NODE_ENV = undefined;
+		} 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 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);
+	};
 
-  it(
-    'serves cached account results on the second invocation',
-    { meta: { tier: 'domain', domain: 'delta' } },
-    async () => {
-      const params = { budget_id: testBudgetId };
-      const firstCall = await handleListAccounts(ynabAPI, deltaFetcher, params);
-      const firstPayload = parseResponse(firstCall);
-      expect(firstPayload.cached).toBe(false);
+	it(
+		"serves cached account results on the second invocation",
+		{ meta: { tier: "domain", domain: "delta" } },
+		async () => {
+			const params = { budget_id: testBudgetId };
+			const firstCall = await handleListAccounts(ynabAPI, deltaFetcher, params);
+			const firstPayload = parseResponse(firstCall);
+			expect(firstPayload.cached).toBe(false);
 
-      const secondCall = await handleListAccounts(ynabAPI, deltaFetcher, params);
-      const secondPayload = parseResponse(secondCall);
-      expect(secondPayload.cached).toBe(true);
-      expect(secondPayload.cache_info).toMatch(/cache/i);
-    },
-  );
+			const secondCall = await handleListAccounts(
+				ynabAPI,
+				deltaFetcher,
+				params,
+			);
+			const secondPayload = parseResponse(secondCall);
+			expect(secondPayload.cached).toBe(true);
+			expect(secondPayload.cache_info).toMatch(/cache/i);
+		},
+	);
 
-  it(
-    'reports delta usage for list_transactions after a change',
-    { meta: { tier: 'domain', domain: 'delta' } },
-    async () => {
-      const params = { budget_id: testBudgetId, account_id: testAccountId };
-      const firstCall = await handleListTransactions(ynabAPI, deltaFetcher, params);
-      const firstPayload = parseResponse(firstCall);
-      expect(firstPayload.cached).toBe(false);
+	it(
+		"reports delta usage for list_transactions after a change",
+		{ meta: { tier: "domain", domain: "delta" } },
+		async () => {
+			const params = { budget_id: testBudgetId, account_id: testAccountId };
+			const firstCall = await handleListTransactions(
+				ynabAPI,
+				deltaFetcher,
+				params,
+			);
+			const firstPayload = parseResponse(firstCall);
+			expect(firstPayload.cached).toBe(false);
 
-      const transactionDate = new Date().toISOString().split('T')[0];
-      const memo = `delta-integration-${Date.now()}`;
-      const transactionPayload: ynab.SaveTransaction = {
-        account_id: testAccountId,
-        date: transactionDate,
-        amount: -1000,
-        memo,
-        payee_name: 'Delta Integration Test',
-        approved: false,
-        cleared: 'uncleared',
-      };
+			const transactionDate = new Date().toISOString().split("T")[0];
+			const memo = `delta-integration-${Date.now()}`;
+			const transactionPayload: ynab.SaveTransaction = {
+				account_id: testAccountId,
+				date: transactionDate,
+				amount: -1000,
+				memo,
+				payee_name: "Delta Integration Test",
+				approved: false,
+				cleared: "uncleared",
+			};
 
-      const createResponse = await ynabAPI.transactions.createTransaction(testBudgetId, {
-        transaction: transactionPayload,
-      });
-      expect(createResponse.data.transaction).toBeDefined();
-      const createdId = createResponse.data.transaction?.id;
-      expect(createdId).toBeTruthy();
+			const createResponse = await ynabAPI.transactions.createTransaction(
+				testBudgetId,
+				{
+					transaction: transactionPayload,
+				},
+			);
+			expect(createResponse.data.transaction).toBeDefined();
+			const createdId = createResponse.data.transaction?.id;
+			expect(createdId).toBeTruthy();
 
-      try {
-        const secondCall = await handleListTransactions(ynabAPI, deltaFetcher, params);
-        const secondPayload = parseResponse(secondCall);
-        expect(secondPayload.cached).toBe(true);
-        // Check for delta-related keywords (flexible assertion)
-        expect(secondPayload.cache_info).toMatch(/delta.*merge|merge.*delta/i);
-      } finally {
-        if (createdId) {
-          await ynabAPI.transactions.deleteTransaction(testBudgetId, createdId);
-        }
-      }
-    },
-  );
+			try {
+				const secondCall = await handleListTransactions(
+					ynabAPI,
+					deltaFetcher,
+					params,
+				);
+				const secondPayload = parseResponse(secondCall);
+				expect(secondPayload.cached).toBe(true);
+				// Check for delta-related keywords (flexible assertion)
+				expect(secondPayload.cache_info).toMatch(/delta.*merge|merge.*delta/i);
+			} finally {
+				if (createdId) {
+					await ynabAPI.transactions.deleteTransaction(testBudgetId, createdId);
+				}
+			}
+		},
+	);
 });

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

@@ -1,117 +1,135 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import * as ynab from 'ynab';
-import { handleListAccounts, handleGetAccount } from '../accountTools.js';
+import { beforeAll, describe, expect, it } from "vitest";
+import * as ynab from "ynab";
+import { handleGetAccount, handleListAccounts } from "../accountTools.js";
 
-const isSkip = ['true', '1', 'yes', 'y', 'on'].includes(
-  (process.env['SKIP_E2E_TESTS'] || '').toLowerCase().trim(),
+const isSkip = ["true", "1", "yes", "y", "on"].includes(
+	(process.env.SKIP_E2E_TESTS || "").toLowerCase().trim(),
 );
-const hasToken = !!process.env['YNAB_ACCESS_TOKEN'];
+const hasToken = !!process.env.YNAB_ACCESS_TOKEN;
 const shouldSkip = isSkip || !hasToken;
 const describeIntegration = shouldSkip ? describe.skip : describe;
 
-describeIntegration('Account Tools Integration', () => {
-  let ynabAPI: ynab.API;
-  let testBudgetId: string;
-
-  beforeAll(async () => {
-    const accessToken = process.env['YNAB_ACCESS_TOKEN']!;
-    ynabAPI = new ynab.API(accessToken);
-
-    // Get the first budget for testing
-    const budgetsResponse = await ynabAPI.budgets.getBudgets();
-    testBudgetId = budgetsResponse.data.budgets[0].id;
-  });
-
-  it(
-    'should successfully list accounts from real API',
-    { meta: { tier: 'core', domain: 'accounts' } },
-    async () => {
-      const result = await handleListAccounts(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.accounts).toBeDefined();
-      expect(Array.isArray(parsedContent.accounts)).toBe(true);
-
-      console.warn(`✅ Successfully listed ${parsedContent.accounts.length} accounts`);
-
-      // Verify account structure
-      if (parsedContent.accounts.length > 0) {
-        const account = parsedContent.accounts[0];
-        expect(account).toHaveProperty('id');
-        expect(account).toHaveProperty('name');
-        expect(account).toHaveProperty('type');
-        expect(account).toHaveProperty('balance');
-      }
-    },
-  );
-
-  it(
-    'should successfully get account details from real API',
-    { meta: { tier: 'domain', domain: 'accounts' } },
-    async () => {
-      // First get the list of accounts to get a valid account ID
-      const listResult = await handleListAccounts(ynabAPI, { budget_id: testBudgetId });
-      const parsedListContent = JSON.parse(listResult.content[0].text);
-
-      if (parsedListContent.accounts.length === 0) {
-        console.warn('⚠️ No accounts found in test budget, skipping account detail test');
-        return;
-      }
-
-      const testAccountId = parsedListContent.accounts[0].id;
-
-      const result = await handleGetAccount(ynabAPI, {
-        budget_id: testBudgetId,
-        account_id: testAccountId,
-      });
-
-      expect(result.content).toHaveLength(1);
-      expect(result.content[0].type).toBe('text');
-
-      const parsedContent = JSON.parse(result.content[0].text);
-      expect(parsedContent.account).toBeDefined();
-      expect(parsedContent.account.id).toBe(testAccountId);
-      expect(parsedContent.account).toHaveProperty('name');
-      expect(parsedContent.account).toHaveProperty('type');
-      expect(parsedContent.account).toHaveProperty('balance');
-
-      console.warn(`✅ Successfully retrieved account: ${parsedContent.account.name}`);
-    },
-  );
-
-  it(
-    'should handle invalid budget ID gracefully',
-    { meta: { tier: 'domain', domain: 'accounts' } },
-    async () => {
-      const result = await handleListAccounts(ynabAPI, { budget_id: 'invalid-budget-id' });
-
-      expect(result.content).toHaveLength(1);
-      const parsedContent = JSON.parse(result.content[0].text);
-      expect(parsedContent.error).toBeDefined();
-      expect(parsedContent.error.message).toContain('Failed to list accounts');
-
-      console.warn('✅ Correctly handled invalid budget ID:', parsedContent.error.message);
-    },
-  );
-
-  it(
-    'should handle invalid account ID gracefully',
-    { meta: { tier: 'domain', domain: 'accounts' } },
-    async () => {
-      const result = await handleGetAccount(ynabAPI, {
-        budget_id: testBudgetId,
-        account_id: 'invalid-account-id',
-      });
-
-      expect(result.content).toHaveLength(1);
-      const parsedContent = JSON.parse(result.content[0].text);
-      expect(parsedContent.error).toBeDefined();
-      expect(parsedContent.error.message).toContain('Failed to get account');
-
-      console.warn('✅ Correctly handled invalid account ID:', parsedContent.error.message);
-    },
-  );
+describeIntegration("Account Tools Integration", () => {
+	let ynabAPI: ynab.API;
+	let testBudgetId: string;
+
+	beforeAll(async () => {
+		const accessToken = process.env.YNAB_ACCESS_TOKEN!;
+		ynabAPI = new ynab.API(accessToken);
+
+		// Get the first budget for testing
+		const budgetsResponse = await ynabAPI.budgets.getBudgets();
+		testBudgetId = budgetsResponse.data.budgets[0].id;
+	});
+
+	it(
+		"should successfully list accounts from real API",
+		{ meta: { tier: "core", domain: "accounts" } },
+		async () => {
+			const result = await handleListAccounts(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.accounts).toBeDefined();
+			expect(Array.isArray(parsedContent.accounts)).toBe(true);
+
+			console.warn(
+				`✅ Successfully listed ${parsedContent.accounts.length} accounts`,
+			);
+
+			// Verify account structure
+			if (parsedContent.accounts.length > 0) {
+				const account = parsedContent.accounts[0];
+				expect(account).toHaveProperty("id");
+				expect(account).toHaveProperty("name");
+				expect(account).toHaveProperty("type");
+				expect(account).toHaveProperty("balance");
+			}
+		},
+	);
+
+	it(
+		"should successfully get account details from real API",
+		{ meta: { tier: "domain", domain: "accounts" } },
+		async () => {
+			// First get the list of accounts to get a valid account ID
+			const listResult = await handleListAccounts(ynabAPI, {
+				budget_id: testBudgetId,
+			});
+			const parsedListContent = JSON.parse(listResult.content[0].text);
+
+			if (parsedListContent.accounts.length === 0) {
+				console.warn(
+					"⚠️ No accounts found in test budget, skipping account detail test",
+				);
+				return;
+			}
+
+			const testAccountId = parsedListContent.accounts[0].id;
+
+			const result = await handleGetAccount(ynabAPI, {
+				budget_id: testBudgetId,
+				account_id: testAccountId,
+			});
+
+			expect(result.content).toHaveLength(1);
+			expect(result.content[0].type).toBe("text");
+
+			const parsedContent = JSON.parse(result.content[0].text);
+			expect(parsedContent.account).toBeDefined();
+			expect(parsedContent.account.id).toBe(testAccountId);
+			expect(parsedContent.account).toHaveProperty("name");
+			expect(parsedContent.account).toHaveProperty("type");
+			expect(parsedContent.account).toHaveProperty("balance");
+
+			console.warn(
+				`✅ Successfully retrieved account: ${parsedContent.account.name}`,
+			);
+		},
+	);
+
+	it(
+		"should handle invalid budget ID gracefully",
+		{ meta: { tier: "domain", domain: "accounts" } },
+		async () => {
+			const result = await handleListAccounts(ynabAPI, {
+				budget_id: "invalid-budget-id",
+			});
+
+			expect(result.content).toHaveLength(1);
+			const parsedContent = JSON.parse(result.content[0].text);
+			expect(parsedContent.error).toBeDefined();
+			expect(parsedContent.error.message).toContain("Failed to list accounts");
+
+			console.warn(
+				"✅ Correctly handled invalid budget ID:",
+				parsedContent.error.message,
+			);
+		},
+	);
+
+	it(
+		"should handle invalid account ID gracefully",
+		{ meta: { tier: "domain", domain: "accounts" } },
+		async () => {
+			const result = await handleGetAccount(ynabAPI, {
+				budget_id: testBudgetId,
+				account_id: "invalid-account-id",
+			});
+
+			expect(result.content).toHaveLength(1);
+			const parsedContent = JSON.parse(result.content[0].text);
+			expect(parsedContent.error).toBeDefined();
+			expect(parsedContent.error.message).toContain("Failed to get account");
+
+			console.warn(
+				"✅ Correctly handled invalid account ID:",
+				parsedContent.error.message,
+			);
+		},
+	);
 });