Add validation type to NimbleOptions.ValidationError

lib/nimble_options.ex

@@ -601,8 +601,8 @@ defmodule NimbleOptions do
     end
   end
 
-  defp validate_type(:integer, key, value, redact) when not is_integer(value) do
-    structured_error_tuple(key, value, "integer", redact)
+  defp validate_type(:integer = type, key, value, redact) when not is_integer(value) do
+    structured_error_tuple(key, value, {:type, type}, "integer", redact)
   end
 
   defp validate_type(:non_neg_integer, key, value, redact)
@@ -1019,19 +1019,31 @@ defmodule NimbleOptions do
     {:error, %ValidationError{key: key, message: message, redact: redact, value: value}}
   end
 
+  # FIX: remove after error types are implemented
   defp structured_error_tuple(key, value, expected, redact?) do
-    structured_error_tuple(key, value, expected, inspect(value), redact?)
+    structured_error_tuple(key, value, false, expected, redact?)
   end
 
-  defp structured_error_tuple(key, value, expected, got, redact?) do
+  defp structured_error_tuple(key, value, type, expected, redact?) do
+    structured_error_tuple(key, value, type, expected, inspect(value), redact?)
+  end
+
+  defp structured_error_tuple(key, value, validation, expected, got, redact?) do
     message =
       if redact? do
         "invalid value for #{render_key(key)}: expected #{expected}"
       else
         "invalid value for #{render_key(key)}: expected #{expected}, got: #{got}"
       end
 
-    {:error, %ValidationError{key: key, message: message, redact: redact?, value: value}}
+    {:error,
+     %ValidationError{
+       key: key,
+       message: message,
+       redact: redact?,
+       value: value,
+       validation: validation
+     }}
   end
 
   defp render_key({__MODULE__, :key}), do: "map key"

lib/nimble_options/validation_error.ex

@@ -12,6 +12,7 @@ defmodule NimbleOptions.ValidationError do
           key: atom(),
           keys_path: [atom()],
           redact: boolean,
+          validation: :required | {:type, term()},
           value: term()
         }
 
@@ -28,8 +29,10 @@ defmodule NimbleOptions.ValidationError do
     * `:value` (`t:term/0`) - The value that failed to validate. This field is `nil` if there
       was no value provided.
 
+    * `:validation` (`:required` or `{:type, type}`) - The validation that failed.
+
   """
-  defexception [:message, :key, :value, keys_path: [], redact: false]
+  defexception [:message, :key, :validation, :value, keys_path: [], redact: false]
 
   @impl true
   def message(%__MODULE__{message: message, keys_path: keys_path}) do

test/nimble_options_test.exs

@@ -133,7 +133,7 @@
              }
     end
 
     test "is redacted" do
       schema = [
         processors: [
           type: :keyword_list,
@@ -264,7 +264,7 @@
                 }}
     end
 
     test "redacted invalid positive integer" do
       schema = [stages: [type: :pos_integer, redact: true]]
 
       assert NimbleOptions.validate([stages: 0], schema) ==
@@ -292,6 +292,7 @@
                 %ValidationError{
                   key: :min_demand,
                   value: 1.5,
+                  validation: {:type, :integer},
                   message: "invalid value for :min_demand option: expected integer, got: 1.5"
                 }}
 
@@ -300,6 +301,7 @@
                 %ValidationError{
                   key: :min_demand,
                   value: :an_atom,
+                  validation: {:type, :integer},
                   message: "invalid value for :min_demand option: expected integer, got: :an_atom"
                 }}
     end
@@ -312,6 +314,7 @@
                 %ValidationError{
                   key: :min_demand,
                   value: 1.5,
+                  validation: {:type, :integer},
                   message: "invalid value for :min_demand option: expected integer",
                   redact: true
                 }}
@@ -324,7 +327,7 @@
       assert NimbleOptions.validate(opts, schema) == {:ok, opts}
     end
 
     test "invalid non negative integer" do
       schema = [min_demand: [type: :non_neg_integer]]
 
       assert NimbleOptions.validate([min_demand: -1], schema) ==
@@ -346,7 +349,7 @@
                 }}
     end
 
     test "redacted invalid non negative integer" do
       schema = [min_demand: [type: :non_neg_integer, redact: true]]
 
       assert NimbleOptions.validate([min_demand: -1], schema) ==
@@ -386,7 +389,7 @@
                 }}
     end
 
     test "redacted invalid float" do
       schema = [certainty: [type: :float, redact: true]]
 
       assert NimbleOptions.validate([certainty: 1], schema) ==
@@ -495,7 +498,7 @@
       assert NimbleOptions.validate(opts, schema) == {:ok, opts}
     end
 
     test "invalid timeout" do
       schema = [timeout: [type: :timeout]]
 
       opts = [timeout: -1]
@@ -574,7 +577,7 @@
       assert NimbleOptions.validate(opts, schema) == {:ok, opts}
     end
 
     test "invalid reference" do
       schema = [name: [type: :reference]]
 
       assert NimbleOptions.validate([name: 1], schema) ==
@@ -586,7 +589,7 @@
                 }}
     end
 
     test "redacted invalid reference" do
       schema = [name: [type: :reference, redact: true]]
 
       assert NimbleOptions.validate([name: 1], schema) ==
@@ -609,7 +612,7 @@
       assert NimbleOptions.validate(opts, schema) == {:ok, opts}
     end
 
     test "invalid mfa" do
       schema = [transformer: [type: :mfa]]
 
       opts = [transformer: {"not_a_module", :func, []}]
@@ -742,7 +745,7 @@
       assert NimbleOptions.validate(opts, schema) == {:ok, opts}
     end
 
     test "invalid {:fun, arity}" do
       schema = [partition_by: [type: {:fun, 1}]]
 
       opts = [partition_by: :not_a_fun]
@@ -770,7 +773,7 @@
              }
     end
 
     test "redacted invalid {:fun, arity}" do
       schema = [partition_by: [type: {:fun, 1}, redact: true]]
 
       opts = [partition_by: :not_a_fun]
@@ -819,7 +822,7 @@
                 }}
     end
 
     test "redacted invalid nil" do
       schema = [name: [type: nil, required: true, redact: true]]
       opts = [name: :not_nil]
 
@@ -1760,7 +1763,7 @@
       )
     end
 
     test "redacted invalid {:struct, struct_name}" do
       schema = [struct: [type: {:struct, URI}, redact: true]]
 
       opts = [struct: %NimbleOptions{}]
@@ -1905,7 +1908,7 @@
     end
 
     for type <- [:keyword_list, :map] do
       test "nested options types for #{type}" do
         schema = [
           processors: [
             type: unquote(type),
@@ -2218,7 +2221,7 @@
 
   describe "nested options show up in error messages" do
     for type <- [:keyword_list, :map] do
       test "for options that we validate for #{type}" do
         schema = [
           socket_options: [
             type: unquote(type),
@@ -2250,7 +2253,7 @@
   end
 
   # No other test is passing in `opts` as a map, so these are just some white box tests for sanity checking
-  describe "can use a map for validate/2" do
+  test "can use a map for validate/2" do
     schema = []
     opts = %{}
     assert NimbleOptions.validate(opts, schema) == {:ok, %{}}