test: add tests for join form settings

test/membership/setting_join_form_test.exs

@@ -0,0 +1,281 @@
+defmodule Mv.Membership.SettingJoinFormTest do
+  @moduledoc """
+  TDD tests for Join Form Settings (onboarding-join-concept subtask 3).
+
+  These tests define the expected API and behaviour for the "Onboarding / Join" section
+  in global settings. No functionality is implemented yet; tests are expected to fail
+  (red) until:
+
+  - Setting resource has attributes: `join_form_enabled`, `join_form_field_ids`,
+    `join_form_field_required`, plus validations and accept in the update action.
+  - `Mv.Membership.get_join_form_allowlist/0` is implemented and returns the allowlist
+    for the public join form (subtask 4).
+  """
+  use Mv.DataCase, async: false
+
+  alias Mv.Membership
+  alias Mv.Helpers.SystemActor
+  alias Mv.Constants
+
+  setup do
+    {:ok, settings} = Membership.get_settings()
+    saved_enabled = Map.get(settings, :join_form_enabled)
+    saved_ids = Map.get(settings, :join_form_field_ids)
+    saved_required = Map.get(settings, :join_form_field_required)
+
+    on_exit(fn ->
+      {:ok, s} = Membership.get_settings()
+      attrs = %{}
+      attrs = if saved_enabled != nil, do: Map.put(attrs, :join_form_enabled, saved_enabled), else: attrs
+      attrs = if saved_ids != nil, do: Map.put(attrs, :join_form_field_ids, saved_ids || []), else: attrs
+      attrs =
+        if saved_required != nil,
+          do: Map.put(attrs, :join_form_field_required, saved_required || %{}),
+          else: attrs
+
+      if attrs != %{} do
+        Membership.update_settings(s, attrs)
+      end
+    end)
+
+    :ok
+  end
+
+  defp update_join_form_settings(settings, attrs) do
+    Membership.update_settings(settings, attrs)
+  end
+
+  defp error_message(errors, field) when is_atom(field) do
+    errors
+    |> Enum.filter(fn err -> Map.get(err, :field) == field end)
+    |> Enum.map(&Map.get(&1, :message, ""))
+    |> List.first() || ""
+  end
+
+  # ---- 1. Persistence and loading ----
+
+  describe "join form settings persistence and loading" do
+    test "save and load join_form_enabled plus field selection and required flags returns same config" do
+      {:ok, settings} = Membership.get_settings()
+      attrs = %{
+        join_form_enabled: true,
+        join_form_field_ids: ["email", "first_name"],
+        join_form_field_required: %{"email" => true, "first_name" => false}
+      }
+
+      assert {:ok, updated} = update_join_form_settings(settings, attrs)
+      assert updated.join_form_enabled == true
+      assert updated.join_form_field_ids == ["email", "first_name"]
+      assert updated.join_form_field_required["email"] == true
+      assert updated.join_form_field_required["first_name"] == false
+
+      {:ok, reloaded} = Membership.get_settings()
+      assert reloaded.join_form_enabled == true
+      assert reloaded.join_form_field_ids == ["email", "first_name"]
+      assert reloaded.join_form_field_required["email"] == true
+      assert reloaded.join_form_field_required["first_name"] == false
+    end
+
+    test "repeated save with changed field list overwrites config without leftovers" do
+      {:ok, settings} = Membership.get_settings()
+      assert {:ok, _} = update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: ["email", "first_name"],
+        join_form_field_required: %{"email" => true, "first_name" => false}
+      })
+
+      assert {:ok, updated} = update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: ["email", "last_name"],
+        join_form_field_required: %{"email" => true, "last_name" => false}
+      })
+
+      assert updated.join_form_field_ids == ["email", "last_name"]
+      assert Map.has_key?(updated.join_form_field_required, "last_name")
+      refute Map.has_key?(updated.join_form_field_required, "first_name")
+    end
+  end
+
+  # ---- 2. Validation ----
+
+  describe "join form settings validation" do
+    test "only existing member fields or custom field ids are accepted; unknown field names rejected or sanitized" do
+      {:ok, settings} = Membership.get_settings()
+
+      result = update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: ["email", "not_a_member_field"],
+        join_form_field_required: %{"email" => true, "not_a_member_field" => false}
+      })
+
+      # Until attributes exist we get NoSuchInput; once implemented we expect validation error
+      assert {:error, _} = result
+    end
+
+    test "config without email is rejected or email is auto-added and required" do
+      {:ok, settings} = Membership.get_settings()
+
+      result = update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: ["first_name", "last_name"],
+        join_form_field_required: %{"first_name" => true, "last_name" => false}
+      })
+
+      # Either rejected or, when loaded, email must be present and required
+      case result do
+        {:error, _} ->
+          :ok
+        {:ok, updated} ->
+          assert "email" in updated.join_form_field_ids
+          assert updated.join_form_field_required["email"] == true
+      end
+    end
+
+    test "required false for email is ignored or forced to true when saved" do
+      {:ok, settings} = Membership.get_settings()
+
+      {:ok, updated} = update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: ["email", "first_name"],
+        join_form_field_required: %{"email" => false, "first_name" => false}
+      })
+
+      assert updated.join_form_field_required["email"] == true
+    end
+
+    test "required flag for field not in join_form_field_ids is rejected or dropped" do
+      {:ok, settings} = Membership.get_settings()
+
+      result = update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: ["email"],
+        join_form_field_required: %{"email" => true, "first_name" => true}
+      })
+
+      case result do
+        {:error, _} ->
+          :ok
+        {:ok, updated} ->
+          refute Map.has_key?(updated.join_form_field_required, "first_name")
+      end
+    end
+  end
+
+  # ---- 3. Allowlist for join form ----
+
+  describe "join form allowlist" do
+    test "allowlist returns configured fields with required/optional when join form enabled" do
+      {:ok, settings} = Membership.get_settings()
+      update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: ["email", "first_name"],
+        join_form_field_required: %{"email" => true, "first_name" => false}
+      })
+
+      allowlist = Membership.get_join_form_allowlist()
+
+      assert length(allowlist) == 2
+      email_entry = Enum.find(allowlist, &( &1.id == "email" ))
+      first_name_entry = Enum.find(allowlist, &( &1.id == "first_name" ))
+      assert email_entry.required == true
+      assert first_name_entry.required == false
+      assert email_entry.type == :member_field
+      assert first_name_entry.type == :member_field
+    end
+
+    test "allowlist returns empty or defined default when join form disabled" do
+      {:ok, settings} = Membership.get_settings()
+      update_join_form_settings(settings, %{
+        join_form_enabled: false,
+        join_form_field_ids: ["email", "first_name"],
+        join_form_field_required: %{"email" => true, "first_name" => false}
+      })
+
+      allowlist = Membership.get_join_form_allowlist()
+
+      assert allowlist == []
+    end
+
+    @tag :requires_custom_field
+    test "allowlist distinguishes member fields and custom field identifiers" do
+      {:ok, settings} = Membership.get_settings()
+      actor = SystemActor.get_system_actor()
+      {:ok, cf} =
+        Membership.create_custom_field(
+          %{name: "join_cf_#{System.unique_integer([:positive])}", value_type: :string},
+          actor: actor
+        )
+      update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: ["email", cf.id],
+        join_form_field_required: %{"email" => true, cf.id => false}
+      })
+
+      allowlist = Membership.get_join_form_allowlist()
+
+      email_entry = Enum.find(allowlist, &( &1.id == "email" ))
+      cf_entry = Enum.find(allowlist, &( &1.id == cf.id ))
+      assert email_entry.type == :member_field
+      assert cf_entry.type == :custom_field
+    end
+  end
+
+  # ---- 4. Defaults and fallback ----
+
+  describe "join form defaults and fallback" do
+    test "when no join settings stored, allowlist returns defined default (e.g. disabled, empty list)" do
+      allowlist = Membership.get_join_form_allowlist()
+      # Default: join form disabled → empty allowlist
+      assert is_list(allowlist)
+      assert allowlist == [] || Enum.all?(allowlist, &(is_map(&1) and Map.has_key?(&1, :id)))
+    end
+
+    test "existing settings without join keys load correctly; new join keys get defaults" do
+      {:ok, settings} = Membership.get_settings()
+      # Ensure other attributes still load
+      assert Map.has_key?(settings, :club_name)
+      # When join keys exist they have sensible defaults
+      join_enabled = Map.get(settings, :join_form_enabled)
+      join_ids = Map.get(settings, :join_form_field_ids)
+      if join_enabled != nil, do: assert(is_boolean(join_enabled))
+      if join_ids != nil, do: assert(is_list(join_ids))
+    end
+  end
+
+  # ---- 5. Authorization (backend: settings update requires authorized actor when policy enforced) ----
+  # Authorization for the settings page is covered by GlobalSettingsLive and page-permission tests.
+  # If the domain later requires an actor for update_settings, tests here would pass an actor.
+
+  # ---- 6. Robustness / edge cases ----
+
+  describe "join form settings robustness" do
+    test "invalid or unexpected payload structure yields clean error or ignores unknown keys" do
+      {:ok, settings} = Membership.get_settings()
+
+      result = update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: "not_a_list",
+        join_form_field_required: %{}
+      })
+
+      assert match?({:error, _}, result) or
+               (match?({:ok, _}, result) && elem(result, 1).join_form_field_ids != "not_a_list")
+    end
+
+    test "larger but reasonable number of fields saves and loads without error" do
+      {:ok, settings} = Membership.get_settings()
+      all_member = Constants.member_fields() |> Enum.map(&to_string/1)
+      required_map = Map.new(all_member, fn f -> {f, f == "email"} end)
+
+      assert {:ok, updated} = update_join_form_settings(settings, %{
+        join_form_enabled: true,
+        join_form_field_ids: all_member,
+        join_form_field_required: required_map
+      })
+
+      assert length(updated.join_form_field_ids) == length(all_member)
+      {:ok, reloaded} = Membership.get_settings()
+      assert length(reloaded.join_form_field_ids) == length(all_member)
+    end
+  end
+end