Deprecate Pleroma.Web.base_url/0

[akkoma] / test / pleroma / user_test.exs

diff --git a/test/pleroma/user_test.exs b/test/pleroma/user_test.exs
index a85e89a50a2f573ea4dc7a5690287a9ae294e53d..79c7d7ed158b8132bd621c4cea2e47155afa517a 100644 (file)
--- a/test/pleroma/user_test.exs
+++ b/test/pleroma/user_test.exs
@@ -151,7 +151,7 @@ defmodule Pleroma.UserTest do
   test "ap_id returns the activity pub id for the user" do
     user = UserBuilder.build()
 
   test "ap_id returns the activity pub id for the user" do
     user = UserBuilder.build()
 

-    expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
+    expected_ap_id = "#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}"

 
     assert expected_ap_id == User.ap_id(user)
   end
 
     assert expected_ap_id == User.ap_id(user)
   end


@@ -202,11 +202,11 @@ defmodule Pleroma.UserTest do
 
   test "doesn't return follow requests for deactivated accounts" do
     locked = insert(:user, is_locked: true)
 
   test "doesn't return follow requests for deactivated accounts" do
     locked = insert(:user, is_locked: true)

-    pending_follower = insert(:user, %{deactivated: true})
+    pending_follower = insert(:user, %{is_active: false})

 
     CommonAPI.follow(pending_follower, locked)
 
 
     CommonAPI.follow(pending_follower, locked)
 

-    assert true == pending_follower.deactivated
+    refute pending_follower.is_active

     assert [] = User.get_follow_requests(locked)
   end
 
     assert [] = User.get_follow_requests(locked)
   end
 


@@ -275,7 +275,7 @@ defmodule Pleroma.UserTest do
 
   test "can't follow a deactivated users" do
     user = insert(:user)
 
   test "can't follow a deactivated users" do
     user = insert(:user)

-    followed = insert(:user, %{deactivated: true})
+    followed = insert(:user, %{is_active: false})

 
     {:error, _} = User.follow(user, followed)
   end
 
     {:error, _} = User.follow(user, followed)
   end


@@ -311,7 +311,7 @@ defmodule Pleroma.UserTest do
     setup do: clear_config([:instance, :external_user_synchronization])
 
     test "unfollow with syncronizes external user" do
     setup do: clear_config([:instance, :external_user_synchronization])
 
     test "unfollow with syncronizes external user" do

-      Pleroma.Config.put([:instance, :external_user_synchronization], true)
+      clear_config([:instance, :external_user_synchronization], true)

 
       followed =
         insert(:user,
 
       followed =
         insert(:user,


@@ -396,7 +396,7 @@ defmodule Pleroma.UserTest do
       user = insert(:user)
       remote_user = insert(:user, %{local: false})
 
       user = insert(:user)
       remote_user = insert(:user, %{local: false})
 

-      Pleroma.Config.put([:instance, :autofollowed_nicknames], [
+      clear_config([:instance, :autofollowed_nicknames], [

         user.nickname,
         remote_user.nickname
       ])
         user.nickname,
         remote_user.nickname
       ])


@@ -413,7 +413,7 @@ defmodule Pleroma.UserTest do
       user1 = insert(:user)
       user2 = insert(:user)
 
       user1 = insert(:user)
       user2 = insert(:user)
 

-      Pleroma.Config.put([:instance, :autofollowing_nicknames], [
+      clear_config([:instance, :autofollowing_nicknames], [

         user1.nickname,
         user2.nickname
       ])
         user1.nickname,
         user2.nickname
       ])


@@ -428,9 +428,9 @@ defmodule Pleroma.UserTest do
 
     test "it sends a welcome message if it is set" do
       welcome_user = insert(:user)
 
     test "it sends a welcome message if it is set" do
       welcome_user = insert(:user)

-      Pleroma.Config.put([:welcome, :direct_message, :enabled], true)
-      Pleroma.Config.put([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
-      Pleroma.Config.put([:welcome, :direct_message, :message], "Hello, this is a direct message")
+      clear_config([:welcome, :direct_message, :enabled], true)
+      clear_config([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
+      clear_config([:welcome, :direct_message, :message], "Hello, this is a direct message")

 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)
 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)


@@ -444,9 +444,9 @@ defmodule Pleroma.UserTest do
 
     test "it sends a welcome chat message if it is set" do
       welcome_user = insert(:user)
 
     test "it sends a welcome chat message if it is set" do
       welcome_user = insert(:user)

-      Pleroma.Config.put([:welcome, :chat_message, :enabled], true)
-      Pleroma.Config.put([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
-      Pleroma.Config.put([:welcome, :chat_message, :message], "Hello, this is a chat message")
+      clear_config([:welcome, :chat_message, :enabled], true)
+      clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
+      clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")

 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)
 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)


@@ -480,12 +480,12 @@ defmodule Pleroma.UserTest do
             )
 
     test "it sends a welcome chat message when Simple policy applied to local instance" do
             )
 
     test "it sends a welcome chat message when Simple policy applied to local instance" do

-      Pleroma.Config.put([:mrf_simple, :media_nsfw], ["localhost"])
+      clear_config([:mrf_simple, :media_nsfw], ["localhost"])

 
       welcome_user = insert(:user)
 
       welcome_user = insert(:user)

-      Pleroma.Config.put([:welcome, :chat_message, :enabled], true)
-      Pleroma.Config.put([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
-      Pleroma.Config.put([:welcome, :chat_message, :message], "Hello, this is a chat message")
+      clear_config([:welcome, :chat_message, :enabled], true)
+      clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
+      clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")

 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)
 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)


@@ -499,10 +499,10 @@ defmodule Pleroma.UserTest do
 
     test "it sends a welcome email message if it is set" do
       welcome_user = insert(:user)
 
     test "it sends a welcome email message if it is set" do
       welcome_user = insert(:user)

-      Pleroma.Config.put([:welcome, :email, :enabled], true)
-      Pleroma.Config.put([:welcome, :email, :sender], welcome_user.email)
+      clear_config([:welcome, :email, :enabled], true)
+      clear_config([:welcome, :email, :sender], welcome_user.email)

 
 

-      Pleroma.Config.put(
+      clear_config(

         [:welcome, :email, :subject],
         "Hello, welcome to cool site: <%= instance_name %>"
       )
         [:welcome, :email, :subject],
         "Hello, welcome to cool site: <%= instance_name %>"
       )


@@ -522,7 +522,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "it sends a confirm email" do
     end
 
     test "it sends a confirm email" do

-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)

 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)
 
       cng = User.register_changeset(%User{}, @full_user_data)
       {:ok, registered_user} = User.register(cng)


@@ -551,8 +551,29 @@ defmodule Pleroma.UserTest do
       )
     end
 
       )
     end
 

+    test "it sends a registration confirmed email if no others will be sent" do
+      clear_config([:welcome, :email, :enabled], false)
+      clear_config([:instance, :account_activation_required], false)
+      clear_config([:instance, :account_approval_required], false)
+
+      {:ok, user} =
+        User.register_changeset(%User{}, @full_user_data)
+        |> User.register()
+
+      ObanHelpers.perform_all()
+
+      instance_name = Pleroma.Config.get([:instance, :name])
+      sender = Pleroma.Config.get([:instance, :notify_email])
+
+      assert_email_sent(
+        from: {instance_name, sender},
+        to: {user.name, user.email},
+        subject: "Account registered on #{instance_name}"
+      )
+    end
+

     test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
     test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do

-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)

 
       @full_user_data
       |> Map.keys()
 
       @full_user_data
       |> Map.keys()


@@ -565,7 +586,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do
     end
 
     test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do

-      Pleroma.Config.put([:instance, :account_activation_required], false)
+      clear_config([:instance, :account_activation_required], false)

 
       @full_user_data
       |> Map.keys()
 
       @full_user_data
       |> Map.keys()


@@ -1313,14 +1334,14 @@ defmodule Pleroma.UserTest do
     end
   end
 
     end
   end
 

-  describe ".deactivate" do
+  describe ".set_activation" do

     test "can de-activate then re-activate a user" do
       user = insert(:user)
     test "can de-activate then re-activate a user" do
       user = insert(:user)

-      assert false == user.deactivated
-      {:ok, user} = User.deactivate(user)
-      assert true == user.deactivated
-      {:ok, user} = User.deactivate(user, false)
-      assert false == user.deactivated
+      assert user.is_active
+      {:ok, user} = User.set_activation(user, false)
+      refute user.is_active
+      {:ok, user} = User.set_activation(user, true)
+      assert user.is_active

     end
 
     test "hide a user from followers" do
     end
 
     test "hide a user from followers" do


@@ -1328,7 +1349,7 @@ defmodule Pleroma.UserTest do
       user2 = insert(:user)
 
       {:ok, user, user2} = User.follow(user, user2)
       user2 = insert(:user)
 
       {:ok, user, user2} = User.follow(user, user2)

-      {:ok, _user} = User.deactivate(user)
+      {:ok, _user} = User.set_activation(user, false)

 
       user2 = User.get_cached_by_id(user2.id)
 
 
       user2 = User.get_cached_by_id(user2.id)
 


@@ -1344,7 +1365,7 @@ defmodule Pleroma.UserTest do
       assert user2.following_count == 1
       assert User.following_count(user2) == 1
 
       assert user2.following_count == 1
       assert User.following_count(user2) == 1
 

-      {:ok, _user} = User.deactivate(user)
+      {:ok, _user} = User.set_activation(user, false)

 
       user2 = User.get_cached_by_id(user2.id)
 
 
       user2 = User.get_cached_by_id(user2.id)
 


@@ -1374,7 +1395,7 @@ defmodule Pleroma.UserTest do
                  user: user2
                })
 
                  user: user2
                })
 

-      {:ok, _user} = User.deactivate(user)
+      {:ok, _user} = User.set_activation(user, false)

 
       assert [] == ActivityPub.fetch_public_activities(%{})
       assert [] == Pleroma.Notification.for_user(user2)
 
       assert [] == ActivityPub.fetch_public_activities(%{})
       assert [] == Pleroma.Notification.for_user(user2)


@@ -1544,7 +1565,7 @@ defmodule Pleroma.UserTest do
       follower = User.get_cached_by_id(follower.id)
 
       refute User.following?(follower, user)
       follower = User.get_cached_by_id(follower.id)
 
       refute User.following?(follower, user)

-      assert %{deactivated: true} = User.get_by_id(user.id)
+      assert %{is_active: false} = User.get_by_id(user.id)

 
       assert [] == User.get_follow_requests(locked_user)
 
 
       assert [] == User.get_follow_requests(locked_user)
 


@@ -1563,31 +1584,15 @@ defmodule Pleroma.UserTest do
     end
   end
 
     end
   end
 

-  describe "delete/1 when confirmation is pending" do
-    setup do
-      user = insert(:user, is_confirmed: false)
-      {:ok, user: user}
-    end
-
-    test "deletes user from database when activation required", %{user: user} do
-      clear_config([:instance, :account_activation_required], true)
+  test "delete/1 when confirmation is pending deletes the user" do
+    clear_config([:instance, :account_activation_required], true)
+    user = insert(:user, is_confirmed: false)

 
 

-      {:ok, job} = User.delete(user)
-      {:ok, _} = ObanHelpers.perform(job)
-
-      refute User.get_cached_by_id(user.id)
-      refute User.get_by_id(user.id)
-    end
-
-    test "deactivates user when activation is not required", %{user: user} do
-      clear_config([:instance, :account_activation_required], false)
-
-      {:ok, job} = User.delete(user)
-      {:ok, _} = ObanHelpers.perform(job)
+    {:ok, job} = User.delete(user)
+    {:ok, _} = ObanHelpers.perform(job)

 
 

-      assert %{deactivated: true} = User.get_cached_by_id(user.id)
-      assert %{deactivated: true} = User.get_by_id(user.id)
-    end
+    refute User.get_cached_by_id(user.id)
+    refute User.get_by_id(user.id)

   end
 
   test "delete/1 when approval is pending deletes the user" do
   end
 
   test "delete/1 when approval is pending deletes the user" do


@@ -1622,7 +1627,7 @@ defmodule Pleroma.UserTest do
         registration_reason: "ahhhhh",
         confirmation_token: "qqqq",
         domain_blocks: ["lain.com"],
         registration_reason: "ahhhhh",
         confirmation_token: "qqqq",
         domain_blocks: ["lain.com"],

-        deactivated: true,
+        is_active: false,

         ap_enabled: true,
         is_moderator: true,
         is_admin: true,
         ap_enabled: true,
         is_moderator: true,
         is_admin: true,


@@ -1664,7 +1669,7 @@ defmodule Pleroma.UserTest do
              registration_reason: nil,
              confirmation_token: nil,
              domain_blocks: [],
              registration_reason: nil,
              confirmation_token: nil,
              domain_blocks: [],

-             deactivated: true,
+             is_active: false,

              ap_enabled: false,
              is_moderator: false,
              is_admin: false,
              ap_enabled: false,
              is_moderator: false,
              is_admin: false,


@@ -1728,13 +1733,13 @@ defmodule Pleroma.UserTest do
     setup do: clear_config([:instance, :account_activation_required])
 
     test "return confirmation_pending for unconfirm user" do
     setup do: clear_config([:instance, :account_activation_required])
 
     test "return confirmation_pending for unconfirm user" do

-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)

       user = insert(:user, is_confirmed: false)
       assert User.account_status(user) == :confirmation_pending
     end
 
     test "return active for confirmed user" do
       user = insert(:user, is_confirmed: false)
       assert User.account_status(user) == :confirmation_pending
     end
 
     test "return active for confirmed user" do

-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)

       user = insert(:user, is_confirmed: true)
       assert User.account_status(user) == :active
     end
       user = insert(:user, is_confirmed: true)
       assert User.account_status(user) == :active
     end


@@ -1750,7 +1755,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "returns :deactivated for deactivated user" do
     end
 
     test "returns :deactivated for deactivated user" do

-      user = insert(:user, local: true, is_confirmed: true, deactivated: true)
+      user = insert(:user, local: true, is_confirmed: true, is_active: false)

       assert User.account_status(user) == :deactivated
     end
 
       assert User.account_status(user) == :deactivated
     end
 


@@ -1813,7 +1818,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "returns false when the account is unconfirmed and confirmation is required" do
     end
 
     test "returns false when the account is unconfirmed and confirmation is required" do

-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)

 
       user = insert(:user, local: true, is_confirmed: false)
       other_user = insert(:user, local: true)
 
       user = insert(:user, local: true, is_confirmed: false)
       other_user = insert(:user, local: true)


@@ -1822,7 +1827,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "returns true when the account is unconfirmed and confirmation is required but the account is remote" do
     end
 
     test "returns true when the account is unconfirmed and confirmation is required but the account is remote" do

-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)

 
       user = insert(:user, local: false, is_confirmed: false)
       other_user = insert(:user, local: true)
 
       user = insert(:user, local: false, is_confirmed: false)
       other_user = insert(:user, local: true)


@@ -1831,7 +1836,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "returns true when the account is unconfirmed and being viewed by a privileged account (confirmation required)" do
     end
 
     test "returns true when the account is unconfirmed and being viewed by a privileged account (confirmation required)" do

-      Pleroma.Config.put([:instance, :account_activation_required], true)
+      clear_config([:instance, :account_activation_required], true)

 
       user = insert(:user, local: true, is_confirmed: false)
       other_user = insert(:user, local: true, is_admin: true)
 
       user = insert(:user, local: true, is_confirmed: false)
       other_user = insert(:user, local: true, is_admin: true)


@@ -1901,7 +1906,7 @@ defmodule Pleroma.UserTest do
 
       users =
         Enum.map(1..total, fn _ ->
 
       users =
         Enum.map(1..total, fn _ ->

-          insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
+          insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)

         end)
 
       inactive_users_ids =
         end)
 
       inactive_users_ids =


@@ -1919,7 +1924,7 @@ defmodule Pleroma.UserTest do
 
       users =
         Enum.map(1..total, fn _ ->
 
       users =
         Enum.map(1..total, fn _ ->

-          insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
+          insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)

         end)
 
       {inactive, active} = Enum.split(users, trunc(total / 2))
         end)
 
       {inactive, active} = Enum.split(users, trunc(total / 2))


@@ -1952,7 +1957,7 @@ defmodule Pleroma.UserTest do
 
       users =
         Enum.map(1..total, fn _ ->
 
       users =
         Enum.map(1..total, fn _ ->

-          insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
+          insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)

         end)
 
       [sender | recipients] = users
         end)
 
       [sender | recipients] = users


@@ -2022,7 +2027,7 @@ defmodule Pleroma.UserTest do
       user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
       user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
       insert(:user, local: true)
       user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
       user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
       insert(:user, local: true)

-      insert(:user, local: false, deactivated: true)
+      insert(:user, local: false, is_active: false)

       {:ok, user1: user1, user2: user2}
     end
 
       {:ok, user1: user1, user2: user2}
     end
 


@@ -2088,7 +2093,7 @@ defmodule Pleroma.UserTest do
     setup do: clear_config([:instance, :external_user_synchronization])
 
     test "updates the counters normally on following/getting a follow when disabled" do
     setup do: clear_config([:instance, :external_user_synchronization])
 
     test "updates the counters normally on following/getting a follow when disabled" do

-      Pleroma.Config.put([:instance, :external_user_synchronization], false)
+      clear_config([:instance, :external_user_synchronization], false)

       user = insert(:user)
 
       other_user =
       user = insert(:user)
 
       other_user =


@@ -2109,7 +2114,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "syncronizes the counters with the remote instance for the followed when enabled" do
     end
 
     test "syncronizes the counters with the remote instance for the followed when enabled" do

-      Pleroma.Config.put([:instance, :external_user_synchronization], false)
+      clear_config([:instance, :external_user_synchronization], false)

 
       user = insert(:user)
 
 
       user = insert(:user)
 


@@ -2124,14 +2129,14 @@ defmodule Pleroma.UserTest do
       assert other_user.following_count == 0
       assert other_user.follower_count == 0
 
       assert other_user.following_count == 0
       assert other_user.follower_count == 0
 

-      Pleroma.Config.put([:instance, :external_user_synchronization], true)
+      clear_config([:instance, :external_user_synchronization], true)

       {:ok, _user, other_user} = User.follow(user, other_user)
 
       assert other_user.follower_count == 437
     end
 
     test "syncronizes the counters with the remote instance for the follower when enabled" do
       {:ok, _user, other_user} = User.follow(user, other_user)
 
       assert other_user.follower_count == 437
     end
 
     test "syncronizes the counters with the remote instance for the follower when enabled" do

-      Pleroma.Config.put([:instance, :external_user_synchronization], false)
+      clear_config([:instance, :external_user_synchronization], false)

 
       user = insert(:user)
 
 
       user = insert(:user)
 


@@ -2146,7 +2151,7 @@ defmodule Pleroma.UserTest do
       assert other_user.following_count == 0
       assert other_user.follower_count == 0
 
       assert other_user.following_count == 0
       assert other_user.follower_count == 0
 

-      Pleroma.Config.put([:instance, :external_user_synchronization], true)
+      clear_config([:instance, :external_user_synchronization], true)

       {:ok, other_user, _user} = User.follow(other_user, user)
 
       assert other_user.following_count == 152
       {:ok, other_user, _user} = User.follow(other_user, user)
 
       assert other_user.following_count == 152


@@ -2193,43 +2198,43 @@ defmodule Pleroma.UserTest do
     test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
       remote_user: remote_user
     } do
     test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
       remote_user: remote_user
     } do

-      Pleroma.Config.put([:instance, :limit_to_local_content], false)
+      clear_config([:instance, :limit_to_local_content], false)

       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
 
       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
 

-      Pleroma.Config.put([:instance, :limit_to_local_content], true)
+      clear_config([:instance, :limit_to_local_content], true)

       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
 
       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
 

-      Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
+      clear_config([:instance, :limit_to_local_content], :unauthenticated)

       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
     end
 
     test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
          %{remote_user: remote_user} do
       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
     end
 
     test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
          %{remote_user: remote_user} do

-      Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
+      clear_config([:instance, :limit_to_local_content], :unauthenticated)

       assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
     end
 
     test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
          %{remote_user: remote_user, local_user: local_user} do
       assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
     end
 
     test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
          %{remote_user: remote_user, local_user: local_user} do

-      Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
+      clear_config([:instance, :limit_to_local_content], :unauthenticated)

       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
     end
 
     test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
          %{remote_user: remote_user} do
       assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
     end
 
     test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
          %{remote_user: remote_user} do

-      Pleroma.Config.put([:instance, :limit_to_local_content], true)
+      clear_config([:instance, :limit_to_local_content], true)

       assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
     end
 
     test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
          %{local_user: local_user} do
       assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
     end
 
     test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
          %{local_user: local_user} do

-      Pleroma.Config.put([:instance, :limit_to_local_content], false)
+      clear_config([:instance, :limit_to_local_content], false)

       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
 
       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
 

-      Pleroma.Config.put([:instance, :limit_to_local_content], true)
+      clear_config([:instance, :limit_to_local_content], true)

       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
 
       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
 

-      Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
+      clear_config([:instance, :limit_to_local_content], :unauthenticated)

       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
     end
   end
       assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
     end
   end


@@ -2248,6 +2253,36 @@ defmodule Pleroma.UserTest do
     end
   end
 
     end
   end
 

+  describe "local_nickname/1" do
+    test "returns nickname without host" do
+      assert User.local_nickname("@mentioned") == "mentioned"
+      assert User.local_nickname("a_local_nickname") == "a_local_nickname"
+      assert User.local_nickname("nickname@host.com") == "nickname"
+    end
+  end
+
+  describe "full_nickname/1" do
+    test "returns fully qualified nickname for local and remote users" do
+      local_user =
+        insert(:user, nickname: "local_user", ap_id: "https://somehost.com/users/local_user")
+
+      remote_user = insert(:user, nickname: "remote@host.com", local: false)
+
+      assert User.full_nickname(local_user) == "local_user@somehost.com"
+      assert User.full_nickname(remote_user) == "remote@host.com"
+    end
+
+    test "strips leading @ from mentions" do
+      assert User.full_nickname("@mentioned") == "mentioned"
+      assert User.full_nickname("@nickname@host.com") == "nickname@host.com"
+    end
+
+    test "does not modify nicknames" do
+      assert User.full_nickname("nickname") == "nickname"
+      assert User.full_nickname("nickname@host.com") == "nickname@host.com"
+    end
+  end
+

   test "avatar fallback" do
     user = insert(:user)
     assert User.avatar_url(user) =~ "/images/avi.png"
   test "avatar fallback" do
     user = insert(:user)
     assert User.avatar_url(user) =~ "/images/avi.png"


@@ -2264,4 +2299,43 @@ defmodule Pleroma.UserTest do
     user = insert(:user, ap_id: "https://lain.com/users/lain", nickname: "lain")
     assert User.get_host(user) == "lain.com"
   end
     user = insert(:user, ap_id: "https://lain.com/users/lain", nickname: "lain")
     assert User.get_host(user) == "lain.com"
   end

+
+  test "update_last_active_at/1" do
+    user = insert(:user)
+    assert is_nil(user.last_active_at)
+
+    test_started_at = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
+
+    assert {:ok, user} = User.update_last_active_at(user)
+
+    assert user.last_active_at >= test_started_at
+    assert user.last_active_at <= NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
+
+    last_active_at =
+      NaiveDateTime.utc_now()
+      |> NaiveDateTime.add(-:timer.hours(24), :millisecond)
+      |> NaiveDateTime.truncate(:second)
+
+    assert {:ok, user} =
+             user
+             |> cast(%{last_active_at: last_active_at}, [:last_active_at])
+             |> User.update_and_set_cache()
+
+    assert user.last_active_at == last_active_at
+    assert {:ok, user} = User.update_last_active_at(user)
+    assert user.last_active_at >= test_started_at
+    assert user.last_active_at <= NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
+  end
+
+  test "active_user_count/1" do
+    insert(:user)
+    insert(:user, %{local: false})
+    insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -5)})
+    insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -3)})
+    insert(:user, %{last_active_at: NaiveDateTime.utc_now()})
+
+    assert User.active_user_count() == 2
+    assert User.active_user_count(6) == 3
+    assert User.active_user_count(1) == 1
+  end

 end
 end