chore: docs and rename test client

config/config.exs

@@ -1,6 +1,6 @@
 import Config
 
-config :klife, Klife.MyClient,
+config :klife, MyTestClient,
   connection: [
     bootstrap_servers: ["localhost:19092", "localhost:29092"],
     # bootstrap_servers: ["localhost:19093", "localhost:29093"],
@@ -82,7 +82,8 @@ config :klife, Klife.MyClient,
     ],
     [
       name: "test_async_topic"
-    ]
+    ],
+    [name: "my_topic"]
   ]
 
 if config_env() == :dev do

lib/klife/application.ex

@@ -24,7 +24,7 @@ defmodule Klife.Application do
 
   defp handle_clients() do
     [
-      Klife.MyClient
+      MyTestClient
     ]
   end
 

lib/klife/client.ex

@@ -62,7 +62,7 @@ defmodule Klife.Client do
   When used it expects an `:otp_app` option that is the OTP application that has the client configuration.
 
   ```elixir
-  defmodule MyApp.MyClient do
+  defmodule MyApp.MyTestClient do
     use Klife.Client, otp_app: :my_app
   end
   ```
@@ -73,8 +73,8 @@ defmodule Klife.Client do
   >
   > - Define it as a proxy to a subset of the functions on `Klife` module,
   > using it's module's name as the `client_name` parameter.
-  > One example of this is the `MyClient.produce/2` that forwards
-  > both arguments to `Klife.produce/3` and inject `MyClient` as the
+  > One example of this is the `MyTestClient.produce/2` that forwards
+  > both arguments to `Klife.produce/3` and inject `MyTestClient` as the
   > second argument.
   >
   > - Define it as a supervisor by calling `use Supervisor` and implementing
@@ -123,7 +123,7 @@ defmodule Klife.Client do
     def start(_type, _args) do
       children = [
         # some other modules...,
-        MyApp.MyClient
+        MyApp.MyTestClient
       ]
 
       opts = [strategy: :one_for_one, name: MyApp.Supervisor]
@@ -160,7 +160,7 @@ defmodule Klife.Client do
 
   ```elixir
   rec = %Klife.Record{value: "some_val", topic: "my_topic"}
-  {:ok, %Klife.Record{offset: offset, partition: partition}} = MyClient.produce(rec)
+  {:ok, %Klife.Record{offset: offset, partition: partition}} = MyTestClient.produce(rec)
   ```
 
   """
@@ -180,7 +180,7 @@ defmodule Klife.Client do
   ## Examples
 
     iex> rec = %Klife.Record{value: "my_val", topic: "my_topic"}
-    iex> {:ok, %Klife.Record{} = enriched_rec} = MyClient.produce(rec)
+    iex> {:ok, %Klife.Record{} = enriched_rec} = MyTestClient.produce(rec)
     iex> true = is_number(enriched_rec.offset)
     iex> true = is_number(enriched_rec.partition)
 

lib/klife/connection/controller.ex

@@ -191,7 +191,7 @@ defmodule Klife.Connection.Controller do
     :persistent_term.put({:known_brokers_ids, state.client_name}, new_brokers)
 
     if to_start != [] or to_remove != [] do
-      PubSub.publish({:client_change, state.client_name}, %{
+      PubSub.publish({:cluster_change, state.client_name}, %{
         added_brokers: to_start,
         removed_brokers: to_remove
       })

lib/klife/producer/controller.ex

@@ -70,13 +70,13 @@ defmodule Klife.Producer.Controller do
 
     Utils.wait_connection!(client_name)
 
-    :ok = PubSub.subscribe({:client_change, client_name})
+    :ok = PubSub.subscribe({:cluster_change, client_name})
 
     {:ok, state}
   end
 
   def handle_info(
-        {{:client_change, client_name}, _event_data, _callback_data},
+        {{:cluster_change, client_name}, _event_data, _callback_data},
         %__MODULE__{client_name: client_name} = state
       ) do
     Process.cancel_timer(state.check_metadata_timer_ref)

lib/klife/utils.ex

@@ -26,7 +26,7 @@ defmodule Klife.Utils do
   # the topic are created, thats why we need to create a connection from
   # scratch here. Must solve it later.
   def create_topics!() do
-    client_opts = Application.fetch_env!(:klife, Klife.MyClient)
+    client_opts = Application.fetch_env!(:klife, MyTestClient)
 
     conn_defaults =
       Klife.Connection.Controller.get_opts()

lib/mix/tasks/benchmark.ex

@@ -113,9 +113,9 @@ if Mix.env() in [:dev] do
             rec1 = Enum.random(records_1)
             rec2 = Enum.random(records_2)
 
-            t0 = Task.async(fn -> Klife.MyClient.produce(rec0) end)
-            t1 = Task.async(fn -> Klife.MyClient.produce(rec1) end)
-            t2 = Task.async(fn -> Klife.MyClient.produce(rec2) end)
+            t0 = Task.async(fn -> MyTestClient.produce(rec0) end)
+            t1 = Task.async(fn -> MyTestClient.produce(rec1) end)
+            t2 = Task.async(fn -> MyTestClient.produce(rec2) end)
 
             [{:ok, _}, {:ok, _}, {:ok, _}] = Task.await_many([t0, t1, t2])
           end,
@@ -211,14 +211,14 @@ if Mix.env() in [:dev] do
             rec1 = Enum.random(records_1)
             rec2 = Enum.random(records_2)
 
-            [{:ok, _}, {:ok, _}, {:ok, _}] = Klife.MyClient.produce_batch([rec0, rec1, rec2])
+            [{:ok, _}, {:ok, _}, {:ok, _}] = MyTestClient.produce_batch([rec0, rec1, rec2])
           end,
           "produce_batch_txn" => fn ->
             rec0 = Enum.random(records_0)
             rec1 = Enum.random(records_1)
             rec2 = Enum.random(records_2)
 
-            {:ok, [_rec1, _rec2, _rec3]} = Klife.MyClient.produce_batch_txn([rec0, rec1, rec2])
+            {:ok, [_rec1, _rec2, _rec3]} = MyTestClient.produce_batch_txn([rec0, rec1, rec2])
           end
         },
         time: 15,
@@ -245,13 +245,13 @@ if Mix.env() in [:dev] do
       Benchee.run(
         %{
           "klife" => fn ->
-            {:ok, _rec} = Klife.MyClient.produce(Enum.random(records_0))
+            {:ok, _rec} = MyTestClient.produce(Enum.random(records_0))
           end,
           "klife multi inflight" => fn ->
-            {:ok, _rec} = Klife.MyClient.produce(Enum.random(in_flight_records))
+            {:ok, _rec} = MyTestClient.produce(Enum.random(in_flight_records))
           end,
           "klife multi inflight linger" => fn ->
-            {:ok, _rec} = Klife.MyClient.produce(Enum.random(in_flight_linger_records))
+            {:ok, _rec} = MyTestClient.produce(Enum.random(in_flight_linger_records))
           end
         },
         time: 15,
@@ -290,7 +290,7 @@ if Mix.env() in [:dev] do
         Enum.map(tasks_recs_to_send, fn recs ->
           Task.async(fn ->
             Enum.map(recs, fn rec ->
-              {:ok, _rec} = Klife.MyClient.produce(rec)
+              {:ok, _rec} = MyTestClient.produce(rec)
             end)
           end)
         end)

mix.exs

@@ -41,7 +41,7 @@ defmodule Klife.MixProject do
   defp groups_for_docs(group), do: {String.to_atom(group), &(&1[:group] == group)}
 
   defp elixirc_paths(:test), do: ["lib", "test/support"]
-  defp elixirc_paths(:dev), do: ["lib"]
+  defp elixirc_paths(:dev), do: ["lib", "test/support"]
   defp elixirc_paths(_), do: ["lib"]
 
   # Run "mix help deps" to learn about dependencies.

test/client_test.exs

@@ -0,0 +1,4 @@
+defmodule Klife.ClientTest do
+  use ExUnit.Case
+  doctest Klife.Client
+end

test/connection/system_test.exs

@@ -138,8 +138,8 @@ defmodule Klife.Connection.SystemTest do
     Enum.each(brokers_list_3, &check_broker_connection(client_name_3, &1))
   end
 
-  @tag client_change: true, capture_log: true
-  test "client changes events" do
+  @tag cluster_change: true, capture_log: true
+  test "cluster changes events" do
     config = [
       connection: [
         bootstrap_servers: ["localhost:19092", "localhost:29092"],
@@ -152,13 +152,13 @@ defmodule Klife.Connection.SystemTest do
       ]
     ]
 
-    Application.put_env(:klife, __MODULE__.MyClientTest, config)
+    Application.put_env(:klife, __MODULE__.MyOtherClient, config)
 
-    defmodule MyClientTest do
+    defmodule MyOtherClient do
       use Klife.Client, otp_app: :klife
     end
 
-    client_name = __MODULE__.MyClientTest
+    client_name = __MODULE__.MyOtherClient
 
     assert {:ok, _pid} = start_supervised(client_name)
 
@@ -168,20 +168,20 @@ defmodule Klife.Connection.SystemTest do
     broker_id_to_remove = List.first(brokers)
     cb_ref = make_ref()
 
-    :ok = PubSub.subscribe({:client_change, client_name}, %{some_data: cb_ref})
+    :ok = PubSub.subscribe({:cluster_change, client_name}, %{some_data: cb_ref})
 
     {:ok, service_name} = TestUtils.stop_broker(client_name, broker_id_to_remove)
 
-    assert_received({{:client_change, ^client_name}, event_data, %{some_data: ^cb_ref}})
+    assert_received({{:cluster_change, ^client_name}, event_data, %{some_data: ^cb_ref}})
     assert broker_id_to_remove in Enum.map(event_data.removed_brokers, fn {b, _h} -> b end)
     assert broker_id_to_remove not in :persistent_term.get({:known_brokers_ids, client_name})
 
     {:ok, broker_id} = TestUtils.start_broker(service_name, client_name)
 
-    assert_received({{:client_change, ^client_name}, event_data, %{some_data: ^cb_ref}})
+    assert_received({{:cluster_change, ^client_name}, event_data, %{some_data: ^cb_ref}})
     assert broker_id in Enum.map(event_data.added_brokers, fn {b, _h} -> b end)
     assert broker_id in :persistent_term.get({:known_brokers_ids, client_name})
 
-    :ok = PubSub.unsubscribe({:client_change, client_name})
+    :ok = PubSub.unsubscribe({:cluster_change, client_name})
   end
 end