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 returns a note activity in a collection", %{conn: conn} do
 369       note_activity = insert(:direct_note_activity)
 370       note_object = Object.normalize(note_activity)
 371       user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))
 372
 373       conn =
 374         conn
 375         |> assign(:user, user)
 376         |> put_req_header("accept", "application/activity+json")
 377         |> get("/users/#{user.nickname}/inbox")
 378
 379       assert response(conn, 200) =~ note_object.data["content"]
 380     end
 381
 382     test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
 383       user = insert(:user)
 384       data = Map.put(data, "bcc", [user.ap_id])
 385
 386       sender_host = URI.parse(data["actor"]).host
 387       Instances.set_consistently_unreachable(sender_host)
 388       refute Instances.reachable?(sender_host)
 389
 390       conn =
 391         conn
 392         |> assign(:valid_signature, true)
 393         |> put_req_header("content-type", "application/activity+json")
 394         |> post("/users/#{user.nickname}/inbox", data)
 395
 396       assert "ok" == json_response(conn, 200)
 397       assert Instances.reachable?(sender_host)
 398     end
 399
 400     test "it removes all follower collections but actor's", %{conn: conn} do
 401       [actor, recipient] = insert_pair(:user)
 402
 403       data =
 404         File.read!("test/fixtures/activitypub-client-post-activity.json")
 405         |> Poison.decode!()
 406
 407       object = Map.put(data["object"], "attributedTo", actor.ap_id)
 408
 409       data =
 410         data
 411         |> Map.put("id", Utils.generate_object_id())
 412         |> Map.put("actor", actor.ap_id)
 413         |> Map.put("object", object)
 414         |> Map.put("cc", [
 415           recipient.follower_address,
 416           actor.follower_address
 417         ])
 418         |> Map.put("to", [
 419           recipient.ap_id,
 420           recipient.follower_address,
 421           "https://www.w3.org/ns/activitystreams#Public"
 422         ])
 423
 424       conn
 425       |> assign(:valid_signature, true)
 426       |> put_req_header("content-type", "application/activity+json")
 427       |> post("/users/#{recipient.nickname}/inbox", data)
 428       |> json_response(200)
 429
 430       activity = Activity.get_by_ap_id(data["id"])
 431
 432       assert activity.id
 433       assert actor.follower_address in activity.recipients
 434       assert actor.follower_address in activity.data["cc"]
 435
 436       refute recipient.follower_address in activity.recipients
 437       refute recipient.follower_address in activity.data["cc"]
 438       refute recipient.follower_address in activity.data["to"]
 439     end
 440   end
 441
 442   describe "/users/:nickname/outbox" do
 443     test "it will not bomb when there is no activity", %{conn: conn} do
 444       user = insert(:user)
 445
 446       conn =
 447         conn
 448         |> put_req_header("accept", "application/activity+json")
 449         |> get("/users/#{user.nickname}/outbox")
 450
 451       result = json_response(conn, 200)
 452       assert user.ap_id <> "/outbox" == result["id"]
 453     end
 454
 455     test "it returns a note activity in a collection", %{conn: conn} do
 456       note_activity = insert(:note_activity)
 457       note_object = Object.normalize(note_activity)
 458       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 459
 460       conn =
 461         conn
 462         |> put_req_header("accept", "application/activity+json")
 463         |> get("/users/#{user.nickname}/outbox")
 464
 465       assert response(conn, 200) =~ note_object.data["content"]
 466     end
 467
 468     test "it returns an announce activity in a collection", %{conn: conn} do
 469       announce_activity = insert(:announce_activity)
 470       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 471
 472       conn =
 473         conn
 474         |> put_req_header("accept", "application/activity+json")
 475         |> get("/users/#{user.nickname}/outbox")
 476
 477       assert response(conn, 200) =~ announce_activity.data["object"]
 478     end
 479
 480     test "it rejects posts from other users", %{conn: conn} do
 481       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 482       user = insert(:user)
 483       otheruser = insert(:user)
 484
 485       conn =
 486         conn
 487         |> assign(:user, otheruser)
 488         |> put_req_header("content-type", "application/activity+json")
 489         |> post("/users/#{user.nickname}/outbox", data)
 490
 491       assert json_response(conn, 403)
 492     end
 493
 494     test "it inserts an incoming create activity into the database", %{conn: conn} do
 495       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 496       user = insert(:user)
 497
 498       conn =
 499         conn
 500         |> assign(:user, user)
 501         |> put_req_header("content-type", "application/activity+json")
 502         |> post("/users/#{user.nickname}/outbox", data)
 503
 504       result = json_response(conn, 201)
 505       assert Activity.get_by_ap_id(result["id"])
 506     end
 507
 508     test "it rejects an incoming activity with bogus type", %{conn: conn} do
 509       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 510       user = insert(:user)
 511
 512       data =
 513         data
 514         |> Map.put("type", "BadType")
 515
 516       conn =
 517         conn
 518         |> assign(:user, user)
 519         |> put_req_header("content-type", "application/activity+json")
 520         |> post("/users/#{user.nickname}/outbox", data)
 521
 522       assert json_response(conn, 400)
 523     end
 524
 525     test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
 526       note_activity = insert(:note_activity)
 527       note_object = Object.normalize(note_activity)
 528       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 529
 530       data = %{
 531         type: "Delete",
 532         object: %{
 533           id: note_object.data["id"]
 534         }
 535       }
 536
 537       conn =
 538         conn
 539         |> assign(:user, user)
 540         |> put_req_header("content-type", "application/activity+json")
 541         |> post("/users/#{user.nickname}/outbox", data)
 542
 543       result = json_response(conn, 201)
 544       assert Activity.get_by_ap_id(result["id"])
 545
 546       assert object = Object.get_by_ap_id(note_object.data["id"])
 547       assert object.data["type"] == "Tombstone"
 548     end
 549
 550     test "it rejects delete activity of object from other actor", %{conn: conn} do
 551       note_activity = insert(:note_activity)
 552       note_object = Object.normalize(note_activity)
 553       user = insert(:user)
 554
 555       data = %{
 556         type: "Delete",
 557         object: %{
 558           id: note_object.data["id"]
 559         }
 560       }
 561
 562       conn =
 563         conn
 564         |> assign(:user, user)
 565         |> put_req_header("content-type", "application/activity+json")
 566         |> post("/users/#{user.nickname}/outbox", data)
 567
 568       assert json_response(conn, 400)
 569     end
 570
 571     test "it increases like count when receiving a like action", %{conn: conn} do
 572       note_activity = insert(:note_activity)
 573       note_object = Object.normalize(note_activity)
 574       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 575
 576       data = %{
 577         type: "Like",
 578         object: %{
 579           id: note_object.data["id"]
 580         }
 581       }
 582
 583       conn =
 584         conn
 585         |> assign(:user, user)
 586         |> put_req_header("content-type", "application/activity+json")
 587         |> post("/users/#{user.nickname}/outbox", data)
 588
 589       result = json_response(conn, 201)
 590       assert Activity.get_by_ap_id(result["id"])
 591
 592       assert object = Object.get_by_ap_id(note_object.data["id"])
 593       assert object.data["like_count"] == 1
 594     end
 595   end
 596
 597   describe "/relay/followers" do
 598     test "it returns relay followers", %{conn: conn} do
 599       relay_actor = Relay.get_actor()
 600       user = insert(:user)
 601       User.follow(user, relay_actor)
 602
 603       result =
 604         conn
 605         |> assign(:relay, true)
 606         |> get("/relay/followers")
 607         |> json_response(200)
 608
 609       assert result["first"]["orderedItems"] == [user.ap_id]
 610     end
 611   end
 612
 613   describe "/relay/following" do
 614     test "it returns relay following", %{conn: conn} do
 615       result =
 616         conn
 617         |> assign(:relay, true)
 618         |> get("/relay/following")
 619         |> json_response(200)
 620
 621       assert result["first"]["orderedItems"] == []
 622     end
 623   end
 624
 625   describe "/users/:nickname/followers" do
 626     test "it returns the followers in a collection", %{conn: conn} do
 627       user = insert(:user)
 628       user_two = insert(:user)
 629       User.follow(user, user_two)
 630
 631       result =
 632         conn
 633         |> get("/users/#{user_two.nickname}/followers")
 634         |> json_response(200)
 635
 636       assert result["first"]["orderedItems"] == [user.ap_id]
 637     end
 638
 639     test "it returns returns a uri if the user has 'hide_followers' set", %{conn: conn} do
 640       user = insert(:user)
 641       user_two = insert(:user, %{info: %{hide_followers: true}})
 642       User.follow(user, user_two)
 643
 644       result =
 645         conn
 646         |> get("/users/#{user_two.nickname}/followers")
 647         |> json_response(200)
 648
 649       assert is_binary(result["first"])
 650     end
 651
 652     test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is not authenticated",
 653          %{conn: conn} do
 654       user = insert(:user, %{info: %{hide_followers: true}})
 655
 656       result =
 657         conn
 658         |> get("/users/#{user.nickname}/followers?page=1")
 659
 660       assert result.status == 403
 661       assert result.resp_body == ""
 662     end
 663
 664     test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
 665          %{conn: conn} do
 666       user = insert(:user, %{info: %{hide_followers: true}})
 667       other_user = insert(:user)
 668       {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
 669
 670       result =
 671         conn
 672         |> assign(:user, user)
 673         |> get("/users/#{user.nickname}/followers?page=1")
 674         |> json_response(200)
 675
 676       assert result["totalItems"] == 1
 677       assert result["orderedItems"] == [other_user.ap_id]
 678     end
 679
 680     test "it works for more than 10 users", %{conn: conn} do
 681       user = insert(:user)
 682
 683       Enum.each(1..15, fn _ ->
 684         other_user = insert(:user)
 685         User.follow(other_user, user)
 686       end)
 687
 688       result =
 689         conn
 690         |> get("/users/#{user.nickname}/followers")
 691         |> json_response(200)
 692
 693       assert length(result["first"]["orderedItems"]) == 10
 694       assert result["first"]["totalItems"] == 15
 695       assert result["totalItems"] == 15
 696
 697       result =
 698         conn
 699         |> get("/users/#{user.nickname}/followers?page=2")
 700         |> json_response(200)
 701
 702       assert length(result["orderedItems"]) == 5
 703       assert result["totalItems"] == 15
 704     end
 705   end
 706
 707   describe "/users/:nickname/following" do
 708     test "it returns the following in a collection", %{conn: conn} do
 709       user = insert(:user)
 710       user_two = insert(:user)
 711       User.follow(user, user_two)
 712
 713       result =
 714         conn
 715         |> get("/users/#{user.nickname}/following")
 716         |> json_response(200)
 717
 718       assert result["first"]["orderedItems"] == [user_two.ap_id]
 719     end
 720
 721     test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
 722       user = insert(:user, %{info: %{hide_follows: true}})
 723       user_two = insert(:user)
 724       User.follow(user, user_two)
 725
 726       result =
 727         conn
 728         |> get("/users/#{user.nickname}/following")
 729         |> json_response(200)
 730
 731       assert is_binary(result["first"])
 732     end
 733
 734     test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is not authenticated",
 735          %{conn: conn} do
 736       user = insert(:user, %{info: %{hide_follows: true}})
 737
 738       result =
 739         conn
 740         |> get("/users/#{user.nickname}/following?page=1")
 741
 742       assert result.status == 403
 743       assert result.resp_body == ""
 744     end
 745
 746     test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
 747          %{conn: conn} do
 748       user = insert(:user, %{info: %{hide_follows: true}})
 749       other_user = insert(:user)
 750       {:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
 751
 752       result =
 753         conn
 754         |> assign(:user, user)
 755         |> get("/users/#{user.nickname}/following?page=1")
 756         |> json_response(200)
 757
 758       assert result["totalItems"] == 1
 759       assert result["orderedItems"] == [other_user.ap_id]
 760     end
 761
 762     test "it works for more than 10 users", %{conn: conn} do
 763       user = insert(:user)
 764
 765       Enum.each(1..15, fn _ ->
 766         user = User.get_cached_by_id(user.id)
 767         other_user = insert(:user)
 768         User.follow(user, other_user)
 769       end)
 770
 771       result =
 772         conn
 773         |> get("/users/#{user.nickname}/following")
 774         |> json_response(200)
 775
 776       assert length(result["first"]["orderedItems"]) == 10
 777       assert result["first"]["totalItems"] == 15
 778       assert result["totalItems"] == 15
 779
 780       result =
 781         conn
 782         |> get("/users/#{user.nickname}/following?page=2")
 783         |> json_response(200)
 784
 785       assert length(result["orderedItems"]) == 5
 786       assert result["totalItems"] == 15
 787     end
 788   end
 789 end