DiscordBlog

defmodule Guild do
  use GenServer

  def execute_in_worker(worker_code, after_worker_callback, state) do
    mini_state = create_state_for_worker(state)
    main_process = self()
    spawn_link(fn ->
      result = worker_code.(mini_state)
      send(main_process, {:worker_completed, after_worker_callback, result})
    end)

DiscordBlog

defmodule Discord.Test do
    use ExUnit.Case
    
    describe "send_message/1" do
        test "errors on invalid messages" do
            # TODO
        end
        
        test "errors when message can't be durably stored" do
            # TODO

DiscordBlog

defmodule Discord do
    def send_message(%Message{} = message) do
        with :ok <- validate_message(message),
             :ok <- save_message(message) do
          broadcast_message(message)
        end
    end
    
    defp validate_message(message) do
        with :ok <- validate_author_is_member(message),

DiscordBlog

assert {:bad, :error} == Discord.send_message(%Message{})

# We start at the Facade
Discord.send_message(%Message{}) {
  # The Facade calls the Delegate
  Delegate.send_message(message) {
    # The Delegate checks if the Server has a patch for send_message/1
    Server.delegate(Discord, :send_message, [message]) {
      # The Server doesn't, so it calls the Original
      Original.send_message(message) {

DiscordBlog

~/src/discord > mix test

...

3 tests, 0 failures

DiscordBlog

defmodule Discord.Test do
  use ExUnit.Case
  use Patch

  describe "send_message/1" do
    test "errors on invalid messages" do
      patch(Discord, :validate_message, {:error, :bad})
      assert {:error, :bad} == Discord.send_message(%Message{})
    end
  end

DiscordBlog

defmodule Patch.Mock.Original.For.Discord do
  alias Patch.Mock.Delegate.For.Discord, as: Delegate
  
  def send_message(%Message{} = message) do
    with :ok <- Delegate.validate_message(message),
         :ok <- Delegate.save_message(message) do
      Delegate.broadcast_message(message)
    end
  end
  

DiscordBlog

def delegate(module, name, arguments) do
  server = Naming.server(module)
  
  case GenServer.call(server, {:delegate, name, arguments}) do
    {:ok, reply} ->
      reply
      
    :error ->
      original = Naming.original(module)
      apply(original, name, arguments)

DiscordBlog

defmodule Patch.Mock.Delegate.For.Discord do
  alias Patch.Mock.Server

  def send_message(%Message{} = message) do
    Server.delegate(Discord, :send_message, [message])
  end
  
  def validate_message(message) do
    Server.delegate(Discord, :validate_message, [message])
  end

DiscordBlog

defmodule Discord do
  alias Patch.Mock.Delegate.For.Discord, as: Delegate
  
  def send_message(%Message{} = message) do
    Delegate.send_message(message)
  end
end