Apply minor refactoring (#122)

* Handle error code 42201 in Registry storage
* Reorganize Plain codec in-test fixtures
* Return error on undefined reference lookup fun
* Update wording in tests

Author: Strech

lib/avrora/schema/encoder.ex

@@ -48,7 +48,7 @@ defmodule Avrora.Schema.Encoder do
   An example of a reference lookup which returns empty JSON body
   """
   @spec reference_lookup(String.t()) :: {:ok, String.t()} | {:error, term()}
-  def reference_lookup(_), do: {:ok, ~s({})}
+  def reference_lookup(_), do: {:error, :undefined_reference_lookup_function}
 
   @doc """
   Convert `erlavro` format to the Schema struct.
@@ -160,6 +160,7 @@ defmodule Avrora.Schema.Encoder do
   defp do_parse(payload) do
     {:ok, :avro_json_decoder.decode_schema(payload, allow_bad_references: true)}
   rescue
+    _ in FunctionClauseError -> {:error, :invalid_schema}
     error in ArgumentError -> {:error, error.message}
     error in ErlangError -> {:error, error.original}
   end

lib/avrora/storage/registry.ex

@@ -168,6 +168,7 @@ defmodule Avrora.Storage.Registry do
         40401 -> :unknown_subject
         40402 -> :unknown_version
         40403 -> :unknown_schema
+        42201 -> :invalid_schema
         409 -> :conflict
         422 -> :unprocessable
         _ -> payload

test/avrora/codec/plain_test.exs

@@ -60,7 +60,7 @@ defmodule Avrora.Codec.PlainTest do
       Avrora.Storage.RegistryMock
       |> expect(:put, fn key, value ->
         assert key == "io.acme.Payment"
-        assert value == payment_json_schema()
+        assert value == payment_json()
 
         {:error, :unconfigured_registry_url}
       end)
@@ -80,13 +80,13 @@ defmodule Avrora.Codec.PlainTest do
     test "when payload is a valid binary and null values must be as is" do
       stub(Avrora.ConfigMock, :convert_null_values, fn -> false end)
 
-      {:ok, decoded} = Codec.Plain.decode(null_value_message(), schema: null_value_schema())
+      {:ok, decoded} = Codec.Plain.decode(null_value_message(), schema: record_with_null_union_field_schema())
 
       assert decoded == %{"key" => "user-1", "value" => :null}
     end
 
     test "when payload is a valid binary and null values must be converted" do
-      {:ok, decoded} = Codec.Plain.decode(null_value_message(), schema: null_value_schema())
+      {:ok, decoded} = Codec.Plain.decode(null_value_message(), schema: record_with_null_union_field_schema())
 
       assert decoded == %{"key" => "user-1", "value" => nil}
     end
@@ -114,8 +114,8 @@ defmodule Avrora.Codec.PlainTest do
     end
 
     test "when payload is valid binary and union type must be decoded without decoding hook" do
-      {:ok, decoded_int} = Codec.Plain.decode(<<2, 84>>, schema: union_schema())
-      {:ok, decoded_str} = Codec.Plain.decode(<<0, 4, 52, 50>>, schema: union_schema())
+      {:ok, decoded_int} = Codec.Plain.decode(<<2, 84>>, schema: record_with_record_union_field_schema())
+      {:ok, decoded_str} = Codec.Plain.decode(<<0, 4, 52, 50>>, schema: record_with_record_union_field_schema())
 
       assert decoded_int == %{"union_field" => %{"value" => 42}}
       assert decoded_str == %{"union_field" => %{"value" => "42"}}
@@ -129,8 +129,8 @@ defmodule Avrora.Codec.PlainTest do
         end
       end)
 
-      {:ok, decoded_int} = Codec.Plain.decode(<<2, 84>>, schema: union_schema())
-      {:ok, decoded_str} = Codec.Plain.decode(<<0, 4, 52, 50>>, schema: union_schema())
+      {:ok, decoded_int} = Codec.Plain.decode(<<2, 84>>, schema: record_with_record_union_field_schema())
+      {:ok, decoded_str} = Codec.Plain.decode(<<0, 4, 52, 50>>, schema: record_with_record_union_field_schema())
 
       assert decoded_int == %{"union_field" => {"io.acme.as_int", %{"value" => 42}}}
       assert decoded_str == %{"union_field" => {"io.acme.as_str", %{"value" => "42"}}}
@@ -171,7 +171,7 @@ defmodule Avrora.Codec.PlainTest do
       Avrora.Storage.RegistryMock
       |> expect(:put, fn key, value ->
         assert key == "io.acme.Payment"
-        assert value == payment_json_schema()
+        assert value == payment_json()
 
         {:error, :unconfigured_registry_url}
       end)
@@ -207,7 +207,7 @@ defmodule Avrora.Codec.PlainTest do
       Avrora.Storage.RegistryMock
       |> expect(:put, fn key, value ->
         assert key == "io.acme.CardType"
-        assert value == enum_json_schema()
+        assert value == enum_json()
 
         {:error, :unconfigured_registry_url}
       end)
@@ -243,7 +243,7 @@ defmodule Avrora.Codec.PlainTest do
       Avrora.Storage.RegistryMock
       |> expect(:put, fn key, value ->
         assert key == "io.acme.CRC32"
-        assert value == fixed_json_schema()
+        assert value == fixed_json()
 
         {:error, :unconfigured_registry_url}
       end)
@@ -277,56 +277,56 @@ defmodule Avrora.Codec.PlainTest do
   defp payment_payload, do: %{"id" => "00000000-0000-0000-0000-000000000000", "amount" => 15.99}
 
   defp payment_schema do
-    {:ok, schema} = Schema.Encoder.from_json(payment_json_schema())
+    {:ok, schema} = Schema.Encoder.from_json(payment_json())
     %{schema | id: nil, version: nil}
   end
 
-  defp null_value_schema do
-    {:ok, schema} = Schema.Encoder.from_json(null_value_json_schema())
+  defp record_with_null_union_field_schema do
+    {:ok, schema} = Schema.Encoder.from_json(record_with_null_union_field_json())
+    %{schema | id: nil, version: nil}
+  end
+
+  defp record_with_record_union_field_schema do
+    {:ok, schema} = Schema.Encoder.from_json(record_with_record_union_field_json())
     %{schema | id: nil, version: nil}
   end
 
   defp map_schema do
-    {:ok, schema} = Schema.Encoder.from_json(map_json_schema())
+    {:ok, schema} = Schema.Encoder.from_json(record_with_map_field_json())
     %{schema | id: nil, version: nil}
   end
 
   defp enum_schema do
-    {:ok, schema} = Schema.Encoder.from_json(enum_json_schema())
+    {:ok, schema} = Schema.Encoder.from_json(enum_json())
     %{schema | id: nil, version: nil}
   end
 
   defp fixed_schema do
-    {:ok, schema} = Schema.Encoder.from_json(fixed_json_schema())
+    {:ok, schema} = Schema.Encoder.from_json(fixed_json())
     %{schema | id: nil, version: nil}
   end
 
-  defp union_schema do
-    {:ok, schema} = Schema.Encoder.from_json(union_json_schema())
-    %{schema | id: nil, version: nil}
+  defp payment_json do
+    ~s({"namespace":"io.acme","name":"Payment","type":"record","fields":[{"name":"id","type":"string"},{"name":"amount","type":"double"}]})
   end
 
-  defp payment_json_schema do
-    ~s({"namespace":"io.acme","name":"Payment","type":"record","fields":[{"name":"id","type":"string"},{"name":"amount","type":"double"}]})
+  defp record_with_null_union_field_json do
+    ~s({"namespace":"io.acme","name":"NullValue","type":"record","fields":[{"name":"key","type":"string"},{"name":"value","type":["null","int"]}]})
   end
 
-  defp null_value_json_schema do
-    ~s({"namespace":"io.acme","name":"Null_Value","type":"record","fields":[{"name":"key","type":"string"},{"name":"value","type":["null","int"]}]})
+  defp record_with_record_union_field_json do
+    ~s({"namespace":"io.acme","name":"UnionValue","type":"record","fields":[{"name":"union_field","type":[{"type":"record","name":"as_str","fields":[{"name":"value","type":"string"}]},{"type":"record","name":"as_int","fields":[{"name":"value","type":"int"}]}]}]})
   end
 
-  defp map_json_schema do
-    ~s({"namespace":"io.acme","name":"Map_Value","type":"record","fields":[{"name":"map_field", "type": {"type": "map", "values": "string"}}]})
+  defp record_with_map_field_json do
+    ~s({"namespace":"io.acme","name":"MapValue","type":"record","fields":[{"name":"map_field", "type": {"type": "map", "values": "string"}}]})
   end
 
-  defp enum_json_schema do
+  defp enum_json do
     ~s({"namespace":"io.acme","name":"CardType","type":"enum","symbols":["MASTERCARD","VISA","AMERICANEXPRESS"]})
   end
 
-  defp fixed_json_schema do
+  defp fixed_json do
     ~s({"namespace":"io.acme","name":"CRC32","type":"fixed","size":8})
   end
-
-  defp union_json_schema do
-    ~s({"namespace":"io.acme","name":"Union_Value","type":"record","fields":[{"name":"union_field","type":[{"type":"record","name":"as_str","fields":[{"name":"value","type":"string"}]},{"type":"record","name":"as_int","fields":[{"name":"value","type":"int"}]}]}]})
-  end
 end

test/avrora/schema/encoder_test.exs

@@ -13,54 +13,66 @@ defmodule Avrora.Schema.EncoderTest do
       {:ok, {type, _, _, _, _, fields, full_name, _}} = Schema.Encoder.to_erlavro(schema)
 
       assert type == :avro_record_type
-      assert full_name == "io.confluent.Payment"
+      assert full_name == "io.acme.Payment"
       assert length(fields) == 2
 
-      assert schema.full_name == "io.confluent.Payment"
+      assert schema.full_name == "io.acme.Payment"
       assert schema.json == payment_json()
     end
 
-    test "when payload is a valid Enum schema" do
+    test "when schema is Enum type" do
       {:ok, schema} = Schema.Encoder.from_json(card_type_json())
       {:ok, {type, _, _, _, _, fields, full_name, _}} = Schema.Encoder.to_erlavro(schema)
 
       assert type == :avro_enum_type
-      assert full_name == "io.confluent.CardType"
+      assert full_name == "io.acme.CardType"
       assert length(fields) == 3
 
-      assert schema.full_name == "io.confluent.CardType"
+      assert schema.full_name == "io.acme.CardType"
       assert schema.json == card_type_json()
     end
 
-    test "when payload is a valid Fixed schema" do
+    test "when payload is Fixed type" do
       {:ok, schema} = Schema.Encoder.from_json(crc32_json())
       {:ok, {type, _, _, _, value, full_name, _}} = Schema.Encoder.to_erlavro(schema)
 
       assert type == :avro_fixed_type
-      assert full_name == "io.confluent.CRC32"
+      assert full_name == "io.acme.CRC32"
       assert value == 8
 
-      assert schema.full_name == "io.confluent.CRC32"
+      assert schema.full_name == "io.acme.CRC32"
       assert schema.json == crc32_json()
     end
 
-    test "when payload is a valid json schema with external reference and callback returns valid schema" do
+    test "when schema is Record type with primitive fields types" do
+      {:ok, schema} = Schema.Encoder.from_json(payment_json())
+      {:ok, {type, _, _, _, _, fields, full_name, _}} = Schema.Encoder.to_erlavro(schema)
+
+      assert type == :avro_record_type
+      assert full_name == "io.acme.Payment"
+      assert length(fields) == 2
+
+      assert schema.full_name == "io.acme.Payment"
+      assert schema.json == payment_json()
+    end
+
+    test "when schema is Record type with nested type ref" do
       {:ok, schema} =
         Schema.Encoder.from_json(message_with_reference_json(), fn name ->
           case name do
-            "io.confluent.Attachment" -> {:ok, attachment_json()}
-            "io.confluent.Signature" -> {:ok, signature_json()}
+            "io.acme.Signature" -> {:ok, signature_json()}
+            "io.acme.Attachment" -> {:ok, attachment_json()}
             _ -> raise "unknown reference name!"
           end
         end)
 
       {:ok, {type, _, _, _, _, fields, full_name, _}} = Schema.Encoder.to_erlavro(schema)
 
       assert type == :avro_record_type
-      assert full_name == "io.confluent.Message"
+      assert full_name == "io.acme.Message"
       assert length(fields) == 2
 
-      assert schema.full_name == "io.confluent.Message"
+      assert schema.full_name == "io.acme.Message"
       assert schema.json == message_json()
 
       {:avro_record_field, _, _, body_type, _, _, _} = List.first(fields)
@@ -70,48 +82,46 @@ defmodule Avrora.Schema.EncoderTest do
       {:avro_array_type, {type, _, _, _, _, fields, full_name, _}, []} = attachments_type
 
       assert type == :avro_record_type
-      assert full_name == "io.confluent.Attachment"
+      assert full_name == "io.acme.Attachment"
       assert length(fields) == 2
 
       {:avro_record_field, _, _, signature_type, _, _, _} = List.last(fields)
       {type, _, _, _, _, fields, full_name, _} = signature_type
 
       assert type == :avro_record_type
-      assert full_name == "io.confluent.Signature"
+      assert full_name == "io.acme.Signature"
       assert length(fields) == 1
     end
 
-    test "when payload is a valid json schema with external reference and callback returns invalid schema" do
+    test "when schema is Record type with type ref of invalid schema" do
       result =
         Schema.Encoder.from_json(message_with_reference_json(), fn name ->
-          assert name == "io.confluent.Attachment"
+          assert name == "io.acme.Attachment"
           {:ok, ~s({})}
         end)
 
       assert {:error, {:not_found, "type"}} == result
     end
 
-    test "when payload is a valid json schema with external reference and callback returns error" do
+    test "when schema is Record type with type ref and resolution failed" do
       result =
         Schema.Encoder.from_json(message_with_reference_json(), fn name ->
-          assert name == "io.confluent.Attachment"
+          assert name == "io.acme.Attachment"
           {:error, :bad_thing_happen}
         end)
 
       assert {:error, :bad_thing_happen} == result
     end
 
-    test "when payload is a valid json schema with external reference and no callback is given" do
-      assert {:error, {:not_found, "type"}} == Schema.Encoder.from_json(message_with_reference_json())
-    end
-
-    test "when payload is not a named type schema" do
-      assert Schema.Encoder.from_json(unnamed_json()) == {:error, :unnamed_type}
+    test "when schema is Record type with type ref and lookup function given" do
+      assert {:error, :undefined_reference_lookup_function} ==
+               Schema.Encoder.from_json(message_with_reference_json())
     end
 
-    test "when payload is an invalid json schema" do
+    test "when schema is an invalid" do
       assert Schema.Encoder.from_json("a:b") == {:error, "argument error"}
       assert Schema.Encoder.from_json("{}") == {:error, {:not_found, "type"}}
+      assert Schema.Encoder.from_json("[null]") == {:error, :invalid_schema}
     end
   end
 
@@ -121,7 +131,7 @@ defmodule Avrora.Schema.EncoderTest do
       {:ok, {type, _, _, _, _, fields, full_name, _}} = Schema.Encoder.to_erlavro(schema)
 
       assert type == :avro_record_type
-      assert full_name == "io.confluent.Payment"
+      assert full_name == "io.acme.Payment"
       assert length(fields) == 2
     end
   end
@@ -133,7 +143,7 @@ defmodule Avrora.Schema.EncoderTest do
       assert is_nil(schema.id)
       assert is_nil(schema.version)
 
-      assert schema.full_name == "io.confluent.Payment"
+      assert schema.full_name == "io.acme.Payment"
       assert schema.json == payment_json()
     end
 
@@ -143,7 +153,7 @@ defmodule Avrora.Schema.EncoderTest do
       assert is_nil(schema.id)
       assert is_nil(schema.version)
 
-      assert schema.full_name == "io.confluent.Payment"
+      assert schema.full_name == "io.acme.Payment"
       assert schema.json == "{}"
     end
 
@@ -153,38 +163,37 @@ defmodule Avrora.Schema.EncoderTest do
   end
 
   defp payment_erlavro do
-    {:avro_record_type, "Payment", "io.confluent", "", [],
+    {:avro_record_type, "Payment", "io.acme", "", [],
      [
        {:avro_record_field, "id", "", {:avro_primitive_type, "string", []}, :undefined, :ascending, []},
        {:avro_record_field, "amount", "", {:avro_primitive_type, "double", []}, :undefined, :ascending, []}
-     ], "io.confluent.Payment", []}
+     ], "io.acme.Payment", []}
   end
 
   defp unnamed_erlavro, do: {:avro_array_type, {:avro_primitive_type, "string", []}, []}
-  defp unnamed_json, do: ~s({"type":"array","items":"string","default":[]})
-  defp crc32_json, do: ~s({"namespace":"io.confluent","name":"CRC32","type":"fixed","size":8})
+  defp crc32_json, do: ~s({"namespace":"io.acme","name":"CRC32","type":"fixed","size":8})
 
   defp signature_json do
-    ~s({"namespace":"io.confluent","name":"Signature","type":"record","fields":[{"name":"checksum","type":{"name":"SignatureChecksum","type":"fixed","size":1048576}}]})
+    ~s({"namespace":"io.acme","name":"Signature","type":"record","fields":[{"name":"checksum","type":{"name":"SignatureChecksum","type":"fixed","size":1048576}}]})
   end
 
   defp attachment_json do
-    ~s({"namespace":"io.confluent","name":"Attachment","type":"record","fields":[{"name":"name","type":"string"},{"name":"signature","type":"io.confluent.Signature"}]})
+    ~s({"namespace":"io.acme","name":"Attachment","type":"record","fields":[{"name":"name","type":"string"},{"name":"signature","type":"io.acme.Signature"}]})
   end
 
   defp payment_json do
-    ~s({"namespace":"io.confluent","name":"Payment","type":"record","fields":[{"name":"id","type":"string"},{"name":"amount","type":"double"}]})
+    ~s({"namespace":"io.acme","name":"Payment","type":"record","fields":[{"name":"id","type":"string"},{"name":"amount","type":"double"}]})
   end
 
   defp card_type_json do
-    ~s({"namespace":"io.confluent","name":"CardType","type":"enum","symbols":["MASTERCARD","VISA","AMERICANEXPRESS"]})
+    ~s({"namespace":"io.acme","name":"CardType","type":"enum","symbols":["MASTERCARD","VISA","AMERICANEXPRESS"]})
   end
 
   defp message_with_reference_json do
-    ~s({"namespace":"io.confluent","name":"Message","type":"record","fields":[{"name":"body","type":"string"},{"name":"attachments","type":{"type":"array","items":"io.confluent.Attachment"}}]})
+    ~s({"namespace":"io.acme","name":"Message","type":"record","fields":[{"name":"body","type":"string"},{"name":"attachments","type":{"type":"array","items":"io.acme.Attachment"}}]})
   end
 
   defp message_json do
-    ~s({"namespace":"io.confluent","name":"Message","type":"record","fields":[{"name":"body","type":"string"},{"name":"attachments","type":{"type":"array","items":{"name":"Attachment","type":"record","fields":[{"name":"name","type":"string"},{"name":"signature","type":{"name":"Signature","type":"record","fields":[{"name":"checksum","type":{"name":"SignatureChecksum","type":"fixed","size":1048576}}]}}]}}}]})
+    ~s({"namespace":"io.acme","name":"Message","type":"record","fields":[{"name":"body","type":"string"},{"name":"attachments","type":{"type":"array","items":{"name":"Attachment","type":"record","fields":[{"name":"name","type":"string"},{"name":"signature","type":{"name":"Signature","type":"record","fields":[{"name":"checksum","type":{"name":"SignatureChecksum","type":"fixed","size":1048576}}]}}]}}}]})
   end
 end