efrilmandClaude Opus 5
992bb04816
Products like fish are sold per weighing (4.2 ons, 5.6 ons), which the order line could not represent: quantity is INTEGER and prices are always computed as quantity * unit_price. Model one weighing as one order line. quantity stays INTEGER and keeps meaning "how many items"; the measured amount goes into a new nullable order_items.weight, and the line is priced weight * unit_price. Two weighings of the same product are two lines, never merged into one. Keeping quantity integral avoids float comparisons in void, refund and split bill, where accumulated rounding error would silently misbehave — "1.4 + 1.4 + 1.4" is not 4.2 in float64, which would leave a fully paid split-bill item marked unpaid. BillableQuantity() is now the single place that decides between weight and count; every price and cost calculation goes through it. Missing one would bill a 4.2 ons fish as a single ons — wrong money, no error. Two database constraints back the design: a weighed line always carries a positive weight, and its quantity is pinned to 1. The latter also makes void all-or-nothing for weighed lines, so the row-splitting branch can never produce a zero-weight remainder row. Also wires product.unit_id through the API, which was previously not settable at all, and corrects the misleading comment on the request's unit_price field — that value has never been used; price always comes from the database. Design notes and the audit of every price multiplication site are in docs/rfc-weight-based-products.md. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
105 lines
2.9 KiB
Go
105 lines
2.9 KiB
Go
package entities
|
|
|
|
import "testing"
|
|
|
|
func weightPtr(v float64) *float64 { return &v }
|
|
|
|
func TestBillableQuantity(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
item OrderItem
|
|
want float64
|
|
}{
|
|
{"unit line counts items", OrderItem{Quantity: 3}, 3},
|
|
{"weighed line uses the weight", OrderItem{Quantity: 1, Weight: weightPtr(4.2)}, 4.2},
|
|
{"weight of zero is still a weighed line", OrderItem{Quantity: 1, Weight: weightPtr(0)}, 0},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := tt.item.BillableQuantity(); got != tt.want {
|
|
t.Errorf("BillableQuantity() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// A weighed line is voided or refunded whole, so the units asked for must not shrink
|
|
// the amount: refunding "1" of a 4.2 ons line refunds all 4.2 ons.
|
|
func TestBillableQuantityForIgnoresUnitsOnWeighedLines(t *testing.T) {
|
|
weighed := OrderItem{Quantity: 1, Weight: weightPtr(5.6)}
|
|
if got := weighed.BillableQuantityFor(1); got != 5.6 {
|
|
t.Errorf("weighed BillableQuantityFor(1) = %v, want 5.6", got)
|
|
}
|
|
|
|
counted := OrderItem{Quantity: 3}
|
|
if got := counted.BillableQuantityFor(2); got != 2 {
|
|
t.Errorf("unit BillableQuantityFor(2) = %v, want 2", got)
|
|
}
|
|
}
|
|
|
|
// The regression this whole feature exists to prevent: a 4.2 ons fish priced per ons
|
|
// must not be billed as a single ons.
|
|
func TestCalculateTotalPriceForWeighedLine(t *testing.T) {
|
|
item := OrderItem{Quantity: 1, Weight: weightPtr(4.2), UnitPrice: 4500, UnitCost: 3000}
|
|
item.CalculateTotalPrice()
|
|
item.CalculateTotalCost()
|
|
|
|
if item.TotalPrice != 18900 {
|
|
t.Errorf("TotalPrice = %v, want 18900", item.TotalPrice)
|
|
}
|
|
if item.TotalCost != 12600 {
|
|
t.Errorf("TotalCost = %v, want 12600", item.TotalCost)
|
|
}
|
|
}
|
|
|
|
func TestCalculateTotalPriceForUnitLine(t *testing.T) {
|
|
item := OrderItem{Quantity: 3, UnitPrice: 25000, UnitCost: 10000}
|
|
item.CalculateTotalPrice()
|
|
item.CalculateTotalCost()
|
|
|
|
if item.TotalPrice != 75000 {
|
|
t.Errorf("TotalPrice = %v, want 75000", item.TotalPrice)
|
|
}
|
|
if item.TotalCost != 30000 {
|
|
t.Errorf("TotalCost = %v, want 30000", item.TotalCost)
|
|
}
|
|
}
|
|
|
|
// Sub-rupiah residue must not survive into a decimal(10,2) column.
|
|
func TestCalculateTotalPriceRoundsToStoredPrecision(t *testing.T) {
|
|
item := OrderItem{Quantity: 1, Weight: weightPtr(4.237), UnitPrice: 4500}
|
|
item.CalculateTotalPrice()
|
|
|
|
if item.TotalPrice != 19066.5 {
|
|
t.Errorf("TotalPrice = %v, want 19066.5", item.TotalPrice)
|
|
}
|
|
}
|
|
|
|
func TestIsWeighed(t *testing.T) {
|
|
if (&OrderItem{Quantity: 1}).IsWeighed() {
|
|
t.Error("unit line reported as weighed")
|
|
}
|
|
if !(&OrderItem{Quantity: 1, Weight: weightPtr(1.5)}).IsWeighed() {
|
|
t.Error("weighed line reported as unit")
|
|
}
|
|
}
|
|
|
|
func TestRoundWeight(t *testing.T) {
|
|
tests := []struct {
|
|
in float64
|
|
want float64
|
|
}{
|
|
{4.2, 4.2},
|
|
{4.2374, 4.237},
|
|
{4.2375, 4.238},
|
|
{0.0004, 0},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
if got := RoundWeight(tt.in); got != tt.want {
|
|
t.Errorf("RoundWeight(%v) = %v, want %v", tt.in, got, tt.want)
|
|
}
|
|
}
|
|
}
|