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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
   6   use Pleroma.Web.ConnCase
   7   import Pleroma.Factory
   8   alias Pleroma.Activity
   9   alias Pleroma.Instances
  10   alias Pleroma.Object
  11   alias Pleroma.User
  12   alias Pleroma.Web.ActivityPub.ObjectView
  13   alias Pleroma.Web.ActivityPub.Relay
  14   alias Pleroma.Web.ActivityPub.UserView
  15   alias Pleroma.Web.ActivityPub.Utils
  16   alias Pleroma.Web.CommonAPI
  17
  18   setup_all do
  19     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  20     :ok
  21   end
  22
  23   clear_config_all([:instance, :federating],
  24     do: Pleroma.Config.put([:instance, :federating], true)
  25   )
  26
  27   describe "/relay" do
  28     clear_config([:instance, :allow_relay])
  29
  30     test "with the relay active, it returns the relay user", %{conn: conn} do
  31       res =
  32         conn
  33         |> get(activity_pub_path(conn, :relay))
  34         |> json_response(200)
  35
  36       assert res["id"] =~ "/relay"
  37     end
  38
  39     test "with the relay disabled, it returns 404", %{conn: conn} do
  40       Pleroma.Config.put([:instance, :allow_relay], false)
  41
  42       conn
  43       |> get(activity_pub_path(conn, :relay))
  44       |> json_response(404)
  45       |> assert
  46     end
  47   end
  48
  49   describe "/internal/fetch" do
  50     test "it returns the internal fetch user", %{conn: conn} do
  51       res =
  52         conn
  53         |> get(activity_pub_path(conn, :internal_fetch))
  54         |> json_response(200)
  55
  56       assert res["id"] =~ "/fetch"
  57     end
  58   end
  59
  60   describe "/users/:nickname" do
  61     test "it returns a json representation of the user with accept application/json", %{
  62       conn: conn
  63     } do
  64       user = insert(:user)
  65
  66       conn =
  67         conn
  68         |> put_req_header("accept", "application/json")
  69         |> get("/users/#{user.nickname}")
  70
  71       user = User.get_cached_by_id(user.id)
  72
  73       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
  74     end
  75
  76     test "it returns a json representation of the user with accept application/activity+json", %{
  77       conn: conn
  78     } do
  79       user = insert(:user)
  80
  81       conn =
  82         conn
  83         |> put_req_header("accept", "application/activity+json")
  84         |> get("/users/#{user.nickname}")
  85
  86       user = User.get_cached_by_id(user.id)
  87
  88       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
  89     end
  90
  91     test "it returns a json representation of the user with accept application/ld+json", %{
  92       conn: conn
  93     } do
  94       user = insert(:user)
  95
  96       conn =
  97         conn
  98         |> put_req_header(
  99           "accept",
 100           "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
 101         )
 102         |> get("/users/#{user.nickname}")
 103
 104       user = User.get_cached_by_id(user.id)
 105
 106       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
 107     end
 108   end
 109
 110   describe "/object/:uuid" do
 111     test "it returns a json representation of the object with accept application/json", %{
 112       conn: conn
 113     } do
 114       note = insert(:note)
 115       uuid = String.split(note.data["id"], "/") |> List.last()
 116
 117       conn =
 118         conn
 119         |> put_req_header("accept", "application/json")
 120         |> get("/objects/#{uuid}")
 121
 122       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
 123     end
 124
 125     test "it returns a json representation of the object with accept application/activity+json",
 126          %{conn: conn} do
 127       note = insert(:note)
 128       uuid = String.split(note.data["id"], "/") |> List.last()
 129
 130       conn =
 131         conn
 132         |> put_req_header("accept", "application/activity+json")
 133         |> get("/objects/#{uuid}")
 134
 135       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
 136     end
 137
 138     test "it returns a json representation of the object with accept application/ld+json", %{
 139       conn: conn
 140     } do
 141       note = insert(:note)
 142       uuid = String.split(note.data["id"], "/") |> List.last()
 143
 144       conn =
 145         conn
 146         |> put_req_header(
 147           "accept",
 148           "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
 149         )
 150         |> get("/objects/#{uuid}")
 151
 152       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
 153     end
 154
 155     test "it returns 404 for non-public messages", %{conn: conn} do
 156       note = insert(:direct_note)
 157       uuid = String.split(note.data["id"], "/") |> List.last()
 158
 159       conn =
 160         conn
 161         |> put_req_header("accept", "application/activity+json")
 162         |> get("/objects/#{uuid}")
 163
 164       assert json_response(conn, 404)
 165     end
 166
 167     test "it returns 404 for tombstone objects", %{conn: conn} do
 168       tombstone = insert(:tombstone)
 169       uuid = String.split(tombstone.data["id"], "/") |> List.last()
 170
 171       conn =
 172         conn
 173         |> put_req_header("accept", "application/activity+json")
 174         |> get("/objects/#{uuid}")
 175
 176       assert json_response(conn, 404)
 177     end
 178   end
 179
 180   describe "/object/:uuid/likes" do
 181     setup do
 182       like = insert(:like_activity)
 183       like_object_ap_id = Object.normalize(like).data["id"]
 184
 185       uuid =
 186         like_object_ap_id
 187         |> String.split("/")
 188         |> List.last()
 189
 190       [id: like.data["id"], uuid: uuid]
 191     end
 192
 193     test "it returns the like activities in a collection", %{conn: conn, id: id, uuid: uuid} do
 194       result =
 195         conn
 196         |> put_req_header("accept", "application/activity+json")
 197         |> get("/objects/#{uuid}/likes")
 198         |> json_response(200)
 199
 200       assert List.first(result["first"]["orderedItems"])["id"] == id
 201       assert result["type"] == "OrderedCollection"
 202       assert result["totalItems"] == 1
 203       refute result["first"]["next"]
 204     end
 205
 206     test "it does not crash when page number is exceeded total pages", %{conn: conn, uuid: uuid} do
 207       result =
 208         conn
 209         |> put_req_header("accept", "application/activity+json")
 210         |> get("/objects/#{uuid}/likes?page=2")
 211         |> json_response(200)
 212
 213       assert result["type"] == "OrderedCollectionPage"
 214       assert result["totalItems"] == 1
 215       refute result["next"]
 216       assert Enum.empty?(result["orderedItems"])
 217     end
 218
 219     test "it contains the next key when likes count is more than 10", %{conn: conn} do
 220       note = insert(:note_activity)
 221       insert_list(11, :like_activity, note_activity: note)
 222
 223       uuid =
 224         note
 225         |> Object.normalize()
 226         |> Map.get(:data)
 227         |> Map.get("id")
 228         |> String.split("/")
 229         |> List.last()
 230
 231       result =
 232         conn
 233         |> put_req_header("accept", "application/activity+json")
 234         |> get("/objects/#{uuid}/likes?page=1")
 235         |> json_response(200)
 236
 237       assert result["totalItems"] == 11
 238       assert length(result["orderedItems"]) == 10
 239       assert result["next"]
 240     end
 241   end
 242
 243   describe "/activities/:uuid" do
 244     test "it returns a json representation of the activity", %{conn: conn} do
 245       activity = insert(:note_activity)
 246       uuid = String.split(activity.data["id"], "/") |> List.last()
 247
 248       conn =
 249         conn
 250         |> put_req_header("accept", "application/activity+json")
 251         |> get("/activities/#{uuid}")
 252
 253       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
 254     end
 255
 256     test "it returns 404 for non-public activities", %{conn: conn} do
 257       activity = insert(:direct_note_activity)
 258       uuid = String.split(activity.data["id"], "/") |> List.last()
 259
 260       conn =
 261         conn
 262         |> put_req_header("accept", "application/activity+json")
 263         |> get("/activities/#{uuid}")
 264
 265       assert json_response(conn, 404)
 266     end
 267   end
 268
 269   describe "/inbox" do
 270     test "it inserts an incoming activity into the database", %{conn: conn} do
 271       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 272
 273       conn =
 274         conn
 275         |> assign(:valid_signature, true)
 276         |> put_req_header("content-type", "application/activity+json")
 277         |> post("/inbox", data)
 278
 279       assert "ok" == json_response(conn, 200)
 280       :timer.sleep(500)
 281       assert Activity.get_by_ap_id(data["id"])
 282     end
 283
 284     test "it clears `unreachable` federation status of the sender", %{conn: conn} do
 285       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 286
 287       sender_url = data["actor"]
 288       Instances.set_consistently_unreachable(sender_url)
 289       refute Instances.reachable?(sender_url)
 290
 291       conn =
 292         conn
 293         |> assign(:valid_signature, true)
 294         |> put_req_header("content-type", "application/activity+json")
 295         |> post("/inbox", data)
 296
 297       assert "ok" == json_response(conn, 200)
 298       assert Instances.reachable?(sender_url)
 299     end
 300   end
 301
 302   describe "/users/:nickname/inbox" do
 303     setup do
 304       data =
 305         File.read!("test/fixtures/mastodon-post-activity.json")
 306         |> Poison.decode!()
 307
 308       [data: data]
 309     end
 310
 311     test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
 312       user = insert(:user)
 313       data = Map.put(data, "bcc", [user.ap_id])
 314
 315       conn =
 316         conn
 317         |> assign(:valid_signature, true)
 318         |> put_req_header("content-type", "application/activity+json")
 319         |> post("/users/#{user.nickname}/inbox", data)
 320
 321       assert "ok" == json_response(conn, 200)
 322       :timer.sleep(500)
 323       assert Activity.get_by_ap_id(data["id"])
 324     end
 325
 326     test "it accepts messages from actors that are followed by the user", %{
 327       conn: conn,
 328       data: data
 329     } do
 330       recipient = insert(:user)
 331       actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})
 332
 333       {:ok, recipient} = User.follow(recipient, actor)
 334
 335       object =
 336         data["object"]
 337         |> Map.put("attributedTo", actor.ap_id)
 338
 339       data =
 340         data
 341         |> Map.put("actor", actor.ap_id)
 342         |> Map.put("object", object)
 343
 344       conn =
 345         conn
 346         |> assign(:valid_signature, true)
 347         |> put_req_header("content-type", "application/activity+json")
 348         |> post("/users/#{recipient.nickname}/inbox", data)
 349
 350       assert "ok" == json_response(conn, 200)
 351       :timer.sleep(500)
 352       assert Activity.get_by_ap_id(data["id"])
 353     end
 354
 355     test "it rejects reads from other users", %{conn: conn} do
 356       user = insert(:user)
 357       otheruser = insert(:user)
 358
 359       conn =
 360         conn
 361         |> assign(:user, otheruser)
 362         |> put_req_header("accept", "application/activity+json")
 363         |> get("/users/#{user.nickname}/inbox")
 364
 365       assert json_response(conn, 403)
 366     end
 367
 368     test "it doesn't crash without an authenticated user", %{conn: conn} do
 369       user = insert(:user)
 370
 371       conn =
 372         conn
 373         |> put_req_header("accept", "application/activity+json")
 374         |> get("/users/#{user.nickname}/inbox")
 375
 376       assert json_response(conn, 403)
 377     end
 378
 379     test "it returns a note activity in a collection", %{conn: conn} do
 380       note_activity = insert(:direct_note_activity)
 381       note_object = Object.normalize(note_activity)
 382       user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))
 383
 384       conn =
 385         conn
 386         |> assign(:user, user)
 387         |> put_req_header("accept", "application/activity+json")
 388         |> get("/users/#{user.nickname}/inbox")
 389
 390       assert response(conn, 200) =~ note_object.data["content"]
 391     end
 392
 393     test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
 394       user = insert(:user)
 395       data = Map.put(data, "bcc", [user.ap_id])
 396
 397       sender_host = URI.parse(data["actor"]).host
 398       Instances.set_consistently_unreachable(sender_host)
 399       refute Instances.reachable?(sender_host)
 400
 401       conn =
 402         conn
 403         |> assign(:valid_signature, true)
 404         |> put_req_header("content-type", "application/activity+json")
 405         |> post("/users/#{user.nickname}/inbox", data)
 406
 407       assert "ok" == json_response(conn, 200)
 408       assert Instances.reachable?(sender_host)
 409     end
 410
 411     test "it removes all follower collections but actor's", %{conn: conn} do
 412       [actor, recipient] = insert_pair(:user)
 413
 414       data =
 415         File.read!("test/fixtures/activitypub-client-post-activity.json")
 416         |> Poison.decode!()
 417
 418       object = Map.put(data["object"], "attributedTo", actor.ap_id)
 419
 420       data =
 421         data
 422         |> Map.put("id", Utils.generate_object_id())
 423         |> Map.put("actor", actor.ap_id)
 424         |> Map.put("object", object)
 425         |> Map.put("cc", [
 426           recipient.follower_address,
 427           actor.follower_address
 428         ])
 429         |> Map.put("to", [
 430           recipient.ap_id,
 431           recipient.follower_address,
 432           "https://www.w3.org/ns/activitystreams#Public"
 433         ])
 434
 435       conn
 436       |> assign(:valid_signature, true)
 437       |> put_req_header("content-type", "application/activity+json")
 438       |> post("/users/#{recipient.nickname}/inbox", data)
 439       |> json_response(200)
 440
 441       activity = Activity.get_by_ap_id(data["id"])
 442
 443       assert activity.id
 444       assert actor.follower_address in activity.recipients
 445       assert actor.follower_address in activity.data["cc"]
 446
 447       refute recipient.follower_address in activity.recipients
 448       refute recipient.follower_address in activity.data["cc"]
 449       refute recipient.follower_address in activity.data["to"]
 450     end
 451   end
 452
 453   describe "/users/:nickname/outbox" do
 454     test "it will not bomb when there is no activity", %{conn: conn} do
 455       user = insert(:user)
 456
 457       conn =
 458         conn
 459         |> put_req_header("accept", "application/activity+json")
 460         |> get("/users/#{user.nickname}/outbox")
 461
 462       result = json_response(conn, 200)
 463       assert user.ap_id <> "/outbox" == result["id"]
 464     end
 465
 466     test "it returns a note activity in a collection", %{conn: conn} do
 467       note_activity = insert(:note_activity)
 468       note_object = Object.normalize(note_activity)
 469       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 470
 471       conn =
 472         conn
 473         |> put_req_header("accept", "application/activity+json")
 474         |> get("/users/#{user.nickname}/outbox")
 475
 476       assert response(conn, 200) =~ note_object.data["content"]
 477     end
 478
 479     test "it returns an announce activity in a collection", %{conn: conn} do
 480       announce_activity = insert(:announce_activity)
 481       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 482
 483       conn =
 484         conn
 485         |> put_req_header("accept", "application/activity+json")
 486         |> get("/users/#{user.nickname}/outbox")
 487
 488       assert response(conn, 200) =~ announce_activity.data["object"]
 489     end
 490
 491     test "it rejects posts from other users", %{conn: conn} do
 492       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 493       user = insert(:user)
 494       otheruser = insert(:user)
 495
 496       conn =
 497         conn
 498         |> assign(:user, otheruser)
 499         |> put_req_header("content-type", "application/activity+json")
 500         |> post("/users/#{user.nickname}/outbox", data)
 501
 502       assert json_response(conn, 403)
 503     end
 504
 505     test "it inserts an incoming create activity into the database", %{conn: conn} do
 506       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 507       user = insert(:user)
 508
 509       conn =
 510         conn
 511         |> assign(:user, user)
 512         |> put_req_header("content-type", "application/activity+json")
 513         |> post("/users/#{user.nickname}/outbox", data)
 514
 515       result = json_response(conn, 201)
 516       assert Activity.get_by_ap_id(result["id"])
 517     end
 518
 519     test "it rejects an incoming activity with bogus type", %{conn: conn} do
 520       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 521       user = insert(:user)
 522
 523       data =
 524         data
 525         |> Map.put("type", "BadType")
 526
 527       conn =
 528         conn
 529         |> assign(:user, user)
 530         |> put_req_header("content-type", "application/activity+json")
 531         |> post("/users/#{user.nickname}/outbox", data)
 532
 533       assert json_response(conn, 400)
 534     end
 535
 536     test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
 537       note_activity = insert(:note_activity)
 538       note_object = Object.normalize(note_activity)
 539       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 540
 541       data = %{
 542         type: "Delete",
 543         object: %{
 544           id: note_object.data["id"]
 545         }
 546       }
 547
 548       conn =
 549         conn
 550         |> assign(:user, user)
 551         |> put_req_header("content-type", "application/activity+json")
 552         |> post("/users/#{user.nickname}/outbox", data)
 553
 554       result = json_response(conn, 201)
 555       assert Activity.get_by_ap_id(result["id"])
 556
 557       assert object = Object.get_by_ap_id(note_object.data["id"])
 558       assert object.data["type"] == "Tombstone"
 559     end
 560
 561     test "it rejects delete activity of object from other actor", %{conn: conn} do
 562       note_activity = insert(:note_activity)
 563       note_object = Object.normalize(note_activity)
 564       user = insert(:user)
 565
 566       data = %{
 567         type: "Delete",
 568         object: %{
 569           id: note_object.data["id"]
 570         }
 571       }
 572
 573       conn =
 574         conn
 575         |> assign(:user, user)
 576         |> put_req_header("content-type", "application/activity+json")
 577         |> post("/users/#{user.nickname}/outbox", data)
 578
 579       assert json_response(conn, 400)
 580     end
 581
 582     test "it increases like count when receiving a like action", %{conn: conn} do
 583       note_activity = insert(:note_activity)
 584       note_object = Object.normalize(note_activity)
 585       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 586
 587       data = %{
 588         type: "Like",
 589         object: %{
 590           id: note_object.data["id"]
 591         }
 592       }
 593
 594       conn =
 595         conn
 596         |> assign(:user, user)
 597         |> put_req_header("content-type", "application/activity+json")
 598         |> post("/users/#{user.nickname}/outbox", data)
 599
 600       result = json_response(conn, 201)
 601       assert Activity.get_by_ap_id(result["id"])
 602
 603       assert object = Object.get_by_ap_id(note_object.data["id"])
 604       assert object.data["like_count"] == 1
 605     end
 606   end
 607
 608   describe "/relay/followers" do
 609     test "it returns relay followers", %{conn: conn} do
 610       relay_actor = Relay.get_actor()
 611       user = insert(:user)
 612       User.follow(user, relay_actor)
 613
 614       result =
 615         conn
 616         |> assign(:relay, true)
 617         |> get("/relay/followers")
 618         |> json_response(200)
 619
 620       assert result["first"]["orderedItems"] == [user.ap_id]
 621     end
 622   end
 623
 624   describe "/relay/following" do
 625     test "it returns relay following", %{conn: conn} do
 626       result =
 627         conn
 628         |> assign(:relay, true)
 629         |> get("/relay/following")
 630         |> json_response(200)
 631
 632       assert result["first"]["orderedItems"] == []
 633     end
 634   end
 635
 636   describe "/users/:nickname/followers" do
 637     test "it returns the followers in a collection", %{conn: conn} do
 638       user = insert(:user)
 639       user_two = insert(:user)
 640       User.follow(user, user_two)
 641
 642       result =
 643         conn
 644         |> get("/users/#{user_two.nickname}/followers")
 645         |> json_response(200)
 646
 647       assert result["first"]["orderedItems"] == [user.ap_id]
 648     end
 649
 650     test "it returns returns a uri if the user has 'hide_followers' set", %{conn: conn} do
 651       user = insert(:user)
 652       user_two = insert(:user, %{info: %{hide_followers: true}})
 653       User.follow(user, user_two)
 654
 655       result =
 656         conn
 657         |> get("/users/#{user_two.nickname}/followers")
 658         |> json_response(200)
 659
 660       assert is_binary(result["first"])
 661     end
 662
 663     test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is not authenticated",
 664          %{conn: conn} do
 665       user = insert(:user, %{info: %{hide_followers: true}})
 666
 667       result =
 668         conn
 669         |> get("/users/#{user.nickname}/followers?page=1")
 670
 671       assert result.status == 403
 672       assert result.resp_body == ""
 673     end
 674
 675     test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
 676          %{conn: conn} do
 677       user = insert(:user, %{info: %{hide_followers: true}})
 678       other_user = insert(:user)
 679       {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
 680
 681       result =
 682         conn
 683         |> assign(:user, user)
 684         |> get("/users/#{user.nickname}/followers?page=1")
 685         |> json_response(200)
 686
 687       assert result["totalItems"] == 1
 688       assert result["orderedItems"] == [other_user.ap_id]
 689     end
 690
 691     test "it works for more than 10 users", %{conn: conn} do
 692       user = insert(:user)
 693
 694       Enum.each(1..15, fn _ ->
 695         other_user = insert(:user)
 696         User.follow(other_user, user)
 697       end)
 698
 699       result =
 700         conn
 701         |> get("/users/#{user.nickname}/followers")
 702         |> json_response(200)
 703
 704       assert length(result["first"]["orderedItems"]) == 10
 705       assert result["first"]["totalItems"] == 15
 706       assert result["totalItems"] == 15
 707
 708       result =
 709         conn
 710         |> get("/users/#{user.nickname}/followers?page=2")
 711         |> json_response(200)
 712
 713       assert length(result["orderedItems"]) == 5
 714       assert result["totalItems"] == 15
 715     end
 716   end
 717
 718   describe "/users/:nickname/following" do
 719     test "it returns the following in a collection", %{conn: conn} do
 720       user = insert(:user)
 721       user_two = insert(:user)
 722       User.follow(user, user_two)
 723
 724       result =
 725         conn
 726         |> get("/users/#{user.nickname}/following")
 727         |> json_response(200)
 728
 729       assert result["first"]["orderedItems"] == [user_two.ap_id]
 730     end
 731
 732     test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
 733       user = insert(:user, %{info: %{hide_follows: true}})
 734       user_two = insert(:user)
 735       User.follow(user, user_two)
 736
 737       result =
 738         conn
 739         |> get("/users/#{user.nickname}/following")
 740         |> json_response(200)
 741
 742       assert is_binary(result["first"])
 743     end
 744
 745     test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is not authenticated",
 746          %{conn: conn} do
 747       user = insert(:user, %{info: %{hide_follows: true}})
 748
 749       result =
 750         conn
 751         |> get("/users/#{user.nickname}/following?page=1")
 752
 753       assert result.status == 403
 754       assert result.resp_body == ""
 755     end
 756
 757     test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
 758          %{conn: conn} do
 759       user = insert(:user, %{info: %{hide_follows: true}})
 760       other_user = insert(:user)
 761       {:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
 762
 763       result =
 764         conn
 765         |> assign(:user, user)
 766         |> get("/users/#{user.nickname}/following?page=1")
 767         |> json_response(200)
 768
 769       assert result["totalItems"] == 1
 770       assert result["orderedItems"] == [other_user.ap_id]
 771     end
 772
 773     test "it works for more than 10 users", %{conn: conn} do
 774       user = insert(:user)
 775
 776       Enum.each(1..15, fn _ ->
 777         user = User.get_cached_by_id(user.id)
 778         other_user = insert(:user)
 779         User.follow(user, other_user)
 780       end)
 781
 782       result =
 783         conn
 784         |> get("/users/#{user.nickname}/following")
 785         |> json_response(200)
 786
 787       assert length(result["first"]["orderedItems"]) == 10
 788       assert result["first"]["totalItems"] == 15
 789       assert result["totalItems"] == 15
 790
 791       result =
 792         conn
 793         |> get("/users/#{user.nickname}/following?page=2")
 794         |> json_response(200)
 795
 796       assert length(result["orderedItems"]) == 5
 797       assert result["totalItems"] == 15
 798     end
 799   end
 800 end