refactor(member-live): modularize the overview and drop the superseded in-memory paths

Extract the cookie parser, export-payload builder and fee-status helper
into their own modules and remove the filter/sort/load helpers the
database pushdown made dead, so the overview LiveView stays a thin
coordinator over focused units.

test/mv_web/live/member_live/index/cookie_test.exs

@@ -0,0 +1,22 @@
+defmodule MvWeb.MemberLive.Index.CookieTest do
+  @moduledoc """
+  Tests for the shared cookie-header parser used by the overview persistence chain.
+  """
+  use ExUnit.Case, async: true
+
+  alias MvWeb.MemberLive.Index.Cookie
+
+  describe "parse_header/1" do
+    test "splits pairs and URL-decodes values" do
+      assert Cookie.parse_header("a=1; b=hello%20world") == %{"a" => "1", "b" => "hello world"}
+    end
+
+    test "maps a valueless entry to an empty string" do
+      assert Cookie.parse_header("flag; a=1") == %{"flag" => "", "a" => "1"}
+    end
+
+    test "keeps only the first '=' as the separator" do
+      assert Cookie.parse_header("token=a=b=c") == %{"token" => "a=b=c"}
+    end
+  end
+end

test/mv_web/live/member_live/index/export_payload_test.exs

@@ -0,0 +1,87 @@
+defmodule MvWeb.MemberLive.Index.ExportPayloadTest do
+  @moduledoc """
+  Tests for the member-overview export descriptor builder: the column order it
+  emits must mirror the rendered table (DB fields in constants order, fee
+  type/status after the fee start date, groups before custom fields), and the
+  filter/sort/selection state must be serialized faithfully.
+  """
+  use ExUnit.Case, async: true
+
+  alias MvWeb.MemberLive.Index.ExportPayload
+
+  defp custom_field(id), do: %{id: id}
+
+  describe "build/1" do
+    test "orders columns like the table: db fields, fee type/status, groups, custom fields" do
+      assigns = %{
+        selected_members: MapSet.new(["m1", "m2"]),
+        member_fields_visible_db: [:first_name, :membership_fee_start_date, :last_name],
+        member_fields_visible_computed: [:membership_fee_status],
+        member_fields_visible: [
+          :first_name,
+          :last_name,
+          :membership_fee_start_date,
+          :membership_fee_type,
+          :membership_fee_status,
+          :groups
+        ],
+        visible_custom_field_ids: ["cf-a"],
+        all_custom_fields: [custom_field("cf-a"), custom_field("cf-b")],
+        query: "ada",
+        sort_field: :last_name,
+        sort_order: :desc,
+        show_current_cycle: true,
+        cycle_status_filter: :unpaid,
+        boolean_custom_field_filters: %{"cf-x" => true}
+      }
+
+      payload = ExportPayload.build(assigns)
+
+      # DB fields follow Mv.Constants.member_fields/0 order (first_name, last_name,
+      # then membership_fee_start_date), membership_fee_type + status are inserted
+      # right after the fee start date, groups precede the custom fields, and custom
+      # fields keep table order (only visible ones).
+      assert payload.column_order == [
+               "first_name",
+               "last_name",
+               "membership_fee_start_date",
+               "membership_fee_type",
+               "membership_fee_status",
+               "groups",
+               "cf-a"
+             ]
+
+      assert Enum.sort(payload.selected_ids) == ["m1", "m2"]
+      assert payload.custom_field_ids == ["cf-a"]
+      assert payload.query == "ada"
+      assert payload.sort_field == "last_name"
+      assert payload.sort_order == "desc"
+      assert payload.show_current_cycle == true
+      assert payload.cycle_status_filter == "unpaid"
+      assert payload.boolean_filters == %{"cf-x" => true}
+    end
+
+    test "defaults optional state and omits groups/custom fields when not visible" do
+      assigns = %{
+        selected_members: MapSet.new(),
+        member_fields_visible_db: [:first_name],
+        member_fields_visible_computed: [],
+        member_fields_visible: [:first_name],
+        visible_custom_field_ids: [],
+        all_custom_fields: [custom_field("cf-a")]
+      }
+
+      payload = ExportPayload.build(assigns)
+
+      assert payload.column_order == ["first_name"]
+      assert payload.selected_ids == []
+      assert payload.custom_field_ids == []
+      assert payload.query == nil
+      assert payload.sort_field == nil
+      assert payload.sort_order == nil
+      assert payload.show_current_cycle == false
+      assert payload.cycle_status_filter == nil
+      assert payload.boolean_filters == %{}
+    end
+  end
+end

test/mv_web/live/member_live/index/field_visibility_test.exs

@@ -6,201 +6,6 @@ defmodule MvWeb.MemberLive.Index.FieldVisibilityTest do
 
   alias MvWeb.MemberLive.Index.FieldVisibility
 
-  # Mock custom field structs for testing
-  defp create_custom_field(id, name, show_in_overview \\ true) do
-    %{
-      id: id,
-      name: name,
-      show_in_overview: show_in_overview
-    }
-  end
-
-  describe "get_all_available_fields/1" do
-    test "returns member fields and custom fields" do
-      custom_fields = [
-        create_custom_field("cf1", "Custom Field 1"),
-        create_custom_field("cf2", "Custom Field 2")
-      ]
-
-      result = FieldVisibility.get_all_available_fields(custom_fields)
-
-      # Should include all member fields
-      assert :first_name in result
-      assert :email in result
-      assert :street in result
-
-      # Should include custom fields as strings
-      assert "custom_field_cf1" in result
-      assert "custom_field_cf2" in result
-    end
-
-    test "handles empty custom fields list" do
-      result = FieldVisibility.get_all_available_fields([])
-
-      # Should only have member fields
-      assert :first_name in result
-      assert :email in result
-
-      refute Enum.any?(result, fn field ->
-               is_binary(field) and String.starts_with?(field, "custom_field_")
-             end)
-    end
-
-    test "includes all member fields from constants" do
-      custom_fields = []
-      result = FieldVisibility.get_all_available_fields(custom_fields)
-
-      member_fields = Mv.Constants.member_fields()
-
-      Enum.each(member_fields, fn field ->
-        assert field in result
-      end)
-    end
-
-    test "includes pseudo member fields (membership_fee_status, membership_fee_type, groups)" do
-      result = FieldVisibility.get_all_available_fields([])
-
-      assert :membership_fee_status in result
-      assert :membership_fee_type in result
-      assert :groups in result
-    end
-  end
-
-  describe "merge_with_global_settings/3" do
-    test "user selection overrides global settings" do
-      user_selection = %{"first_name" => false}
-      settings = %{member_field_visibility: %{first_name: true, email: true}}
-      custom_fields = []
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      assert result["first_name"] == false
-      assert result["email"] == true
-    end
-
-    test "falls back to global settings when user selection is empty" do
-      user_selection = %{}
-      settings = %{member_field_visibility: %{first_name: false, email: true}}
-      custom_fields = []
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      assert result["first_name"] == false
-      assert result["email"] == true
-    end
-
-    test "defaults to the curated set when field not in settings" do
-      user_selection = %{}
-      settings = %{member_field_visibility: %{join_date: false}}
-      custom_fields = []
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      # join_date from settings overrides its curated default
-      assert result["join_date"] == false
-      # name is in the curated default set -> visible
-      assert result["name"] == true
-      # email is not in the curated default set -> hidden
-      assert result["email"] == false
-    end
-
-    test "handles custom fields visibility" do
-      user_selection = %{}
-      settings = %{member_field_visibility: %{}}
-
-      custom_fields = [
-        create_custom_field("cf1", "Custom 1", true),
-        create_custom_field("cf2", "Custom 2", false)
-      ]
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      assert result["custom_field_cf1"] == true
-      assert result["custom_field_cf2"] == false
-    end
-
-    test "user selection overrides custom field visibility" do
-      user_selection = %{"custom_field_cf1" => false}
-      settings = %{member_field_visibility: %{}}
-
-      custom_fields = [
-        create_custom_field("cf1", "Custom 1", true)
-      ]
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      assert result["custom_field_cf1"] == false
-    end
-
-    test "handles string keys in settings (JSONB format)" do
-      user_selection = %{}
-      settings = %{member_field_visibility: %{"first_name" => false, "email" => true}}
-      custom_fields = []
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      assert result["first_name"] == false
-      assert result["email"] == true
-    end
-
-    test "handles mixed atom and string keys in settings" do
-      user_selection = %{}
-      # Use string keys only (as JSONB would return)
-      settings = %{member_field_visibility: %{"first_name" => false, "email" => true}}
-      custom_fields = []
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      assert result["first_name"] == false
-      assert result["email"] == true
-    end
-
-    test "handles nil settings gracefully" do
-      user_selection = %{}
-      settings = %{member_field_visibility: nil}
-      custom_fields = []
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      # Falls back to the curated default set (no crash on nil)
-      assert result["join_date"] == true
-      assert result["email"] == false
-    end
-
-    test "handles missing member_field_visibility key" do
-      user_selection = %{}
-      settings = %{}
-      custom_fields = []
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      # Falls back to the curated default set
-      assert result["join_date"] == true
-      assert result["email"] == false
-    end
-
-    test "includes all fields in result" do
-      user_selection = %{"first_name" => false}
-      settings = %{member_field_visibility: %{email: true}}
-
-      custom_fields = [
-        create_custom_field("cf1", "Custom 1", true)
-      ]
-
-      result = FieldVisibility.merge_with_global_settings(user_selection, settings, custom_fields)
-
-      # Should include all member fields
-      member_fields = Mv.Constants.member_fields()
-
-      Enum.each(member_fields, fn field ->
-        assert Map.has_key?(result, Atom.to_string(field))
-      end)
-
-      # Should include custom fields
-      assert Map.has_key?(result, "custom_field_cf1")
-    end
-  end
-
   describe "offered_member_fields/3 ordering (name group, then email, then address group, then rest)" do
     test "compact member + compact address: Name, E-Mail, Adresse lead" do
       result = FieldVisibility.offered_member_fields(true, false, true)
@@ -251,55 +56,6 @@ defmodule MvWeb.MemberLive.Index.FieldVisibilityTest do
 
   defp index_of(list, elem), do: Enum.find_index(list, &(&1 == elem))
 
-  describe "get_visible_fields/1" do
-    test "returns only fields with true visibility" do
-      selection = %{
-        "first_name" => true,
-        "email" => false,
-        "street" => true,
-        "custom_field_123" => false
-      }
-
-      result = FieldVisibility.get_visible_fields(selection)
-
-      assert :first_name in result
-      assert :street in result
-      refute :email in result
-      refute "custom_field_123" in result
-    end
-
-    test "converts member field strings to atoms" do
-      selection = %{"first_name" => true, "email" => true}
-
-      result = FieldVisibility.get_visible_fields(selection)
-
-      assert :first_name in result
-      assert :email in result
-    end
-
-    test "keeps custom fields as strings" do
-      selection = %{"custom_field_abc-123" => true}
-
-      result = FieldVisibility.get_visible_fields(selection)
-
-      assert "custom_field_abc-123" in result
-    end
-
-    test "handles empty selection" do
-      assert FieldVisibility.get_visible_fields(%{}) == []
-    end
-
-    test "handles all fields hidden" do
-      selection = %{"first_name" => false, "email" => false}
-
-      assert FieldVisibility.get_visible_fields(selection) == []
-    end
-
-    test "handles invalid input" do
-      assert FieldVisibility.get_visible_fields(nil) == []
-    end
-  end
-
   describe "get_visible_member_fields/1" do
     test "returns only member fields that are visible" do
       selection = %{

test/mv_web/live/member_live/index/membership_fee_status_test.exs

@@ -6,7 +6,6 @@ defmodule MvWeb.MemberLive.Index.MembershipFeeStatusTest do
 
   import Mv.Fixtures, only: [create_fee_type: 1, create_cycle: 3]
 
-  alias Mv.Membership.Member
   alias MvWeb.MemberLive.Index.MembershipFeeStatus
 
   require Ash.Query
@@ -26,35 +25,6 @@ defmodule MvWeb.MemberLive.Index.MembershipFeeStatusTest do
     member
   end
 
-  describe "load_cycles_for_members/2" do
-    test "efficiently loads cycles for members" do
-      fee_type = create_fee_type(%{interval: :yearly})
-
-      member1 = create_member(%{membership_fee_type_id: fee_type.id})
-      member2 = create_member(%{membership_fee_type_id: fee_type.id})
-
-      create_cycle(member1, fee_type, %{cycle_start: ~D[2023-01-01], status: :paid})
-      create_cycle(member2, fee_type, %{cycle_start: ~D[2023-01-01], status: :unpaid})
-
-      query =
-        Member
-        |> Ash.Query.filter(id in [^member1.id, ^member2.id])
-        |> MembershipFeeStatus.load_cycles_for_members()
-
-      system_actor = Mv.Helpers.SystemActor.get_system_actor()
-      members = Ash.read!(query, actor: system_actor)
-
-      assert length(members) == 2
-
-      # Verify cycles are loaded
-      member1_loaded = Enum.find(members, &(&1.id == member1.id))
-      member2_loaded = Enum.find(members, &(&1.id == member2.id))
-
-      assert member1_loaded.membership_fee_cycles != nil
-      assert member2_loaded.membership_fee_cycles != nil
-    end
-  end
-
   describe "get_cycle_status_for_member/2" do
     test "returns status of last completed cycle" do
       fee_type = create_fee_type(%{interval: :yearly})
@@ -339,27 +309,5 @@ defmodule MvWeb.MemberLive.Index.MembershipFeeStatusTest do
       assert length(filtered) == 1
       assert List.first(filtered).id == member2.id
     end
-
-    test "returns all members when filter is nil" do
-      fee_type = create_fee_type(%{interval: :yearly})
-      member1 = create_member(%{membership_fee_type_id: fee_type.id})
-      member2 = create_member(%{membership_fee_type_id: fee_type.id})
-
-      system_actor = Mv.Helpers.SystemActor.get_system_actor()
-
-      members =
-        [member1, member2]
-        |> Enum.map(fn m ->
-          m
-          |> Ash.load!([membership_fee_cycles: [:membership_fee_type]], actor: system_actor)
-          |> Ash.load!(:membership_fee_type, actor: system_actor)
-        end)
-
-      # filter_unpaid_members should still work for backwards compatibility
-      filtered = MembershipFeeStatus.filter_unpaid_members(members, false)
-
-      # Both members have no cycles, so both should be filtered out
-      assert Enum.empty?(filtered)
-    end
   end
 end

test/mv_web/member_live/index_membership_fee_status_test.exs

@@ -95,6 +95,9 @@ defmodule MvWeb.MemberLive.IndexMembershipFeeStatusTest do
       html = render(view)
       # Should show suspended status (current cycle)
       assert html =~ "hero-pause-circle" || html =~ "suspended"
+
+      # The toggle button exposes its pressed state to assistive tech.
+      assert has_element?(view, ~s([data-testid=toggle-cycle-view][aria-pressed="true"]))
     end
 
     test "shows correct color coding for paid status", %{conn: conn} do

test/mv_web/member_live/index_pagination_test.exs

@@ -8,10 +8,10 @@ defmodule MvWeb.MemberLive.IndexPaginationTest do
 
   import Phoenix.LiveViewTest
 
-  require Ash.Query
-
   alias Mv.Helpers.SystemActor
 
+  require Ash.Query
+
   # Matches the :overview default_limit / @page_limit in the LiveView.
   @page_limit 50
 

test/mv_web/member_live/index_test.exs

@@ -708,27 +708,6 @@ defmodule MvWeb.MemberLive.IndexTest do
       # Flash message should appear
       assert has_element?(view, "#flash-group")
     end
-
-    test "copy excludes a member whose email is blank from the recipient list", %{conn: conn} do
-      # The Member create action requires an email, so a blank-email member cannot
-      # be persisted; we exercise the preserved defensive filter in
-      # format_selected_member_emails/2 directly. One member has an email, the
-      # other has a blank one — only the former is a recipient (§1.10).
-      with_email = %{
-        id: Ecto.UUID.generate(),
-        first_name: "Has",
-        last_name: "Mail",
-        email: "has@example.com"
-      }
-
-      blank_email = %{id: Ecto.UUID.generate(), first_name: "Blank", last_name: "Mail", email: ""}
-      selected = MapSet.new([with_email.id, blank_email.id])
-
-      emails = MemberIndex.format_selected_member_emails([with_email, blank_email], selected)
-
-      assert emails == ["Has Mail <has@example.com>"]
-      _ = conn
-    end
   end
 
   describe "copy_emails empty-recipient feedback" do
@@ -1800,153 +1779,6 @@ defmodule MvWeb.MemberLive.IndexTest do
       |> Ash.load!(:custom_field_values, actor: actor)
     end
 
-    # Tests for get_boolean_custom_field_value/2
-    test "get_boolean_custom_field_value extracts true from Ash.Union format", %{conn: _conn} do
-      system_actor = SystemActor.get_system_actor()
-      boolean_field = create_boolean_custom_field()
-      member = create_member_with_boolean_value(%{}, boolean_field, true, system_actor)
-
-      # Test the function (will fail until implemented)
-      result = MemberIndex.get_boolean_custom_field_value(member, boolean_field)
-
-      assert result == true
-    end
-
-    test "get_boolean_custom_field_value extracts false from Ash.Union format", %{conn: _conn} do
-      system_actor = SystemActor.get_system_actor()
-      boolean_field = create_boolean_custom_field()
-      member = create_member_with_boolean_value(%{}, boolean_field, false, system_actor)
-
-      result = MemberIndex.get_boolean_custom_field_value(member, boolean_field)
-
-      assert result == false
-    end
-
-    test "get_boolean_custom_field_value extracts true from map format with _union_type and _union_value keys",
-         %{conn: _conn} do
-      system_actor = SystemActor.get_system_actor()
-      boolean_field = create_boolean_custom_field()
-
-      {:ok, member} =
-        Membership.create_member(
-          %{
-            first_name: "Test",
-            last_name: "Member",
-            email: "test.member.#{System.unique_integer([:positive])}@example.com"
-          },
-          actor: system_actor
-        )
-
-      # Create CustomFieldValue with map format (Ash expects _union_type and _union_value)
-      {:ok, _cfv} =
-        CustomFieldValue
-        |> Ash.Changeset.for_create(:create, %{
-          member_id: member.id,
-          custom_field_id: boolean_field.id,
-          value: %{"_union_type" => "boolean", "_union_value" => true}
-        })
-        |> Ash.create(actor: system_actor)
-
-      # Reload member with custom field values
-      member = member |> Ash.load!(:custom_field_values, actor: system_actor)
-
-      result = MemberIndex.get_boolean_custom_field_value(member, boolean_field)
-
-      assert result == true
-    end
-
-    test "get_boolean_custom_field_value returns nil when no CustomFieldValue exists", %{
-      conn: _conn
-    } do
-      system_actor = SystemActor.get_system_actor()
-      boolean_field = create_boolean_custom_field()
-
-      {:ok, member} =
-        Membership.create_member(
-          %{
-            first_name: "Test",
-            last_name: "Member",
-            email: "test.member.#{System.unique_integer([:positive])}@example.com"
-          },
-          actor: system_actor
-        )
-
-      # Member has no custom field value for this field
-      member = member |> Ash.load!(:custom_field_values, actor: system_actor)
-
-      result = MemberIndex.get_boolean_custom_field_value(member, boolean_field)
-
-      assert result == nil
-    end
-
-    test "get_boolean_custom_field_value returns nil when CustomFieldValue has nil value", %{
-      conn: _conn
-    } do
-      system_actor = SystemActor.get_system_actor()
-      boolean_field = create_boolean_custom_field()
-
-      {:ok, member} =
-        Membership.create_member(
-          %{
-            first_name: "Test",
-            last_name: "Member",
-            email: "test.member.#{System.unique_integer([:positive])}@example.com"
-          },
-          actor: system_actor
-        )
-
-      # Create CustomFieldValue with nil value (edge case)
-      {:ok, _cfv} =
-        CustomFieldValue
-        |> Ash.Changeset.for_create(:create, %{
-          member_id: member.id,
-          custom_field_id: boolean_field.id,
-          value: nil
-        })
-        |> Ash.create(actor: system_actor)
-
-      member = member |> Ash.load!(:custom_field_values, actor: system_actor)
-
-      result = MemberIndex.get_boolean_custom_field_value(member, boolean_field)
-
-      assert result == nil
-    end
-
-    test "get_boolean_custom_field_value returns nil for non-boolean CustomFieldValue", %{
-      conn: _conn
-    } do
-      system_actor = SystemActor.get_system_actor()
-      string_field = create_string_custom_field()
-      boolean_field = create_boolean_custom_field()
-
-      {:ok, member} =
-        Membership.create_member(
-          %{
-            first_name: "Test",
-            last_name: "Member",
-            email: "test.member.#{System.unique_integer([:positive])}@example.com"
-          },
-          actor: system_actor
-        )
-
-      # Create string custom field value (not boolean)
-      {:ok, _cfv} =
-        CustomFieldValue
-        |> Ash.Changeset.for_create(:create, %{
-          member_id: member.id,
-          custom_field_id: string_field.id,
-          value: %{"_union_type" => "string", "_union_value" => "test"}
-        })
-        |> Ash.create(actor: system_actor)
-
-      member = member |> Ash.load!(:custom_field_values, actor: system_actor)
-
-      # Try to get boolean value from string field - should return nil
-      result = MemberIndex.get_boolean_custom_field_value(member, boolean_field)
-
-      assert result == nil
-    end
-
     # Tests for apply_boolean_custom_field_filters/2
     test "apply_boolean_custom_field_filters filters members with true value and excludes false/without values",
          %{conn: _conn} do