From e4e805d139e7e403becf5d41f66709bc3b4c26c7 Mon Sep 17 00:00:00 2001 From: Angel Beltran Date: Thu, 6 Aug 2026 19:47:09 -0600 Subject: [PATCH] reports: add test coverage for GetListingCountsOverTime/Report mock.shop_amazon_listing_counts is a recursive view that computes a running inventory count: starting from the listing's base count in mock.shop_amazon_listings, it walks mock.raw_shop_events in order, applying each event as a delta (sale/refund) or an absolute reset (inventory-reset), per mock.shop_amazon_listing_event_sequence's interpretation of each row's JSON payload. This is the first test to exercise that view directly rather than just the Go code around it. Fixture uses the real SaveNewMockSale/SaveNewMockRefund/ SaveNewMockInventoryReset methods - the same entry points the simulate-sale/refund/inventory UI uses - rather than hand-rolling the JSON payload shape, so the test tracks the real payload contract. Covers the full running-count sequence (base -> sale -> refund -> reset), the unknown-listing ErrNotFound case, and GetListingCountsReport's MaxCount/MinCount over that sequence. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01XEDaCB7C2NEBgyvqEtZuxY --- domains/reports/reports_test.go | 149 ++++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) create mode 100644 domains/reports/reports_test.go diff --git a/domains/reports/reports_test.go b/domains/reports/reports_test.go new file mode 100644 index 0000000..021452d --- /dev/null +++ b/domains/reports/reports_test.go @@ -0,0 +1,149 @@ +package reports_test + +import ( + "context" + "errors" + "testing" + + "ruben/inventory2/consts" + "ruben/inventory2/domains/accounts" + "ruben/inventory2/domains/reports" + "ruben/inventory2/internal/testdb" +) + +// createAmazonListing creates a listing with the given base count in +// shopID and registers its cleanup. Must be called after +// setupAmazonMockShop, so cleanup order (LIFO) deletes the listing before +// the shop it belongs to. +func createAmazonListing(t *testing.T, acctStore *accounts.Store, acctID int64, shopID string, baseCount int64) (listingID string) { + t.Helper() + ctx := context.Background() + + pool := testdb.Pool(t) + + listing, err := acctStore.CreateMockListing(ctx, accounts.MockListing{ + AccountShopListingIDs: accounts.AccountShopListingIDs{ + AccountShopIDs: accounts.AccountShopIDs{ + AccountIDs: accounts.AccountIDs{AccountID: acctID}, + Platform: accounts.Amazon, + ShopID: shopID, + }, + }, + SKU: "test-sku", + Name: "Test Listing", + Description: "a listing created for a test", + Count: baseCount, + }) + if err != nil { + t.Fatalf("CreateMockListing() error = %v", err) + } + + t.Cleanup(func() { + pool.Exec(context.Background(), ` + DELETE FROM mock.shop_amazon_listings WHERE shop_id = $1 AND listing_id = $2 + `, shopID, listing.ListingID) + }) + + return listing.ListingID +} + +// TestGetListingCountsOverTime exercises the actual running-count logic, +// which lives in a recursive SQL view (mock.shop_amazon_listing_counts, +// built on mock.shop_amazon_listing_event_sequence) rather than in Go: it +// starts from the listing's base count and walks mock.raw_shop_events in +// order, applying each as a delta (sale/refund) or an absolute reset +// (inventory-reset). Uses the real SaveNewMock* methods to write those +// events, the same entry points the simulate-sale/refund/inventory UI +// uses, rather than hand-rolling the JSON payload shape. +func TestGetListingCountsOverTime(t *testing.T) { + pool := testdb.Pool(t) + acctStore := accounts.NewStore(testdb.Logger(), pool) + reportsStore := reports.NewStore(testdb.Logger(), pool, acctStore) + ctx := context.Background() + + acctID, shopID := setupAmazonMockShop(t, pool, acctStore) + listingID := createAmazonListing(t, acctStore, acctID, shopID, 100) + + if _, err := acctStore.SaveNewMockSale(ctx, acctID, accounts.Amazon, shopID, listingID, 10); err != nil { + t.Fatalf("SaveNewMockSale() error = %v", err) + } + if _, err := acctStore.SaveNewMockRefund(ctx, acctID, accounts.Amazon, shopID, listingID, 5); err != nil { + t.Fatalf("SaveNewMockRefund() error = %v", err) + } + if _, err := acctStore.SaveNewMockInventoryReset(ctx, acctID, accounts.Amazon, shopID, listingID, 50); err != nil { + t.Fatalf("SaveNewMockInventoryReset() error = %v", err) + } + + got, err := reportsStore.GetListingCountsOverTime(ctx, acctID, accounts.Amazon, shopID, listingID) + if err != nil { + t.Fatalf("GetListingCountsOverTime() error = %v", err) + } + + wantCounts := []int64{100, 110, 105, 50} + if len(got) != len(wantCounts) { + t.Fatalf("GetListingCountsOverTime() returned %d rows, want %d: %+v", len(got), len(wantCounts), got) + } + + if got[0].EventTimestamp != nil { + t.Errorf("got[0].EventTimestamp = %v, want nil (the base count row)", got[0].EventTimestamp) + } + for i, row := range got { + if row.Count != wantCounts[i] { + t.Errorf("got[%d].Count = %d, want %d (full sequence: %+v)", i, row.Count, wantCounts[i], got) + } + } + for i := 1; i < len(got); i++ { + if got[i].EventTimestamp == nil { + t.Errorf("got[%d].EventTimestamp = nil, want set (only the base row should be nil)", i) + } + } +} + +func TestGetListingCountsOverTime_UnknownListing(t *testing.T) { + pool := testdb.Pool(t) + acctStore := accounts.NewStore(testdb.Logger(), pool) + reportsStore := reports.NewStore(testdb.Logger(), pool, acctStore) + ctx := context.Background() + + acctID, shopID := setupAmazonMockShop(t, pool, acctStore) + + _, err := reportsStore.GetListingCountsOverTime(ctx, acctID, accounts.Amazon, shopID, "no-such-listing") + if !errors.Is(err, consts.ErrNotFound) { + t.Fatalf("GetListingCountsOverTime() error = %v, want %v", err, consts.ErrNotFound) + } +} + +func TestGetListingCountsReport(t *testing.T) { + pool := testdb.Pool(t) + acctStore := accounts.NewStore(testdb.Logger(), pool) + reportsStore := reports.NewStore(testdb.Logger(), pool, acctStore) + ctx := context.Background() + + acctID, shopID := setupAmazonMockShop(t, pool, acctStore) + listingID := createAmazonListing(t, acctStore, acctID, shopID, 100) + + if _, err := acctStore.SaveNewMockSale(ctx, acctID, accounts.Amazon, shopID, listingID, 10); err != nil { + t.Fatalf("SaveNewMockSale() error = %v", err) + } + if _, err := acctStore.SaveNewMockInventoryReset(ctx, acctID, accounts.Amazon, shopID, listingID, 20); err != nil { + t.Fatalf("SaveNewMockInventoryReset() error = %v", err) + } + + report, err := reportsStore.GetListingCountsReport(ctx, acctID, accounts.Amazon, shopID, listingID) + if err != nil { + t.Fatalf("GetListingCountsReport() error = %v", err) + } + + if report.AccountID != acctID || report.Platform != accounts.Amazon || report.ShopID != shopID || report.ListingID != listingID { + t.Errorf("report identity = %+v, want AccountID=%d Platform=%s ShopID=%s ListingID=%s", + report, acctID, accounts.Amazon, shopID, listingID) + } + + // counts over the sequence: 100 (base) -> 110 (sale +10) -> 20 (reset) + if got := report.MaxCount().Count; got != 110 { + t.Errorf("MaxCount().Count = %d, want 110", got) + } + if got := report.MinCount().Count; got != 20 { + t.Errorf("MinCount().Count = %d, want 20", got) + } +}