refactor: upgrade guardian controller to 1.7

lib/bokken_web/controllers/admin/guardian_controller.ex

@@ -1,5 +1,5 @@
 defmodule BokkenWeb.Admin.GuardianController do
-  use BokkenWeb, controller: "1.6"
+  use BokkenWeb, :controller
 
   alias Bokken.Accounts
   alias Bokken.Accounts.Guardian
@@ -8,7 +8,7 @@ defmodule BokkenWeb.Admin.GuardianController do
 
   def index(conn, _params) do
     guardians = Accounts.list_guardians([:user])
-    render(conn, "index.json", guardians: guardians)
+    render(conn, :index, guardians: guardians)
   end
 
   def update(conn, %{"id" => id, "guardian" => guardian_params, "user" => user_params})
@@ -17,7 +17,7 @@ defmodule BokkenWeb.Admin.GuardianController do
 
     with {:ok, %Guardian{} = guardian} <-
            Accounts.update_guardian_and_user(guardian, guardian_params, user_params) do
-      render(conn, "guardian.json", guardian: guardian)
+      render(conn, :show, guardian: guardian)
     end
   end
 end

lib/bokken_web/views/admin/guardian_view.ex → lib/bokken_web/controllers/admin/guardian_json.ex

@@ -1,13 +1,15 @@
-defmodule BokkenWeb.Admin.GuardianView do
-  use BokkenWeb, :view
-
+defmodule BokkenWeb.Admin.GuardianJSON do
   alias Bokken.Uploaders.Avatar
 
-  def render("index.json", %{guardians: guardians}) do
-    %{data: render_many(guardians, __MODULE__, "guardian.json")}
+  def index(%{guardians: guardians}) do
+    %{data: for(g <- guardians, do: guardian(g))}
+  end
+
+  def show(%{guardian: guardian}) do
+    %{data: guardian(guardian)}
   end
 
-  def render("guardian.json", %{guardian: guardian}) do
+  def guardian(guardian) do
     %{
       id: guardian.id,
       photo: Avatar.url({guardian.photo, guardian}, :thumb),

lib/bokken_web/controllers/admin/user_controller.ex

@@ -1,5 +1,5 @@
 defmodule BokkenWeb.Admin.UserController do
-  use BokkenWeb, controller: "1.6"
+  use BokkenWeb, :controller
 
   alias Bokken.Accounts
   alias Bokken.Accounts.User
@@ -8,14 +8,14 @@ defmodule BokkenWeb.Admin.UserController do
 
   def index(conn, _params) do
     users = Accounts.list_users()
-    render(conn, "index.json", users: users)
+    render(conn, :index, users: users)
   end
 
   def update(conn, %{"id" => id, "user" => user_params}) when is_organizer(conn) do
     user = Accounts.get_user!(id)
 
     with {:ok, %User{} = user} <- Accounts.update_user_as_admin(user, user_params) do
-      render(conn, "user.json", user: user)
+      render(conn, :user, user: user)
     end
   end
 end

lib/bokken_web/controllers/guardian_controller.ex

@@ -1,5 +1,5 @@
 defmodule BokkenWeb.GuardianController do
-  use BokkenWeb, controller: "1.6"
+  use BokkenWeb, :controller
 
   alias Bokken.Accounts
   alias Bokken.Accounts.Guardian
@@ -8,30 +8,30 @@ defmodule BokkenWeb.GuardianController do
 
   def index(conn, _params) do
     guardians = Accounts.list_guardians()
-    render(conn, "index.json", guardians: guardians)
+    render(conn, :index, guardians: guardians)
   end
 
   def create(conn, %{"guardian" => guardian_params})
       when is_guardian(conn) or is_organizer(conn) do
     with {:ok, %Guardian{} = guardian} <- Accounts.create_guardian(guardian_params) do
       conn
       |> put_status(:created)
-      |> put_resp_header("location", Routes.guardian_path(conn, :show, guardian))
-      |> render("show.json", guardian: guardian)
+      |> put_resp_header("location", ~p"/api/guardians/#{guardian.id}")
+      |> render(:show, guardian: guardian)
     end
   end
 
   def show(conn, %{"id" => id}) do
     guardian = Accounts.get_guardian!(id)
-    render(conn, "show.json", guardian: guardian)
+    render(conn, :show, guardian: guardian)
   end
 
   def update(conn, %{"id" => id, "guardian" => guardian_params})
       when is_guardian(conn) or is_organizer(conn) do
     guardian = Accounts.get_guardian!(id)
 
     with {:ok, %Guardian{} = guardian} <- Accounts.update_guardian(guardian, guardian_params) do
-      render(conn, "show.json", guardian: guardian)
+      render(conn, :show, guardian: guardian)
     end
   end
 

lib/bokken_web/views/guardian_view.ex → lib/bokken_web/controllers/guardian_json.ex

@@ -1,23 +1,20 @@
-defmodule BokkenWeb.GuardianView do
-  use BokkenWeb, :view
-
+defmodule BokkenWeb.GuardianJSON do
   alias Bokken.Uploaders.Avatar
-  alias BokkenWeb.GuardianView
 
-  def render("index.json", %{guardians: guardians, current_user: current_user}) do
-    %{data: render_many(guardians, GuardianView, "guardian.json", current_user: current_user)}
+  def index(%{guardians: guardians, current_user: current_user}) do
+    %{data: for(g <- guardians, do: data(g, current_user))}
   end
 
-  def render("show.json", %{guardian: guardian, current_user: current_user}) do
-    %{data: render_one(guardian, GuardianView, "guardian.json", current_user: current_user)}
+  def show(%{guardian: guardian, current_user: current_user}) do
+    %{data: data(guardian, current_user)}
   end
 
-  def render("guardian.json", %{guardian: guardian, current_user: current_user}) do
-    data(guardian)
+  defp data(guardian, current_user) do
+    guardian(guardian)
     |> Map.merge(personal(guardian, current_user))
   end
 
-  defp data(guardian) do
+  defp guardian(guardian) do
     %{
       id: guardian.id,
       photo: Avatar.url({guardian.photo, guardian}, :thumb),

test/bokken_web/controllers/admin/guardian_controller_test.exs

@@ -0,0 +1,48 @@
+defmodule BokkenWeb.Admin.GuardianControllerTest do
+  use BokkenWeb.ConnCase
+
+  alias Bokken.Accounts
+
+  import Bokken.Factory
+
+  setup %{conn: conn} do
+    password = "password1234!"
+    guardian_user = insert(:user, role: "organizer", password: password)
+
+    {:ok, user} = Accounts.authenticate_user(guardian_user.email, password)
+
+    {:ok, conn: log_in_user(conn, user)}
+  end
+
+  describe "index" do
+    test "lists all guardians", %{conn: conn} do
+      conn = get(conn, ~p"/api/admin/guardians/")
+      assert json_response(conn, 200)["data"] == []
+    end
+  end
+
+  describe "show" do
+    test "shoes", %{conn: conn} do
+      guardian = insert(:guardian)
+
+      update_attrs = %{
+        mobile: "+351915096743",
+        first_name: "Ana Maria",
+        last_name: "Silva Costa",
+        city: "Guimarães"
+      }
+
+      user_params = %{
+        user_id: guardian.user_id
+      }
+
+      conn =
+        put(conn, ~p"/api/admin/guardians/#{guardian.id}", %{
+          guardian: update_attrs,
+          user: user_params
+        })
+
+      assert %{"id" => _id} = json_response(conn, 200)["data"]
+    end
+  end
+end

test/bokken_web/controllers/guardian_controller_test.exs

@@ -17,7 +17,7 @@ defmodule BokkenWeb.GuardianControllerTest do
 
   describe "index" do
     test "lists all guardians", %{conn: conn} do
-      conn = get(conn, Routes.guardian_path(conn, :index))
+      conn = get(conn, ~p"/api/guardians/")
       assert json_response(conn, 200)["data"] == []
     end
   end
@@ -36,10 +36,10 @@ defmodule BokkenWeb.GuardianControllerTest do
 
       guardian = params_for(:guardian, guardian_attrs)
 
-      conn = post(conn, Routes.guardian_path(conn, :create), guardian: guardian)
+      conn = post(conn, ~p"/api/guardians/", guardian: guardian)
       assert %{"id" => id} = json_response(conn, 201)["data"]
 
-      conn = get(conn, Routes.guardian_path(conn, :show, id))
+      conn = get(conn, ~p"/api/guardians/#{id}")
 
       assert %{
                "id" => _id,
@@ -56,7 +56,7 @@ defmodule BokkenWeb.GuardianControllerTest do
       user_id = get_req_header(conn, "user_id")
       user_id = Enum.at(user_id, 0)
       guardian = Map.put(guardian, :user_id, user_id)
-      conn = post(conn, Routes.guardian_path(conn, :create), guardian: guardian)
+      conn = post(conn, ~p"/api/guardians/", guardian: guardian)
       assert json_response(conn, 422)["errors"] != %{}
     end
   end
@@ -75,10 +75,11 @@ defmodule BokkenWeb.GuardianControllerTest do
         city: "Guimarães"
       }
 
-      conn = put(conn, Routes.guardian_path(conn, :update, guardian), guardian: update_attrs)
+      conn = put(conn, ~p"/api/guardians/#{guardian.id}", guardian: update_attrs)
+
       assert %{"id" => id} = json_response(conn, 200)["data"]
 
-      conn = get(conn, Routes.guardian_path(conn, :show, id))
+      conn = get(conn, ~p"/api/guardians/#{id}")
 
       assert %{
                "first_name" => "Ana Maria",
@@ -91,7 +92,7 @@ defmodule BokkenWeb.GuardianControllerTest do
 
     test "renders errors when data is invalid", %{conn: conn, guardian: guardian} do
       invalid_attrs = %{mobile: nil}
-      conn = put(conn, Routes.guardian_path(conn, :update, guardian), guardian: invalid_attrs)
+      conn = put(conn, ~p"/api/guardians/#{guardian.id}", guardian: invalid_attrs)
       assert json_response(conn, 422)["errors"] != %{}
     end
   end
@@ -100,11 +101,11 @@ defmodule BokkenWeb.GuardianControllerTest do
     setup [:new_guardian]
 
     test "deletes chosen guardian", %{conn: conn, guardian: guardian} do
-      conn = delete(conn, Routes.guardian_path(conn, :delete, guardian))
+      conn = delete(conn, ~p"/api/guardians/#{guardian.id}")
       assert response(conn, 204)
 
       assert_error_sent 404, fn ->
-        get(conn, Routes.guardian_path(conn, :show, guardian))
+        get(conn, ~p"/api/guardians/#{guardian.id}")
       end
     end
   end