LiveView Testing

register_live_test.ex

defmodule PetalProWeb.RegisterLiveTest do
  use PetalProWeb.ConnCase, async: true
  alias PetalProWeb.RegisterLive
  import Phoenix.LiveViewTest

  test "can register an account", %{conn: conn} do
    {:ok, view, html} = live(conn, Routes.live_path(conn, RegisterLive))

    assert html =~ "Register"

    assert view
    |> form("#email-form", user: %{email: "matt@petal.build"})
    |> render_submit() =~ "Password"

    assert view
    |> form("#user-details-form", user: %{name: "Matt", password: "password"})
    |> render_submit() =~ "Please check your email"
  end

  test "it fails when email is not valid", %{conn: conn} do
    {:ok, view, _html} = live(conn, Routes.live_path(conn, RegisterLive))

    assert view
    |> form("#email-form", user: %{email: "kfjwlkef"})
    |> render_submit() =~ "is not a valid email"
  end

  test "it fails when password is not valid", %{conn: conn} do
    {:ok, view, _html} = live(conn, Routes.live_path(conn, RegisterLive))

    view
    |> form("#email-form", user: %{email: "matt@petal.build"})
    |> render_submit()

    view
    |> form("#user-details-form", user: %{password: ""})
    |> render_submit() =~ "be blank"

    view
    |> form("#user-details-form", user: %{password: "1"})
    |> render_submit() =~ "be at least"
  end
end

sign_in_live_test.ex

defmodule PetalProWeb.SignInLiveTest do
  use PetalProWeb.ConnCase, async: true
  alias PetalProWeb.SignInLive
  import Phoenix.LiveViewTest
  import PetalPro.AccountsFixtures

  @create_attrs %{name: "Matt", email: "matt@petal.build", password: "password"}

  defp create_user(_) do
    user = user_fixture(@create_attrs)
    %{user: user}
  end

  describe "sign in" do
    setup [:create_user]

    test "it signs you in successfully", %{conn: conn} do
      {:ok, view, _html} = live(conn, Routes.live_path(conn, SignInLive))

      form =
        form(view, "#sign-in-form",
          user: %{
            email: @create_attrs.email,
            password: @create_attrs.password
          }
        )

      assert render_submit(form) =~ ~r/phx-trigger-action/

      token =
        DB.last(PetalPro.Accounts.User)
        |> PetalPro.Accounts.generate_user_session_token()
        |> Base.encode64()

      sign_in_token_form = form(view, "#sign-in-token-form", user: %{base64_token: token})
      conn = follow_trigger_action(sign_in_token_form, conn)
      assert conn.method == "POST"
      assert redirected_to(conn) == "/"
    end
  end

  test "sign in with remember me selected will set a cookie", %{conn: conn} do
    {:ok, view, _html} = live(conn, Routes.live_path(conn, SignInLive))

    form =
      form(view, "#sign-in-form",
        user: %{
          email: @create_attrs.email,
          password: @create_attrs.password,
          remember_me: true
        }
      )

    assert render_submit(form) =~ ~r/remember_me/

    token =
      DB.last(PetalPro.Accounts.User)
      |> PetalPro.Accounts.generate_user_session_token()
      |> Base.encode64()

    sign_in_token_form = form(view, "#sign-in-token-form", user: %{base64_token: token})
    conn = follow_trigger_action(sign_in_token_form, conn)
    assert conn.method == "POST"
    assert redirected_to(conn) == "/"
  end

  test "sign in fails when the wrong details are entered", %{conn: conn} do
    {:ok, view, _html} = live(conn, Routes.live_path(conn, SignInLive))

    assert view
           |> form("#sign-in-form",
             user: %{
               email: "",
               password: ""
             }
           )
           |> render_submit() =~ "Invalid"

    assert view
    |> form("#sign-in-form",
      user: %{
        email: @create_attrs.email,
        password: ""
      }
    )
    |> render_submit() =~ "Invalid"

    assert view
    |> form("#sign-in-form",
      user: %{
        email: @create_attrs.email,
        password: "2small"
      }
    )
    |> render_submit() =~ "Invalid"
  end
end

user_live_test.ex

defmodule AppWeb.UserLiveTest do
  use AppWeb.ConnCase

  import Phoenix.LiveViewTest
  import App.AccountsFixtures

  @create_attrs %{age: 42, name: "some name"}
  @update_attrs %{age: 43, name: "some updated name"}
  @invalid_attrs %{age: nil, name: nil}

  defp create_user(_) do
    user = user_fixture()
    %{user: user}
  end

  describe "Index" do
    setup [:create_user]

    test "lists all users", %{conn: conn, user: user} do
      {:ok, _index_live, html} = live(conn, Routes.user_index_path(conn, :index))

      assert html =~ "Listing Users"
      assert html =~ user.name
    end

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

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

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

      assert index_live
             |> form("#user-form", user: @invalid_attrs)
             |> render_change() =~ "can't be blank"

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

      assert html =~ "User created successfully"
      assert html =~ "some name"
    end

    test "updates user in listing", %{conn: conn, user: user} do
      {:ok, index_live, _html} = live(conn, Routes.user_index_path(conn, :index))

      assert index_live |> element("#user-#{user.id} a", "Edit") |> render_click() =~
               "Edit User"

      assert_patch(index_live, Routes.user_index_path(conn, :edit, user))

      assert index_live
             |> form("#user-form", user: @invalid_attrs)
             |> render_change() =~ "can't be blank"

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

      assert html =~ "User updated successfully"
      assert html =~ "some updated name"
    end

    test "deletes user in listing", %{conn: conn, user: user} do
      {:ok, index_live, _html} = live(conn, Routes.user_index_path(conn, :index))

      assert index_live |> element("#user-#{user.id} a", "Delete") |> render_click()
      refute has_element?(index_live, "#user-#{user.id}")
    end
  end

  describe "Show" do
    setup [:create_user]

    test "displays user", %{conn: conn, user: user} do
      {:ok, _show_live, html} = live(conn, Routes.user_show_path(conn, :show, user))

      assert html =~ "Show User"
      assert html =~ user.name
    end

    test "updates user within modal", %{conn: conn, user: user} do
      {:ok, show_live, _html} = live(conn, Routes.user_show_path(conn, :show, user))

      assert show_live |> element("a", "Edit") |> render_click() =~
               "Edit User"

      assert_patch(show_live, Routes.user_show_path(conn, :edit, user))

      assert show_live
             |> form("#user-form", user: @invalid_attrs)
             |> render_change() =~ "can't be blank"

      {:ok, _, html} =
        show_live
        |> form("#user-form", user: @update_attrs)
        |> render_submit()
        |> follow_redirect(conn, Routes.user_show_path(conn, :show, user))

      assert html =~ "User updated successfully"
      assert html =~ "some updated name"
    end
  end
end