Add more tests for pp

Author: Premwoik

lib/gradient/elixir_type.ex

@@ -28,7 +28,7 @@ defmodule Gradient.ElixirType do
   end
 
   def pretty_print({:ann_type, _, [var_name, var_type]}) do
-    pretty_print(var_name) <> pretty_print(var_type)
+    pretty_print(var_name) <> " :: " <> pretty_print(var_type)
   end
 
   def pretty_print({:type, _, :map, :any}) do

test/gradient/elixir_type_test.exs

@@ -3,46 +3,14 @@ defmodule Gradient.ElixirTypeTest do
   doctest Gradient.ElixirType
 
   alias Gradient.ElixirType
+  alias Gradient.TypeData
 
-  test "pp integer()" do
-    type = {:integer, 0, 12}
-    expected = "12"
-    actual = ElixirType.pretty_print(type)
-    assert expected == actual
-  end
-
-  test "pp atom()" do
-    type = {:atom, 0, :ok}
-    expected = ":ok"
-    actual = ElixirType.pretty_print(type)
-    assert expected == actual
-  end
-
-  test "pp nil()" do
-    type = {:atom, 0, nil}
-    expected = "nil"
-    actual = ElixirType.pretty_print(type)
-    assert expected == actual
-  end
-
-  test "pp false boolean()" do
-    type = {:atom, 0, false}
-    expected = "false"
-    actual = ElixirType.pretty_print(type)
-    assert expected == actual
-  end
-
-  test "pp true boolean()" do
-    type = {:atom, 0, true}
-    expected = "true"
-    actual = ElixirType.pretty_print(type)
-    assert expected == actual
-  end
-
-  test "pp binary()" do
-    type = {:type, 0, :binary, []}
-    expected = "binary()"
-    actual = ElixirType.pretty_print(type)
-    assert expected == actual
+  describe "pretty print" do
+    for {name, type, expected} <- TypeData.all_pp_test_data() do
+      test "#{name}" do
+        type = unquote(Macro.escape(type))
+        assert unquote(expected) == ElixirType.pretty_print(type)
+      end
+    end
   end
 end

test/support/type_data.ex

@@ -0,0 +1,91 @@
+defmodule Gradient.TypeData do
+  @spec all_pp_test_data() :: [{name :: String.t(), type :: tuple(), expected :: String.t()}]
+  def all_pp_test_data() do
+    [
+      value_test_data(),
+      buildin_types_test_data(),
+      op_types_test_data(),
+      fun_types_test_data(),
+      map_types_test_data(),
+      tuple_types_test_data(),
+      other_types_test_data()
+    ]
+    |> List.flatten()
+  end
+
+  def value_test_data() do
+    [
+      {"integer value", {:integer, 0, 12}, "12"},
+      {"atom value", {:atom, 0, :ok}, ":ok"},
+      {"boolean false", {:atom, 0, false}, "false"},
+      {"boolean true", {:atom, 0, true}, "true"},
+      {"nil", {:atom, 0, nil}, "nil"}
+    ]
+  end
+
+  def buildin_types_test_data() do
+    [
+      {"integer type", {:type, 0, :integer, []}, "integer()"},
+      {"float type", {:type, 0, :float, []}, "float()"},
+      {"atom type", {:type, 0, :atom, []}, "atom()"},
+      {"boolean type", {:type, 0, :boolean, []}, "boolean()"},
+      {"binary type", {:type, 0, :binary, []}, "binary()"},
+      {"range type", {:type, 0, :range, [{:integer, 0, 1}, {:integer, 0, 10}]}, "1..10"},
+      {"list type", {:type, 0, :list, []}, "list()"},
+      {"nonempty_list type", {:type, 0, :nonempty_list, []}, "nonempty_list()"},
+      {"nil() or []", {:type, 0, nil, []}, "[]"},
+      {"type with args", {:type, 0, :list, [{:type, 0, :integer, []}]}, "list(integer())"}
+    ]
+  end
+
+  def op_types_test_data() do
+    [
+      {"binary operator", {:op, 0, :+, {:integer, 0, 1}, {:integer, 0, 2}}, "1 + 2"},
+      {"unary operator", {:op, 0, :not, {:var, 0, :status}}, "not status"}
+    ]
+  end
+
+  def fun_types_test_data() do
+    [
+      {"any fun type", {:type, 0, :fun, []}, "fun()"},
+      {"fun accepts any args that returns specified type",
+       {:type, 0, :fun, [{:type, 0, :any}, {:atom, 0, :ok}]}, "(... -> :ok)"},
+      {"fun accepts specified args and return specified type",
+       {:type, 0, :fun, [{:type, 0, :product, [{:type, 0, :atom, []}]}, {:type, 0, :atom, []}]},
+       "(atom() -> atom())"}
+    ]
+  end
+
+  def map_types_test_data() do
+    [
+      {"any map type", {:type, 0, :map, :any}, "map()"},
+      {"complex map type",
+       {:type, 0, :map,
+        [
+          {:type, 0, :map_field_assoc, [{:atom, 0, :value_a}, {:integer, 0, 5}]},
+          {:type, 0, :map_field_exact, [{:atom, 0, :value_b}, {:atom, 0, :neo}]}
+        ]}, "%{optional(:value_a) => 5, required(:value_b) => :neo}"}
+    ]
+  end
+
+  def tuple_types_test_data() do
+    [
+      {"any tuple type", {:type, 0, :tuple, :any}, "tuple()"},
+      {"tuple {:ok, 8}", {:type, 0, :tuple, [{:atom, 0, :ok}, {:integer, 0, 8}]}, "{:ok, 8}"}
+    ]
+  end
+
+  def other_types_test_data() do
+    [
+      {"var type", {:var, 0, :a}, "a"},
+      {"anotated type", {:ann_type, 0, [{:var, 0, :name}, {:type, 0, :integer, []}]},
+       "name :: integer()"},
+      {"remote type without args",
+       {:remote_type, 0, [{:atom, 0, MyModule}, {:atom, 0, :my_fun}, []]}, "MyModule.my_fun()"},
+      {"remote type with args",
+       {:remote_type, 0, [{:atom, 0, MyModule}, {:atom, 0, :my_fun}, [{:type, 0, :integer, []}]]},
+       "MyModule.my_fun(integer())"},
+      {"user type", {:user_type, 0, :my_type, [{:type, 0, :atom, []}]}, "my_type(atom())"}
+    ]
+  end
+end