Format and refactor tests

Author: josevalim

test/ecto/query/builder/distinct_test.exs

@@ -9,25 +9,26 @@ defmodule Ecto.Query.Builder.DistinctTest do
   describe "escape" do
     test "handles expressions and params" do
       assert {true, {[], %{}}} ==
-             escape(true, {[], %{}}, [x: 0], __ENV__)
+               escape(true, {[], %{}}, [x: 0], __ENV__)
 
-      assert {Macro.escape(quote do [asc: &0.y()] end), {[], %{}}} ==
-             escape(quote do x.y() end, {[], %{}}, [x: 0], __ENV__)
+      assert {Macro.escape(quote(do: [asc: &0.y()])), {[], %{}}} ==
+               escape(quote(do: x.y()), {[], %{}}, [x: 0], __ENV__)
 
-      assert {Macro.escape(quote do [asc: &0.x(), asc: &1.y()] end), {[], %{}}} ==
-             escape(quote do [x.x(), y.y()] end, {[], %{}}, [x: 0, y: 1], __ENV__)
+      assert {Macro.escape(quote(do: [asc: &0.x(), asc: &1.y()])), {[], %{}}} ==
+               escape(quote(do: [x.x(), y.y()]), {[], %{}}, [x: 0, y: 1], __ENV__)
 
-      assert {Macro.escape(quote do [asc: &0.x(), desc: &1.y()] end), {[], %{}}} ==
-             escape(quote do [x.x(), desc: y.y()] end, {[], %{}}, [x: 0, y: 1], __ENV__)
+      assert {Macro.escape(quote(do: [asc: &0.x(), desc: &1.y()])), {[], %{}}} ==
+               escape(quote(do: [x.x(), desc: y.y()]), {[], %{}}, [x: 0, y: 1], __ENV__)
 
       import Kernel, except: [>: 2]
-      assert {Macro.escape(quote do [asc: 1 > 2] end), {[], %{}}} ==
-             escape(quote do 1 > 2 end, {[], %{}}, [], __ENV__)
+
+      assert {Macro.escape(quote(do: [asc: 1 > 2])), {[], %{}}} ==
+               escape(quote(do: 1 > 2), {[], %{}}, [], __ENV__)
     end
 
     test "raises on unbound variables" do
       assert_raise Ecto.Query.CompileError, ~r"unbound variable `x` in query", fn ->
-        escape(quote do x.y end, {[], %{}}, [], __ENV__)
+        escape(quote(do: x.y), {[], %{}}, [], __ENV__)
       end
     end
   end
@@ -41,7 +42,7 @@ defmodule Ecto.Query.Builder.DistinctTest do
 
     test "accepts keyword lists" do
       kw = [desc: :title]
-      assert distinct("q", [q], ^kw).distinct == distinct("q", [q], [desc: q.title]).distinct
+      assert distinct("q", [q], ^kw).distinct == distinct("q", [q], desc: q.title).distinct
     end
 
     test "accepts the boolean true" do
@@ -57,28 +58,41 @@ defmodule Ecto.Query.Builder.DistinctTest do
       ]
 
       %{distinct: distinct} = distinct("posts", ^order_by)
+
       assert Macro.to_string(distinct.expr) ==
-             "[asc: &0.foo() == ^0 and &0.bar() == ^1, desc: &0.bar(), asc: &0.baz() == ^2 and &0.bat() == ^3]"
+               "[asc: &0.foo() == ^0 and &0.bar() == ^1, desc: &0.bar(), asc: &0.baz() == ^2 and &0.bat() == ^3]"
+
       assert distinct.params ==
-             [{1, {0, :foo}}, {"bar", {0, :bar}}, {2, {0, :baz}}, {"bat", {0, :bat}}]
+               [{1, {0, :foo}}, {"bar", {0, :bar}}, {2, {0, :baz}}, {"bat", {0, :bat}}]
     end
 
     test "supports subqueries" do
       distinct = [
-        asc: dynamic([p], exists(from other_post in "posts", where: other_post.id == parent_as(:p).id))
+        asc:
+          dynamic(
+            [p],
+            exists(from other_post in "posts", where: other_post.id == parent_as(:p).id)
+          )
       ]
 
       %{distinct: distinct} = from p in "posts", as: :p, distinct: ^distinct
-      assert distinct.expr ==  [asc: {:exists, [], [subquery: 0]}]
+      assert distinct.expr == [asc: {:exists, [], [subquery: 0]}]
       assert [_] = distinct.subqueries
 
-      %{distinct: distinct} = from p in "posts", as: :p, distinct: [asc: exists(from other_post in "posts", where: other_post.id == parent_as(:p).id)]
-      assert distinct.expr ==  [asc: {:exists, [], [subquery: 0]}]
+      %{distinct: distinct} =
+        from p in "posts",
+          as: :p,
+          distinct: [
+            asc: exists(from other_post in "posts", where: other_post.id == parent_as(:p).id)
+          ]
+
+      assert distinct.expr == [asc: {:exists, [], [subquery: 0]}]
       assert [_] = distinct.subqueries
     end
 
     test "raises on non-atoms" do
       message = "expected a field as an atom in `distinct`, got: `\"temp\"`"
+
       assert_raise ArgumentError, message, fn ->
         temp = "temp"
         distinct("posts", [p], [^temp])
@@ -87,6 +101,7 @@ defmodule Ecto.Query.Builder.DistinctTest do
 
     test "raises non-lists" do
       message = ~r"`distinct` interpolated on root expects a field or a keyword list"
+
       assert_raise ArgumentError, message, fn ->
         temp = "temp"
         distinct("posts", [p], ^temp)

test/ecto/query/builder/filter_test.exs

@@ -10,36 +10,41 @@ defmodule Ecto.Query.Builder.FilterTest do
     test "handles expressions, params" do
       import Kernel, except: [==: 2, and: 2]
 
-      assert escape(:where, quote do [] end, 0, [x: 0], __ENV__) ===
-             {true, {[], %{subqueries: []}}}
+      assert escape(:where, quote(do: []), 0, [x: 0], __ENV__) ===
+               {true, {[], %{subqueries: []}}}
 
-      assert escape(:where, quote do {x.x()} == {^"foo"} end, 0, [x: 0], __ENV__) ===
-             {Macro.escape(quote do {&0.x()} == {^0} end),
-             {[{"foo", {0, :x}}], %{subqueries: []}}}
+      assert escape(:where, quote(do: {x.x()} == {^"foo"}), 0, [x: 0], __ENV__) ===
+               {Macro.escape(quote(do: {&0.x()} == {^0})),
+                {[{"foo", {0, :x}}], %{subqueries: []}}}
+
+      escaped = Macro.escape(quote(do: &0.x() == ^0 and &0.y() == ^1))
 
-      escaped = Macro.escape(quote do &0.x() == ^0 and &0.y() == ^1 end)
       assert {^escaped, {params, %{}}} =
-              escape(:where, quote do [x: ^"foo", y: ^"bar"] end, 0, [x: 0], __ENV__)
+               escape(:where, quote(do: [x: ^"foo", y: ^"bar"]), 0, [x: 0], __ENV__)
+
       assert [{{_, _, ["bar", :y]}, {0, :y}}, {{_, _, ["foo", :x]}, {0, :x}}] = params
     end
 
     test "raises on invalid expressions" do
       assert_raise Ecto.Query.CompileError,
-                   ~r"expected a keyword list at compile time in where, got: `\[\{1, 2\}\]`", fn ->
-        escape(:where, quote do [{1, 2}] end, 0, [], __ENV__)
-      end
+                   ~r"expected a keyword list at compile time in where, got: `\[\{1, 2\}\]`",
+                   fn ->
+                     escape(:where, quote(do: [{1, 2}]), 0, [], __ENV__)
+                   end
 
       assert_raise Ecto.Query.CompileError,
-                   ~r"Tuples can only be used in comparisons with literal tuples of the same size", fn ->
-        escape(:where, quote do {1, 2} > ^foo end, 0, [], __ENV__)
-      end
+                   ~r"Tuples can only be used in comparisons with literal tuples of the same size",
+                   fn ->
+                     escape(:where, quote(do: {1, 2} > ^foo), 0, [], __ENV__)
+                   end
     end
 
     test "raises on nils" do
       assert_raise Ecto.Query.CompileError,
-                   ~r"nil given for `x`. Comparison with nil is forbidden as it is unsafe.", fn ->
-        escape(:where, quote do [x: nil] end, 0, [], __ENV__)
-      end
+                   ~r"nil given for `x`. Comparison with nil is forbidden as it is unsafe.",
+                   fn ->
+                     escape(:where, quote(do: [x: nil]), 0, [], __ENV__)
+                   end
     end
 
     test "works without Ecto.Query.subquery/1" do
@@ -49,7 +54,7 @@ defmodule Ecto.Query.Builder.FilterTest do
       %{wheres: [where]} = from(p in "posts", where: exists(s))
 
       assert Macro.to_string(where.expr) ==
-             "exists({:subquery, 0})"
+               "exists({:subquery, 0})"
     end
   end
 
@@ -61,28 +66,34 @@ defmodule Ecto.Query.Builder.FilterTest do
 
     test "accepts keyword lists" do
       %{wheres: [where]} = where(from(p in "posts"), [p], ^[foo: 1, bar: "baz"])
+
       assert Macro.to_string(where.expr) ==
-             "&0.foo() == ^0 and &0.bar() == ^1"
+               "&0.foo() == ^0 and &0.bar() == ^1"
+
       assert where.params ==
-             [{1, {0, :foo}}, {"baz", {0, :bar}}]
+               [{1, {0, :foo}}, {"baz", {0, :bar}}]
     end
 
     test "supports dynamic expressions" do
       dynamic = dynamic([p], p.foo == ^1 and p.bar == ^"baz")
       %{wheres: [where]} = where("posts", ^dynamic)
+
       assert Macro.to_string(where.expr) ==
-             "&0.foo() == ^0 and &0.bar() == ^1"
+               "&0.foo() == ^0 and &0.bar() == ^1"
+
       assert where.params ==
-             [{1, {0, :foo}}, {"baz", {0, :bar}}]
+               [{1, {0, :foo}}, {"baz", {0, :bar}}]
     end
 
     test "in subquery" do
       s = from(p in "posts", select: p.id, where: p.public == ^true)
       %{wheres: [where]} = from(p in "posts", where: p.id in subquery(s))
+
       assert Macro.to_string(where.expr) ==
-             "&0.id() in {:subquery, 0}"
+               "&0.id() in {:subquery, 0}"
+
       assert where.params ==
-        [{:subquery, 0}]
+               [{:subquery, 0}]
     end
 
     test "supports exists subquery expressions" do
@@ -91,20 +102,21 @@ defmodule Ecto.Query.Builder.FilterTest do
       %{wheres: [where]} = from(p in "posts", where: exists(s))
 
       assert Macro.to_string(where.expr) ==
-             "exists({:subquery, 0})"
+               "exists({:subquery, 0})"
+
       assert where.params ==
-             [{:subquery, 0}]
+               [{:subquery, 0}]
     end
 
     test "supports comparison with subqueries with all and any quantifiers" do
       s = from(p in "posts", select: p.rating, order_by: [desc: p.created_at], limit: 10)
 
       assert_quantified_subquery = fn %{wheres: [where]}, expected_quantifier ->
         assert Macro.to_string(where.expr) ==
-               "&0.rating() >= #{expected_quantifier}({:subquery, 0})"
+                 "&0.rating() >= #{expected_quantifier}({:subquery, 0})"
 
         assert where.params ==
-                [{:subquery, 0}]
+                 [{:subquery, 0}]
       end
 
       all_query = from(p in "posts", where: p.rating >= all(s))
@@ -120,9 +132,10 @@ defmodule Ecto.Query.Builder.FilterTest do
       %{wheres: [where]} = from(p in "posts", where: p.rating > subquery(s), select: p.id)
 
       assert Macro.to_string(where.expr) ==
-             "&0.rating() > {:subquery, 0}"
+               "&0.rating() > {:subquery, 0}"
+
       assert where.params ==
-             [{:subquery, 0}]
+               [{:subquery, 0}]
     end
 
     test "raises on invalid keywords" do

test/ecto/query/builder/group_by_test.exs

@@ -8,34 +8,36 @@ defmodule Ecto.Query.Builder.GroupByTest do
 
   describe "escape" do
     test "handles expressions and params" do
-      assert {Macro.escape(quote do [&0.y()] end), {[], %{}}} ==
-             escape(:group_by, quote do x.y() end, {[], %{}}, [x: 0], __ENV__)
+      assert {Macro.escape(quote(do: [&0.y()])), {[], %{}}} ==
+               escape(:group_by, quote(do: x.y()), {[], %{}}, [x: 0], __ENV__)
 
-      assert {Macro.escape(quote do [&0.x(), &1.y()] end), {[], %{}}} ==
-             escape(:group_by, quote do [x.x(), y.y()] end, {[], %{}}, [x: 0, y: 1], __ENV__)
+      assert {Macro.escape(quote(do: [&0.x(), &1.y()])), {[], %{}}} ==
+               escape(:group_by, quote(do: [x.x(), y.y()]), {[], %{}}, [x: 0, y: 1], __ENV__)
 
       import Kernel, except: [>: 2]
-      assert {Macro.escape(quote do [1 > 2] end), {[], %{}}} ==
-             escape(:group_by, quote do 1 > 2 end, {[], %{}}, [], __ENV__)
+
+      assert {Macro.escape(quote(do: [1 > 2])), {[], %{}}} ==
+               escape(:group_by, quote(do: 1 > 2), {[], %{}}, [], __ENV__)
     end
 
     test "raises on unbound variables" do
       message = ~r"unbound variable `x` in query"
+
       assert_raise Ecto.Query.CompileError, message, fn ->
-        escape(:group_by, quote do x.y end, {[], %{}}, [], __ENV__)
+        escape(:group_by, quote(do: x.y), {[], %{}}, [], __ENV__)
       end
     end
 
     test "can reference the alias of a selected value with selected_as/1" do
       query = from p in "posts", select: selected_as(p.id, :ident), group_by: selected_as(:ident)
-      assert [{:selected_as, [], [:ident]}]  = hd(query.group_bys).expr
+      assert [{:selected_as, [], [:ident]}] = hd(query.group_bys).expr
     end
 
     test "raises if name given to selected_as/1 is not an atom" do
       message = "expected literal atom or interpolated value in selected_as/1, got: `\"ident\"`"
 
       assert_raise Ecto.Query.CompileError, message, fn ->
-        escape(:group_by, quote do selected_as("ident") end, {[], %{}}, [], __ENV__)
+        escape(:group_by, quote(do: selected_as("ident")), {[], %{}}, [], __ENV__)
       end
     end
   end
@@ -60,20 +62,27 @@ defmodule Ecto.Query.Builder.GroupByTest do
       assert group_by.expr == [{:exists, [], [{:subquery, 0}]}]
       assert [_] = group_by.subqueries
 
-      assert [group_by] = group_by("q", [q], exists(from other_q in "q", where: other_q.title == parent_as(:q).title)).group_bys
+      assert [group_by] =
+               group_by(
+                 "q",
+                 [q],
+                 exists(from other_q in "q", where: other_q.title == parent_as(:q).title)
+               ).group_bys
 
       assert group_by.expr == [{:exists, [], [{:subquery, 0}]}]
       assert [_] = group_by.subqueries
     end
 
     test "raises when no a field or a list of fields" do
       message = "expected a field as an atom in `group_by`, got: `\"temp\"`"
+
       assert_raise ArgumentError, message, fn ->
         temp = "temp"
         group_by("posts", [p], [^temp])
       end
 
       message = "expected a list of fields and dynamics in `group_by`, got: `\"temp\"`"
+
       assert_raise ArgumentError, message, fn ->
         temp = "temp"
         group_by("posts", [p], ^temp)