notid/integreat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bfa04ef83fb6907cd0df8d6940482ff9be436419
integreat/test/clj/auto_ap/import/transactions_test.clj

516 lines
36 KiB
Clojure
Raw Blame History

(ns auto-ap.import.transactions-test
(:require
[auto-ap.datomic :refer [conn]]
[auto-ap.import.transactions :as sut]
[auto-ap.integration.util :refer [wrap-setup]]
[datomic.client.api :as dc]
[clj-time.coerce :as coerce]
[clojure.test :as t]
[digest :as di]))
(t/use-fixtures :each wrap-setup)
(defn noop-rule [transaction _]
transaction)
(def base-transaction #:transaction {:date #inst "2020-01-02T00:00:00-08:00"
:raw-id "1"
:id #_{:clj-kondo/ignore [:unresolved-var]}
(di/sha-256 "1")
:amount 12.0
:description-original "original-description"
:status "POSTED"
:client 123
:bank-account 456})
(t/deftest categorize-transactions
(let [bank-account {:db/id 456
:client/_bank-accounts {:db/id 123
:client/locations ["MH"]}}]
(t/testing "Should exclude a transaction before start date"
(t/is (= :not-ready
(sut/categorize-transaction (assoc base-transaction :transaction/date #inst "2020-01-01")
(assoc bank-account :bank-account/start-date #inst "2030-01-01")
{})))
(t/is (= :import
(sut/categorize-transaction (assoc base-transaction :transaction/date #inst "2020-01-02")
(assoc bank-account :bank-account/start-date #inst "2020-01-01")
{}))))
(t/testing "Should exclude a transaction before locked-until"
(t/is (= :not-ready
(sut/categorize-transaction (assoc base-transaction :transaction/date #inst "2020-01-01")
(assoc-in bank-account [:client/_bank-accounts :client/locked-until] #inst "2030-01-01")
{})))
(t/is (= :import
(sut/categorize-transaction (assoc base-transaction :transaction/date #inst "2020-01-01")
(assoc-in bank-account [:client/_bank-accounts :client/locked-until] #inst "2010-01-01")
{}))))
(t/testing "Should error a transaction without a client"
(t/is (= :error
(sut/categorize-transaction (dissoc base-transaction :transaction/client)
bank-account
{}))))
(t/testing "Should error a transaction without a bank-account"
(t/is (= :error
(sut/categorize-transaction (dissoc base-transaction :transaction/bank-account)
bank-account
{}))))
(t/testing "Should error a transaction without an id"
(t/is (= :error
(sut/categorize-transaction (dissoc base-transaction :transaction/id)
bank-account
{}))))
(t/testing "Should ignore a transaction that exists"
(t/is (= :extant
(sut/categorize-transaction (assoc base-transaction :transaction/id "123")
bank-account
{"123" :transaction-approval-status/unapproved}))))
(t/testing "Should import a transaction"
(t/is (= :import
(sut/categorize-transaction base-transaction
bank-account
{}))))))
(t/deftest transaction->txs
(t/testing "Should import and code transactions"
(t/testing "Should import one transaction"
(let [{:strs [bank-account-id client-id]} (:tempids (dc/transact conn
{:tx-data [{:db/id "bank-account-id"
:bank-account/code "TEST-1"}
{:db/id "client-id"
:client/code "TEST"
:client/locations ["Z" "E"]
:client/bank-accounts ["bank-account-id"]}]}))
_ (println bank-account-id client-id)
result (sut/transaction->txs base-transaction
(dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (= [(assoc base-transaction
:transaction/approval-status :transaction-approval-status/unapproved
:transaction/bank-account bank-account-id
:transaction/client client-id)]
result))))
(t/testing "Should match an uncleared check"
(let [{:strs [bank-account-id payment-id]} (->> {:tx-data [#:payment {:status :payment-status/pending
:date #inst "2019-01-01"
:bank-account "bank-account-id"
:client "client-id"
:check-number 10001
:amount 30.0
:db/id "payment-id"}
#:bank-account {:name "Bank account"
:db/id "bank-account-id"}
#:client {:name "Client"
:db/id "client-id"
:bank-accounts ["bank-account-id"]}]}
(dc/transact conn)
:tempids)]
(let [[transaction-result] (sut/transaction->txs (assoc base-transaction
:transaction/description-original "CHECK 10001"
:transaction/amount -30.0)
(dc/pull (dc/db conn ) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (= {:db/id payment-id
:payment/status :payment-status/cleared}
(:transaction/payment transaction-result))))
(t/testing "Should match a check that matches on amount if check number does not match"
(let [[transaction-result] (sut/transaction->txs (assoc base-transaction
:transaction/description-original "CHECK 12301"
:transaction/amount -30.0)
(dc/pull (dc/db conn ) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (= {:db/id payment-id
:payment/status :payment-status/cleared}
(:transaction/payment transaction-result)))))
(t/testing "Should not match an already matched check"
(dc/transact conn {:tx-data [{:db/id payment-id :payment/status :payment-status/cleared}]})
(let [[result] (sut/transaction->txs (assoc base-transaction
:transaction/description-original "CHECK 10001"
:transaction/amount -30.0)
(dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (= nil
(:transaction/payment result)))))))
(t/testing "Should match expected-deposits"
(let [{:strs [bank-account-id client-id expected-deposit-id]} (->> {:tx-data [#:expected-deposit {:client "client-id"
:date #inst "2021-07-01T00:00:00-08:00"
:vendor :vendor/ccp-square
:total 100.0
:location "MF"
:status :expected-deposit-status/pending
:db/id "expected-deposit-id"}
#:bank-account {:name "Bank account"
:db/id "bank-account-id"}
#:client {:name "Client"
:db/id "client-id"
:locations ["MF"]
:bank-accounts ["bank-account-id"]}]}
(dc/transact conn)
:tempids)]
(t/testing "Should match within 10 days"
(let [[transaction-result] (sut/transaction->txs (assoc base-transaction
:transaction/date #inst "2021-07-03T00:00:00-08:00"
:transaction/amount 100.0)
(dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (= expected-deposit-id
(:db/id (sut/find-expected-deposit client-id 100.0 (clj-time.coerce/to-date-time #inst "2021-07-03T00:00:00-08:00")))))
(t/is (= {:db/id expected-deposit-id
:expected-deposit/status :expected-deposit-status/cleared}
(:transaction/expected-deposit transaction-result)))))
(t/testing "Should copy vendor from expected-depoisit"
(let [[transaction-result] (sut/transaction->txs (assoc base-transaction
:transaction/vendor :vendor/ccp-square)
(dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (= :vendor/ccp-square
(:transaction/vendor transaction-result)))))
(t/testing "Should credit CCP"
(let [[transaction-result] (sut/transaction->txs (assoc base-transaction
:transaction/date #inst "2021-07-03T00:00:00-08:00"
:transaction/amount 100.0)
(dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (= [{:transaction-account/account :account/ccp
:transaction-account/amount 100.0
:transaction-account/location "A"}]
(:transaction/accounts transaction-result)))))
(t/testing "Should not match old expected deposits"
(let [[transaction-result] (sut/transaction->txs (assoc base-transaction
:transaction/date #inst "2021-07-13"
:transaction/amount 100.0)
(dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (not (:transaction/expected-deposit transaction-result)))))
(t/testing "Should only match exact."
(let [[transaction-result] (sut/transaction->txs (assoc base-transaction
:transaction/date "2021-07-03"
:transaction/amount 100.01)
(dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
noop-rule)]
(t/is (not (:transaction/expected-deposit transaction-result)))))))))
(t/deftest apply-synthetic-ids
(t/testing "Should increment index for duplicate transactions"
(t/is (= ["2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
"2020-01-02T00:00:00.000-08:00-456-original-description-12.0-1-123"]
(map :transaction/raw-id (sut/apply-synthetic-ids [base-transaction base-transaction])))))
(t/testing "Should use unique ids if a parameter is different"
(t/is (= ["2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
"2020-01-02T00:00:00.000-08:00-456-original-description-13.0-0-123"]
(map :transaction/raw-id (sut/apply-synthetic-ids [base-transaction (assoc base-transaction :transaction/amount 13.0)])))))
(t/testing "Should increment index if an unimportant field is set"
(t/is (= ["2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
"2020-01-02T00:00:00.000-08:00-456-original-description-12.0-1-123"]
(map :transaction/raw-id (sut/apply-synthetic-ids [base-transaction (assoc base-transaction :transaction/other-random-value 10.0)])))))
(t/testing "Should be forgiving if dates come in other formats"
(t/is (= "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
(->> (sut/apply-synthetic-ids [(assoc base-transaction
:transaction/date #inst "2020-01-02T00:00:00-08:00")])
first
:transaction/raw-id)))
(t/is (= "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
(->> (sut/apply-synthetic-ids [(assoc base-transaction
:transaction/date #inst "2020-01-02T08:00:00-00:00")])
first
:transaction/raw-id)))
(t/is (= "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
(->> (sut/apply-synthetic-ids [(assoc base-transaction
:transaction/date (coerce/to-date-time #inst "2020-01-02T08:00:00-00:00"))])
first
:transaction/raw-id)))
(t/is (= "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
(->> (sut/apply-synthetic-ids [(assoc base-transaction
:transaction/date (coerce/to-date-time #inst "2020-01-02T00:00:00-08:00"))])
first
:transaction/raw-id)))))
(t/deftest match-transaction-to-single-unfulfilled-payments
(t/testing "Auto-pay Invoices"
(let [{:strs [vendor1-id vendor2-id]} (->> {:tx-data [#:vendor {:name "Autopay vendor 1"
:db/id "vendor1-id"}
#:vendor {:name "Autopay vendor 2"
:db/id "vendor2-id"}]}
(dc/transact conn)
:tempids)]
(t/testing "Should find a single invoice that matches exactly"
(let [{:strs [client-id]} (->> {:tx-data [#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 30.0
:db/id "invoice-id"}
#:client {:name "Client" :db/id "client-id"}]}
(dc/transact conn)
:tempids)
invoices-matches (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
(t/is (= 1 (count invoices-matches)))
))
(t/testing "Should not match paid invoice that isn't a scheduled payment"
(let [{:strs [client-id]} (->> {:tx-data
[#:invoice{:status :invoice-status/paid
:vendor vendor1-id
:date #inst "2019-01-01"
:client "client-id"
:total 30.0
:db/id "invoice-id"}
#:client {:name "Client" :db/id "client-id"}]}
(dc/transact conn)
:tempids)
invoices-matches (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
(t/is (= [] invoices-matches))))
(t/testing "Should not match unpaid invoice"
(let [{:strs [client-id]} (->> {:tx-data
[#:invoice {:status :invoice-status/unpaid
:scheduled-payment #inst "2019-01-04"
:vendor vendor1-id
:date #inst "2019-01-01"
:client "client-id"
:total 30.0
:db/id "invoice-id"}
#:client {:name "Client" :db/id "client-id"}]}
(dc/transact conn)
:tempids)
invoices-matches (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
(t/is (= [] invoices-matches))))
(t/testing "Should not match invoice that already has a payment"
(let [{:strs [client-id]} (->> {:tx-data
[#:invoice {:status :invoice-status/paid
:scheduled-payment #inst "2019-01-04"
:vendor vendor1-id
:date #inst "2019-01-01"
:client "client-id"
:total 30.0
:db/id "invoice-id"}
{:invoice-payment/amount 30.0
:invoice-payment/invoice "invoice-id"}
#:client {:name "Client"
:db/id "client-id"}]}
(dc/transact conn)
:tempids)
invoices-matches (sut/match-transaction-to-single-unfulfilled-autopayments -30.0
client-id)]
(t/is (= [] invoices-matches))))
(t/testing "Should match multiple invoices for same vendor that total to transaction amount"
(let [{:strs [client-id]} (->> {:tx-data
[#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 15.0
:db/id "invoice1-id"}
#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 15.0
:db/id "invoice2-id"}
#:client {:name "Client" :db/id "client-id"}]}
(dc/transact conn)
:tempids)
invoices-matches (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
(t/is (= 2 (count invoices-matches))
(str "Expected " (vec invoices-matches) " to have a singular match of two invoices."))))
(t/testing "Should not match if there are multiple candidate matches"
(let [{:strs [client-id]} (->> {:tx-data
[#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 30.0
:db/id "invoice1-id"}
#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 30.0
:db/id "invoice2-id"}
#:client {:name "Client" :db/id "client-id"}]}
(dc/transact conn)
:tempids)
invoices-matches (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
(t/is (= 0 (count invoices-matches))
(str "Expected " (vec invoices-matches) " to not match due to multiple possibilities."))))
(t/testing "Should not match if invoices are for different vendors"
(let [{:strs [client-id]} (->> {:tx-data
[#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 10.0
:db/id "invoice1-id"}
#:invoice {:status :invoice-status/paid
:vendor vendor2-id
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 20.0
:db/id "invoice2-id"}
#:client {:name "Client" :db/id "client-id"}]}
(dc/transact conn)
:tempids)
invoices-matches (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
(t/is (= 0 (count invoices-matches))
(str "Expected " (vec invoices-matches) " to only consider invoices for the same vendor."))))
(t/testing "Should only consider invoices chronologically"
(let [{:strs [client-id]} (->> {:tx-data
[#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 10.0
:db/id "invoice1-id"}
#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-06"
:date #inst "2019-01-01"
:client "client-id"
:total 21.0
:db/id "invoice2-id"}
#:invoice {:status :invoice-status/paid
:vendor vendor1-id
:scheduled-payment #inst "2019-01-05"
:date #inst "2019-01-01"
:client "client-id"
:total 30.0
:db/id "invoice3-id"}
#:client {:name "Client" :db/id "client-id"}]}
(dc/transact conn)
:tempids)]
(t/is (= 2 (count (sut/match-transaction-to-single-unfulfilled-autopayments -40.0 client-id)))
(str "Expected to match with the chronologically adjacent invoice-1 and invoice-3."))
(t/is (= [] (sut/match-transaction-to-single-unfulfilled-autopayments -31.0 client-id))
(str "Expected to not match, because there is invoice-3 is between invoice-1 and invoice-2.")))))))
#_(t/testing "Auto-pay Invoices"
(t/testing "Should match paid invoice that doesn't have a payment yet"
(let [{:strs [bank-account-id client-id invoice1-id invoice2-id vendor-id]} (->> [#:invoice {:status :invoice-status/paid
:vendor "vendor-id"
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 20.0
:db/id "invoice1-id"}
#:invoice {:status :invoice-status/paid
:vendor "vendor-id"
:scheduled-payment #inst "2019-01-04"
:date #inst "2019-01-01"
:client "client-id"
:total 10.0
:db/id "invoice2-id"}
#:vendor {:name "Autopay vendor"
:db/id "vendor-id"}
#:bank-account {:name "Bank account"
:db/id "bank-account-id"}
#:client {:name "Client"
:db/id "client-id"
:bank-accounts ["bank-account-id"]}]
(d/transact (d/connect uri))
deref
:tempids)
[[transaction-tx payment-tx invoice-payments1-tx invoice-payments2-tx]] (sut/yodlees->transactions [(assoc base-yodlee-transaction
:amount {:amount 30.0}
:bank-account {:db/id bank-account-id
:client/_bank-accounts {:db/id client-id
:client/locations ["A"]}})]
:bank-account
noop-rule
#{})]
(t/is (= :transaction-approval-status/approved
(:transaction/approval-status transaction-tx))
(str "Should have approved transaction " transaction-tx))
(t/is (= #:payment{:status :payment-status/cleared
:type :payment-type/debit
:date (:transaction/date transaction-tx)
:client client-id
:bank-account bank-account-id
:vendor vendor-id
:amount 30.0}
(dissoc payment-tx :db/id))
(str "Should have created payment " payment-tx))
(t/is (= #:invoice-payment{:invoice invoice1-id
:amount 20.0
:payment (:db/id payment-tx)}
(dissoc invoice-payments1-tx :db/id))
(str "Should have paid invoice 1" invoice-payments1-tx))
(t/is (= #:invoice-payment{:invoice invoice2-id
:amount 10.0
:payment (:db/id payment-tx)}
(dissoc invoice-payments2-tx :db/id))
(str "Should have paid invoice 2" invoice-payments2-tx))))
(t/testing "Should not match paid invoice that isn't a scheduled payment"
(let [{:strs [bank-account-id client-id invoice-id]} (->> [#:invoice {:status :invoice-status/paid
:vendor "vendor-id"
:date #inst "2019-01-01"
:client "client-id"
:total 30.0
:db/id "invoice-id"}
#:vendor {:name "Autopay vendor"
:db/id "vendor-id"}
#:bank-account {:name "Bank account"
:db/id "bank-account-id"}
#:client {:name "Client"
:db/id "client-id"
:bank-accounts ["bank-account-id"]}]
(d/transact (d/connect uri))
deref
:tempids)
[[transaction-tx payment-tx]] (sut/yodlees->transactions [(assoc base-yodlee-transaction
:amount {:amount 30.0}
:bank-account {:db/id bank-account-id
:client/_bank-accounts {:db/id client-id
:client/locations ["A"]}})]
:bank-account
noop-rule
#{})]
(t/is (= :transaction-approval-status/unapproved
(:transaction/approval-status transaction-tx)))
(t/is (nil? (:transaction/payment transaction-tx))))))
Reference in New Issue View Git Blame Copy Permalink