Phoenix 애플리케이션 통합 테스트

Test Web App Interactions

Simulating HTTP Requests

defmodule MyPhoenixAppWeb.ExampleTest do
  use ExUnit.Case, async: true
  import Phoenix.ConnTest

  # Assume a simple router route: get "/hello", PageController, :hello
  # and PageController.hello renders a page with "Hello World"
  test "can get a simple page" do
    # Simulate a GET request to /hello
    conn = get("/hello")

    # Assert the HTTP status code
    assert conn.status == 200

    # Assert the response body contains "Hello World"
    assert html_response(conn, 200) =~ "Hello World"
  end
end

Testing GET Requests

defmodule MyPhoenixAppWeb.PostControllerTest do
  use ExUnit.Case, async: true
  import Phoenix.ConnTest

  # Assume we have a router route: get "/posts", PostController, :index
  # And PostController.index renders a list of posts including "My First Post"
  test "lists all posts on GET /posts" do
    # Simulate a request to the /posts endpoint
    conn = get("/posts")

    # Assert that the request was successful and contains expected content
    assert conn.status == 200
    assert html_response(conn, 200) =~ "<h1>All Posts</h1>"
    assert html_response(conn, 200) =~ "My First Post"
  end
end

Testing POST Requests

defmodule MyPhoenixAppWeb.PostControllerTest do
  use ExUnit.Case, async: true
  import Phoenix.ConnTest

  # Assume we have a router route: post "/posts", PostController, :create
  # This action creates a post and redirects to the index page.
  test "creates a new post on POST /posts" do
    post_params = %{"post" => %{"title" => "New Post", "body" => "Content"}}

    # Simulate a POST request with parameters
    conn = post("/posts", post_params)

    # Assert that a redirect occurred to the posts index
    assert redirected_to(conn) == "/posts"
  end
end

Asserting Rendered Content

defmodule MyPhoenixAppWeb.PageControllerTest do
  use ExUnit.Case, async: true
  import Phoenix.ConnTest

  # Assume get "/dashboard" renders a page with user information
  test "renders dashboard with user info" do
    # For this example, we simulate a simple GET (no session handling here)
    conn = get("/dashboard")

    assert conn.status == 200
    response_html = html_response(conn, 200)

    # Check for specific elements in the rendered HTML
    assert response_html =~ "<title>Dashboard</title>"
    assert response_html =~ "<span>Welcome, John Doe!</span>"
    assert response_html =~ ~r/Last Login: \d{4}-\d{2}-\d{2}/ # Regex for dynamic date
  end
end

Testing Redirects and Errors

defmodule MyPhoenixAppWeb.AuthControllerTest do
  use ExUnit.Case, async: true
  import Phoenix.ConnTest

  # Assume post "/login" redirects to /dashboard on success
  test "redirects after successful login" do
    login_params = %{"email" => "test@example.com", "password" => "password"}
    conn = post("/login", login_params)
    assert redirected_to(conn) == "/dashboard"
  end

  # Assume post "/register" sends a 400 error for invalid data
  test "sends 400 error for invalid registration" do
    invalid_params = %{"email" => "bad", "password" => "short"}
    conn = post("/register", invalid_params)
    assert conn.status == 400
    assert json_response(conn, 400) == %{"errors" => %{"email" => ["is invalid"]}}
  end
end

Simulating User Sessions

defmodule MyPhoenixAppWeb.SessionControllerTest do
  use ExUnit.Case, async: true
  import Phoenix.ConnTest

  # Assume get "/profile" requires a user_id in the session
  test "accesses profile with session data" do
    # Build a connection and add a user_id to its session
    conn = 
      build_conn()
      |> put_session(:user_id, 123)
      |> get("/profile")

    assert conn.status == 200
    assert html_response(conn, 200) =~ "User Profile for ID: 123"
  end

  test "redirects unauthenticated users" do
    # No session data means no authenticated user
    conn = get("/profile")
    assert redirected_to(conn) == "/login"
  end
end

Channel Testing Introduction

Connecting to a Channel

defmodule MyPhoenixAppWeb.ChatChannelTest do
  use ExUnit.Case, async: true
  use Phoenix.ChannelTest

  # Assume MyPhoenixAppWeb.UserSocket is your main WebSocket module
  # and it handles joining a "room:lobby" channel.
  test "can join the lobby channel" do
    # Simulate a client connecting and joining "room:lobby" with no params
    {:ok, _pid, socket} = subscribe_and_join(MyPhoenixAppWeb.UserSocket, "room:lobby", %{})

    # Assert that the socket is connected to the correct topic
    assert socket.topic == "room:lobby"

    # You might also assert on assigns set during the join process
    # assert socket.assigns.user_id # If user_id is assigned on join
  end
end

Sending & Receiving Channel Messages

defmodule MyPhoenixAppWeb.ChatChannelTest do
  use ExUnit.Case, async: true
  use Phoenix.ChannelTest

  # Assume MyPhoenixAppWeb.UserSocket handles "new_msg" events on "room:lobby"
  test "broadcasts messages to the lobby" do
    {:ok, _pid, socket} = subscribe_and_join(MyPhoenixAppWeb.UserSocket, "room:lobby", %{})

    # Simulate pushing a message from the client
    ref = push(socket, "new_msg", %{"body" => "Hello everyone!"})

    # Assert that the server replied 'ok' to the push
    assert_reply ref, :ok

    # Assert that a message was broadcasted back to the topic
    assert_broadcast "new_msg", %{"body" => "Hello everyone!"}
  end
end

Quick Check

Recap: Integrated Confidence