ydim 1.1.4 → 1.1.6

data/test/data/camt053.xml

@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Synthetic camt.053, shaped like the UBS Z53 downloads: a business account
+     and a private account in the same delivery, one statement re-sent under a
+     new MsgId, and the remittance information in the forms payers actually
+     use. All IBANs, names and numbers are made up. -->
+<Document xmlns="urn:iso:std:iso:20022:tech:xsd:camt.053.001.08">
+  <BkToCstmrStmt>
+    <GrpHdr>
+      <MsgId>TESTMSG0001</MsgId>
+      <CreDtTm>2026-07-31T18:00:00+02:00</CreDtTm>
+    </GrpHdr>
+    <!-- The business account: this is the one ydim reconciles. -->
+    <Stmt>
+      <Id>TESTSTMT0001</Id>
+      <ElctrncSeqNb>1</ElctrncSeqNb>
+      <CreDtTm>2026-07-31T18:00:00+02:00</CreDtTm>
+      <Acct>
+        <Id><IBAN>CH1100000000000000001</IBAN></Id>
+        <Ccy>CHF</Ccy>
+        <Ownr><Nm>Test Business GmbH</Nm></Ownr>
+      </Acct>
+      <Bal>
+        <Tp><CdOrPrtry><Cd>OPBD</Cd></CdOrPrtry></Tp>
+        <Amt Ccy="CHF">1000.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Dt><Dt>2026-07-01</Dt></Dt>
+      </Bal>
+      <Bal>
+        <Tp><CdOrPrtry><Cd>CLBD</Cd></CdOrPrtry></Tp>
+        <Amt Ccy="CHF">4433.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Dt><Dt>2026-07-31</Dt></Dt>
+      </Bal>
+      <!-- Invoice named and the amount agrees: bookable without review. -->
+      <Ntry>
+        <Amt Ccy="CHF">500.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-10</Dt></BookgDt>
+        <ValDt><Dt>2026-07-10</Dt></ValDt>
+        <AcctSvcrRef>REFA1</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><Nm>Example AG</Nm></Pty></Dbtr></RltdPties>
+          <RmtInf><Ustrd>RG 10001 VOM 1.7.2026</Ustrd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Credit</AddtlNtryInf>
+      </Ntry>
+      <!-- One transfer settling two invoices, with the numbers run together
+           exactly as the payer's software writes them. -->
+      <Ntry>
+        <Amt Ccy="CHF">300.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-11</Dt></BookgDt>
+        <ValDt><Dt>2026-07-11</Dt></ValDt>
+        <AcctSvcrRef>REFA2</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><Nm>Example AG</Nm></Pty></Dbtr></RltdPties>
+          <RmtInf><Ustrd>RG 10002 VOM 2.7.2026RG 10003 VOM 3.7.2026</Ustrd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Credit</AddtlNtryInf>
+      </Ntry>
+      <!-- No reference at all: only the amount and the payer's name to go on. -->
+      <Ntry>
+        <Amt Ccy="CHF">250.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-12</Dt></BookgDt>
+        <ValDt><Dt>2026-07-12</Dt></ValDt>
+        <AcctSvcrRef>REFA3</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><Nm>Nameless AG</Nm></Pty></Dbtr></RltdPties>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>e-banking Credit</AddtlNtryInf>
+      </Ntry>
+      <!-- TWINT: the remittance information is the payer's phone number. -->
+      <Ntry>
+        <Amt Ccy="CHF">42.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-13</Dt></BookgDt>
+        <ValDt><Dt>2026-07-13</Dt></ValDt>
+        <AcctSvcrRef>REFA4</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><PstlAdr><AdrLine>Twint, Payer</AdrLine></PstlAdr></Pty></Dbtr></RltdPties>
+          <RmtInf><Ustrd>+41791234567                       TWINT-Acc.:+41790000000</Ustrd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Credit UBS TWINT // TWINT, PAYER</AddtlNtryInf>
+      </Ntry>
+      <!-- A machine-generated hex reference that happens to contain "10004".
+           Reading an invoice number out of it would be an accident. -->
+      <Ntry>
+        <Amt Ccy="CHF">777.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-14</Dt></BookgDt>
+        <ValDt><Dt>2026-07-14</Dt></ValDt>
+        <AcctSvcrRef>REFA5</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <Refs><EndToEndId>0ebf10004f364fc394da3e2776a05643</EndToEndId></Refs>
+          <RltdPties><Dbtr><Pty><Nm>Hexadecimal AG</Nm></Pty></Dbtr></RltdPties>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>e-banking Credit</AddtlNtryInf>
+      </Ntry>
+      <!-- Money going out is never a payment on an invoice we issued. -->
+      <Ntry>
+        <Amt Ccy="CHF">99.00</Amt>
+        <CdtDbtInd>DBIT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-15</Dt></BookgDt>
+        <ValDt><Dt>2026-07-15</Dt></ValDt>
+        <AcctSvcrRef>REFA6</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Cdtr><Pty><Nm>Supplier AG</Nm></Pty></Cdtr></RltdPties>
+          <RmtInf><Strd><CdtrRefInf>
+            <Tp><CdOrPrtry><Prtry>QRR</Prtry></CdOrPrtry></Tp>
+            <Ref>102316851467000225775300000</Ref>
+          </CdtrRefInf><AddtlRmtInf>QRR</AddtlRmtInf></Strd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Payment Order</AddtlNtryInf>
+      </Ntry>
+      <!-- Still pending: it can be reversed, so it must not settle anything. -->
+      <Ntry>
+        <Amt Ccy="CHF">123.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>PDNG</Cd></Sts>
+        <BookgDt><Dt>2026-07-16</Dt></BookgDt>
+        <ValDt><Dt>2026-07-16</Dt></ValDt>
+        <AcctSvcrRef>REFA7</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><Nm>Pending AG</Nm></Pty></Dbtr></RltdPties>
+          <RmtInf><Ustrd>RG 10005</Ustrd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Credit</AddtlNtryInf>
+      </Ntry>
+      <!-- Right invoice, not enough money. -->
+      <Ntry>
+        <Amt Ccy="CHF">640.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-17</Dt></BookgDt>
+        <ValDt><Dt>2026-07-17</Dt></ValDt>
+        <AcctSvcrRef>REFA8</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><Nm>Partial AG</Nm></Pty></Dbtr></RltdPties>
+          <RmtInf><Ustrd>Rechnung 10006</Ustrd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Credit</AddtlNtryInf>
+      </Ntry>
+      <!-- Names an invoice that was settled on an earlier run. -->
+      <Ntry>
+        <Amt Ccy="CHF">1000.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-18</Dt></BookgDt>
+        <ValDt><Dt>2026-07-18</Dt></ValDt>
+        <AcctSvcrRef>REFA9</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><Nm>Prompt AG</Nm></Pty></Dbtr></RltdPties>
+          <RmtInf><Ustrd>RG 10007</Ustrd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Credit</AddtlNtryInf>
+      </Ntry>
+    </Stmt>
+    <!-- The same day delivered a second time under a new statement id. -->
+    <Stmt>
+      <Id>TESTSTMT0002</Id>
+      <ElctrncSeqNb>2</ElctrncSeqNb>
+      <CreDtTm>2026-07-31T18:00:00+02:00</CreDtTm>
+      <Acct>
+        <Id><IBAN>CH1100000000000000001</IBAN></Id>
+        <Ccy>CHF</Ccy>
+        <Ownr><Nm>Test Business GmbH</Nm></Ownr>
+      </Acct>
+      <Ntry>
+        <Amt Ccy="CHF">500.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-10</Dt></BookgDt>
+        <ValDt><Dt>2026-07-10</Dt></ValDt>
+        <AcctSvcrRef>REFA1</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><Nm>Example AG</Nm></Pty></Dbtr></RltdPties>
+          <RmtInf><Ustrd>RG 10001 VOM 1.7.2026</Ustrd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Credit</AddtlNtryInf>
+      </Ntry>
+    </Stmt>
+    <!-- A private account rides along in the same download. Nothing here is
+         ever a payment on a ydim invoice, however well it seems to match. -->
+    <Stmt>
+      <Id>TESTSTMT0003</Id>
+      <ElctrncSeqNb>3</ElctrncSeqNb>
+      <CreDtTm>2026-07-31T18:00:00+02:00</CreDtTm>
+      <Acct>
+        <Id><IBAN>CH2200000000000000002</IBAN></Id>
+        <Ccy>CHF</Ccy>
+        <Ownr><Nm>Private Person</Nm></Ownr>
+      </Acct>
+      <Ntry>
+        <Amt Ccy="CHF">500.00</Amt>
+        <CdtDbtInd>CRDT</CdtDbtInd>
+        <Sts><Cd>BOOK</Cd></Sts>
+        <BookgDt><Dt>2026-07-19</Dt></BookgDt>
+        <ValDt><Dt>2026-07-19</Dt></ValDt>
+        <AcctSvcrRef>REFB1</AcctSvcrRef>
+        <NtryDtls><TxDtls>
+          <RltdPties><Dbtr><Pty><Nm>Example AG</Nm></Pty></Dbtr></RltdPties>
+          <RmtInf><Ustrd>RG 10001 VOM 1.7.2026</Ustrd></RmtInf>
+        </TxDtls></NtryDtls>
+        <AddtlNtryInf>Credit</AddtlNtryInf>
+      </Ntry>
+    </Stmt>
+  </BkToCstmrStmt>
+</Document>

data/test/test_camt.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# TestCamt -- ydim -- 09.08.2026 -- zdavatz@ywesee.com
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+$: << File.dirname(__FILE__)
+
+require 'minitest/autorun'
+require 'ydim/camt'
+
+module YDIM
+  class TestCamt < Minitest::Test
+    DATA = File.expand_path('data/camt053.xml', File.dirname(__FILE__))
+    BUSINESS = 'CH1100000000000000001'
+    PRIVATE  = 'CH2200000000000000002'
+    def setup
+      @statements = Camt.read(DATA)
+      @entries = Camt.entries(DATA)
+    end
+    def entry(reference)
+      @entries.find { |ntry| ntry.reference == reference }
+    end
+    def test_read__statements
+      assert_equal(3, @statements.size)
+      stmt = @statements.first
+      assert_equal('TESTSTMT0001', stmt.id)
+      assert_equal(BUSINESS, stmt.account_iban)
+      assert_equal('CHF', stmt.currency)
+      assert_equal('Test Business GmbH', stmt.owner)
+      assert_equal(1000.00, stmt.opening_balance)
+      assert_equal(4433.00, stmt.closing_balance)
+      assert_equal(9, stmt.entries.size)
+    end
+    def test_read__entry
+      ntry = entry('REFA1')
+      assert_equal(BUSINESS, ntry.account_iban)
+      assert_equal(500.00, ntry.amount)
+      assert_equal(50000, ntry.amount_cents)
+      assert_equal('CHF', ntry.currency)
+      assert_equal(true, ntry.credit?)
+      assert_equal(true, ntry.booked?)
+      assert_equal(Date.new(2026, 7, 10), ntry.booking_date)
+      assert_equal(Date.new(2026, 7, 10), ntry.value_date)
+      assert_equal('Example AG', ntry.counterparty)
+      assert_equal(['RG 10001 VOM 1.7.2026'], ntry.remittance)
+    end
+    def test_read__debit
+      ntry = entry('REFA6')
+      assert_equal(false, ntry.credit?)
+      assert_equal('Supplier AG', ntry.counterparty)
+      assert_equal(['102316851467000225775300000'], ntry.creditor_references)
+    end
+    def test_read__pending_is_not_booked
+      assert_equal(false, entry('REFA7').booked?)
+      assert_equal(true, entry('REFA1').booked?)
+    end
+    # A number a payer typed is a token; one a machine generated is not.
+    def test_numeric_tokens__invoice_number
+      assert_equal(%w{10001 1 7 2026}, entry('REFA1').numeric_tokens)
+    end
+    def test_numeric_tokens__two_invoices_run_together
+      tokens = entry('REFA2').numeric_tokens
+      assert_includes(tokens, '10002')
+      assert_includes(tokens, '10003')
+    end
+    def test_numeric_tokens__ignores_hex_reference
+      # "0ebf10004f364fc394da3e2776a05643" must not offer up "10004".
+      assert_equal([], entry('REFA5').numeric_tokens)
+    end
+    def test_numeric_tokens__twint_phone_number
+      # The phone numbers are tokens, they are just not invoice numbers; what
+      # matters is that no shorter number is carved out of them.
+      assert_equal(%w{41791234567 41790000000}, entry('REFA4').numeric_tokens)
+    end
+    def test_numeric_tokens__none
+      assert_equal([], entry('REFA3').numeric_tokens)
+    end
+    def test_account
+      ntry = entry('REFA1')
+      assert_equal(true,  ntry.account?(BUSINESS))
+      assert_equal(true,  ntry.account?([PRIVATE, BUSINESS]))
+      assert_equal(false, ntry.account?(PRIVATE))
+      assert_equal(true,  ntry.account?([]))
+      # Written the way a human copies it out of e-banking.
+      assert_equal(true, ntry.account?('ch11 0000 0000 0000 00001'))
+    end
+    def test_entries__keeps_duplicates
+      assert_equal(11, @entries.size)
+      assert_equal(2, @entries.count { |ntry| ntry.reference == 'REFA1' \
+        && ntry.account_iban == BUSINESS })
+    end
+    def test_dedup
+      unique = Camt.dedup(@entries)
+      assert_equal(10, unique.size)
+      assert_equal(1, unique.count { |ntry| ntry.reference == 'REFA1' \
+        && ntry.account_iban == BUSINESS })
+      # Same reference on a different account is a different movement.
+      assert_equal(1, unique.count { |ntry| ntry.account_iban == PRIVATE })
+    end
+    def test_read__directory
+      assert_equal(@statements.size,
+        Camt.read(File.dirname(DATA)).size)
+    end
+    def test_parse__namespace_is_taken_from_the_document
+      # camt.053.001.02 through .08 differ only in the namespace URI here.
+      xml = File.read(DATA).gsub('camt.053.001.08', 'camt.053.001.04')
+      assert_equal(3, Camt.parse(xml).size)
+    end
+    def test_parse__not_xml
+      assert_raises(REXML::ParseException) { Camt.parse('not xml at all') }
+    end
+  end
+end

data/test/test_reconciler.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# TestReconciler -- ydim -- 09.08.2026 -- zdavatz@ywesee.com
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+$: << File.dirname(__FILE__)
+
+require 'minitest/autorun'
+require 'ydim/reconciler'
+
+module YDIM
+  class TestReconciler < Minitest::Test
+    DATA = File.expand_path('data/camt053.xml', File.dirname(__FILE__))
+    BUSINESS = 'CH1100000000000000001'
+    PRIVATE  = 'CH2200000000000000002'
+    # Stands in for Invoice::Info, which needs the whole server to load.
+    Info = Struct.new(:unique_id, :total_brutto, :currency, :date,
+      :debitor_name, :payment_received, :deleted)
+    def invoice(id, total, name, date = '2026-07-01', paid = nil)
+      Info.new(id, total, 'CHF', Date.parse(date), name, paid, false)
+    end
+    # The invoice book the fixture statements are payments against.
+    def setup
+      @book = [
+        invoice(10001, 500.00, 'Example AG'),
+        invoice(10002, 100.00, 'Example AG'),
+        invoice(10003, 200.00, 'Example AG'),
+        invoice(10004, 777.00, 'Hexadecimal AG'),
+        invoice(10006, 800.00, 'Partial AG'),
+        invoice(10008, 250.00, 'Nameless AG'),
+      ]
+      # 10005 is named by a pending entry, 10007 was settled earlier; neither
+      # is open, so both are only reachable through the resolver.
+      @settled = {
+        '10005' => invoice(10005, 123.00, 'Pending AG'),
+        '10007' => invoice(10007, 1000.00, 'Prompt AG', '2026-07-01',
+          Date.new(2026, 7, 5)),
+      }
+      @entries = Camt.entries(DATA)
+    end
+    def reconcile(book = @book, accounts = BUSINESS)
+      resolver = lambda { |id| @settled[id] }
+      Reconciler.new(book, accounts, resolver).reconcile(@entries)
+    end
+    def match(result, reference)
+      result.matches.find { |m| m.entry.reference == reference }
+    end
+
+    def test_reconcile__requires_an_account
+      # Without a filter the private account in the same download would be
+      # matched against invoices, so this must fail rather than guess.
+      error = assert_raises(ArgumentError) { reconcile(@book, []) }
+      assert_match(/camt_accounts/, error.message)
+      assert_raises(ArgumentError) { reconcile(@book, nil) }
+    end
+    def test_reconcile__ignores_other_accounts
+      result = reconcile
+      assert_equal(1, result.skipped[:other_account])
+      assert_nil(match(result, 'REFB1'))
+    end
+    # The private account carries a credit that names invoice 10001 for the
+    # right amount. Reconciling that account instead would settle it.
+    def test_reconcile__business_and_private_do_not_mix
+      business = reconcile(@book, BUSINESS)
+      assert_equal([10001], match(business, 'REFA1').invoice_ids)
+      private_only = reconcile(@book, PRIVATE)
+      assert_equal(1, private_only.applicable.size)
+      assert_equal(9, private_only.skipped[:other_account])
+    end
+    def test_reconcile__counts_every_entry
+      result = reconcile
+      counted = result.matches.size + result.skipped.values.inject(0) { |a, b|
+        a + b }
+      assert_equal(@entries.size, counted)
+    end
+    def test_reconcile__skips_duplicates_debits_and_pending
+      result = reconcile
+      assert_equal(1, result.skipped[:duplicate])
+      assert_equal(1, result.skipped[:debit])
+      assert_equal(1, result.skipped[:not_booked])
+      assert_nil(match(result, 'REFA7'))
+    end
+
+    def test_match__exact
+      found = match(reconcile, 'REFA1')
+      assert_equal(:exact, found.state)
+      assert_equal([10001], found.invoice_ids)
+      assert_equal(true, found.applicable?)
+    end
+    def test_match__split_over_two_invoices
+      found = match(reconcile, 'REFA2')
+      assert_equal(:split, found.state)
+      assert_equal([10002, 10003], found.invoice_ids.sort)
+      assert_equal(true, found.applicable?)
+    end
+    def test_match__amount_and_name_only
+      found = match(reconcile, 'REFA3')
+      assert_equal(:amount_only, found.state)
+      assert_equal([10008], found.invoice_ids)
+      assert_equal(false, found.applicable?)
+      assert_equal(true, found.review?)
+    end
+    # The hex reference contains "10004" and invoice 10004 is over exactly this
+    # amount, so a looser reader would book it. It may be suggested, never
+    # booked.
+    def test_match__hex_reference_is_not_an_invoice_number
+      found = match(reconcile, 'REFA5')
+      assert_equal(:amount_only, found.state)
+      assert_equal(false, found.applicable?)
+    end
+    def test_match__underpaid
+      found = match(reconcile, 'REFA8')
+      assert_equal(:underpaid, found.state)
+      assert_equal([10006], found.invoice_ids)
+      assert_equal(false, found.applicable?)
+      assert_match(/640\.00 received, 800\.00 invoiced/, found.reason)
+    end
+    def test_match__overpaid
+      found = match(reconcile(@book.collect { |info|
+        info.unique_id == 10006 ? invoice(10006, 500.00, 'Partial AG') : info
+      }), 'REFA8')
+      assert_equal(:overpaid, found.state)
+      assert_match(/640\.00 received, 500\.00 invoiced/, found.reason)
+    end
+    def test_match__not_open
+      found = match(reconcile, 'REFA9')
+      assert_equal(:not_open, found.state)
+      assert_equal(false, found.applicable?)
+      assert_match(/no longer open/, found.reason)
+    end
+    def test_match__twint_phone_number_settles_nothing
+      found = match(reconcile, 'REFA4')
+      assert_equal(:unmatched, found.state)
+      assert_equal([], found.invoice_ids)
+    end
+    def test_match__ambiguous_amount
+      book = @book + [invoice(10009, 250.00, 'Nameless AG')]
+      found = match(reconcile(book), 'REFA3')
+      assert_equal(:ambiguous, found.state)
+      assert_equal([10008, 10009], found.invoice_ids.sort)
+      assert_equal(false, found.applicable?)
+    end
+    # Same amount, but only one of them is from the payer.
+    def test_match__debitor_name_breaks_the_tie
+      book = @book + [invoice(10009, 250.00, 'Unrelated AG')]
+      found = match(reconcile(book), 'REFA3')
+      assert_equal(:amount_only, found.state)
+      assert_equal([10008], found.invoice_ids)
+    end
+    def test_match__invoice_written_after_the_payment_is_no_candidate
+      book = [invoice(10008, 250.00, 'Nameless AG', '2026-07-20')]
+      assert_equal(:unmatched, match(reconcile(book), 'REFA3').state)
+    end
+    def test_match__currency_mismatch
+      book = [Info.new(10001, 500.00, 'EUR', Date.parse('2026-07-01'),
+        'Example AG', nil, false)]
+      found = match(reconcile(book), 'REFA1')
+      assert_equal(:currency_mismatch, found.state)
+      assert_equal(false, found.applicable?)
+    end
+    def test_match__deleted_invoice_is_not_payable
+      book = [Info.new(10001, 500.00, 'CHF', Date.parse('2026-07-01'),
+        'Example AG', nil, true)]
+      assert_equal(:not_open, match(reconcile(book), 'REFA1').state)
+    end
+
+    def test_result__groups
+      result = reconcile
+      assert_equal(%w{REFA1 REFA2},
+        result.applicable.collect { |m| m.entry.reference }.sort)
+      assert_equal(%w{REFA3 REFA5 REFA8 REFA9},
+        result.review.collect { |m| m.entry.reference }.sort)
+      assert_equal(%w{REFA4},
+        result.unmatched.collect { |m| m.entry.reference })
+      assert_equal([], result.applied)
+    end
+    def test_invoice_ref__carries_no_server_classes
+      # Results travel back over DRb; a client must be able to load them with
+      # ydim/reconciler alone.
+      ref = Reconciler::InvoiceRef.new(@book.first)
+      assert_equal(ref.to_s, Marshal.load(Marshal.dump(ref)).to_s)
+      assert_equal(50000, ref.total_cents)
+      assert_equal(true, ref.payable?)
+    end
+  end
+end

data/test/test_root_session.rb

@@ -342,6 +342,115 @@ module YDIM
       assert_logged(:debug, :debug) {
         @session.update_item(12, 4, {:foo => 'bar'}, :autoinvoice)
       }
+    end
+    def test_mark_paid
+      inv = flexmock('invoice')
+      date = Date.new(2026, 7, 10)
+      inv.should_receive(:payment_received=).with(date).times(1)
+      inv.should_receive(:odba_store).times(1)
+      inv.should_receive(:info).and_return('info')
+      flexstub(Invoice).should_receive(:find_by_unique_id)\
+        .with('12').and_return(inv)
+      res = nil
+      assert_logged(:info, :debug) {
+        res = @session.mark_paid(12, date)
+      }
+      assert_equal('info', res)
+    end
+    def test_open_invoice_infos
+      open = flexmock('open')
+      open.should_receive(:info).and_return('open info')
+      due = flexmock('due')
+      due.should_receive(:info).and_return('due info')
+      flexstub(Invoice).should_receive(:search_by_status)\
+        .with('is_open').and_return([open])
+      flexstub(Invoice).should_receive(:search_by_status)\
+        .with('is_due').and_return([due])
+      res = nil
+      assert_logged(:debug) {
+        res = @session.open_invoice_infos
+      }
+      assert_equal(['open info', 'due info'], res)
+    end
+    # The entries come from the client, already parsed; the daemon never reads
+    # the statement files itself.
+    def entry(amount, remittance)
+      ntry = YDIM::Camt::Entry.new
+      ntry.account_iban = 'CH1100000000000000001'
+      ntry.amount = amount
+      ntry.currency = 'CHF'
+      ntry.credit = true
+      ntry.status = 'BOOK'
+      ntry.booking_date = Date.new(2026, 7, 10)
+      ntry.reference = "REF#{amount}"
+      ntry.remittance.push(remittance)
+      ntry
+    end
+    def invoice_info(id, total, paid = nil)
+      info = flexmock("info#{id}")
+      info.should_receive(:unique_id).and_return(id)
+      info.should_receive(:total_brutto).and_return(total)
+      info.should_receive(:currency).and_return('CHF')
+      info.should_receive(:date).and_return(Date.new(2026, 7, 1))
+      info.should_receive(:debitor_name).and_return('Example AG')
+      info.should_receive(:payment_received).and_return(paid)
+      info.should_receive(:deleted).and_return(false)
+      info
+    end
+    def stub_invoice_book
+      config = flexmock('config')
+      config.should_receive(:camt_accounts)\
+        .and_return(['CH1100000000000000001'])
+      @serv.should_receive(:config).and_return { config }
+      open = flexmock('open invoice')
+      open.should_receive(:info).and_return(invoice_info(10001, 500.00))
+      flexstub(Invoice).should_receive(:search_by_status)\
+        .with('is_open').and_return([open])
+      flexstub(Invoice).should_receive(:search_by_status)\
+        .with('is_due').and_return([])
+    end
+    def test_reconcile_camt
+      stub_invoice_book
+      flexstub(Invoice).should_receive(:find_by_unique_id).and_return(nil)
+      entries = [entry(500.00, 'RG 10001'), entry(42.00, 'RG 99999')]
+      res = nil
+      assert_logged(:info, :debug) {
+        res = @session.reconcile_camt(entries)
+      }
+      assert_equal(1, res.applicable.size)
+      assert_equal([10001], res.applicable.first.invoice_ids)
+      assert_equal(1, res.unmatched.size)
+      # Read-only without :apply.
+      assert_equal([], res.applied)
+    end
+    def test_reconcile_camt__apply
+      stub_invoice_book
+      paid = flexmock('invoice to settle')
+      paid.should_receive(:payment_received=).with(Date.new(2026, 7, 10))\
+        .times(1)
+      paid.should_receive(:odba_store).times(1)
+      paid.should_receive(:info).and_return('settled')
+      flexstub(Invoice).should_receive(:find_by_unique_id)\
+        .with('10001').and_return(paid)
+      res = nil
+      assert_logged(:info, :debug, :info, :debug) {
+        res = @session.reconcile_camt([entry(500.00, 'RG 10001')],
+          :apply => true)
+      }
+      assert_equal(1, res.applied.size)
+    end
+    # A credit on a private account must never settle an invoice, however
+    # exactly it matches.
+    def test_reconcile_camt__other_account
+      stub_invoice_book
+      ntry = entry(500.00, 'RG 10001')
+      ntry.account_iban = 'CH2200000000000000002'
+      res = nil
+      assert_logged(:info, :debug) {
+        res = @session.reconcile_camt([ntry])
+      }
+      assert_equal([], res.applicable)
+      assert_equal(1, res.skipped[:other_account])
     end
 	end
 end

data/ydim.gemspec

@@ -30,6 +30,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rclconf"
   spec.add_dependency "needle"
   spec.add_dependency "ypdf-writer"
+  # ypdf-writer allows color >= 1.4.0, but color 2.0 removed the named
+  # constants it refers to while loading (Color::RGB::Blue), so a fresh
+  # install cannot even require pdf/writer and no invoice renders.
+  spec.add_dependency "color", "< 2"
   spec.add_dependency "rrba"
   spec.add_dependency "hpricot"
   spec.add_dependency "pkg-config"
@@ -38,9 +42,16 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "flexmock"
+  # test_root_session.rb's assert_logged relies on flexmock passing the block
+  # to and_return as a trailing argument; flexmock 3 stopped doing that and
+  # every test using it dies with "undefined method `call' for nil".
+  spec.add_development_dependency "flexmock", "< 3"
   spec.add_development_dependency "test-unit"
-  spec.add_development_dependency "minitest"
+  # The suite runs on flexmock/test_unit, which needs the
+  # Minitest::Unit::TestCase shim that MT_COMPAT=1 enables. Minitest 6 dropped
+  # it, and every test file then fails to load with "undefined method
+  # `teardown'".
+  spec.add_development_dependency "minitest", "< 6"
   spec.add_development_dependency "rspec"
 end