Allow encode/2 to receive opts in any order (#112)

---------

Co-authored-by: Sergey Fedorov <[email protected]>

lib/avrora/encoder.ex

@@ -105,6 +105,12 @@ defmodule Avrora.Encoder do
     end
   end
 
+  def encode(payload, schema_name: schema_name) when is_map(payload),
+    do: encode(payload, schema_name: schema_name, format: :guess)
+
+  def encode(payload, format: format, schema_name: schema_name) when is_map(payload),
+    do: encode(payload, schema_name: schema_name, format: format)
+
   @doc """
   Encode message map in Avro format, loading schema from local file or Schema Registry.
 
@@ -128,9 +134,6 @@ defmodule Avrora.Encoder do
   """
   @spec encode(map(), schema_name: String.t(), format: :guess | :registry | :ocf | :plain) ::
           {:ok, binary()} | {:error, term()}
-  def encode(payload, schema_name: schema_name) when is_map(payload),
-    do: encode(payload, schema_name: schema_name, format: :guess)
-
   def encode(payload, schema_name: schema_name, format: format) when is_map(payload) do
     with {:ok, schema_name} <- Name.parse(schema_name) do
       if format == :plain do

test/avrora/encoder_test.exs

@@ -625,6 +625,42 @@ defmodule Avrora.EncoderTest do
 
       assert encoded == messenger_plain_message()
     end
+
+    test "when `format` passed before `schema_name` option it accepts the order" do
+      messenger_schema = messenger_schema()
+
+      Avrora.Storage.MemoryMock
+      |> expect(:get, fn key ->
+        assert key == "io.confluent.Messenger"
+
+        {:ok, nil}
+      end)
+      |> expect(:put, fn key, value ->
+        assert key == "io.confluent.Messenger"
+        assert value == messenger_schema
+
+        {:ok, value}
+      end)
+
+      Avrora.Storage.RegistryMock
+      |> expect(:put, fn key, value ->
+        assert key == "io.confluent.Messenger"
+        assert value == messenger_json_schema_with_local_reference()
+
+        {:error, :unconfigured_registry_url}
+      end)
+
+      Avrora.Storage.FileMock
+      |> expect(:get, fn key ->
+        assert key == "io.confluent.Messenger"
+
+        {:ok, messenger_schema}
+      end)
+
+      {:ok, encoded} = Encoder.encode(messenger_payload(), format: :plain, schema_name: "io.confluent.Messenger")
+
+      assert encoded == messenger_plain_message()
+    end
   end
 
   describe "encode_plain/2" do