Test pretty printing types in elixir

Author: Premwoik

test/examples/type/Elixir.WrongRet.beam

@@ -8,8 +8,8 @@ defmodule WrongRet do
   @spec ret_wrong_atom3() :: atom()
   def ret_wrong_atom3, do: %{a: 1}
 
-  @spec ret_wrong_atom4() :: atom()
-  def ret_wrong_atom4, do: false
+  # @spec ret_wrong_atom4() :: atom()
+  # def ret_wrong_atom4, do: false
 
   @spec ret_wrong_integer() :: integer()
   def ret_wrong_integer, do: 1.0
@@ -46,4 +46,7 @@ defmodule WrongRet do
 
   @spec ret_wrong_map() :: map()
   def ret_wrong_map, do: {:a, 1, 2}
+
+  @spec ret_wrong_fun() :: (... -> atom())
+  def ret_wrong_fun, do: fn -> 12 end
 end

test/examples/type/wrong_ret.ex

@@ -8,6 +8,10 @@ defmodule Gradient.ElixirFmtTest do
 
   @example_module_path "test/examples/simple_app.ex"
 
+  setup_all config do
+    load_wrong_ret_error_examples(config)
+  end
+
   test "try_highlight_in_context/2" do
     opts = [forms: basic_erlang_forms()]
     expression = {:integer, 31, 12}
@@ -20,16 +24,110 @@ defmodule Gradient.ElixirFmtTest do
     assert res == expected
   end
 
-  @tag :skip
   describe "types format" do
-    test "wrong return type" do
-      {_tokens, ast} = load("/type/Elixir.WrongRet.beam", "/type/wrong_ret.ex")
-      opts = []
-      errors = type_check_file(ast, opts)
+    test "return integer() instead atom()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_atom)
+
+      assert String.contains?(msg, "atom()")
+      assert String.contains?(msg, "1")
+    end
+
+    test "return tuple() instead atom()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_atom2)
+
+      assert String.contains?(msg, "atom()")
+      assert String.contains?(msg, "{:ok, []}")
+    end
+
+    test "return map() instead atom()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_atom3)
+
+      assert String.contains?(msg, "atom()")
+      assert String.contains?(msg, "%{required(:a) => 1}")
+    end
+
+    test "return float() instead integer()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_integer)
+
+      assert String.contains?(msg, "integer()")
+      assert String.contains?(msg, "1.0")
+    end
+
+    test "return atom() instead integer()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_integer2)
+
+      assert String.contains?(msg, "integer()")
+      assert String.contains?(msg, ":ok")
+    end
+
+    test "return boolean() instead integer()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_integer3)
+
+      assert String.contains?(msg, "integer()")
+      assert String.contains?(msg, "true")
+    end
+
+    test "return list() instead integer()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_integer4)
+
+      assert String.contains?(msg, "integer()")
+      assert String.contains?(msg, "nonempty_list()")
+    end
+
+    test "return integer() out of the range()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_out_of_range_int)
+
+      assert String.contains?(msg, "range(1, 10)")
+      assert String.contains?(msg, "12")
+    end
+
+    test "return atom() instead boolean()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_boolean)
+
+      assert String.contains?(msg, "boolean()")
+      assert String.contains?(msg, ":ok")
+    end
+
+    test "return binary() instead boolean()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_boolean2)
+
+      assert String.contains?(msg, "boolean()")
+      assert String.contains?(msg, "binary()")
+    end
+
+    test "return integer() instead boolean()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_boolean3)
+
+      assert String.contains?(msg, "boolean()")
+      assert String.contains?(msg, "1")
+    end
+
+    test "return keyword() instead boolean()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_boolean4)
+
+      assert String.contains?(msg, "boolean()")
+      assert String.contains?(msg, "nonempty_list()")
+    end
+
+    test "return list() instead keyword()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_keyword)
+
+      assert String.contains?(msg, "{atom(), any()}")
+      assert String.contains?(msg, "1")
+    end
+
+    test "return tuple() instead map()", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_map)
 
-      for e <- errors do
-        :io.put_chars(e)
-      end
+      assert String.contains?(msg, "map()")
+      assert String.contains?(msg, "{:a, 1, 2}")
+    end
+
+    test "return lambda with wrong returned type", %{wrong_ret_errors: errors} do
+      msg = format_error_to_binary(errors.ret_wrong_fun)
+
+      assert String.contains?(msg, "atom()")
+      assert String.contains?(msg, "12")
     end
   end
 
@@ -44,17 +142,52 @@ defmodule Gradient.ElixirFmtTest do
     IO.puts(res)
   end
 
-  def basic_erlang_forms() do
+  # Helpers
+
+  defp basic_erlang_forms() do
     [{:attribute, 1, :file, {@example_module_path, 1}}]
   end
 
-  def type_check_file(ast, opts) do
+  defp type_check_file(ast, opts) do
     forms = AstSpecifier.specify(ast)
     opts = Keyword.put(opts, :return_errors, true)
     opts = Keyword.put(opts, :forms, forms)
 
-    forms
-    |> :gradualizer.type_check_forms(opts)
-    |> Enum.map(fn {_, err} -> ElixirFmt.format_error(err, opts) end)
+    errors =
+      forms
+      |> :gradualizer.type_check_forms(opts)
+      |> Enum.map(&elem(&1, 1))
+
+    {errors, forms}
+  end
+
+  defp format_error_to_binary(error, opts \\ []) do
+    error
+    |> ElixirFmt.format_error(opts)
+    |> :erlang.iolist_to_binary()
+  end
+
+  @spec load_wrong_ret_error_examples(map()) :: map()
+  defp load_wrong_ret_error_examples(config) do
+    {_tokens, ast} = load("/type/Elixir.WrongRet.beam", "/type/wrong_ret.ex")
+
+    {errors, forms} = type_check_file(ast, [])
+    names = get_function_names_from_ast(forms)
+
+    errors_map =
+      Enum.zip(names, errors)
+      |> Map.new()
+
+    Map.put(config, :wrong_ret_errors, errors_map)
+  end
+
+  @spec get_function_names_from_ast([tuple()]) :: [atom()]
+  def get_function_names_from_ast(ast) do
+    ast
+    |> Enum.filter(fn
+      {:function, _, name, _, _} -> name != :__info__
+      _ -> false
+    end)
+    |> Enum.map(&elem(&1, 2))
   end
 end