1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
6 use Pleroma.Web.ConnCase
9 alias Pleroma.Instances
12 alias Pleroma.Web.ActivityPub.ObjectView
13 alias Pleroma.Web.ActivityPub.UserView
14 alias Pleroma.Web.ActivityPub.Utils
17 Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
19 config_path = [:instance, :federating]
20 initial_setting = Pleroma.Config.get(config_path)
22 Pleroma.Config.put(config_path, true)
23 on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
29 test "with the relay active, it returns the relay user", %{conn: conn} do
32 |> get(activity_pub_path(conn, :relay))
35 assert res["id"] =~ "/relay"
38 test "with the relay disabled, it returns 404", %{conn: conn} do
39 Pleroma.Config.put([:instance, :allow_relay], false)
42 |> get(activity_pub_path(conn, :relay))
46 Pleroma.Config.put([:instance, :allow_relay], true)
50 describe "/users/:nickname" do
51 test "it returns a json representation of the user with accept application/json", %{
58 |> put_req_header("accept", "application/json")
59 |> get("/users/#{user.nickname}")
61 user = User.get_cached_by_id(user.id)
63 assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
66 test "it returns a json representation of the user with accept application/activity+json", %{
73 |> put_req_header("accept", "application/activity+json")
74 |> get("/users/#{user.nickname}")
76 user = User.get_cached_by_id(user.id)
78 assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
81 test "it returns a json representation of the user with accept application/ld+json", %{
90 "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
92 |> get("/users/#{user.nickname}")
94 user = User.get_cached_by_id(user.id)
96 assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
100 describe "/object/:uuid" do
101 test "it returns a json representation of the object with accept application/json", %{
105 uuid = String.split(note.data["id"], "/") |> List.last()
109 |> put_req_header("accept", "application/json")
110 |> get("/objects/#{uuid}")
112 assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
115 test "it returns a json representation of the object with accept application/activity+json",
118 uuid = String.split(note.data["id"], "/") |> List.last()
122 |> put_req_header("accept", "application/activity+json")
123 |> get("/objects/#{uuid}")
125 assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
128 test "it returns a json representation of the object with accept application/ld+json", %{
132 uuid = String.split(note.data["id"], "/") |> List.last()
138 "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
140 |> get("/objects/#{uuid}")
142 assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
145 test "it returns 404 for non-public messages", %{conn: conn} do
146 note = insert(:direct_note)
147 uuid = String.split(note.data["id"], "/") |> List.last()
151 |> put_req_header("accept", "application/activity+json")
152 |> get("/objects/#{uuid}")
154 assert json_response(conn, 404)
157 test "it returns 404 for tombstone objects", %{conn: conn} do
158 tombstone = insert(:tombstone)
159 uuid = String.split(tombstone.data["id"], "/") |> List.last()
163 |> put_req_header("accept", "application/activity+json")
164 |> get("/objects/#{uuid}")
166 assert json_response(conn, 404)
170 describe "/object/:uuid/likes" do
171 test "it returns the like activities in a collection", %{conn: conn} do
172 like = insert(:like_activity)
173 like_object_ap_id = Object.normalize(like).data["id"]
174 uuid = String.split(like_object_ap_id, "/") |> List.last()
178 |> put_req_header("accept", "application/activity+json")
179 |> get("/objects/#{uuid}/likes")
180 |> json_response(200)
182 assert List.first(result["first"]["orderedItems"])["id"] == like.data["id"]
186 describe "/activities/:uuid" do
187 test "it returns a json representation of the activity", %{conn: conn} do
188 activity = insert(:note_activity)
189 uuid = String.split(activity.data["id"], "/") |> List.last()
193 |> put_req_header("accept", "application/activity+json")
194 |> get("/activities/#{uuid}")
196 assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
199 test "it returns 404 for non-public activities", %{conn: conn} do
200 activity = insert(:direct_note_activity)
201 uuid = String.split(activity.data["id"], "/") |> List.last()
205 |> put_req_header("accept", "application/activity+json")
206 |> get("/activities/#{uuid}")
208 assert json_response(conn, 404)
213 test "it inserts an incoming activity into the database", %{conn: conn} do
214 data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
218 |> assign(:valid_signature, true)
219 |> put_req_header("content-type", "application/activity+json")
220 |> post("/inbox", data)
222 assert "ok" == json_response(conn, 200)
224 assert Activity.get_by_ap_id(data["id"])
227 test "it clears `unreachable` federation status of the sender", %{conn: conn} do
228 data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
230 sender_url = data["actor"]
231 Instances.set_consistently_unreachable(sender_url)
232 refute Instances.reachable?(sender_url)
236 |> assign(:valid_signature, true)
237 |> put_req_header("content-type", "application/activity+json")
238 |> post("/inbox", data)
240 assert "ok" == json_response(conn, 200)
241 assert Instances.reachable?(sender_url)
245 describe "/users/:nickname/inbox" do
248 File.read!("test/fixtures/mastodon-post-activity.json")
254 test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
256 data = Map.put(data, "bcc", [user.ap_id])
260 |> assign(:valid_signature, true)
261 |> put_req_header("content-type", "application/activity+json")
262 |> post("/users/#{user.nickname}/inbox", data)
264 assert "ok" == json_response(conn, 200)
266 assert Activity.get_by_ap_id(data["id"])
269 test "it accepts messages from actors that are followed by the user", %{
273 recipient = insert(:user)
274 actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})
276 {:ok, recipient} = User.follow(recipient, actor)
280 |> Map.put("attributedTo", actor.ap_id)
284 |> Map.put("actor", actor.ap_id)
285 |> Map.put("object", object)
289 |> assign(:valid_signature, true)
290 |> put_req_header("content-type", "application/activity+json")
291 |> post("/users/#{recipient.nickname}/inbox", data)
293 assert "ok" == json_response(conn, 200)
295 assert Activity.get_by_ap_id(data["id"])
298 test "it rejects reads from other users", %{conn: conn} do
300 otheruser = insert(:user)
304 |> assign(:user, otheruser)
305 |> put_req_header("accept", "application/activity+json")
306 |> get("/users/#{user.nickname}/inbox")
308 assert json_response(conn, 403)
311 test "it returns a note activity in a collection", %{conn: conn} do
312 note_activity = insert(:direct_note_activity)
313 note_object = Object.normalize(note_activity)
314 user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))
318 |> assign(:user, user)
319 |> put_req_header("accept", "application/activity+json")
320 |> get("/users/#{user.nickname}/inbox")
322 assert response(conn, 200) =~ note_object.data["content"]
325 test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
327 data = Map.put(data, "bcc", [user.ap_id])
329 sender_host = URI.parse(data["actor"]).host
330 Instances.set_consistently_unreachable(sender_host)
331 refute Instances.reachable?(sender_host)
335 |> assign(:valid_signature, true)
336 |> put_req_header("content-type", "application/activity+json")
337 |> post("/users/#{user.nickname}/inbox", data)
339 assert "ok" == json_response(conn, 200)
340 assert Instances.reachable?(sender_host)
343 test "it removes all follower collections but actor's", %{conn: conn} do
344 [actor, recipient] = insert_pair(:user)
347 File.read!("test/fixtures/activitypub-client-post-activity.json")
350 object = Map.put(data["object"], "attributedTo", actor.ap_id)
354 |> Map.put("id", Utils.generate_object_id())
355 |> Map.put("actor", actor.ap_id)
356 |> Map.put("object", object)
358 recipient.follower_address,
359 actor.follower_address
363 recipient.follower_address,
364 "https://www.w3.org/ns/activitystreams#Public"
368 |> assign(:valid_signature, true)
369 |> put_req_header("content-type", "application/activity+json")
370 |> post("/users/#{recipient.nickname}/inbox", data)
371 |> json_response(200)
373 activity = Activity.get_by_ap_id(data["id"])
376 assert actor.follower_address in activity.recipients
377 assert actor.follower_address in activity.data["cc"]
379 refute recipient.follower_address in activity.recipients
380 refute recipient.follower_address in activity.data["cc"]
381 refute recipient.follower_address in activity.data["to"]
385 describe "/users/:nickname/outbox" do
386 test "it will not bomb when there is no activity", %{conn: conn} do
391 |> put_req_header("accept", "application/activity+json")
392 |> get("/users/#{user.nickname}/outbox")
394 result = json_response(conn, 200)
395 assert user.ap_id <> "/outbox" == result["id"]
398 test "it returns a note activity in a collection", %{conn: conn} do
399 note_activity = insert(:note_activity)
400 note_object = Object.normalize(note_activity)
401 user = User.get_cached_by_ap_id(note_activity.data["actor"])
405 |> put_req_header("accept", "application/activity+json")
406 |> get("/users/#{user.nickname}/outbox")
408 assert response(conn, 200) =~ note_object.data["content"]
411 test "it returns an announce activity in a collection", %{conn: conn} do
412 announce_activity = insert(:announce_activity)
413 user = User.get_cached_by_ap_id(announce_activity.data["actor"])
417 |> put_req_header("accept", "application/activity+json")
418 |> get("/users/#{user.nickname}/outbox")
420 assert response(conn, 200) =~ announce_activity.data["object"]
423 test "it rejects posts from other users", %{conn: conn} do
424 data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
426 otheruser = insert(:user)
430 |> assign(:user, otheruser)
431 |> put_req_header("content-type", "application/activity+json")
432 |> post("/users/#{user.nickname}/outbox", data)
434 assert json_response(conn, 403)
437 test "it inserts an incoming create activity into the database", %{conn: conn} do
438 data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
443 |> assign(:user, user)
444 |> put_req_header("content-type", "application/activity+json")
445 |> post("/users/#{user.nickname}/outbox", data)
447 result = json_response(conn, 201)
448 assert Activity.get_by_ap_id(result["id"])
451 test "it rejects an incoming activity with bogus type", %{conn: conn} do
452 data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
457 |> Map.put("type", "BadType")
461 |> assign(:user, user)
462 |> put_req_header("content-type", "application/activity+json")
463 |> post("/users/#{user.nickname}/outbox", data)
465 assert json_response(conn, 400)
468 test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
469 note_activity = insert(:note_activity)
470 note_object = Object.normalize(note_activity)
471 user = User.get_cached_by_ap_id(note_activity.data["actor"])
476 id: note_object.data["id"]
482 |> assign(:user, user)
483 |> put_req_header("content-type", "application/activity+json")
484 |> post("/users/#{user.nickname}/outbox", data)
486 result = json_response(conn, 201)
487 assert Activity.get_by_ap_id(result["id"])
489 assert object = Object.get_by_ap_id(note_object.data["id"])
490 assert object.data["type"] == "Tombstone"
493 test "it rejects delete activity of object from other actor", %{conn: conn} do
494 note_activity = insert(:note_activity)
495 note_object = Object.normalize(note_activity)
501 id: note_object.data["id"]
507 |> assign(:user, user)
508 |> put_req_header("content-type", "application/activity+json")
509 |> post("/users/#{user.nickname}/outbox", data)
511 assert json_response(conn, 400)
514 test "it increases like count when receiving a like action", %{conn: conn} do
515 note_activity = insert(:note_activity)
516 note_object = Object.normalize(note_activity)
517 user = User.get_cached_by_ap_id(note_activity.data["actor"])
522 id: note_object.data["id"]
528 |> assign(:user, user)
529 |> put_req_header("content-type", "application/activity+json")
530 |> post("/users/#{user.nickname}/outbox", data)
532 result = json_response(conn, 201)
533 assert Activity.get_by_ap_id(result["id"])
535 assert object = Object.get_by_ap_id(note_object.data["id"])
536 assert object.data["like_count"] == 1
540 describe "/users/:nickname/followers" do
541 test "it returns the followers in a collection", %{conn: conn} do
543 user_two = insert(:user)
544 User.follow(user, user_two)
548 |> get("/users/#{user_two.nickname}/followers")
549 |> json_response(200)
551 assert result["first"]["orderedItems"] == [user.ap_id]
554 test "it returns returns empty if the user has 'hide_followers' set", %{conn: conn} do
556 user_two = insert(:user, %{info: %{hide_followers: true}})
557 User.follow(user, user_two)
561 |> get("/users/#{user_two.nickname}/followers")
562 |> json_response(200)
564 assert result["first"]["orderedItems"] == []
565 assert result["totalItems"] == 0
568 test "it works for more than 10 users", %{conn: conn} do
571 Enum.each(1..15, fn _ ->
572 other_user = insert(:user)
573 User.follow(other_user, user)
578 |> get("/users/#{user.nickname}/followers")
579 |> json_response(200)
581 assert length(result["first"]["orderedItems"]) == 10
582 assert result["first"]["totalItems"] == 15
583 assert result["totalItems"] == 15
587 |> get("/users/#{user.nickname}/followers?page=2")
588 |> json_response(200)
590 assert length(result["orderedItems"]) == 5
591 assert result["totalItems"] == 15
595 describe "/users/:nickname/following" do
596 test "it returns the following in a collection", %{conn: conn} do
598 user_two = insert(:user)
599 User.follow(user, user_two)
603 |> get("/users/#{user.nickname}/following")
604 |> json_response(200)
606 assert result["first"]["orderedItems"] == [user_two.ap_id]
609 test "it returns returns empty if the user has 'hide_follows' set", %{conn: conn} do
610 user = insert(:user, %{info: %{hide_follows: true}})
611 user_two = insert(:user)
612 User.follow(user, user_two)
616 |> get("/users/#{user.nickname}/following")
617 |> json_response(200)
619 assert result["first"]["orderedItems"] == []
620 assert result["totalItems"] == 0
623 test "it works for more than 10 users", %{conn: conn} do
626 Enum.each(1..15, fn _ ->
627 user = User.get_cached_by_id(user.id)
628 other_user = insert(:user)
629 User.follow(user, other_user)
634 |> get("/users/#{user.nickname}/following")
635 |> json_response(200)
637 assert length(result["first"]["orderedItems"]) == 10
638 assert result["first"]["totalItems"] == 15
639 assert result["totalItems"] == 15
643 |> get("/users/#{user.nickname}/following?page=2")
644 |> json_response(200)
646 assert length(result["orderedItems"]) == 5
647 assert result["totalItems"] == 15