Merge branch 'email-stub-in-verify-credentials' into 'develop'

[akkoma] / test / pleroma / user_test.exs

diff --git a/test/pleroma/user_test.exs b/test/pleroma/user_test.exs
index ac9db9ffb53ffd62b4477ec0c0a1a0a70db35635..be39339f34724d798c4c37b851875408635907b3 100644 (file)
--- a/test/pleroma/user_test.exs
+++ b/test/pleroma/user_test.exs
@@ -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)


@@ -552,7 +552,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
     end
 
     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 +565,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()


@@ -694,7 +694,7 @@ defmodule Pleroma.UserTest do
 
       {:ok, user} = Repo.insert(changeset)
 
 
       {:ok, user} = Repo.insert(changeset)
 

-      assert user.approval_pending
+      refute user.is_approved

       assert user.registration_reason == "I'm a cool guy :)"
     end
 
       assert user.registration_reason == "I'm a cool guy :)"
     end
 


@@ -1313,14 +1313,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 +1328,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 +1344,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 +1374,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)


@@ -1388,17 +1388,17 @@ defmodule Pleroma.UserTest do
 
   describe "approve" do
     test "approves a user" do
 
   describe "approve" do
     test "approves a user" do

-      user = insert(:user, approval_pending: true)
-      assert true == user.approval_pending
+      user = insert(:user, is_approved: false)
+      refute user.is_approved

       {:ok, user} = User.approve(user)
       {:ok, user} = User.approve(user)

-      assert false == user.approval_pending
+      assert user.is_approved

     end
 
     test "approves a list of users" do
       unapproved_users = [
     end
 
     test "approves a list of users" do
       unapproved_users = [

-        insert(:user, approval_pending: true),
-        insert(:user, approval_pending: true),
-        insert(:user, approval_pending: true)
+        insert(:user, is_approved: false),
+        insert(:user, is_approved: false),
+        insert(:user, is_approved: false)

       ]
 
       {:ok, users} = User.approve(unapproved_users)
       ]
 
       {:ok, users} = User.approve(unapproved_users)


@@ -1406,7 +1406,7 @@ defmodule Pleroma.UserTest do
       assert Enum.count(users) == 3
 
       Enum.each(users, fn user ->
       assert Enum.count(users) == 3
 
       Enum.each(users, fn user ->

-        assert false == user.approval_pending
+        assert user.is_approved

       end)
     end
 
       end)
     end
 


@@ -1414,7 +1414,7 @@ defmodule Pleroma.UserTest do
       clear_config([:welcome, :email, :enabled], true)
       clear_config([:welcome, :email, :sender], "tester@test.me")
 
       clear_config([:welcome, :email, :enabled], true)
       clear_config([:welcome, :email, :sender], "tester@test.me")
 

-      user = insert(:user, approval_pending: true)
+      user = insert(:user, is_approved: false)

       welcome_user = insert(:user, email: "tester@test.me")
       instance_name = Pleroma.Config.get([:instance, :name])
 
       welcome_user = insert(:user, email: "tester@test.me")
       instance_name = Pleroma.Config.get([:instance, :name])
 


@@ -1432,7 +1432,7 @@ defmodule Pleroma.UserTest do
     test "approving an approved user does not trigger post-register actions" do
       clear_config([:welcome, :email, :enabled], true)
 
     test "approving an approved user does not trigger post-register actions" do
       clear_config([:welcome, :email, :enabled], true)
 

-      user = insert(:user, approval_pending: false)
+      user = insert(:user, is_approved: true)

       User.approve(user)
 
       ObanHelpers.perform_all()
       User.approve(user)
 
       ObanHelpers.perform_all()


@@ -1465,9 +1465,9 @@ defmodule Pleroma.UserTest do
       end)
     end
 
       end)
     end
 

-    test "sends approval emails when `approval_pending: true`" do
+    test "sends approval emails when `is_approved: false`" do

       admin = insert(:user, is_admin: true)
       admin = insert(:user, is_admin: true)

-      user = insert(:user, is_confirmed: false, approval_pending: true)
+      user = insert(:user, is_confirmed: false, is_approved: false)

       User.confirm(user)
 
       ObanHelpers.perform_all()
       User.confirm(user)
 
       ObanHelpers.perform_all()


@@ -1494,7 +1494,7 @@ defmodule Pleroma.UserTest do
     end
 
     test "confirming a confirmed user does not trigger post-register actions" do
     end
 
     test "confirming a confirmed user does not trigger post-register actions" do

-      user = insert(:user, is_confirmed: true, approval_pending: true)
+      user = insert(:user, is_confirmed: true, is_approved: false)

       User.confirm(user)
 
       ObanHelpers.perform_all()
       User.confirm(user)
 
       ObanHelpers.perform_all()


@@ -1544,7 +1544,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,35 +1563,19 @@ 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)
-
-      {: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)
+  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)
+    {: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

-    user = insert(:user, approval_pending: true)
+    user = insert(:user, is_approved: false)

 
     {:ok, job} = User.delete(user)
     {:ok, _} = ObanHelpers.perform(job)
 
     {:ok, job} = User.delete(user)
     {:ok, _} = ObanHelpers.perform(job)


@@ -1618,11 +1602,11 @@ defmodule Pleroma.UserTest do
         is_locked: true,
         is_confirmed: false,
         password_reset_pending: true,
         is_locked: true,
         is_confirmed: false,
         password_reset_pending: true,

-        approval_pending: true,
+        is_approved: false,

         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,


@@ -1660,11 +1644,11 @@ defmodule Pleroma.UserTest do
              is_locked: false,
              is_confirmed: true,
              password_reset_pending: false,
              is_locked: false,
              is_confirmed: true,
              password_reset_pending: false,

-             approval_pending: false,
+             is_approved: true,

              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 +1712,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,15 +1734,15 @@ 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
 
     test "returns :approval_pending for unapproved user" do
       assert User.account_status(user) == :deactivated
     end
 
     test "returns :approval_pending for unapproved user" do

-      user = insert(:user, local: true, approval_pending: true)
+      user = insert(:user, local: true, is_approved: false)

       assert User.account_status(user) == :approval_pending
 
       assert User.account_status(user) == :approval_pending
 

-      user = insert(:user, local: true, is_confirmed: false, approval_pending: true)
+      user = insert(:user, local: true, is_confirmed: false, is_approved: false)

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


@@ -1813,7 +1797,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 +1806,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)


@@ -1830,15 +1814,8 @@ defmodule Pleroma.UserTest do
       assert User.visible_for(user, other_user) == :visible
     end
 
       assert User.visible_for(user, other_user) == :visible
     end
 

-    test "returns true when the account is unconfirmed and confirmation is not required" do
-      user = insert(:user, local: true, is_confirmed: false)
-      other_user = insert(:user, local: true)
-
-      assert User.visible_for(user, other_user) == :visible
-    end
-

     test "returns true when the account is unconfirmed and being viewed by a privileged account (confirmation required)" do
     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)


@@ -1908,7 +1885,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 =


@@ -1926,7 +1903,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))


@@ -1959,7 +1936,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


@@ -2029,7 +2006,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
 


@@ -2095,7 +2072,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 =


@@ -2116,7 +2093,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)
 


@@ -2131,14 +2108,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)
 


@@ -2153,7 +2130,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


@@ -2200,43 +2177,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


@@ -2255,6 +2232,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"


@@ -2271,4 +2278,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