Lars Nolden
dece0d5b79
Classification preferences gains "Classify newly imported transactions with AI", stored as classify_on_import in config.toml and on by default, so existing configurations keep their behaviour. It covers CSV imports and bank synchronization alike. With it off, no import path contacts the provider: classification falls to the new provider-free rules path, where an opted-in merchant rule still applies its category and tags, an alias match still attaches its merchant, and everything else arrives on the editable fallback without a provenance error that would suggest the provider had failed. Analyse remains available on demand.
400 lines
15 KiB
Go
400 lines
15 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"reflect"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
|
|
"finance-duck/internal/classification"
|
|
"finance-duck/internal/domain"
|
|
)
|
|
|
|
const n26Statement = "Booking Date,Value Date,Partner Name,Partner IBAN,Type,Payment Reference,Account Name,Amount (EUR)\n" +
|
|
"2026-09-01,2026-08-31,Cafe,DE02120300000000202051,Card,Lunch,Main,-12.30\n" +
|
|
"2026-09-02,2026-09-02,Employer,DE89370400440532013000,Transfer,Salary,Main,2400.00\n"
|
|
|
|
const laterStatement = "Booking Date,Value Date,Partner Name,Partner IBAN,Type,Payment Reference,Account Name,Amount (EUR)\n" +
|
|
"2026-10-01,2026-10-01,Bakery,DE02120300000000202051,Card,Breakfast,Main,-4.50\n"
|
|
|
|
// unmappedStatement uses columns no preset recognizes, so it needs a proposed
|
|
// mapping: German booking dates, split Soll/Haben money and a free-text note.
|
|
const unmappedStatement = "Datum;Empfänger;Soll;Haben;Notiz\n" +
|
|
"01.09.2026;Cafe Sonne;12,30;;Mittagessen Berlin\n" +
|
|
"02.09.2026;Arbeitgeber GmbH;;1.200,00;Gehalt September\n"
|
|
|
|
func mockCSVMapper(t *testing.T, a *App, proposal map[string]any) *[]string {
|
|
t.Helper()
|
|
prompts := &[]string{}
|
|
mock := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var request struct {
|
|
Messages []struct {
|
|
Role string `json:"role"`
|
|
Content string `json:"content"`
|
|
} `json:"messages"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
|
|
t.Error(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
for _, message := range request.Messages {
|
|
if message.Role == "user" {
|
|
*prompts = append(*prompts, message.Content)
|
|
}
|
|
}
|
|
content, err := json.Marshal(proposal)
|
|
if err != nil {
|
|
t.Error(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
json.NewEncoder(w).Encode(map[string]any{"choices": []any{map[string]any{
|
|
"finish_reason": "stop", "message": map[string]any{"content": string(content)},
|
|
}}})
|
|
}))
|
|
t.Cleanup(mock.Close)
|
|
a.classifier = classification.Client{APIKey: "test-private-key", Model: "test/model", BaseURL: mock.URL}
|
|
a.settings.Model = "test/model"
|
|
return prompts
|
|
}
|
|
|
|
func prepare(t *testing.T, a *App, s State, statement string) CSVImport {
|
|
t.Helper()
|
|
prepared, err := a.PrepareCSVImport(context.Background(), s.Revision, "n26", strings.NewReader(statement))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return prepared
|
|
}
|
|
|
|
func TestPreparedCSVImportWritesNothingUntilConfirmed(t *testing.T) {
|
|
a, s := testApp(t)
|
|
before := domain.Clone(s.Data)
|
|
prepared := prepare(t, a, s, n26Statement)
|
|
if prepared.Source != "n26_csv" || prepared.SourceLabel != "N26" || prepared.MappedBy != "preset" || prepared.Model != "" {
|
|
t.Fatalf("recognized export was not mapped locally: %+v", prepared)
|
|
}
|
|
if prepared.Records != 2 || prepared.New != 2 || prepared.Duplicates != 0 || len(prepared.Samples) != 2 {
|
|
t.Fatalf("unexpected preview counts: %+v", prepared)
|
|
}
|
|
// The preview must show what would be written, including direction and dates.
|
|
sample := prepared.Samples[0]
|
|
if sample.BookingDate != "2026-09-01" || sample.ValueDate != "2026-08-31" || sample.Amount.String() != "-12.30" ||
|
|
sample.RawDescription != "Lunch" || sample.Counterparty != "Cafe" || sample.Currency != "EUR" {
|
|
t.Fatalf("unexpected preview sample: %+v", sample)
|
|
}
|
|
if prepared.Samples[1].Amount.String() != "2400.00" {
|
|
t.Fatalf("preview hid the credit record: %+v", prepared.Samples[1])
|
|
}
|
|
mapped := map[string]string{}
|
|
for _, column := range prepared.Columns {
|
|
mapped[column.Field] = column.Column
|
|
}
|
|
if mapped["Booking date"] != "Booking Date" || mapped["Amount"] != "Amount (EUR)" || mapped["Description"] != "Payment Reference" ||
|
|
mapped["Currency"] != "EUR (from the amount column header)" || mapped["Dates read as"] == "" || mapped["Decimal separator"] == "" {
|
|
t.Fatalf("mapping was not reviewable: %+v", prepared.Columns)
|
|
}
|
|
current, err := a.Snapshot(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(before, current.Data) {
|
|
t.Fatal("preparing an import changed the journal")
|
|
}
|
|
|
|
// Cancelling must discard the statement without importing anything.
|
|
a.CancelCSVImport(prepared.ID)
|
|
if _, err := a.ConfirmCSVImport(context.Background(), prepared.ID, s.Revision); err == nil {
|
|
t.Fatal("confirmed a cancelled import")
|
|
}
|
|
current, err = a.Snapshot(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(before, current.Data) {
|
|
t.Fatal("cancelling an import changed the journal")
|
|
}
|
|
|
|
prepared = prepare(t, a, s, n26Statement)
|
|
result, err := a.ConfirmCSVImport(context.Background(), prepared.ID, prepared.Revision)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Imported != 2 || len(result.State.Data.Transactions) != 2 {
|
|
t.Fatalf("confirmation did not import the previewed records: %+v", result)
|
|
}
|
|
for _, tx := range result.State.Data.Transactions {
|
|
if tx.Facts.Source != "n26_csv" || tx.Facts.Currency != "EUR" || tx.Facts.AccountID != "n26" {
|
|
t.Fatalf("imported facts differ from the preview: %+v", tx.Facts)
|
|
}
|
|
}
|
|
// A confirmed statement is consumed: confirming again must not double count.
|
|
if _, err := a.ConfirmCSVImport(context.Background(), prepared.ID, prepared.Revision); err == nil {
|
|
t.Fatal("confirmed the same prepared import twice")
|
|
}
|
|
repeat := prepare(t, a, result.State, n26Statement)
|
|
if repeat.Records != 2 || repeat.New != 0 || repeat.Duplicates != 2 {
|
|
t.Fatalf("reimport preview did not report duplicates: %+v", repeat)
|
|
}
|
|
again, err := a.ConfirmCSVImport(context.Background(), repeat.ID, repeat.Revision)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if again.Imported != 0 || len(again.State.Data.Transactions) != 2 {
|
|
t.Fatalf("reimport duplicated transactions: %+v", again)
|
|
}
|
|
}
|
|
|
|
func TestUnrecognizedStatementNeedsAConfiguredModel(t *testing.T) {
|
|
a, s := testApp(t)
|
|
_, err := a.PrepareCSVImport(context.Background(), s.Revision, "n26", strings.NewReader(unmappedStatement))
|
|
if err == nil || !strings.Contains(err.Error(), "unrecognized CSV layout") {
|
|
t.Fatalf("unmapped statement without AI: %v", err)
|
|
}
|
|
current, err := a.Snapshot(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(s.Data, current.Data) {
|
|
t.Fatal("a failed mapping changed the journal")
|
|
}
|
|
// Recognized exports must keep working with no AI configured at all.
|
|
if prepared := prepare(t, a, s, n26Statement); prepared.MappedBy != "preset" {
|
|
t.Fatalf("preset import required AI: %+v", prepared)
|
|
}
|
|
}
|
|
|
|
func TestProposedMappingIsPreviewedFromRedactedSample(t *testing.T) {
|
|
a, s := testApp(t)
|
|
prompts := mockCSVMapper(t, a, map[string]any{
|
|
"booking_date_column": "Datum",
|
|
"value_date_column": "",
|
|
"amount_column": "",
|
|
"debit_column": "Soll",
|
|
"credit_column": "Haben",
|
|
"currency_column": "",
|
|
"description_column": "Notiz",
|
|
"counterparty_column": "Empfänger",
|
|
"counterparty_iban_column": "",
|
|
"date_format": "dd.mm.yyyy",
|
|
"decimal_format": "comma",
|
|
})
|
|
prepared := prepare(t, a, s, unmappedStatement)
|
|
if prepared.MappedBy != "openrouter" || prepared.Model != "test/model" || prepared.Source != "csv" {
|
|
t.Fatalf("proposed mapping was not attributed: %+v", prepared)
|
|
}
|
|
if prepared.Records != 2 || prepared.New != 2 || len(prepared.Samples) != 2 {
|
|
t.Fatalf("unexpected preview counts: %+v", prepared)
|
|
}
|
|
if prepared.Samples[0].Amount.String() != "-12.30" || prepared.Samples[1].Amount.String() != "1200.00" {
|
|
t.Fatalf("split debit and credit lost direction: %+v", prepared.Samples)
|
|
}
|
|
if prepared.Samples[0].RawDescription != "Mittagessen Berlin" || prepared.Samples[0].Counterparty != "Cafe Sonne" || prepared.Samples[0].BookingDate != "2026-09-01" {
|
|
t.Fatalf("unexpected preview sample: %+v", prepared.Samples[0])
|
|
}
|
|
if len(*prompts) != 1 {
|
|
t.Fatalf("expected exactly one mapping request, got %d", len(*prompts))
|
|
}
|
|
// Only column names and value shapes may leave this machine.
|
|
for _, secret := range []string{"Cafe Sonne", "Mittagessen", "Arbeitgeber", "12,30", "1.200,00", "01.09.2026"} {
|
|
if strings.Contains((*prompts)[0], secret) {
|
|
t.Fatalf("mapping request leaked %q: %s", secret, (*prompts)[0])
|
|
}
|
|
}
|
|
for _, header := range []string{"Datum", "Soll", "Haben", "Notiz", "Empfänger"} {
|
|
if !strings.Contains((*prompts)[0], header) {
|
|
t.Fatalf("mapping request omitted column %q: %s", header, (*prompts)[0])
|
|
}
|
|
}
|
|
result, err := a.ConfirmCSVImport(context.Background(), prepared.ID, prepared.Revision)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Imported != 2 {
|
|
t.Fatalf("confirmed mapping imported %d records", result.Imported)
|
|
}
|
|
for _, tx := range result.State.Data.Transactions {
|
|
if tx.Facts.Source != "csv" || tx.Facts.ExternalID != "" {
|
|
t.Fatalf("mapped facts carry an unexpected identity: %+v", tx.Facts)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUnsafeProposedMappingsAreRejected(t *testing.T) {
|
|
valid := map[string]any{
|
|
"booking_date_column": "Datum", "value_date_column": "", "amount_column": "",
|
|
"debit_column": "Soll", "credit_column": "Haben", "currency_column": "",
|
|
"description_column": "Notiz", "counterparty_column": "Empfänger",
|
|
"counterparty_iban_column": "", "date_format": "dd.mm.yyyy", "decimal_format": "comma",
|
|
}
|
|
with := func(changes map[string]any) map[string]any {
|
|
proposal := map[string]any{}
|
|
for key, value := range valid {
|
|
proposal[key] = value
|
|
}
|
|
for key, value := range changes {
|
|
proposal[key] = value
|
|
}
|
|
return proposal
|
|
}
|
|
cases := map[string]map[string]any{
|
|
"invented column": with(map[string]any{"description_column": "Verwendungszweck"}),
|
|
"missing date": with(map[string]any{"booking_date_column": ""}),
|
|
"missing description": with(map[string]any{"description_column": ""}),
|
|
"no money": with(map[string]any{"debit_column": "", "credit_column": ""}),
|
|
"both strategies": with(map[string]any{"amount_column": "Soll"}),
|
|
"half split": with(map[string]any{"credit_column": ""}),
|
|
"unsupported format": with(map[string]any{"date_format": "%d.%m.%Y"}),
|
|
"column reused": with(map[string]any{"counterparty_column": "Notiz"}),
|
|
"unknown field": with(map[string]any{"balance_column": "Soll"}),
|
|
}
|
|
for name, proposal := range cases {
|
|
t.Run(name, func(t *testing.T) {
|
|
a, s := testApp(t)
|
|
mockCSVMapper(t, a, proposal)
|
|
prepared, err := a.PrepareCSVImport(context.Background(), s.Revision, "n26", strings.NewReader(unmappedStatement))
|
|
if err == nil {
|
|
t.Fatalf("accepted an unsafe mapping: %+v", prepared)
|
|
}
|
|
current, e := a.Snapshot(context.Background())
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if !reflect.DeepEqual(s.Data, current.Data) {
|
|
t.Fatal("a rejected mapping changed the journal")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConfirmationRequiresTheReviewedJournalRevision(t *testing.T) {
|
|
a, s := testApp(t)
|
|
prepared := prepare(t, a, s, n26Statement)
|
|
// An unrelated edit invalidates the preview: its duplicate analysis and
|
|
// sample were computed against the revision the operator reviewed.
|
|
changed, err := a.Mutate(context.Background(), s.Revision, func(d *domain.Dataset) error {
|
|
d.Tags = append(d.Tags, domain.Tag{ID: "tag_new", Name: "new"})
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := a.ConfirmCSVImport(context.Background(), prepared.ID, prepared.Revision); err == nil {
|
|
t.Fatal("confirmed a preview of a superseded journal")
|
|
}
|
|
if _, err := a.ConfirmCSVImport(context.Background(), prepared.ID, changed.Revision); err == nil {
|
|
t.Fatal("confirmed a preview with a substituted revision")
|
|
}
|
|
if _, err := a.PrepareCSVImport(context.Background(), s.Revision, "n26", strings.NewReader(n26Statement)); err == nil {
|
|
t.Fatal("prepared an import against a superseded revision")
|
|
}
|
|
if _, err := a.PrepareCSVImport(context.Background(), changed.Revision, "missing", strings.NewReader(n26Statement)); err == nil {
|
|
t.Fatal("prepared an import for an unknown account")
|
|
}
|
|
current, err := a.Snapshot(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(current.Data.Transactions) != 0 {
|
|
t.Fatalf("rejected confirmations imported %d transactions", len(current.Data.Transactions))
|
|
}
|
|
}
|
|
|
|
// Switching AI classification off for imports must stop every provider call
|
|
// while leaving deterministic merchant rules, and the imported facts, intact.
|
|
func TestAIClassificationOnImportCanBeSwitchedOff(t *testing.T) {
|
|
a, s := testApp(t)
|
|
var calls atomic.Int32
|
|
mockClassifier(t, a, func(*http.Request) { calls.Add(1) })
|
|
ctx := context.Background()
|
|
s, err := a.Mutate(ctx, s.Revision, func(d *domain.Dataset) error {
|
|
d.Merchants = append(d.Merchants, domain.Merchant{
|
|
ID: "mer_cafe", Name: "Cafe", Aliases: []string{},
|
|
DefaultCategoryID: "groceries", DefaultTagIDs: []string{"home"}, UseDefaults: true,
|
|
})
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !s.Settings.ClassifyOnImport {
|
|
t.Fatal("imports must classify by default")
|
|
}
|
|
s, err = a.SaveSettings(ctx, Settings{Model: "test/model", ClassifyOnImport: false})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if s.Settings.ClassifyOnImport {
|
|
t.Fatal("saved preference did not switch classification off")
|
|
}
|
|
prepared := prepare(t, a, s, n26Statement)
|
|
result, err := a.ConfirmCSVImport(ctx, prepared.ID, prepared.Revision)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Imported != 2 || calls.Load() != 0 {
|
|
t.Fatalf("import contacted the provider %d times with classification off", calls.Load())
|
|
}
|
|
for _, tx := range result.State.Data.Transactions {
|
|
switch tx.Facts.RawDescription {
|
|
case "Lunch":
|
|
if tx.Enrichment.MerchantID != "mer_cafe" || tx.Enrichment.CategoryID != "groceries" ||
|
|
!reflect.DeepEqual(tx.Enrichment.TagIDs, []string{"home"}) || tx.Enrichment.Classification.Source != "rule" {
|
|
t.Fatalf("merchant rule did not apply without AI: %+v", tx.Enrichment)
|
|
}
|
|
default:
|
|
// No rule and no AI is not a failure: the record stays editable
|
|
// without a provenance error suggesting the provider failed.
|
|
if tx.Enrichment.CategoryID != domain.IncomeFallback || tx.Enrichment.Classification.Source != "fallback" || tx.Enrichment.Classification.Error != "" {
|
|
t.Fatalf("unclassified import reported a failure: %+v", tx.Enrichment)
|
|
}
|
|
}
|
|
}
|
|
|
|
// The preference is a stored preference, not a session flag.
|
|
a = reopenBankingApp(t, a)
|
|
mockClassifier(t, a, func(*http.Request) { calls.Add(1) })
|
|
restarted, err := a.Snapshot(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if restarted.Settings.ClassifyOnImport || restarted.Settings.Model != "test/model" {
|
|
t.Fatalf("preferences did not survive restart: %+v", restarted.Settings)
|
|
}
|
|
prepared = prepare(t, a, restarted, laterStatement)
|
|
if _, err = a.ConfirmCSVImport(ctx, prepared.ID, prepared.Revision); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if calls.Load() != 0 {
|
|
t.Fatalf("restarted import contacted the provider %d times", calls.Load())
|
|
}
|
|
|
|
// Switching it back on classifies subsequent imports again.
|
|
enabled, err := a.SaveSettings(ctx, Settings{Model: "test/model", ClassifyOnImport: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
prepared = prepare(t, a, enabled, "Booking Date,Partner Name,Type,Payment Reference,Amount (EUR)\n2026-11-02,Market,Card,REWE Groceries,-21.40\n")
|
|
final, err := a.ConfirmCSVImport(ctx, prepared.ID, prepared.Revision)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if calls.Load() != 1 {
|
|
t.Fatalf("re-enabled import made %d provider requests", calls.Load())
|
|
}
|
|
classified := false
|
|
for _, tx := range final.State.Data.Transactions {
|
|
if tx.Facts.RawDescription == "REWE Groceries" {
|
|
classified = tx.Enrichment.Classification.Source == "openrouter" && tx.Enrichment.CategoryID == "groceries"
|
|
}
|
|
}
|
|
if !classified {
|
|
t.Fatal("re-enabled classification did not reach the new transaction")
|
|
}
|
|
}
|