git.squeep.com Git - akkoma/blob - test/pleroma/web/admin_api/controllers/announcement_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.AdminAPI.AnnouncementControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   import Pleroma.Factory
   9
  10   setup do
  11     admin = insert(:user, is_admin: true)
  12     token = insert(:oauth_admin_token, user: admin)
  13
  14     conn =
  15       build_conn()
  16       |> assign(:user, admin)
  17       |> assign(:token, token)
  18
  19     {:ok, %{admin: admin, token: token, conn: conn}}
  20   end
  21
  22   describe "GET /api/v1/pleroma/admin/announcements" do
  23     test "it lists all announcements", %{conn: conn} do
  24       %{id: id} = insert(:announcement)
  25
  26       response =
  27         conn
  28         |> get("/api/v1/pleroma/admin/announcements")
  29         |> json_response_and_validate_schema(:ok)
  30
  31       assert [%{"id" => ^id}] = response
  32     end
  33
  34     test "it paginates announcements", %{conn: conn} do
  35       _announcements = Enum.map(0..20, fn _ -> insert(:announcement) end)
  36
  37       response =
  38         conn
  39         |> get("/api/v1/pleroma/admin/announcements")
  40         |> json_response_and_validate_schema(:ok)
  41
  42       assert length(response) == 20
  43     end
  44
  45     test "it paginates announcements with custom params", %{conn: conn} do
  46       announcements = Enum.map(0..20, fn _ -> insert(:announcement) end)
  47
  48       response =
  49         conn
  50         |> get("/api/v1/pleroma/admin/announcements", limit: 5, offset: 7)
  51         |> json_response_and_validate_schema(:ok)
  52
  53       assert length(response) == 5
  54       assert Enum.at(response, 0)["id"] == Enum.at(announcements, 7).id
  55     end
  56
  57     test "it returns empty list with out-of-bounds offset", %{conn: conn} do
  58       _announcements = Enum.map(0..20, fn _ -> insert(:announcement) end)
  59
  60       response =
  61         conn
  62         |> get("/api/v1/pleroma/admin/announcements", offset: 21)
  63         |> json_response_and_validate_schema(:ok)
  64
  65       assert [] = response
  66     end
  67
  68     test "it rejects invalid pagination params", %{conn: conn} do
  69       conn
  70       |> get("/api/v1/pleroma/admin/announcements", limit: 0)
  71       |> json_response_and_validate_schema(400)
  72
  73       conn
  74       |> get("/api/v1/pleroma/admin/announcements", limit: -1)
  75       |> json_response_and_validate_schema(400)
  76
  77       conn
  78       |> get("/api/v1/pleroma/admin/announcements", offset: -1)
  79       |> json_response_and_validate_schema(400)
  80     end
  81   end
  82
  83   describe "GET /api/v1/pleroma/admin/announcements/:id" do
  84     test "it displays one announcement", %{conn: conn} do
  85       %{id: id} = insert(:announcement)
  86
  87       response =
  88         conn
  89         |> get("/api/v1/pleroma/admin/announcements/#{id}")
  90         |> json_response_and_validate_schema(:ok)
  91
  92       assert %{"id" => ^id} = response
  93     end
  94
  95     test "it returns not found for non-existent id", %{conn: conn} do
  96       %{id: id} = insert(:announcement)
  97
  98       _response =
  99         conn
 100         |> get("/api/v1/pleroma/admin/announcements/#{id}xxx")
 101         |> json_response_and_validate_schema(:not_found)
 102     end
 103   end
 104
 105   describe "DELETE /api/v1/pleroma/admin/announcements/:id" do
 106     test "it deletes specified announcement", %{conn: conn} do
 107       %{id: id} = insert(:announcement)
 108
 109       _response =
 110         conn
 111         |> delete("/api/v1/pleroma/admin/announcements/#{id}")
 112         |> json_response_and_validate_schema(:ok)
 113     end
 114
 115     test "it returns not found for non-existent id", %{conn: conn} do
 116       %{id: id} = insert(:announcement)
 117
 118       _response =
 119         conn
 120         |> delete("/api/v1/pleroma/admin/announcements/#{id}xxx")
 121         |> json_response_and_validate_schema(:not_found)
 122
 123       assert %{id: ^id} = Pleroma.Announcement.get_by_id(id)
 124     end
 125   end
 126
 127   describe "PATCH /api/v1/pleroma/admin/announcements/:id" do
 128     test "it returns not found for non-existent id", %{conn: conn} do
 129       %{id: id} = insert(:announcement)
 130
 131       _response =
 132         conn
 133         |> put_req_header("content-type", "application/json")
 134         |> patch("/api/v1/pleroma/admin/announcements/#{id}xxx", %{})
 135         |> json_response_and_validate_schema(:not_found)
 136
 137       assert %{id: ^id} = Pleroma.Announcement.get_by_id(id)
 138     end
 139
 140     test "it updates a field", %{conn: conn} do
 141       %{id: id} = insert(:announcement)
 142
 143       now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
 144       starts_at = NaiveDateTime.add(now, -10, :second)
 145
 146       _response =
 147         conn
 148         |> put_req_header("content-type", "application/json")
 149         |> patch("/api/v1/pleroma/admin/announcements/#{id}", %{
 150           starts_at: NaiveDateTime.to_iso8601(starts_at)
 151         })
 152         |> json_response_and_validate_schema(:ok)
 153
 154       new = Pleroma.Announcement.get_by_id(id)
 155
 156       assert NaiveDateTime.compare(new.starts_at, starts_at) == :eq
 157     end
 158
 159     test "it updates with time with utc timezone", %{conn: conn} do
 160       %{id: id} = insert(:announcement)
 161
 162       now = DateTime.now("Etc/UTC") |> elem(1) |> DateTime.truncate(:second)
 163       starts_at = DateTime.add(now, -10, :second)
 164
 165       _response =
 166         conn
 167         |> put_req_header("content-type", "application/json")
 168         |> patch("/api/v1/pleroma/admin/announcements/#{id}", %{
 169           starts_at: DateTime.to_iso8601(starts_at)
 170         })
 171         |> json_response_and_validate_schema(:ok)
 172
 173       new = Pleroma.Announcement.get_by_id(id)
 174
 175       assert DateTime.compare(new.starts_at, starts_at) == :eq
 176     end
 177
 178     test "it updates a data field", %{conn: conn} do
 179       %{id: id} = announcement = insert(:announcement, data: %{"all_day" => true})
 180
 181       assert announcement.data["all_day"] == true
 182
 183       new_content = "new content"
 184
 185       response =
 186         conn
 187         |> put_req_header("content-type", "application/json")
 188         |> patch("/api/v1/pleroma/admin/announcements/#{id}", %{
 189           content: new_content
 190         })
 191         |> json_response_and_validate_schema(:ok)
 192
 193       assert response["content"] == new_content
 194       assert response["all_day"] == true
 195
 196       new = Pleroma.Announcement.get_by_id(id)
 197
 198       assert new.data["content"] == new_content
 199       assert new.data["all_day"] == true
 200     end
 201
 202     test "it nullifies a nullable field", %{conn: conn} do
 203       now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
 204       starts_at = NaiveDateTime.add(now, -10, :second)
 205
 206       %{id: id} = insert(:announcement, starts_at: starts_at)
 207
 208       response =
 209         conn
 210         |> put_req_header("content-type", "application/json")
 211         |> patch("/api/v1/pleroma/admin/announcements/#{id}", %{
 212           starts_at: nil
 213         })
 214         |> json_response_and_validate_schema(:ok)
 215
 216       assert response["starts_at"] == nil
 217
 218       new = Pleroma.Announcement.get_by_id(id)
 219
 220       assert new.starts_at == nil
 221     end
 222   end
 223
 224   describe "POST /api/v1/pleroma/admin/announcements" do
 225     test "it creates an announcement", %{conn: conn} do
 226       content = "test post announcement api"
 227
 228       now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
 229       starts_at = NaiveDateTime.add(now, -10, :second)
 230       ends_at = NaiveDateTime.add(now, 10, :second)
 231
 232       response =
 233         conn
 234         |> put_req_header("content-type", "application/json")
 235         |> post("/api/v1/pleroma/admin/announcements", %{
 236           "content" => content,
 237           "starts_at" => NaiveDateTime.to_iso8601(starts_at),
 238           "ends_at" => NaiveDateTime.to_iso8601(ends_at),
 239           "all_day" => true
 240         })
 241         |> json_response_and_validate_schema(:ok)
 242
 243       assert %{"content" => ^content, "all_day" => true} = response
 244
 245       announcement = Pleroma.Announcement.get_by_id(response["id"])
 246
 247       assert not is_nil(announcement)
 248
 249       assert NaiveDateTime.compare(announcement.starts_at, starts_at) == :eq
 250       assert NaiveDateTime.compare(announcement.ends_at, ends_at) == :eq
 251     end
 252
 253     test "creating with time with utc timezones", %{conn: conn} do
 254       content = "test post announcement api"
 255
 256       now = DateTime.now("Etc/UTC") |> elem(1) |> DateTime.truncate(:second)
 257       starts_at = DateTime.add(now, -10, :second)
 258       ends_at = DateTime.add(now, 10, :second)
 259
 260       response =
 261         conn
 262         |> put_req_header("content-type", "application/json")
 263         |> post("/api/v1/pleroma/admin/announcements", %{
 264           "content" => content,
 265           "starts_at" => DateTime.to_iso8601(starts_at),
 266           "ends_at" => DateTime.to_iso8601(ends_at),
 267           "all_day" => true
 268         })
 269         |> json_response_and_validate_schema(:ok)
 270
 271       assert %{"content" => ^content, "all_day" => true} = response
 272
 273       announcement = Pleroma.Announcement.get_by_id(response["id"])
 274
 275       assert not is_nil(announcement)
 276
 277       assert DateTime.compare(announcement.starts_at, starts_at) == :eq
 278       assert DateTime.compare(announcement.ends_at, ends_at) == :eq
 279     end
 280   end
 281 end