Assert results more precise, Add tests

Author: Premwoik

test/examples/type/Elixir.RecordEx.beam

@@ -0,0 +1,12 @@
+defmodule RecordEx do
+  require Record
+  Record.defrecord(:user, name: "john", age: 25)
+
+  @type user :: record(:user, name: String.t(), age: integer)
+
+  @spec ret_wrong_record() :: user()
+  def ret_wrong_record(), do: :ok
+
+  @spec ret_wrong_record2() :: user()
+  def ret_wrong_record2(), do: user(name: 12)
+end

test/examples/type/Elixir.WrongRet.beam

@@ -26,6 +26,26 @@ defmodule WrongRet do
   @spec ret_out_of_range_int() :: 1..10
   def ret_out_of_range_int, do: 12
 
+  @spec ret_wrong_float() :: float()
+  def ret_wrong_float() do
+    1
+  end
+
+  @spec ret_wrong_float2() :: float()
+  def ret_wrong_float2() do
+    nil
+  end
+
+  @spec ret_wrong_char() :: char()
+  def ret_wrong_char() do
+    'Ala ma kota'
+  end
+
+  @spec ret_wrong_char2() :: ?o
+  def ret_wrong_char2() do
+    nil
+  end
+
   @spec ret_wrong_boolean() :: boolean()
   def ret_wrong_boolean, do: :ok
 

test/examples/type/record.ex

@@ -9,7 +9,9 @@ defmodule Gradient.ElixirFmtTest do
   @example_module_path "test/examples/simple_app.ex"
 
   setup_all config do
-    load_wrong_ret_error_examples(config)
+    config
+    |> load_wrong_ret_error_examples()
+    |> load_record_type_example()
   end
 
   test "try_highlight_in_context/2" do
@@ -26,108 +28,151 @@ defmodule Gradient.ElixirFmtTest do
 
   describe "types format" do
     test "return integer() instead atom()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_atom)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_atom)
 
-      assert String.contains?(msg, "atom()")
-      assert String.contains?(msg, "1")
+      assert String.contains?(expected, "atom()")
+      assert String.contains?(actual, "1")
     end
 
     test "return tuple() instead atom()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_atom2)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_atom2)
 
-      assert String.contains?(msg, "atom()")
-      assert String.contains?(msg, "{:ok, []}")
+      assert String.contains?(expected, "atom()")
+      assert String.contains?(actual, "{:ok, []}")
     end
 
     test "return map() instead atom()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_atom3)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_atom3)
 
-      assert String.contains?(msg, "atom()")
-      assert String.contains?(msg, "%{required(:a) => 1}")
+      assert String.contains?(expected, "atom()")
+      assert String.contains?(actual, "%{required(:a) => 1}")
     end
 
     test "return float() instead integer()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_integer)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_integer)
 
-      assert String.contains?(msg, "integer()")
-      assert String.contains?(msg, "1.0")
+      assert String.contains?(expected, "integer()")
+      assert String.contains?(actual, "float()")
     end
 
     test "return atom() instead integer()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_integer2)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_integer2)
 
-      assert String.contains?(msg, "integer()")
-      assert String.contains?(msg, ":ok")
+      assert String.contains?(expected, "integer()")
+      assert String.contains?(actual, ":ok")
     end
 
     test "return boolean() instead integer()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_integer3)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_integer3)
 
-      assert String.contains?(msg, "integer()")
-      assert String.contains?(msg, "true")
+      assert String.contains?(expected, "integer()")
+      assert String.contains?(actual, "true")
     end
 
     test "return list() instead integer()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_integer4)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_integer4)
 
-      assert String.contains?(msg, "integer()")
-      assert String.contains?(msg, "nonempty_list()")
+      assert String.contains?(expected, "integer()")
+      assert String.contains?(actual, "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)
+      [expected, actual] = format_error_to_binary(errors.ret_out_of_range_int)
 
-      assert String.contains?(msg, "range(1, 10)")
-      assert String.contains?(msg, "12")
+      assert String.contains?(expected, "1..10")
+      assert String.contains?(actual, "12")
+    end
+
+    test "return integer() instead float()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_float)
+
+      assert String.contains?(expected, "float()")
+      assert String.contains?(actual, "1")
+    end
+
+    test "return nil() instead float()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_float2)
+
+      assert String.contains?(expected, "float()")
+      assert String.contains?(actual, "nil")
+    end
+
+    test "return charlist() instead char()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_char)
+
+      assert String.contains?(expected, "char()")
+      assert String.contains?(actual, "nonempty_list()")
+    end
+
+    test "return nil() instead char()", %{wrong_ret_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_char2)
+
+      # unfortunately char is represented as {:integer, 0, _}
+      assert String.contains?(expected, "111")
+      assert String.contains?(actual, "nil")
     end
 
     test "return atom() instead boolean()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_boolean)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_boolean)
 
-      assert String.contains?(msg, "boolean()")
-      assert String.contains?(msg, ":ok")
+      assert String.contains?(expected, "boolean()")
+      assert String.contains?(actual, ":ok")
     end
 
     test "return binary() instead boolean()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_boolean2)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_boolean2)
 
-      assert String.contains?(msg, "boolean()")
-      assert String.contains?(msg, "binary()")
+      assert String.contains?(expected, "boolean()")
+      assert String.contains?(actual, "binary()")
     end
 
     test "return integer() instead boolean()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_boolean3)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_boolean3)
 
-      assert String.contains?(msg, "boolean()")
-      assert String.contains?(msg, "1")
+      assert String.contains?(expected, "boolean()")
+      assert String.contains?(actual, "1")
     end
 
     test "return keyword() instead boolean()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_boolean4)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_boolean4)
 
-      assert String.contains?(msg, "boolean()")
-      assert String.contains?(msg, "nonempty_list()")
+      assert String.contains?(expected, "boolean()")
+      assert String.contains?(actual, "nonempty_list()")
     end
 
     test "return list() instead keyword()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_keyword)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_keyword)
 
-      assert String.contains?(msg, "{atom(), any()}")
-      assert String.contains?(msg, "1")
+      assert String.contains?(expected, "{atom(), any()}")
+      assert String.contains?(actual, "1")
     end
 
     test "return tuple() instead map()", %{wrong_ret_errors: errors} do
-      msg = format_error_to_binary(errors.ret_wrong_map)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_map)
 
-      assert String.contains?(msg, "map()")
-      assert String.contains?(msg, "{:a, 1, 2}")
+      assert String.contains?(expected, "map()")
+      assert String.contains?(actual, "{: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)
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_fun)
+
+      assert String.contains?(expected, "atom()")
+      assert String.contains?(actual, "12")
+    end
 
-      assert String.contains?(msg, "atom()")
-      assert String.contains?(msg, "12")
+    test "return atom() instead record()", %{record_type_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_record)
+
+      assert String.contains?(expected, "user()")
+      assert String.contains?(actual, ":ok")
+    end
+
+    test "return wrong record value type", %{record_type_errors: errors} do
+      [expected, actual] = format_error_to_binary(errors.ret_wrong_record2)
+
+      assert String.contains?(expected, "String.t()")
+      assert String.contains?(actual, "12")
     end
   end
 
@@ -165,6 +210,26 @@ defmodule Gradient.ElixirFmtTest do
     error
     |> ElixirFmt.format_error(opts)
     |> :erlang.iolist_to_binary()
+    |> String.split("have type")
+    |> List.last()
+    |> String.split("but it has type")
+  end
+
+  @spec load_record_type_example(map()) :: map()
+  defp load_record_type_example(config) do
+    {_tokens, ast} = load("/type/Elixir.RecordEx.beam", "/type/record.ex")
+
+    {errors, forms} = type_check_file(ast, [])
+
+    names =
+      get_function_names_from_ast(forms)
+      |> Enum.drop(3)
+
+    errors_map =
+      Enum.zip(names, errors)
+      |> Map.new()
+
+    Map.put(config, :record_type_errors, errors_map)
   end
 
   @spec load_wrong_ret_error_examples(map()) :: map()