mirror of
https://github.com/ash-project/ash_phoenix.git
synced 2024-09-20 07:12:49 +12:00
01ca583443
Co-Authored By: Zach Daniel
1837 lines
53 KiB
Elixir
1837 lines
53 KiB
Elixir
defmodule AshPhoenix.FormTest do
|
|
use ExUnit.Case
|
|
import ExUnit.CaptureLog
|
|
|
|
alias AshPhoenix.Form
|
|
alias AshPhoenix.Test.{Domain, Artist, Author, Comment, Post, PostWithDefault}
|
|
alias Phoenix.HTML.FormData
|
|
|
|
defp form_for(form, _) do
|
|
Phoenix.HTML.FormData.to_form(form, [])
|
|
end
|
|
|
|
defp inputs_for(form, key) do
|
|
form[key].value
|
|
end
|
|
|
|
describe "validate_opts" do
|
|
test "errors are not set on the parent and list child form" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form([:comments], validate_opts: [errors: false])
|
|
|> form_for("action")
|
|
|
|
assert form.errors == []
|
|
assert Form.errors(form.source, for_path: [:comments, 0]) == []
|
|
end
|
|
|
|
test "unknown errors produce warnings" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
params: %{"text" => "bar"},
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create_with_unknown_error
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form([:comments], params: %{"text" => "foo"}, validate_opts: [errors: true])
|
|
|> form_for("action")
|
|
|
|
assert capture_log(fn ->
|
|
Form.errors(form.source, for_path: [:comments, 0]) == []
|
|
end) =~
|
|
"Unhandled error in form submission for AshPhoenix.Test.Comment.create_with_unknown_error"
|
|
end
|
|
|
|
test "update_form marks touched by default" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
params: %{"text" => "bar"},
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create_with_unknown_error
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form([:comments], params: %{"text" => "foo"})
|
|
|> Form.update_form([:comments, 0], & &1)
|
|
|
|
assert MapSet.member?(form.touched_forms, "comments")
|
|
end
|
|
|
|
test "errors are not set on the parent and single child form" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :single,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form([:post], validate_opts: [errors: false])
|
|
|> form_for("action")
|
|
|
|
assert form.errors == []
|
|
assert Form.errors(form.source, for_path: [:post]) == []
|
|
end
|
|
end
|
|
|
|
describe "clear_value/1" do
|
|
test "it clears attributes" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create)
|
|
|> Form.validate(%{"text" => "text"})
|
|
|
|
assert Form.value(form, :text) == "text"
|
|
assert form.source.attributes == %{text: "text"}
|
|
assert form.source.params == %{"text" => "text"}
|
|
assert form.params == %{"text" => "text"}
|
|
|
|
form = Form.clear_value(form, :text)
|
|
|
|
assert Form.value(form, :text) == nil
|
|
assert form.source.attributes == %{}
|
|
assert form.source.params == %{}
|
|
assert form.params == %{}
|
|
end
|
|
|
|
test "it clears arguments" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create)
|
|
|> Form.validate(%{"excerpt" => "text"})
|
|
|
|
assert Form.value(form, :excerpt) == "text"
|
|
assert form.source.arguments == %{excerpt: "text"}
|
|
assert form.source.params == %{"excerpt" => "text"}
|
|
assert form.params == %{"excerpt" => "text"}
|
|
|
|
form = Form.clear_value(form, :excerpt)
|
|
|
|
assert Form.value(form, :excerpt) == nil
|
|
assert form.source.arguments == %{}
|
|
assert form.source.params == %{}
|
|
assert form.params == %{}
|
|
end
|
|
|
|
test "it clears multiple fields" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create)
|
|
|> Form.validate(%{"excerpt" => "text", "text" => "text"})
|
|
|
|
assert Form.value(form, :excerpt) == "text"
|
|
assert Form.value(form, :text) == "text"
|
|
|
|
assert form.source.attributes == %{text: "text"}
|
|
assert form.source.arguments == %{excerpt: "text"}
|
|
assert form.source.params == %{"excerpt" => "text", "text" => "text"}
|
|
assert form.params == %{"excerpt" => "text", "text" => "text"}
|
|
|
|
form = Form.clear_value(form, [:excerpt, :text])
|
|
|
|
assert Form.value(form, :text) == nil
|
|
assert Form.value(form, :excerpt) == nil
|
|
|
|
assert form.params == %{}
|
|
assert form.source.arguments == %{}
|
|
assert form.source.attributes == %{}
|
|
assert form.source.params == %{}
|
|
end
|
|
end
|
|
|
|
describe "validations and form values" do
|
|
test "validation errors don't clear fields" do
|
|
form =
|
|
AshPhoenix.Test.User
|
|
|> AshPhoenix.Form.for_create(:register)
|
|
|> AshPhoenix.Form.validate(%{"password" => "f"})
|
|
|> AshPhoenix.Form.validate(%{"password" => "fo"})
|
|
|> AshPhoenix.Form.validate(%{"password" => "fo", "password_confirmation" => "foo"})
|
|
|
|
assert AshPhoenix.Form.value(form, :password) == "fo"
|
|
end
|
|
|
|
test "form values are retrieved casted for un-changing arguments" do
|
|
form =
|
|
AshPhoenix.Test.User
|
|
|> AshPhoenix.Form.for_create(:register)
|
|
|> AshPhoenix.Form.validate(%{"password" => "f"})
|
|
|> AshPhoenix.Form.validate(%{"password" => :f})
|
|
|
|
assert AshPhoenix.Form.value(form, :password) == "f"
|
|
end
|
|
|
|
test "lists with invalid values return those invalid values when getting them" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create_author_required, domain: Domain, forms: [auto?: true])
|
|
|> Form.validate(%{"list_of_ints" => %{"0" => %{"map" => "of stuff"}}})
|
|
|
|
assert AshPhoenix.Form.value(form, :list_of_ints) == [%{"map" => "of stuff"}]
|
|
end
|
|
end
|
|
|
|
describe "has_form?" do
|
|
test "checks for the existence of a list of forms" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form([:comments])
|
|
|
|
# assert Form.has_form?(form, [:comments])
|
|
assert Form.has_form?(form, [:comments, 0])
|
|
assert Form.has_form?(form, "form[comments][0]")
|
|
|
|
refute Form.has_form?(form, [:comments, 1])
|
|
refute Form.has_form?(form, "form[comments][1]")
|
|
end
|
|
|
|
test "checks for the existence of a single form" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :single,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form([:post])
|
|
|
|
assert Form.has_form?(form, [:post])
|
|
assert Form.has_form?(form, "form[post]")
|
|
|
|
refute Form.has_form?(form, [:unknown])
|
|
refute Form.has_form?(form, "form[unknown]")
|
|
end
|
|
end
|
|
|
|
describe "form_for fields" do
|
|
test "it should show simple field values" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create)
|
|
|> Form.validate(%{"text" => "text"})
|
|
|> form_for("action")
|
|
|
|
assert FormData.input_value(form.source, form, :text) == "text"
|
|
end
|
|
|
|
test "it sets the default id of a form" do
|
|
assert Form.for_create(Post, :create).id == "form"
|
|
assert Form.for_create(Post, :create, as: "post").id == "post"
|
|
end
|
|
end
|
|
|
|
test "a read will validate attributes" do
|
|
form =
|
|
Post
|
|
|> Form.for_read(:read)
|
|
|> Form.validate(%{"text" => [1, 2, 3]})
|
|
|> form_for("action")
|
|
|
|
assert form.errors[:text] == {"is invalid", []}
|
|
end
|
|
|
|
test "validation errors are attached to fields" do
|
|
form = Form.for_create(PostWithDefault, :create, domain: Domain)
|
|
form = AshPhoenix.Form.validate(form, %{"text" => ""}, errors: form.submitted_once?)
|
|
{:error, form} = Form.submit(form, params: %{"text" => ""})
|
|
assert %{errors: [text: {"is required", []}]} = form_for(form, "foo")
|
|
assert form.valid? == false
|
|
end
|
|
|
|
test "blank form values unset - helps support dead view forms" do
|
|
form =
|
|
Form.for_create(PostWithDefault, :create,
|
|
domain: Domain,
|
|
exclude_fields_if_empty: [:text, :title]
|
|
)
|
|
|
|
{:ok, post} = Form.submit(form, params: %{"title" => "", "text" => "bar"})
|
|
assert post.text == "bar"
|
|
assert post.title == nil
|
|
end
|
|
|
|
test "blank nested form values unset - helps support dead view forms" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
post: [
|
|
resource: PostWithDefault,
|
|
create_action: :create
|
|
]
|
|
],
|
|
exclude_fields_if_empty: [post: [:title, :description]]
|
|
)
|
|
|> Form.add_form(:post)
|
|
|
|
{:ok, comment} =
|
|
Form.submit(form,
|
|
params: %{"text" => "comment", "post" => %{"title" => "", "text" => "bar"}}
|
|
)
|
|
|
|
post = comment.post
|
|
assert post.text == "bar"
|
|
assert post.title == nil
|
|
end
|
|
|
|
test "phoenix forms are accepted as input in some cases" do
|
|
form = Form.for_create(PostWithDefault, :create, domain: Domain)
|
|
form = AshPhoenix.Form.validate(form, %{"text" => ""}, errors: form.submitted_once?)
|
|
form = form_for(form, "foo")
|
|
# This simply shouldn't raise
|
|
AshPhoenix.Form.params(form)
|
|
end
|
|
|
|
test "a phoenix form is returned in cases where a phoenix form is passed in" do
|
|
form = Form.for_create(PostWithDefault, :create, domain: Domain)
|
|
form = AshPhoenix.Form.validate(form, %{"text" => ""}, errors: form.submitted_once?)
|
|
form = form_for(form, "foo")
|
|
|
|
assert %Phoenix.HTML.Form{} = AshPhoenix.Form.validate(form, %{})
|
|
end
|
|
|
|
test "it supports forms with data and a `type: :append_and_remove`" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
comment =
|
|
Comment
|
|
|> Ash.Changeset.for_create(:create, %{text: "comment"})
|
|
|> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
|
|
|> Ash.create!()
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update_with_replace,
|
|
domain: Domain,
|
|
forms: [
|
|
comments: [
|
|
read_resource: Comment,
|
|
type: :list,
|
|
read_action: :read,
|
|
data: [comment]
|
|
]
|
|
]
|
|
)
|
|
|
|
assert [comment_form] = inputs_for(form_for(form, "blah"), :comments)
|
|
|
|
assert Phoenix.HTML.Form.input_value(comment_form, :text) == "comment"
|
|
|
|
form = Form.validate(form, %{"comments" => [%{"id" => comment.id}]})
|
|
|
|
comment_id = comment.id
|
|
|
|
assert %{"comments" => [%{"id" => ^comment_id}]} = Form.params(form)
|
|
end
|
|
|
|
test "ignoring a form filters it from the parameters" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
comment =
|
|
Comment
|
|
|> Ash.Changeset.for_create(:create, %{text: "comment"})
|
|
|> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
|
|
|> Ash.create!()
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update_with_replace,
|
|
domain: Domain,
|
|
forms: [
|
|
comments: [
|
|
read_resource: Comment,
|
|
type: :list,
|
|
read_action: :read,
|
|
data: [comment]
|
|
]
|
|
]
|
|
)
|
|
|
|
assert [comment_form] = inputs_for(form_for(form, "blah"), :comments)
|
|
|
|
assert Phoenix.HTML.Form.input_value(comment_form, :text) == "comment"
|
|
|
|
form = Form.validate(form, %{"comments" => [%{"id" => comment.id, "_ignore" => "true"}]})
|
|
|
|
assert %{"comments" => []} = Form.params(form)
|
|
|
|
form = Form.validate(form, %{"comments" => [%{"id" => comment.id, "_ignore" => "false"}]})
|
|
|
|
comment_id = comment.id
|
|
assert %{"comments" => [%{"id" => ^comment_id, "_ignore" => "false"}]} = Form.params(form)
|
|
|
|
form = Form.validate(form, %{"comments" => [%{"id" => comment.id, "_ignore" => "true"}]})
|
|
|
|
assert %{"comments" => []} = Form.params(form)
|
|
end
|
|
|
|
describe "the .changed? field is updated as data changes" do
|
|
test "it is false for a create form with no changes" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create)
|
|
|> Form.validate(%{})
|
|
|
|
refute form.changed?
|
|
end
|
|
|
|
test "it is false by default for update forms" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update)
|
|
|> Form.validate(%{})
|
|
|
|
refute form.changed?
|
|
end
|
|
|
|
test "it is true when a change is made" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update)
|
|
|> Form.validate(%{text: "post1"})
|
|
|
|
assert form.changed?
|
|
end
|
|
|
|
test "it goes back to false if the change is unmade" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update)
|
|
|> Form.validate(%{text: "post1"})
|
|
|
|
assert form.changed?
|
|
|
|
form =
|
|
form
|
|
|> Form.validate(%{text: "post"})
|
|
|
|
refute form.changed?
|
|
end
|
|
|
|
test "adding a form causes changed? to be true on the root form, but not the nested form" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
post: [
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post)
|
|
|
|
assert form.changed?
|
|
refute form.forms[:post].changed?
|
|
end
|
|
|
|
test "removing a form that was there prior marks the form as changed" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
comment =
|
|
Comment
|
|
|> Ash.Changeset.for_create(:create, %{text: "comment"})
|
|
|> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
|
|
|> Ash.create!()
|
|
|
|
# Check the persisted post.comments count after create
|
|
post = Post |> Ash.get!(post.id) |> Ash.load!(:comments)
|
|
assert Enum.count(post.comments) == 1
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update,
|
|
domain: Domain,
|
|
forms: [
|
|
comments: [
|
|
resource: Comment,
|
|
type: :list,
|
|
data: [comment],
|
|
create_action: :create,
|
|
update_action: :update
|
|
]
|
|
]
|
|
)
|
|
|
|
refute form.changed?
|
|
|
|
form = Form.remove_form(form, [:comments, 0])
|
|
|
|
assert form.changed?
|
|
end
|
|
|
|
test "generated forms have default values even with no server round-trips" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
comment =
|
|
Comment
|
|
|> Ash.Changeset.for_create(:create, %{text: "comment"})
|
|
|> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
|
|
|> Ash.create!()
|
|
|
|
# Check the persisted post.comments count after create
|
|
post = Post |> Ash.get!(post.id) |> Ash.load!(:comments)
|
|
assert Enum.count(post.comments) == 1
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update,
|
|
domain: Domain,
|
|
forms: [
|
|
comments: [
|
|
resource: Comment,
|
|
type: :list,
|
|
data: [comment],
|
|
create_action: :create,
|
|
update_action: :update
|
|
]
|
|
]
|
|
)
|
|
|
|
form = AshPhoenix.Form.add_form(form, :comments)
|
|
|
|
assert AshPhoenix.Form.params(form, hidden?: true) == %{
|
|
"_form_type" => "update",
|
|
"_touched" => "comments",
|
|
"comments" => [
|
|
%{
|
|
"_form_type" => "update",
|
|
"_touched" => "_form_type,id",
|
|
"id" => post.comments |> Enum.at(0) |> Map.get(:id)
|
|
},
|
|
%{"_form_type" => "create", "_touched" => "_form_type"}
|
|
],
|
|
"id" => post.id
|
|
}
|
|
end
|
|
|
|
test "removing a non-existant form should not change touched_forms" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create, domain: Domain, forms: [auto?: true])
|
|
|> AshPhoenix.Form.remove_form([:author])
|
|
|
|
assert MapSet.member?(form.touched_forms, "author") == false
|
|
end
|
|
|
|
test "removing a form that was added does not mark the form as changed" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
comment =
|
|
Comment
|
|
|> Ash.Changeset.for_create(:create, %{text: "comment"})
|
|
|> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
|
|
|> Ash.create!()
|
|
|
|
# Check the persisted post.comments count after create
|
|
post = Post |> Ash.get!(post.id) |> Ash.load!(:comments)
|
|
assert Enum.count(post.comments) == 1
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update,
|
|
domain: Domain,
|
|
forms: [
|
|
comments: [
|
|
resource: Comment,
|
|
type: :list,
|
|
data: [comment],
|
|
create_action: :create,
|
|
update_action: :update
|
|
]
|
|
]
|
|
)
|
|
|
|
refute form.changed?
|
|
|
|
form = Form.add_form(form, [:comments])
|
|
|
|
assert form.changed?
|
|
|
|
form = Form.remove_form(form, [:comments, 1])
|
|
|
|
refute form.changed?
|
|
end
|
|
end
|
|
|
|
describe "errors" do
|
|
test "errors are not set on the form without validating" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create)
|
|
|> form_for("action")
|
|
|
|
assert form.errors == []
|
|
end
|
|
|
|
test "errors are set on the form according to changeset errors on validate" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create)
|
|
|> Form.validate(%{})
|
|
|> form_for("action")
|
|
|
|
assert form.errors == [{:text, {"is required", []}}]
|
|
end
|
|
|
|
test "nested errors are set on the appropriate form after submit" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
post: [
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{})
|
|
|> Form.validate(%{"text" => "text", "post" => %{}})
|
|
|> Form.submit(force?: true)
|
|
|> elem(1)
|
|
|> form_for("action")
|
|
|
|
assert form.errors == []
|
|
|
|
assert hd(inputs_for(form, :post)).errors == [{:text, {"is required", []}}]
|
|
end
|
|
|
|
test "relationship source data is retained, so that it can be properly removed" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
comment =
|
|
Comment
|
|
|> Ash.Changeset.for_create(:create, %{text: "comment"})
|
|
|> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
|
|
|> Ash.create!()
|
|
|
|
comment = Comment |> Ash.get!(comment.id)
|
|
|
|
comment
|
|
|> Ash.load!(:post)
|
|
|> Form.for_update(:update,
|
|
domain: Domain,
|
|
forms: [
|
|
auto?: true
|
|
]
|
|
)
|
|
|> Form.remove_form([:post])
|
|
|> Form.submit!(params: %{"text" => "text", "post" => %{"text" => "new_post"}})
|
|
|
|
assert [%{text: "new_post"}] = Ash.read!(Post)
|
|
end
|
|
|
|
test "nested errors are set on the appropriate form after submit, even if no submit actually happens" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
post: [
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{})
|
|
|> Form.submit(params: %{"text" => "text", "post" => %{}})
|
|
|> elem(1)
|
|
|> form_for("action")
|
|
|
|
assert form.errors == []
|
|
|
|
assert hd(inputs_for(form, :post)).errors == [{:text, {"is required", []}}]
|
|
end
|
|
|
|
test "nested errors can be fetched with `Form.errors/2`" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
post: [
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{})
|
|
|> Form.validate(%{"text" => "text", "post" => %{}})
|
|
|> Form.submit(force?: true)
|
|
|> elem(1)
|
|
|> form_for("action")
|
|
|
|
assert Form.errors(form.source, for_path: [:post]) == [{:text, "is required"}]
|
|
|
|
assert Form.errors(form.source, for_path: [:post], format: :raw) == [
|
|
{:text, {"is required", []}}
|
|
]
|
|
|
|
assert Form.errors(form.source, for_path: [:post], format: :plaintext) == [
|
|
"text: is required"
|
|
]
|
|
|
|
assert Form.errors(form.source, for_path: :all) == %{[:post] => [{:text, "is required"}]}
|
|
end
|
|
|
|
test "errors can be fetched with `Form.errors/2`" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
post: [
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{})
|
|
|> Form.validate(%{"post" => %{"text" => "text"}})
|
|
|> Form.submit(force?: true)
|
|
|> elem(1)
|
|
|> form_for("action")
|
|
|
|
assert Form.errors(form.source) == [{:text, "is required"}]
|
|
|
|
assert Form.errors(form.source, format: :raw) == [
|
|
{:text, {"is required", []}}
|
|
]
|
|
|
|
assert Form.errors(form.source, format: :plaintext) == [
|
|
"text: is required"
|
|
]
|
|
end
|
|
|
|
test "nested forms submit empty values when they have been touched, even if not included in future params" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{})
|
|
|> Form.validate(%{"text" => "text"})
|
|
|
|
assert %{"text" => "text", "post" => nil} = Form.params(form)
|
|
end
|
|
|
|
test "nested forms submit empty list values when not present in input params" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{})
|
|
|> Form.validate(%{"text" => "text"})
|
|
|
|
assert Form.value(form, :text) == "text"
|
|
|
|
assert %{
|
|
"text" => "text",
|
|
"post" => [],
|
|
"_form_type" => "create",
|
|
"_touched" => "_form_type,_touched,post,text"
|
|
} = Form.params(form, hidden?: true)
|
|
end
|
|
|
|
test "nested errors are set on the appropriate form after submit for many to many relationships" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
for: :linked_posts,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{})
|
|
|> Form.validate(%{"text" => "text", "post" => [%{}]})
|
|
|> Form.submit(force?: true)
|
|
|> elem(1)
|
|
|> form_for("action")
|
|
|
|
assert form.errors == []
|
|
|
|
assert [nested_form] = inputs_for(form, :post)
|
|
assert nested_form.errors == [{:text, {"is required", []}}]
|
|
end
|
|
|
|
test "errors with a path are propagated down to the appropirate nested form" do
|
|
author = %Author{
|
|
email: "me@example.com"
|
|
}
|
|
|
|
form =
|
|
author
|
|
|> Form.for_update(:update_with_embedded_argument, domain: Domain, forms: [auto?: true])
|
|
|> Form.add_form(:embedded_argument, params: %{})
|
|
|> Form.validate(%{"embedded_argument" => %{"value" => "you@example.com"}})
|
|
|> form_for("action")
|
|
|
|
assert AshPhoenix.Form.errors(form, for_path: [:embedded_argument]) == [
|
|
value: "must match email"
|
|
]
|
|
|
|
assert AshPhoenix.Form.errors(form) == []
|
|
|
|
# Check that errors will appear on a nested form using the Phoenix Core Components inputs_for
|
|
# https://github.com/phoenixframework/phoenix_live_view/blob/main/lib/phoenix_component.ex#L2410
|
|
%Phoenix.HTML.FormField{field: field_name, form: parent_form} = form[:embedded_argument]
|
|
|
|
inputs_for_form =
|
|
parent_form.impl.to_form(
|
|
parent_form.source,
|
|
parent_form,
|
|
field_name,
|
|
parent_form.options
|
|
)
|
|
|> List.first()
|
|
|
|
# This is the expected format for a phoenix core component
|
|
assert inputs_for_form.errors == [{:value, {"must match email", []}}]
|
|
end
|
|
|
|
test "deeply nested errors don't multiply" do
|
|
author = %Author{
|
|
email: "me@example.com"
|
|
}
|
|
|
|
form =
|
|
author
|
|
|> Form.for_update(:update_with_embedded_argument, domain: Domain, forms: [auto?: true])
|
|
|> Form.add_form(:embedded_argument, params: %{})
|
|
|> Form.add_form([:embedded_argument, :nested_embeds], params: %{})
|
|
|> Form.validate(%{
|
|
"embedded_argument" => %{
|
|
"value" => "you@example.com",
|
|
nested_embeds: %{"0" => %{"limit" => "non-integer", "four_chars" => "not-4-chars"}}
|
|
}
|
|
})
|
|
|> form_for("action")
|
|
|
|
%Phoenix.HTML.FormField{field: field_name, form: parent_form} = form[:embedded_argument]
|
|
|
|
inputs_for_arg_form =
|
|
parent_form.impl.to_form(
|
|
parent_form.source,
|
|
parent_form,
|
|
field_name,
|
|
parent_form.options
|
|
)
|
|
|> List.first()
|
|
|
|
%Phoenix.HTML.FormField{field: field_name, form: parent_form} =
|
|
inputs_for_arg_form[:nested_embeds]
|
|
|
|
inputs_for_nested_form =
|
|
parent_form.impl.to_form(
|
|
parent_form.source,
|
|
parent_form,
|
|
field_name,
|
|
parent_form.options
|
|
)
|
|
|> List.first()
|
|
|
|
# Note: I'm not 100% which of the 3 errors messages are preferred. The opts are get_text bindings for error translation
|
|
# In the Phoenix core components the error translation is done `Gettext.dpgettext(MyApp.Gettext, domain, msgctxt, msgid, bindings)` with our tuple being `{msgid, bindings}`
|
|
assert Keyword.get_values(inputs_for_nested_form.errors, :limit) == [
|
|
{"is invalid", []}
|
|
]
|
|
|
|
assert Keyword.get_values(inputs_for_nested_form.errors, :four_chars) == [
|
|
{"must have length of exactly %{exact}",
|
|
[
|
|
exact: 4
|
|
]}
|
|
]
|
|
end
|
|
end
|
|
|
|
describe "data" do
|
|
test "it uses the provided data to create forms even without input" do
|
|
post1_id = Ash.UUID.generate()
|
|
post2_id = Ash.UUID.generate()
|
|
|
|
form =
|
|
Comment
|
|
|> Form.for_create(
|
|
:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
data: [%Post{id: post1_id}, %Post{id: post2_id}],
|
|
update_action: :update,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|> form_for("foo")
|
|
|
|
assert Enum.count(inputs_for(form, :post)) == 2
|
|
end
|
|
|
|
test "a function can be used to derive the data from the data of the parent form" do
|
|
post1_id = Ash.UUID.generate()
|
|
post2_id = Ash.UUID.generate()
|
|
comment_id = Ash.UUID.generate()
|
|
|
|
form =
|
|
Comment
|
|
|> Form.for_create(
|
|
:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
data: [
|
|
%Post{id: post1_id, comments: [%Comment{id: comment_id}]},
|
|
%Post{id: post2_id, comments: []}
|
|
],
|
|
update_action: :update,
|
|
forms: [
|
|
comments: [
|
|
data: &(&1.comments || []),
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create,
|
|
update_action: :update
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|> Form.validate(%{
|
|
"text" => "text",
|
|
"post" => %{
|
|
"0" => %{"id" => post1_id, "comments" => %{"0" => %{"id" => comment_id}}},
|
|
"1" => %{"id" => post2_id}
|
|
}
|
|
})
|
|
|
|
assert %{
|
|
"post" => [
|
|
%{"comments" => [%{"id" => ^comment_id}], "id" => ^post1_id},
|
|
%{"id" => ^post2_id}
|
|
],
|
|
"text" => "text"
|
|
} = Form.params(form)
|
|
end
|
|
end
|
|
|
|
describe "submit" do
|
|
test "it runs the action with the params" do
|
|
assert {:ok, %{text: "text"}} =
|
|
Post
|
|
|> Form.for_create(:create, domain: Domain)
|
|
|> Form.validate(%{text: "text"})
|
|
|> Form.submit()
|
|
end
|
|
|
|
test "it fallback to resource defined Domain if unset" do
|
|
assert {:ok, %{name: "name"}} =
|
|
Artist
|
|
|> Form.for_action(:create)
|
|
|> Form.validate(%{name: "name"})
|
|
|> Form.submit()
|
|
|
|
assert {:ok, [%{name: "name"}]} =
|
|
Artist
|
|
|> Form.for_action(:read)
|
|
|> Form.validate(%{name: "name changed"})
|
|
|> Form.submit()
|
|
|
|
artist =
|
|
Artist
|
|
|> Ash.Changeset.for_create(:create, %{name: "name"})
|
|
|> Ash.create!()
|
|
|
|
assert {:ok, %{name: "name changed"}} =
|
|
artist
|
|
|> Form.for_action(:update)
|
|
|> Form.validate(%{name: "name changed"})
|
|
|> Form.submit()
|
|
|
|
assert :ok =
|
|
artist
|
|
|> Form.for_action(:destroy)
|
|
|> Form.validate(%{name: "name changed"})
|
|
|> Form.submit()
|
|
end
|
|
end
|
|
|
|
describe "prepare_source" do
|
|
test "it runs on initial create" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
prepare_source: &Ash.Changeset.put_context(&1, :foo, :bar)
|
|
)
|
|
|
|
assert form.source.context.foo == :bar
|
|
end
|
|
|
|
test "it is preserved on validate create" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
prepare_source: &Ash.Changeset.put_context(&1, :foo, :bar)
|
|
)
|
|
|> Form.validate(%{text: "text"})
|
|
|
|
assert form.source.context.foo == :bar
|
|
end
|
|
|
|
test "it is preserved through to submit" do
|
|
result =
|
|
Post
|
|
|> Form.for_create(:create,
|
|
domain: Domain,
|
|
prepare_source: fn changeset ->
|
|
Ash.Changeset.before_action(
|
|
changeset,
|
|
&Ash.Changeset.force_change_attribute(&1, :title, "special_title")
|
|
)
|
|
end
|
|
)
|
|
|> Form.validate(%{text: "text"})
|
|
|> Form.submit!()
|
|
|
|
assert result.title == "special_title"
|
|
end
|
|
end
|
|
|
|
describe "params" do
|
|
test "it includes nested forms, and honors their `for` configuration" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create
|
|
]
|
|
]
|
|
],
|
|
other_post: [
|
|
type: :single,
|
|
for: :for_posts,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form("form[post]", params: %{"text" => "post_text"})
|
|
|> Form.add_form("form[other_post]", params: %{"text" => "post_text"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "post_text"})
|
|
|> Form.validate(%{
|
|
"text" => "text",
|
|
"post" => [%{"comments" => [%{"text" => "post_text"}], "text" => "post_text"}],
|
|
"other_post" => %{"text" => "post_text"}
|
|
})
|
|
|
|
assert %{
|
|
"text" => "text",
|
|
"post" => [%{"comments" => [%{"text" => "post_text"}], "text" => "post_text"}],
|
|
"for_posts" => %{"text" => "post_text"}
|
|
} = Form.params(form)
|
|
end
|
|
end
|
|
|
|
test "it properly retains form order" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create
|
|
]
|
|
]
|
|
],
|
|
other_post: [
|
|
type: :single,
|
|
for: :for_posts,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form("form[post]", params: %{"text" => "post_text"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "0"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "1"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "2"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "3"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "4"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "5"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "6"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "7"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "8"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "9"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "10"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{"text" => "11"})
|
|
|
|
assert %{
|
|
"post" => [
|
|
%{
|
|
"comments" => [
|
|
%{"text" => "0"},
|
|
%{"text" => "1"},
|
|
%{"text" => "2"},
|
|
%{"text" => "3"},
|
|
%{"text" => "4"},
|
|
%{"text" => "5"},
|
|
%{"text" => "6"},
|
|
%{"text" => "7"},
|
|
%{"text" => "8"},
|
|
%{"text" => "9"},
|
|
%{"text" => "10"},
|
|
%{"text" => "11"}
|
|
]
|
|
}
|
|
]
|
|
} = Form.params(form)
|
|
end
|
|
|
|
describe "`inputs_for` with no configuration" do
|
|
# phoenix changes make this not work anymore
|
|
# test "it should raise an error" do
|
|
# form =
|
|
# Post
|
|
# |> Form.for_create(:create)
|
|
# |> Form.validate(%{text: "text"})
|
|
# |> form_for("action")
|
|
|
|
# assert_raise AshPhoenix.Form.NoFormConfigured, fn ->
|
|
# inputs_for(form, :post) == []
|
|
# end
|
|
# end
|
|
end
|
|
|
|
describe "inputs_for` relationships" do
|
|
test "it should name the fields correctly on `for_update`" do
|
|
post_id = Ash.UUID.generate()
|
|
comment_id = Ash.UUID.generate()
|
|
|
|
comment = %Comment{
|
|
text: "text",
|
|
post: %Post{
|
|
id: post_id,
|
|
text: "Some text",
|
|
comments: [%Comment{id: comment_id}]
|
|
}
|
|
}
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
as: "comment",
|
|
forms: [
|
|
post: [
|
|
data: comment.post,
|
|
type: :single,
|
|
resource: Post,
|
|
update_action: :update,
|
|
create_action: :create,
|
|
forms: [
|
|
comments: [
|
|
data: & &1.comments,
|
|
type: :list,
|
|
resource: Comment,
|
|
update_action: :update,
|
|
create_action: :create
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|
|
comments_form =
|
|
form
|
|
|> form_for("action")
|
|
|> inputs_for(:post)
|
|
|> hd()
|
|
|> inputs_for(:comments)
|
|
|> hd()
|
|
|
|
assert comments_form.name == "comment[post][comments][0]"
|
|
end
|
|
|
|
test "the `type: :single` option should create a form without integer paths" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{text: "post_text"})
|
|
|> Form.validate(%{"text" => "text", "post" => %{"text" => "post_text"}})
|
|
|> form_for("action")
|
|
|
|
assert %Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
related_form = hd(inputs_for(form, :post))
|
|
|
|
assert related_form.name == "form[post]"
|
|
|
|
assert FormData.input_value(related_form.source, related_form, :text) == "post_text"
|
|
end
|
|
|
|
test "it should show nothing in `inputs_for` by default" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.validate(%{"text" => "text"})
|
|
|> form_for("action")
|
|
|
|
assert inputs_for(form, :post) == []
|
|
end
|
|
|
|
test "when a value has been appended to the relationship, a form is created" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{text: "post_text"})
|
|
|> form_for("action")
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
related_form
|
|
] = inputs_for(form, :post)
|
|
|
|
assert FormData.input_value(related_form.source, related_form, :text) == "post_text"
|
|
end
|
|
|
|
test "a query path can be used when manipulating forms" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form("form[post]", params: %{text: "post_text"})
|
|
|> Form.add_form("form[post][0][comments]", params: %{text: "post_text"})
|
|
|> form_for("action")
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
post_form
|
|
] = inputs_for(form, :post)
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Comment}}
|
|
] = inputs_for(post_form, :comments)
|
|
end
|
|
|
|
test "list values get an index in their name and id" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{text: "post_text0"})
|
|
|> Form.add_form(:post, params: %{text: "post_text1"})
|
|
|> Form.add_form(:post, params: %{text: "post_text2"})
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
form_0,
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
form_1,
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
form_2
|
|
] = inputs_for(form_for(form, "action"), :post)
|
|
|
|
assert form_0.name == "form[post][0]"
|
|
assert form_0.id == "form_post_0"
|
|
|
|
assert form_1.name == "form[post][1]"
|
|
assert form_1.id == "form_post_1"
|
|
|
|
assert form_2.name == "form[post][2]"
|
|
assert form_2.id == "form_post_2"
|
|
end
|
|
|
|
test "when a value has been removed from the relationship, the form is removed" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{text: "post_text0"})
|
|
|> Form.add_form(:post, params: %{text: "post_text1"})
|
|
|> Form.add_form(:post, params: %{text: "post_text2"})
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}},
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}},
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}}
|
|
] = inputs_for(form_for(form, "action"), :post)
|
|
|
|
form =
|
|
form
|
|
|> Form.remove_form([:post, 0])
|
|
|> Form.remove_form([:post, 1])
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
related_form
|
|
] = inputs_for(form_for(form, "action"), :post)
|
|
|
|
assert FormData.input_value(related_form.source, related_form, :text) == "post_text1"
|
|
end
|
|
|
|
test "when all values have been removed from a relationship, the empty list remains" do
|
|
form =
|
|
Comment
|
|
|> Form.for_create(:create,
|
|
forms: [
|
|
post: [
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{text: "post_text0"})
|
|
|> Form.add_form(:post, params: %{text: "post_text1"})
|
|
|> Form.add_form(:post, params: %{text: "post_text2"})
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}},
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}},
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}}
|
|
] = inputs_for(form_for(form, "action"), :post)
|
|
|
|
form =
|
|
form
|
|
|> Form.remove_form([:post, 0])
|
|
|> Form.remove_form([:post, 0])
|
|
|> Form.remove_form([:post, 0])
|
|
|> Form.validate(%{})
|
|
|
|
assert [] = inputs_for(form_for(form, "action"), :post)
|
|
assert %{"post" => []} = Form.params(form)
|
|
end
|
|
|
|
test "when all values have been removed from an existing relationship, the empty list remains" do
|
|
post1_id = Ash.UUID.generate()
|
|
post2_id = Ash.UUID.generate()
|
|
comment = %Comment{text: "text", post: [%Post{id: post1_id}, %Post{id: post2_id}]}
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
forms: [
|
|
post: [
|
|
data: comment.post,
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create,
|
|
update_action: :update
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form(:post, params: %{text: "post_text3"})
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}},
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}},
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}}
|
|
] = inputs_for(form_for(form, "action"), :post)
|
|
|
|
form =
|
|
form
|
|
|> Form.remove_form([:post, 0])
|
|
|> Form.remove_form([:post, 0])
|
|
|> Form.remove_form([:post, 0])
|
|
|> Form.validate(%{})
|
|
|
|
assert %{"post" => []} = Form.params(form)
|
|
end
|
|
|
|
test "when all values have been removed from an existing `:single` relationship, the empty list remains" do
|
|
post_id = Ash.UUID.generate()
|
|
comment_2 = %Comment{text: "text"}
|
|
|
|
comment = %Comment{text: "text", post: %Post{id: post_id, comments: [comment_2]}}
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
forms: [
|
|
post: [
|
|
data: & &1.post,
|
|
type: :single,
|
|
resource: Post,
|
|
update_action: :update,
|
|
create_action: :create,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
data: & &1.comments,
|
|
create_action: :create,
|
|
update_action: :update
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|
|
assert [%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}}] =
|
|
form
|
|
|> form_for("action")
|
|
|> inputs_for(:post)
|
|
|
|
form =
|
|
form
|
|
|> Form.remove_form([:post, :comments, 0])
|
|
# This is added by the hidden fields helper, so we add it here to simulate that.
|
|
|> Form.validate(%{"post" => %{"_touched" => "comments"}})
|
|
|
|
assert %{"post" => %{"comments" => []}} = Form.params(form)
|
|
end
|
|
|
|
test "remaining forms are reindexed after a form has been removed" do
|
|
post1_id = Ash.UUID.generate()
|
|
post2_id = Ash.UUID.generate()
|
|
post3_id = Ash.UUID.generate()
|
|
|
|
comment = %Comment{
|
|
text: "text",
|
|
post: [%Post{id: post1_id}, %Post{id: post2_id}, %Post{id: post3_id}]
|
|
}
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
forms: [
|
|
posts: [
|
|
data: comment.post,
|
|
type: :list,
|
|
resource: Post,
|
|
create_action: :create,
|
|
update_action: :update
|
|
]
|
|
]
|
|
)
|
|
|> Form.remove_form([:posts, 1])
|
|
|
|
assert [
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
form_0,
|
|
%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}} =
|
|
form_1
|
|
] = inputs_for(form_for(form, "action"), :posts)
|
|
|
|
assert form_0.name == "form[posts][0]"
|
|
assert form_0.id == "form_posts_0"
|
|
|
|
assert form_1.name == "form[posts][1]"
|
|
assert form_1.id == "form_posts_1"
|
|
end
|
|
|
|
test "when `:single`, `inputs_for` generates a list of one single item" do
|
|
post_id = Ash.UUID.generate()
|
|
comment = %Comment{text: "text", post: %Post{id: post_id, text: "Some text"}}
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
forms: [
|
|
post: [
|
|
data: comment.post,
|
|
type: :single,
|
|
resource: Post,
|
|
update_action: :update
|
|
]
|
|
]
|
|
)
|
|
|
|
assert [%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Post}}] =
|
|
inputs_for(form_for(form, "action"), :post)
|
|
end
|
|
|
|
test "it creates nested forms for single resources" do
|
|
post_id = Ash.UUID.generate()
|
|
comment_id = Ash.UUID.generate()
|
|
|
|
comment = %Comment{
|
|
text: "text",
|
|
post: %Post{
|
|
id: post_id,
|
|
text: "Some text",
|
|
comments: [%Comment{id: comment_id}]
|
|
}
|
|
}
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
forms: [
|
|
post: [
|
|
data: comment.post,
|
|
type: :single,
|
|
resource: Post,
|
|
update_action: :update,
|
|
create_action: :create,
|
|
forms: [
|
|
comments: [
|
|
data: & &1.comments,
|
|
type: :list,
|
|
resource: Comment,
|
|
update_action: :update,
|
|
create_action: :create
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|
|
assert [%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Comment}}] =
|
|
form
|
|
|> form_for("action")
|
|
|> inputs_for(:post)
|
|
|> hd()
|
|
|> inputs_for(:comments)
|
|
end
|
|
|
|
test "it `add_form`s for nested single resources" do
|
|
post_id = Ash.UUID.generate()
|
|
|
|
comment = %Comment{
|
|
text: "text",
|
|
post: %Post{
|
|
id: post_id,
|
|
text: "Some text",
|
|
comments: []
|
|
}
|
|
}
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
forms: [
|
|
post: [
|
|
data: comment.post,
|
|
type: :single,
|
|
resource: Post,
|
|
update_action: :update,
|
|
create_action: :create,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form([:post, :comments])
|
|
|
|
assert [%Phoenix.HTML.Form{source: %AshPhoenix.Form{resource: AshPhoenix.Test.Comment}}] =
|
|
form
|
|
|> form_for("action")
|
|
|> inputs_for(:post)
|
|
|> hd()
|
|
|> inputs_for(:comments)
|
|
end
|
|
|
|
test "it `remove_form`s for nested single resources" do
|
|
post_id = Ash.UUID.generate()
|
|
|
|
comment = %Comment{
|
|
text: "text",
|
|
post: %Post{
|
|
id: post_id,
|
|
text: "Some text",
|
|
comments: []
|
|
}
|
|
}
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
forms: [
|
|
post: [
|
|
data: comment.post,
|
|
type: :single,
|
|
resource: Post,
|
|
update_action: :update,
|
|
create_action: :create,
|
|
forms: [
|
|
comments: [
|
|
type: :list,
|
|
resource: Comment,
|
|
create_action: :create
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|> Form.add_form([:post, :comments])
|
|
|> Form.remove_form([:post, :comments, 0])
|
|
|
|
assert [] =
|
|
form
|
|
|> form_for("action")
|
|
|> inputs_for(:post)
|
|
|> hd()
|
|
|> inputs_for(:comments)
|
|
end
|
|
|
|
test "when `remove_form`ing an existing `:single` relationship, a nil value is included in the params - if the form has been touched" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.new()
|
|
|> Ash.Changeset.set_argument(:author, %{email: "nigel@elixir-lang.org"})
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
form =
|
|
post
|
|
|> Form.for_update(:update, domain: Domain, forms: [auto?: true])
|
|
|> Form.remove_form([:author])
|
|
|
|
params =
|
|
form
|
|
|> Form.params()
|
|
|
|
assert %{"author" => nil} = params
|
|
end
|
|
|
|
test "when add_forming a required argument, the added form should be valid without needing to manually validate it" do
|
|
form =
|
|
Post
|
|
|> Form.for_create(:create_author_required, domain: Domain, forms: [auto?: true])
|
|
|> Form.validate(%{"text" => "foo"})
|
|
|> Form.add_form([:author], params: %{"email" => "james@foo.com"})
|
|
|
|
assert form.valid? == true
|
|
end
|
|
end
|
|
|
|
describe "issue #259" do
|
|
test "updating should not duplicate nested resources" do
|
|
post =
|
|
Post
|
|
|> Ash.Changeset.for_create(:create, %{text: "post"})
|
|
|> Ash.create!()
|
|
|
|
comment =
|
|
Comment
|
|
|> Ash.Changeset.for_create(:create, %{text: "comment"})
|
|
|> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
|
|
|> Ash.create!()
|
|
|
|
# Check the persisted post.comments count after create
|
|
post = Post |> Ash.get!(post.id) |> Ash.load!(:comments)
|
|
assert Enum.count(post.comments) == 1
|
|
|
|
# Grab the persisted comment
|
|
comment = Comment |> Ash.get!(comment.id) |> Ash.load!(post: [:comments])
|
|
|
|
form =
|
|
comment
|
|
|> Form.for_update(:update,
|
|
as: "comment",
|
|
domain: Domain,
|
|
forms: [
|
|
post: [
|
|
data: & &1.post,
|
|
type: :single,
|
|
resource: Post,
|
|
update_action: :update,
|
|
create_action: :create,
|
|
skip_unknown_inputs: ["id"],
|
|
forms: [
|
|
comments: [
|
|
data: & &1.comments,
|
|
skip_unknown_inputs: ["id"],
|
|
type: :list,
|
|
resource: Comment,
|
|
update_action: :update,
|
|
create_action: :create
|
|
]
|
|
]
|
|
]
|
|
]
|
|
)
|
|
|
|
updated_comment =
|
|
form
|
|
|> AshPhoenix.Form.submit!(
|
|
params: %{
|
|
"post" => %{
|
|
"id" => post.id,
|
|
"text" => "text",
|
|
"comments" => %{
|
|
"0" => %{
|
|
"id" => comment.id,
|
|
"text" => comment.text
|
|
}
|
|
}
|
|
}
|
|
}
|
|
)
|
|
|
|
assert Enum.count(updated_comment.post.comments) == 1
|
|
|
|
# now, check the persisted post
|
|
persisted_post = Post |> Ash.get!(post.id) |> Ash.load!(:comments)
|
|
assert Enum.count(persisted_post.comments) == 1
|
|
end
|
|
end
|
|
end
|