improvement: run notifications for generators

test: add tests specifically for generator pattern

lib/ash/generator/generator.ex

@@ -465,7 +465,7 @@ defmodule Ash.Generator do
         ) ::
           Ash.Resource.record()
   def generate(%Ash.Changeset{} = changeset) do
-    Ash.create!(changeset, return_notifications?: true) |> elem(0)
+    Ash.create!(changeset)
   end
 
   def generate(changeset_generator) do
@@ -500,31 +500,31 @@ defmodule Ash.Generator do
       [%Ash.Changeset{} = first | _rest] = batch ->
         after_action = first.context[:private][:generator_after_action]
 
-        after_action =
+        opts = [
+          return_records?: true,
+          return_errors?: true,
+          notify?: true,
+          sorted?: true,
+          stop_on_error?: true,
+          actor: first.context[:private][:actor]
+        ]
+
+        opts =
           if after_action do
-            fn _changeset, record ->
+            Keyword.put(opts, :after_action, fn _changeset, record ->
               {:ok, after_action.(record)}
-            end
+            end)
           else
-            # Do nothing
-            fn _changeset, record -> {:ok, record} end
+            opts
           end
 
         result =
-          Ash.bulk_create!(Enum.map(batch, & &1.params), first.resource, first.action.name,
-            after_action: after_action,
-            return_records?: true,
-            return_errors?: true,
-            return_notifications?: true,
-            actor: first.context[:private][:actor]
-          )
+          Ash.bulk_create!(Enum.map(batch, & &1.params), first.resource, first.action.name, opts)
 
         if result.status != :success do
           raise Ash.Error.to_error_class(result.errors)
         end
 
-        Ash.Notifier.notify(result.notifications)
-
         result.records || []
 
       batch ->

test/generator/generator_test.exs

@@ -179,6 +179,64 @@ defmodule Ash.Test.GeneratorTest do
     end
   end
 
+  defmodule Generator do
+    use Ash.Generator
+
+    def seed_post(opts \\ []) do
+      seed_generator(
+        %Post{
+          title: sequence(:title, &"Post #{&1}")
+        },
+        overrides: opts
+      )
+    end
+
+    def post(opts \\ []) do
+      changeset_generator(Post, :create,
+        defaults: [title: sequence(:title, &"Post #{&1}")],
+        overrides: opts
+      )
+    end
+  end
+
+  describe "generator" do
+    test "can generate one" do
+      import Generator
+      assert %Post{title: "Post 0"} = generate(post())
+      assert %Post{title: "Post 1"} = generate(seed_post())
+    end
+
+    test "can generate many" do
+      import Generator
+      assert [%Post{title: "Post 0"}, %Post{title: "Post 1"}] = generate_many(post(), 2)
+      assert [%Post{title: "Post 2"}, %Post{title: "Post 3"}] = generate_many(seed_post(), 2)
+    end
+
+    test "errors are raised when generating invalid single items" do
+      import Generator
+
+      assert_raise Ash.Error.Invalid, ~r/Invalid value provided for title/, fn ->
+        generate(post(title: %{a: :b}))
+      end
+
+      assert_raise Ash.Error.Invalid, ~r/Invalid value provided for title/, fn ->
+        generate(seed_post(title: %{a: :b}))
+      end
+    end
+
+    test "errors are raised when generating invalid many items" do
+      import Generator
+
+      assert_raise Ash.Error.Invalid, ~r/Invalid value provided for title/, fn ->
+        generate_many(post(title: %{a: :b}), 2)
+      end
+
+      assert_raise Ash.Error.Invalid, ~r/Invalid value provided for title/, fn ->
+        generate_many(post(title: %{a: :b}), 2)
+      end
+    end
+  end
+
   describe "action_input" do
     test "action input can be provided to an action" do
       check all(input <- Ash.Generator.action_input(Post, :create)) do