git.squeep.com Git - akkoma/blob - test/web/mastodon_api/mastodon_api_controller_test.exs

   1 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   2   use Pleroma.Web.ConnCase
   3
   4   alias Pleroma.Web.TwitterAPI.TwitterAPI
   5   alias Pleroma.{Repo, User, Activity}
   6   alias Pleroma.Web.{OStatus, CommonAPI}
   7
   8   import Pleroma.Factory
   9
  10   test "the home timeline", %{conn: conn} do
  11     user = insert(:user)
  12     following = insert(:user)
  13
  14     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  15
  16     conn = conn
  17     |> assign(:user, user)
  18     |> get("/api/v1/timelines/home")
  19
  20     assert length(json_response(conn, 200)) == 0
  21
  22     {:ok, user} = User.follow(user, following)
  23
  24     conn = build_conn()
  25     |> assign(:user, user)
  26     |> get("/api/v1/timelines/home")
  27
  28     assert [%{"content" => "test"}] = json_response(conn, 200)
  29   end
  30
  31   test "the public timeline", %{conn: conn} do
  32     following = insert(:user)
  33
  34     {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
  35     {:ok, [_activity]} = OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
  36
  37     conn = conn
  38     |> get("/api/v1/timelines/public")
  39
  40     assert length(json_response(conn, 200)) == 2
  41
  42     conn = build_conn()
  43     |> get("/api/v1/timelines/public", %{"local" => "True"})
  44
  45     assert [%{"content" => "test"}] = json_response(conn, 200)
  46   end
  47
  48   test "posting a status", %{conn: conn} do
  49     user = insert(:user)
  50
  51     conn = conn
  52     |> assign(:user, user)
  53     |> post("/api/v1/statuses", %{"status" => "cofe", "spoiler_text" => "2hu"})
  54
  55     assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu"} = json_response(conn, 200)
  56     assert Repo.get(Activity, id)
  57   end
  58
  59   test "replying to a status", %{conn: conn} do
  60     user = insert(:user)
  61
  62     {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
  63
  64     conn = conn
  65     |> assign(:user, user)
  66     |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
  67
  68     assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
  69
  70     activity = Repo.get(Activity, id)
  71
  72     assert activity.data["context"] == replied_to.data["context"]
  73     assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
  74   end
  75
  76   test "verify_credentials", %{conn: conn} do
  77     user = insert(:user)
  78
  79     conn = conn
  80     |> assign(:user, user)
  81     |> get("/api/v1/accounts/verify_credentials")
  82
  83     assert %{"id" => id} = json_response(conn, 200)
  84     assert id == user.id
  85   end
  86
  87   test "get a status", %{conn: conn} do
  88     activity = insert(:note_activity)
  89
  90     conn = conn
  91     |> get("/api/v1/statuses/#{activity.id}")
  92
  93     assert %{"id" => id} = json_response(conn, 200)
  94     assert id == to_string(activity.id)
  95   end
  96
  97   describe "deleting a status" do
  98     test "when you created it", %{conn: conn} do
  99       activity = insert(:note_activity)
 100       author = User.get_by_ap_id(activity.data["actor"])
 101
 102       conn = conn
 103       |> assign(:user, author)
 104       |> delete("/api/v1/statuses/#{activity.id}")
 105
 106       assert %{} = json_response(conn, 200)
 107
 108       assert Repo.get(Activity, activity.id) == nil
 109     end
 110
 111     test "when you didn't create it", %{conn: conn} do
 112       activity = insert(:note_activity)
 113       user = insert(:user)
 114
 115       conn = conn
 116       |> assign(:user, user)
 117       |> delete("/api/v1/statuses/#{activity.id}")
 118
 119       assert %{"error" => _} = json_response(conn, 403)
 120
 121       assert Repo.get(Activity, activity.id) == activity
 122     end
 123   end
 124
 125   describe "reblogging" do
 126     test "reblogs and returns the reblogged status", %{conn: conn} do
 127       activity = insert(:note_activity)
 128       user = insert(:user)
 129
 130       conn = conn
 131       |> assign(:user, user)
 132       |> post("/api/v1/statuses/#{activity.id}/reblog")
 133
 134       assert %{"id" => id, "reblogged" => true, "reblogs_count" => 1} = json_response(conn, 200)
 135       assert to_string(activity.id) == id
 136     end
 137   end
 138
 139   describe "favoriting" do
 140     test "favs a status and returns it", %{conn: conn} do
 141       activity = insert(:note_activity)
 142       user = insert(:user)
 143
 144       conn = conn
 145       |> assign(:user, user)
 146       |> post("/api/v1/statuses/#{activity.id}/favourite")
 147
 148       assert %{"id" => id, "favourites_count" => 1, "favourited" => true} = json_response(conn, 200)
 149       assert to_string(activity.id) == id
 150     end
 151   end
 152
 153   describe "unfavoriting" do
 154     test "unfavorites a status and returns it", %{conn: conn} do
 155       activity = insert(:note_activity)
 156       user = insert(:user)
 157
 158       {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 159
 160       conn = conn
 161       |> assign(:user, user)
 162       |> post("/api/v1/statuses/#{activity.id}/unfavourite")
 163
 164       assert %{"id" => id, "favourites_count" => 0, "favourited" => false} = json_response(conn, 200)
 165       assert to_string(activity.id) == id
 166     end
 167   end
 168
 169   describe "user timelines" do
 170     test "gets a users statuses", %{conn: conn} do
 171       _note = insert(:note_activity)
 172       note_two = insert(:note_activity)
 173
 174       user = User.get_by_ap_id(note_two.data["actor"])
 175
 176       conn = conn
 177       |> get("/api/v1/accounts/#{user.id}/statuses")
 178
 179       assert [%{"id" => id}] = json_response(conn, 200)
 180
 181       assert id == to_string(note_two.id)
 182     end
 183   end
 184
 185   describe "user relationships" do
 186     test "returns the relationships for the current user", %{conn: conn} do
 187       user = insert(:user)
 188       other_user = insert(:user)
 189       {:ok, user} = User.follow(user, other_user)
 190
 191       conn = conn
 192       |> assign(:user, user)
 193       |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
 194
 195       assert [relationship] = json_response(conn, 200)
 196
 197       assert other_user.id == relationship["id"]
 198     end
 199   end
 200
 201   test "account fetching", %{conn: conn} do
 202     user = insert(:user)
 203
 204     conn = conn
 205     |> get("/api/v1/accounts/#{user.id}")
 206
 207     assert %{"id" => id} = json_response(conn, 200)
 208     assert id == user.id
 209
 210     conn = build_conn()
 211     |> get("/api/v1/accounts/-1")
 212
 213     assert %{"error" => "Can't find user"} = json_response(conn, 404)
 214   end
 215
 216   test "media upload", %{conn: conn} do
 217     file = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
 218
 219     user = insert(:user)
 220
 221     conn = conn
 222     |> assign(:user, user)
 223     |> post("/api/v1/media", %{"file" => file})
 224
 225     assert media = json_response(conn, 200)
 226
 227     assert media["type"] == "image"
 228   end
 229
 230   test "hashtag timeline", %{conn: conn} do
 231     following = insert(:user)
 232
 233     {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
 234     {:ok, [_activity]} = OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
 235
 236     conn = conn
 237     |> get("/api/v1/timelines/tag/2hu")
 238
 239     assert [%{"id" => id}] = json_response(conn, 200)
 240
 241     assert id == to_string(activity.id)
 242   end
 243
 244   test "getting followers", %{conn: conn} do
 245     user = insert(:user)
 246     other_user = insert(:user)
 247     {:ok, user} = User.follow(user, other_user)
 248
 249     conn = conn
 250     |> get("/api/v1/accounts/#{other_user.id}/followers")
 251
 252     assert [%{"id" => id}] = json_response(conn, 200)
 253     assert id = user.id
 254   end
 255
 256   test "getting following", %{conn: conn} do
 257     user = insert(:user)
 258     other_user = insert(:user)
 259     {:ok, user} = User.follow(user, other_user)
 260
 261     conn = conn
 262     |> get("/api/v1/accounts/#{user.id}/following")
 263
 264     assert [%{"id" => id}] = json_response(conn, 200)
 265     assert id = other_user.id
 266   end
 267
 268   test "following / unfollowing a user", %{conn: conn} do
 269     user = insert(:user)
 270     other_user = insert(:user)
 271
 272     conn = conn
 273     |> assign(:user, user)
 274     |> post("/api/v1/accounts/#{other_user.id}/follow")
 275
 276     assert %{"id" => id, "following" => true} = json_response(conn, 200)
 277
 278     user = Repo.get(User, user.id)
 279     conn = build_conn()
 280     |> assign(:user, user)
 281     |> post("/api/v1/accounts/#{other_user.id}/unfollow")
 282
 283     assert %{"id" => id, "following" => false} = json_response(conn, 200)
 284
 285     user = Repo.get(User, user.id)
 286     conn = build_conn()
 287     |> assign(:user, user)
 288     |> post("/api/v1/follows", %{"uri" => other_user.nickname})
 289
 290     assert %{"id" => id} = json_response(conn, 200)
 291     assert id == other_user.id
 292   end
 293
 294   test "blocking / unblocking a user", %{conn: conn} do
 295     user = insert(:user)
 296     other_user = insert(:user)
 297
 298     conn = conn
 299     |> assign(:user, user)
 300     |> post("/api/v1/accounts/#{other_user.id}/block")
 301
 302     assert %{"id" => id, "blocking" => true} = json_response(conn, 200)
 303
 304     user = Repo.get(User, user.id)
 305     conn = build_conn()
 306     |> assign(:user, user)
 307     |> post("/api/v1/accounts/#{other_user.id}/unblock")
 308
 309     assert %{"id" => id, "blocking" => false} = json_response(conn, 200)
 310   end
 311
 312   test "getting a list of blocks", %{conn: conn} do
 313     user = insert(:user)
 314     other_user = insert(:user)
 315
 316     {:ok, user} = User.block(user, other_user)
 317
 318     conn = conn
 319     |> assign(:user, user)
 320     |> get("/api/v1/blocks")
 321
 322     other_user_id = other_user.id
 323     assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
 324   end
 325
 326   test "unimplemented mute endpoints" do
 327     user = insert(:user)
 328     other_user = insert(:user)
 329
 330     ["mute", "unmute"]
 331     |> Enum.each(fn(endpoint) ->
 332       conn = build_conn()
 333       |> assign(:user, user)
 334       |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
 335
 336       assert %{"id" => id} = json_response(conn, 200)
 337       assert id == other_user.id
 338     end)
 339   end
 340
 341   test "unimplemented mutes, follow_requests, blocks, domain blocks" do
 342     user = insert(:user)
 343
 344     ["blocks", "domain_blocks", "mutes", "follow_requests"]
 345     |> Enum.each(fn(endpoint) ->
 346       conn = build_conn()
 347       |> assign(:user, user)
 348       |> get("/api/v1/#{endpoint}")
 349
 350       assert [] = json_response(conn, 200)
 351     end)
 352   end
 353
 354   test "account search", %{conn: conn} do
 355     user = insert(:user)
 356     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 357     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 358
 359     conn = conn
 360     |> assign(:user, user)
 361     |> get("/api/v1/accounts/search", %{"q" => "2hu"})
 362
 363     assert [account] = json_response(conn, 200)
 364     assert account["id"] == user_three.id
 365   end
 366
 367   test "search", %{conn: conn} do
 368     user = insert(:user)
 369     user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 370     user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
 371
 372     {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 373     {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 374
 375     conn = conn
 376     |> get("/api/v1/search", %{"q" => "2hu"})
 377
 378     assert results = json_response(conn, 200)
 379
 380     [account] = results["accounts"]
 381     assert account["id"] == user_three.id
 382
 383     assert results["hashtags"] == []
 384
 385     [status] = results["statuses"]
 386     assert status["id"] == to_string(activity.id)
 387   end
 388
 389   test "search fetches remote accounts", %{conn: conn} do
 390     conn = conn
 391     |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
 392
 393     assert results = json_response(conn, 200)
 394     [account] = results["accounts"]
 395     assert account["acct"] == "shp@social.heldscal.la"
 396   end
 397
 398   test "returns the favorites of a user", %{conn: conn} do
 399     user = insert(:user)
 400     other_user = insert(:user)
 401
 402     {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
 403     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
 404
 405     {:ok, _, _} = CommonAPI.favorite(activity.id, user)
 406
 407     conn = conn
 408     |> assign(:user, user)
 409     |> get("/api/v1/favourites")
 410
 411     assert [status] = json_response(conn, 200)
 412     assert status["id"] == to_string(activity.id)
 413   end
 414 end