hostas/test/hostas_web/controllers/denizen_controller_test.exs

defmodule HostasWeb.Auth.DenizenControllerTest do
  use HostasWeb.ConnCase

  # For testing with Ecto
  import Ecto.Query, only: [from: 2]
  alias Hostas.Repo

  alias Hostas.Denizen
  alias Hostas.Token

  @denizen %{
    "handle" => "test",
    "name" => "Test Denizen",
    "password" => "password",
  }

  setup_all %{conn: conn} do
    denizen1 = %Denizen{}
      |> Denizen.changeset(%{handle: "denizen1", name: "Test Denizen 1", password: "password"})
      |> Repo.insert!

    denizen1 = Denizen.create(%{handle: "denizen1", name: "Test Denizen 1", password: "password"})
    denizen2 = Denizen.create(%{handle: "denizen2", name: "Test Denizen 2", password: "password"})

    {:ok, token} = Token.new(denizen1.id)

    # Facilitate requests to protected routes
    conn = put_req_header(conn, "authorization", "Bearer #{struct.token}")

    %{denizen1: denizen1, denizen2: denizen2, token: token, conn: conn}
  end

  describe "register denizen" do
    test "succeeds", %{conn: conn} do
      conn = post(conn, ~p"/hostapi/denizen/", @denizen)

      assert json_response(conn, 201)["handle"] == @denizen["handle"]
      assert json_response(conn, 201)["name"] == @denizen["name"]
      assert json_response(conn, 201)["id"] == @denizen["id"]
    end

    test "fails because duplicate handle", %{conn: conn, denizen1: pre_existing_denizen} do
      pre_existing_handle = pre_existing_denizen["handle"]
      conn = post(
        conn,
        ~p"/hostapi/denizen/",
        Map.put(@denizen, "handle", pre_existing_handle)
      )

      assert json_response(conn, 422)["error"] ==
        "Denizen with handle #{pre_existing_handle} already exists"
    end
  end

  describe "show denizen" do
    test "succeeds", %{conn: conn, denizen1: denizen} do
      %{handle: handle} = denizen
      conn = get(conn, ~p"/hostapi/denizen/#{handle}")
      assert json_response(conn, 200) == Map.delete(denizen, :password)
    end

    test "fails because handle is unknown", %{conn: conn} do
      conn = get(conn, ~p"/hostapi/denizen/unknown_denizen")
      assert json_response(conn, 404)["error"] == "No denizen corresponding to given handle"
    end
  end

  describe "deactivate denizen" do
    test "returns 201 when done by same denizen", %{conn: conn, denizen1: denizen} do
      %{handle: handle} = denizen
      conn = delete(conn, ~p"/hostapi/denizen/#{handle}")
      assert json_response(conn, 201)
    end

    test "succeeds", %{conn: conn, denizen1: denizen} do
      %{handle: handle} = denizen
      conn = delete(conn, ~p"/hostapi/denizen/#{handle}")
      assert json_response(conn, 201)
    end

    test "fails because denizens can't deactivate one another", %{conn: conn, denizen2: denizen2} do
      conn = delete(conn, ~p"/hostapi/denizen/#{denizen2.handle}")
      assert json_response(conn, 403)["error"] == "Regular denizens cannot deactivate other denizens"
    end

    test "fails because referenced denizen doesn't exist", %{conn: conn, denizen1: denizen} do
      conn = delete(conn, ~p"/hostapi/denizen/unknown_denizen")
      assert json_response(conn, 403)["error"] == "Regular denizens cannot deactivate other denizens"
    end
  end

  describe "update denizen" do
    test "succeeds", %{conn: conn, denizen1: denizen} do
      update = Map.put(denizen, :name, "Updated Name")
      conn = patch(conn, ~p"/hostapi/denizen/#{denizen.handle}", update)

      assert json_response(conn, 200) == update
    end

    test "fails because denizen can't modify someone else's account", %{conn: conn, denizen2: denizen2} do
      conn = patch(conn, ~p"/hostapi/denizen/#{denizen.handle}", %{})
      assert json_response(conn, 403)["error"] == "Regular denizens cannot update other denizens"
    end

    test "fails because denizen doesn't exist", %{conn: conn} do
      conn = patch(conn, ~p"/hostapi/denizen/unknown_denizen", %{})
      assert json_response(conn, 403)["error"] == "Regular denizens cannot update other denizens"
    end
  end
end