feat(member): back the overview with a keyset-paginated :overview read action

test/mv_web/member_live/index_cycle_status_filter_test.exs

@@ -0,0 +1,78 @@
+defmodule MvWeb.MemberLive.IndexCycleStatusFilterTest do
+  @moduledoc """
+  §1.13 — the paid/unpaid cycle-status filter, under the current or last-completed
+  cycle view, returns the same members as the previous in-memory classifier,
+  computed DB-side via the `cycle_end`-backed aggregates.
+  """
+  use Mv.DataCase, async: false
+
+  import Mv.Fixtures, only: [create_fee_type: 2, member_fixture_with_actor: 2, create_cycle: 4]
+
+  alias Mv.Membership.Member
+  alias MvWeb.MemberLive.Index.MembershipFeeStatus
+  alias MvWeb.MemberLive.Index.OverviewQuery
+
+  @today ~D[2024-07-15]
+
+  setup do
+    actor = Mv.Helpers.SystemActor.get_system_actor()
+    ft = create_fee_type(%{interval: :yearly}, actor)
+
+    # current 2024 paid, last-completed 2023 unpaid
+    paid_now = member_fixture_with_actor(%{membership_fee_type_id: ft.id}, actor)
+    create_cycle(paid_now, ft, %{cycle_start: ~D[2024-01-01], status: :paid}, actor)
+    create_cycle(paid_now, ft, %{cycle_start: ~D[2023-01-01], status: :unpaid}, actor)
+
+    # current 2024 unpaid, last-completed 2023 paid
+    unpaid_now = member_fixture_with_actor(%{membership_fee_type_id: ft.id}, actor)
+    create_cycle(unpaid_now, ft, %{cycle_start: ~D[2024-01-01], status: :unpaid}, actor)
+    create_cycle(unpaid_now, ft, %{cycle_start: ~D[2023-01-01], status: :paid}, actor)
+
+    # no cycles
+    _no_cycles = member_fixture_with_actor(%{membership_fee_type_id: ft.id}, actor)
+
+    %{actor: actor, paid_now: paid_now, unpaid_now: unpaid_now}
+  end
+
+  defp db_ids(status, show_current, actor) do
+    OverviewQuery.build(%{
+      cycle_status_filter: status,
+      show_current_cycle: show_current,
+      today: @today
+    })
+    |> Ash.read!(actor: actor)
+    |> MapSet.new(& &1.id)
+  end
+
+  defp oracle_ids(status, show_current, actor) do
+    Member
+    |> Ash.Query.load(membership_fee_cycles: [:membership_fee_type])
+    |> Ash.Query.load(:membership_fee_type)
+    |> Ash.read!(actor: actor)
+    |> Enum.filter(fn m ->
+      MembershipFeeStatus.get_cycle_status_for_member(m, show_current, @today) == status
+    end)
+    |> MapSet.new(& &1.id)
+  end
+
+  # {status, show_current, member-key expected in the result}
+  @cases [
+    {:paid, true, :paid_now},
+    {:unpaid, true, :unpaid_now},
+    {:paid, false, :unpaid_now},
+    {:unpaid, false, :paid_now}
+  ]
+
+  for {status, show_current, expected_key} <- @cases do
+    test "#{status} under #{if show_current, do: "current", else: "last"} cycle matches oracle",
+         %{actor: actor} = ctx do
+      status = unquote(status)
+      show_current = unquote(show_current)
+      expected = Map.fetch!(ctx, unquote(expected_key))
+
+      db = db_ids(status, show_current, actor)
+      assert db == oracle_ids(status, show_current, actor)
+      assert expected.id in db
+    end
+  end
+end

test/mv_web/member_live/index_keyset_property_test.exs

@@ -0,0 +1,86 @@
+defmodule MvWeb.MemberLive.IndexKeysetPropertyTest do
+  @moduledoc """
+  §2.2 — Keyset pagination completeness: concatenating every keyset page yields
+  exactly the full filtered set once each (no duplicates, no gaps) in a stable
+  total order.
+
+  §2.3 — Sort determinism with the unique `id` tie-breaker: members equal on the
+  sort key are ordered by `id`, and the result set equals the unsorted set.
+  """
+  use Mv.DataCase, async: false
+  use ExUnitProperties
+
+  import Mv.Fixtures, only: [member_fixture_with_actor: 2]
+
+  alias Mv.Membership.Member
+  alias MvWeb.MemberLive.Index.OverviewQuery
+
+  setup do
+    %{actor: Mv.Helpers.SystemActor.get_system_actor()}
+  end
+
+  defp clear_members(actor) do
+    Member |> Ash.read!(actor: actor) |> Enum.each(&Ash.destroy!(&1, actor: actor))
+  end
+
+  defp read_all_pages(query, actor, limit) do
+    page = Ash.read!(query, page: [limit: limit], actor: actor)
+    collect(page, page.results)
+  end
+
+  defp collect(%{more?: true} = page, acc) do
+    next = Ash.page!(page, :next)
+    collect(next, acc ++ next.results)
+  end
+
+  defp collect(_page, acc), do: acc
+
+  property "keyset pages cover the full set once, no dupes or gaps", %{actor: actor} do
+    check all(
+            n <- integer(1..12),
+            limit <- integer(1..5),
+            sort <- member_of([:last_name, :join_date, :inserted_at]),
+            order <- member_of([:asc, :desc]),
+            max_runs: 25
+          ) do
+      clear_members(actor)
+      # Deliberate ties on last_name so the tie-breaker is exercised.
+      members =
+        for i <- 1..n do
+          member_fixture_with_actor(%{last_name: "Tie#{rem(i, 3)}"}, actor)
+        end
+
+      expected = MapSet.new(members, & &1.id)
+
+      query = OverviewQuery.build(%{sort_field: sort, sort_order: order})
+      paged = read_all_pages(query, actor, limit)
+      paged_ids = Enum.map(paged, & &1.id)
+
+      assert MapSet.new(paged_ids) == expected
+      assert length(paged_ids) == MapSet.size(expected)
+    end
+  end
+
+  property "sort with ties is a deterministic total order broken by id", %{actor: actor} do
+    check all(
+            n <- integer(2..10),
+            order <- member_of([:asc, :desc]),
+            max_runs: 25
+          ) do
+      clear_members(actor)
+
+      members =
+        for _ <- 1..n do
+          member_fixture_with_actor(%{last_name: "Same"}, actor)
+        end
+
+      ordered =
+        OverviewQuery.build(%{sort_field: :last_name, sort_order: order})
+        |> Ash.read!(actor: actor)
+        |> Enum.map(& &1.id)
+
+      # All last_names equal -> order is fully determined by the id tie-breaker (asc).
+      assert ordered == Enum.sort(Enum.map(members, & &1.id))
+    end
+  end
+end