Merge branch 'main' into feature/223_memberfields_settings

test/mv_web/components/payment_filter_component_test.exs

@@ -3,7 +3,7 @@ defmodule MvWeb.Components.PaymentFilterComponentTest do
   Unit tests for the PaymentFilterComponent.
 
   Tests cover:
-  - Rendering in all 3 filter states (nil, :paid, :not_paid)
+  - Rendering in all 3 filter states (nil, :paid, :unpaid)
   - Event emission when selecting options
   - ARIA attributes for accessibility
   - Dropdown open/close behavior
@@ -25,15 +25,15 @@ defmodule MvWeb.Components.PaymentFilterComponentTest do
 
     test "renders with paid filter active", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
-      {:ok, view, _html} = live(conn, "/members?paid_filter=paid")
+      {:ok, view, _html} = live(conn, "/members?cycle_status_filter=paid")
 
       # Should show badge when filter is active
       assert has_element?(view, "#payment-filter .badge")
     end
 
-    test "renders with not_paid filter active", %{conn: conn} do
+    test "renders with unpaid filter active", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
-      {:ok, view, _html} = live(conn, "/members?paid_filter=not_paid")
+      {:ok, view, _html} = live(conn, "/members?cycle_status_filter=unpaid")
 
       # Should show badge when filter is active
       assert has_element?(view, "#payment-filter .badge")
@@ -82,7 +82,7 @@ defmodule MvWeb.Components.PaymentFilterComponentTest do
   describe "filter selection" do
     test "selecting 'All' clears the filter and updates URL", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
-      {:ok, view, _html} = live(conn, "/members?paid_filter=paid")
+      {:ok, view, _html} = live(conn, "/members?cycle_status_filter=paid")
 
       # Open dropdown
       view
@@ -94,7 +94,7 @@ defmodule MvWeb.Components.PaymentFilterComponentTest do
       |> element("#payment-filter button[phx-value-filter='']")
       |> render_click()
 
-      # URL should not contain paid_filter param - wait for patch
+      # URL should not contain cycle_status_filter param - wait for patch
       assert_patch(view)
     end
 
@@ -112,12 +112,12 @@ defmodule MvWeb.Components.PaymentFilterComponentTest do
       |> element("#payment-filter button[phx-value-filter='paid']")
       |> render_click()
 
-      # Wait for patch and check URL contains paid_filter=paid
+      # Wait for patch and check URL contains cycle_status_filter=paid
       path = assert_patch(view)
-      assert path =~ "paid_filter=paid"
+      assert path =~ "cycle_status_filter=paid"
     end
 
-    test "selecting 'Not paid' sets the filter and updates URL", %{conn: conn} do
+    test "selecting 'Unpaid' sets the filter and updates URL", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
       {:ok, view, _html} = live(conn, "/members")
 
@@ -126,14 +126,14 @@ defmodule MvWeb.Components.PaymentFilterComponentTest do
       |> element("#payment-filter button[aria-haspopup='true']")
       |> render_click()
 
-      # Select "Not paid" option
+      # Select "Unpaid" option
       view
-      |> element("#payment-filter button[phx-value-filter='not_paid']")
+      |> element("#payment-filter button[phx-value-filter='unpaid']")
       |> render_click()
 
-      # Wait for patch and check URL contains paid_filter=not_paid
+      # Wait for patch and check URL contains cycle_status_filter=unpaid
       path = assert_patch(view)
-      assert path =~ "paid_filter=not_paid"
+      assert path =~ "cycle_status_filter=unpaid"
     end
   end
 
@@ -166,7 +166,7 @@ defmodule MvWeb.Components.PaymentFilterComponentTest do
 
     test "has aria-checked on selected option", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
-      {:ok, view, _html} = live(conn, "/members?paid_filter=paid")
+      {:ok, view, _html} = live(conn, "/members?cycle_status_filter=paid")
 
       # Open dropdown
       view

test/mv_web/helpers/membership_fee_helpers_test.exs

@@ -0,0 +1,260 @@
+defmodule MvWeb.Helpers.MembershipFeeHelpersTest do
+  @moduledoc """
+  Tests for MembershipFeeHelpers module.
+  """
+  use Mv.DataCase, async: true
+
+  require Ash.Query
+
+  alias MvWeb.Helpers.MembershipFeeHelpers
+  alias Mv.MembershipFees.CalendarCycles
+
+  describe "format_currency/1" do
+    test "formats decimal amount correctly" do
+      assert MembershipFeeHelpers.format_currency(Decimal.new("60.00")) == "60,00 €"
+      assert MembershipFeeHelpers.format_currency(Decimal.new("5.5")) == "5,50 €"
+      assert MembershipFeeHelpers.format_currency(Decimal.new("100")) == "100,00 €"
+      assert MembershipFeeHelpers.format_currency(Decimal.new("0.99")) == "0,99 €"
+    end
+  end
+
+  describe "format_interval/1" do
+    test "formats all interval types correctly" do
+      assert MembershipFeeHelpers.format_interval(:monthly) == "Monthly"
+      assert MembershipFeeHelpers.format_interval(:quarterly) == "Quarterly"
+      assert MembershipFeeHelpers.format_interval(:half_yearly) == "Half-yearly"
+      assert MembershipFeeHelpers.format_interval(:yearly) == "Yearly"
+    end
+  end
+
+  describe "format_cycle_range/2" do
+    test "formats yearly cycle range correctly" do
+      cycle_start = ~D[2024-01-01]
+      interval = :yearly
+      _cycle_end = CalendarCycles.calculate_cycle_end(cycle_start, interval)
+
+      result = MembershipFeeHelpers.format_cycle_range(cycle_start, interval)
+      assert result =~ "2024"
+      assert result =~ "01.01"
+      assert result =~ "31.12"
+    end
+
+    test "formats quarterly cycle range correctly" do
+      cycle_start = ~D[2024-01-01]
+      interval = :quarterly
+      _cycle_end = CalendarCycles.calculate_cycle_end(cycle_start, interval)
+
+      result = MembershipFeeHelpers.format_cycle_range(cycle_start, interval)
+      assert result =~ "2024"
+      assert result =~ "01.01"
+      assert result =~ "31.03"
+    end
+
+    test "formats monthly cycle range correctly" do
+      cycle_start = ~D[2024-03-01]
+      interval = :monthly
+      _cycle_end = CalendarCycles.calculate_cycle_end(cycle_start, interval)
+
+      result = MembershipFeeHelpers.format_cycle_range(cycle_start, interval)
+      assert result =~ "2024"
+      assert result =~ "01.03"
+      assert result =~ "31.03"
+    end
+  end
+
+  describe "get_last_completed_cycle/2" do
+    test "returns last completed cycle for member" do
+      # Create test data
+      fee_type =
+        Mv.MembershipFees.MembershipFeeType
+        |> Ash.Changeset.for_create(:create, %{
+          name: "Test Type",
+          amount: Decimal.new("50.00"),
+          interval: :yearly
+        })
+        |> Ash.create!()
+
+      # Create member without fee type first to avoid auto-generation
+      member =
+        Mv.Membership.Member
+        |> Ash.Changeset.for_create(:create_member, %{
+          first_name: "Test",
+          last_name: "Member",
+          email: "test#{System.unique_integer([:positive])}@example.com",
+          join_date: ~D[2022-01-01]
+        })
+        |> Ash.create!()
+
+      # Assign fee type after member creation (this may generate cycles, but we'll create our own)
+      member =
+        member
+        |> Ash.Changeset.for_update(:update_member, %{membership_fee_type_id: fee_type.id})
+        |> Ash.update!()
+
+      # Delete any auto-generated cycles first
+      cycles =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.read!()
+
+      Enum.each(cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+      # Create cycles manually
+      _cycle_2022 =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Changeset.for_create(:create, %{
+          cycle_start: ~D[2022-01-01],
+          amount: Decimal.new("50.00"),
+          member_id: member.id,
+          membership_fee_type_id: fee_type.id,
+          status: :paid
+        })
+        |> Ash.create!()
+
+      cycle_2023 =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Changeset.for_create(:create, %{
+          cycle_start: ~D[2023-01-01],
+          amount: Decimal.new("50.00"),
+          member_id: member.id,
+          membership_fee_type_id: fee_type.id,
+          status: :paid
+        })
+        |> Ash.create!()
+
+      # Load cycles with membership_fee_type relationship
+      member =
+        member
+        |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+        |> Ash.load!(:membership_fee_type)
+
+      # Use a fixed date in 2024 to ensure 2023 is last completed
+      today = ~D[2024-06-15]
+      last_cycle = MembershipFeeHelpers.get_last_completed_cycle(member, today)
+
+      assert last_cycle.id == cycle_2023.id
+    end
+
+    test "returns nil if no cycles exist" do
+      fee_type =
+        Mv.MembershipFees.MembershipFeeType
+        |> Ash.Changeset.for_create(:create, %{
+          name: "Test Type",
+          amount: Decimal.new("50.00"),
+          interval: :yearly
+        })
+        |> Ash.create!()
+
+      # Create member without fee type first
+      member =
+        Mv.Membership.Member
+        |> Ash.Changeset.for_create(:create_member, %{
+          first_name: "Test",
+          last_name: "Member",
+          email: "test#{System.unique_integer([:positive])}@example.com"
+        })
+        |> Ash.create!()
+
+      # Assign fee type
+      member =
+        member
+        |> Ash.Changeset.for_update(:update_member, %{membership_fee_type_id: fee_type.id})
+        |> Ash.update!()
+
+      # Delete any auto-generated cycles
+      cycles =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.read!()
+
+      Enum.each(cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+      # Load cycles and fee type (will be empty)
+      member =
+        member
+        |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+        |> Ash.load!(:membership_fee_type)
+
+      last_cycle = MembershipFeeHelpers.get_last_completed_cycle(member, Date.utc_today())
+      assert last_cycle == nil
+    end
+  end
+
+  describe "get_current_cycle/2" do
+    test "returns current cycle for member" do
+      fee_type =
+        Mv.MembershipFees.MembershipFeeType
+        |> Ash.Changeset.for_create(:create, %{
+          name: "Test Type",
+          amount: Decimal.new("50.00"),
+          interval: :yearly
+        })
+        |> Ash.create!()
+
+      # Create member without fee type first
+      member =
+        Mv.Membership.Member
+        |> Ash.Changeset.for_create(:create_member, %{
+          first_name: "Test",
+          last_name: "Member",
+          email: "test#{System.unique_integer([:positive])}@example.com",
+          join_date: ~D[2023-01-01]
+        })
+        |> Ash.create!()
+
+      # Assign fee type
+      member =
+        member
+        |> Ash.Changeset.for_update(:update_member, %{membership_fee_type_id: fee_type.id})
+        |> Ash.update!()
+
+      # Delete any auto-generated cycles
+      cycles =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.read!()
+
+      Enum.each(cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+      today = Date.utc_today()
+      current_year_start = %{today | month: 1, day: 1}
+
+      current_cycle =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Changeset.for_create(:create, %{
+          cycle_start: current_year_start,
+          amount: Decimal.new("50.00"),
+          member_id: member.id,
+          membership_fee_type_id: fee_type.id,
+          status: :unpaid
+        })
+        |> Ash.create!()
+
+      # Load cycles with membership_fee_type relationship
+      member =
+        member
+        |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+        |> Ash.load!(:membership_fee_type)
+
+      result = MembershipFeeHelpers.get_current_cycle(member, today)
+
+      assert result.id == current_cycle.id
+    end
+  end
+
+  describe "status_color/1" do
+    test "returns correct color classes for statuses" do
+      assert MembershipFeeHelpers.status_color(:paid) == "badge-success"
+      assert MembershipFeeHelpers.status_color(:unpaid) == "badge-error"
+      assert MembershipFeeHelpers.status_color(:suspended) == "badge-ghost"
+    end
+  end
+
+  describe "status_icon/1" do
+    test "returns correct icon names for statuses" do
+      assert MembershipFeeHelpers.status_icon(:paid) == "hero-check-circle"
+      assert MembershipFeeHelpers.status_icon(:unpaid) == "hero-x-circle"
+      assert MembershipFeeHelpers.status_icon(:suspended) == "hero-pause-circle"
+    end
+  end
+end

test/mv_web/live/membership_fee_type_live/form_test.exs

@@ -0,0 +1,218 @@
+defmodule MvWeb.MembershipFeeTypeLive.FormTest do
+  @moduledoc """
+  Tests for membership fee types create/edit form.
+  """
+  use MvWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias Mv.MembershipFees.MembershipFeeType
+  alias Mv.Membership.Member
+
+  require Ash.Query
+
+  setup %{conn: conn} do
+    # Create admin user
+    {:ok, user} =
+      Mv.Accounts.User
+      |> Ash.Changeset.for_create(:register_with_password, %{
+        email: "admin#{System.unique_integer([:positive])}@mv.local",
+        password: "testpassword123"
+      })
+      |> Ash.create()
+
+    authenticated_conn = conn_with_password_user(conn, user)
+    %{conn: authenticated_conn, user: user}
+  end
+
+  # Helper to create a membership fee type
+  defp create_fee_type(attrs) do
+    default_attrs = %{
+      name: "Test Fee Type #{System.unique_integer([:positive])}",
+      amount: Decimal.new("50.00"),
+      interval: :yearly
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeType
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a member
+  defp create_member(attrs) do
+    default_attrs = %{
+      first_name: "Test",
+      last_name: "Member",
+      email: "test.member.#{System.unique_integer([:positive])}@example.com"
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    Member
+    |> Ash.Changeset.for_create(:create_member, attrs)
+    |> Ash.create!()
+  end
+
+  describe "create form" do
+    test "creates new membership fee type", %{conn: conn} do
+      {:ok, view, _html} = live(conn, "/membership_fee_types/new")
+
+      form_data = %{
+        "membership_fee_type[name]" => "New Type",
+        "membership_fee_type[amount]" => "75.00",
+        "membership_fee_type[interval]" => "yearly",
+        "membership_fee_type[description]" => "Test description"
+      }
+
+      {:error, {:live_redirect, %{to: to}}} =
+        view
+        |> form("#membership-fee-type-form", form_data)
+        |> render_submit()
+
+      assert to == "/membership_fee_types"
+
+      # Verify type was created
+      type =
+        MembershipFeeType
+        |> Ash.Query.filter(name == "New Type")
+        |> Ash.read_one!()
+
+      assert type.amount == Decimal.new("75.00")
+      assert type.interval == :yearly
+    end
+
+    test "interval field is editable on create", %{conn: conn} do
+      {:ok, _view, html} = live(conn, "/membership_fee_types/new")
+
+      # Interval field should be editable (not disabled)
+      refute html =~ "disabled" || html =~ "readonly"
+    end
+  end
+
+  describe "edit form" do
+    test "loads existing type data", %{conn: conn} do
+      fee_type = create_fee_type(%{name: "Existing Type", amount: Decimal.new("60.00")})
+
+      {:ok, _view, html} = live(conn, "/membership_fee_types/#{fee_type.id}/edit")
+
+      assert html =~ "Existing Type"
+      assert html =~ "60" || html =~ "60,00"
+    end
+
+    test "interval field is grayed out on edit", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      {:ok, _view, html} = live(conn, "/membership_fee_types/#{fee_type.id}/edit")
+
+      # Interval field should be disabled
+      assert html =~ "disabled" || html =~ "readonly"
+    end
+
+    test "amount change warning displays on edit", %{conn: conn} do
+      fee_type = create_fee_type(%{amount: Decimal.new("50.00")})
+      create_member(%{membership_fee_type_id: fee_type.id})
+
+      {:ok, view, _html} = live(conn, "/membership_fee_types/#{fee_type.id}/edit")
+
+      # Change amount
+      view
+      |> form("#membership-fee-type-form", %{"membership_fee_type[amount]" => "75.00"})
+      |> render_change()
+
+      # Should show warning in rendered view
+      html = render(view)
+      assert html =~ "affect" || html =~ "Change Amount"
+    end
+
+    test "amount change warning shows correct affected member count", %{conn: conn} do
+      fee_type = create_fee_type(%{amount: Decimal.new("50.00")})
+
+      # Create 3 members
+      Enum.each(1..3, fn _ ->
+        create_member(%{membership_fee_type_id: fee_type.id})
+      end)
+
+      {:ok, view, _html} = live(conn, "/membership_fee_types/#{fee_type.id}/edit")
+
+      # Change amount
+      html =
+        view
+        |> form("#membership-fee-type-form", %{"membership_fee_type[amount]" => "75.00"})
+        |> render_change()
+
+      # Should show affected count
+      assert html =~ "3" || html =~ "members" || html =~ "Mitglieder"
+    end
+
+    test "amount change can be confirmed", %{conn: conn} do
+      fee_type = create_fee_type(%{amount: Decimal.new("50.00")})
+
+      {:ok, view, _html} = live(conn, "/membership_fee_types/#{fee_type.id}/edit")
+
+      # Change amount and confirm
+      view
+      |> form("#membership-fee-type-form", %{"membership_fee_type[amount]" => "75.00"})
+      |> render_change()
+
+      view
+      |> element("button[phx-click='confirm_amount_change']")
+      |> render_click()
+
+      # Submit the form to actually save the change
+      view
+      |> form("#membership-fee-type-form", %{"membership_fee_type[amount]" => "75.00"})
+      |> render_submit()
+
+      # Amount should be updated
+      updated_type = Ash.read_one!(MembershipFeeType |> Ash.Query.filter(id == ^fee_type.id))
+      assert updated_type.amount == Decimal.new("75.00")
+    end
+
+    test "amount change can be cancelled", %{conn: conn} do
+      fee_type = create_fee_type(%{amount: Decimal.new("50.00")})
+
+      {:ok, view, _html} = live(conn, "/membership_fee_types/#{fee_type.id}/edit")
+
+      # Change amount and cancel
+      view
+      |> form("#membership-fee-type-form", %{"membership_fee_type[amount]" => "75.00"})
+      |> render_change()
+
+      view
+      |> element("button[phx-click='cancel_amount_change']")
+      |> render_click()
+
+      # Amount should remain unchanged
+      updated_type = Ash.read_one!(MembershipFeeType |> Ash.Query.filter(id == ^fee_type.id))
+      assert updated_type.amount == Decimal.new("50.00")
+    end
+
+    test "validation errors display correctly", %{conn: conn} do
+      {:ok, view, _html} = live(conn, "/membership_fee_types/new")
+
+      # Submit with invalid data
+      html =
+        view
+        |> form("#membership-fee-type-form", %{
+          "membership_fee_type[name]" => "",
+          "membership_fee_type[amount]" => ""
+        })
+        |> render_submit()
+
+      # Should show validation errors
+      assert html =~ "can't be blank" || html =~ "darf nicht leer sein" || html =~ "required"
+    end
+  end
+
+  describe "permissions" do
+    test "only admin can access", %{conn: conn} do
+      # This test assumes non-admin users cannot access
+      {:ok, _view, html} = live(conn, "/membership_fee_types/new")
+
+      # Should show the form (admin user in setup)
+      assert html =~ "Membership Fee Type" || html =~ "Beitragsart"
+    end
+  end
+end

test/mv_web/live/membership_fee_type_live/index_test.exs

@@ -0,0 +1,151 @@
+defmodule MvWeb.MembershipFeeTypeLive.IndexTest do
+  @moduledoc """
+  Tests for membership fee types list view.
+  """
+  use MvWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias Mv.MembershipFees.MembershipFeeType
+  alias Mv.Membership.Member
+
+  require Ash.Query
+
+  setup %{conn: conn} do
+    # Create admin user
+    {:ok, user} =
+      Mv.Accounts.User
+      |> Ash.Changeset.for_create(:register_with_password, %{
+        email: "admin#{System.unique_integer([:positive])}@mv.local",
+        password: "testpassword123"
+      })
+      |> Ash.create()
+
+    authenticated_conn = conn_with_password_user(conn, user)
+    %{conn: authenticated_conn, user: user}
+  end
+
+  # Helper to create a membership fee type
+  defp create_fee_type(attrs) do
+    default_attrs = %{
+      name: "Test Fee Type #{System.unique_integer([:positive])}",
+      amount: Decimal.new("50.00"),
+      interval: :yearly
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeType
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a member
+  defp create_member(attrs) do
+    default_attrs = %{
+      first_name: "Test",
+      last_name: "Member",
+      email: "test.member.#{System.unique_integer([:positive])}@example.com"
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    Member
+    |> Ash.Changeset.for_create(:create_member, attrs)
+    |> Ash.create!()
+  end
+
+  describe "list display" do
+    test "displays all membership fee types with correct data", %{conn: conn} do
+      _fee_type1 =
+        create_fee_type(%{name: "Regular", amount: Decimal.new("60.00"), interval: :yearly})
+
+      _fee_type2 =
+        create_fee_type(%{name: "Reduced", amount: Decimal.new("30.00"), interval: :yearly})
+
+      {:ok, _view, html} = live(conn, "/membership_fee_types")
+
+      assert html =~ "Regular"
+      assert html =~ "Reduced"
+      assert html =~ "60" || html =~ "60,00"
+      assert html =~ "30" || html =~ "30,00"
+      assert html =~ "Yearly" || html =~ "Jährlich"
+    end
+
+    test "member count column shows correct count", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      # Create 3 members with this fee type
+      Enum.each(1..3, fn _ ->
+        create_member(%{membership_fee_type_id: fee_type.id})
+      end)
+
+      {:ok, _view, html} = live(conn, "/membership_fee_types")
+
+      assert html =~ "3" || html =~ "Members" || html =~ "Mitglieder"
+    end
+
+    test "create button navigates to form", %{conn: conn} do
+      {:ok, view, _html} = live(conn, "/membership_fee_types")
+
+      {:error, {:live_redirect, %{to: to}}} =
+        view
+        |> element("a[href='/membership_fee_types/new']")
+        |> render_click()
+
+      assert to == "/membership_fee_types/new"
+    end
+
+    test "edit button per row navigates to edit form", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      {:ok, view, _html} = live(conn, "/membership_fee_types")
+
+      {:error, {:live_redirect, %{to: to}}} =
+        view
+        |> element("a[href='/membership_fee_types/#{fee_type.id}/edit']")
+        |> render_click()
+
+      assert to == "/membership_fee_types/#{fee_type.id}/edit"
+    end
+  end
+
+  describe "delete functionality" do
+    test "delete button disabled if type is in use", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      create_member(%{membership_fee_type_id: fee_type.id})
+
+      {:ok, _view, html} = live(conn, "/membership_fee_types")
+
+      # Delete button should be disabled
+      assert html =~ "disabled" || html =~ "cursor-not-allowed"
+    end
+
+    test "delete button works if type is not in use", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      # No members assigned
+
+      {:ok, view, _html} = live(conn, "/membership_fee_types")
+
+      # Delete button should be enabled
+      view
+      |> element("button[phx-click='delete'][phx-value-id='#{fee_type.id}']")
+      |> render_click()
+
+      # Type should be deleted
+      assert {:error, %Ash.Error.Invalid{errors: [%Ash.Error.Query.NotFound{}]}} =
+               Ash.get(MembershipFeeType, fee_type.id, domain: Mv.MembershipFees)
+    end
+  end
+
+  describe "permissions" do
+    test "only admin can access", %{conn: conn} do
+      # This test assumes non-admin users cannot access
+      # Adjust based on actual permission implementation
+      {:ok, _view, html} = live(conn, "/membership_fee_types")
+
+      # Should show the page (admin user in setup)
+      assert html =~ "Membership Fee Types" || html =~ "Beitragsarten"
+    end
+  end
+end

test/mv_web/member_live/form_membership_fee_type_test.exs

@@ -0,0 +1,167 @@
+defmodule MvWeb.MemberLive.FormMembershipFeeTypeTest do
+  @moduledoc """
+  Tests for membership fee type dropdown in member form.
+  """
+  use MvWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias Mv.Membership.Member
+  alias Mv.MembershipFees.MembershipFeeType
+
+  require Ash.Query
+
+  setup %{conn: conn} do
+    # Create admin user
+    {:ok, user} =
+      Mv.Accounts.User
+      |> Ash.Changeset.for_create(:register_with_password, %{
+        email: "admin#{System.unique_integer([:positive])}@mv.local",
+        password: "testpassword123"
+      })
+      |> Ash.create()
+
+    authenticated_conn = conn_with_password_user(conn, user)
+    %{conn: authenticated_conn, user: user}
+  end
+
+  # Helper to create a membership fee type
+  defp create_fee_type(attrs) do
+    default_attrs = %{
+      name: "Test Fee Type #{System.unique_integer([:positive])}",
+      amount: Decimal.new("50.00"),
+      interval: :yearly
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeType
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a member
+  defp create_member(attrs) do
+    default_attrs = %{
+      first_name: "Test",
+      last_name: "Member",
+      email: "test.member.#{System.unique_integer([:positive])}@example.com"
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    Member
+    |> Ash.Changeset.for_create(:create_member, attrs)
+    |> Ash.create!()
+  end
+
+  describe "membership fee type dropdown" do
+    test "displays in form", %{conn: conn} do
+      {:ok, _view, html} = live(conn, "/members/new")
+
+      # Should show membership fee type dropdown
+      assert html =~ "membership_fee_type_id" || html =~ "Membership Fee Type" ||
+               html =~ "Beitragsart"
+    end
+
+    test "shows available types", %{conn: conn} do
+      _fee_type1 = create_fee_type(%{name: "Type 1", interval: :yearly})
+      _fee_type2 = create_fee_type(%{name: "Type 2", interval: :yearly})
+
+      {:ok, _view, html} = live(conn, "/members/new")
+
+      assert html =~ "Type 1"
+      assert html =~ "Type 2"
+    end
+
+    test "filters to same interval types if member has type", %{conn: conn} do
+      yearly_type = create_fee_type(%{name: "Yearly Type", interval: :yearly})
+      _monthly_type = create_fee_type(%{name: "Monthly Type", interval: :monthly})
+
+      member = create_member(%{membership_fee_type_id: yearly_type.id})
+
+      {:ok, _view, html} = live(conn, "/members/#{member.id}/edit")
+
+      # Should show yearly type but not monthly
+      assert html =~ "Yearly Type"
+      refute html =~ "Monthly Type"
+    end
+
+    test "shows warning if different interval selected", %{conn: conn} do
+      yearly_type = create_fee_type(%{name: "Yearly Type", interval: :yearly})
+      monthly_type = create_fee_type(%{name: "Monthly Type", interval: :monthly})
+
+      member = create_member(%{membership_fee_type_id: yearly_type.id})
+
+      {:ok, _view, html} = live(conn, "/members/#{member.id}/edit")
+
+      # Monthly type should not be in the dropdown (filtered by interval)
+      refute html =~ monthly_type.id
+
+      # Only yearly types should be available
+      assert html =~ yearly_type.id
+    end
+
+    test "warning cleared if same interval selected", %{conn: conn} do
+      yearly_type1 = create_fee_type(%{name: "Yearly Type 1", interval: :yearly})
+      yearly_type2 = create_fee_type(%{name: "Yearly Type 2", interval: :yearly})
+
+      member = create_member(%{membership_fee_type_id: yearly_type1.id})
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}/edit")
+
+      # Select another yearly type (should not show warning)
+      html =
+        view
+        |> form("#member-form", %{"member[membership_fee_type_id]" => yearly_type2.id})
+        |> render_change()
+
+      refute html =~ "Warning" || html =~ "Warnung"
+    end
+
+    test "form saves with selected membership fee type", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      {:ok, view, _html} = live(conn, "/members/new")
+
+      form_data = %{
+        "member[first_name]" => "Test",
+        "member[last_name]" => "Member",
+        "member[email]" => "test#{System.unique_integer([:positive])}@example.com",
+        "member[membership_fee_type_id]" => fee_type.id
+      }
+
+      {:error, {:live_redirect, %{to: _to}}} =
+        view
+        |> form("#member-form", form_data)
+        |> render_submit()
+
+      # Verify member was created with fee type
+      member =
+        Member
+        |> Ash.Query.filter(email == ^form_data["member[email]"])
+        |> Ash.read_one!()
+
+      assert member.membership_fee_type_id == fee_type.id
+    end
+
+    test "new members get default membership fee type", %{conn: conn} do
+      # Set default fee type in settings
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      {:ok, settings} = Mv.Membership.get_settings()
+
+      settings
+      |> Ash.Changeset.for_update(:update_membership_fee_settings, %{
+        default_membership_fee_type_id: fee_type.id
+      })
+      |> Ash.update!()
+
+      {:ok, view, _html} = live(conn, "/members/new")
+
+      # Form should have default fee type selected
+      html = render(view)
+      assert html =~ fee_type.name || html =~ "selected"
+    end
+  end
+end

test/mv_web/member_live/index/membership_fee_status_test.exs

@@ -0,0 +1,362 @@
+defmodule MvWeb.MemberLive.Index.MembershipFeeStatusTest do
+  @moduledoc """
+  Tests for MembershipFeeStatus helper module.
+  """
+  use Mv.DataCase, async: false
+
+  alias MvWeb.MemberLive.Index.MembershipFeeStatus
+  alias Mv.Membership.Member
+  alias Mv.MembershipFees.MembershipFeeType
+  alias Mv.MembershipFees.MembershipFeeCycle
+
+  require Ash.Query
+
+  # Helper to create a membership fee type
+  defp create_fee_type(attrs) do
+    default_attrs = %{
+      name: "Test Fee Type #{System.unique_integer([:positive])}",
+      amount: Decimal.new("50.00"),
+      interval: :yearly
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeType
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a member
+  defp create_member(attrs) do
+    default_attrs = %{
+      first_name: "Test",
+      last_name: "Member",
+      email: "test.member.#{System.unique_integer([:positive])}@example.com"
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    Member
+    |> Ash.Changeset.for_create(:create_member, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a cycle
+  # Note: Does not delete existing cycles - tests should manage their own test data
+  # If cleanup is needed, it should be done in setup or explicitly in the test
+  defp create_cycle(member, fee_type, attrs) do
+    default_attrs = %{
+      cycle_start: ~D[2023-01-01],
+      amount: Decimal.new("50.00"),
+      member_id: member.id,
+      membership_fee_type_id: fee_type.id,
+      status: :unpaid
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeCycle
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  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()
+
+      members = Ash.read!(query)
+
+      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})
+      # Create member without fee type to avoid auto-generation
+      member = create_member(%{})
+
+      # Assign fee type
+      member =
+        member
+        |> Ash.Changeset.for_update(:update_member, %{membership_fee_type_id: fee_type.id})
+        |> Ash.update!()
+
+      # Delete any auto-generated cycles
+      cycles =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.read!()
+
+      Enum.each(cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+      # Create cycles with dates that ensure 2023 is last completed
+      # Use a fixed "today" date in 2024 to make 2023 the last completed
+      create_cycle(member, fee_type, %{cycle_start: ~D[2022-01-01], status: :paid})
+      create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :unpaid})
+
+      # Load cycles with membership_fee_type relationship
+      member =
+        member
+        |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+        |> Ash.load!(:membership_fee_type)
+
+      # Use fixed date in 2024 to ensure 2023 is last completed
+      # We need to manually set the date for the helper function
+      # Since get_cycle_status_for_member doesn't take a date, we need to ensure
+      # the cycles are properly loaded with their fee_type relationship
+      status = MembershipFeeStatus.get_cycle_status_for_member(member, false)
+
+      # The status depends on what Date.utc_today() returns
+      # If we're in 2024 or later, 2023 should be last completed
+      # If we're still in 2023, 2022 would be last completed
+      # For this test, we'll just verify it returns a valid status
+      assert status in [:paid, :unpaid, :suspended, nil]
+    end
+
+    test "returns status of current cycle when show_current is true" do
+      fee_type = create_fee_type(%{interval: :yearly})
+      # Create member without fee type to avoid auto-generation
+      member = create_member(%{})
+
+      # Assign fee type
+      member =
+        member
+        |> Ash.Changeset.for_update(:update_member, %{membership_fee_type_id: fee_type.id})
+        |> Ash.update!()
+
+      # Delete any auto-generated cycles
+      cycles =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.read!()
+
+      Enum.each(cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+      # Create cycles - use current year for current cycle
+      today = Date.utc_today()
+      current_year_start = %{today | month: 1, day: 1}
+      last_year_start = %{current_year_start | year: current_year_start.year - 1}
+
+      create_cycle(member, fee_type, %{cycle_start: last_year_start, status: :paid})
+      create_cycle(member, fee_type, %{cycle_start: current_year_start, status: :suspended})
+
+      # Load cycles with membership_fee_type relationship
+      member =
+        member
+        |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+        |> Ash.load!(:membership_fee_type)
+
+      status = MembershipFeeStatus.get_cycle_status_for_member(member, true)
+
+      # Should return status of current cycle
+      assert status == :suspended
+    end
+
+    test "returns nil if no cycles exist" do
+      fee_type = create_fee_type(%{interval: :yearly})
+      # Create member without fee type to avoid auto-generation
+      member = create_member(%{})
+
+      # Assign fee type
+      member =
+        member
+        |> Ash.Changeset.for_update(:update_member, %{membership_fee_type_id: fee_type.id})
+        |> Ash.update!()
+
+      # Delete any auto-generated cycles
+      cycles =
+        Mv.MembershipFees.MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.read!()
+
+      Enum.each(cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+      # Load cycles and fee type first (will be empty)
+      member =
+        member
+        |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+        |> Ash.load!(:membership_fee_type)
+
+      status = MembershipFeeStatus.get_cycle_status_for_member(member, false)
+
+      assert status == nil
+    end
+  end
+
+  describe "format_cycle_status_badge/1" do
+    test "returns badge component for paid status" do
+      result = MembershipFeeStatus.format_cycle_status_badge(:paid)
+      assert result.color == "badge-success"
+      assert result.icon == "hero-check-circle"
+      assert result.label == "Paid" || result.label == "Bezahlt"
+    end
+
+    test "returns badge component for unpaid status" do
+      result = MembershipFeeStatus.format_cycle_status_badge(:unpaid)
+      assert result.color == "badge-error"
+      assert result.icon == "hero-x-circle"
+      assert result.label == "Unpaid" || result.label == "Unbezahlt"
+    end
+
+    test "returns badge component for suspended status" do
+      result = MembershipFeeStatus.format_cycle_status_badge(:suspended)
+      assert result.color == "badge-ghost"
+      assert result.icon == "hero-pause-circle"
+      assert result.label == "Suspended" || result.label == "Ausgesetzt"
+    end
+
+    test "handles nil status gracefully" do
+      result = MembershipFeeStatus.format_cycle_status_badge(nil)
+      assert result == nil
+    end
+  end
+
+  describe "filter_members_by_cycle_status/3" do
+    test "filters paid members in last cycle" do
+      fee_type = create_fee_type(%{interval: :yearly})
+      today = Date.utc_today()
+      last_year_start = Date.new!(today.year - 1, 1, 1)
+
+      # Member with paid last cycle
+      member1 = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member1, fee_type, %{cycle_start: last_year_start, status: :paid})
+
+      # Member with unpaid last cycle
+      member2 = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member2, fee_type, %{cycle_start: last_year_start, status: :unpaid})
+
+      members =
+        [member1, member2]
+        |> Enum.map(fn m ->
+          m
+          |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+          |> Ash.load!(:membership_fee_type)
+        end)
+
+      filtered = MembershipFeeStatus.filter_members_by_cycle_status(members, :paid, false)
+
+      assert length(filtered) == 1
+      assert List.first(filtered).id == member1.id
+    end
+
+    test "filters unpaid members in last cycle" do
+      fee_type = create_fee_type(%{interval: :yearly})
+      today = Date.utc_today()
+      last_year_start = Date.new!(today.year - 1, 1, 1)
+
+      # Member with paid last cycle
+      member1 = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member1, fee_type, %{cycle_start: last_year_start, status: :paid})
+
+      # Member with unpaid last cycle
+      member2 = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member2, fee_type, %{cycle_start: last_year_start, status: :unpaid})
+
+      members =
+        [member1, member2]
+        |> Enum.map(fn m ->
+          m
+          |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+          |> Ash.load!(:membership_fee_type)
+        end)
+
+      filtered = MembershipFeeStatus.filter_members_by_cycle_status(members, :unpaid, false)
+
+      assert length(filtered) == 1
+      assert List.first(filtered).id == member2.id
+    end
+
+    test "filters paid members in current cycle" do
+      fee_type = create_fee_type(%{interval: :yearly})
+      today = Date.utc_today()
+      current_year_start = Date.new!(today.year, 1, 1)
+
+      # Member with paid current cycle
+      member1 = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member1, fee_type, %{cycle_start: current_year_start, status: :paid})
+
+      # Member with unpaid current cycle
+      member2 = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member2, fee_type, %{cycle_start: current_year_start, status: :unpaid})
+
+      members =
+        [member1, member2]
+        |> Enum.map(fn m ->
+          m
+          |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+          |> Ash.load!(:membership_fee_type)
+        end)
+
+      filtered = MembershipFeeStatus.filter_members_by_cycle_status(members, :paid, true)
+
+      assert length(filtered) == 1
+      assert List.first(filtered).id == member1.id
+    end
+
+    test "filters unpaid members in current cycle" do
+      fee_type = create_fee_type(%{interval: :yearly})
+      today = Date.utc_today()
+      current_year_start = Date.new!(today.year, 1, 1)
+
+      # Member with paid current cycle
+      member1 = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member1, fee_type, %{cycle_start: current_year_start, status: :paid})
+
+      # Member with unpaid current cycle
+      member2 = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member2, fee_type, %{cycle_start: current_year_start, status: :unpaid})
+
+      members =
+        [member1, member2]
+        |> Enum.map(fn m ->
+          m
+          |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+          |> Ash.load!(:membership_fee_type)
+        end)
+
+      filtered = MembershipFeeStatus.filter_members_by_cycle_status(members, :unpaid, true)
+
+      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})
+
+      members =
+        [member1, member2]
+        |> Enum.map(fn m ->
+          m
+          |> Ash.load!(membership_fee_cycles: [:membership_fee_type])
+          |> Ash.load!(:membership_fee_type)
+        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_custom_fields_accessibility_test.exs

@@ -52,14 +52,11 @@ defmodule MvWeb.MemberLive.IndexCustomFieldsAccessibilityTest do
     field: field
   } do
     conn = conn_with_oidc_user(conn)
-    {:ok, _view, html} = live(conn, "/members")
+    {:ok, view, _html} = live(conn, "/members")
 
-    # Check that the sort button has aria-label
-    assert html =~ ~r/aria-label=["']Click to sort["']/i or
-             html =~ ~r/aria-label=["'].*sort.*["']/i
-
-    # Check that data-testid is present for testing
-    assert html =~ ~r/data-testid=["']custom_field_#{field.id}["']/
+    # Check that the sort button has aria-label and data-testid
+    test_id = "custom_field_#{field.id}"
+    assert has_element?(view, "[data-testid='#{test_id}'][aria-label='Click to sort']")
   end
 
   test "sort header component shows correct ARIA label when sorted ascending", %{
@@ -71,10 +68,9 @@ defmodule MvWeb.MemberLive.IndexCustomFieldsAccessibilityTest do
     {:ok, view, _html} =
       live(conn, "/members?query=&sort_field=custom_field_#{field.id}&sort_order=asc")
 
-    html = render(view)
-
-    # Check that aria-label indicates ascending sort
-    assert html =~ ~r/aria-label=["'].*ascending.*["']/i
+    # Check that aria-label indicates ascending sort using data-testid
+    test_id = "custom_field_#{field.id}"
+    assert has_element?(view, "[data-testid='#{test_id}'][aria-label='ascending']")
   end
 
   test "sort header component shows correct ARIA label when sorted descending", %{
@@ -86,21 +82,21 @@ defmodule MvWeb.MemberLive.IndexCustomFieldsAccessibilityTest do
     {:ok, view, _html} =
       live(conn, "/members?query=&sort_field=custom_field_#{field.id}&sort_order=desc")
 
-    html = render(view)
-
-    # Check that aria-label indicates descending sort
-    assert html =~ ~r/aria-label=["'].*descending.*["']/i
+    # Check that aria-label indicates descending sort using data-testid
+    test_id = "custom_field_#{field.id}"
+    assert has_element?(view, "[data-testid='#{test_id}'][aria-label='descending']")
   end
 
   test "custom field column header is keyboard accessible", %{conn: conn, field: field} do
     conn = conn_with_oidc_user(conn)
-    {:ok, _view, html} = live(conn, "/members")
+    {:ok, view, _html} = live(conn, "/members")
 
     # Check that the sort button is a button element (keyboard accessible)
-    assert html =~ ~r/<button[^>]*data-testid=["']custom_field_#{field.id}["']/
+    test_id = "custom_field_#{field.id}"
+    assert has_element?(view, "button[data-testid='#{test_id}']")
 
     # Button should not have tabindex="-1" (which would remove from tab order)
-    refute html =~ ~r/tabindex=["']-1["']/
+    refute has_element?(view, "button[data-testid='#{test_id}'][tabindex='-1']")
   end
 
   test "custom field column header has proper semantic structure", %{conn: conn, field: field} do

test/mv_web/member_live/index_field_visibility_test.exs

@@ -10,7 +10,8 @@ defmodule MvWeb.MemberLive.IndexFieldVisibilityTest do
   - Integration with member list display
   - Custom fields visibility
   """
-  use MvWeb.ConnCase, async: true
+  # async: false to prevent PostgreSQL deadlocks when creating members and custom fields
+  use MvWeb.ConnCase, async: false
 
   import Phoenix.LiveViewTest
   require Ash.Query

test/mv_web/member_live/index_membership_fee_status_test.exs

@@ -0,0 +1,261 @@
+defmodule MvWeb.MemberLive.IndexMembershipFeeStatusTest do
+  @moduledoc """
+  Tests for membership fee status column in member list view.
+  """
+  use MvWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias Mv.Membership.Member
+  alias Mv.MembershipFees.MembershipFeeType
+  alias Mv.MembershipFees.MembershipFeeCycle
+
+  require Ash.Query
+
+  setup %{conn: conn} do
+    # Create admin user
+    {:ok, user} =
+      Mv.Accounts.User
+      |> Ash.Changeset.for_create(:register_with_password, %{
+        email: "admin#{System.unique_integer([:positive])}@mv.local",
+        password: "testpassword123"
+      })
+      |> Ash.create()
+
+    conn = conn_with_password_user(conn, user)
+    %{conn: conn, user: user}
+  end
+
+  # Helper to create a membership fee type
+  defp create_fee_type(attrs) do
+    default_attrs = %{
+      name: "Test Fee Type #{System.unique_integer([:positive])}",
+      amount: Decimal.new("50.00"),
+      interval: :yearly
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeType
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a member
+  defp create_member(attrs) do
+    default_attrs = %{
+      first_name: "Test",
+      last_name: "Member",
+      email: "test.member.#{System.unique_integer([:positive])}@example.com"
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    Member
+    |> Ash.Changeset.for_create(:create_member, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a cycle
+  defp create_cycle(member, fee_type, attrs) do
+    # Delete any auto-generated cycles first to avoid conflicts
+    existing_cycles =
+      MembershipFeeCycle
+      |> Ash.Query.filter(member_id == ^member.id)
+      |> Ash.read!()
+
+    Enum.each(existing_cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+    default_attrs = %{
+      cycle_start: ~D[2023-01-01],
+      amount: Decimal.new("50.00"),
+      member_id: member.id,
+      membership_fee_type_id: fee_type.id,
+      status: :unpaid
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeCycle
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  describe "status column display" do
+    test "shows status column in member list", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :paid})
+
+      {:ok, _view, html} = live(conn, "/members")
+
+      # Should show membership fee status column
+      assert html =~ "Membership Fee Status" || html =~ "Mitgliedsbeitrag Status"
+    end
+
+    test "shows last completed cycle status by default", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member, fee_type, %{cycle_start: ~D[2022-01-01], status: :paid})
+      create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :unpaid})
+
+      {:ok, view, _html} = live(conn, "/members")
+
+      # Should show unpaid status (2023 is last completed)
+      html = render(view)
+      assert html =~ "hero-x-circle" || html =~ "unpaid"
+    end
+
+    test "toggle switches to current cycle view", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      today = Date.utc_today()
+      current_year_start = %{today | month: 1, day: 1}
+
+      create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :paid})
+      create_cycle(member, fee_type, %{cycle_start: current_year_start, status: :suspended})
+
+      {:ok, view, _html} = live(conn, "/members")
+
+      # Toggle to current cycle (use the button in the header, not the one in the column)
+      view
+      |> element("button[phx-click='toggle_cycle_view'].btn.gap-2")
+      |> render_click()
+
+      html = render(view)
+      # Should show suspended status (current cycle)
+      assert html =~ "hero-pause-circle" || html =~ "suspended"
+    end
+
+    test "shows correct color coding for paid status", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :paid})
+
+      {:ok, view, _html} = live(conn, "/members")
+
+      html = render(view)
+      assert html =~ "text-success" || html =~ "hero-check-circle"
+    end
+
+    test "shows correct color coding for unpaid status", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :unpaid})
+
+      {:ok, view, _html} = live(conn, "/members")
+
+      html = render(view)
+      assert html =~ "text-error" || html =~ "hero-x-circle"
+    end
+
+    test "shows correct color coding for suspended status", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+      create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :suspended})
+
+      {:ok, view, _html} = live(conn, "/members")
+
+      html = render(view)
+      assert html =~ "text-base-content/60" || html =~ "hero-pause-circle"
+    end
+
+    test "handles members without cycles gracefully", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+      # No cycles created
+
+      {:ok, view, _html} = live(conn, "/members")
+
+      html = render(view)
+      # Should not crash, may show empty or default state
+      assert html =~ member.first_name
+    end
+  end
+
+  describe "filters" do
+    test "filter unpaid in last cycle works", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      # Member with unpaid last cycle
+      member1 = create_member(%{first_name: "UnpaidMember", membership_fee_type_id: fee_type.id})
+      create_cycle(member1, fee_type, %{cycle_start: ~D[2023-01-01], status: :unpaid})
+
+      # Member with paid last cycle
+      member2 = create_member(%{first_name: "PaidMember", membership_fee_type_id: fee_type.id})
+      create_cycle(member2, fee_type, %{cycle_start: ~D[2023-01-01], status: :paid})
+
+      # Verify cycles exist in database
+      cycles1 =
+        MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member1.id)
+        |> Ash.read!()
+
+      cycles2 =
+        MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member2.id)
+        |> Ash.read!()
+
+      refute Enum.empty?(cycles1)
+      refute Enum.empty?(cycles2)
+
+      {:ok, _view, html} = live(conn, "/members?cycle_status_filter=unpaid")
+
+      assert html =~ "UnpaidMember"
+      refute html =~ "PaidMember"
+    end
+
+    test "filter unpaid in current cycle works", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      today = Date.utc_today()
+      current_year_start = %{today | month: 1, day: 1}
+
+      # Member with unpaid current cycle
+      member1 = create_member(%{first_name: "UnpaidCurrent", membership_fee_type_id: fee_type.id})
+      create_cycle(member1, fee_type, %{cycle_start: current_year_start, status: :unpaid})
+
+      # Member with paid current cycle
+      member2 = create_member(%{first_name: "PaidCurrent", membership_fee_type_id: fee_type.id})
+      create_cycle(member2, fee_type, %{cycle_start: current_year_start, status: :paid})
+
+      # Verify cycles exist in database
+      cycles1 =
+        MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member1.id)
+        |> Ash.read!()
+
+      cycles2 =
+        MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member2.id)
+        |> Ash.read!()
+
+      refute Enum.empty?(cycles1)
+      refute Enum.empty?(cycles2)
+
+      {:ok, _view, html} =
+        live(conn, "/members?cycle_status_filter=unpaid&show_current_cycle=true")
+
+      assert html =~ "UnpaidCurrent"
+      refute html =~ "PaidCurrent"
+    end
+  end
+
+  describe "performance" do
+    test "loads cycles efficiently without N+1 queries", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      # Create multiple members with cycles
+      Enum.each(1..5, fn _ ->
+        member = create_member(%{membership_fee_type_id: fee_type.id})
+        create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :paid})
+      end)
+
+      {:ok, _view, html} = live(conn, "/members")
+
+      # Should render without errors (N+1 would cause performance issues)
+      assert html =~ "Members" || html =~ "Mitglieder"
+    end
+  end
+end

test/mv_web/member_live/index_test.exs

@@ -410,15 +410,17 @@ defmodule MvWeb.MemberLive.IndexTest do
       assert render(view) =~ "1"
     end
 
-    test "copy button is not visible when no members are selected", %{conn: conn} do
+    test "copy button is disabled when no members selected", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
       {:ok, view, _html} = live(conn, "/members")
 
-      # Ensure no members are selected (default state)
-      refute has_element?(view, "#copy-emails-btn")
+      # Copy button should be disabled (button element)
+      assert has_element?(view, "#copy-emails-btn[disabled]")
+      # Open email button should be disabled (link with tabindex and aria-disabled)
+      assert has_element?(view, "#open-email-btn[tabindex='-1'][aria-disabled='true']")
     end
 
-    test "copy button is visible when members are selected", %{
+    test "copy button is enabled after selection", %{
       conn: conn,
       member1: member1
     } do
@@ -428,8 +430,13 @@ defmodule MvWeb.MemberLive.IndexTest do
       # Select a member by sending the select_member event directly
       render_click(view, "select_member", %{"id" => member1.id})
 
-      # Button should now be visible
-      assert has_element?(view, "#copy-emails-btn")
+      # Copy button should now be enabled (no disabled attribute)
+      refute has_element?(view, "#copy-emails-btn[disabled]")
+      # Open email button should now be enabled (no tabindex=-1 or aria-disabled)
+      refute has_element?(view, "#open-email-btn[tabindex='-1']")
+      refute has_element?(view, "#open-email-btn[aria-disabled='true']")
+      # Counter should show correct count
+      assert render(view) =~ "1"
     end
 
     test "copy button click triggers event and shows flash", %{
@@ -450,220 +457,204 @@ defmodule MvWeb.MemberLive.IndexTest do
     end
   end
 
-  describe "payment filter integration" do
-    setup do
-      # Create members with different payment status
-      # Use unique names that won't appear elsewhere in the HTML
-      {:ok, paid_member} =
-        Mv.Membership.create_member(%{
-          first_name: "Zahler",
-          last_name: "Mitglied",
-          email: "zahler@example.com",
-          paid: true
+  describe "cycle status filter" do
+    alias Mv.MembershipFees.MembershipFeeType
+    alias Mv.MembershipFees.MembershipFeeCycle
+
+    # Helper to create a membership fee type
+    defp create_fee_type(attrs) do
+      default_attrs = %{
+        name: "Test Fee Type #{System.unique_integer([:positive])}",
+        amount: Decimal.new("50.00"),
+        interval: :yearly
+      }
+
+      attrs = Map.merge(default_attrs, attrs)
+
+      MembershipFeeType
+      |> Ash.Changeset.for_create(:create, attrs)
+      |> Ash.create!()
+    end
+
+    # Helper to create a member
+    defp create_member(attrs) do
+      default_attrs = %{
+        first_name: "Test",
+        last_name: "Member",
+        email: "test.member.#{System.unique_integer([:positive])}@example.com"
+      }
+
+      attrs = Map.merge(default_attrs, attrs)
+
+      Mv.Membership.Member
+      |> Ash.Changeset.for_create(:create_member, attrs)
+      |> Ash.create!()
+    end
+
+    # Helper to create a cycle
+    defp create_cycle(member, fee_type, attrs) do
+      # Delete any auto-generated cycles first to avoid conflicts
+      existing_cycles =
+        MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.read!()
+
+      Enum.each(existing_cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+      default_attrs = %{
+        cycle_start: ~D[2023-01-01],
+        amount: Decimal.new("50.00"),
+        member_id: member.id,
+        membership_fee_type_id: fee_type.id,
+        status: :unpaid
+      }
+
+      attrs = Map.merge(default_attrs, attrs)
+
+      MembershipFeeCycle
+      |> Ash.Changeset.for_create(:create, attrs)
+      |> Ash.create!()
+    end
+
+    test "filter shows only members with paid status in last cycle", %{conn: conn} do
+      conn = conn_with_oidc_user(conn)
+      fee_type = create_fee_type(%{interval: :yearly})
+      today = Date.utc_today()
+      last_year_start = Date.new!(today.year - 1, 1, 1)
+
+      # Member with paid last cycle
+      paid_member =
+        create_member(%{
+          first_name: "PaidLast",
+          membership_fee_type_id: fee_type.id
         })
 
-      {:ok, unpaid_member} =
-        Mv.Membership.create_member(%{
-          first_name: "Nichtzahler",
-          last_name: "Mitglied",
-          email: "nichtzahler@example.com",
-          paid: false
+      create_cycle(paid_member, fee_type, %{cycle_start: last_year_start, status: :paid})
+
+      # Member with unpaid last cycle
+      unpaid_member =
+        create_member(%{
+          first_name: "UnpaidLast",
+          membership_fee_type_id: fee_type.id
         })
 
-      {:ok, nil_paid_member} =
-        Mv.Membership.create_member(%{
-          first_name: "Unbestimmt",
-          last_name: "Mitglied",
-          email: "unbestimmt@example.com"
-          # paid is nil by default
+      create_cycle(unpaid_member, fee_type, %{cycle_start: last_year_start, status: :unpaid})
+
+      {:ok, _view, html} = live(conn, "/members?cycle_status_filter=paid")
+
+      assert html =~ "PaidLast"
+      refute html =~ "UnpaidLast"
+    end
+
+    test "filter shows only members with unpaid status in last cycle", %{conn: conn} do
+      conn = conn_with_oidc_user(conn)
+      fee_type = create_fee_type(%{interval: :yearly})
+      today = Date.utc_today()
+      last_year_start = Date.new!(today.year - 1, 1, 1)
+
+      # Member with paid last cycle
+      paid_member =
+        create_member(%{
+          first_name: "PaidLast",
+          membership_fee_type_id: fee_type.id
         })
 
-      %{paid_member: paid_member, unpaid_member: unpaid_member, nil_paid_member: nil_paid_member}
+      create_cycle(paid_member, fee_type, %{cycle_start: last_year_start, status: :paid})
+
+      # Member with unpaid last cycle
+      unpaid_member =
+        create_member(%{
+          first_name: "UnpaidLast",
+          membership_fee_type_id: fee_type.id
+        })
+
+      create_cycle(unpaid_member, fee_type, %{cycle_start: last_year_start, status: :unpaid})
+
+      {:ok, _view, html} = live(conn, "/members?cycle_status_filter=unpaid")
+
+      refute html =~ "PaidLast"
+      assert html =~ "UnpaidLast"
     end
 
-    test "filter shows all members when no filter is active", %{
-      conn: conn,
-      paid_member: paid_member,
-      unpaid_member: unpaid_member,
-      nil_paid_member: nil_paid_member
-    } do
+    test "filter shows only members with paid status in current cycle", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
-      {:ok, _view, html} = live(conn, "/members")
+      fee_type = create_fee_type(%{interval: :yearly})
+      today = Date.utc_today()
+      current_year_start = Date.new!(today.year, 1, 1)
 
-      assert html =~ paid_member.first_name
-      assert html =~ unpaid_member.first_name
-      assert html =~ nil_paid_member.first_name
+      # Member with paid current cycle
+      paid_member =
+        create_member(%{
+          first_name: "PaidCurrent",
+          membership_fee_type_id: fee_type.id
+        })
+
+      create_cycle(paid_member, fee_type, %{cycle_start: current_year_start, status: :paid})
+
+      # Member with unpaid current cycle
+      unpaid_member =
+        create_member(%{
+          first_name: "UnpaidCurrent",
+          membership_fee_type_id: fee_type.id
+        })
+
+      create_cycle(unpaid_member, fee_type, %{cycle_start: current_year_start, status: :unpaid})
+
+      {:ok, _view, html} = live(conn, "/members?cycle_status_filter=paid&show_current_cycle=true")
+
+      assert html =~ "PaidCurrent"
+      refute html =~ "UnpaidCurrent"
     end
 
-    test "filter shows only paid members when paid filter is active", %{
-      conn: conn,
-      paid_member: paid_member,
-      unpaid_member: unpaid_member,
-      nil_paid_member: nil_paid_member
-    } do
+    test "filter shows only members with unpaid status in current cycle", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
-      {:ok, _view, html} = live(conn, "/members?paid_filter=paid")
+      fee_type = create_fee_type(%{interval: :yearly})
+      today = Date.utc_today()
+      current_year_start = Date.new!(today.year, 1, 1)
 
-      assert html =~ paid_member.first_name
-      refute html =~ unpaid_member.first_name
-      refute html =~ nil_paid_member.first_name
+      # Member with paid current cycle
+      paid_member =
+        create_member(%{
+          first_name: "PaidCurrent",
+          membership_fee_type_id: fee_type.id
+        })
+
+      create_cycle(paid_member, fee_type, %{cycle_start: current_year_start, status: :paid})
+
+      # Member with unpaid current cycle
+      unpaid_member =
+        create_member(%{
+          first_name: "UnpaidCurrent",
+          membership_fee_type_id: fee_type.id
+        })
+
+      create_cycle(unpaid_member, fee_type, %{cycle_start: current_year_start, status: :unpaid})
+
+      {:ok, _view, html} =
+        live(conn, "/members?cycle_status_filter=unpaid&show_current_cycle=true")
+
+      refute html =~ "PaidCurrent"
+      assert html =~ "UnpaidCurrent"
     end
 
-    test "filter shows only unpaid members (including nil) when not_paid filter is active", %{
-      conn: conn,
-      paid_member: paid_member,
-      unpaid_member: unpaid_member,
-      nil_paid_member: nil_paid_member
-    } do
-      conn = conn_with_oidc_user(conn)
-      {:ok, _view, html} = live(conn, "/members?paid_filter=not_paid")
-
-      refute html =~ paid_member.first_name
-      assert html =~ unpaid_member.first_name
-      assert html =~ nil_paid_member.first_name
-    end
-
-    test "filter combines with search query (AND)", %{
-      conn: conn,
-      paid_member: paid_member
-    } do
-      conn = conn_with_oidc_user(conn)
-      {:ok, _view, html} = live(conn, "/members?query=Zahler&paid_filter=paid")
-
-      assert html =~ paid_member.first_name
-    end
-
-    test "filter combines with sorting", %{conn: conn} do
+    test "toggle cycle view updates URL and preserves filter", %{conn: conn} do
       conn = conn_with_oidc_user(conn)
 
-      {:ok, view, _html} =
-        live(conn, "/members?paid_filter=paid&sort_field=first_name&sort_order=asc")
+      # Start with last cycle view and paid filter
+      {:ok, view, _html} = live(conn, "/members?cycle_status_filter=paid")
 
-      # Click on email sort header
+      # Toggle to current cycle - this should update URL and preserve filter
+      # Use the button in the toolbar
       view
-      |> element("[data-testid='email']")
+      |> element("button[phx-click='toggle_cycle_view']")
       |> render_click()
 
-      # Filter should be preserved in URL
+      # Wait for patch to complete
       path = assert_patch(view)
-      assert path =~ "paid_filter=paid"
-      assert path =~ "sort_field=email"
-    end
 
-    test "URL parameter paid_filter is set when selecting filter", %{conn: conn} do
-      conn = conn_with_oidc_user(conn)
-      {:ok, view, _html} = live(conn, "/members")
-
-      # Open filter dropdown
-      view
-      |> element("#payment-filter button[aria-haspopup='true']")
-      |> render_click()
-
-      # Select "Paid" option
-      view
-      |> element("#payment-filter button[phx-value-filter='paid']")
-      |> render_click()
-
-      path = assert_patch(view)
-      assert path =~ "paid_filter=paid"
-    end
-
-    test "URL parameter is correctly read on page load", %{
-      conn: conn,
-      paid_member: paid_member
-    } do
-      conn = conn_with_oidc_user(conn)
-      {:ok, _view, html} = live(conn, "/members?paid_filter=paid")
-
-      # Only paid member should be visible
-      assert html =~ paid_member.first_name
-      # Filter badge should be visible
-      assert html =~ "badge"
-    end
-
-    test "invalid URL parameter is ignored", %{
-      conn: conn,
-      paid_member: paid_member,
-      unpaid_member: unpaid_member
-    } do
-      conn = conn_with_oidc_user(conn)
-      {:ok, _view, html} = live(conn, "/members?paid_filter=invalid_value")
-
-      # All members should be visible (filter not applied)
-      assert html =~ paid_member.first_name
-      assert html =~ unpaid_member.first_name
-    end
-
-    test "search maintains filter state", %{conn: conn} do
-      conn = conn_with_oidc_user(conn)
-      {:ok, view, _html} = live(conn, "/members?paid_filter=paid")
-
-      # Perform search
-      view
-      |> element("[data-testid='search-input']")
-      |> render_change(%{"query" => "test"})
-
-      # Filter state should be maintained in URL
-      path = assert_patch(view)
-      assert path =~ "paid_filter=paid"
-    end
-  end
-
-  describe "paid column in table" do
-    setup do
-      {:ok, paid_member} =
-        Mv.Membership.create_member(%{
-          first_name: "Paid",
-          last_name: "Member",
-          email: "paid.column@example.com",
-          paid: true
-        })
-
-      {:ok, unpaid_member} =
-        Mv.Membership.create_member(%{
-          first_name: "Unpaid",
-          last_name: "Member",
-          email: "unpaid.column@example.com",
-          paid: false
-        })
-
-      %{paid_member: paid_member, unpaid_member: unpaid_member}
-    end
-
-    test "paid column shows green badge for paid members", %{conn: conn} do
-      conn = conn_with_oidc_user(conn)
-      {:ok, _view, html} = live(conn, "/members")
-
-      # Check for success badge (green)
-      assert html =~ "badge-success"
-    end
-
-    test "paid column shows red badge for unpaid members", %{conn: conn} do
-      conn = conn_with_oidc_user(conn)
-      {:ok, _view, html} = live(conn, "/members")
-
-      # Check for error badge (red)
-      assert html =~ "badge-error"
-    end
-
-    test "paid column shows 'Yes' for paid members", %{conn: conn} do
-      conn = conn_with_oidc_user(conn)
-      Gettext.put_locale(MvWeb.Gettext, "en")
-      {:ok, _view, html} = live(conn, "/members")
-
-      # The table should contain "Yes" text inside badge
-      assert html =~ "badge-success"
-      assert html =~ "Yes"
-    end
-
-    test "paid column shows 'No' for unpaid members", %{conn: conn} do
-      conn = conn_with_oidc_user(conn)
-      Gettext.put_locale(MvWeb.Gettext, "en")
-      {:ok, _view, html} = live(conn, "/members")
-
-      # The table should contain "No" text inside badge
-      assert html =~ "badge-error"
-      assert html =~ "No"
+      # URL should contain both filter and show_current_cycle
+      assert path =~ "cycle_status_filter=paid"
+      assert path =~ "show_current_cycle=true"
     end
   end
 end

test/mv_web/member_live/membership_fee_integration_test.exs

@@ -0,0 +1,237 @@
+defmodule MvWeb.MemberLive.MembershipFeeIntegrationTest do
+  @moduledoc """
+  Integration tests for membership fee UI workflows.
+  """
+  use MvWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias Mv.Membership.Member
+  alias Mv.MembershipFees.MembershipFeeType
+  alias Mv.MembershipFees.MembershipFeeCycle
+
+  require Ash.Query
+
+  setup do
+    # Create admin user
+    {:ok, user} =
+      Mv.Accounts.User
+      |> Ash.Changeset.for_create(:register_with_password, %{
+        email: "admin#{System.unique_integer([:positive])}@mv.local",
+        password: "testpassword123"
+      })
+      |> Ash.create()
+
+    conn = conn_with_password_user(build_conn(), user)
+    %{conn: conn, user: user}
+  end
+
+  # Helper to create a membership fee type
+  defp create_fee_type(attrs) do
+    default_attrs = %{
+      name: "Test Fee Type #{System.unique_integer([:positive])}",
+      amount: Decimal.new("50.00"),
+      interval: :yearly
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeType
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a member
+  defp create_member(attrs) do
+    default_attrs = %{
+      first_name: "Test",
+      last_name: "Member",
+      email: "test.member.#{System.unique_integer([:positive])}@example.com"
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    Member
+    |> Ash.Changeset.for_create(:create_member, attrs)
+    |> Ash.create!()
+  end
+
+  describe "end-to-end workflows" do
+    test "create type → assign to member → view cycles → change status", %{conn: conn} do
+      # Create type
+      fee_type = create_fee_type(%{name: "Regular", interval: :yearly})
+
+      # Assign to member
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      # View cycles
+      {:ok, view, html} = live(conn, "/members/#{member.id}")
+
+      assert html =~ "Membership Fees" || html =~ "Mitgliedsbeiträge"
+
+      # Get a cycle
+      cycles =
+        MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.read!()
+
+      if !Enum.empty?(cycles) do
+        cycle = List.first(cycles)
+
+        # Switch to Membership Fees tab
+        view
+        |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+        |> render_click()
+
+        # Change status
+        view
+        |> element("button[phx-click='mark_cycle_status'][phx-value-cycle_id='#{cycle.id}']")
+        |> render_click()
+
+        # Verify status changed
+        updated_cycle = Ash.read_one!(MembershipFeeCycle |> Ash.Query.filter(id == ^cycle.id))
+        assert updated_cycle.status == :paid
+      end
+    end
+
+    test "change member type → cycles regenerate", %{conn: conn} do
+      fee_type1 =
+        create_fee_type(%{name: "Type 1", interval: :yearly, amount: Decimal.new("50.00")})
+
+      fee_type2 =
+        create_fee_type(%{name: "Type 2", interval: :yearly, amount: Decimal.new("75.00")})
+
+      member = create_member(%{membership_fee_type_id: fee_type1.id})
+
+      # Change type
+      {:ok, view, _html} = live(conn, "/members/#{member.id}/edit")
+
+      view
+      |> form("#member-form", %{"member[membership_fee_type_id]" => fee_type2.id})
+      |> render_submit()
+
+      # Verify cycles regenerated with new amount
+      cycles =
+        MembershipFeeCycle
+        |> Ash.Query.filter(member_id == ^member.id)
+        |> Ash.Query.filter(status == :unpaid)
+        |> Ash.read!()
+
+      # Future unpaid cycles should have new amount
+      Enum.each(cycles, fn cycle ->
+        if Date.compare(cycle.cycle_start, Date.utc_today()) != :lt do
+          assert Decimal.equal?(cycle.amount, fee_type2.amount)
+        end
+      end)
+    end
+
+    test "update settings → new members get default type", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+
+      # Update settings
+      {:ok, settings} = Mv.Membership.get_settings()
+
+      settings
+      |> Ash.Changeset.for_update(:update_membership_fee_settings, %{
+        default_membership_fee_type_id: fee_type.id
+      })
+      |> Ash.update!()
+
+      # Create new member
+      {:ok, view, _html} = live(conn, "/members/new")
+
+      form_data = %{
+        "member[first_name]" => "New",
+        "member[last_name]" => "Member",
+        "member[email]" => "new#{System.unique_integer([:positive])}@example.com"
+      }
+
+      {:error, {:live_redirect, %{to: _to}}} =
+        view
+        |> form("#member-form", form_data)
+        |> render_submit()
+
+      # Verify member got default type
+      member =
+        Member
+        |> Ash.Query.filter(email == ^form_data["member[email]"])
+        |> Ash.read_one!()
+
+      assert member.membership_fee_type_id == fee_type.id
+    end
+
+    test "delete cycle → confirmation → cycle deleted", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      cycle =
+        MembershipFeeCycle
+        |> Ash.Changeset.for_create(:create, %{
+          cycle_start: ~D[2023-01-01],
+          amount: Decimal.new("50.00"),
+          member_id: member.id,
+          membership_fee_type_id: fee_type.id,
+          status: :unpaid
+        })
+        |> Ash.create!()
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}")
+
+      # Switch to Membership Fees tab
+      view
+      |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+      |> render_click()
+
+      # Delete cycle with confirmation
+      view
+      |> element("button[phx-click='delete_cycle'][phx-value-cycle_id='#{cycle.id}']")
+      |> render_click()
+
+      # Confirm deletion
+      view
+      |> element("button[phx-click='confirm_delete_cycle'][phx-value-cycle_id='#{cycle.id}']")
+      |> render_click()
+
+      # Verify cycle deleted - Ash.read_one returns {:ok, nil} if not found
+      result = MembershipFeeCycle |> Ash.Query.filter(id == ^cycle.id) |> Ash.read_one()
+      assert result == {:ok, nil}
+    end
+
+    test "edit cycle amount → modal → amount updated", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      cycle =
+        MembershipFeeCycle
+        |> Ash.Changeset.for_create(:create, %{
+          cycle_start: ~D[2023-01-01],
+          amount: Decimal.new("50.00"),
+          member_id: member.id,
+          membership_fee_type_id: fee_type.id,
+          status: :unpaid
+        })
+        |> Ash.create!()
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}")
+
+      # Switch to Membership Fees tab
+      view
+      |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+      |> render_click()
+
+      # Open edit modal by clicking on the amount span
+      view
+      |> element("span[phx-click='edit_cycle_amount'][phx-value-cycle_id='#{cycle.id}']")
+      |> render_click()
+
+      # Update amount
+      view
+      |> form("form[phx-submit='save_cycle_amount']", %{"amount" => "75.00"})
+      |> render_submit()
+
+      # Verify amount updated
+      updated_cycle = Ash.read_one!(MembershipFeeCycle |> Ash.Query.filter(id == ^cycle.id))
+      assert updated_cycle.amount == Decimal.new("75.00")
+    end
+  end
+end

test/mv_web/member_live/show_membership_fees_test.exs

@@ -0,0 +1,270 @@
+defmodule MvWeb.MemberLive.ShowMembershipFeesTest do
+  @moduledoc """
+  Tests for membership fees section in member detail view.
+  """
+  use MvWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias Mv.Membership.Member
+  alias Mv.MembershipFees.MembershipFeeType
+  alias Mv.MembershipFees.MembershipFeeCycle
+
+  require Ash.Query
+
+  setup %{conn: conn} do
+    # Create admin user
+    {:ok, user} =
+      Mv.Accounts.User
+      |> Ash.Changeset.for_create(:register_with_password, %{
+        email: "admin#{System.unique_integer([:positive])}@mv.local",
+        password: "testpassword123"
+      })
+      |> Ash.create()
+
+    conn = conn_with_password_user(conn, user)
+    %{conn: conn, user: user}
+  end
+
+  # Helper to create a membership fee type
+  defp create_fee_type(attrs) do
+    default_attrs = %{
+      name: "Test Fee Type #{System.unique_integer([:positive])}",
+      amount: Decimal.new("50.00"),
+      interval: :yearly
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeType
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a member
+  defp create_member(attrs) do
+    default_attrs = %{
+      first_name: "Test",
+      last_name: "Member",
+      email: "test.member.#{System.unique_integer([:positive])}@example.com"
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    Member
+    |> Ash.Changeset.for_create(:create_member, attrs)
+    |> Ash.create!()
+  end
+
+  # Helper to create a cycle
+  defp create_cycle(member, fee_type, attrs) do
+    # Delete any auto-generated cycles first to avoid conflicts
+    existing_cycles =
+      MembershipFeeCycle
+      |> Ash.Query.filter(member_id == ^member.id)
+      |> Ash.read!()
+
+    Enum.each(existing_cycles, fn cycle -> Ash.destroy!(cycle) end)
+
+    default_attrs = %{
+      cycle_start: ~D[2023-01-01],
+      amount: Decimal.new("50.00"),
+      member_id: member.id,
+      membership_fee_type_id: fee_type.id,
+      status: :unpaid
+    }
+
+    attrs = Map.merge(default_attrs, attrs)
+
+    MembershipFeeCycle
+    |> Ash.Changeset.for_create(:create, attrs)
+    |> Ash.create!()
+  end
+
+  describe "cycles table display" do
+    test "displays all cycles for member", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      _cycle1 = create_cycle(member, fee_type, %{cycle_start: ~D[2022-01-01], status: :paid})
+      _cycle2 = create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :unpaid})
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}")
+
+      # Switch to membership fees tab
+      view
+      |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+      |> render_click()
+
+      html = render(view)
+
+      # Should show cycles table
+      assert html =~ "Membership Fees" || html =~ "Mitgliedsbeiträge"
+      # Check for formatted cycle dates (e.g., "01.01.2022" or "2022")
+      assert html =~ "2022" || html =~ "2023" || html =~ "01.01.2022" || html =~ "01.01.2023"
+    end
+
+    test "table columns show correct data", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly, amount: Decimal.new("60.00")})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      create_cycle(member, fee_type, %{
+        cycle_start: ~D[2023-01-01],
+        amount: Decimal.new("60.00"),
+        status: :paid
+      })
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}")
+
+      # Switch to membership fees tab
+      view
+      |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+      |> render_click()
+
+      html = render(view)
+
+      # Should show interval, amount, status
+      assert html =~ "Yearly" || html =~ "Jährlich"
+      assert html =~ "60" || html =~ "60,00"
+      assert html =~ "paid" || html =~ "bezahlt"
+    end
+  end
+
+  describe "membership fee type display" do
+    test "shows assigned membership fee type", %{conn: conn} do
+      yearly_type = create_fee_type(%{interval: :yearly, name: "Yearly Type"})
+      _monthly_type = create_fee_type(%{interval: :monthly, name: "Monthly Type"})
+
+      member = create_member(%{membership_fee_type_id: yearly_type.id})
+
+      {:ok, _view, html} = live(conn, "/members/#{member.id}")
+
+      # Should show yearly type name
+      assert html =~ "Yearly Type"
+    end
+
+    test "shows no type message when no type assigned", %{conn: conn} do
+      member = create_member(%{})
+
+      {:ok, _view, html} = live(conn, "/members/#{member.id}")
+
+      # Should show message about no type assigned
+      assert html =~ "No membership fee type assigned" || html =~ "No type"
+    end
+  end
+
+  describe "status change actions" do
+    test "mark as paid works", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      cycle = create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :unpaid})
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}")
+
+      # Switch to membership fees tab
+      view
+      |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+      |> render_click()
+
+      # Mark as paid
+      view
+      |> element(
+        "button[phx-click='mark_cycle_status'][phx-value-cycle_id='#{cycle.id}'][phx-value-status='paid']"
+      )
+      |> render_click()
+
+      # Verify cycle is now paid
+      updated_cycle = Ash.read_one!(MembershipFeeCycle |> Ash.Query.filter(id == ^cycle.id))
+      assert updated_cycle.status == :paid
+    end
+
+    test "mark as suspended works", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      cycle = create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :unpaid})
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}")
+
+      # Switch to membership fees tab
+      view
+      |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+      |> render_click()
+
+      # Mark as suspended
+      view
+      |> element(
+        "button[phx-click='mark_cycle_status'][phx-value-cycle_id='#{cycle.id}'][phx-value-status='suspended']"
+      )
+      |> render_click()
+
+      # Verify cycle is now suspended
+      updated_cycle = Ash.read_one!(MembershipFeeCycle |> Ash.Query.filter(id == ^cycle.id))
+      assert updated_cycle.status == :suspended
+    end
+
+    test "mark as unpaid works", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      cycle = create_cycle(member, fee_type, %{cycle_start: ~D[2023-01-01], status: :paid})
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}")
+
+      # Switch to membership fees tab
+      view
+      |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+      |> render_click()
+
+      # Mark as unpaid
+      view
+      |> element(
+        "button[phx-click='mark_cycle_status'][phx-value-cycle_id='#{cycle.id}'][phx-value-status='unpaid']"
+      )
+      |> render_click()
+
+      # Verify cycle is now unpaid
+      updated_cycle = Ash.read_one!(MembershipFeeCycle |> Ash.Query.filter(id == ^cycle.id))
+      assert updated_cycle.status == :unpaid
+    end
+  end
+
+  describe "cycle regeneration" do
+    test "manual regeneration button exists and can be clicked", %{conn: conn} do
+      fee_type = create_fee_type(%{interval: :yearly})
+      member = create_member(%{membership_fee_type_id: fee_type.id})
+
+      {:ok, view, _html} = live(conn, "/members/#{member.id}")
+
+      # Switch to membership fees tab
+      view
+      |> element("button[phx-click='switch_tab'][phx-value-tab='membership_fees']")
+      |> render_click()
+
+      # Verify regenerate button exists
+      assert has_element?(view, "button[phx-click='regenerate_cycles']")
+
+      # Trigger regeneration (just verify it doesn't crash)
+      view
+      |> element("button[phx-click='regenerate_cycles']")
+      |> render_click()
+
+      # Verify the action completed without error
+      # (The actual cycle generation depends on many factors, so we just test the UI works)
+      assert render(view) =~ "Membership Fees" || render(view) =~ "Mitgliedsbeiträge"
+    end
+  end
+
+  describe "edge cases" do
+    test "handles members without membership fee type gracefully", %{conn: conn} do
+      # No fee type
+      member = create_member(%{})
+
+      {:ok, _view, html} = live(conn, "/members/#{member.id}")
+
+      # Should not crash
+      assert html =~ member.first_name
+    end
+  end
+end

test/mv_web/member_live/show_test.exs

@@ -0,0 +1,175 @@
+defmodule MvWeb.MemberLive.ShowTest do
+  @moduledoc """
+  Tests for the member show page.
+
+  Tests cover:
+  - Displaying member information
+  - Custom Fields section visibility (Issue #282 regression test)
+  - Custom field values formatting
+
+  ## Note on async: false
+  Tests use `async: false` (not `async: true`) to prevent PostgreSQL deadlocks
+  when creating members and custom fields concurrently. This is intentional and
+  documented here to avoid confusion in commit messages.
+  """
+  # async: false to prevent PostgreSQL deadlocks when creating members and custom fields
+  use MvWeb.ConnCase, async: false
+  import Phoenix.LiveViewTest
+  require Ash.Query
+  use Gettext, backend: MvWeb.Gettext
+
+  alias Mv.Membership.{CustomField, CustomFieldValue, Member}
+
+  setup do
+    # Create test member
+    {:ok, member} =
+      Member
+      |> Ash.Changeset.for_create(:create_member, %{
+        first_name: "Alice",
+        last_name: "Anderson",
+        email: "alice@example.com"
+      })
+      |> Ash.create()
+
+    %{member: member}
+  end
+
+  describe "custom fields section visibility (Issue #282)" do
+    test "displays Custom Fields section even when member has no custom field values", %{
+      conn: conn,
+      member: member
+    } do
+      # Create a custom field but no value for the member
+      {:ok, custom_field} =
+        CustomField
+        |> Ash.Changeset.for_create(:create, %{
+          name: "phone_mobile",
+          value_type: :string
+        })
+        |> Ash.create()
+
+      conn = conn_with_oidc_user(conn)
+      {:ok, _view, html} = live(conn, ~p"/members/#{member}")
+
+      # Custom Fields section should be visible
+      assert html =~ gettext("Custom Fields")
+
+      # Custom field label should be visible
+      assert html =~ custom_field.name
+
+      # Value should show placeholder for empty value
+      assert html =~ "—" or html =~ gettext("Not set")
+    end
+
+    test "displays Custom Fields section with multiple custom fields, some without values", %{
+      conn: conn,
+      member: member
+    } do
+      # Create multiple custom fields
+      {:ok, field1} =
+        CustomField
+        |> Ash.Changeset.for_create(:create, %{
+          name: "phone_mobile",
+          value_type: :string
+        })
+        |> Ash.create()
+
+      {:ok, field2} =
+        CustomField
+        |> Ash.Changeset.for_create(:create, %{
+          name: "membership_number",
+          value_type: :integer
+        })
+        |> Ash.create()
+
+      # Create value only for first field
+      {:ok, _cfv} =
+        CustomFieldValue
+        |> Ash.Changeset.for_create(:create, %{
+          member_id: member.id,
+          custom_field_id: field1.id,
+          value: %{"_union_type" => "string", "_union_value" => "+49123456789"}
+        })
+        |> Ash.create()
+
+      conn = conn_with_oidc_user(conn)
+      {:ok, _view, html} = live(conn, ~p"/members/#{member}")
+
+      # Custom Fields section should be visible
+      assert html =~ gettext("Custom Fields")
+
+      # Both field labels should be visible
+      assert html =~ field1.name
+      assert html =~ field2.name
+
+      # First field should show value
+      assert html =~ "+49123456789"
+
+      # Second field should show placeholder
+      assert html =~ "—" or html =~ gettext("Not set")
+    end
+
+    test "does not display Custom Fields section when no custom fields exist", %{
+      conn: conn,
+      member: member
+    } do
+      conn = conn_with_oidc_user(conn)
+      {:ok, _view, html} = live(conn, ~p"/members/#{member}")
+
+      # Custom Fields section should NOT be visible
+      refute html =~ gettext("Custom Fields")
+    end
+  end
+
+  describe "custom field value formatting" do
+    test "formats string custom field values", %{conn: conn, member: member} do
+      {:ok, custom_field} =
+        CustomField
+        |> Ash.Changeset.for_create(:create, %{
+          name: "phone_mobile",
+          value_type: :string
+        })
+        |> Ash.create()
+
+      {:ok, _cfv} =
+        CustomFieldValue
+        |> Ash.Changeset.for_create(:create, %{
+          member_id: member.id,
+          custom_field_id: custom_field.id,
+          value: %{"_union_type" => "string", "_union_value" => "+49123456789"}
+        })
+        |> Ash.create()
+
+      conn = conn_with_oidc_user(conn)
+      {:ok, _view, html} = live(conn, ~p"/members/#{member}")
+
+      assert html =~ "+49123456789"
+    end
+
+    test "formats email custom field values as mailto links", %{conn: conn, member: member} do
+      {:ok, custom_field} =
+        CustomField
+        |> Ash.Changeset.for_create(:create, %{
+          name: "private_email",
+          value_type: :email
+        })
+        |> Ash.create()
+
+      {:ok, _cfv} =
+        CustomFieldValue
+        |> Ash.Changeset.for_create(:create, %{
+          member_id: member.id,
+          custom_field_id: custom_field.id,
+          value: %{"_union_type" => "email", "_union_value" => "private@example.com"}
+        })
+        |> Ash.create()
+
+      conn = conn_with_oidc_user(conn)
+      {:ok, _view, html} = live(conn, ~p"/members/#{member}")
+
+      # Should contain mailto link
+      assert html =~ ~s(href="mailto:private@example.com")
+      assert html =~ "private@example.com"
+    end
+  end
+end

test/mv_web/user_live/form_test.exs

@@ -1,5 +1,6 @@
 defmodule MvWeb.UserLive.FormTest do
-  use MvWeb.ConnCase, async: true
+  # async: false to prevent PostgreSQL deadlocks when creating members and users
+  use MvWeb.ConnCase, async: false
   import Phoenix.LiveViewTest
 
   # Helper to setup authenticated connection and live view