Testing that a message is broadcasted to PubSub

baezanat

Hello! I need to test that a Liveview broadcasts a message to a PubSub topic after a redirect. Anybody knows how I could go about testing whether a message is broadcasted? Thanks so much!

2 comments

/phoenix #testing #pubsub #liveview #test

0 1816 2

2021-04-15 08:00:24 UTC

First Post!

Show Best Posts
Show All (oldest first)
Show All (newest first)

CinderellaMan

Hello

I’m possibly misunderstanding the complexity but what I normally do is that I inject things like modules dynamically dependent on the environment. For example, the code which uses the PubSub module to broadcast message to the topic, instead of the hardcoded PubSub module would have something like:

@pubsub_client Application.get_env(:naive, :pubsub_client)

and use it to broadcast:

@pubsub_client.broadcast(
  :ignore,
  topic,
  data
)

Option 2:

You could subscribe to the topic to figure out have you received the expected message back.

Option 3:

The broadcast function could be passed as an argument

I hope that helps somehow

Post #1

Last Post!

baezanat

Thank you for your answer! So, the problem with option 2 is that the name of the topic is built with a unique session_id that I plugged into the session.

  @doc """
  Assign unique session_id to socket
  """
  def assign_session_id(socket, %{"session_id" => session_id}) do
    assign_new(socket, :session_id, fn -> session_id end)
  end

  @doc """
  Returns a unique string per session to be used for alerts messages
  """
  def alerts_topic_id(socket), do: "alerts-#{socket.assigns.session_id}"

  @doc """
  Send a notification message to the unique pubsub topic for the current session
  """
  def send_notification(socket, type, message) do
    topic = alerts_topic_id(socket)
    PubSub.broadcast(TrainingCardBuilder.PubSub, topic, {type, message})
  end

When I mount the liveview I store it into a socket assign and then retrieve it from there to broadcast a message. So in order to subscribe to the topic from my test, I would need to have the session_id assigns, but I don’t think we can access the assigns in a test, right?

To explain things better: my LV does something and, if successful, broadcasts a message to the topic (unique for each session) saying that the action was successful.

  defp save_exercise(socket, :edit, exercise_params) do
    case Exercise.Update.call(socket.assigns.exercise, exercise_params) do
      {:ok, _exercise} ->
        send_notification(socket, :info, gettext("Exercise updated successfully"))
        :timer.sleep(10)

        {:noreply,
         socket
         |> push_redirect(to: socket.assigns.return_to)}

      {:error, %Ecto.Changeset{} = changeset} ->
        {:noreply, assign(socket, :changeset, changeset)}
    end
  end

The message is then used by another LV, whose template is located in root, which issues a notification.

  def mount(_params, session, socket) do
    subscribe_to_alarms_topic(session)

    socket =
      socket
      |> assign(:info, nil)
      |> assign(:error, nil)

    {:ok, socket}
  end

  defp subscribe_to_alarms_topic(session) do
    topic = alerts_topic_id(session)
    PubSub.subscribe(TrainingCardBuilder.PubSub, topic)
  end

  @impl true
  def handle_info({:info, message}, socket) do
    send(self(), :schedule_clear_message)

    {:noreply, assign(socket, info: message)}
  end

  @impl true
  def handle_info({:error, message}, socket) do
    send(self(), :schedule_clear_message)

    {:noreply, assign(socket, error: message)}
  end

I want to test my initial LV, the one that does the action and then broadcasts a message. The problem is that, after the broadcast, there is a redirect, after which the LV is remounted. In my test, currently, I follow the redirect and then test for the html that the notifications LV in the root layout should insert upon receiving the message. But my test fails, presumably because right when the LV is mounted, the html isn’t yet included.

    test "saves new exercise", %{conn: conn} do
      {:ok, index_live, _html} = live(conn, Routes.exercise_index_path(conn, :index))

      assert index_live |> element("a", "New") |> render_click() =~
               "New Exercise"

      assert_patch(index_live, Routes.exercise_index_path(conn, :new))

      assert index_live
             |> form("#exercise-form", exercise: @invalid_attrs)
             |> render_change() =~ "can&apos;t be blank"

      {:ok, _, html} =
        index_live
        |> form("#exercise-form", exercise: @create_attrs)
        |> render_submit()
        |> follow_redirect(conn, Routes.exercise_index_path(conn, :index))

      assert html =~ "Exercise created successfully"
    end

That last line fails, even though I correctly see the notification displayed… Presumably, as I said, because the redirect and the notification are asynchronous. So, I thought I should test just if my LV issues the message correctly before redirect, but I don’t know how to do it…

Another interesting thing about this case is that I had to add :timer.sleep(10) just after the message is broadcasted and before the LV redirects (see code snipet again below); otherwise, the notification would not be displayed after the redirect.

  defp save_exercise(socket, :edit, exercise_params) do
    case Exercise.Update.call(socket.assigns.exercise, exercise_params) do
      {:ok, _exercise} ->
        send_notification(socket, :info, gettext("Exercise updated successfully"))
        :timer.sleep(10)

        {:noreply,
         socket
         |> push_redirect(to: socket.assigns.return_to)}

      {:error, %Ecto.Changeset{} = changeset} ->
        {:noreply, assign(socket, :changeset, changeset)}
    end
  end

Post #2