2021-12-02 09:28:38 +13:00
|
|
|
defmodule AshPhoenix.FilterFormTest do
|
2021-11-30 15:40:46 +13:00
|
|
|
use ExUnit.Case
|
2021-12-02 09:28:38 +13:00
|
|
|
import Phoenix.HTML.Form, only: [form_for: 2, inputs_for: 2, input_value: 2]
|
2021-11-30 15:40:46 +13:00
|
|
|
|
|
|
|
alias AshPhoenix.FilterForm
|
2021-12-02 09:28:38 +13:00
|
|
|
alias AshPhoenix.Test.Post
|
|
|
|
|
|
|
|
require Ash.Query
|
2021-11-30 15:40:46 +13:00
|
|
|
|
2021-12-02 09:28:38 +13:00
|
|
|
describe "groups" do
|
|
|
|
test "a group can be added" do
|
|
|
|
form = FilterForm.new(Post)
|
|
|
|
|
2021-12-07 08:17:30 +13:00
|
|
|
{form, group_id} = FilterForm.add_group(form, operator: :or, return_id?: true)
|
|
|
|
form = FilterForm.add_predicate(form, :title, :eq, "new post", to: group_id)
|
2021-12-02 09:28:38 +13:00
|
|
|
|
|
|
|
assert %FilterForm{
|
|
|
|
components: [
|
|
|
|
%FilterForm{
|
|
|
|
components: [
|
|
|
|
%FilterForm.Predicate{
|
|
|
|
field: :title,
|
|
|
|
operator: :eq,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
]
|
|
|
|
}
|
|
|
|
]
|
|
|
|
} = form
|
|
|
|
end
|
|
|
|
|
|
|
|
test "a group can be removed" do
|
|
|
|
form = FilterForm.new(Post)
|
|
|
|
|
2021-12-07 08:17:30 +13:00
|
|
|
{form, group_id} = FilterForm.add_group(form, operator: :or, return_id?: true)
|
|
|
|
form = FilterForm.add_predicate(form, :title, :eq, "new post", to: group_id)
|
2021-12-02 09:28:38 +13:00
|
|
|
|
|
|
|
form = FilterForm.remove_group(form, group_id)
|
|
|
|
|
|
|
|
assert %FilterForm{
|
|
|
|
components: []
|
|
|
|
} = form
|
|
|
|
end
|
|
|
|
|
|
|
|
test "a predicate can be removed from a group" do
|
|
|
|
form = FilterForm.new(Post)
|
|
|
|
|
2021-12-07 08:17:30 +13:00
|
|
|
{form, group_id} = FilterForm.add_group(form, operator: :or, return_id?: true)
|
|
|
|
|
|
|
|
{form, predicate_id} =
|
|
|
|
FilterForm.add_predicate(form, :title, :eq, "new post", to: group_id, return_id?: true)
|
2021-12-02 09:28:38 +13:00
|
|
|
|
|
|
|
form = FilterForm.remove_predicate(form, predicate_id)
|
|
|
|
|
|
|
|
assert %FilterForm{
|
|
|
|
components: [
|
|
|
|
%FilterForm{
|
|
|
|
components: []
|
|
|
|
}
|
|
|
|
]
|
|
|
|
} = form
|
|
|
|
end
|
|
|
|
|
2023-03-28 20:21:41 +13:00
|
|
|
test "groups and predicates can be removed with remove_component" do
|
|
|
|
form = FilterForm.new(Post)
|
|
|
|
|
|
|
|
{form, group_id} = FilterForm.add_group(form, operator: :or, return_id?: true)
|
|
|
|
|
|
|
|
{form, predicate_id} =
|
|
|
|
FilterForm.add_predicate(form, :title, :eq, "new post", to: group_id, return_id?: true)
|
|
|
|
|
|
|
|
form = FilterForm.remove_component(form, predicate_id)
|
|
|
|
|
|
|
|
assert %FilterForm{
|
|
|
|
components: [
|
|
|
|
%FilterForm{
|
|
|
|
components: []
|
|
|
|
}
|
|
|
|
]
|
|
|
|
} = form
|
|
|
|
|
|
|
|
form = FilterForm.remove_component(form, group_id)
|
|
|
|
|
|
|
|
assert %FilterForm{
|
|
|
|
components: []
|
|
|
|
} = form
|
|
|
|
end
|
|
|
|
|
2021-12-02 09:28:38 +13:00
|
|
|
test "with `remove_empty_groups?: true` empty groups are removed on component removal" do
|
|
|
|
form = FilterForm.new(Post, remove_empty_groups?: true)
|
|
|
|
|
2021-12-07 08:17:30 +13:00
|
|
|
{form, group_id} = FilterForm.add_group(form, operator: :or, return_id?: true)
|
|
|
|
|
|
|
|
{form, predicate_id} =
|
|
|
|
FilterForm.add_predicate(form, :title, :eq, "new post", to: group_id, return_id?: true)
|
2021-12-02 09:28:38 +13:00
|
|
|
|
|
|
|
form = FilterForm.remove_predicate(form, predicate_id)
|
|
|
|
|
|
|
|
assert %FilterForm{components: []} = form
|
|
|
|
end
|
2022-09-29 07:34:50 +13:00
|
|
|
|
|
|
|
test "the form ids and names for deeply nested components are correct" do
|
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new()
|
|
|
|
|> FilterForm.add_group(return_id?: true)
|
|
|
|
|> then(fn {form, id} -> FilterForm.add_group(form, to: id, return_id?: true) end)
|
|
|
|
|> then(fn {form, id} -> FilterForm.add_group(form, to: id, return_id?: true) end)
|
|
|
|
|> then(fn {form, id} ->
|
|
|
|
FilterForm.add_predicate(form, :title, :eq, "new_post", to: id)
|
|
|
|
end)
|
|
|
|
|> form_for("action")
|
|
|
|
|
|
|
|
assert [group_form] = inputs_for(form, :components)
|
|
|
|
|
|
|
|
assert group_form.id == group_form.source.id
|
|
|
|
assert group_form.name == form.name <> "[components][0]"
|
|
|
|
|
|
|
|
assert [sub_group_form] = inputs_for(group_form, :components)
|
|
|
|
|
|
|
|
assert sub_group_form.id == sub_group_form.source.id
|
|
|
|
assert sub_group_form.name == form.name <> "[components][0][components][0]"
|
|
|
|
|
|
|
|
assert [predicate_form] = inputs_for(sub_group_form, :components)
|
|
|
|
|
|
|
|
assert predicate_form.id == predicate_form.source.id
|
|
|
|
assert predicate_form.name == form.name <> "[components][0][components][0][components][0]"
|
|
|
|
end
|
2021-12-02 09:28:38 +13:00
|
|
|
end
|
|
|
|
|
|
|
|
describe "to_filter/1" do
|
|
|
|
test "An empty form returns the filter `true`" do
|
|
|
|
form = FilterForm.new(Post)
|
2021-12-06 14:24:08 +13:00
|
|
|
|
2022-12-21 21:07:07 +13:00
|
|
|
assert FilterForm.to_filter_map(form) == {:ok, true}
|
|
|
|
|
2021-12-06 14:24:08 +13:00
|
|
|
assert Ash.Query.equivalent_to?(
|
|
|
|
FilterForm.filter!(Post, form),
|
|
|
|
true
|
|
|
|
)
|
2021-12-02 09:28:38 +13:00
|
|
|
end
|
|
|
|
|
|
|
|
test "A form with a single predicate returns the corresponding filter" do
|
|
|
|
form =
|
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2022-12-21 21:07:07 +13:00
|
|
|
assert FilterForm.to_filter_map(form) ==
|
|
|
|
{:ok, %{"and" => [%{"title" => %{"eq" => "new post"}}]}}
|
|
|
|
|
2021-12-02 09:28:38 +13:00
|
|
|
assert Ash.Query.equivalent_to?(
|
|
|
|
FilterForm.filter!(Post, form),
|
|
|
|
title == "new post"
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2021-12-07 08:17:30 +13:00
|
|
|
test "the is_nil predicate correctly chooses the operator" do
|
|
|
|
form =
|
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
operator: :is_nil,
|
|
|
|
value: "true"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
assert Ash.Query.equivalent_to?(
|
|
|
|
FilterForm.filter!(Post, form),
|
|
|
|
is_nil(title)
|
|
|
|
)
|
|
|
|
|
|
|
|
form =
|
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
operator: :is_nil,
|
|
|
|
value: "false"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
assert Ash.Query.equivalent_to?(
|
2021-12-29 16:30:06 +13:00
|
|
|
FilterForm.filter!(Post, form),
|
2021-12-07 08:17:30 +13:00
|
|
|
not is_nil(title)
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2021-12-02 09:28:38 +13:00
|
|
|
test "predicates that map to functions work as well" do
|
|
|
|
form =
|
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
operator: :contains,
|
|
|
|
value: "new"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
assert Ash.Query.equivalent_to?(
|
|
|
|
FilterForm.filter!(Post, form),
|
|
|
|
contains(title, "new")
|
|
|
|
)
|
|
|
|
end
|
2021-12-02 21:12:18 +13:00
|
|
|
|
|
|
|
test "predicates can reference paths" do
|
|
|
|
form =
|
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{
|
|
|
|
field: :text,
|
|
|
|
operator: :contains,
|
|
|
|
path: "comments",
|
|
|
|
value: "new"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
assert Ash.Query.equivalent_to?(
|
|
|
|
FilterForm.filter!(Post, form),
|
|
|
|
contains(comments.text, "new")
|
|
|
|
)
|
|
|
|
end
|
2022-08-14 07:10:47 +12:00
|
|
|
|
2022-12-21 21:07:07 +13:00
|
|
|
test "predicates can reference paths for to_filter_map" do
|
|
|
|
form =
|
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{
|
|
|
|
field: :text,
|
|
|
|
operator: :eq,
|
|
|
|
path: "comments",
|
|
|
|
value: "new"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
assert {:ok, %{"and" => [%{"comments" => %{"text" => %{"eq" => "new"}}}]} = filter} =
|
|
|
|
FilterForm.to_filter_map(form)
|
|
|
|
|
|
|
|
assert Ash.Query.equivalent_to?(
|
|
|
|
Ash.Query.filter(Post, ^Ash.Filter.parse!(Post, filter)),
|
|
|
|
comments.text == "new"
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2022-09-27 12:32:49 +13:00
|
|
|
test "predicates with fields that refer to a relationship will be appended to the path" do
|
|
|
|
form =
|
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{
|
|
|
|
field: :comments,
|
|
|
|
operator: :contains,
|
|
|
|
path: "",
|
|
|
|
value: "new"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
assert hd(form.components).path == [:comments]
|
2022-10-01 09:40:23 +13:00
|
|
|
assert hd(form.components).field == :id
|
2022-09-27 12:32:49 +13:00
|
|
|
end
|
|
|
|
|
2022-08-14 07:10:47 +12:00
|
|
|
test "predicates can be added with paths" do
|
|
|
|
form = FilterForm.new(Post)
|
|
|
|
|
|
|
|
form =
|
|
|
|
FilterForm.add_predicate(
|
|
|
|
form,
|
|
|
|
:text,
|
|
|
|
:contains,
|
|
|
|
"new",
|
|
|
|
path: "comments"
|
|
|
|
)
|
|
|
|
|
|
|
|
assert Ash.Query.equivalent_to?(
|
|
|
|
FilterForm.filter!(Post, form),
|
|
|
|
contains(comments.text, "new")
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
test "predicates can be updated" do
|
|
|
|
form = FilterForm.new(Post)
|
|
|
|
|
|
|
|
{form, predicate_id} =
|
|
|
|
FilterForm.add_predicate(
|
|
|
|
form,
|
|
|
|
:text,
|
|
|
|
:contains,
|
|
|
|
"new",
|
|
|
|
path: "comments",
|
|
|
|
return_id?: true
|
|
|
|
)
|
|
|
|
|
|
|
|
form =
|
|
|
|
FilterForm.update_predicate(form, predicate_id, fn predicate ->
|
|
|
|
%{predicate | path: []}
|
|
|
|
end)
|
|
|
|
|
|
|
|
assert Ash.Query.equivalent_to?(
|
|
|
|
FilterForm.filter!(Post, form),
|
|
|
|
contains(text, "new")
|
|
|
|
)
|
|
|
|
end
|
2021-12-02 09:28:38 +13:00
|
|
|
end
|
|
|
|
|
|
|
|
describe "form_data implementation" do
|
2021-11-30 15:40:46 +13:00
|
|
|
test "form_for works with a new filter form" do
|
|
|
|
form = FilterForm.new(Post)
|
|
|
|
|
|
|
|
form_for(form, "action")
|
|
|
|
end
|
|
|
|
|
|
|
|
test "form_for works with a single group" do
|
|
|
|
form =
|
2021-12-02 09:28:38 +13:00
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
2021-11-30 15:40:46 +13:00
|
|
|
|
|
|
|
form_for(form, "action")
|
|
|
|
end
|
|
|
|
|
2021-12-02 09:28:38 +13:00
|
|
|
test "the `:operator` and `:negated` inputs are available" do
|
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|> form_for("action")
|
|
|
|
|
|
|
|
assert input_value(form, :negated) == false
|
|
|
|
assert input_value(form, :operator) == :and
|
|
|
|
end
|
|
|
|
|
2021-12-06 19:05:47 +13:00
|
|
|
test "the filter name can be overridden" do
|
|
|
|
filter_form =
|
|
|
|
FilterForm.new(Post,
|
|
|
|
params: %{field: :field, operator: :contains, value: ""},
|
|
|
|
as: "resource_filter"
|
|
|
|
)
|
|
|
|
|
|
|
|
assert filter_form.name == "resource_filter"
|
|
|
|
end
|
|
|
|
|
2021-12-02 09:28:38 +13:00
|
|
|
test "the `:components` are available as nested forms" do
|
2021-12-06 18:30:00 +13:00
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|> form_for("action")
|
|
|
|
|
|
|
|
assert [predicate_form] = inputs_for(form, :components)
|
|
|
|
|
2021-12-06 19:05:47 +13:00
|
|
|
assert form.name == "filter"
|
2021-12-06 18:30:00 +13:00
|
|
|
assert form.name == form.source.name
|
|
|
|
assert form.id == form.source.id
|
2021-12-06 19:13:40 +13:00
|
|
|
assert predicate_form.name == form.name <> "[components][0]"
|
2021-12-06 18:30:00 +13:00
|
|
|
assert(input_value(predicate_form, :field) == :title)
|
2021-11-30 15:40:46 +13:00
|
|
|
|
2021-12-02 09:28:38 +13:00
|
|
|
assert input_value(predicate_form, :value) == "new post"
|
|
|
|
assert input_value(predicate_form, :operator) == :eq
|
|
|
|
assert input_value(predicate_form, :negated) == false
|
2021-11-30 15:40:46 +13:00
|
|
|
end
|
2021-12-02 21:12:18 +13:00
|
|
|
|
2021-12-06 15:17:26 +13:00
|
|
|
test "the form ids and names for nested components are correct" do
|
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|> form_for("action")
|
|
|
|
|
|
|
|
assert [predicate_form] = inputs_for(form, :components)
|
|
|
|
|
2021-12-06 18:30:00 +13:00
|
|
|
assert predicate_form.id == predicate_form.source.id
|
2021-12-06 19:13:40 +13:00
|
|
|
assert predicate_form.name == form.name <> "[components][0]"
|
2021-12-06 15:17:26 +13:00
|
|
|
end
|
|
|
|
|
2021-12-02 21:12:18 +13:00
|
|
|
test "using an unknown operator shows an error" do
|
|
|
|
assert [predicate_form] =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
operator: "what_on_earth",
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|> form_for("action")
|
|
|
|
|> inputs_for(:components)
|
|
|
|
|
|
|
|
assert [{:operator, {"No such operator what_on_earth", []}}] = predicate_form.errors
|
|
|
|
end
|
2021-11-30 15:40:46 +13:00
|
|
|
end
|
2021-12-03 06:52:14 +13:00
|
|
|
|
2021-12-06 15:51:35 +13:00
|
|
|
describe "validate/1" do
|
|
|
|
test "will update the forms accordingly" do
|
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
predicate = Enum.at(form.components, 0)
|
|
|
|
|
|
|
|
form =
|
|
|
|
FilterForm.validate(form, %{
|
|
|
|
"components" => %{
|
|
|
|
"0" => %{
|
2022-09-29 07:34:50 +13:00
|
|
|
id: Map.get(predicate, :id),
|
2021-12-06 15:51:35 +13:00
|
|
|
field: :title,
|
|
|
|
value: "new post 2"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
new_predicate = Enum.at(form.components, 0)
|
|
|
|
|
|
|
|
assert %{
|
|
|
|
predicate
|
|
|
|
| value: "new post 2",
|
|
|
|
params: Map.put(predicate.params, "value", "new post 2")
|
|
|
|
} == new_predicate
|
|
|
|
end
|
2022-09-29 07:34:50 +13:00
|
|
|
|
2022-10-04 17:54:50 +13:00
|
|
|
test "changing the field clears the value" do
|
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
predicate = Enum.at(form.components, 0)
|
|
|
|
|
|
|
|
form =
|
|
|
|
FilterForm.validate(form, %{
|
|
|
|
"components" => %{
|
|
|
|
"0" => %{
|
|
|
|
id: Map.get(predicate, :id),
|
|
|
|
field: :other,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
assert is_nil(Enum.at(form.components, 0).value)
|
|
|
|
end
|
|
|
|
|
2023-04-26 10:48:50 +12:00
|
|
|
test "changing the field don't clears the value if reset_on_change? is false" do
|
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
predicate = Enum.at(form.components, 0)
|
|
|
|
|
|
|
|
form =
|
|
|
|
FilterForm.validate(
|
|
|
|
form,
|
|
|
|
%{
|
|
|
|
"components" => %{
|
|
|
|
"0" => %{
|
|
|
|
id: Map.get(predicate, :id),
|
|
|
|
field: :other,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
reset_on_change?: false
|
|
|
|
)
|
|
|
|
|
|
|
|
assert not is_nil(Enum.at(form.components, 0).value)
|
|
|
|
end
|
|
|
|
|
2022-09-29 07:34:50 +13:00
|
|
|
test "the form names for deeply nested components are correct" do
|
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new()
|
|
|
|
|> FilterForm.add_group(return_id?: true)
|
|
|
|
|> then(fn {form, id} -> FilterForm.add_group(form, to: id, return_id?: true) end)
|
|
|
|
|> then(fn {form, id} -> FilterForm.add_group(form, to: id, return_id?: true) end)
|
|
|
|
|> then(fn {form, id} ->
|
|
|
|
FilterForm.add_predicate(form, :title, :eq, "new_post", to: id)
|
|
|
|
end)
|
|
|
|
|
|
|
|
original_form = form_for(form, "action")
|
|
|
|
|
|
|
|
assert [group_form] = inputs_for(original_form, :components)
|
|
|
|
assert group_form.name == form.name <> "[components][0]"
|
|
|
|
assert [sub_group_form] = inputs_for(group_form, :components)
|
|
|
|
assert sub_group_form.name == form.name <> "[components][0][components][0]"
|
|
|
|
assert [predicate_form] = inputs_for(sub_group_form, :components)
|
|
|
|
assert predicate_form.name == form.name <> "[components][0][components][0][components][0]"
|
|
|
|
|
|
|
|
form =
|
|
|
|
FilterForm.validate(form, %{
|
|
|
|
"id" => original_form.id,
|
|
|
|
"components" => %{
|
|
|
|
"0" => %{
|
|
|
|
"id" => group_form.id,
|
|
|
|
"components" => %{
|
|
|
|
"0" => %{
|
|
|
|
"id" => sub_group_form.id,
|
|
|
|
"components" => %{
|
|
|
|
"0" => %{
|
|
|
|
"id" => predicate_form.id,
|
|
|
|
"field" => "title",
|
|
|
|
"value" => "new post"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|> form_for("action")
|
|
|
|
|
|
|
|
assert [group_form] = inputs_for(form, :components)
|
|
|
|
assert group_form.name == form.name <> "[components][0]"
|
|
|
|
assert [sub_group_form] = inputs_for(group_form, :components)
|
|
|
|
assert sub_group_form.name == form.name <> "[components][0][components][0]"
|
|
|
|
assert [predicate_form] = inputs_for(sub_group_form, :components)
|
|
|
|
assert predicate_form.name == form.name <> "[components][0][components][0][components][0]"
|
|
|
|
end
|
2021-12-06 15:51:35 +13:00
|
|
|
end
|
|
|
|
|
2021-12-03 06:52:14 +13:00
|
|
|
describe "params_for_query/1" do
|
|
|
|
test "can be query encoded, and then rebuilt" do
|
|
|
|
form =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(
|
|
|
|
params: %{
|
|
|
|
field: :title,
|
|
|
|
value: "new post"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
assert [predicate_form] =
|
|
|
|
form
|
|
|
|
|> form_for("action")
|
|
|
|
|> inputs_for(:components)
|
|
|
|
|
|
|
|
assert input_value(predicate_form, :field) == :title
|
|
|
|
assert input_value(predicate_form, :value) == "new post"
|
|
|
|
assert input_value(predicate_form, :operator) == :eq
|
|
|
|
assert input_value(predicate_form, :negated) == false
|
|
|
|
|
|
|
|
encoded =
|
|
|
|
form
|
|
|
|
|> FilterForm.params_for_query()
|
|
|
|
|> Plug.Conn.Query.encode()
|
|
|
|
|
|
|
|
decoded = Plug.Conn.Query.decode(encoded)
|
|
|
|
|
|
|
|
assert [predicate_form] =
|
|
|
|
Post
|
|
|
|
|> FilterForm.new(params: decoded)
|
|
|
|
|> form_for("action")
|
|
|
|
|> inputs_for(:components)
|
|
|
|
|
|
|
|
assert input_value(predicate_form, :field) == :title
|
|
|
|
assert input_value(predicate_form, :value) == "new post"
|
|
|
|
assert input_value(predicate_form, :operator) == :eq
|
|
|
|
assert input_value(predicate_form, :negated) == false
|
|
|
|
end
|
|
|
|
end
|
2021-11-30 15:40:46 +13:00
|
|
|
end
|