add fake tap server for testing

Makefile

···
 
 lexgen:
 	~/other.git/indigo/lexgen --build-file ./atvouch_lexicons.json ./lexicons
+
+appview-auth:
+	cd ./appview/auth && go build -o ./atvouch-auth
+
+appview:
+	cd ./appview && mix deps.get && mix compile

appview/mix.exs

···
       app: :atvouch,
       version: "0.1.0",
       elixir: "~> 1.17",
+      elixirc_paths: elixirc_paths(Mix.env()),
       start_permanent: Mix.env() == :prod,
       deps: deps()
     ]
···
       mod: {Atvouch.Application, []}
     ]
   end
+
+  defp elixirc_paths(:test), do: ["lib", "test/support"]
+  defp elixirc_paths(_), do: ["lib"]
 
   defp deps do
     [

appview/test/atvouch/tap/socket_test.exs

···
+defmodule Atvouch.Tap.SocketTest do
+  use ExUnit.Case
+
+  defmodule TestHandler do
+    @behaviour Atvouch.Tap.Handler
+
+    @impl true
+    def handle_record(event) do
+      send(:tap_socket_test, {:handle_record, event})
+      :ok
+    end
+
+    @impl true
+    def handle_identity(event) do
+      send(:tap_socket_test, {:handle_identity, event})
+      :ok
+    end
+
+    @impl true
+    def handle_connect do
+      send(:tap_socket_test, :handle_connect)
+      :ok
+    end
+  end
+
+  setup do
+    Process.register(self(), :tap_socket_test)
+    {server_pid, port} = Atvouch.Test.FakeTapServer.start(self())
+
+    on_exit(fn ->
+      try do
+        Supervisor.stop(server_pid, :normal, 1_000)
+      catch
+        :exit, _ -> :ok
+      end
+    end)
+
+    {:ok, port: port}
+  end
+
+  test "connects and receives record events", %{port: port} do
+    {:ok, _pid} =
+      Atvouch.Tap.Socket.start_link(
+        uri: "ws://localhost:#{port}/channel",
+        handler: TestHandler,
+        password: "123",
+        name: :"tap_test_#{port}"
+      )
+
+    assert_receive :handle_connect, 5_000
+    assert_receive {:ws_connected, ws_pid}, 5_000
+
+    Atvouch.Test.FakeTapServer.send_event(ws_pid, %{
+      "id" => 1,
+      "type" => "record",
+      "record" => %{
+        "did" => "did:plc:abc",
+        "rev" => "rev1",
+        "collection" => "dev.atvouch.vouch",
+        "rkey" => "self",
+        "action" => "create",
+        "live" => true
+      }
+    })
+
+    assert_receive {:handle_record, event}, 5_000
+    assert event.id == 1
+    assert event.action == :create
+    assert event.did == "did:plc:abc"
+    assert event.collection == "dev.atvouch.vouch"
+    assert event.live == true
+
+    # auto-ack
+    assert_receive {:ws_message, %{"type" => "ack", "id" => 1}}, 5_000
+  end
+
+  test "connects and receives identity events", %{port: port} do
+    {:ok, _pid} =
+      Atvouch.Tap.Socket.start_link(
+        uri: "ws://localhost:#{port}/channel",
+        handler: TestHandler,
+        password: "123",
+        name: :"tap_test_identity_#{port}"
+      )
+
+    assert_receive :handle_connect, 5_000
+    assert_receive {:ws_connected, ws_pid}, 5_000
+
+    Atvouch.Test.FakeTapServer.send_event(ws_pid, %{
+      "id" => 2,
+      "type" => "identity",
+      "identity" => %{
+        "did" => "did:plc:xyz",
+        "handle" => "test.bsky.social",
+        "is_active" => true,
+        "status" => "active"
+      }
+    })
+
+    assert_receive {:handle_identity, event}, 5_000
+    assert event.id == 2
+    assert event.did == "did:plc:xyz"
+    assert event.handle == "test.bsky.social"
+    assert event.is_active == true
+    assert event.status == "active"
+
+    assert_receive {:ws_message, %{"type" => "ack", "id" => 2}}, 5_000
+  end
+end

appview/test/support/fake_tap_server.ex

···
+defmodule Atvouch.Test.FakeTapServer do
+  @moduledoc false
+
+  defmodule WebSocketHandler do
+    @behaviour WebSock
+
+    @impl true
+    def init(state) do
+      send(state.test_pid, {:ws_connected, self()})
+      {:ok, state}
+    end
+
+    @impl true
+    def handle_in({text, opcode: :text}, state) do
+      case Jason.decode(text) do
+        {:ok, msg} ->
+          send(state.test_pid, {:ws_message, msg})
+
+        _ ->
+          :ok
+      end
+
+      {:ok, state}
+    end
+
+    @impl true
+    def handle_info({:send_event, event}, state) do
+      {:push, {:text, Jason.encode!(event)}, state}
+    end
+
+    def handle_info(_msg, state) do
+      {:ok, state}
+    end
+
+    @impl true
+    def terminate(_reason, _state) do
+      :ok
+    end
+  end
+
+  defmodule Router do
+    use Plug.Router
+
+    plug(:match)
+    plug(:dispatch)
+
+    get "/channel" do
+      test_pid = conn.private[:test_pid]
+
+      conn
+      |> upgrade_adapter(:websocket, {WebSocketHandler, %{test_pid: test_pid}, []})
+    end
+
+    match _ do
+      send_resp(conn, 404, "not found")
+    end
+  end
+
+  defmodule PlugWithPid do
+    @behaviour Plug
+
+    def init(opts), do: opts
+
+    def call(conn, opts) do
+      conn
+      |> Plug.Conn.put_private(:test_pid, opts[:test_pid])
+      |> Router.call(Router.init([]))
+    end
+  end
+
+  def start(test_pid) do
+    {:ok, server_pid} =
+      Bandit.start_link(
+        plug: {PlugWithPid, test_pid: test_pid},
+        port: 0,
+        ip: {127, 0, 0, 1}
+      )
+
+    {:ok, {_ip, port}} = ThousandIsland.listener_info(server_pid)
+    {server_pid, port}
+  end
+
+  def send_event(ws_pid, event) do
+    send(ws_pid, {:send_event, event})
+  end
+end