refactor: upgrade guardian controller to 1.7

\

@@ -0,0 +1,121 @@
+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)}
+  end
+
+  describe "index" do
+    test "lists all guardians", %{conn: conn} do
+      conn = get(conn, ~p"/api/guardians/")
+      assert json_response(conn, 200)["data"] == []
+    end
+  end
+
+  describe "create guardian" do
+    test "renders guardian when data is valid", %{conn: conn} do
+      new_user = insert(:user, role: "guardian")
+
+      guardian_attrs = %{
+        city: "Guimarães",
+        mobile: "+351915196743",
+        first_name: "Carla Maria",
+        last_name: "Silva Costa",
+        user_id: new_user.id
+      }
+
+      guardian = params_for(:guardian, guardian_attrs)
+
+      conn = post(conn, ~p"/api/guardians/guardian", guardian: guardian)
+      assert %{"id" => id} = json_response(conn, 201)["data"]
+
+      conn = get(conn, Routes.guardian_path(conn, :show, id))
+
+      assert %{
+               "id" => _id,
+               "first_name" => "Carla Maria",
+               "last_name" => "Silva Costa"
+             } = json_response(conn, 200)["data"]
+
+      assert not Map.has_key?(json_response(conn, 200)["data"], "city")
+      assert not Map.has_key?(json_response(conn, 200)["data"], "mobile")
+    end
+
+    test "renders errors when data is invalid", %{conn: conn} do
+      guardian = params_for(:guardian, mobile: nil)
+      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)
+      assert json_response(conn, 422)["errors"] != %{}
+    end
+  end
+
+  describe "update guardian" do
+    setup [:new_guardian_update]
+
+    test "renders guardian when data is valid", %{
+      conn: conn,
+      guardian: %Guardian{id: _id} = guardian
+    } do
+      update_attrs = %{
+        mobile: "+351915096743",
+        first_name: "Ana Maria",
+        last_name: "Silva Costa",
+        city: "Guimarães"
+      }
+
+      conn = put(conn, Routes.guardian_path(conn, :update, guardian), guardian: update_attrs)
+      assert %{"id" => id} = json_response(conn, 200)["data"]
+
+      conn = get(conn, Routes.guardian_path(conn, :show, id))
+
+      assert %{
+               "first_name" => "Ana Maria",
+               "last_name" => "Silva Costa"
+             } = json_response(conn, 200)["data"]
+
+      assert not Map.has_key?(json_response(conn, 200)["data"], "mobile")
+      assert not Map.has_key?(json_response(conn, 200)["data"], "city")
+    end
+
+    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)
+      assert json_response(conn, 422)["errors"] != %{}
+    end
+  end
+
+  describe "delete guardian" do
+    setup [:new_guardian]
+
+    test "deletes chosen guardian", %{conn: conn, guardian: guardian} do
+      conn = delete(conn, Routes.guardian_path(conn, :delete, guardian))
+      assert response(conn, 204)
+
+      assert_error_sent 404, fn ->
+        get(conn, Routes.guardian_path(conn, :show, guardian))
+      end
+    end
+  end
+
+  defp new_guardian(_) do
+    guardian = insert(:guardian)
+    %{guardian: guardian}
+  end
+
+  defp new_guardian_update(_) do
+    guardian = insert(:guardian)
+    %{guardian: guardian}
+  end
+end

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

@@ -1,13 +1,11 @@
-defmodule BokkenWeb.Admin.GuardianView do
-  use BokkenWeb, :view
-
+defmodule BokkenWeb.Controller.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(%{guardian: g}))}
   end
 
-  def render("guardian.json", %{guardian: guardian}) do
+  def guardian(%{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.ex

@@ -0,0 +1,121 @@
+# defmodule BokkenWeb.Admin.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: "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, Routes.guardian_path(conn, :index))
+#       assert json_response(conn, 200)["data"] == []
+#     end
+#   end
+
+#   describe "create guardian" do
+#     test "renders guardian when data is valid", %{conn: conn} do
+#       new_user = insert(:user, role: "guardian")
+
+#       guardian_attrs = %{
+#         city: "Guimarães",
+#         mobile: "+351915196743",
+#         first_name: "Carla Maria",
+#         last_name: "Silva Costa",
+#         user_id: new_user.id
+#       }
+
+#       guardian = params_for(:guardian, guardian_attrs)
+
+#       conn = post(conn, Routes.guardian_path(conn, :create), guardian: guardian)
+#       assert %{"id" => id} = json_response(conn, 201)["data"]
+
+#       conn = get(conn, Routes.guardian_path(conn, :show, id))
+
+#       assert %{
+#                "id" => _id,
+#                "first_name" => "Carla Maria",
+#                "last_name" => "Silva Costa"
+#              } = json_response(conn, 200)["data"]
+
+#       assert not Map.has_key?(json_response(conn, 200)["data"], "city")
+#       assert not Map.has_key?(json_response(conn, 200)["data"], "mobile")
+#     end
+
+#     test "renders errors when data is invalid", %{conn: conn} do
+#       guardian = params_for(:guardian, mobile: nil)
+#       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)
+#       assert json_response(conn, 422)["errors"] != %{}
+#     end
+#   end
+
+#   describe "update guardian" do
+#     setup [:new_guardian_update]
+
+#     test "renders guardian when data is valid", %{
+#       conn: conn,
+#       guardian: %Guardian{id: _id} = guardian
+#     } do
+#       update_attrs = %{
+#         mobile: "+351915096743",
+#         first_name: "Ana Maria",
+#         last_name: "Silva Costa",
+#         city: "Guimarães"
+#       }
+
+#       conn = put(conn, Routes.guardian_path(conn, :update, guardian), guardian: update_attrs)
+#       assert %{"id" => id} = json_response(conn, 200)["data"]
+
+#       conn = get(conn, Routes.guardian_path(conn, :show, id))
+
+#       assert %{
+#                "first_name" => "Ana Maria",
+#                "last_name" => "Silva Costa"
+#              } = json_response(conn, 200)["data"]
+
+#       assert not Map.has_key?(json_response(conn, 200)["data"], "mobile")
+#       assert not Map.has_key?(json_response(conn, 200)["data"], "city")
+#     end
+
+#     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)
+#       assert json_response(conn, 422)["errors"] != %{}
+#     end
+#   end
+
+#   describe "delete guardian" do
+#     setup [:new_guardian]
+
+#     test "deletes chosen guardian", %{conn: conn, guardian: guardian} do
+#       conn = delete(conn, Routes.guardian_path(conn, :delete, guardian))
+#       assert response(conn, 204)
+
+#       assert_error_sent 404, fn ->
+#         get(conn, Routes.guardian_path(conn, :show, guardian))
+#       end
+#     end
+#   end
+
+#   defp new_guardian(_) do
+#     guardian = insert(:guardian)
+#     %{guardian: guardian}
+#   end
+
+#   defp new_guardian_update(_) do
+#     guardian = insert(:guardian)
+#     %{guardian: guardian}
+#   end
+# end