X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=test%2Fweb%2Factivity_pub%2Factivity_pub_test.exs;h=2453998ad8a54f4ed59c0dfce92c55335aa6bf48;hb=b73a1a33de76dc848037a5d0e951866bd21f92c4;hp=c6434f789126b67b776b3ee798087c7c51801985;hpb=96007753ad099b43fcea33662e22b5528426849d;p=akkoma

diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
index c6434f789..2453998ad 100644
--- a/test/web/activity_pub/activity_pub_test.exs
+++ b/test/web/activity_pub/activity_pub_test.exs
@@ -1,11 +1,22 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
 defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
   use Pleroma.DataCase
   alias Pleroma.Web.ActivityPub.ActivityPub
   alias Pleroma.Web.ActivityPub.Utils
+  alias Pleroma.Web.CommonAPI
   alias Pleroma.{Activity, Object, User}
   alias Pleroma.Builders.ActivityBuilder
 
   import Pleroma.Factory
+  import Tesla.Mock
+
+  setup do
+    mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
+    :ok
+  end
 
   describe "building a user from his ap id" do
     test "it returns a user" do
@@ -13,13 +24,31 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
       assert user.ap_id == user_id
       assert user.nickname == "admin@mastodon.example.org"
-      assert user.info["source_data"]
-      assert user.info["ap_enabled"]
+      assert user.info.source_data
+      assert user.info.ap_enabled
       assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
     end
   end
 
   describe "insertion" do
+    test "drops activities beyond a certain limit" do
+      limit = Pleroma.Config.get([:instance, :remote_limit])
+
+      random_text =
+        :crypto.strong_rand_bytes(limit + 1)
+        |> Base.encode64()
+        |> binary_part(0, limit + 1)
+
+      data = %{
+        "ok" => true,
+        "object" => %{
+          "content" => random_text
+        }
+      }
+
+      assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
+    end
+
     test "returns the activity if one with the same id is already in" do
       activity = insert(:note_activity)
       {:ok, new_activity} = ActivityPub.insert(activity.data)
@@ -56,7 +85,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
         "id" => "some_id",
         "object" => %{
           "id" => "object_id"
-         }
+        }
       }
 
       {:ok, %Activity{} = activity} = ActivityPub.insert(data)
@@ -83,16 +112,18 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
 
   describe "create activities" do
     test "removes doubled 'to' recipients" do
+      user = insert(:user)
+
       {:ok, activity} =
         ActivityPub.create(%{
           to: ["user1", "user1", "user2"],
-          actor: %User{ap_id: "1"},
+          actor: user,
           context: "",
           object: %{}
         })
 
       assert activity.data["to"] == ["user1", "user2"]
-      assert activity.actor == "1"
+      assert activity.actor == user.ap_id
       assert activity.recipients == ["user1", "user2"]
     end
   end
@@ -128,12 +159,15 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
   test "doesn't return blocked activities" do
     activity_one = insert(:note_activity)
     activity_two = insert(:note_activity)
+    activity_three = insert(:note_activity)
     user = insert(:user)
+    booster = insert(:user)
     {:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})
 
     activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})
 
     assert Enum.member?(activities, activity_two)
+    assert Enum.member?(activities, activity_three)
     refute Enum.member?(activities, activity_one)
 
     {:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})
@@ -141,15 +175,53 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
     activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})
 
     assert Enum.member?(activities, activity_two)
+    assert Enum.member?(activities, activity_three)
+    assert Enum.member?(activities, activity_one)
+
+    {:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
+    {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
+    %Activity{} = boost_activity = Activity.get_create_activity_by_object_ap_id(id)
+    activity_three = Repo.get(Activity, activity_three.id)
+
+    activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})
+
+    assert Enum.member?(activities, activity_two)
+    refute Enum.member?(activities, activity_three)
+    refute Enum.member?(activities, boost_activity)
     assert Enum.member?(activities, activity_one)
 
     activities = ActivityPub.fetch_activities([], %{"blocking_user" => nil})
 
     assert Enum.member?(activities, activity_two)
+    assert Enum.member?(activities, activity_three)
+    assert Enum.member?(activities, boost_activity)
     assert Enum.member?(activities, activity_one)
   end
 
+  test "excludes reblogs on request" do
+    user = insert(:user)
+    {:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
+    {:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})
+
+    [activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})
+
+    assert activity == expected_activity
+  end
+
   describe "public fetch activities" do
+    test "doesn't retrieve unlisted activities" do
+      user = insert(:user)
+
+      {:ok, _unlisted_activity} =
+        CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
+
+      {:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})
+
+      [activity] = ActivityPub.fetch_public_activities()
+
+      assert activity == listed_activity
+    end
+
     test "retrieves public activities" do
       _activities = ActivityPub.fetch_public_activities()
 
@@ -243,7 +315,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       {:ok, like_activity, object} = ActivityPub.like(user, object)
       assert object.data["like_count"] == 1
 
-      {:ok, object} = ActivityPub.unlike(user, object)
+      {:ok, _, _, object} = ActivityPub.unlike(user, object)
       assert object.data["like_count"] == 0
 
       assert Repo.get(Activity, like_activity.id) == nil
@@ -271,6 +343,36 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
     end
   end
 
+  describe "unannouncing an object" do
+    test "unannouncing a previously announced object" do
+      note_activity = insert(:note_activity)
+      object = Object.get_by_ap_id(note_activity.data["object"]["id"])
+      user = insert(:user)
+
+      # Unannouncing an object that is not announced does nothing
+      # {:ok, object} = ActivityPub.unannounce(user, object)
+      # assert object.data["announcement_count"] == 0
+
+      {:ok, announce_activity, object} = ActivityPub.announce(user, object)
+      assert object.data["announcement_count"] == 1
+
+      {:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
+      assert object.data["announcement_count"] == 0
+
+      assert unannounce_activity.data["to"] == [
+               User.ap_followers(user),
+               announce_activity.data["actor"]
+             ]
+
+      assert unannounce_activity.data["type"] == "Undo"
+      assert unannounce_activity.data["object"] == announce_activity.data
+      assert unannounce_activity.data["actor"] == user.ap_id
+      assert unannounce_activity.data["context"] == announce_activity.data["context"]
+
+      assert Repo.get(Activity, announce_activity.id) == nil
+    end
+  end
+
   describe "uploading files" do
     test "copies the file to the configured folder" do
       file = %Plug.Upload{
@@ -359,7 +461,40 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
 
       assert activity.data["type"] == "Undo"
       assert activity.data["actor"] == follower.ap_id
-      assert activity.data["object"] == follow_activity.data["id"]
+
+      assert is_map(activity.data["object"])
+      assert activity.data["object"]["type"] == "Follow"
+      assert activity.data["object"]["object"] == followed.ap_id
+      assert activity.data["object"]["id"] == follow_activity.data["id"]
+    end
+  end
+
+  describe "blocking / unblocking" do
+    test "creates a block activity" do
+      blocker = insert(:user)
+      blocked = insert(:user)
+
+      {:ok, activity} = ActivityPub.block(blocker, blocked)
+
+      assert activity.data["type"] == "Block"
+      assert activity.data["actor"] == blocker.ap_id
+      assert activity.data["object"] == blocked.ap_id
+    end
+
+    test "creates an undo activity for the last block" do
+      blocker = insert(:user)
+      blocked = insert(:user)
+
+      {:ok, block_activity} = ActivityPub.block(blocker, blocked)
+      {:ok, activity} = ActivityPub.unblock(blocker, blocked)
+
+      assert activity.data["type"] == "Undo"
+      assert activity.data["actor"] == blocker.ap_id
+
+      assert is_map(activity.data["object"])
+      assert activity.data["object"]["type"] == "Block"
+      assert activity.data["object"]["object"] == blocked.ap_id
+      assert activity.data["object"]["id"] == block_activity.data["id"]
     end
   end
 
@@ -375,10 +510,67 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
 
       assert Repo.get(Activity, delete.id) != nil
 
-      assert Repo.get(Object, object.id) == nil
+      assert Repo.get(Object, object.id).data["type"] == "Tombstone"
     end
   end
 
+  describe "timeline post-processing" do
+    test "it filters broken threads" do
+      user1 = insert(:user)
+      user2 = insert(:user)
+      user3 = insert(:user)
+
+      {:ok, user1} = User.follow(user1, user3)
+      assert User.following?(user1, user3)
+
+      {:ok, user2} = User.follow(user2, user3)
+      assert User.following?(user2, user3)
+
+      {:ok, user3} = User.follow(user3, user2)
+      assert User.following?(user3, user2)
+
+      {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
+
+      {:ok, private_activity_1} =
+        CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
+
+      {:ok, private_activity_2} =
+        CommonAPI.post(user2, %{
+          "status" => "hi 3",
+          "visibility" => "private",
+          "in_reply_to_status_id" => private_activity_1.id
+        })
+
+      {:ok, private_activity_3} =
+        CommonAPI.post(user3, %{
+          "status" => "hi 4",
+          "visibility" => "private",
+          "in_reply_to_status_id" => private_activity_2.id
+        })
+
+      assert user1.following == [user3.ap_id <> "/followers", user1.ap_id]
+
+      activities = ActivityPub.fetch_activities([user1.ap_id | user1.following])
+
+      assert [public_activity, private_activity_1, private_activity_3] == activities
+      assert length(activities) == 3
+
+      activities = ActivityPub.contain_timeline(activities, user1)
+
+      assert [public_activity, private_activity_1] == activities
+      assert length(activities) == 2
+    end
+  end
+
+  test "it can fetch plume articles" do
+    {:ok, object} =
+      ActivityPub.fetch_object_from_id(
+        "https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/"
+      )
+
+    assert object
+  end
+
   describe "update" do
     test "it creates an update activity with the new user data" do
       user = insert(:user)
@@ -400,6 +592,15 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
     end
   end
 
+  test "it can fetch peertube videos" do
+    {:ok, object} =
+      ActivityPub.fetch_object_from_id(
+        "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
+      )
+
+    assert object
+  end
+
   def data_uri do
     File.read!("test/fixtures/avatar_data_uri")
   end