Files
actual/packages/api/methods.test.ts
T
e67bb684e2 [AI] Add API methods to budget a category from its templates (#9260)
* [AI] Add API methods to budget a category from its templates

applyCategoryTemplate runs the same budget/apply-single-template handler as
the "Overwrite with template" item in a category's budget menu.

getCategoryTemplateAmount runs budget/dry-run-category-template, which the
budget automations editor uses for its preview. It reads the category's saved
templates rather than the ones open in the editor.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

* [AI] Throw from the template dry run when the templates fail validation

dryRunCategoryTemplate ignored the errors computeTemplates collects, so a
category whose templates fail validation, for example with two #goal lines,
was previewed as 0. It now throws with those errors. The automations editor
already catches a failed dry run. getCategoryTemplateAmount rethrows the
error as an APIError.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

* [AI] Return the template dry run's validation errors instead of throwing

Throwing from dryRunCategoryTemplate surfaced as an internal error in the
budget automations editor, for example when "Cover schedule" is picked
before a schedule is chosen. The dry run now returns the errors
computeTemplates collects alongside the amounts, and
getCategoryTemplateAmount throws an APIError when there are any.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

* [AI] Reject category templates that fail to parse in the template API methods

A #template line that fails to parse is stored as an error template, which
the template runner skips, so applying could budget 0 and report success.
applyCategoryTemplate and getCategoryTemplateAmount now throw with the
failing lines instead. The UI's apply paths are left unchanged.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

* [AI] Format the template API test

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

* [AI] Read category templates for the template API without storing them

The template preview parsed the category's note by storing its templates in goal_def first, so a read wrote to the budget. It now parses the note in memory, and applying stores the templates once, inside apply-single-template.

* [AI] Type the template API test's goal_def query

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 02:02:50 +00:00

1675 lines
46 KiB
TypeScript

import * as fs from 'fs/promises';
import * as path from 'path';
import type { RuleEntity } from '@actual-app/core/types/models';
import { vi } from 'vitest';
import * as api from './index';
declare global {
var IS_TESTING: boolean;
var currentMonth: string | null;
}
// In tests we run from source; loot-core's API fs uses __dirname (for the built dist/).
// Mock the fs so path constants point at loot-core package root where migrations live.
vi.mock(
'../loot-core/src/platform/server/fs/index.api',
async importOriginal => {
const actual = (await importOriginal()) as Record<string, unknown>;
const pathMod = await import('path');
const lootCoreRoot = pathMod.join(__dirname, '..', 'loot-core');
return {
...actual,
migrationsPath: pathMod.join(lootCoreRoot, 'migrations'),
bundledDatabasePath: pathMod.join(lootCoreRoot, 'default-db.sqlite'),
demoBudgetPath: pathMod.join(lootCoreRoot, 'demo-budget'),
};
},
);
const budgetName = 'test-budget';
global.IS_TESTING = true;
beforeEach(async () => {
const budgetPath = path.join(__dirname, '/mocks/budgets/', budgetName);
await fs.rm(budgetPath, { force: true, recursive: true });
await createTestBudget('default-budget-template', budgetName);
await api.init({
dataDir: path.join(__dirname, '/mocks/budgets/'),
});
});
afterEach(async () => {
global.currentMonth = null;
await api.shutdown();
});
async function createTestBudget(templateName: string, name: string) {
const templatePath = path.join(
__dirname,
'/../loot-core/src/mocks/files',
templateName,
);
const budgetPath = path.join(__dirname, '/mocks/budgets/', name);
await fs.mkdir(budgetPath);
await fs.copyFile(
path.join(templatePath, 'metadata.json'),
path.join(budgetPath, 'metadata.json'),
);
await fs.copyFile(
path.join(templatePath, 'db.sqlite'),
path.join(budgetPath, 'db.sqlite'),
);
}
describe('API setup and teardown', () => {
// apis: loadBudget, getBudgetMonths
test('successfully loads budget', async () => {
await expect(api.loadBudget(budgetName)).resolves.toBeUndefined();
await expect(api.getBudgetMonths()).resolves.toMatchSnapshot();
});
});
describe('API budget import/export', () => {
const importedBudgetIds = new Set<string>();
beforeEach(async () => {
await api.loadBudget(budgetName);
});
afterEach(async () => {
// Close any budget loaded by an import before removing its files
await api.shutdown();
for (const id of importedBudgetIds) {
await fs.rm(path.join(__dirname, '/mocks/budgets/', id), {
force: true,
recursive: true,
});
}
importedBudgetIds.clear();
});
// apis: exportBudget, importBudget
test('exportBudget returns bytes that importBudget loads back', async () => {
const accountId = await api.createAccount({ name: 'round-trip' }, 0);
await api.addTransactions(accountId, [
{ date: '2023-10-01', amount: 1234, notes: 'round-trip transaction' },
]);
const data = await api.exportBudget();
expect(data).toBeInstanceOf(Uint8Array);
expect(data.length).toBeGreaterThan(0);
const { id } = await api.importBudget(data);
expect(id).toBeTruthy();
importedBudgetIds.add(id);
// The imported budget is now the loaded one; verify the data
// survived the round-trip
const accounts = await api.getAccounts();
expect(accounts).toEqual(
expect.arrayContaining([
expect.objectContaining({ id: accountId, name: 'round-trip' }),
]),
);
const transactions = await api.getTransactions(
accountId,
'2023-10-01',
'2023-10-31',
);
expect(transactions).toEqual(
expect.arrayContaining([
expect.objectContaining({
amount: 1234,
notes: 'round-trip transaction',
}),
]),
);
});
// apis: exportBudget, importBudget
test('importBudget imports from a file path', async () => {
const data = await api.exportBudget();
const filepath = path.join(__dirname, '/mocks/budgets/', 'export.zip');
await fs.writeFile(filepath, data);
try {
const { id } = await api.importBudget(filepath);
expect(id).toBeTruthy();
importedBudgetIds.add(id);
} finally {
await fs.rm(filepath, { force: true });
}
});
// apis: importBudget
test('importBudget rejects with an Error on failure', async () => {
await expect(api.importBudget('/does/not/exist.zip')).rejects.toThrow(
/^Error importing budget:/,
);
await expect(api.importBudget(new Uint8Array([1, 2, 3]))).rejects.toThrow(
/^Error importing budget:/,
);
});
});
describe('API CRUD operations', () => {
beforeEach(async () => {
// load test budget
await api.loadBudget(budgetName);
});
// api: getBudgets
test('getBudgets', async () => {
const budgets = await api.getBudgets();
expect(budgets).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: 'test-budget',
name: 'Default Test Db',
}),
]),
);
});
// apis: getCategoryGroups, createCategoryGroup, updateCategoryGroup, deleteCategoryGroup
test('CategoryGroups: successfully update category groups', async () => {
const month = '2023-10';
global.currentMonth = month;
// get existing category groups
const groups = await api.getCategoryGroups();
expect(groups).toEqual(
expect.arrayContaining([
expect.objectContaining({
hidden: false,
id: 'fc3825fd-b982-4b72-b768-5b30844cf832',
is_income: false,
name: 'Usual Expenses',
}),
expect.objectContaining({
hidden: false,
id: 'a137772f-cf2f-4089-9432-822d2ddc1466',
is_income: false,
name: 'Investments and Savings',
}),
expect.objectContaining({
hidden: false,
id: '2E1F5BDB-209B-43F9-AF2C-3CE28E380C00',
is_income: true,
name: 'Income',
}),
]),
);
// create our test category group
const mainGroupId = await api.createCategoryGroup({
name: 'test-group',
});
let budgetMonth = await api.getBudgetMonth(month);
expect(budgetMonth.categoryGroups).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: mainGroupId,
}),
]),
);
// update group
await api.updateCategoryGroup(mainGroupId, {
name: 'update-tests',
});
budgetMonth = await api.getBudgetMonth(month);
expect(budgetMonth.categoryGroups).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: mainGroupId,
}),
]),
);
// delete group
await api.deleteCategoryGroup(mainGroupId);
budgetMonth = await api.getBudgetMonth(month);
expect(budgetMonth.categoryGroups).toEqual(
expect.arrayContaining([
expect.not.objectContaining({
id: mainGroupId,
}),
]),
);
});
// apis: createCategory, getCategories, updateCategory, deleteCategory
test('Categories: successfully update categories', async () => {
const month = '2023-10';
global.currentMonth = month;
// create our test category group
const mainGroupId = await api.createCategoryGroup({
name: 'test-group',
});
const secondaryGroupId = await api.createCategoryGroup({
name: 'test-secondary-group',
});
const categoryId = await api.createCategory({
name: 'test-budget',
group_id: mainGroupId,
});
const categoryIdHidden = await api.createCategory({
name: 'test-budget-hidden',
group_id: mainGroupId,
hidden: true,
});
let categories = await api.getCategories();
expect(categories).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: categoryId,
name: 'test-budget',
hidden: false,
group_id: mainGroupId,
}),
expect.objectContaining({
id: categoryIdHidden,
name: 'test-budget-hidden',
hidden: true,
group_id: mainGroupId,
}),
]),
);
// update/move category
await api.updateCategory(categoryId, {
name: 'updated-budget',
group_id: secondaryGroupId,
});
await api.updateCategory(categoryIdHidden, {
name: 'updated-budget-hidden',
group_id: secondaryGroupId,
hidden: false,
});
categories = await api.getCategories();
expect(categories).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: categoryId,
name: 'updated-budget',
hidden: false,
group_id: secondaryGroupId,
}),
expect.objectContaining({
id: categoryIdHidden,
name: 'updated-budget-hidden',
hidden: false,
group_id: secondaryGroupId,
}),
]),
);
// delete categories
await api.deleteCategory(categoryId);
expect(categories).toEqual(
expect.arrayContaining([
expect.not.objectContaining({
id: categoryId,
}),
]),
);
});
test.each([
{ invalidGroupId: null, label: 'null' },
{ invalidGroupId: '', label: 'empty string' },
])(
'Categories: reject invalid group_id ($label)',
async ({ invalidGroupId }) => {
const groupId = await api.createCategoryGroup({
name: 'test-valid-group',
});
const categoryId = await api.createCategory({
name: 'test-category',
group_id: groupId,
});
await expect(
api.updateCategory(categoryId, {
// @ts-expect-error - Testing invalid runtime input
group_id: invalidGroupId,
}),
).rejects.toThrow();
const categories = await api.getCategories();
expect(categories).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: categoryId,
group_id: groupId,
}),
]),
);
},
);
test.each(['nope', '00000000-0000-4000-8000-000000000123'])(
'Categories: reject non-existent group_id (%s)',
async invalidGroupId => {
const groupId = await api.createCategoryGroup({
name: 'valid-group-for-invalid-id-test',
});
const categoryId = await api.createCategory({
name: 'category-with-valid-group',
group_id: groupId,
});
await expect(
api.updateCategory(categoryId, {
group_id: invalidGroupId,
}),
).rejects.toThrow('category group does not exist');
const categories = await api.getCategories();
expect(categories).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: categoryId,
group_id: groupId,
}),
]),
);
},
);
test('Categories: reject deleted category group', async () => {
const validGroupId = await api.createCategoryGroup({
name: 'valid-group-for-deleted-group-test',
});
const deletedGroupId = await api.createCategoryGroup({
name: 'group-to-be-deleted',
});
const categoryId = await api.createCategory({
name: 'category-to-preserve',
group_id: validGroupId,
});
await api.deleteCategoryGroup(deletedGroupId);
await expect(
api.updateCategory(categoryId, {
group_id: deletedGroupId,
}),
).rejects.toThrow('category group does not exist');
const categories = await api.getCategories();
expect(categories).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: categoryId,
group_id: validGroupId,
}),
]),
);
});
test('Categories: partial update preserves existing group', async () => {
const groupId = await api.createCategoryGroup({
name: 'partial-update-group',
});
const categoryId = await api.createCategory({
name: 'original-category',
group_id: groupId,
});
// Update the name without providing group_id
await api.updateCategory(categoryId, {
name: 'renamed-category',
});
// Update another field without providing group_id
await api.updateCategory(categoryId, {
hidden: true,
});
const categories = await api.getCategories();
expect(categories).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: categoryId,
name: 'renamed-category',
group_id: groupId,
hidden: true,
}),
]),
);
});
// apis: setBudgetAmount, setBudgetCarryover, getBudgetMonth
test('Budgets: successfully update budgets', async () => {
const month = '2023-10';
global.currentMonth = month;
// create some new categories to test with
const groupId = await api.createCategoryGroup({
name: 'tests',
});
const categoryId = await api.createCategory({
name: 'test-budget',
group_id: groupId,
});
await api.setBudgetAmount(month, categoryId, 100);
await api.setBudgetCarryover(month, categoryId, true);
const budgetMonth = await api.getBudgetMonth(month);
expect(budgetMonth.categoryGroups).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: groupId,
categories: expect.arrayContaining([
expect.objectContaining({
id: categoryId,
budgeted: 100,
carryover: true,
}),
]),
}),
]),
);
});
// apis: applyCategoryTemplate, getCategoryTemplateAmount
test('Budgets: successfully apply a category template', async () => {
const month = '2023-10';
global.currentMonth = month;
const groupId = await api.createCategoryGroup({
name: 'tests',
});
const categoryId = await api.createCategory({
name: 'test-template',
group_id: groupId,
});
const noTemplateId = await api.createCategory({
name: 'test-no-template',
group_id: groupId,
});
await api.updateNote(categoryId, '#template 50');
expect(await api.getCategoryTemplateAmount(month, categoryId)).toBe(5000);
// The preview parses the note without storing its templates.
const { data: previewed } = (await api.aqlQuery(
api.q('categories').filter({ id: categoryId }).select(['goal_def']),
)) as { data: Array<{ goal_def: string | null }> };
expect(previewed).toEqual([expect.objectContaining({ goal_def: null })]);
await api.setBudgetAmount(month, categoryId, 100);
await api.applyCategoryTemplate(month, categoryId);
const budgetMonth = await api.getBudgetMonth(month);
expect(budgetMonth.categoryGroups).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: groupId,
categories: expect.arrayContaining([
expect.objectContaining({ id: categoryId, budgeted: 5000 }),
]),
}),
]),
);
await expect(
api.applyCategoryTemplate(month, noTemplateId),
).rejects.toThrow('has no template');
await expect(
api.getCategoryTemplateAmount(month, noTemplateId),
).rejects.toThrow('has no template');
await api.updateNote(categoryId, '#goal 100\n#goal 200');
await expect(
api.getCategoryTemplateAmount(month, categoryId),
).rejects.toThrow('Only one #goal is allowed per category');
await api.updateNote(categoryId, '#template 70\n#template nonsense');
await expect(api.applyCategoryTemplate(month, categoryId)).rejects.toThrow(
'#template nonsense',
);
await expect(
api.getCategoryTemplateAmount(month, categoryId),
).rejects.toThrow('#template nonsense');
const unchangedMonth = await api.getBudgetMonth(month);
expect(unchangedMonth.categoryGroups).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: groupId,
categories: expect.arrayContaining([
expect.objectContaining({ id: categoryId, budgeted: 5000 }),
]),
}),
]),
);
});
//apis: createAccount, getAccounts, updateAccount, closeAccount, deleteAccount, reopenAccount, getAccountBalance
test('Accounts: successfully complete account operators', async () => {
const accountId1 = await api.createAccount(
{ name: 'test-account1', offbudget: true },
1000,
);
const accountId2 = await api.createAccount({ name: 'test-account2' }, 0);
let accounts = await api.getAccounts();
// accounts successfully created
expect(accounts).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: accountId1,
name: 'test-account1',
offbudget: true,
}),
expect.objectContaining({ id: accountId2, name: 'test-account2' }),
]),
);
expect(await api.getAccountBalance(accountId1)).toEqual(1000);
expect(await api.getAccountBalance(accountId2)).toEqual(0);
await api.updateAccount(accountId1, { offbudget: false });
await api.closeAccount(accountId1, accountId2);
await api.deleteAccount(accountId2);
// accounts successfully updated, and one of them deleted
accounts = await api.getAccounts();
expect(accounts).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: accountId1,
name: 'test-account1',
closed: true,
offbudget: false,
}),
expect.not.objectContaining({ id: accountId2 }),
]),
);
await api.reopenAccount(accountId1);
// the non-deleted account is reopened
accounts = await api.getAccounts();
expect(accounts).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: accountId1,
name: 'test-account1',
closed: false,
}),
]),
);
});
// apis: createPayee, getPayees, updatePayee, deletePayee
test('Payees: successfully update payees', async () => {
const payeeId1 = await api.createPayee({ name: 'test-payee1' });
const payeeId2 = await api.createPayee({ name: 'test-payee2' });
let payees = await api.getPayees();
// payees successfully created
expect(payees).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: payeeId1,
name: 'test-payee1',
}),
expect.objectContaining({
id: payeeId2,
name: 'test-payee2',
}),
]),
);
await api.updatePayee(payeeId1, { name: 'test-updated-payee' });
await api.deletePayee(payeeId2);
// confirm update and delete were successful
payees = await api.getPayees();
expect(payees).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: payeeId1,
name: 'test-updated-payee',
}),
expect.not.objectContaining({
name: 'test-payee1',
}),
expect.not.objectContaining({
id: payeeId2,
}),
]),
);
});
// apis: createTag, getTags, updateTag, deleteTag
test('Tags: successfully complete tag operations', async () => {
// Create tags
const tagId1 = await api.createTag({ tag: 'test-tag1', color: '#ff0000' });
const tagId2 = await api.createTag({
tag: 'test-tag2',
description: 'A test tag',
});
let tags = await api.getTags();
expect(tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: tagId1,
tag: 'test-tag1',
color: '#ff0000',
}),
expect.objectContaining({
id: tagId2,
tag: 'test-tag2',
description: 'A test tag',
}),
]),
);
// Update tag
await api.updateTag(tagId1, { tag: 'updated-tag', color: '#00ff00' });
tags = await api.getTags();
expect(tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: tagId1,
tag: 'updated-tag',
color: '#00ff00',
}),
]),
);
// Delete tag
await api.deleteTag(tagId2);
tags = await api.getTags();
expect(tags).not.toEqual(
expect.arrayContaining([expect.objectContaining({ id: tagId2 })]),
);
});
test('Tags: create tag with minimal fields', async () => {
const tagId = await api.createTag({ tag: 'minimal-tag' });
const tags = await api.getTags();
expect(tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: tagId,
tag: 'minimal-tag',
color: null,
description: null,
}),
]),
);
});
test('Tags: update single field only', async () => {
const tagId = await api.createTag({ tag: 'original', color: '#ff0000' });
// Update only color, tag and description should remain unchanged
await api.updateTag(tagId, { color: '#00ff00' });
const tags = await api.getTags();
expect(tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: tagId,
tag: 'original',
color: '#00ff00',
description: null,
}),
]),
);
});
test('Tags: handle null values correctly', async () => {
const tagId = await api.createTag({
tag: 'with-nulls',
color: null,
description: null,
});
const tags = await api.getTags();
expect(tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: tagId,
color: null,
description: null,
}),
]),
);
});
test('Tags: clear optional field', async () => {
const tagId = await api.createTag({
tag: 'clearable',
color: '#ff0000',
description: 'will be cleared',
});
// Clear color by setting to null
await api.updateTag(tagId, { color: null });
let tags = await api.getTags();
expect(tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: tagId,
tag: 'clearable',
color: null,
description: 'will be cleared',
}),
]),
);
// Clear description by setting to null
await api.updateTag(tagId, { description: null });
tags = await api.getTags();
expect(tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: tagId,
tag: 'clearable',
color: null,
description: null,
}),
]),
);
});
// apis: getNote, updateNote
test('Notes: successfully get and update note', async () => {
const categories = await api.getCategories();
const categoryId = categories[0].id;
// No note exists initially
const initial = await api.getNote(categoryId);
expect(initial).toBeNull();
// Set a note
await api.updateNote(categoryId, 'Test note content');
const afterSet = await api.getNote(categoryId);
expect(afterSet).toEqual({ id: categoryId, note: 'Test note content' });
// Update the note
await api.updateNote(categoryId, 'Updated note content');
const afterUpdate = await api.getNote(categoryId);
expect(afterUpdate).toEqual({
id: categoryId,
note: 'Updated note content',
});
});
// apis: getRules, getPayeeRules, createRule, updateRule, deleteRule
test('Rules: successfully update rules', async () => {
await api.createPayee({ name: 'test-payee' });
await api.createPayee({ name: 'test-payee2' });
// create our test rules
const rule = await api.createRule({
stage: 'pre',
conditionsOp: 'and',
conditions: [
{
field: 'payee',
op: 'is',
value: 'test-payee',
},
],
actions: [
{
op: 'set',
field: 'category',
value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
},
],
});
const rule2 = await api.createRule({
stage: 'pre',
conditionsOp: 'and',
conditions: [
{
field: 'payee',
op: 'is',
value: 'test-payee2',
},
],
actions: [
{
op: 'set',
field: 'category',
value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
},
],
});
// get existing rules
const rules = await api.getRules();
expect(rules).toEqual(
expect.arrayContaining([
expect.objectContaining({
actions: expect.arrayContaining([
expect.objectContaining({
field: 'category',
op: 'set',
type: 'id',
value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
}),
]),
conditions: expect.arrayContaining([
expect.objectContaining({
field: 'payee',
op: 'is',
type: 'id',
value: 'test-payee2',
}),
]),
conditionsOp: 'and',
id: rule2.id,
stage: 'pre',
}),
expect.objectContaining({
actions: expect.arrayContaining([
expect.objectContaining({
field: 'category',
op: 'set',
type: 'id',
value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
}),
]),
conditions: expect.arrayContaining([
expect.objectContaining({
field: 'payee',
op: 'is',
type: 'id',
value: 'test-payee',
}),
]),
conditionsOp: 'and',
id: rule.id,
stage: 'pre',
}),
]),
);
// get by payee
expect(await api.getPayeeRules('test-payee')).toEqual(
expect.arrayContaining([
expect.objectContaining({
actions: expect.arrayContaining([
expect.objectContaining({
field: 'category',
op: 'set',
type: 'id',
value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
}),
]),
conditions: expect.arrayContaining([
expect.objectContaining({
field: 'payee',
op: 'is',
type: 'id',
value: 'test-payee',
}),
]),
conditionsOp: 'and',
id: rule.id,
stage: 'pre',
}),
]),
);
expect(await api.getPayeeRules('test-payee2')).toEqual(
expect.arrayContaining([
expect.objectContaining({
actions: expect.arrayContaining([
expect.objectContaining({
field: 'category',
op: 'set',
type: 'id',
value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
}),
]),
conditions: expect.arrayContaining([
expect.objectContaining({
field: 'payee',
op: 'is',
type: 'id',
value: 'test-payee2',
}),
]),
conditionsOp: 'and',
id: rule2.id,
stage: 'pre',
}),
]),
);
// update one rule
const updatedRule = {
...rule,
stage: 'post',
conditionsOp: 'or',
} satisfies RuleEntity;
expect(await api.updateRule(updatedRule)).toEqual(updatedRule);
expect(await api.getRules()).toEqual(
expect.arrayContaining([
expect.objectContaining({
actions: expect.arrayContaining([
expect.objectContaining({
field: 'category',
op: 'set',
type: 'id',
value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
}),
]),
conditions: expect.arrayContaining([
expect.objectContaining({
field: 'payee',
op: 'is',
type: 'id',
value: 'test-payee',
}),
]),
conditionsOp: 'or',
id: rule.id,
stage: 'post',
}),
expect.objectContaining({
actions: expect.arrayContaining([
expect.objectContaining({
field: 'category',
op: 'set',
type: 'id',
value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
}),
]),
conditions: expect.arrayContaining([
expect.objectContaining({
field: 'payee',
op: 'is',
type: 'id',
value: 'test-payee2',
}),
]),
conditionsOp: 'and',
id: rule2.id,
stage: 'pre',
}),
]),
);
// delete rules
await api.deleteRule(rules[1].id);
expect(await api.getRules()).toHaveLength(1);
await api.deleteRule(rules[0].id);
expect(await api.getRules()).toHaveLength(0);
});
// apis: addTransactions, getTransactions, importTransactions, updateTransaction, deleteTransaction
test('Transactions: successfully update transactions', async () => {
const accountId = await api.createAccount({ name: 'test-account' }, 0);
let newTransaction = [
{
account: accountId,
date: '2023-11-03',
imported_id: '11',
amount: 100,
notes: 'notes',
},
{
account: accountId,
date: '2023-11-03',
imported_id: '12',
amount: 100,
notes: '',
},
];
const addResult = await api.addTransactions(accountId, newTransaction, {
learnCategories: true,
runTransfers: true,
});
expect(addResult).toBe('ok');
expect(await api.getAccountBalance(accountId)).toEqual(200);
expect(
await api.getAccountBalance(accountId, new Date(2023, 10, 2)),
).toEqual(0);
// confirm added transactions exist
let transactions = await api.getTransactions(
accountId,
'2023-11-01',
'2023-11-30',
);
expect(transactions).toEqual(
expect.arrayContaining(
newTransaction.map(trans => expect.objectContaining(trans)),
),
);
expect(transactions).toHaveLength(2);
newTransaction = [
{
account: accountId,
date: '2023-12-03',
imported_id: '11',
amount: 100,
notes: 'notes',
},
{
account: accountId,
date: '2023-12-03',
imported_id: '12',
amount: 100,
notes: 'notes',
},
{
account: accountId,
date: '2023-12-03',
imported_id: '22',
amount: 200,
notes: '',
},
];
const reconciled = await api.importTransactions(accountId, newTransaction);
// Expect it to reconcile and to have updated one of the previous transactions
expect(reconciled.added).toHaveLength(1);
expect(reconciled.updated).toHaveLength(1);
// confirm imported transactions exist
transactions = await api.getTransactions(
accountId,
'2023-12-01',
'2023-12-31',
);
expect(transactions).toEqual(
expect.arrayContaining([
expect.objectContaining({ imported_id: '22', amount: 200 }),
]),
);
expect(transactions).toHaveLength(1);
// confirm imported transactions update perfomed
transactions = await api.getTransactions(
accountId,
'2023-11-01',
'2023-11-30',
);
expect(transactions).toEqual(
expect.arrayContaining([
expect.objectContaining({ notes: 'notes', amount: 100 }),
]),
);
expect(transactions).toHaveLength(2);
const idToUpdate = reconciled.added[0];
const idToDelete = reconciled.updated[0];
await api.updateTransaction(idToUpdate, { amount: 500 });
await api.deleteTransaction(idToDelete);
// confirm updates and deletions work
transactions = await api.getTransactions(
accountId,
'2023-12-01',
'2023-12-31',
);
expect(transactions).toEqual(
expect.arrayContaining([
expect.objectContaining({ id: idToUpdate, amount: 500 }),
expect.not.objectContaining({ id: idToDelete }),
]),
);
expect(transactions).toHaveLength(1);
});
test('Transactions: updating a split child keeps its other fields', async () => {
const accountId = await api.createAccount({ name: 'test-account' }, 0);
const groupId = await api.createCategoryGroup({ name: 'tests' });
const categoryId = await api.createCategory({
name: 'test-split',
group_id: groupId,
});
await api.addTransactions(accountId, [
{
date: '2023-11-03',
amount: 300,
subtransactions: [
{ amount: 100, category: categoryId, notes: 'first' },
{ amount: 200, category: categoryId, notes: 'second' },
],
},
]);
let [parent] = await api.getTransactions(
accountId,
'2023-11-01',
'2023-11-30',
);
const child = parent.subtransactions?.find(t => t.notes === 'first');
if (!child) {
throw new Error('split child not found');
}
await api.updateTransaction(child.id, { notes: 'updated' });
[parent] = await api.getTransactions(accountId, '2023-11-01', '2023-11-30');
expect(parent.subtransactions).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: child.id,
notes: 'updated',
amount: 100,
category: categoryId,
}),
expect.objectContaining({
notes: 'second',
amount: 200,
category: categoryId,
}),
]),
);
expect(parent.amount).toBe(300);
});
// apis: mergeTransactions
test('Transactions: successfully merge two transactions', async () => {
const accountId = await api.createAccount({ name: 'test-account' }, 0);
await api.addTransactions(accountId, [
{ date: '2023-11-03', amount: 100, notes: 'notes' },
{ date: '2023-11-03', amount: 100, imported_id: '1' },
]);
const before = await api.getTransactions(
accountId,
'2023-11-01',
'2023-11-30',
);
expect(before).toHaveLength(2);
const keptId = await api.mergeTransactions([before[0].id, before[1].id]);
const after = await api.getTransactions(
accountId,
'2023-11-01',
'2023-11-30',
);
expect(after).toHaveLength(1);
expect(after[0]).toMatchObject({ id: keptId, notes: 'notes' });
});
test('Transactions: import notes are preserved when importing', async () => {
const accountId = await api.createAccount({ name: 'test-account' }, 0);
// Test with notes
const transactionsWithNotes = [
{
date: '2023-11-03',
imported_id: '11',
amount: 100,
notes: 'test note',
},
];
const addResultWithNotes = await api.addTransactions(
accountId,
transactionsWithNotes,
{
learnCategories: true,
runTransfers: true,
},
);
expect(addResultWithNotes).toBe('ok');
let transactions = await api.getTransactions(
accountId,
'2023-11-01',
'2023-11-30',
);
expect(transactions[0].notes).toBe('test note');
// Clear transactions
await api.deleteTransaction(transactions[0].id);
// Test without notes
const transactionsWithoutNotes = [
{ date: '2023-11-03', imported_id: '11', amount: 100 },
];
const addResultWithoutNotes = await api.addTransactions(
accountId,
transactionsWithoutNotes,
{
learnCategories: true,
runTransfers: true,
},
);
expect(addResultWithoutNotes).toBe('ok');
transactions = await api.getTransactions(
accountId,
'2023-11-01',
'2023-11-30',
);
expect(transactions[0].notes).toBeNull();
});
test('Transactions: reimportDeleted=false prevents reimporting deleted transactions', async () => {
const accountId = await api.createAccount({ name: 'test-account' }, 0);
// Import a transaction
const result1 = await api.importTransactions(accountId, [
{
date: '2023-11-03',
imported_id: 'reimport-test-1',
amount: 100,
account: accountId,
},
]);
expect(result1.added).toHaveLength(1);
// Delete the transaction
await api.deleteTransaction(result1.added[0]);
// Reimport the same transaction with reimportDeleted=false
const result2 = await api.importTransactions(
accountId,
[
{
date: '2023-11-03',
imported_id: 'reimport-test-1',
amount: 100,
account: accountId,
},
],
{ reimportDeleted: false },
);
// Should match the deleted transaction and not create a new one
expect(result2.added).toHaveLength(0);
expect(result2.updated).toHaveLength(0);
});
test('Transactions: reimportDeleted=true reimports deleted transactions', async () => {
const accountId = await api.createAccount({ name: 'test-account' }, 0);
// Import a transaction
const result1 = await api.importTransactions(accountId, [
{
date: '2023-11-03',
imported_id: 'reimport-test-2',
amount: 200,
account: accountId,
},
]);
expect(result1.added).toHaveLength(1);
// Delete the transaction
await api.deleteTransaction(result1.added[0]);
// Reimport the same transaction relying on reimportDeleted=true default
const result2 = await api.importTransactions(accountId, [
{
date: '2023-11-03',
imported_id: 'reimport-test-2',
amount: 200,
account: accountId,
},
]);
// Should create a new transaction since deleted ones are ignored
expect(result2.added).toHaveLength(1);
});
});
//apis: createSchedule, getSchedules, updateSchedule, deleteSchedule
test('Schedules: successfully complete schedules operations', async () => {
await api.loadBudget(budgetName);
//test a schedule with a recuring configuration
const ScheduleId1 = await api.createSchedule({
name: 'test-schedule 1',
posts_transaction: true,
// amount: -5000,
amountOp: 'is',
date: {
frequency: 'monthly',
interval: 1,
start: '2025-06-13',
patterns: [],
skipWeekend: false,
weekendSolveMode: 'after',
endMode: 'never',
},
});
//test the creation of non recurring schedule
const ScheduleId2 = await api.createSchedule({
name: 'test-schedule 2',
posts_transaction: false,
amount: 4000,
amountOp: 'is',
date: '2025-06-13',
});
let schedules = await api.getSchedules();
// Schedules successfully created
expect(schedules).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: 'test-schedule 1',
posts_transaction: true,
// amount: -5000,
amountOp: 'is',
date: {
frequency: 'monthly',
interval: 1,
start: '2025-06-13',
patterns: [],
skipWeekend: false,
weekendSolveMode: 'after',
endMode: 'never',
},
}),
expect.objectContaining({
name: 'test-schedule 2',
posts_transaction: false,
amount: 4000,
amountOp: 'is',
date: '2025-06-13',
}),
]),
);
//check getIDByName works on schedules
expect(await api.getIDByName('schedules', 'test-schedule 1')).toEqual(
ScheduleId1,
);
expect(await api.getIDByName('schedules', 'test-schedule 2')).toEqual(
ScheduleId2,
);
//check getIDByName works on accounts
const schedAccountId1 = await api.createAccount(
{ name: 'sched-test-account1', offbudget: true },
1000,
);
expect(await api.getIDByName('accounts', 'sched-test-account1')).toEqual(
schedAccountId1,
);
//check getIDByName works on payees
const schedPayeeId1 = await api.createPayee({ name: 'sched-test-payee1' });
expect(await api.getIDByName('payees', 'sched-test-payee1')).toEqual(
schedPayeeId1,
);
await api.updateSchedule(ScheduleId1, {
amount: -10000,
account: schedAccountId1,
});
await api.deleteSchedule(ScheduleId2);
// schedules successfully updated, and one of them deleted
await api.updateSchedule(ScheduleId1, {
amount: -10000,
account: schedAccountId1,
payee: schedPayeeId1,
});
await api.deleteSchedule(ScheduleId2);
schedules = await api.getSchedules();
expect(schedules).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: ScheduleId1,
posts_transaction: true,
amount: -10000,
account: schedAccountId1,
payee: schedPayeeId1,
amountOp: 'is',
date: {
frequency: 'monthly',
interval: 1,
start: '2025-06-13',
patterns: [],
skipWeekend: false,
weekendSolveMode: 'after',
endMode: 'never',
},
}),
expect.not.objectContaining({ id: ScheduleId2 }),
]),
);
});
describe('API schedules: getScheduleDates', () => {
beforeEach(async () => {
await api.loadBudget(budgetName);
});
// apis: createSchedule, getSchedules, getScheduleDates
test('expands the date of a stored schedule', async () => {
const id = await api.createSchedule({
name: 'rent',
amount: -120000,
amountOp: 'is',
posts_transaction: false,
date: {
frequency: 'monthly',
start: '2024-06-01',
skipWeekend: true,
weekendSolveMode: 'after',
endMode: 'never',
},
});
const [schedule] = (await api.getSchedules()).filter(s => s.id === id);
expect(
await api.getScheduleDates(schedule.date, {
start: '2024-06-01',
end: '2024-09-30',
}),
).toEqual(['2024-06-03', '2024-07-01', '2024-08-01', '2024-09-02']);
});
// apis: createSchedule, getSchedules, getScheduleDates
test('starts at the next date the app shows and never repeats a date', async () => {
// Tests run with today pinned to Sunday 2017-01-01. The occurrences on
// Saturday 31 December and Sunday 1 January both move to Monday 2
// January, which must be listed once and match the stored next_date.
const id = await api.createSchedule({
name: 'daily weekdays',
amount: -500,
amountOp: 'is',
posts_transaction: false,
date: {
frequency: 'daily',
start: '2016-12-31',
skipWeekend: true,
weekendSolveMode: 'after',
endMode: 'never',
},
});
const [schedule] = (await api.getSchedules()).filter(s => s.id === id);
const dates = await api.getScheduleDates(schedule.date, { count: 3 });
expect(dates[0]).toEqual(schedule.next_date);
expect(dates).toEqual(['2017-01-02', '2017-01-03', '2017-01-04']);
});
// apis: getScheduleDates
test('expands a single date', async () => {
expect(
await api.getScheduleDates('2024-06-13', {
start: '2024-06-01',
end: '2024-06-30',
}),
).toEqual(['2024-06-13']);
});
// apis: getScheduleDates
test('starts from today when no start is given', async () => {
// Tests run with today pinned to 2017-01-01.
expect(
await api.getScheduleDates(
{ frequency: 'yearly', start: '2016-03-01' },
{ count: 1 },
),
).toEqual(['2017-03-01']);
});
// apis: getScheduleDates
test('rejects invalid requests', async () => {
const daily = { frequency: 'daily', start: '2024-01-01' } as const;
await expect(
api.getScheduleDates(daily, { start: '2024-13-01', count: 1 }),
).rejects.toThrow('Invalid start date');
await expect(
api.getScheduleDates(daily, { start: '2024-02-01', end: '2024-01-01' }),
).rejects.toThrow('is before start');
await expect(
api.getScheduleDates(daily, { start: '2024-01-01', count: -1 }),
).rejects.toThrow('count must be a non-negative integer');
await expect(
api.getScheduleDates(daily, { start: '2024-01-01' }),
).rejects.toThrow('needs an `end` date or a `count`');
await expect(
api.getScheduleDates(
{ ...daily, endMode: 'after_n_occurrences', endOccurrences: 0 },
{ start: '2024-01-01' },
),
).rejects.toThrow('endOccurrences must be a positive integer');
await expect(
api.getScheduleDates(
{ ...daily, endMode: 'on_date', endDate: 'soon' },
{ start: '2024-01-01' },
),
).rejects.toThrow('Invalid recurrence end date');
await expect(
api.getScheduleDates('06/13/2024', { start: '2024-01-01' }),
).rejects.toThrow('Invalid schedule date');
});
});
// apis: getPreferences
test('Preferences: successfully read synced preferences', async () => {
await api.loadBudget(budgetName);
await api.internal?.send('preferences/save', {
id: 'numberFormat',
value: '1.234,56',
});
await api.internal?.send('preferences/save', {
id: 'hideFraction',
value: 'true',
});
const preferences = await api.getPreferences();
expect(preferences).toMatchObject({
numberFormat: '1.234,56',
hideFraction: 'true',
});
});
describe('API preferences: setPreference', () => {
beforeEach(async () => {
await api.loadBudget(budgetName);
});
// apis: setPreference
test('successfully sets a single preference', async () => {
await api.setPreference('numberFormat', '1,234.5');
const preferences = await api.getPreferences();
expect(preferences.numberFormat).toBe('1,234.5');
});
// apis: setPreference
test('can set multiple preferences', async () => {
await api.setPreference('numberFormat', '1,234.5');
await api.setPreference('hideFraction', 'true');
await api.setPreference('defaultCurrencyCode', 'USD');
const preferences = await api.getPreferences();
expect(preferences).toMatchObject({
numberFormat: '1,234.5',
hideFraction: 'true',
defaultCurrencyCode: 'USD',
});
});
// apis: setPreference
test('can set feature flag preferences', async () => {
await api.setPreference('flags.newSidebarUI', 'true');
const preferences = await api.getPreferences();
expect(preferences['flags.newSidebarUI']).toBe('true');
});
// apis: setPreference
test('can set account-specific preferences', async () => {
const accountId = 'test-account-123';
await api.setPreference(
`show-account-${accountId}-net-worth-chart`,
'false',
);
const preferences = await api.getPreferences();
expect(preferences[`show-account-${accountId}-net-worth-chart`]).toBe(
'false',
);
});
// apis: setPreference
test('can set CSV import preferences', async () => {
await api.setPreference(
`csv-mappings-${budgetName}`,
'col1:name,col2:amount',
);
const preferences = await api.getPreferences();
expect(preferences[`csv-mappings-${budgetName}`]).toBe(
'col1:name,col2:amount',
);
});
});