git.squeep.com Git - akkoma/blob - test/web/activity_pub/activity_pub_controller_test.exs

   1 defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
   2   use Pleroma.Web.ConnCase
   3   import Pleroma.Factory
   4   alias Pleroma.Web.ActivityPub.{UserView, ObjectView}
   5   alias Pleroma.{Repo, User}
   6   alias Pleroma.Activity
   7
   8   describe "/relay" do
   9     test "with the relay active, it returns the relay user", %{conn: conn} do
  10       res =
  11         conn
  12         |> get(activity_pub_path(conn, :relay))
  13         |> json_response(200)
  14
  15       assert res["id"] =~ "/relay"
  16     end
  17
  18     test "with the relay disabled, it returns 404", %{conn: conn} do
  19       Pleroma.Config.put([:instance, :allow_relay], false)
  20
  21       res =
  22         conn
  23         |> get(activity_pub_path(conn, :relay))
  24         |> json_response(404)
  25
  26       Pleroma.Config.put([:instance, :allow_relay], true)
  27     end
  28   end
  29
  30   describe "/users/:nickname" do
  31     test "it returns a json representation of the user", %{conn: conn} do
  32       user = insert(:user)
  33
  34       conn =
  35         conn
  36         |> put_req_header("accept", "application/activity+json")
  37         |> get("/users/#{user.nickname}")
  38
  39       user = Repo.get(User, user.id)
  40
  41       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
  42     end
  43   end
  44
  45   describe "/object/:uuid" do
  46     test "it returns a json representation of the object", %{conn: conn} do
  47       note = insert(:note)
  48       uuid = String.split(note.data["id"], "/") |> List.last()
  49
  50       conn =
  51         conn
  52         |> put_req_header("accept", "application/activity+json")
  53         |> get("/objects/#{uuid}")
  54
  55       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
  56     end
  57
  58     test "it returns 404 for non-public messages", %{conn: conn} do
  59       note = insert(:direct_note)
  60       uuid = String.split(note.data["id"], "/") |> List.last()
  61
  62       conn =
  63         conn
  64         |> put_req_header("accept", "application/activity+json")
  65         |> get("/objects/#{uuid}")
  66
  67       assert json_response(conn, 404)
  68     end
  69   end
  70
  71   describe "/inbox" do
  72     test "it inserts an incoming activity into the database", %{conn: conn} do
  73       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
  74
  75       conn =
  76         conn
  77         |> assign(:valid_signature, true)
  78         |> put_req_header("content-type", "application/activity+json")
  79         |> post("/inbox", data)
  80
  81       assert "ok" == json_response(conn, 200)
  82       :timer.sleep(500)
  83       assert Activity.get_by_ap_id(data["id"])
  84     end
  85   end
  86
  87   describe "/users/:nickname/inbox" do
  88     test "it inserts an incoming activity into the database", %{conn: conn} do
  89       user = insert(:user)
  90
  91       data =
  92         File.read!("test/fixtures/mastodon-post-activity.json")
  93         |> Poison.decode!()
  94         |> Map.put("bcc", [user.ap_id])
  95
  96       conn =
  97         conn
  98         |> assign(:valid_signature, true)
  99         |> put_req_header("content-type", "application/activity+json")
 100         |> post("/users/#{user.nickname}/inbox", data)
 101
 102       assert "ok" == json_response(conn, 200)
 103       :timer.sleep(500)
 104       assert Activity.get_by_ap_id(data["id"])
 105     end
 106   end
 107
 108   describe "/users/:nickname/outbox" do
 109     test "it returns a note activity in a collection", %{conn: conn} do
 110       note_activity = insert(:note_activity)
 111       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 112
 113       conn =
 114         conn
 115         |> put_req_header("accept", "application/activity+json")
 116         |> get("/users/#{user.nickname}/outbox")
 117
 118       assert response(conn, 200) =~ note_activity.data["object"]["content"]
 119     end
 120
 121     test "it returns an announce activity in a collection", %{conn: conn} do
 122       announce_activity = insert(:announce_activity)
 123       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 124
 125       conn =
 126         conn
 127         |> put_req_header("accept", "application/activity+json")
 128         |> get("/users/#{user.nickname}/outbox")
 129
 130       assert response(conn, 200) =~ announce_activity.data["object"]
 131     end
 132   end
 133
 134   describe "/users/:nickname/followers" do
 135     test "it returns the followers in a collection", %{conn: conn} do
 136       user = insert(:user)
 137       user_two = insert(:user)
 138       User.follow(user, user_two)
 139
 140       result =
 141         conn
 142         |> get("/users/#{user_two.nickname}/followers")
 143         |> json_response(200)
 144
 145       assert result["first"]["orderedItems"] == [user.ap_id]
 146     end
 147
 148     test "it works for more than 10 users", %{conn: conn} do
 149       user = insert(:user)
 150
 151       Enum.each(1..15, fn _ ->
 152         other_user = insert(:user)
 153         User.follow(other_user, user)
 154       end)
 155
 156       result =
 157         conn
 158         |> get("/users/#{user.nickname}/followers")
 159         |> json_response(200)
 160
 161       assert length(result["first"]["orderedItems"]) == 10
 162       assert result["first"]["totalItems"] == 15
 163       assert result["totalItems"] == 15
 164
 165       result =
 166         conn
 167         |> get("/users/#{user.nickname}/followers?page=2")
 168         |> json_response(200)
 169
 170       assert length(result["orderedItems"]) == 5
 171       assert result["totalItems"] == 15
 172     end
 173   end
 174
 175   describe "/users/:nickname/following" do
 176     test "it returns the following in a collection", %{conn: conn} do
 177       user = insert(:user)
 178       user_two = insert(:user)
 179       User.follow(user, user_two)
 180
 181       result =
 182         conn
 183         |> get("/users/#{user.nickname}/following")
 184         |> json_response(200)
 185
 186       assert result["first"]["orderedItems"] == [user_two.ap_id]
 187     end
 188
 189     test "it works for more than 10 users", %{conn: conn} do
 190       user = insert(:user)
 191
 192       Enum.each(1..15, fn _ ->
 193         user = Repo.get(User, user.id)
 194         other_user = insert(:user)
 195         User.follow(user, other_user)
 196       end)
 197
 198       result =
 199         conn
 200         |> get("/users/#{user.nickname}/following")
 201         |> json_response(200)
 202
 203       assert length(result["first"]["orderedItems"]) == 10
 204       assert result["first"]["totalItems"] == 15
 205       assert result["totalItems"] == 15
 206
 207       result =
 208         conn
 209         |> get("/users/#{user.nickname}/following?page=2")
 210         |> json_response(200)
 211
 212       assert length(result["orderedItems"]) == 5
 213       assert result["totalItems"] == 15
 214     end
 215   end
 216 end