Include tests around nested selections

Author: keathley

lib/norm.ex

@@ -512,7 +512,8 @@ defmodule Norm do
   in the selection are still considered optional. Selections, like schemas,
   are open and allow unspecied keys to be passed through. If no selectors are
   provided then `selection` defaults to `:all` and recursively marks all keys in
-  all schema's as required.
+  all nested schema's. If the schema includes internal selections these selections
+  will not be overwritten.
 
   ## Examples
 

lib/norm/spec/selection.ex

@@ -51,21 +51,28 @@ defmodule Norm.Spec.Selection do
   defp validate_selectors!([_key | rest]), do: validate_selectors!(rest)
   defp validate_selectors!(other), do: raise ArgumentError, "select expects a list of keys but received: #{inspect other}"
 
-  defp assert_spec!(schema, key) do
+  defp assert_spec!(%Schema{}=schema, key) do
     case Schema.spec(schema, key) do
       nil -> raise SpecError, {:selection, key, schema}
       spec -> spec
     end
   end
+  defp assert_spec!(%__MODULE__{}, _key) do
+    # In the future we might support this and allow users to overwrite internal
+    # selections. But for now its safer to forbid this.
+    raise ArgumentError, """
+    Attempting to specify a selection on top of another selection is
+    not allowed.
+    """
+  end
+  defp assert_spec!(other, _key) do
+    raise ArgumentError, "Expected a schema and got: #{inspect other}"
+  end
 
   defimpl Norm.Conformer.Conformable do
     alias Norm.Conformer
     alias Norm.Conformer.Conformable
 
-    # def conform(_, input, path) when not is_map(input) do
-    #   {:error, [Conformer.error(path, input, "not a map")]}
-    # end
-
     def conform(%{required: required, schema: schema}, input, path) do
       with {:ok, conformed} <- Conformable.conform(schema, input, path) do
         errors = ensure_keys(required, conformed, path, [])

test/norm/selection_test.exs

@@ -37,6 +37,25 @@ defmodule Norm.SelectionTest do
       assert errors == [%{spec: ":required", input: %{fauxuser: %{age: 31}}, path: [:user]}]
     end
 
+    test "works with nested selections"  do
+      user_with_name = schema(%{user: selection(user_schema(), [:name])})
+      input = %{name: "chris"}
+      assert %{user: input} == conform!(%{user: input}, selection(user_with_name))
+
+      assert_raise ArgumentError, fn ->
+        user = schema(%{name: spec(is_binary()), age: spec(is_integer())})
+        required_user = selection(user)
+        selection(schema(%{user: required_user}), [user: [:name]])
+      end
+    end
+
+    test "returns an error if a non map input is given" do
+      assert {:error, errors} = conform(123, selection(user_schema()))
+      assert errors == [
+        %{input: 123, path: [], spec: "not a map"}
+      ]
+    end
+
     test "if no keys are selected all keys are enforced recursively" do
       assert valid?(@input, selection(user_schema()))
       refute valid?(%{}, selection(user_schema()))