Introduce relay

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

test/mobilizon/actors/actors_test.exs

@@ -479,9 +479,9 @@ defmodule Mobilizon.ActorsTest do
     alias Mobilizon.Actors.Follower
     alias Mobilizon.Actors.Actor
 
-    @valid_attrs %{approved: true, score: 42}
-    @update_attrs %{approved: false, score: 43}
-    @invalid_attrs %{approved: nil, score: nil}
+    @valid_attrs %{approved: true}
+    @update_attrs %{approved: false}
+    @invalid_attrs %{approved: nil}
 
     setup do
       actor = insert(:actor)
@@ -509,7 +509,6 @@ defmodule Mobilizon.ActorsTest do
 
       assert {:ok, %Follower{} = follower} = Actors.create_follower(valid_attrs)
       assert follower.approved == true
-      assert follower.score == 42
 
       assert %{total: 1, elements: [target_actor]} = Actor.get_followings(actor)
       assert %{total: 1, elements: [actor]} = Actor.get_followers(target_actor)
@@ -546,7 +545,6 @@ defmodule Mobilizon.ActorsTest do
       assert {:ok, follower} = Actors.update_follower(follower, @update_attrs)
       assert %Follower{} = follower
       assert follower.approved == false
-      assert follower.score == 43
     end
 
     test "update_follower/2 with invalid data returns error changeset", context do
@@ -582,12 +580,12 @@ defmodule Mobilizon.ActorsTest do
       assert actor.followings |> Enum.map(& &1.target_actor_id) == [target_actor.id]
 
       # Test if actor is already following target actor
-      {:error, msg} = Actor.follow(target_actor, actor)
+      assert {:error, :already_following, msg} = Actor.follow(target_actor, actor)
       assert msg =~ "already following"
 
       # Test if target actor is suspended
       target_actor = %{target_actor | suspended: true}
-      {:error, msg} = Actor.follow(target_actor, actor)
+      assert {:error, :suspended, msg} = Actor.follow(target_actor, actor)
       assert msg =~ "suspended"
     end
   end

test/mobilizon/service/activity_pub/activity_pub_test.exs

@@ -11,7 +11,7 @@ defmodule Mobilizon.Service.ActivityPub.ActivityPubTest do
   alias Mobilizon.Events
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Actors
-  alias Mobilizon.Service.HTTPSignatures
+  alias Mobilizon.Service.HTTPSignatures.Signature
   alias Mobilizon.Service.ActivityPub
   use ExVCR.Mock, adapter: ExVCR.Adapter.Hackney
 
@@ -24,12 +24,12 @@ defmodule Mobilizon.Service.ActivityPub.ActivityPubTest do
       actor = insert(:actor)
 
       signature =
-        HTTPSignatures.sign(actor, %{
+        Signature.sign(actor, %{
           host: "example.com",
           "content-length": 15,
-          digest: Jason.encode!(%{id: "my_id"}) |> HTTPSignatures.build_digest(),
-          "(request-target)": HTTPSignatures.generate_request_target("POST", "/inbox"),
-          date: HTTPSignatures.generate_date_header()
+          digest: Jason.encode!(%{id: "my_id"}) |> Signature.build_digest(),
+          "(request-target)": Signature.generate_request_target("POST", "/inbox"),
+          date: Signature.generate_date_header()
         })
 
       assert signature =~ "headers=\"(request-target) content-length date digest host\""
@@ -53,21 +53,21 @@ defmodule Mobilizon.Service.ActivityPub.ActivityPubTest do
   end
 
   describe "create activities" do
-    test "removes doubled 'to' recipients" do
-      actor = insert(:actor)
-
-      {:ok, activity, _} =
-        ActivityPub.create(%{
-          to: ["user1", "user1", "user2"],
-          actor: actor,
-          context: "",
-          object: %{}
-        })
-
-      assert activity.data["to"] == ["user1", "user2"]
-      assert activity.actor == actor.url
-      assert activity.recipients == ["user1", "user2"]
-    end
+    #    test "removes doubled 'to' recipients" do
+    #      actor = insert(:actor)
+    #
+    #      {:ok, activity, _} =
+    #        ActivityPub.create(%{
+    #          to: ["user1", "user1", "user2"],
+    #          actor: actor,
+    #          context: "",
+    #          object: %{}
+    #        })
+    #
+    #      assert activity.data["to"] == ["user1", "user2"]
+    #      assert activity.actor == actor.url
+    #      assert activity.recipients == ["user1", "user2"]
+    #    end
   end
 
   describe "fetching an" do
@@ -110,6 +110,7 @@ defmodule Mobilizon.Service.ActivityPub.ActivityPubTest do
   end
 
   describe "deletion" do
+    # TODO: The delete activity it relayed and fetched once again (and then not found /o\)
     test "it creates a delete activity and deletes the original event" do
       event = insert(:event)
       event = Events.get_event_full_by_url!(event.url)

test/mobilizon/service/activity_pub/relay_test.exs

@@ -0,0 +1,15 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Mobilizon.Service.ActivityPub.RelayTest do
+  use Mobilizon.DataCase
+
+  alias Mobilizon.Service.ActivityPub.Relay
+
+  test "gets an actor for the relay" do
+    actor = Relay.get_actor()
+
+    assert actor.url =~ "/relay"
+  end
+end

test/mobilizon/service/activity_pub/transmogrifier_test.exs

@@ -13,6 +13,7 @@ defmodule Mobilizon.Service.ActivityPub.TransmogrifierTest do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events
   alias Mobilizon.Events.{Comment, Event}
+  alias Mobilizon.Service.ActivityPub
   alias Mobilizon.Service.ActivityPub.Utils
   alias Mobilizon.Service.ActivityPub.Transmogrifier
   use ExVCR.Mock, adapter: ExVCR.Adapter.Hackney
@@ -151,7 +152,7 @@ defmodule Mobilizon.Service.ActivityPub.TransmogrifierTest do
       data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") |> Jason.decode!()
 
       {:ok, %Activity{data: data, local: false}, _} = Transmogrifier.handle_incoming(data)
-      assert Enum.at(data["object"]["tag"], 2) == "moo"
+      assert Enum.at(data["object"]["tag"], 1)["name"] == "#moo"
     end
 
     #     test "it works for incoming notices with contentMap" do
@@ -293,43 +294,41 @@ defmodule Mobilizon.Service.ActivityPub.TransmogrifierTest do
     #   assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
     # end
 
-    # test "it works for incoming announces" do
-    #   data = File.read!("test/fixtures/mastodon-announce.json") |> Jason.decode!()
+    test "it works for incoming announces" do
+      data = File.read!("test/fixtures/mastodon-announce.json") |> Jason.decode!()
 
-    #   {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
+      {:ok, %Activity{data: data, local: false}, _} = Transmogrifier.handle_incoming(data)
 
-    #   assert data["actor"] == "https://social.tcit.fr/users/tcit"
-    #   assert data["type"] == "Announce"
+      assert data["actor"] == "https://framapiaf.org/users/Framasoft"
+      assert data["type"] == "Announce"
 
-    #   assert data["id"] ==
-    #            "https://social.tcit.fr/users/tcit/statuses/101188891162897047/activity"
+      assert data["id"] ==
+               "https://framapiaf.org/users/Framasoft/statuses/102501959686438400/activity"
 
-    #   assert data["object"] ==
-    #            "https://social.tcit.fr/users/tcit/statuses/101188891162897047"
+      assert data["object"] ==
+               "https://framapiaf.org/users/Framasoft/statuses/102501959686438400"
 
-    #   assert %Comment{} = Events.get_comment_from_url(data["object"])
-    # end
+      assert %Comment{} = Events.get_comment_from_url(data["object"])
+    end
 
-    # test "it works for incoming announces with an existing activity" do
-    #   comment = insert(:comment)
+    test "it works for incoming announces with an existing activity" do
+      comment = insert(:comment)
 
-    #   data =
-    #     File.read!("test/fixtures/mastodon-announce.json")
-    #     |> Jason.decode!()
-    #     |> Map.put("object", comment.url)
+      data =
+        File.read!("test/fixtures/mastodon-announce.json")
+        |> Jason.decode!()
+        |> Map.put("object", comment.url)
 
-    #   {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
+      {:ok, %Activity{data: data, local: false}, _} = Transmogrifier.handle_incoming(data)
 
-    #   assert data["actor"] == "https://social.tcit.fr/users/tcit"
-    #   assert data["type"] == "Announce"
+      assert data["actor"] == "https://framapiaf.org/users/Framasoft"
+      assert data["type"] == "Announce"
 
-    #   assert data["id"] ==
-    #            "https://social.tcit.fr/users/tcit/statuses/101188891162897047/activity"
+      assert data["id"] ==
+               "https://framapiaf.org/users/Framasoft/statuses/102501959686438400/activity"
 
-    #   assert data["object"] == comment.url
-
-    #   # assert Activity.get_create_activity_by_object_ap_id(data["object"]).id == activity.id
-    # end
+      assert data["object"] == comment.url
+    end
 
     test "it works for incoming update activities" do
       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Jason.decode!()
@@ -423,32 +422,32 @@ defmodule Mobilizon.Service.ActivityPub.TransmogrifierTest do
     #       assert Repo.get(Activity, activity.id)
     #     end
 
-    # test "it works for incoming unannounces with an existing notice" do
-    #   comment = insert(:comment)
+    test "it works for incoming unannounces with an existing notice" do
+      comment = insert(:comment)
 
-    #   announce_data =
-    #     File.read!("test/fixtures/mastodon-announce.json")
-    #     |> Jason.decode!()
-    #     |> Map.put("object", comment.url)
+      announce_data =
+        File.read!("test/fixtures/mastodon-announce.json")
+        |> Jason.decode!()
+        |> Map.put("object", comment.url)
 
-    #   {:ok, %Activity{data: announce_data, local: false}} =
-    #     Transmogrifier.handle_incoming(announce_data)
+      {:ok, %Activity{data: announce_data, local: false}, _} =
+        Transmogrifier.handle_incoming(announce_data)
 
-    #   data =
-    #     File.read!("test/fixtures/mastodon-undo-announce.json")
-    #     |> Jason.decode!()
-    #     |> Map.put("object", announce_data)
-    #     |> Map.put("actor", announce_data["actor"])
+      data =
+        File.read!("test/fixtures/mastodon-undo-announce.json")
+        |> Jason.decode!()
+        |> Map.put("object", announce_data)
+        |> Map.put("actor", announce_data["actor"])
 
-    #   {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
+      {:ok, %Activity{data: data, local: false}, _} = Transmogrifier.handle_incoming(data)
 
-    #   assert data["type"] == "Undo"
-    #   assert data["object"]["type"] == "Announce"
-    #   assert data["object"]["object"] == comment.url
+      assert data["type"] == "Undo"
+      assert data["object"]["type"] == "Announce"
+      assert data["object"]["object"] == comment.url
 
-    #   assert data["object"]["id"] ==
-    #            "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
-    # end
+      assert data["object"]["id"] ==
+               "https://framapiaf.org/users/Framasoft/statuses/102501959686438400/activity"
+    end
 
     test "it works for incomming unfollows with an existing follow" do
       actor = insert(:actor)
@@ -552,175 +551,127 @@ defmodule Mobilizon.Service.ActivityPub.TransmogrifierTest do
     #       refute User.blocks?(blocker, user)
     #     end
 
-    #     test "it works for incoming accepts which were pre-accepted" do
-    #       follower = insert(:user)
-    #       followed = insert(:user)
+    test "it works for incoming accepts which were pre-accepted" do
+      follower = insert(:actor)
+      followed = insert(:actor)
 
-    #       {:ok, follower} = User.follow(follower, followed)
-    #       assert User.following?(follower, followed) == true
+      refute Actor.following?(follower, followed)
 
-    #       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
+      {:ok, follow_activity, _} = ActivityPub.follow(follower, followed)
+      assert Actor.following?(follower, followed)
 
-    #       accept_data =
-    #         File.read!("test/fixtures/mastodon-accept-activity.json")
-    #         |> Jason.decode!()
-    #         |> Map.put("actor", followed.ap_id)
+      accept_data =
+        File.read!("test/fixtures/mastodon-accept-activity.json")
+        |> Jason.decode!()
+        |> Map.put("actor", followed.url)
 
-    #       object =
-    #         accept_data["object"]
-    #         |> Map.put("actor", follower.ap_id)
-    #         |> Map.put("id", follow_activity.data["id"])
+      object =
+        accept_data["object"]
+        |> Map.put("actor", follower.url)
+        |> Map.put("id", follow_activity.data["id"])
 
-    #       accept_data = Map.put(accept_data, "object", object)
+      accept_data = Map.put(accept_data, "object", object)
 
-    #       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
-    #       refute activity.local
+      {:ok, activity, _} = Transmogrifier.handle_incoming(accept_data)
+      refute activity.local
 
-    #       assert activity.data["object"] == follow_activity.data["id"]
+      assert activity.data["object"]["id"] == follow_activity.data["id"]
 
-    #       follower = Repo.get(User, follower.id)
+      {:ok, follower} = Actors.get_actor_by_url(follower.url)
 
-    #       assert User.following?(follower, followed) == true
-    #     end
+      assert Actor.following?(follower, followed)
+    end
 
-    #     test "it works for incoming accepts which were orphaned" do
-    #       follower = insert(:user)
-    #       followed = insert(:user, %{info: %{"locked" => true}})
+    test "it works for incoming accepts which are referenced by IRI only" do
+      follower = insert(:actor)
+      followed = insert(:actor)
 
-    #       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
+      {:ok, follow_activity, _} = ActivityPub.follow(follower, followed)
 
-    #       accept_data =
-    #         File.read!("test/fixtures/mastodon-accept-activity.json")
-    #         |> Jason.decode!()
-    #         |> Map.put("actor", followed.ap_id)
+      accept_data =
+        File.read!("test/fixtures/mastodon-accept-activity.json")
+        |> Jason.decode!()
+        |> Map.put("actor", followed.url)
+        |> Map.put("object", follow_activity.data["id"])
 
-    #       accept_data =
-    #         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
+      {:ok, activity, _} = Transmogrifier.handle_incoming(accept_data)
+      assert activity.data["object"] == follow_activity.data["id"]
+      assert activity.data["object"] =~ "/follow/"
+      assert activity.data["id"] =~ "/accept/follow/"
 
-    #       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
-    #       assert activity.data["object"] == follow_activity.data["id"]
+      {:ok, follower} = Actors.get_actor_by_url(follower.url)
 
-    #       follower = Repo.get(User, follower.id)
+      assert Actor.following?(follower, followed)
+    end
 
-    #       assert User.following?(follower, followed) == true
-    #     end
+    test "it fails for incoming accepts which cannot be correlated" do
+      follower = insert(:actor)
+      followed = insert(:actor)
 
-    #     test "it works for incoming accepts which are referenced by IRI only" do
-    #       follower = insert(:user)
-    #       followed = insert(:user, %{info: %{"locked" => true}})
+      accept_data =
+        File.read!("test/fixtures/mastodon-accept-activity.json")
+        |> Jason.decode!()
+        |> Map.put("actor", followed.url)
 
-    #       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
+      accept_data =
+        Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.url))
 
-    #       accept_data =
-    #         File.read!("test/fixtures/mastodon-accept-activity.json")
-    #         |> Jason.decode!()
-    #         |> Map.put("actor", followed.ap_id)
-    #         |> Map.put("object", follow_activity.data["id"])
+      :error = Transmogrifier.handle_incoming(accept_data)
 
-    #       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
-    #       assert activity.data["object"] == follow_activity.data["id"]
+      {:ok, follower} = Actors.get_actor_by_url(follower.url)
 
-    #       follower = Repo.get(User, follower.id)
+      refute Actor.following?(follower, followed)
+    end
 
-    #       assert User.following?(follower, followed) == true
-    #     end
+    test "it fails for incoming rejects which cannot be correlated" do
+      follower = insert(:actor)
+      followed = insert(:actor)
 
-    #     test "it fails for incoming accepts which cannot be correlated" do
-    #       follower = insert(:user)
-    #       followed = insert(:user, %{info: %{"locked" => true}})
+      accept_data =
+        File.read!("test/fixtures/mastodon-reject-activity.json")
+        |> Jason.decode!()
+        |> Map.put("actor", followed.url)
 
-    #       accept_data =
-    #         File.read!("test/fixtures/mastodon-accept-activity.json")
-    #         |> Jason.decode!()
-    #         |> Map.put("actor", followed.ap_id)
+      accept_data =
+        Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.url))
 
-    #       accept_data =
-    #         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
+      :error = Transmogrifier.handle_incoming(accept_data)
 
-    #       :error = Transmogrifier.handle_incoming(accept_data)
+      {:ok, follower} = Actors.get_actor_by_url(follower.url)
 
-    #       follower = Repo.get(User, follower.id)
+      refute Actor.following?(follower, followed)
+    end
 
-    #       refute User.following?(follower, followed) == true
-    #     end
+    test "it works for incoming rejects which are referenced by IRI only" do
+      follower = insert(:actor)
+      followed = insert(:actor)
 
-    #     test "it fails for incoming rejects which cannot be correlated" do
-    #       follower = insert(:user)
-    #       followed = insert(:user, %{info: %{"locked" => true}})
+      {:ok, follow_activity, _} = ActivityPub.follow(follower, followed)
 
-    #       accept_data =
-    #         File.read!("test/fixtures/mastodon-reject-activity.json")
-    #         |> Jason.decode!()
-    #         |> Map.put("actor", followed.ap_id)
+      assert Actor.following?(follower, followed)
 
-    #       accept_data =
-    #         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
+      reject_data =
+        File.read!("test/fixtures/mastodon-reject-activity.json")
+        |> Jason.decode!()
+        |> Map.put("actor", followed.url)
+        |> Map.put("object", follow_activity.data["id"])
 
-    #       :error = Transmogrifier.handle_incoming(accept_data)
+      {:ok, %Activity{data: _}, _} = Transmogrifier.handle_incoming(reject_data)
 
-    #       follower = Repo.get(User, follower.id)
+      refute Actor.following?(follower, followed)
+    end
 
-    #       refute User.following?(follower, followed) == true
-    #     end
+    test "it rejects activities without a valid ID" do
+      actor = insert(:actor)
 
-    #     test "it works for incoming rejects which are orphaned" do
-    #       follower = insert(:user)
-    #       followed = insert(:user, %{info: %{"locked" => true}})
+      data =
+        File.read!("test/fixtures/mastodon-follow-activity.json")
+        |> Jason.decode!()
+        |> Map.put("object", actor.url)
+        |> Map.put("id", "")
 
-    #       {:ok, follower} = User.follow(follower, followed)
-    #       {:ok, _follow_activity} = ActivityPub.follow(follower, followed)
-
-    #       assert User.following?(follower, followed) == true
-
-    #       reject_data =
-    #         File.read!("test/fixtures/mastodon-reject-activity.json")
-    #         |> Jason.decode!()
-    #         |> Map.put("actor", followed.ap_id)
-
-    #       reject_data =
-    #         Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))
-
-    #       {:ok, activity} = Transmogrifier.handle_incoming(reject_data)
-    #       refute activity.local
-
-    #       follower = Repo.get(User, follower.id)
-
-    #       assert User.following?(follower, followed) == false
-    #     end
-
-    #     test "it works for incoming rejects which are referenced by IRI only" do
-    #       follower = insert(:user)
-    #       followed = insert(:user, %{info: %{"locked" => true}})
-
-    #       {:ok, follower} = User.follow(follower, followed)
-    #       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
-
-    #       assert User.following?(follower, followed) == true
-
-    #       reject_data =
-    #         File.read!("test/fixtures/mastodon-reject-activity.json")
-    #         |> Jason.decode!()
-    #         |> Map.put("actor", followed.ap_id)
-    #         |> Map.put("object", follow_activity.data["id"])
-
-    #       {:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)
-
-    #       follower = Repo.get(User, follower.id)
-
-    #       assert User.following?(follower, followed) == false
-    #     end
-
-    #     test "it rejects activities without a valid ID" do
-    #       user = insert(:user)
-
-    #       data =
-    #         File.read!("test/fixtures/mastodon-follow-activity.json")
-    #         |> Jason.decode!()
-    #         |> Map.put("object", user.ap_id)
-    #         |> Map.put("id", "")
-
-    #       :error = Transmogrifier.handle_incoming(data)
-    #     end
+      :error = Transmogrifier.handle_incoming(data)
+    end
 
     test "it accepts Flag activities" do
       %Actor{url: reporter_url} = _reporter = insert(:actor)