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
 179     test "it caches a response", %{conn: conn} do
 180       note = insert(:note)
 181       uuid = String.split(note.data["id"], "/") |> List.last()
 182
 183       conn1 =
 184         conn
 185         |> put_req_header("accept", "application/activity+json")
 186         |> get("/objects/#{uuid}")
 187
 188       assert json_response(conn1, :ok)
 189       assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))
 190
 191       conn2 =
 192         conn
 193         |> put_req_header("accept", "application/activity+json")
 194         |> get("/objects/#{uuid}")
 195
 196       assert json_response(conn1, :ok) == json_response(conn2, :ok)
 197       assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
 198     end
 199
 200     test "cached purged after object deletion", %{conn: conn} do
 201       note = insert(:note)
 202       uuid = String.split(note.data["id"], "/") |> List.last()
 203
 204       conn1 =
 205         conn
 206         |> put_req_header("accept", "application/activity+json")
 207         |> get("/objects/#{uuid}")
 208
 209       assert json_response(conn1, :ok)
 210       assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))
 211
 212       Object.delete(note)
 213
 214       conn2 =
 215         conn
 216         |> put_req_header("accept", "application/activity+json")
 217         |> get("/objects/#{uuid}")
 218
 219       assert "Not found" == json_response(conn2, :not_found)
 220     end
 221   end
 222
 223   describe "/activities/:uuid" do
 224     test "it returns a json representation of the activity", %{conn: conn} do
 225       activity = insert(:note_activity)
 226       uuid = String.split(activity.data["id"], "/") |> List.last()
 227
 228       conn =
 229         conn
 230         |> put_req_header("accept", "application/activity+json")
 231         |> get("/activities/#{uuid}")
 232
 233       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
 234     end
 235
 236     test "it returns 404 for non-public activities", %{conn: conn} do
 237       activity = insert(:direct_note_activity)
 238       uuid = String.split(activity.data["id"], "/") |> List.last()
 239
 240       conn =
 241         conn
 242         |> put_req_header("accept", "application/activity+json")
 243         |> get("/activities/#{uuid}")
 244
 245       assert json_response(conn, 404)
 246     end
 247
 248     test "it caches a response", %{conn: conn} do
 249       activity = insert(:note_activity)
 250       uuid = String.split(activity.data["id"], "/") |> List.last()
 251
 252       conn1 =
 253         conn
 254         |> put_req_header("accept", "application/activity+json")
 255         |> get("/activities/#{uuid}")
 256
 257       assert json_response(conn1, :ok)
 258       assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))
 259
 260       conn2 =
 261         conn
 262         |> put_req_header("accept", "application/activity+json")
 263         |> get("/activities/#{uuid}")
 264
 265       assert json_response(conn1, :ok) == json_response(conn2, :ok)
 266       assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
 267     end
 268
 269     test "cached purged after activity deletion", %{conn: conn} do
 270       user = insert(:user)
 271       {:ok, activity} = CommonAPI.post(user, %{"status" => "cofe"})
 272
 273       uuid = String.split(activity.data["id"], "/") |> List.last()
 274
 275       conn1 =
 276         conn
 277         |> put_req_header("accept", "application/activity+json")
 278         |> get("/activities/#{uuid}")
 279
 280       assert json_response(conn1, :ok)
 281       assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))
 282
 283       Activity.delete_by_ap_id(activity.object.data["id"])
 284
 285       conn2 =
 286         conn
 287         |> put_req_header("accept", "application/activity+json")
 288         |> get("/activities/#{uuid}")
 289
 290       assert "Not found" == json_response(conn2, :not_found)
 291     end
 292   end
 293
 294   describe "/inbox" do
 295     test "it inserts an incoming activity into the database", %{conn: conn} do
 296       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 297
 298       conn =
 299         conn
 300         |> assign(:valid_signature, true)
 301         |> put_req_header("content-type", "application/activity+json")
 302         |> post("/inbox", data)
 303
 304       assert "ok" == json_response(conn, 200)
 305       :timer.sleep(500)
 306       assert Activity.get_by_ap_id(data["id"])
 307     end
 308
 309     test "it clears `unreachable` federation status of the sender", %{conn: conn} do
 310       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 311
 312       sender_url = data["actor"]
 313       Instances.set_consistently_unreachable(sender_url)
 314       refute Instances.reachable?(sender_url)
 315
 316       conn =
 317         conn
 318         |> assign(:valid_signature, true)
 319         |> put_req_header("content-type", "application/activity+json")
 320         |> post("/inbox", data)
 321
 322       assert "ok" == json_response(conn, 200)
 323       assert Instances.reachable?(sender_url)
 324     end
 325   end
 326
 327   describe "/users/:nickname/inbox" do
 328     setup do
 329       data =
 330         File.read!("test/fixtures/mastodon-post-activity.json")
 331         |> Poison.decode!()
 332
 333       [data: data]
 334     end
 335
 336     test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
 337       user = insert(:user)
 338       data = Map.put(data, "bcc", [user.ap_id])
 339
 340       conn =
 341         conn
 342         |> assign(:valid_signature, true)
 343         |> put_req_header("content-type", "application/activity+json")
 344         |> post("/users/#{user.nickname}/inbox", data)
 345
 346       assert "ok" == json_response(conn, 200)
 347       :timer.sleep(500)
 348       assert Activity.get_by_ap_id(data["id"])
 349     end
 350
 351     test "it accepts messages from actors that are followed by the user", %{
 352       conn: conn,
 353       data: data
 354     } do
 355       recipient = insert(:user)
 356       actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})
 357
 358       {:ok, recipient} = User.follow(recipient, actor)
 359
 360       object =
 361         data["object"]
 362         |> Map.put("attributedTo", actor.ap_id)
 363
 364       data =
 365         data
 366         |> Map.put("actor", actor.ap_id)
 367         |> Map.put("object", object)
 368
 369       conn =
 370         conn
 371         |> assign(:valid_signature, true)
 372         |> put_req_header("content-type", "application/activity+json")
 373         |> post("/users/#{recipient.nickname}/inbox", data)
 374
 375       assert "ok" == json_response(conn, 200)
 376       :timer.sleep(500)
 377       assert Activity.get_by_ap_id(data["id"])
 378     end
 379
 380     test "it rejects reads from other users", %{conn: conn} do
 381       user = insert(:user)
 382       otheruser = insert(:user)
 383
 384       conn =
 385         conn
 386         |> assign(:user, otheruser)
 387         |> put_req_header("accept", "application/activity+json")
 388         |> get("/users/#{user.nickname}/inbox")
 389
 390       assert json_response(conn, 403)
 391     end
 392
 393     test "it doesn't crash without an authenticated user", %{conn: conn} do
 394       user = insert(:user)
 395
 396       conn =
 397         conn
 398         |> put_req_header("accept", "application/activity+json")
 399         |> get("/users/#{user.nickname}/inbox")
 400
 401       assert json_response(conn, 403)
 402     end
 403
 404     test "it returns a note activity in a collection", %{conn: conn} do
 405       note_activity = insert(:direct_note_activity)
 406       note_object = Object.normalize(note_activity)
 407       user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))
 408
 409       conn =
 410         conn
 411         |> assign(:user, user)
 412         |> put_req_header("accept", "application/activity+json")
 413         |> get("/users/#{user.nickname}/inbox?page=true")
 414
 415       assert response(conn, 200) =~ note_object.data["content"]
 416     end
 417
 418     test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
 419       user = insert(:user)
 420       data = Map.put(data, "bcc", [user.ap_id])
 421
 422       sender_host = URI.parse(data["actor"]).host
 423       Instances.set_consistently_unreachable(sender_host)
 424       refute Instances.reachable?(sender_host)
 425
 426       conn =
 427         conn
 428         |> assign(:valid_signature, true)
 429         |> put_req_header("content-type", "application/activity+json")
 430         |> post("/users/#{user.nickname}/inbox", data)
 431
 432       assert "ok" == json_response(conn, 200)
 433       assert Instances.reachable?(sender_host)
 434     end
 435
 436     test "it removes all follower collections but actor's", %{conn: conn} do
 437       [actor, recipient] = insert_pair(:user)
 438
 439       data =
 440         File.read!("test/fixtures/activitypub-client-post-activity.json")
 441         |> Poison.decode!()
 442
 443       object = Map.put(data["object"], "attributedTo", actor.ap_id)
 444
 445       data =
 446         data
 447         |> Map.put("id", Utils.generate_object_id())
 448         |> Map.put("actor", actor.ap_id)
 449         |> Map.put("object", object)
 450         |> Map.put("cc", [
 451           recipient.follower_address,
 452           actor.follower_address
 453         ])
 454         |> Map.put("to", [
 455           recipient.ap_id,
 456           recipient.follower_address,
 457           "https://www.w3.org/ns/activitystreams#Public"
 458         ])
 459
 460       conn
 461       |> assign(:valid_signature, true)
 462       |> put_req_header("content-type", "application/activity+json")
 463       |> post("/users/#{recipient.nickname}/inbox", data)
 464       |> json_response(200)
 465
 466       activity = Activity.get_by_ap_id(data["id"])
 467
 468       assert activity.id
 469       assert actor.follower_address in activity.recipients
 470       assert actor.follower_address in activity.data["cc"]
 471
 472       refute recipient.follower_address in activity.recipients
 473       refute recipient.follower_address in activity.data["cc"]
 474       refute recipient.follower_address in activity.data["to"]
 475     end
 476   end
 477
 478   describe "/users/:nickname/outbox" do
 479     test "it will not bomb when there is no activity", %{conn: conn} do
 480       user = insert(:user)
 481
 482       conn =
 483         conn
 484         |> put_req_header("accept", "application/activity+json")
 485         |> get("/users/#{user.nickname}/outbox")
 486
 487       result = json_response(conn, 200)
 488       assert user.ap_id <> "/outbox" == result["id"]
 489     end
 490
 491     test "it returns a note activity in a collection", %{conn: conn} do
 492       note_activity = insert(:note_activity)
 493       note_object = Object.normalize(note_activity)
 494       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 495
 496       conn =
 497         conn
 498         |> put_req_header("accept", "application/activity+json")
 499         |> get("/users/#{user.nickname}/outbox?page=true")
 500
 501       assert response(conn, 200) =~ note_object.data["content"]
 502     end
 503
 504     test "it returns an announce activity in a collection", %{conn: conn} do
 505       announce_activity = insert(:announce_activity)
 506       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 507
 508       conn =
 509         conn
 510         |> put_req_header("accept", "application/activity+json")
 511         |> get("/users/#{user.nickname}/outbox?page=true")
 512
 513       assert response(conn, 200) =~ announce_activity.data["object"]
 514     end
 515
 516     test "it rejects posts from other users", %{conn: conn} do
 517       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 518       user = insert(:user)
 519       otheruser = insert(:user)
 520
 521       conn =
 522         conn
 523         |> assign(:user, otheruser)
 524         |> put_req_header("content-type", "application/activity+json")
 525         |> post("/users/#{user.nickname}/outbox", data)
 526
 527       assert json_response(conn, 403)
 528     end
 529
 530     test "it inserts an incoming create activity into the database", %{conn: conn} do
 531       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 532       user = insert(:user)
 533
 534       conn =
 535         conn
 536         |> assign(:user, user)
 537         |> put_req_header("content-type", "application/activity+json")
 538         |> post("/users/#{user.nickname}/outbox", data)
 539
 540       result = json_response(conn, 201)
 541       assert Activity.get_by_ap_id(result["id"])
 542     end
 543
 544     test "it rejects an incoming activity with bogus type", %{conn: conn} do
 545       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 546       user = insert(:user)
 547
 548       data =
 549         data
 550         |> Map.put("type", "BadType")
 551
 552       conn =
 553         conn
 554         |> assign(:user, user)
 555         |> put_req_header("content-type", "application/activity+json")
 556         |> post("/users/#{user.nickname}/outbox", data)
 557
 558       assert json_response(conn, 400)
 559     end
 560
 561     test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
 562       note_activity = insert(:note_activity)
 563       note_object = Object.normalize(note_activity)
 564       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 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       result = json_response(conn, 201)
 580       assert Activity.get_by_ap_id(result["id"])
 581
 582       assert object = Object.get_by_ap_id(note_object.data["id"])
 583       assert object.data["type"] == "Tombstone"
 584     end
 585
 586     test "it rejects delete activity of object from other actor", %{conn: conn} do
 587       note_activity = insert(:note_activity)
 588       note_object = Object.normalize(note_activity)
 589       user = insert(:user)
 590
 591       data = %{
 592         type: "Delete",
 593         object: %{
 594           id: note_object.data["id"]
 595         }
 596       }
 597
 598       conn =
 599         conn
 600         |> assign(:user, user)
 601         |> put_req_header("content-type", "application/activity+json")
 602         |> post("/users/#{user.nickname}/outbox", data)
 603
 604       assert json_response(conn, 400)
 605     end
 606
 607     test "it increases like count when receiving a like action", %{conn: conn} do
 608       note_activity = insert(:note_activity)
 609       note_object = Object.normalize(note_activity)
 610       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 611
 612       data = %{
 613         type: "Like",
 614         object: %{
 615           id: note_object.data["id"]
 616         }
 617       }
 618
 619       conn =
 620         conn
 621         |> assign(:user, user)
 622         |> put_req_header("content-type", "application/activity+json")
 623         |> post("/users/#{user.nickname}/outbox", data)
 624
 625       result = json_response(conn, 201)
 626       assert Activity.get_by_ap_id(result["id"])
 627
 628       assert object = Object.get_by_ap_id(note_object.data["id"])
 629       assert object.data["like_count"] == 1
 630     end
 631   end
 632
 633   describe "/relay/followers" do
 634     test "it returns relay followers", %{conn: conn} do
 635       relay_actor = Relay.get_actor()
 636       user = insert(:user)
 637       User.follow(user, relay_actor)
 638
 639       result =
 640         conn
 641         |> assign(:relay, true)
 642         |> get("/relay/followers")
 643         |> json_response(200)
 644
 645       assert result["first"]["orderedItems"] == [user.ap_id]
 646     end
 647   end
 648
 649   describe "/relay/following" do
 650     test "it returns relay following", %{conn: conn} do
 651       result =
 652         conn
 653         |> assign(:relay, true)
 654         |> get("/relay/following")
 655         |> json_response(200)
 656
 657       assert result["first"]["orderedItems"] == []
 658     end
 659   end
 660
 661   describe "/users/:nickname/followers" do
 662     test "it returns the followers in a collection", %{conn: conn} do
 663       user = insert(:user)
 664       user_two = insert(:user)
 665       User.follow(user, user_two)
 666
 667       result =
 668         conn
 669         |> get("/users/#{user_two.nickname}/followers")
 670         |> json_response(200)
 671
 672       assert result["first"]["orderedItems"] == [user.ap_id]
 673     end
 674
 675     test "it returns returns a uri if the user has 'hide_followers' set", %{conn: conn} do
 676       user = insert(:user)
 677       user_two = insert(:user, %{info: %{hide_followers: true}})
 678       User.follow(user, user_two)
 679
 680       result =
 681         conn
 682         |> get("/users/#{user_two.nickname}/followers")
 683         |> json_response(200)
 684
 685       assert is_binary(result["first"])
 686     end
 687
 688     test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is not authenticated",
 689          %{conn: conn} do
 690       user = insert(:user, %{info: %{hide_followers: true}})
 691
 692       result =
 693         conn
 694         |> get("/users/#{user.nickname}/followers?page=1")
 695
 696       assert result.status == 403
 697       assert result.resp_body == ""
 698     end
 699
 700     test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
 701          %{conn: conn} do
 702       user = insert(:user, %{info: %{hide_followers: true}})
 703       other_user = insert(:user)
 704       {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
 705
 706       result =
 707         conn
 708         |> assign(:user, user)
 709         |> get("/users/#{user.nickname}/followers?page=1")
 710         |> json_response(200)
 711
 712       assert result["totalItems"] == 1
 713       assert result["orderedItems"] == [other_user.ap_id]
 714     end
 715
 716     test "it works for more than 10 users", %{conn: conn} do
 717       user = insert(:user)
 718
 719       Enum.each(1..15, fn _ ->
 720         other_user = insert(:user)
 721         User.follow(other_user, user)
 722       end)
 723
 724       result =
 725         conn
 726         |> get("/users/#{user.nickname}/followers")
 727         |> json_response(200)
 728
 729       assert length(result["first"]["orderedItems"]) == 10
 730       assert result["first"]["totalItems"] == 15
 731       assert result["totalItems"] == 15
 732
 733       result =
 734         conn
 735         |> get("/users/#{user.nickname}/followers?page=2")
 736         |> json_response(200)
 737
 738       assert length(result["orderedItems"]) == 5
 739       assert result["totalItems"] == 15
 740     end
 741   end
 742
 743   describe "/users/:nickname/following" do
 744     test "it returns the following in a collection", %{conn: conn} do
 745       user = insert(:user)
 746       user_two = insert(:user)
 747       User.follow(user, user_two)
 748
 749       result =
 750         conn
 751         |> get("/users/#{user.nickname}/following")
 752         |> json_response(200)
 753
 754       assert result["first"]["orderedItems"] == [user_two.ap_id]
 755     end
 756
 757     test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
 758       user = insert(:user, %{info: %{hide_follows: true}})
 759       user_two = insert(:user)
 760       User.follow(user, user_two)
 761
 762       result =
 763         conn
 764         |> get("/users/#{user.nickname}/following")
 765         |> json_response(200)
 766
 767       assert is_binary(result["first"])
 768     end
 769
 770     test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is not authenticated",
 771          %{conn: conn} do
 772       user = insert(:user, %{info: %{hide_follows: true}})
 773
 774       result =
 775         conn
 776         |> get("/users/#{user.nickname}/following?page=1")
 777
 778       assert result.status == 403
 779       assert result.resp_body == ""
 780     end
 781
 782     test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
 783          %{conn: conn} do
 784       user = insert(:user, %{info: %{hide_follows: true}})
 785       other_user = insert(:user)
 786       {:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
 787
 788       result =
 789         conn
 790         |> assign(:user, user)
 791         |> get("/users/#{user.nickname}/following?page=1")
 792         |> json_response(200)
 793
 794       assert result["totalItems"] == 1
 795       assert result["orderedItems"] == [other_user.ap_id]
 796     end
 797
 798     test "it works for more than 10 users", %{conn: conn} do
 799       user = insert(:user)
 800
 801       Enum.each(1..15, fn _ ->
 802         user = User.get_cached_by_id(user.id)
 803         other_user = insert(:user)
 804         User.follow(user, other_user)
 805       end)
 806
 807       result =
 808         conn
 809         |> get("/users/#{user.nickname}/following")
 810         |> json_response(200)
 811
 812       assert length(result["first"]["orderedItems"]) == 10
 813       assert result["first"]["totalItems"] == 15
 814       assert result["totalItems"] == 15
 815
 816       result =
 817         conn
 818         |> get("/users/#{user.nickname}/following?page=2")
 819         |> json_response(200)
 820
 821       assert length(result["orderedItems"]) == 5
 822       assert result["totalItems"] == 15
 823     end
 824   end
 825 end