Fix test cases

.formatter.exs

@@ -0,0 +1,3 @@
+[
+ inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

README.md

@@ -4,8 +4,8 @@
 
 **NOTE**: If you are upgrading from 1.0, be aware that the autoclustering functionality has been extracted
 to its own package, which you will need to depend on if you use that feature.
-The package is [libcluster](https://github.com/bitwalker/libcluster) and is available on 
-[Hex](https://hex.pm/packages/libcluster). Please be sure to read over the README to make sure your 
+The package is [libcluster](https://github.com/bitwalker/libcluster) and is available on
+[Hex](https://hex.pm/packages/libcluster). Please be sure to read over the README to make sure your
 config is properly updated.
 
 Swarm is a global distributed registry, offering a feature set similar to that of `gproc`,
@@ -324,6 +324,18 @@ end
 
 MIT
 
+## Testing
+
+`mix test` runs a variety of tests, most of them use a cluster of
+Elixir nodes to test the tracker and the registry. If you want more
+verbose output during the tests, run them like this:
+
+ # SWARM_DEBUG=true mix test
+
+This sets the log level to `:debug`, runs ExUnit with `--trace`, and
+enables GenServer tracing on the Tracker processes.
+
+
 ## TODO
 
 - automated testing (some are present)

config/config.exs

@@ -3,7 +3,7 @@ use Mix.Config
 config :swarm,
  nodes: [:"[email protected]", :"[email protected]"],
  sync_nodes_timeout: 0,
- debug: false,
+ anti_entropy_interval: 5_000,
  node_blacklist: [
  # the following blacklists nodes set up by exrm/relx/distillery
  # for remote shells (the first) and hot upgrade scripting (the second)
@@ -18,8 +18,12 @@ config :swarm,
  # the same type of list as node_blacklist
  ]
 
-config :logger,
- level: :info
+config :logger, level: :warn
+
+if System.get_env("SWARM_DEBUG") == "true" do
+ config :swarm, debug: true
+ config :logger, level: :debug
+end
 
 config :porcelain,
  goon_warn_if_missing: false

lib/swarm.ex

@@ -47,17 +47,21 @@ defmodule Swarm do
  The default value is `:infinity` to block indefinitely.
  """
  @spec register_name(term, atom(), atom(), [term]) :: {:ok, pid} | {:error, term}
- @spec register_name(term, atom(), atom(), [term], non_neg_integer() | :infinity) :: {:ok, pid} | {:error, term}
+ @spec register_name(term, atom(), atom(), [term], non_neg_integer() | :infinity) ::
+ {:ok, pid} | {:error, term}
  def register_name(name, m, f, a, timeout \\ :infinity)
  def register_name(name, m, f, a, timeout), do: Swarm.Registry.register(name, m, f, a, timeout)
 
  @doc """
  Either finds the named process in the swarm or registers it using the register function.
  """
  @spec whereis_or_register_name(term, atom(), atom(), [term]) :: {:ok, pid} | {:error, term}
- @spec whereis_or_register_name(term, atom(), atom(), [term], non_neg_integer() | :infinity) :: {:ok, pid} | {:error, term}
+ @spec whereis_or_register_name(term, atom(), atom(), [term], non_neg_integer() | :infinity) ::
+ {:ok, pid} | {:error, term}
  def whereis_or_register_name(name, m, f, a, timeout \\ :infinity)
- def whereis_or_register_name(name, m, f, a, timeout), do: Swarm.Registry.whereis_or_register(name, m, f, a, timeout)
+
+ def whereis_or_register_name(name, m, f, a, timeout),
+ do: Swarm.Registry.whereis_or_register(name, m, f, a, timeout)
 
  @doc """
  Unregisters the given name from the registry.

lib/swarm/app.ex

@@ -10,8 +10,9 @@ defmodule Swarm.App do
  children = [
  supervisor(Task.Supervisor, [[name: Swarm.TaskSupervisor]]),
  worker(Swarm.Registry, []),
- worker(Swarm.Tracker, []),
+ worker(Swarm.Tracker, [])
  ]
+
  supervise(children, strategy: :one_for_one)
  end
 end

lib/swarm/distribution/ring.ex

@@ -2,10 +2,10 @@ defmodule Swarm.Distribution.Ring do
  @moduledoc false
  use Swarm.Distribution.Strategy
 
- def create(),  do: HashRing.new()
- def add_node(ring, node),  do: HashRing.add_node(ring, node)
+ def create(), do: HashRing.new()
+ def add_node(ring, node), do: HashRing.add_node(ring, node)
  def add_node(ring, node, weight), do: HashRing.add_node(ring, node, weight)
- def add_nodes(ring, nodes),  do: HashRing.add_nodes(ring, nodes)
- def remove_node(ring, node),  do: HashRing.remove_node(ring, node)
- def key_to_node(ring, key),  do: HashRing.key_to_node(ring, key)
+ def add_nodes(ring, nodes), do: HashRing.add_nodes(ring, nodes)
+ def remove_node(ring, node), do: HashRing.remove_node(ring, node)
+ def key_to_node(ring, key), do: HashRing.key_to_node(ring, key)
 end

lib/swarm/distribution/static_quorum_ring.ex

@@ -57,32 +57,24 @@ defmodule Swarm.Distribution.StaticQuorumRing do
  def create do
  %StaticQuorumRing{
  static_quorum_size: static_quorum_size(),
- ring: HashRing.new(),
+ ring: HashRing.new()
  }
  end
 
  def add_node(quorum, node) do
- %StaticQuorumRing{quorum |
- ring: HashRing.add_node(quorum.ring, node),
- }
+ %StaticQuorumRing{quorum | ring: HashRing.add_node(quorum.ring, node)}
  end
 
  def add_node(quorum, node, weight) do
- %StaticQuorumRing{quorum |
- ring: HashRing.add_node(quorum.ring, node, weight),
- }
+ %StaticQuorumRing{quorum | ring: HashRing.add_node(quorum.ring, node, weight)}
  end
 
  def add_nodes(quorum, nodes) do
- %StaticQuorumRing{quorum |
- ring: HashRing.add_nodes(quorum.ring, nodes),
- }
+ %StaticQuorumRing{quorum | ring: HashRing.add_nodes(quorum.ring, nodes)}
  end
 
  def remove_node(quorum, node) do
- %StaticQuorumRing{quorum |
- ring: HashRing.remove_node(quorum.ring, node),
- }
+ %StaticQuorumRing{quorum | ring: HashRing.remove_node(quorum.ring, node)}
  end
 
  @doc """
@@ -103,14 +95,18 @@ defmodule Swarm.Distribution.StaticQuorumRing do
  end
 
  defp static_quorum_size(nil), do: static_quorum_size(2)
+
  defp static_quorum_size(binary) when is_binary(binary) do
  binary
  |> Integer.parse()
  |> convert_to_integer()
  |> static_quorum_size()
  end
+
  defp static_quorum_size(size) when is_integer(size) and size > 0, do: size
- defp static_quorum_size(_size), do: raise "config :static_quorum_size should be a positive integer"
+
+ defp static_quorum_size(_size),
+ do: raise("config :static_quorum_size should be a positive integer")
 
  defp convert_to_integer({integer, _}) when is_integer(integer), do: integer
  defp convert_to_integer(other), do: other

lib/swarm/distribution/strategy.ex

@@ -21,7 +21,7 @@ defmodule Swarm.Distribution.Strategy do
  end
  end
 
- @type reason :: String.t
+ @type reason :: String.t()
  @type strategy :: term
  @type weight :: pos_integer
  @type nodelist :: [node() | {node(), weight}]

lib/swarm/logger.ex

@@ -5,24 +5,24 @@ defmodule Swarm.Logger do
  @doc """
  Log a debugging message
  """
- @spec debug(String.t) :: :ok
- def debug(message), do: Logger.debug("[swarm on #{Node.self}] #{message}")
+ @spec debug(String.t()) :: :ok
+ def debug(message), do: Logger.debug("[swarm on #{Node.self()}] #{message}")
 
  @doc """
  Log a warning message
  """
- @spec warn(String.t) :: :ok
- def warn(message),  do: Logger.warn("[swarm on #{Node.self}] #{message}")
+ @spec warn(String.t()) :: :ok
+ def warn(message), do: Logger.warn("[swarm on #{Node.self()}] #{message}")
 
  @doc """
  Log an info message
  """
- @spec info(String.t) :: :ok
- def info(message), do: Logger.info("[swarm on #{Node.self}] #{message}")
+ @spec info(String.t()) :: :ok
+ def info(message), do: Logger.info("[swarm on #{Node.self()}] #{message}")
 
  @doc """
  Log an error message
  """
- @spec error(String.t) :: :ok
- def error(message), do: Logger.error("[swarm on #{Node.self}] #{message}")
+ @spec error(String.t()) :: :ok
+ def error(message), do: Logger.error("[swarm on #{Node.self()}] #{message}")
 end