Merge remote-tracking branch 'remotes/origin/develop' into feature/object-hashtags...

[akkoma] / test / pleroma / user_test.exs

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


@@ -1712,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


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


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


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


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


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


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


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


@@ -2177,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