Merge remote-tracking branch 'pleroma/develop' into feature/disable-account

test/activity_test.exs

@@ -5,6 +5,7 @@
 defmodule Pleroma.ActivityTest do
   use Pleroma.DataCase
   alias Pleroma.Activity
+  alias Pleroma.Bookmark
   import Pleroma.Factory
 
   test "returns an activity by it's AP id" do
@@ -28,4 +29,48 @@ defmodule Pleroma.ActivityTest do
 
     assert activity == found_activity
   end
+
+  test "preloading a bookmark" do
+    user = insert(:user)
+    user2 = insert(:user)
+    user3 = insert(:user)
+    activity = insert(:note_activity)
+    {:ok, _bookmark} = Bookmark.create(user.id, activity.id)
+    {:ok, _bookmark2} = Bookmark.create(user2.id, activity.id)
+    {:ok, bookmark3} = Bookmark.create(user3.id, activity.id)
+
+    queried_activity =
+      Ecto.Query.from(Pleroma.Activity)
+      |> Activity.with_preloaded_bookmark(user3)
+      |> Repo.one()
+
+    assert queried_activity.bookmark == bookmark3
+  end
+
+  describe "getting a bookmark" do
+    test "when association is loaded" do
+      user = insert(:user)
+      activity = insert(:note_activity)
+      {:ok, bookmark} = Bookmark.create(user.id, activity.id)
+
+      queried_activity =
+        Ecto.Query.from(Pleroma.Activity)
+        |> Activity.with_preloaded_bookmark(user)
+        |> Repo.one()
+
+      assert Activity.get_bookmark(queried_activity, user) == bookmark
+    end
+
+    test "when association is not loaded" do
+      user = insert(:user)
+      activity = insert(:note_activity)
+      {:ok, bookmark} = Bookmark.create(user.id, activity.id)
+
+      queried_activity =
+        Ecto.Query.from(Pleroma.Activity)
+        |> Repo.one()
+
+      assert Activity.get_bookmark(queried_activity, user) == bookmark
+    end
+  end
 end

test/conversation/participation_test.exs

@@ -0,0 +1,89 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Conversation.ParticipationTest do
+  use Pleroma.DataCase
+  import Pleroma.Factory
+  alias Pleroma.Conversation.Participation
+  alias Pleroma.Web.CommonAPI
+
+  test "it creates a participation for a conversation and a user" do
+    user = insert(:user)
+    conversation = insert(:conversation)
+
+    {:ok, %Participation{} = participation} =
+      Participation.create_for_user_and_conversation(user, conversation)
+
+    assert participation.user_id == user.id
+    assert participation.conversation_id == conversation.id
+
+    :timer.sleep(1000)
+    # Creating again returns the same participation
+    {:ok, %Participation{} = participation_two} =
+      Participation.create_for_user_and_conversation(user, conversation)
+
+    assert participation.id == participation_two.id
+    refute participation.updated_at == participation_two.updated_at
+  end
+
+  test "recreating an existing participations sets it to unread" do
+    participation = insert(:participation, %{read: true})
+
+    {:ok, participation} =
+      Participation.create_for_user_and_conversation(
+        participation.user,
+        participation.conversation
+      )
+
+    refute participation.read
+  end
+
+  test "it marks a participation as read" do
+    participation = insert(:participation, %{read: false})
+    {:ok, participation} = Participation.mark_as_read(participation)
+
+    assert participation.read
+  end
+
+  test "it marks a participation as unread" do
+    participation = insert(:participation, %{read: true})
+    {:ok, participation} = Participation.mark_as_unread(participation)
+
+    refute participation.read
+  end
+
+  test "gets all the participations for a user, ordered by updated at descending" do
+    user = insert(:user)
+    {:ok, activity_one} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
+    :timer.sleep(1000)
+    {:ok, activity_two} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
+    :timer.sleep(1000)
+
+    {:ok, activity_three} =
+      CommonAPI.post(user, %{
+        "status" => "x",
+        "visibility" => "direct",
+        "in_reply_to_status_id" => activity_one.id
+      })
+
+    assert [participation_one, participation_two] = Participation.for_user(user)
+
+    object2 = Pleroma.Object.normalize(activity_two)
+    object3 = Pleroma.Object.normalize(activity_three)
+
+    assert participation_one.conversation.ap_id == object3.data["context"]
+    assert participation_two.conversation.ap_id == object2.data["context"]
+
+    # Pagination
+    assert [participation_one] = Participation.for_user(user, %{"limit" => 1})
+
+    assert participation_one.conversation.ap_id == object3.data["context"]
+
+    # With last_activity_id
+    assert [participation_one] =
+             Participation.for_user_with_last_activity_id(user, %{"limit" => 1})
+
+    assert participation_one.last_activity_id == activity_three.id
+  end
+end

test/conversation_test.exs

@@ -0,0 +1,175 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.ConversationTest do
+  use Pleroma.DataCase
+  alias Pleroma.Activity
+  alias Pleroma.Conversation
+  alias Pleroma.Object
+  alias Pleroma.Web.CommonAPI
+
+  import Pleroma.Factory
+
+  test "it creates a conversation for given ap_id" do
+    assert {:ok, %Conversation{} = conversation} =
+             Conversation.create_for_ap_id("https://some_ap_id")
+
+    # Inserting again returns the same
+    assert {:ok, conversation_two} = Conversation.create_for_ap_id("https://some_ap_id")
+    assert conversation_two.id == conversation.id
+  end
+
+  test "public posts don't create conversations" do
+    user = insert(:user)
+    {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey"})
+
+    object = Pleroma.Object.normalize(activity)
+    context = object.data["context"]
+
+    conversation = Conversation.get_for_ap_id(context)
+
+    refute conversation
+  end
+
+  test "it creates or updates a conversation and participations for a given DM" do
+    har = insert(:user)
+    jafnhar = insert(:user, local: false)
+    tridi = insert(:user)
+
+    {:ok, activity} =
+      CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"})
+
+    object = Pleroma.Object.normalize(activity)
+    context = object.data["context"]
+
+    conversation =
+      Conversation.get_for_ap_id(context)
+      |> Repo.preload(:participations)
+
+    assert conversation
+
+    assert Enum.find(conversation.participations, fn %{user_id: user_id} -> har.id == user_id end)
+
+    assert Enum.find(conversation.participations, fn %{user_id: user_id} ->
+             jafnhar.id == user_id
+           end)
+
+    {:ok, activity} =
+      CommonAPI.post(jafnhar, %{
+        "status" => "Hey @#{har.nickname}",
+        "visibility" => "direct",
+        "in_reply_to_status_id" => activity.id
+      })
+
+    object = Pleroma.Object.normalize(activity)
+    context = object.data["context"]
+
+    conversation_two =
+      Conversation.get_for_ap_id(context)
+      |> Repo.preload(:participations)
+
+    assert conversation_two.id == conversation.id
+
+    assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
+             har.id == user_id
+           end)
+
+    assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
+             jafnhar.id == user_id
+           end)
+
+    {:ok, activity} =
+      CommonAPI.post(tridi, %{
+        "status" => "Hey @#{har.nickname}",
+        "visibility" => "direct",
+        "in_reply_to_status_id" => activity.id
+      })
+
+    object = Pleroma.Object.normalize(activity)
+    context = object.data["context"]
+
+    conversation_three =
+      Conversation.get_for_ap_id(context)
+      |> Repo.preload([:participations, :users])
+
+    assert conversation_three.id == conversation.id
+
+    assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
+             har.id == user_id
+           end)
+
+    assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
+             jafnhar.id == user_id
+           end)
+
+    assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
+             tridi.id == user_id
+           end)
+
+    assert Enum.find(conversation_three.users, fn %{id: user_id} ->
+             har.id == user_id
+           end)
+
+    assert Enum.find(conversation_three.users, fn %{id: user_id} ->
+             jafnhar.id == user_id
+           end)
+
+    assert Enum.find(conversation_three.users, fn %{id: user_id} ->
+             tridi.id == user_id
+           end)
+  end
+
+  test "create_or_bump_for returns the conversation with participations" do
+    har = insert(:user)
+    jafnhar = insert(:user, local: false)
+
+    {:ok, activity} =
+      CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"})
+
+    {:ok, conversation} = Conversation.create_or_bump_for(activity)
+
+    assert length(conversation.participations) == 2
+
+    {:ok, activity} =
+      CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "public"})
+
+    assert {:error, _} = Conversation.create_or_bump_for(activity)
+  end
+
+  test "create_or_bump_for does not normalize objects before checking the activity type" do
+    note = insert(:note)
+    note_id = note.data["id"]
+    Repo.delete(note)
+    refute Object.get_by_ap_id(note_id)
+
+    Tesla.Mock.mock(fn env ->
+      case env.url do
+        ^note_id ->
+          # TODO: add attributedTo and tag to the note factory
+          body =
+            note.data
+            |> Map.put("attributedTo", note.data["actor"])
+            |> Map.put("tag", [])
+            |> Jason.encode!()
+
+          %Tesla.Env{status: 200, body: body}
+      end
+    end)
+
+    undo = %Activity{
+      id: "fake",
+      data: %{
+        "id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
+        "actor" => note.data["actor"],
+        "to" => [note.data["actor"]],
+        "object" => note_id,
+        "type" => "Undo"
+      }
+    }
+
+    Conversation.create_or_bump_for(undo)
+
+    refute Object.get_by_ap_id(note_id)
+  end
+end

test/plugs/rate_limit_plug_test.exs

@@ -0,0 +1,50 @@
+defmodule Pleroma.Plugs.RateLimitPlugTest do
+  use ExUnit.Case, async: true
+  use Plug.Test
+
+  alias Pleroma.Plugs.RateLimitPlug
+
+  @opts RateLimitPlug.init(%{max_requests: 5, interval: 1})
+
+  setup do
+    enabled = Pleroma.Config.get([:app_account_creation, :enabled])
+
+    Pleroma.Config.put([:app_account_creation, :enabled], true)
+
+    on_exit(fn ->
+      Pleroma.Config.put([:app_account_creation, :enabled], enabled)
+    end)
+
+    :ok
+  end
+
+  test "it restricts by opts" do
+    conn = conn(:get, "/")
+    bucket_name = conn.remote_ip |> Tuple.to_list() |> Enum.join(".")
+    ms = 1000
+
+    conn = RateLimitPlug.call(conn, @opts)
+    {1, 4, _, _, _} = ExRated.inspect_bucket(bucket_name, ms, 5)
+    conn = RateLimitPlug.call(conn, @opts)
+    {2, 3, _, _, _} = ExRated.inspect_bucket(bucket_name, ms, 5)
+    conn = RateLimitPlug.call(conn, @opts)
+    {3, 2, _, _, _} = ExRated.inspect_bucket(bucket_name, ms, 5)
+    conn = RateLimitPlug.call(conn, @opts)
+    {4, 1, _, _, _} = ExRated.inspect_bucket(bucket_name, ms, 5)
+    conn = RateLimitPlug.call(conn, @opts)
+    {5, 0, to_reset, _, _} = ExRated.inspect_bucket(bucket_name, ms, 5)
+    conn = RateLimitPlug.call(conn, @opts)
+    assert conn.status == 403
+    assert conn.halted
+    assert conn.resp_body == "{\"error\":\"Rate limit exceeded.\"}"
+
+    Process.sleep(to_reset)
+
+    conn = conn(:get, "/")
+    conn = RateLimitPlug.call(conn, @opts)
+    {1, 4, _, _, _} = ExRated.inspect_bucket(bucket_name, ms, 5)
+    refute conn.status == 403
+    refute conn.halted
+    refute conn.resp_body
+  end
+end

test/support/factory.ex

@@ -5,6 +5,23 @@
 defmodule Pleroma.Factory do
   use ExMachina.Ecto, repo: Pleroma.Repo
 
+  def participation_factory do
+    conversation = insert(:conversation)
+    user = insert(:user)
+
+    %Pleroma.Conversation.Participation{
+      conversation: conversation,
+      user: user,
+      read: false
+    }
+  end
+
+  def conversation_factory do
+    %Pleroma.Conversation{
+      ap_id: sequence(:ap_id, &"https://some_conversation/#{&1}")
+    }
+  end
+
   def user_factory do
     user = %Pleroma.User{
       name: sequence(:name, &"Test テスト User #{&1}"),

test/user_test.exs

@@ -350,7 +350,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "it creates confirmed user if :confirmed option is given" do
-      changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
+      changeset = User.register_changeset(%User{}, @full_user_data, need_confirmation: false)
       assert changeset.valid?
 
       {:ok, user} = Repo.insert(changeset)
@@ -864,10 +864,12 @@ defmodule Pleroma.UserTest do
 
       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{user2.nickname}"})
 
+      activity = Repo.preload(activity, :bookmark)
+
       [notification] = Pleroma.Notification.for_user(user2)
       assert notification.activity.id == activity.id
 
-      assert [activity] == ActivityPub.fetch_public_activities(%{})
+      assert [activity] == ActivityPub.fetch_public_activities(%{}) |> Repo.preload(:bookmark)
 
       assert [activity] ==
                ActivityPub.fetch_activities([user2.ap_id | user2.following], %{"user" => user2})

test/web/activity_pub/activity_pub_test.exs

@@ -10,6 +10,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
   alias Pleroma.Object
   alias Pleroma.User
   alias Pleroma.Web.ActivityPub.ActivityPub
+  alias Pleroma.Web.ActivityPub.Publisher
   alias Pleroma.Web.ActivityPub.Utils
   alias Pleroma.Web.CommonAPI
 
@@ -22,6 +23,28 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
     :ok
   end
 
+  describe "streaming out participations" do
+    test "it streams them out" do
+      user = insert(:user)
+      {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
+
+      {:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)
+
+      participations =
+        conversation.participations
+        |> Repo.preload(:user)
+
+      with_mock Pleroma.Web.Streamer,
+        stream: fn _, _ -> nil end do
+        ActivityPub.stream_out_participations(conversation.participations)
+
+        Enum.each(participations, fn participation ->
+          assert called(Pleroma.Web.Streamer.stream("participation", participation))
+        end)
+      end
+    end
+  end
+
   describe "fetching restricted by visibility" do
     test "it restricts by the appropriate visibility" do
       user = insert(:user)
@@ -130,9 +153,15 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
     end
 
     test "doesn't drop activities with content being null" do
+      user = insert(:user)
+
       data = %{
-        "ok" => true,
+        "actor" => user.ap_id,
+        "to" => [],
         "object" => %{
+          "actor" => user.ap_id,
+          "to" => [],
+          "type" => "Note",
           "content" => nil
         }
       }
@@ -148,8 +177,17 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
     end
 
     test "inserts a given map into the activity database, giving it an id if it has none." do
+      user = insert(:user)
+
       data = %{
-        "ok" => true
+        "actor" => user.ap_id,
+        "to" => [],
+        "object" => %{
+          "actor" => user.ap_id,
+          "to" => [],
+          "type" => "Note",
+          "content" => "hey"
+        }
       }
 
       {:ok, %Activity{} = activity} = ActivityPub.insert(data)
@@ -159,9 +197,16 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       given_id = "bla"
 
       data = %{
-        "ok" => true,
         "id" => given_id,
-        "context" => "blabla"
+        "actor" => user.ap_id,
+        "to" => [],
+        "context" => "blabla",
+        "object" => %{
+          "actor" => user.ap_id,
+          "to" => [],
+          "type" => "Note",
+          "content" => "hey"
+        }
       }
 
       {:ok, %Activity{} = activity} = ActivityPub.insert(data)
@@ -172,26 +217,39 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
     end
 
     test "adds a context when none is there" do
+      user = insert(:user)
+
       data = %{
-        "id" => "some_id",
+        "actor" => user.ap_id,
+        "to" => [],
         "object" => %{
-          "id" => "object_id"
+          "actor" => user.ap_id,
+          "to" => [],
+          "type" => "Note",
+          "content" => "hey"
         }
       }
 
       {:ok, %Activity{} = activity} = ActivityPub.insert(data)
+      object = Pleroma.Object.normalize(activity)
 
       assert is_binary(activity.data["context"])
-      assert is_binary(activity.data["object"]["context"])
+      assert is_binary(object.data["context"])
       assert activity.data["context_id"]
-      assert activity.data["object"]["context_id"]
+      assert object.data["context_id"]
     end
 
     test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
+      user = insert(:user)
+
       data = %{
+        "actor" => user.ap_id,
+        "to" => [],
         "object" => %{
+          "actor" => user.ap_id,
+          "to" => [],
           "type" => "Note",
-          "ok" => true
+          "content" => "hey"
         }
       }
 
@@ -906,8 +964,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
 
       private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])
 
-      assert [public_activity, private_activity_1, private_activity_3] ==
-               activities
+      assert [public_activity, private_activity_1, private_activity_3] == activities
 
       assert length(activities) == 3
 
@@ -1000,7 +1057,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       actor = insert(:user)
       inbox = "http://200.site/users/nick1/inbox"
 
-      assert {:ok, _} = ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
+      assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
 
       assert called(Instances.set_reachable(inbox))
     end
@@ -1013,7 +1070,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       inbox = "http://200.site/users/nick1/inbox"
 
       assert {:ok, _} =
-               ActivityPub.publish_one(%{
+               Publisher.publish_one(%{
                  inbox: inbox,
                  json: "{}",
                  actor: actor,
@@ -1032,7 +1089,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       inbox = "http://200.site/users/nick1/inbox"
 
       assert {:ok, _} =
-               ActivityPub.publish_one(%{
+               Publisher.publish_one(%{
                  inbox: inbox,
                  json: "{}",
                  actor: actor,
@@ -1050,8 +1107,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       actor = insert(:user)
       inbox = "http://404.site/users/nick1/inbox"
 
-      assert {:error, _} =
-               ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
+      assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
 
       assert called(Instances.set_unreachable(inbox))
     end
@@ -1063,8 +1119,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       actor = insert(:user)
       inbox = "http://connrefused.site/users/nick1/inbox"
 
-      assert {:error, _} =
-               ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
+      assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
 
       assert called(Instances.set_unreachable(inbox))
     end
@@ -1076,7 +1131,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       actor = insert(:user)
       inbox = "http://200.site/users/nick1/inbox"
 
-      assert {:ok, _} = ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
+      assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
 
       refute called(Instances.set_unreachable(inbox))
     end
@@ -1089,7 +1144,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
       inbox = "http://connrefused.site/users/nick1/inbox"
 
       assert {:error, _} =
-               ActivityPub.publish_one(%{
+               Publisher.publish_one(%{
                  inbox: inbox,
                  json: "{}",
                  actor: actor,

test/web/admin_api/admin_api_controller_test.exs

@@ -9,7 +9,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
   alias Pleroma.UserInviteToken
   import Pleroma.Factory
 
-  describe "/api/pleroma/admin/user" do
+  describe "/api/pleroma/admin/users" do
     test "Delete" do
       admin = insert(:user, info: %{is_admin: true})
       user = insert(:user)
@@ -18,7 +18,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
         build_conn()
         |> assign(:user, admin)
         |> put_req_header("accept", "application/json")
-        |> delete("/api/pleroma/admin/user?nickname=#{user.nickname}")
+        |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
 
       assert json_response(conn, 200) == user.nickname
     end
@@ -30,7 +30,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
         build_conn()
         |> assign(:user, admin)
         |> put_req_header("accept", "application/json")
-        |> post("/api/pleroma/admin/user", %{
+        |> post("/api/pleroma/admin/users", %{
           "nickname" => "lain",
           "email" => "lain@example.org",
           "password" => "test"
@@ -75,7 +75,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     end
   end
 
-  describe "/api/pleroma/admin/user/follow" do
+  describe "/api/pleroma/admin/users/follow" do
     test "allows to force-follow another user" do
       admin = insert(:user, info: %{is_admin: true})
       user = insert(:user)
@@ -84,7 +84,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       build_conn()
       |> assign(:user, admin)
       |> put_req_header("accept", "application/json")
-      |> post("/api/pleroma/admin/user/follow", %{
+      |> post("/api/pleroma/admin/users/follow", %{
         "follower" => follower.nickname,
         "followed" => user.nickname
       })
@@ -96,7 +96,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     end
   end
 
-  describe "/api/pleroma/admin/user/unfollow" do
+  describe "/api/pleroma/admin/users/unfollow" do
     test "allows to force-unfollow another user" do
       admin = insert(:user, info: %{is_admin: true})
       user = insert(:user)
@@ -107,7 +107,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       build_conn()
       |> assign(:user, admin)
       |> put_req_header("accept", "application/json")
-      |> post("/api/pleroma/admin/user/unfollow", %{
+      |> post("/api/pleroma/admin/users/unfollow", %{
         "follower" => follower.nickname,
         "followed" => user.nickname
       })
@@ -191,7 +191,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     end
   end
 
-  describe "/api/pleroma/admin/permission_group" do
+  describe "/api/pleroma/admin/users/:nickname/permission_group" do
     test "GET is giving user_info" do
       admin = insert(:user, info: %{is_admin: true})
 
@@ -199,7 +199,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
         build_conn()
         |> assign(:user, admin)
         |> put_req_header("accept", "application/json")
-        |> get("/api/pleroma/admin/permission_group/#{admin.nickname}")
+        |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
 
       assert json_response(conn, 200) == %{
                "is_admin" => true,
@@ -215,7 +215,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
         build_conn()
         |> assign(:user, admin)
         |> put_req_header("accept", "application/json")
-        |> post("/api/pleroma/admin/permission_group/#{user.nickname}/admin")
+        |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 
       assert json_response(conn, 200) == %{
                "is_admin" => true
@@ -230,7 +230,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
         build_conn()
         |> assign(:user, admin)
         |> put_req_header("accept", "application/json")
-        |> delete("/api/pleroma/admin/permission_group/#{user.nickname}/admin")
+        |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 
       assert json_response(conn, 200) == %{
                "is_admin" => false
@@ -238,7 +238,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     end
   end
 
-  describe "PUT /api/pleroma/admin/activation_status" do
+  describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
     setup %{conn: conn} do
       admin = insert(:user, info: %{is_admin: true})
 
@@ -255,7 +255,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
 
       conn =
         conn
-        |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})
+        |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
 
       user = User.get_cached_by_id(user.id)
       assert user.info.deactivated == true
@@ -267,7 +267,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
 
       conn =
         conn
-        |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: true})
+        |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})
 
       user = User.get_cached_by_id(user.id)
       assert user.info.deactivated == false
@@ -280,7 +280,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       conn =
         conn
         |> assign(:user, user)
-        |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})
+        |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
 
       assert json_response(conn, :forbidden)
     end
@@ -309,7 +309,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       conn =
         conn
         |> assign(:user, user)
-        |> post("/api/pleroma/admin/email_invite?email=#{recipient_email}&name=#{recipient_name}")
+        |> post(
+          "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
+        )
 
       assert json_response(conn, :no_content)
 
@@ -341,13 +343,13 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       conn =
         conn
         |> assign(:user, non_admin_user)
-        |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
+        |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 
       assert json_response(conn, :forbidden)
     end
   end
 
-  describe "POST /api/pleroma/admin/email_invite, with invalid config" do
+  describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
     setup do
       [user: insert(:user, info: %{is_admin: true})]
     end
@@ -367,7 +369,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       conn =
         conn
         |> assign(:user, user)
-        |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
+        |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 
       assert json_response(conn, :internal_server_error)
     end
@@ -387,7 +389,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       conn =
         conn
         |> assign(:user, user)
-        |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
+        |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 
       assert json_response(conn, :internal_server_error)
     end
@@ -405,7 +407,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     assert conn.status == 200
   end
 
-  test "/api/pleroma/admin/password_reset" do
+  test "/api/pleroma/admin/users/:nickname/password_reset" do
     admin = insert(:user, info: %{is_admin: true})
     user = insert(:user)
 
@@ -413,20 +415,25 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       build_conn()
       |> assign(:user, admin)
       |> put_req_header("accept", "application/json")
-      |> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")
+      |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
 
     assert conn.status == 200
   end
 
   describe "GET /api/pleroma/admin/users" do
-    test "renders users array for the first page" do
+    setup do
       admin = insert(:user, info: %{is_admin: true})
-      user = insert(:user, local: false, tags: ["foo", "bar"])
 
       conn =
         build_conn()
         |> assign(:user, admin)
-        |> get("/api/pleroma/admin/users?page=1")
+
+      {:ok, conn: conn, admin: admin}
+    end
+
+    test "renders users array for the first page", %{conn: conn, admin: admin} do
+      user = insert(:user, local: false, tags: ["foo", "bar"])
+      conn = get(conn, "/api/pleroma/admin/users?page=1")
 
       assert json_response(conn, 200) == %{
                "count" => 2,
@@ -452,14 +459,10 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
              }
     end
 
-    test "renders empty array for the second page" do
-      admin = insert(:user, info: %{is_admin: true})
+    test "renders empty array for the second page", %{conn: conn} do
       insert(:user)
 
-      conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> get("/api/pleroma/admin/users?page=2")
+      conn = get(conn, "/api/pleroma/admin/users?page=2")
 
       assert json_response(conn, 200) == %{
                "count" => 2,
@@ -468,14 +471,10 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
              }
     end
 
-    test "regular search" do
-      admin = insert(:user, info: %{is_admin: true})
+    test "regular search", %{conn: conn} do
       user = insert(:user, nickname: "bob")
 
-      conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> get("/api/pleroma/admin/users?query=bo")
+      conn = get(conn, "/api/pleroma/admin/users?query=bo")
 
       assert json_response(conn, 200) == %{
                "count" => 1,
@@ -493,17 +492,101 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
              }
     end
 
-    test "regular search with page size" do
-      admin = insert(:user, info: %{is_admin: true})
+    test "search by domain", %{conn: conn} do
+      user = insert(:user, nickname: "nickname@domain.com")
+      insert(:user)
+
+      conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
+
+      assert json_response(conn, 200) == %{
+               "count" => 1,
+               "page_size" => 50,
+               "users" => [
+                 %{
+                   "deactivated" => user.info.deactivated,
+                   "id" => user.id,
+                   "nickname" => user.nickname,
+                   "roles" => %{"admin" => false, "moderator" => false},
+                   "local" => true,
+                   "tags" => []
+                 }
+               ]
+             }
+    end
+
+    test "search by full nickname", %{conn: conn} do
+      user = insert(:user, nickname: "nickname@domain.com")
+      insert(:user)
+
+      conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
+
+      assert json_response(conn, 200) == %{
+               "count" => 1,
+               "page_size" => 50,
+               "users" => [
+                 %{
+                   "deactivated" => user.info.deactivated,
+                   "id" => user.id,
+                   "nickname" => user.nickname,
+                   "roles" => %{"admin" => false, "moderator" => false},
+                   "local" => true,
+                   "tags" => []
+                 }
+               ]
+             }
+    end
+
+    test "search by display name", %{conn: conn} do
+      user = insert(:user, name: "Display name")
+      insert(:user)
+
+      conn = get(conn, "/api/pleroma/admin/users?name=display")
+
+      assert json_response(conn, 200) == %{
+               "count" => 1,
+               "page_size" => 50,
+               "users" => [
+                 %{
+                   "deactivated" => user.info.deactivated,
+                   "id" => user.id,
+                   "nickname" => user.nickname,
+                   "roles" => %{"admin" => false, "moderator" => false},
+                   "local" => true,
+                   "tags" => []
+                 }
+               ]
+             }
+    end
+
+    test "search by email", %{conn: conn} do
+      user = insert(:user, email: "email@example.com")
+      insert(:user)
+
+      conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
+
+      assert json_response(conn, 200) == %{
+               "count" => 1,
+               "page_size" => 50,
+               "users" => [
+                 %{
+                   "deactivated" => user.info.deactivated,
+                   "id" => user.id,
+                   "nickname" => user.nickname,
+                   "roles" => %{"admin" => false, "moderator" => false},
+                   "local" => true,
+                   "tags" => []
+                 }
+               ]
+             }
+    end
+
+    test "regular search with page size", %{conn: conn} do
       user = insert(:user, nickname: "aalice")
       user2 = insert(:user, nickname: "alice")
 
-      conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> get("/api/pleroma/admin/users?query=a&page_size=1&page=1")
+      conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 
-      assert json_response(conn, 200) == %{
+      assert json_response(conn1, 200) == %{
                "count" => 2,
                "page_size" => 1,
                "users" => [
@@ -518,12 +601,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
                ]
              }
 
-      conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> get("/api/pleroma/admin/users?query=a&page_size=1&page=2")
+      conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 
-      assert json_response(conn, 200) == %{
+      assert json_response(conn2, 200) == %{
                "count" => 2,
                "page_size" => 1,
                "users" => [
@@ -566,7 +646,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
              }
     end
 
-    test "only local users with no query" do
+    test "only local users with no query", %{admin: old_admin} do
       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
       user = insert(:user, nickname: "bob")
 
@@ -578,7 +658,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
         |> get("/api/pleroma/admin/users?filters=local")
 
       assert json_response(conn, 200) == %{
-               "count" => 2,
+               "count" => 3,
                "page_size" => 50,
                "users" => [
                  %{
@@ -596,6 +676,100 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
                    "roles" => %{"admin" => true, "moderator" => false},
                    "local" => true,
                    "tags" => []
+                 },
+                 %{
+                   "deactivated" => false,
+                   "id" => old_admin.id,
+                   "local" => true,
+                   "nickname" => old_admin.nickname,
+                   "roles" => %{"admin" => true, "moderator" => false},
+                   "tags" => []
+                 }
+               ]
+             }
+    end
+
+    test "load only admins", %{conn: conn, admin: admin} do
+      second_admin = insert(:user, info: %{is_admin: true})
+      insert(:user)
+      insert(:user)
+
+      conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
+
+      assert json_response(conn, 200) == %{
+               "count" => 2,
+               "page_size" => 50,
+               "users" => [
+                 %{
+                   "deactivated" => false,
+                   "id" => admin.id,
+                   "nickname" => admin.nickname,
+                   "roles" => %{"admin" => true, "moderator" => false},
+                   "local" => admin.local,
+                   "tags" => []
+                 },
+                 %{
+                   "deactivated" => false,
+                   "id" => second_admin.id,
+                   "nickname" => second_admin.nickname,
+                   "roles" => %{"admin" => true, "moderator" => false},
+                   "local" => second_admin.local,
+                   "tags" => []
+                 }
+               ]
+             }
+    end
+
+    test "load only moderators", %{conn: conn} do
+      moderator = insert(:user, info: %{is_moderator: true})
+      insert(:user)
+      insert(:user)
+
+      conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
+
+      assert json_response(conn, 200) == %{
+               "count" => 1,
+               "page_size" => 50,
+               "users" => [
+                 %{
+                   "deactivated" => false,
+                   "id" => moderator.id,
+                   "nickname" => moderator.nickname,
+                   "roles" => %{"admin" => false, "moderator" => true},
+                   "local" => moderator.local,
+                   "tags" => []
+                 }
+               ]
+             }
+    end
+
+    test "load users with tags list", %{conn: conn} do
+      user1 = insert(:user, tags: ["first"])
+      user2 = insert(:user, tags: ["second"])
+      insert(:user)
+      insert(:user)
+
+      conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
+
+      assert json_response(conn, 200) == %{
+               "count" => 2,
+               "page_size" => 50,
+               "users" => [
+                 %{
+                   "deactivated" => false,
+                   "id" => user1.id,
+                   "nickname" => user1.nickname,
+                   "roles" => %{"admin" => false, "moderator" => false},
+                   "local" => user1.local,
+                   "tags" => ["first"]
+                 },
+                 %{
+                   "deactivated" => false,
+                   "id" => user2.id,
+                   "nickname" => user2.nickname,
+                   "roles" => %{"admin" => false, "moderator" => false},
+                   "local" => user2.local,
+                   "tags" => ["second"]
                  }
                ]
              }
@@ -650,14 +824,19 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
              }
   end
 
-  describe "GET /api/pleroma/admin/invite_token" do
-    test "without options" do
+  describe "GET /api/pleroma/admin/users/invite_token" do
+    setup do
       admin = insert(:user, info: %{is_admin: true})
 
       conn =
         build_conn()
         |> assign(:user, admin)
-        |> get("/api/pleroma/admin/invite_token")
+
+      {:ok, conn: conn}
+    end
+
+    test "without options", %{conn: conn} do
+      conn = get(conn, "/api/pleroma/admin/users/invite_token")
 
       token = json_response(conn, 200)
       invite = UserInviteToken.find_by_token!(token)
@@ -667,13 +846,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       assert invite.invite_type == "one_time"
     end
 
-    test "with expires_at" do
-      admin = insert(:user, info: %{is_admin: true})
-
+    test "with expires_at", %{conn: conn} do
       conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> get("/api/pleroma/admin/invite_token", %{
+        get(conn, "/api/pleroma/admin/users/invite_token", %{
           "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
         })
 
@@ -686,13 +861,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       assert invite.invite_type == "date_limited"
     end
 
-    test "with max_use" do
-      admin = insert(:user, info: %{is_admin: true})
-
+    test "with max_use", %{conn: conn} do
       conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> get("/api/pleroma/admin/invite_token", %{
+        get(conn, "/api/pleroma/admin/users/invite_token", %{
           "invite" => %{"max_use" => 150}
         })
 
@@ -704,13 +875,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       assert invite.invite_type == "reusable"
     end
 
-    test "with max use and expires_at" do
-      admin = insert(:user, info: %{is_admin: true})
-
+    test "with max use and expires_at", %{conn: conn} do
       conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> get("/api/pleroma/admin/invite_token", %{
+        get(conn, "/api/pleroma/admin/users/invite_token", %{
           "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
         })
 
@@ -723,26 +890,27 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     end
   end
 
-  describe "GET /api/pleroma/admin/invites" do
-    test "no invites" do
+  describe "GET /api/pleroma/admin/users/invites" do
+    setup do
       admin = insert(:user, info: %{is_admin: true})
 
       conn =
         build_conn()
         |> assign(:user, admin)
-        |> get("/api/pleroma/admin/invites")
+
+      {:ok, conn: conn}
+    end
+
+    test "no invites", %{conn: conn} do
+      conn = get(conn, "/api/pleroma/admin/users/invites")
 
       assert json_response(conn, 200) == %{"invites" => []}
     end
 
-    test "with invite" do
-      admin = insert(:user, info: %{is_admin: true})
+    test "with invite", %{conn: conn} do
       {:ok, invite} = UserInviteToken.create_invite()
 
-      conn =
-        build_conn()
-        |> assign(:user, admin)
-        |> get("/api/pleroma/admin/invites")
+      conn = get(conn, "/api/pleroma/admin/users/invites")
 
       assert json_response(conn, 200) == %{
                "invites" => [
@@ -760,7 +928,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
     end
   end
 
-  describe "POST /api/pleroma/admin/revoke_invite" do
+  describe "POST /api/pleroma/admin/users/revoke_invite" do
     test "with token" do
       admin = insert(:user, info: %{is_admin: true})
       {:ok, invite} = UserInviteToken.create_invite()
@@ -768,7 +936,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
       conn =
         build_conn()
         |> assign(:user, admin)
-        |> post("/api/pleroma/admin/revoke_invite", %{"token" => invite.token})
+        |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
 
       assert json_response(conn, 200) == %{
                "expires_at" => nil,

test/web/admin_api/search_test.exs

@@ -70,11 +70,11 @@ defmodule Pleroma.Web.AdminAPI.SearchTest do
     test "it returns specific user" do
       insert(:user)
       insert(:user)
-      insert(:user, nickname: "bob", local: true, info: %{deactivated: false})
+      user = insert(:user, nickname: "bob", local: true, info: %{deactivated: false})
 
       {:ok, _results, total_count} = Search.user(%{query: ""})
 
-      {:ok, _results, count} =
+      {:ok, [^user], count} =
         Search.user(%{
           query: "Bo",
           active: true,
@@ -84,5 +84,87 @@ defmodule Pleroma.Web.AdminAPI.SearchTest do
       assert total_count == 3
       assert count == 1
     end
+
+    test "it returns user by domain" do
+      insert(:user)
+      insert(:user)
+      user = insert(:user, nickname: "some@domain.com")
+
+      {:ok, _results, total} = Search.user()
+      {:ok, [^user], count} = Search.user(%{query: "domain.com"})
+      assert total == 3
+      assert count == 1
+    end
+
+    test "it return user by full nickname" do
+      insert(:user)
+      insert(:user)
+      user = insert(:user, nickname: "some@domain.com")
+
+      {:ok, _results, total} = Search.user()
+      {:ok, [^user], count} = Search.user(%{query: "some@domain.com"})
+      assert total == 3
+      assert count == 1
+    end
+
+    test "it returns admin user" do
+      admin = insert(:user, info: %{is_admin: true})
+      insert(:user)
+      insert(:user)
+
+      {:ok, _results, total} = Search.user()
+      {:ok, [^admin], count} = Search.user(%{is_admin: true})
+      assert total == 3
+      assert count == 1
+    end
+
+    test "it returns moderator user" do
+      moderator = insert(:user, info: %{is_moderator: true})
+      insert(:user)
+      insert(:user)
+
+      {:ok, _results, total} = Search.user()
+      {:ok, [^moderator], count} = Search.user(%{is_moderator: true})
+      assert total == 3
+      assert count == 1
+    end
+
+    test "it returns users with tags" do
+      user1 = insert(:user, tags: ["first"])
+      user2 = insert(:user, tags: ["second"])
+      insert(:user)
+      insert(:user)
+
+      {:ok, _results, total} = Search.user()
+      {:ok, users, count} = Search.user(%{tags: ["first", "second"]})
+      assert total == 4
+      assert count == 2
+      assert user1 in users
+      assert user2 in users
+    end
+
+    test "it returns user by display name" do
+      user = insert(:user, name: "Display name")
+      insert(:user)
+      insert(:user)
+
+      {:ok, _results, total} = Search.user()
+      {:ok, [^user], count} = Search.user(%{name: "display"})
+
+      assert total == 3
+      assert count == 1
+    end
+
+    test "it returns user by email" do
+      user = insert(:user, email: "some@example.com")
+      insert(:user)
+      insert(:user)
+
+      {:ok, _results, total} = Search.user()
+      {:ok, [^user], count} = Search.user(%{email: "some@example.com"})
+
+      assert total == 3
+      assert count == 1
+    end
   end
 end

test/web/federator_test.exs

@@ -58,7 +58,7 @@ defmodule Pleroma.Web.FederatorTest do
 
   describe "Targets reachability filtering in `publish`" do
     test_with_mock "it federates only to reachable instances via AP",
-                   Federator,
+                   Pleroma.Web.ActivityPub.Publisher,
                    [:passthrough],
                    [] do
       user = insert(:user)
@@ -88,13 +88,18 @@ defmodule Pleroma.Web.FederatorTest do
       {:ok, _activity} =
         CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"})
 
-      assert called(Federator.publish_single_ap(%{inbox: inbox1, unreachable_since: dt}))
+      assert called(
+               Pleroma.Web.ActivityPub.Publisher.publish_one(%{
+                 inbox: inbox1,
+                 unreachable_since: dt
+               })
+             )
 
-      refute called(Federator.publish_single_ap(%{inbox: inbox2}))
+      refute called(Pleroma.Web.ActivityPub.Publisher.publish_one(%{inbox: inbox2}))
     end
 
     test_with_mock "it federates only to reachable instances via Websub",
-                   Federator,
+                   Pleroma.Web.Websub,
                    [:passthrough],
                    [] do
       user = insert(:user)
@@ -122,17 +127,17 @@ defmodule Pleroma.Web.FederatorTest do
       {:ok, _activity} = CommonAPI.post(user, %{"status" => "HI"})
 
       assert called(
-               Federator.publish_single_websub(%{
+               Pleroma.Web.Websub.publish_one(%{
                  callback: sub2.callback,
                  unreachable_since: dt
                })
              )
 
-      refute called(Federator.publish_single_websub(%{callback: sub1.callback}))
+      refute called(Pleroma.Web.Websub.publish_one(%{callback: sub1.callback}))
     end
 
     test_with_mock "it federates only to reachable instances via Salmon",
-                   Federator,
+                   Pleroma.Web.Salmon,
                    [:passthrough],
                    [] do
       user = insert(:user)
@@ -162,13 +167,13 @@ defmodule Pleroma.Web.FederatorTest do
         CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"})
 
       assert called(
-               Federator.publish_single_salmon(%{
+               Pleroma.Web.Salmon.publish_one(%{
                  recipient: remote_user2,
                  unreachable_since: dt
                })
              )
 
-      refute called(Federator.publish_single_websub(%{recipient: remote_user1}))
+      refute called(Pleroma.Web.Salmon.publish_one(%{recipient: remote_user1}))
     end
   end
 

test/web/mastodon_api/mastodon_api_controller_test.exs

@@ -16,6 +16,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   alias Pleroma.Web.CommonAPI
   alias Pleroma.Web.MastodonAPI.FilterView
   alias Pleroma.Web.OAuth.App
+  alias Pleroma.Web.OAuth.Token
   alias Pleroma.Web.OStatus
   alias Pleroma.Web.Push
   alias Pleroma.Web.TwitterAPI.TwitterAPI
@@ -300,6 +301,65 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
     assert status["url"] != direct.data["id"]
   end
 
+  test "Conversations", %{conn: conn} do
+    user_one = insert(:user)
+    user_two = insert(:user)
+
+    {:ok, user_two} = User.follow(user_two, user_one)
+
+    {:ok, direct} =
+      CommonAPI.post(user_one, %{
+        "status" => "Hi @#{user_two.nickname}!",
+        "visibility" => "direct"
+      })
+
+    {:ok, _follower_only} =
+      CommonAPI.post(user_one, %{
+        "status" => "Hi @#{user_two.nickname}!",
+        "visibility" => "private"
+      })
+
+    res_conn =
+      conn
+      |> assign(:user, user_one)
+      |> get("/api/v1/conversations")
+
+    assert response = json_response(res_conn, 200)
+
+    assert [
+             %{
+               "id" => res_id,
+               "accounts" => res_accounts,
+               "last_status" => res_last_status,
+               "unread" => unread
+             }
+           ] = response
+
+    assert length(res_accounts) == 2
+    assert is_binary(res_id)
+    assert unread == true
+    assert res_last_status["id"] == direct.id
+
+    # Apparently undocumented API endpoint
+    res_conn =
+      conn
+      |> assign(:user, user_one)
+      |> post("/api/v1/conversations/#{res_id}/read")
+
+    assert response = json_response(res_conn, 200)
+    assert length(response["accounts"]) == 2
+    assert response["last_status"]["id"] == direct.id
+    assert response["unread"] == false
+
+    # (vanilla) Mastodon frontend behaviour
+    res_conn =
+      conn
+      |> assign(:user, user_one)
+      |> get("/api/v1/statuses/#{res_last_status["id"]}/context")
+
+    assert %{"ancestors" => [], "descendants" => []} == json_response(res_conn, 200)
+  end
+
   test "doesn't include DMs from blocked users", %{conn: conn} do
     blocker = insert(:user)
     blocked = insert(:user)
@@ -513,6 +573,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
       assert response = json_response(conn, 200)
       assert response["phrase"] == filter.phrase
       assert response["context"] == filter.context
+      assert response["irreversible"] == false
       assert response["id"] != nil
       assert response["id"] != ""
     end
@@ -3156,4 +3217,129 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
     replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
     assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
   end
+
+  describe "create account by app" do
+    setup do
+      enabled = Pleroma.Config.get([:app_account_creation, :enabled])
+      max_requests = Pleroma.Config.get([:app_account_creation, :max_requests])
+      interval = Pleroma.Config.get([:app_account_creation, :interval])
+
+      Pleroma.Config.put([:app_account_creation, :enabled], true)
+      Pleroma.Config.put([:app_account_creation, :max_requests], 5)
+      Pleroma.Config.put([:app_account_creation, :interval], 1)
+
+      on_exit(fn ->
+        Pleroma.Config.put([:app_account_creation, :enabled], enabled)
+        Pleroma.Config.put([:app_account_creation, :max_requests], max_requests)
+        Pleroma.Config.put([:app_account_creation, :interval], interval)
+      end)
+
+      :ok
+    end
+
+    test "Account registration via Application", %{conn: conn} do
+      conn =
+        conn
+        |> post("/api/v1/apps", %{
+          client_name: "client_name",
+          redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
+          scopes: "read, write, follow"
+        })
+
+      %{
+        "client_id" => client_id,
+        "client_secret" => client_secret,
+        "id" => _,
+        "name" => "client_name",
+        "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
+        "vapid_key" => _,
+        "website" => nil
+      } = json_response(conn, 200)
+
+      conn =
+        conn
+        |> post("/oauth/token", %{
+          grant_type: "client_credentials",
+          client_id: client_id,
+          client_secret: client_secret
+        })
+
+      assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
+               json_response(conn, 200)
+
+      assert token
+      token_from_db = Repo.get_by(Token, token: token)
+      assert token_from_db
+      assert refresh
+      assert scope == "read write follow"
+
+      conn =
+        build_conn()
+        |> put_req_header("authorization", "Bearer " <> token)
+        |> post("/api/v1/accounts", %{
+          username: "lain",
+          email: "lain@example.org",
+          password: "PlzDontHackLain",
+          agreement: true
+        })
+
+      %{
+        "access_token" => token,
+        "created_at" => _created_at,
+        "scope" => _scope,
+        "token_type" => "Bearer"
+      } = json_response(conn, 200)
+
+      token_from_db = Repo.get_by(Token, token: token)
+      assert token_from_db
+      token_from_db = Repo.preload(token_from_db, :user)
+      assert token_from_db.user
+
+      assert token_from_db.user.info.confirmation_pending
+    end
+
+    test "rate limit", %{conn: conn} do
+      app_token = insert(:oauth_token, user: nil)
+
+      conn =
+        put_req_header(conn, "authorization", "Bearer " <> app_token.token)
+        |> Map.put(:remote_ip, {15, 15, 15, 15})
+
+      for i <- 1..5 do
+        conn =
+          conn
+          |> post("/api/v1/accounts", %{
+            username: "#{i}lain",
+            email: "#{i}lain@example.org",
+            password: "PlzDontHackLain",
+            agreement: true
+          })
+
+        %{
+          "access_token" => token,
+          "created_at" => _created_at,
+          "scope" => _scope,
+          "token_type" => "Bearer"
+        } = json_response(conn, 200)
+
+        token_from_db = Repo.get_by(Token, token: token)
+        assert token_from_db
+        token_from_db = Repo.preload(token_from_db, :user)
+        assert token_from_db.user
+
+        assert token_from_db.user.info.confirmation_pending
+      end
+
+      conn =
+        conn
+        |> post("/api/v1/accounts", %{
+          username: "6lain",
+          email: "6lain@example.org",
+          password: "PlzDontHackLain",
+          agreement: true
+        })
+
+      assert json_response(conn, 403) == %{"error" => "Rate limit exceeded."}
+    end
+  end
 end

test/web/mastodon_api/status_view_test.exs

@@ -168,6 +168,8 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
 
     {:ok, _bookmark} = Bookmark.create(user.id, activity.id)
 
+    activity = Activity.get_by_id_with_object(activity.id)
+
     status = StatusView.render("status.json", %{activity: activity, for: user})
 
     assert status.bookmarked == true

test/web/oauth/oauth_controller_test.exs

@@ -614,6 +614,27 @@ defmodule Pleroma.Web.OAuth.OAuthControllerTest do
       assert token.scopes == ["scope1", "scope2"]
     end
 
+    test "issue a token for client_credentials grant type" do
+      app = insert(:oauth_app, scopes: ["read", "write"])
+
+      conn =
+        build_conn()
+        |> post("/oauth/token", %{
+          "grant_type" => "client_credentials",
+          "client_id" => app.client_id,
+          "client_secret" => app.client_secret
+        })
+
+      assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
+               json_response(conn, 200)
+
+      assert token
+      token_from_db = Repo.get_by(Token, token: token)
+      assert token_from_db
+      assert refresh
+      assert scope == "read write"
+    end
+
     test "rejects token exchange with invalid client credentials" do
       user = insert(:user)
       app = insert(:oauth_app)
@@ -644,7 +665,7 @@ defmodule Pleroma.Web.OAuth.OAuthControllerTest do
 
       password = "testpassword"
       user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
-      info_change = Pleroma.User.Info.confirmation_changeset(user.info, :unconfirmed)
+      info_change = Pleroma.User.Info.confirmation_changeset(user.info, need_confirmation: true)
 
       {:ok, user} =
         user

test/web/ostatus/activity_representer_test.exs

@@ -67,37 +67,31 @@ defmodule Pleroma.Web.OStatus.ActivityRepresenterTest do
   end
 
   test "a reply note" do
-    note = insert(:note_activity)
-    answer = insert(:note_activity)
-    object = answer.data["object"]
-    object = Map.put(object, "inReplyTo", note.data["object"]["id"])
-
-    data = %{answer.data | "object" => object}
-    answer = %{answer | data: data}
-
-    note_object = Object.get_by_ap_id(note.data["object"]["id"])
+    user = insert(:user)
+    note_object = insert(:note)
+    _note = insert(:note_activity, %{note: note_object})
+    object = insert(:note, %{data: %{"inReplyTo" => note_object.data["id"]}})
+    answer = insert(:note_activity, %{note: object})
 
     Repo.update!(
       Object.change(note_object, %{data: Map.put(note_object.data, "external_url", "someurl")})
     )
 
-    user = User.get_cached_by_ap_id(answer.data["actor"])
-
     expected = """
     <activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
     <activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>
-    <id>#{answer.data["object"]["id"]}</id>
+    <id>#{object.data["id"]}</id>
     <title>New note by #{user.nickname}</title>
-    <content type="html">#{answer.data["object"]["content"]}</content>
-    <published>#{answer.data["object"]["published"]}</published>
-    <updated>#{answer.data["object"]["published"]}</updated>
+    <content type="html">#{object.data["content"]}</content>
+    <published>#{object.data["published"]}</published>
+    <updated>#{object.data["published"]}</updated>
     <ostatus:conversation ref="#{answer.data["context"]}">#{answer.data["context"]}</ostatus:conversation>
     <link ref="#{answer.data["context"]}" rel="ostatus:conversation" />
     <summary>2hu</summary>
-    <link type="application/atom+xml" href="#{answer.data["object"]["id"]}" rel="self" />
-    <link type="text/html" href="#{answer.data["object"]["id"]}" rel="alternate" />
+    <link type="application/atom+xml" href="#{object.data["id"]}" rel="self" />
+    <link type="text/html" href="#{object.data["id"]}" rel="alternate" />
     <category term="2hu"/>
-    <thr:in-reply-to ref="#{note.data["object"]["id"]}" href="someurl" />
+    <thr:in-reply-to ref="#{note_object.data["id"]}" href="someurl" />
     <link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
     <link name="2hu" rel="emoji" href="corndog.png" />
     """

test/web/salmon/salmon_test.exs

@@ -7,7 +7,9 @@ defmodule Pleroma.Web.Salmon.SalmonTest do
   alias Pleroma.Activity
   alias Pleroma.Repo
   alias Pleroma.User
+  alias Pleroma.Web.Federator.Publisher
   alias Pleroma.Web.Salmon
+  import Mock
   import Pleroma.Factory
 
   @magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"
@@ -77,7 +79,10 @@ defmodule Pleroma.Web.Salmon.SalmonTest do
              "RSA.uzg6r1peZU0vXGADWxGJ0PE34WvmhjUmydbX5YYdOiXfODVLwCMi1umGoqUDm-mRu4vNEdFBVJU1CpFA7dKzWgIsqsa501i2XqElmEveXRLvNRWFB6nG03Q5OUY2as8eE54BJm0p20GkMfIJGwP6TSFb-ICp3QjzbatuSPJ6xCE=.AQAB"
   end
 
-  test "it pushes an activity to remote accounts it's addressed to" do
+  test_with_mock "it pushes an activity to remote accounts it's addressed to",
+                 Publisher,
+                 [:passthrough],
+                 [] do
     user_data = %{
       info: %{
         salmon: "http://test-example.org/salmon"
@@ -102,10 +107,8 @@ defmodule Pleroma.Web.Salmon.SalmonTest do
     user = User.get_cached_by_ap_id(activity.data["actor"])
     {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
 
-    poster = fn url, _data, _headers ->
-      assert url == "http://test-example.org/salmon"
-    end
+    Salmon.publish(user, activity)
 
-    Salmon.publish(user, activity, poster)
+    assert called(Publisher.enqueue_one(Salmon, %{recipient: mentioned_user}))
   end
 end

test/web/twitter_api/twitter_api_controller_test.exs

@@ -1094,7 +1094,7 @@ defmodule Pleroma.Web.TwitterAPI.ControllerTest do
   describe "GET /api/account/confirm_email/:id/:token" do
     setup do
       user = insert(:user)
-      info_change = User.Info.confirmation_changeset(user.info, :unconfirmed)
+      info_change = User.Info.confirmation_changeset(user.info, need_confirmation: true)
 
       {:ok, user} =
         user
@@ -1145,7 +1145,7 @@ defmodule Pleroma.Web.TwitterAPI.ControllerTest do
       end
 
       user = insert(:user)
-      info_change = User.Info.confirmation_changeset(user.info, :unconfirmed)
+      info_change = User.Info.confirmation_changeset(user.info, need_confirmation: true)
 
       {:ok, user} =
         user

test/web/twitter_api/views/activity_view_test.exs

@@ -295,8 +295,8 @@ defmodule Pleroma.Web.TwitterAPI.ActivityViewTest do
       "id" => announce.id,
       "is_local" => true,
       "is_post_verb" => false,
-      "statusnet_html" => "shp retweeted a status.",
-      "text" => "shp retweeted a status.",
+      "statusnet_html" => "shp repeated a status.",
+      "text" => "shp repeated a status.",
       "uri" => "tag:#{announce.data["id"]}:objectType=note",
       "user" => UserView.render("show.json", user: other_user),
       "retweeted_status" => ActivityView.render("activity.json", activity: activity),

test/web/views/error_view_test.exs

@@ -4,6 +4,7 @@
 
 defmodule Pleroma.Web.ErrorViewTest do
   use Pleroma.Web.ConnCase, async: true
+  import ExUnit.CaptureLog
 
   # Bring render/3 and render_to_string/3 for testing custom views
   import Phoenix.View
@@ -13,17 +14,23 @@ defmodule Pleroma.Web.ErrorViewTest do
   end
 
   test "render 500.json" do
-    assert render(Pleroma.Web.ErrorView, "500.json", []) ==
-             %{errors: %{detail: "Internal server error", reason: "nil"}}
+    assert capture_log(fn ->
+             assert render(Pleroma.Web.ErrorView, "500.json", []) ==
+                      %{errors: %{detail: "Internal server error", reason: "nil"}}
+           end) =~ "[error] Internal server error: nil"
   end
 
   test "render any other" do
-    assert render(Pleroma.Web.ErrorView, "505.json", []) ==
-             %{errors: %{detail: "Internal server error", reason: "nil"}}
+    assert capture_log(fn ->
+             assert render(Pleroma.Web.ErrorView, "505.json", []) ==
+                      %{errors: %{detail: "Internal server error", reason: "nil"}}
+           end) =~ "[error] Internal server error: nil"
   end
 
   test "render 500.json with reason" do
-    assert render(Pleroma.Web.ErrorView, "500.json", reason: "test reason") ==
-             %{errors: %{detail: "Internal server error", reason: "\"test reason\""}}
+    assert capture_log(fn ->
+             assert render(Pleroma.Web.ErrorView, "500.json", reason: "test reason") ==
+                      %{errors: %{detail: "Internal server error", reason: "\"test reason\""}}
+           end) =~ "[error] Internal server error: \"test reason\""
   end
 end