refactor

test/membership/custom_field_slug_test.exs

@@ -1,13 +1,14 @@
 defmodule Mv.Membership.CustomFieldSlugTest do
   @moduledoc """
-  Tests for automatic slug generation on CustomField resource.
+  Tests for CustomField slug business rules only.
 
-  This test suite verifies:
-  1. Slugs are automatically generated from the name attribute
-  2. Slugs are unique (cannot have duplicates)
-  3. Slugs are immutable (don't change when name changes)
-  4. Slugs handle various edge cases (unicode, special chars, etc.)
-  5. Slugs can be used for lookups
+  We test our business logic, not Ash/slugify implementation details:
+  - Slug is generated from name on create (one smoke test)
+  - Slug is unique (business rule)
+  - Slug is immutable (does not change when name is updated; cannot be set manually)
+  - Slug cannot be empty (rejects name with only special characters)
+
+  We do not test: slugify edge cases (umlauts, truncation, etc.) or Ash/Ecto struct/load behavior.
   """
   use Mv.DataCase, async: true
 
@@ -18,8 +19,8 @@ defmodule Mv.Membership.CustomFieldSlugTest do
     %{actor: system_actor}
   end
 
-  describe "automatic slug generation on create" do
-    test "generates slug from name with simple ASCII text", %{actor: actor} do
+  describe "slug generation (business rule)" do
+    test "slug is generated from name on create", %{actor: actor} do
       {:ok, custom_field} =
         CustomField
         |> Ash.Changeset.for_create(:create, %{
@@ -30,78 +31,6 @@ defmodule Mv.Membership.CustomFieldSlugTest do
 
       assert custom_field.slug == "mobile-phone"
     end
-
-    test "generates slug from name with German umlauts", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Café Müller",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      assert custom_field.slug == "cafe-muller"
-    end
-
-    test "generates slug with lowercase conversion", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "TEST NAME",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      assert custom_field.slug == "test-name"
-    end
-
-    test "generates slug by removing special characters", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "E-Mail & Address!",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      assert custom_field.slug == "e-mail-address"
-    end
-
-    test "generates slug by replacing multiple spaces with single hyphen", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Multiple   Spaces",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      assert custom_field.slug == "multiple-spaces"
-    end
-
-    test "trims leading and trailing hyphens", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "-Test-",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      assert custom_field.slug == "test"
-    end
-
-    test "handles unicode characters properly (ß becomes ss)", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Straße",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      assert custom_field.slug == "strasse"
-    end
   end
 
   describe "slug uniqueness" do
@@ -248,29 +177,8 @@ defmodule Mv.Membership.CustomFieldSlugTest do
     end
   end
 
-  describe "slug edge cases" do
-    test "handles very long names by truncating slug", %{actor: actor} do
-      # Create a name at the maximum length (100 chars)
-      long_name = String.duplicate("abcdefghij", 10)
-      # 100 characters exactly
-
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: long_name,
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      # Slug should be truncated to maximum 100 characters
-      assert String.length(custom_field.slug) <= 100
-      # Should be the full slugified version since name is exactly 100 chars
-      assert custom_field.slug == long_name
-    end
-
+  describe "slug cannot be empty (business rule)" do
     test "rejects name with only special characters", %{actor: actor} do
-      # When name contains only special characters, slug would be empty
-      # This should fail validation
       assert {:error, %Ash.Error.Invalid{} = error} =
                CustomField
                |> Ash.Changeset.for_create(:create, %{
@@ -279,107 +187,9 @@ defmodule Mv.Membership.CustomFieldSlugTest do
                })
                |> Ash.create(actor: actor)
 
-      # Should fail because slug would be empty
       error_message = Exception.message(error)
       assert error_message =~ "Slug cannot be empty" or error_message =~ "is required"
     end
-
-    test "handles mixed special characters and text", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Test@#$%Name",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      # slugify keeps the hyphen between words
-      assert custom_field.slug == "test-name"
-    end
-
-    test "handles numbers in name", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Field 123 Test",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      assert custom_field.slug == "field-123-test"
-    end
-
-    test "handles consecutive hyphens in name", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Test---Name",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      # Should reduce multiple hyphens to single hyphen
-      assert custom_field.slug == "test-name"
-    end
-
-    test "handles name with dots and underscores", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "test.field_name",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      # Dots and underscores should be handled (either kept or converted)
-      assert custom_field.slug =~ ~r/^[a-z0-9-]+$/
-    end
-  end
-
-  describe "slug in queries and responses" do
-    test "slug is included in struct after create", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Test",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      # Slug should be present in the struct
-      assert Map.has_key?(custom_field, :slug)
-      assert custom_field.slug != nil
-    end
-
-    test "can load custom field and slug is present", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Test",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      # Load it back
-      loaded_custom_field = Ash.get!(CustomField, custom_field.id, actor: actor)
-
-      assert loaded_custom_field.slug == "test"
-    end
-
-    test "slug is returned in list queries", %{actor: actor} do
-      {:ok, custom_field} =
-        CustomField
-        |> Ash.Changeset.for_create(:create, %{
-          name: "Test",
-          value_type: :string
-        })
-        |> Ash.create(actor: actor)
-
-      custom_fields = Ash.read!(CustomField, actor: actor)
-
-      found = Enum.find(custom_fields, &(&1.id == custom_field.id))
-      assert found.slug == "test"
-    end
   end
 
   describe "slug-based lookup (future feature)" do