Fix type system warnings

Author: josevalim

test/ecto/changeset_test.exs

@@ -537,14 +537,6 @@ defmodule Ecto.ChangesetTest do
     assert_raise Ecto.CastError, ~r"mixed keys", fn ->
       cast(%Post{}, %{"title" => "foo", title: "foo"}, ~w())
     end
-
-    assert_raise FunctionClauseError, fn ->
-      cast(%Post{}, %{}, %{})
-    end
-
-    assert_raise FunctionClauseError, fn ->
-      cast(%Post{}, %{"title" => "foo"}, nil)
-    end
   end
 
   test "cast/4: protects against atom injection" do
@@ -1280,12 +1272,6 @@ defmodule Ecto.ChangesetTest do
       |> validate_required("title")
     end
 
-    # When field is nil
-    assert_raise FunctionClauseError, fn ->
-      changeset(%{"title" => "hello"})
-      |> validate_required(nil)
-    end
-
     # When field is list and is an empty value
     changeset =
       %Post{topics: ["foo"]}

test/ecto/multi_test.exs

@@ -438,12 +438,6 @@ defmodule Ecto.MultiTest do
     assert multi.operations == [{:changeset, {:changeset, changeset, []}}]
   end
 
-  test "add run with invalid arity" do
-    assert_raise FunctionClauseError, fn ->
-      Multi.new() |> Multi.run(:run, fn -> nil end)
-    end
-  end
-
   test "repeating an operation" do
     fun = fn _, _ -> {:ok, :ok} end
 

test/ecto/query/builder/distinct_test.exs

@@ -95,7 +95,7 @@ defmodule Ecto.Query.Builder.DistinctTest do
 
       assert_raise ArgumentError, message, fn ->
         temp = "temp"
-        distinct("posts", [p], [^temp])
+        distinct("posts", [p], [^Process.get(:unused, temp)])
       end
     end
 

test/ecto/query/builder/group_by_test.exs

@@ -78,14 +78,14 @@ defmodule Ecto.Query.Builder.GroupByTest do
 
       assert_raise ArgumentError, message, fn ->
         temp = "temp"
-        group_by("posts", [p], [^temp])
+        group_by("posts", [p], [^Process.get(:unused, 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)
+        group_by("posts", [p], ^Process.get(:unused, temp))
       end
     end
 

test/ecto/query/builder/join_test.exs

@@ -136,7 +136,7 @@ defmodule Ecto.Query.Builder.JoinTest do
   test "raises on invalid qualifier" do
     assert_raise ArgumentError, ~r/invalid join qualifier `:whatever`/, fn ->
       qual = :whatever
-      join("posts", qual, [p], c in "comments", on: true)
+      join("posts", Process.get(:unused, qual), [p], c in "comments", on: true)
     end
   end
 

test/ecto/query/builder/limit_offset_test.exs

@@ -1,4 +1,4 @@
-Code.require_file "../../../support/eval_helpers.exs", __DIR__
+Code.require_file("../../../support/eval_helpers.exs", __DIR__)
 
 defmodule Ecto.Query.Builder.LimitOffsetTest do
   use ExUnit.Case, async: true
@@ -48,18 +48,22 @@ defmodule Ecto.Query.Builder.LimitOffsetTest do
 
   test "with_ties must be a runtime or compile time boolean" do
     msg = "`with_ties` expression must evaluate to a boolean at runtime, got: `1`"
+
     assert_raise RuntimeError, msg, fn ->
-      with_ties("posts", ^1)
+      with_ties("posts", ^Process.get(:unused, 1))
     end
 
-    msg = "`with_ties` expression must be a compile time boolean or an interpolated value using ^, got: `1`"
+    msg =
+      "`with_ties` expression must be a compile time boolean or an interpolated value using ^, got: `1`"
+
     assert_raise Ecto.Query.CompileError, msg, fn ->
-      quote_and_eval with_ties("posts", 1)
+      quote_and_eval(with_ties("posts", 1))
     end
   end
 
   test "with_ties requires a limit" do
     msg = "`with_ties` can only be applied to queries containing a `limit`"
+
     assert_raise Ecto.Query.CompileError, msg, fn ->
       with_ties("posts", true)
     end

test/ecto/query/builder/order_by_test.exs

@@ -258,7 +258,7 @@ defmodule Ecto.Query.Builder.OrderByTest do
     test "raises on invalid direction" do
       assert_raise ArgumentError, ~r"expected one of :asc,", fn ->
         temp = :temp
-        order_by("posts", [p], [{^var!(temp), p.y}])
+        order_by("posts", [p], [{^Process.get(:unused, temp), p.y}])
       end
     end
 
@@ -267,12 +267,12 @@ defmodule Ecto.Query.Builder.OrderByTest do
 
       assert_raise ArgumentError, message, fn ->
         temp = "temp"
-        order_by("posts", [p], asc: ^temp)
+        order_by("posts", [p], asc: ^Process.get(:unused, temp))
       end
 
       assert_raise ArgumentError, ~r"To use dynamic expressions", fn ->
         dynamic_expr = dynamic([p], p.foo == ^1)
-        order_by("posts", [p], asc: ^dynamic_expr)
+        order_by("posts", [p], asc: ^Process.get(:unused, dynamic_expr))
       end
     end
 

test/ecto/query/builder/preload_test.exs

@@ -1,4 +1,4 @@
-Code.require_file "../../../support/eval_helpers.exs", __DIR__
+Code.require_file("../../../support/eval_helpers.exs", __DIR__)
 
 defmodule Ecto.Query.Builder.PreloadTest do
   use ExUnit.Case, async: true
@@ -19,70 +19,92 @@ defmodule Ecto.Query.Builder.PreloadTest do
       comments = :comments
       assert preload("posts", ^comments).preloads == [:comments]
       assert preload("posts", ^[comments]).preloads == [:comments]
-      assert preload("posts", [users: ^comments]).preloads == [users: :comments]
+      assert preload("posts", users: ^comments).preloads == [users: :comments]
       assert preload("posts", ^[users: comments]).preloads == [users: :comments]
-      assert preload("posts", [users: ^[comments]]).preloads == [users: [:comments]]
+      assert preload("posts", users: ^[comments]).preloads == [users: [:comments]]
       assert preload("posts", ^[users: [comments]]).preloads == [users: [:comments]]
       assert preload("posts", [{^:users, ^comments}]).preloads == [users: :comments]
       assert preload("posts", [[[users: ^comments]]]).preloads == [users: :comments]
       assert preload("posts", ^[[[users: comments]]]).preloads == [users: :comments]
       assert preload("posts", [[users: [[^comments]]]]).preloads == [users: [:comments]]
       assert preload("posts", ^[[users: [[comments]]]]).preloads == [users: [:comments]]
-      assert preload("posts", [[:likes, users: [[^comments]]]]).preloads == [{:users, [:comments]}, :likes]
-      assert preload("posts", ^[[:likes, users: [[comments]]]]).preloads == [{:users, [:comments]}, :likes]
+
+      assert preload("posts", [[:likes, users: [[^comments]]]]).preloads == [
+               {:users, [:comments]},
+               :likes
+             ]
+
+      assert preload("posts", ^[[:likes, users: [[comments]]]]).preloads == [
+               {:users, [:comments]},
+               :likes
+             ]
 
       query = from u in "users", limit: 10
-      assert preload("posts", [users: ^query]).preloads == [users: query]
+      assert preload("posts", users: ^query).preloads == [users: query]
       assert preload("posts", [{^:users, ^query}]).preloads == [users: query]
       assert preload("posts", ^[users: query]).preloads == [users: query]
-      assert preload("posts", [users: ^{query, :comments}]).preloads == [users: {query, :comments}]
-      assert preload("posts", ^[users: {query, :comments}]).preloads == [users: {query, [:comments]}]
+      assert preload("posts", users: ^{query, :comments}).preloads == [users: {query, :comments}]
+
+      assert preload("posts", ^[users: {query, :comments}]).preloads == [
+               users: {query, [:comments]}
+             ]
 
       fun = fn _ -> [] end
-      assert preload("posts", [users: ^fun]).preloads == [users: fun]
+      assert preload("posts", users: ^fun).preloads == [users: fun]
       assert preload("posts", [{^:users, ^fun}]).preloads == [users: fun]
       assert preload("posts", ^[users: fun]).preloads == [users: fun]
-      assert preload("posts", [users: ^{fun, :comments}]).preloads == [users: {fun, :comments}]
+      assert preload("posts", users: ^{fun, :comments}).preloads == [users: {fun, :comments}]
       assert preload("posts", ^[users: {fun, :comments}]).preloads == [users: {fun, [:comments]}]
     end
 
     test "supports interpolation with associations" do
       comments = :comments
 
       query = from p in "posts", join: c in assoc(p, :comments), as: ^comments
+
       assert %{preloads: [], assocs: [{:comments, {1, []}}]} =
                preload(query, [{^comments, c}], [{^comments, c}])
+
       assert %{preloads: [:foo], assocs: [{:comments, {1, []}}]} =
                preload(query, [{^comments, c}], [:foo, {^comments, c}])
 
       query =
         from p in "posts",
-          join: f in assoc(p, :foo), as: :foo,
-          join: c in assoc(f, :comments), as: ^comments
+          join: f in assoc(p, :foo),
+          as: :foo,
+          join: c in assoc(f, :comments),
+          as: ^comments
+
       assert %{preloads: [], assocs: [{:foo, {1, [{:comments, {2, []}}]}}]} =
-               preload(query, [{:foo, f}, {^comments, c}], [foo: {f, [{^comments, c}]}])
+               preload(query, [{:foo, f}, {^comments, c}], foo: {f, [{^comments, c}]})
     end
 
     test "supports dynamics for join association bindings using named bindings" do
       comments = :comments
 
       query =
         from p in "posts",
-        join: c in assoc(p, :comments),
-        as: ^comments
+          join: c in assoc(p, :comments),
+          as: ^comments
+
       preloads = [
         comments: dynamic([{^comments, c}], c)
       ]
+
       assert %{preloads: [], assocs: [comments: {1, []}]} = preload(query, ^preloads)
 
       query =
         from p in "posts",
-        join: c in assoc(p, :comments), as: ^comments,
-        join: l in assoc(p, :likes), as: :likes
+          join: c in assoc(p, :comments),
+          as: ^comments,
+          join: l in assoc(p, :likes),
+          as: :likes
+
       preloads = [
         likes: dynamic([likes: l], l),
         comments: dynamic([{^comments, c}], c)
       ]
+
       assert %{preloads: [], assocs: [likes: {2, []}, comments: {1, []}]} =
                preload(query, ^preloads)
     end
@@ -94,20 +116,24 @@ defmodule Ecto.Query.Builder.PreloadTest do
 
       query =
         from p in "posts",
-        join: assoc(p, :comments),
-        join: assoc(p, :likes)
+          join: assoc(p, :comments),
+          join: assoc(p, :likes)
+
       preloads = [
         likes: dynamic([_p, _c, l], l),
         comments: dynamic([_p, c], c)
       ]
+
       assert %{preloads: [], assocs: [likes: {2, []}, comments: {1, []}]} =
                preload(query, ^preloads)
 
       query =
         from p in "posts",
-        join: c in assoc(p, :comments),
-        join: assoc(c, :likes)
+          join: c in assoc(p, :comments),
+          join: assoc(c, :likes)
+
       preloads = [comments: {dynamic([_p, c], c), likes: dynamic([_p, _c, l], l)}]
+
       assert %{preloads: [], assocs: [comments: {1, [likes: {2, []}]}]} =
                preload(query, ^preloads)
     end
@@ -141,39 +167,46 @@ defmodule Ecto.Query.Builder.PreloadTest do
       assert_raise Ecto.Query.CompileError, message, fn ->
         quote_and_eval(%Ecto.Query{} |> preload(1))
       end
+
       assert_raise Ecto.Query.CompileError, message, fn ->
         quote_and_eval(%Ecto.Query{} |> preload([1]))
       end
 
       assert_raise ArgumentError, message, fn ->
-         preload(%Ecto.Query{}, ^1)
+        preload(%Ecto.Query{}, ^1)
       end
+
       assert_raise ArgumentError, message, fn ->
-         preload(%Ecto.Query{}, ^[1])
+        preload(%Ecto.Query{}, ^[1])
       end
     end
 
     test "raises on invalid keys" do
       message = ~r"malformed key in preload `1`"
+
       assert_raise Ecto.Query.CompileError, message, fn ->
         quote_and_eval(%Ecto.Query{} |> preload([{1, :foo}]))
       end
 
       message = ~r"expected key in preload to be an atom, got: `1`"
+
       assert_raise ArgumentError, message, fn ->
         temp = 1
-        preload(%Ecto.Query{}, [{^temp, :foo}])
+        preload(%Ecto.Query{}, [{^Process.get(:unused, temp), :foo}])
       end
+
       assert_raise ArgumentError, message, fn ->
         preload(%Ecto.Query{}, ^[{1, :foo}])
       end
     end
 
     test "raises when preload join association is nested in non-join" do
       message = ~r"cannot preload join association `:comments`"
+
       assert_raise Ecto.Query.CompileError, message, fn ->
-        quote_and_eval(%Ecto.Query{} |> preload([_, c], [users: [comments: c]]))
+        quote_and_eval(%Ecto.Query{} |> preload([_, c], users: [comments: c]))
       end
+
       assert_raise ArgumentError, message, fn ->
         query = from p in "posts", join: c in assoc(p, :comments)
         preload(query, ^[users: [comments: dynamic([_, c], c)]])
@@ -182,6 +215,7 @@ defmodule Ecto.Query.Builder.PreloadTest do
 
     test "raises when dynamic evaluates to something other than single binding" do
       message = ~r"invalid dynamic in preload: `dynamic\(\[_, c\], c.field\)`"
+
       assert_raise ArgumentError, message, fn ->
         query = from p in "posts", join: c in assoc(p, :comments)
         preload(query, ^[comments: dynamic([_, c], c.field)])
@@ -190,9 +224,10 @@ defmodule Ecto.Query.Builder.PreloadTest do
 
     test "raises when preload function has more than two arguments" do
       message = ~r"invalid preload for key `:comments`:"
+
       assert_raise ArgumentError, message, fn ->
         query = from p in "posts", join: c in assoc(p, :comments)
-        preload(query, ^[comments: fn _, _, _  -> [] end])
+        preload(query, ^[comments: fn _, _, _ -> [] end])
       end
     end
   end

test/ecto/query/builder/select_test.exs

@@ -480,7 +480,7 @@ defmodule Ecto.Query.Builder.SelectTest do
       message = "expected atom in selected_as/2, got: `\"ident\"`"
 
       assert_raise Ecto.Query.CompileError, message, fn ->
-        from p in "posts", select: selected_as(p.id, ^"ident")
+        from p in "posts", select: selected_as(p.id, ^Process.get(:unused, "ident"))
       end
     end