QT/sure
1
0
Fork 0
mirror of https://github.com/we-promise/sure.git synced 2026-09-07 07:34:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
db181eb84fbb9ed9fdcf9c2acaa7efacd6ba3a61
sure/test/models/rule/condition_test.rb
T
KhaosticaJohn BaillieKhaosticasure-admin
 c3cfdf03b2 fix(rules): validate Rule::Condition type registry + normalize legacy values (#1908) 
* fix(rules): validate Rule::Condition type registry + normalize legacy 'name' values

Closes #1229.

/rules crashes with `ActionView::Template::Error (Unsupported condition
type: name)` when a Rule::Condition row has a condition_type the
registry doesn't know about. Reporter found two cases in the wild:

  - "name" — invalid, crashes the rules index because the view path
    (`_rule.html.erb` → `displayed_condition.filter.label`) ends up
    in `Rule::Registry#get_filter!` which raises.
  - "transaction_details" — actually a valid filter that searches the
    `transactions.extra` JSONB metadata field (see existing tests in
    test/models/rule/condition_test.rb). Reporter assumed it was a
    transaction-name synonym; it isn't. This PR leaves it alone.

Changes:

- Rule::Condition gains a SUPPORTED_CONDITION_TYPES registry constant
  matching Rule::Registry::TransactionResource#condition_filters plus
  "compound", an inclusion validation against it, and a
  before_validation callback that maps the one known legacy alias
  ("name" -> "transaction_name") so saving an existing rule fixes
  itself.
- Rule::Condition#filter now rescues UnsupportedConditionError and
  returns a Rule::ConditionFilter::Unsupported placeholder. The
  placeholder labels itself "Unsupported (<key>)" (i18n) and its
  #apply returns `scope.none`, so any stale row that survives the
  migration stops matching rather than silently matching everything.
- A one-shot migration normalizes existing "name" rows. Single UPDATE
  statement — rule_conditions is a small per-family table.

Tests added in test/models/rule/condition_test.rb cover the inclusion
validation, the normalization callback, and the graceful-render path
(uses update_columns to simulate a row written before the validation
existed — that's the exact codepath that crashes /rules today).

* test(rules): add system test for unsupported condition_type render + raise on migration down

- test/system/rules_test.rb: visit /rules with a row whose condition_type
  has been update_columns'd to "name" — assert page renders and shows
  the "Unsupported (name)" label instead of raising.
- db/migrate/...normalize_rule_condition_types.rb: replace the empty
  #down with `raise ActiveRecord::IrreversibleMigration` to match the
  repo's data-migration convention (see e.g. 20260219190000_scope_*).

* chore(rules): log unsupported condition + cross-check supported types

Address maintainer review on #1908:
- Log a Rails.logger.warn (with rule_id and condition_type) from
  Rule::ConditionFilter::Unsupported#apply so silent zero-match rules
  are traceable when debugging.
- Add a comment above Rule::Condition::SUPPORTED_CONDITION_TYPES and a
  test that cross-checks it against the registry's filter keys, so
  drift between the two surfaces as a failing test rather than a
  confusing validation error.

* refactor(rules): derive supported condition types from registry

---------

Co-authored-by: John Baillie <johnbaillie2007@gmail.com>
Co-authored-by: Khaostica <256858950+Khaostica@users.noreply.github.com>
Co-authored-by: sure-admin <sure-admin@splashblot.com>
2026-08-26 07:09:55 +02:00

681 lines
19 KiB
Ruby
Raw Blame History

require "test_helper"
class Rule::ConditionTest < ActiveSupport::TestCase
include EntriesTestHelper
setup do
@family = families(:empty)
@transaction_rule = rules(:one)
@account = @family.accounts.create!(name: "Rule test", balance: 1000, currency: "USD", accountable: Depository.new)
@grocery_category = @family.categories.create!(name: "Grocery")
@whole_foods_merchant = @family.merchants.create!(name: "Whole Foods", type: "FamilyMerchant")
# Some sample transactions to work with
create_transaction(date: Date.current, account: @account, amount: 100, name: "Rule test transaction1", merchant: @whole_foods_merchant)
create_transaction(date: Date.current, account: @account, amount: -200, name: "Rule test transaction2")
create_transaction(date: 1.day.ago.to_date, account: @account, amount: 50, name: "Rule test transaction3")
create_transaction(date: 1.year.ago.to_date, account: @account, amount: 10, name: "Rule test transaction4", merchant: @whole_foods_merchant)
create_transaction(date: 1.year.ago.to_date, account: @account, amount: 1000, name: "Rule test transaction5")
@rule_scope = @account.transactions
end
test "applies transaction_name condition" do
scope = @rule_scope
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_name",
operator: "=",
value: "Rule test transaction1"
)
scope = condition.prepare(scope)
assert_equal 5, scope.count
filtered = condition.apply(scope)
assert_equal 1, filtered.count
end
test "applies transaction_amount condition using absolute values" do
scope = @rule_scope
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_amount",
operator: ">",
value: "50"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 3, filtered.count
end
test "applies transaction_amount not equal operator using absolute values" do
create_transaction(date: Date.current, account: @account, amount: -100, name: "Rule test transaction negative 100")
scope = @account.transactions
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_amount",
operator: "!=",
value: "100"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# Absolute amounts: 100, -100, 200, 50, 10, 1000 — exclude both ±100
assert_equal 4, filtered.count
assert_not filtered.any? { |txn| txn.entry.amount.abs == 100 }
end
test "applies transaction_merchant condition" do
scope = @rule_scope
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_merchant",
operator: "=",
value: @whole_foods_merchant.id
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 2, filtered.count
end
test "applies compound and condition" do
scope = @rule_scope
parent_condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "compound",
operator: "and",
sub_conditions: [
Rule::Condition.new(
condition_type: "transaction_merchant",
operator: "=",
value: @whole_foods_merchant.id
),
Rule::Condition.new(
condition_type: "transaction_amount",
operator: "<",
value: "50"
)
]
)
scope = parent_condition.prepare(scope)
filtered = parent_condition.apply(scope)
assert_equal 1, filtered.count
end
test "applies compound or condition" do
scope = @rule_scope
parent_condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "compound",
operator: "or",
sub_conditions: [
Rule::Condition.new(
condition_type: "transaction_merchant",
operator: "=",
value: @whole_foods_merchant.id
),
Rule::Condition.new(
condition_type: "transaction_amount",
operator: "<",
value: "50"
)
]
)
scope = parent_condition.prepare(scope)
filtered = parent_condition.apply(scope)
assert_equal 2, filtered.count
end
test "applies transaction_category condition" do
scope = @rule_scope
# Set category for one transaction
@account.transactions.first.update!(category: @grocery_category)
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_category",
operator: "=",
value: @grocery_category.id
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 1, filtered.count
assert_equal @grocery_category.id, filtered.first.category_id
end
test "applies is_null condition for transaction_category" do
scope = @rule_scope
# Set category for one transaction
@account.transactions.first.update!(category: @grocery_category)
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_category",
operator: "is_null",
value: nil
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 4, filtered.count
assert filtered.all? { |t| t.category_id.nil? }
end
test "applies transaction_tag condition" do
scope = @rule_scope
tag = @family.tags.create!(name: "Reimbursable")
tagged = @account.transactions.first
tagged.tags << tag
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_tag",
operator: "=",
value: tag.id
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 1, filtered.count
assert_equal tagged.id, filtered.first.id
end
test "applies is_null condition for transaction_tag" do
scope = @rule_scope
tag = @family.tags.create!(name: "Reimbursable")
@account.transactions.first.tags << tag
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_tag",
operator: "is_null",
value: nil
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# The 4 transactions without any tag
assert_equal 4, filtered.count
assert filtered.none? { |t| t.tags.include?(tag) }
end
test "compound AND of two transaction_tag conditions matches transactions having both tags" do
scope = @rule_scope
tag_a = @family.tags.create!(name: "Reimbursable")
tag_b = @family.tags.create!(name: "Business")
both = @account.transactions.first
both.tags << [ tag_a, tag_b ]
only_a = @account.transactions.second
only_a.tags << tag_a
parent_condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "compound",
operator: "and",
sub_conditions: [
Rule::Condition.new(condition_type: "transaction_tag", operator: "=", value: tag_a.id),
Rule::Condition.new(condition_type: "transaction_tag", operator: "=", value: tag_b.id)
]
)
scope = parent_condition.prepare(scope)
filtered = parent_condition.apply(scope)
# Only the transaction carrying BOTH tags matches (a single joined alias could not)
assert_equal 1, filtered.count
assert_equal both.id, filtered.first.id
end
test "compound OR of transaction_tag conditions does not duplicate multi-tagged transactions" do
scope = @rule_scope
tag_a = @family.tags.create!(name: "Reimbursable")
tag_b = @family.tags.create!(name: "Business")
multi = @account.transactions.first
multi.tags << [ tag_a, tag_b ]
parent_condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "compound",
operator: "or",
sub_conditions: [
Rule::Condition.new(condition_type: "transaction_tag", operator: "=", value: tag_a.id),
Rule::Condition.new(condition_type: "transaction_tag", operator: "=", value: tag_b.id)
]
)
scope = parent_condition.prepare(scope)
filtered = parent_condition.apply(scope)
# Matches both OR branches but must be returned exactly once (no join fan-out)
assert_equal 1, filtered.count
assert_equal [ multi.id ], filtered.map(&:id)
end
test "applies is_null condition for transaction_merchant" do
scope = @rule_scope
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_merchant",
operator: "is_null",
value: nil
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 3, filtered.count
assert filtered.all? { |t| t.merchant_id.nil? }
end
test "applies transaction_details condition with like operator" do
scope = @rule_scope
# Create a transaction with extra details (simulating PayPal with underlying merchant)
paypal_entry = create_transaction(
date: Date.current,
account: @account,
amount: 75,
name: "PayPal"
)
paypal_entry.transaction.update!(
extra: {
"simplefin" => {
"payee" => "Amazon via PayPal",
"description" => "Purchase from Amazon",
"memo" => "Order #12345"
}
}
)
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_details",
operator: "like",
value: "Amazon"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 1, filtered.count
assert_equal paypal_entry.transaction.id, filtered.first.id
end
test "applies transaction_details condition with equal operator case-sensitive" do
scope = @rule_scope
# Create transaction with specific details
transaction_entry = create_transaction(
date: Date.current,
account: @account,
amount: 100,
name: "PayPal"
)
transaction_entry.transaction.update!(
extra: {
"simplefin" => {
"payee" => "Netflix"
}
}
)
# Test case-sensitive match (should match)
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_details",
operator: "=",
value: "Netflix"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 1, filtered.count
# Test case-sensitive match (should NOT match due to case difference)
condition_lowercase = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_details",
operator: "=",
value: "netflix"
)
scope = condition_lowercase.prepare(scope)
filtered = condition_lowercase.apply(scope)
assert_equal 0, filtered.count
end
test "applies transaction_details condition with is_null operator" do
scope = @rule_scope
# Create transaction with extra details
transaction_with_details = create_transaction(
date: Date.current,
account: @account,
amount: 50,
name: "Transaction with details"
)
transaction_with_details.transaction.update!(
extra: { "simplefin" => { "payee" => "Test Merchant" } }
)
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_details",
operator: "is_null",
value: nil
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# Should return all original transactions (which have no extra details) but not the new one
assert_equal 5, filtered.count
assert_not filtered.map(&:id).include?(transaction_with_details.transaction.id)
end
test "applies transaction_notes condition" do
scope = @rule_scope
# Add notes to one transaction
transaction_entry = @account.entries.first
transaction_entry.update!(notes: "Important: This is a business expense")
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_notes",
operator: "like",
value: "business expense"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 1, filtered.count
assert_equal transaction_entry.transaction.id, filtered.first.id
end
test "applies transaction_notes condition with is_null operator" do
scope = @rule_scope
# Add notes to one transaction
transaction_entry = @account.entries.first
transaction_entry.update!(notes: "Some notes")
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_notes",
operator: "is_null",
value: nil
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# Should return all transactions without notes
assert_equal 4, filtered.count
assert_not filtered.map(&:id).include?(transaction_entry.transaction.id)
end
test "applies transaction_type condition for income" do
scope = @rule_scope
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_type",
operator: "=",
value: "income"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# transaction2 has amount -200 (income)
assert_equal 1, filtered.count
assert filtered.all? { |t| t.entry.amount.negative? }
end
test "applies transaction_type condition for expense" do
scope = @rule_scope
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_type",
operator: "=",
value: "expense"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# transaction1, 3, 4, 5 have positive amounts (expenses)
assert_equal 4, filtered.count
assert filtered.all? { |t| t.entry.amount.positive? && !t.transfer? }
end
test "applies transaction_type condition for transfer" do
scope = @rule_scope
# Create a transfer transaction
transfer_entry = create_transaction(
date: Date.current,
account: @account,
amount: 500,
name: "Transfer to savings"
)
transfer_entry.transaction.update!(kind: "funds_movement")
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_type",
operator: "=",
value: "transfer"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
assert_equal 1, filtered.count
assert_equal transfer_entry.transaction.id, filtered.first.id
assert filtered.first.transfer?
end
test "transaction_type expense excludes transfers" do
scope = @rule_scope
# Create a transfer with positive amount (would look like expense)
transfer_entry = create_transaction(
date: Date.current,
account: @account,
amount: 500,
name: "Transfer to savings"
)
transfer_entry.transaction.update!(kind: "funds_movement")
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_type",
operator: "=",
value: "expense"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# Should NOT include the transfer even though it has positive amount
assert_not filtered.map(&:id).include?(transfer_entry.transaction.id)
end
test "transaction_type income excludes transfers" do
scope = @rule_scope
# Create a transfer inflow (negative amount)
transfer_entry = create_transaction(
date: Date.current,
account: @account,
amount: -500,
name: "Transfer from savings"
)
transfer_entry.transaction.update!(kind: "funds_movement")
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_type",
operator: "=",
value: "income"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# Should NOT include the transfer even though it has negative amount
assert_not filtered.map(&:id).include?(transfer_entry.transaction.id)
end
test "transaction_type transfer includes investment_contribution" do
scope = @rule_scope
# Create investment contribution with negative amount (inflow from provider)
contribution_entry = create_transaction(
date: Date.current,
account: @account,
amount: -1000,
name: "401k contribution"
)
contribution_entry.transaction.update!(kind: "investment_contribution")
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_type",
operator: "=",
value: "transfer"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# investment_contribution is a transfer kind
assert filtered.map(&:id).include?(contribution_entry.transaction.id)
# Should NOT match expense filter
expense_condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_type",
operator: "=",
value: "expense"
)
expense_scope = expense_condition.prepare(@rule_scope)
expense_filtered = expense_condition.apply(expense_scope)
assert_not expense_filtered.map(&:id).include?(contribution_entry.transaction.id)
end
test "SUPPORTED_CONDITION_TYPES comes from the registry's filter keys" do
expected = (Rule::Registry::TransactionResource.condition_filter_keys + [ "compound" ]).sort
assert_equal expected, Rule::Condition::SUPPORTED_CONDITION_TYPES.sort
end
test "validates condition_type against supported registry" do
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "definitely_not_a_real_type",
operator: "like",
value: "x"
)
assert_not condition.valid?
assert_includes condition.errors[:condition_type], "is not included in the list"
end
test "normalizes legacy 'name' condition_type to 'transaction_name' on save" do
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "name",
operator: "like",
value: "starbucks"
)
assert condition.valid?, condition.errors.full_messages.to_sentence
assert_equal "transaction_name", condition.condition_type
end
test "filter falls back gracefully when persisted condition_type is unsupported" do
# Bypass validations to simulate legacy rows that already exist in the database.
condition = Rule::Condition.new(
condition_type: "transaction_name",
operator: "like",
value: "x"
)
condition.rule = @transaction_rule
condition.save!
condition.update_columns(condition_type: "name")
condition.reload
assert_nothing_raised do
assert_equal "Unsupported (name)", condition.filter.label
assert_equal "name", condition.filter.key
end
end
test "transaction_type income excludes investment_contribution" do
scope = @rule_scope
# Create investment contribution with negative amount
contribution_entry = create_transaction(
date: Date.current,
account: @account,
amount: -1000,
name: "401k contribution"
)
contribution_entry.transaction.update!(kind: "investment_contribution")
condition = Rule::Condition.new(
rule: @transaction_rule,
condition_type: "transaction_type",
operator: "=",
value: "income"
)
scope = condition.prepare(scope)
filtered = condition.apply(scope)
# Should NOT include investment_contribution even with negative amount
assert_not filtered.map(&:id).include?(contribution_entry.transaction.id)
end
end
Reference in New Issue View Git Blame Copy Permalink