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)
+  def 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),

lib/bokken_web/views/auth_view.ex

@@ -2,7 +2,7 @@ defmodule BokkenWeb.AuthView do
   use BokkenWeb, :view
 
   alias BokkenWeb.AuthView
-  alias BokkenWeb.GuardianView
+  alias BokkenWeb.GuardianJSON
   alias BokkenWeb.MentorView
   alias BokkenWeb.NinjaJSON
   alias BokkenWeb.OrganizerView
@@ -12,7 +12,7 @@ defmodule BokkenWeb.AuthView do
   end
 
   def render("me.json", %{user: %{role: :guardian, guardian: guardian} = user}) do
-    render_one(guardian, GuardianView, "guardian.json", current_user: user)
+    GuardianJSON.data(guardian, user)
     |> Map.merge(render_one(user, AuthView, "user.json", current_user: user))
     |> Map.put(:guardian_id, guardian.id)
   end

test/bokken_web/controllers/admin/guardian_controller_test.exs

@@ -0,0 +1,45 @@
+defmodule BokkenWeb.Admin.GuardianControllerTest do
+  use BokkenWeb.ConnCase
+
+  import Bokken.Factory
+
+  setup %{conn: conn} do
+    {:ok, conn: put_resp_header(conn, "accept", "application/json")}
+  end
+
+  describe "index" do
+    setup [:login_as_organizer]
+
+    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
+    setup [:login_as_organizer]
+
+    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

@@ -1,28 +1,26 @@
 defmodule BokkenWeb.GuardianControllerTest do
   use BokkenWeb.ConnCase
 
-  alias Bokken.Accounts
   alias Bokken.Accounts.Guardian
 
   import Bokken.Factory
 
   setup %{conn: conn} do
-    password = "password1234!"
-    guardian_user = insert(:user, role: "guardian", password: password)
-
-    {:ok, user} = Accounts.authenticate_user(guardian_user.email, password)
-
-    {:ok, conn: log_in_user(conn, user)}
+    {:ok, conn: put_resp_header(conn, "accept", "application/json")}
   end
 
   describe "index" do
+    setup [:login_as_guardian]
+
     test "lists all guardians", %{conn: conn} do
-      conn = get(conn, Routes.guardian_path(conn, :index))
-      assert json_response(conn, 200)["data"] == []
+      conn = get(conn, ~p"/api/guardians/")
+      assert json_response(conn, 200)["data"] != []
     end
   end
 
   describe "create guardian" do
+    setup [:login_as_guardian]
+
     test "renders guardian when data is valid", %{conn: conn} do
       new_user = insert(:user, role: "guardian")
 
@@ -36,10 +34,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,12 +54,13 @@ 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
 
   describe "update guardian" do
+    setup [:login_as_guardian]
     setup [:new_guardian_update]
 
     test "renders guardian when data is valid", %{
@@ -75,10 +74,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,20 +91,21 @@ 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
 
   describe "delete guardian" do
+    setup [:login_as_guardian]
     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