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