Merge branch 'fix/1658-invite-send' into 'develop'

[akkoma] / test / web / mastodon_api / views / account_view_test.exs

diff --git a/test/web/mastodon_api/views/account_view_test.exs b/test/web/mastodon_api/views/account_view_test.exs
index f2f334992c686babc77d97b26b3ba0e1281dde75..4435f69ff6669faf6289651badcbcb4540ef31f2 100644 (file)
--- a/test/web/mastodon_api/views/account_view_test.exs
+++ b/test/web/mastodon_api/views/account_view_test.exs
@@ -1,14 +1,23 @@
 # Pleroma: A lightweight social networking server
 # Pleroma: A lightweight social networking server

-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>

 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
   use Pleroma.DataCase
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
   use Pleroma.DataCase

-  import Pleroma.Factory
+

   alias Pleroma.User
   alias Pleroma.User

+  alias Pleroma.UserRelationship

   alias Pleroma.Web.CommonAPI
   alias Pleroma.Web.MastodonAPI.AccountView
 
   alias Pleroma.Web.CommonAPI
   alias Pleroma.Web.MastodonAPI.AccountView
 

+  import Pleroma.Factory
+  import Tesla.Mock
+
+  setup do
+    mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
+    :ok
+  end
+

   test "Represent a user account" do
     source_data = %{
       "tag" => [
   test "Represent a user account" do
     source_data = %{
       "tag" => [


@@ -26,15 +35,14 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
 
     user =
       insert(:user, %{
 
     user =
       insert(:user, %{

-        info: %{
-          note_count: 5,
-          follower_count: 3,
-          source_data: source_data,
-          background: background_image
-        },
+        follower_count: 3,
+        note_count: 5,
+        source_data: source_data,
+        background: background_image,

         nickname: "shp@shitposter.club",
         name: ":karjalanpiirakka: shp",
         nickname: "shp@shitposter.club",
         name: ":karjalanpiirakka: shp",

-        bio: "<script src=\"invalid-html\"></script><span>valid html</span>",
+        bio:
+          "<script src=\"invalid-html\"></script><span>valid html</span>. a<br>b<br/>c<br >d<br />f",

         inserted_at: ~N[2017-08-15 15:47:06.597036]
       })
 
         inserted_at: ~N[2017-08-15 15:47:06.597036]
       })
 


@@ -48,7 +56,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
       followers_count: 3,
       following_count: 0,
       statuses_count: 5,
       followers_count: 3,
       following_count: 0,
       statuses_count: 5,

-      note: "<span>valid html</span>",
+      note: "<span>valid html</span>. a<br/>b<br/>c<br/>d<br/>f",

       url: user.ap_id,
       avatar: "http://localhost:4001/images/avi.png",
       avatar_static: "http://localhost:4001/images/avi.png",
       url: user.ap_id,
       avatar: "http://localhost:4001/images/avi.png",
       avatar_static: "http://localhost:4001/images/avi.png",


@@ -65,9 +73,10 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
       fields: [],
       bot: false,
       source: %{
       fields: [],
       bot: false,
       source: %{

-        note: "valid html",
+        note: "valid html. a\nb\nc\nd\nf",

         sensitive: false,
         pleroma: %{
         sensitive: false,
         pleroma: %{

+          actor_type: "Person",

           discoverable: false
         },
         fields: []
           discoverable: false
         },
         fields: []


@@ -88,31 +97,28 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
       }
     }
 
       }
     }
 

-    assert expected == AccountView.render("account.json", %{user: user})
+    assert expected == AccountView.render("show.json", %{user: user})

   end
 
   test "Represent the user account for the account owner" do
     user = insert(:user)
 
   end
 
   test "Represent the user account for the account owner" do
     user = insert(:user)
 

-    notification_settings = %{
-      "followers" => true,
-      "follows" => true,
-      "non_follows" => true,
-      "non_followers" => true
-    }
-
-    privacy = user.info.default_scope
+    notification_settings = %Pleroma.User.NotificationSetting{}
+    privacy = user.default_scope

 
     assert %{
 
     assert %{

-             pleroma: %{notification_settings: ^notification_settings},
+             pleroma: %{notification_settings: ^notification_settings, allow_following_move: true},

              source: %{privacy: ^privacy}
              source: %{privacy: ^privacy}

-           } = AccountView.render("account.json", %{user: user, for: user})
+           } = AccountView.render("show.json", %{user: user, for: user})

   end
 
   test "Represent a Service(bot) account" do
     user =
       insert(:user, %{
   end
 
   test "Represent a Service(bot) account" do
     user =
       insert(:user, %{

-        info: %{note_count: 5, follower_count: 3, source_data: %{"type" => "Service"}},
+        follower_count: 3,
+        note_count: 5,
+        source_data: %{},
+        actor_type: "Service",

         nickname: "shp@shitposter.club",
         inserted_at: ~N[2017-08-15 15:47:06.597036]
       })
         nickname: "shp@shitposter.club",
         inserted_at: ~N[2017-08-15 15:47:06.597036]
       })


@@ -140,6 +146,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
         note: user.bio,
         sensitive: false,
         pleroma: %{
         note: user.bio,
         sensitive: false,
         pleroma: %{

+          actor_type: "Service",

           discoverable: false
         },
         fields: []
           discoverable: false
         },
         fields: []


@@ -160,13 +167,24 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
       }
     }
 
       }
     }
 

-    assert expected == AccountView.render("account.json", %{user: user})
+    assert expected == AccountView.render("show.json", %{user: user})
+  end
+
+  test "Represent a Funkwhale channel" do
+    {:ok, user} =
+      User.get_or_fetch_by_ap_id(
+        "https://channels.tests.funkwhale.audio/federation/actors/compositions"
+      )
+
+    assert represented = AccountView.render("show.json", %{user: user})
+    assert represented.acct == "compositions@channels.tests.funkwhale.audio"
+    assert represented.url == "https://channels.tests.funkwhale.audio/channels/compositions"

   end
 
   test "Represent a deactivated user for an admin" do
   end
 
   test "Represent a deactivated user for an admin" do

-    admin = insert(:user, %{info: %{is_admin: true}})
-    deactivated_user = insert(:user, %{info: %{deactivated: true}})
-    represented = AccountView.render("account.json", %{user: deactivated_user, for: admin})
+    admin = insert(:user, is_admin: true)
+    deactivated_user = insert(:user, deactivated: true)
+    represented = AccountView.render("show.json", %{user: deactivated_user, for: admin})

     assert represented[:pleroma][:deactivated] == true
   end
 
     assert represented[:pleroma][:deactivated] == true
   end
 


@@ -184,33 +202,57 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
   end
 
   describe "relationship" do
   end
 
   describe "relationship" do

+    defp test_relationship_rendering(user, other_user, expected_result) do
+      opts = %{user: user, target: other_user, relationships: nil}
+      assert expected_result == AccountView.render("relationship.json", opts)
+
+      relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
+      opts = Map.put(opts, :relationships, relationships_opt)
+      assert expected_result == AccountView.render("relationship.json", opts)
+
+      assert [expected_result] ==
+               AccountView.render("relationships.json", %{user: user, targets: [other_user]})
+    end
+
+    @blank_response %{
+      following: false,
+      followed_by: false,
+      blocking: false,
+      blocked_by: false,
+      muting: false,
+      muting_notifications: false,
+      subscribing: false,
+      requested: false,
+      domain_blocking: false,
+      showing_reblogs: true,
+      endorsed: false
+    }
+

     test "represent a relationship for the following and followed user" do
       user = insert(:user)
       other_user = insert(:user)
 
       {:ok, user} = User.follow(user, other_user)
       {:ok, other_user} = User.follow(other_user, user)
     test "represent a relationship for the following and followed user" do
       user = insert(:user)
       other_user = insert(:user)
 
       {:ok, user} = User.follow(user, other_user)
       {:ok, other_user} = User.follow(other_user, user)

-      {:ok, other_user} = User.subscribe(user, other_user)
-      {:ok, user} = User.mute(user, other_user, true)
-      {:ok, user} = CommonAPI.hide_reblogs(user, other_user)
-
-      expected = %{
-        id: to_string(other_user.id),
-        following: true,
-        followed_by: true,
-        blocking: false,
-        blocked_by: false,
-        muting: true,
-        muting_notifications: true,
-        subscribing: true,
-        requested: false,
-        domain_blocking: false,
-        showing_reblogs: false,
-        endorsed: false
-      }
-
-      assert expected ==
-               AccountView.render("relationship.json", %{user: user, target: other_user})
+      {:ok, _subscription} = User.subscribe(user, other_user)
+      {:ok, _user_relationships} = User.mute(user, other_user, true)
+      {:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, other_user)
+
+      expected =
+        Map.merge(
+          @blank_response,
+          %{
+            following: true,
+            followed_by: true,
+            muting: true,
+            muting_notifications: true,
+            subscribing: true,
+            showing_reblogs: false,
+            id: to_string(other_user.id)
+          }
+        )
+
+      test_relationship_rendering(user, other_user, expected)

     end
 
     test "represent a relationship for the blocking and blocked user" do
     end
 
     test "represent a relationship for the blocking and blocked user" do


@@ -218,27 +260,17 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
       other_user = insert(:user)
 
       {:ok, user} = User.follow(user, other_user)
       other_user = insert(:user)
 
       {:ok, user} = User.follow(user, other_user)

-      {:ok, other_user} = User.subscribe(user, other_user)
-      {:ok, user} = User.block(user, other_user)
-      {:ok, other_user} = User.block(other_user, user)
-
-      expected = %{
-        id: to_string(other_user.id),
-        following: false,
-        followed_by: false,
-        blocking: true,
-        blocked_by: true,
-        muting: false,
-        muting_notifications: false,
-        subscribing: false,
-        requested: false,
-        domain_blocking: false,
-        showing_reblogs: true,
-        endorsed: false
-      }
+      {:ok, _subscription} = User.subscribe(user, other_user)
+      {:ok, _user_relationship} = User.block(user, other_user)
+      {:ok, _user_relationship} = User.block(other_user, user)
+
+      expected =
+        Map.merge(
+          @blank_response,
+          %{following: false, blocking: true, blocked_by: true, id: to_string(other_user.id)}
+        )

 
 

-      assert expected ==
-               AccountView.render("relationship.json", %{user: user, target: other_user})
+      test_relationship_rendering(user, other_user, expected)

     end
 
     test "represent a relationship for the user blocking a domain" do
     end
 
     test "represent a relationship for the user blocking a domain" do


@@ -247,49 +279,47 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
 
       {:ok, user} = User.block_domain(user, "bad.site")
 
 
       {:ok, user} = User.block_domain(user, "bad.site")
 

-      assert %{domain_blocking: true, blocking: false} =
-               AccountView.render("relationship.json", %{user: user, target: other_user})
+      expected =
+        Map.merge(
+          @blank_response,
+          %{domain_blocking: true, blocking: false, id: to_string(other_user.id)}
+        )
+
+      test_relationship_rendering(user, other_user, expected)

     end
 
     test "represent a relationship for the user with a pending follow request" do
       user = insert(:user)
     end
 
     test "represent a relationship for the user with a pending follow request" do
       user = insert(:user)

-      other_user = insert(:user, %{info: %User.Info{locked: true}})
+      other_user = insert(:user, locked: true)

 
       {:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
       user = User.get_cached_by_id(user.id)
       other_user = User.get_cached_by_id(other_user.id)
 
 
       {:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
       user = User.get_cached_by_id(user.id)
       other_user = User.get_cached_by_id(other_user.id)
 

-      expected = %{
-        id: to_string(other_user.id),
-        following: false,
-        followed_by: false,
-        blocking: false,
-        blocked_by: false,
-        muting: false,
-        muting_notifications: false,
-        subscribing: false,
-        requested: true,
-        domain_blocking: false,
-        showing_reblogs: true,
-        endorsed: false
-      }
+      expected =
+        Map.merge(
+          @blank_response,
+          %{requested: true, following: false, id: to_string(other_user.id)}
+        )

 
 

-      assert expected ==
-               AccountView.render("relationship.json", %{user: user, target: other_user})
+      test_relationship_rendering(user, other_user, expected)

     end
   end
 
   test "represent an embedded relationship" do
     user =
       insert(:user, %{
     end
   end
 
   test "represent an embedded relationship" do
     user =
       insert(:user, %{

-        info: %{note_count: 5, follower_count: 0, source_data: %{"type" => "Service"}},
+        follower_count: 0,
+        note_count: 5,
+        source_data: %{},
+        actor_type: "Service",

         nickname: "shp@shitposter.club",
         inserted_at: ~N[2017-08-15 15:47:06.597036]
       })
 
     other_user = insert(:user)
     {:ok, other_user} = User.follow(other_user, user)
         nickname: "shp@shitposter.club",
         inserted_at: ~N[2017-08-15 15:47:06.597036]
       })
 
     other_user = insert(:user)
     {:ok, other_user} = User.follow(other_user, user)

-    {:ok, other_user} = User.block(other_user, user)
+    {:ok, _user_relationship} = User.block(other_user, user)

     {:ok, _} = User.follow(insert(:user), user)
 
     expected = %{
     {:ok, _} = User.follow(insert(:user), user)
 
     expected = %{


@@ -315,6 +345,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
         note: user.bio,
         sensitive: false,
         pleroma: %{
         note: user.bio,
         sensitive: false,
         pleroma: %{

+          actor_type: "Service",

           discoverable: false
         },
         fields: []
           discoverable: false
         },
         fields: []


@@ -348,40 +379,48 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
       }
     }
 
       }
     }
 

-    assert expected == AccountView.render("account.json", %{user: user, for: other_user})
+    assert expected ==
+             AccountView.render("show.json", %{user: refresh_record(user), for: other_user})

   end
 
   test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
   end
 
   test "returns the settings store if the requesting user is the represented user and it's requested specifically" do

-    user = insert(:user, %{info: %User.Info{pleroma_settings_store: %{fe: "test"}}})
+    user = insert(:user, pleroma_settings_store: %{fe: "test"})

 
     result =
 
     result =

-      AccountView.render("account.json", %{user: user, for: user, with_pleroma_settings: true})
+      AccountView.render("show.json", %{user: user, for: user, with_pleroma_settings: true})

 
     assert result.pleroma.settings_store == %{:fe => "test"}
 
 
     assert result.pleroma.settings_store == %{:fe => "test"}
 

-    result = AccountView.render("account.json", %{user: user, with_pleroma_settings: true})
+    result = AccountView.render("show.json", %{user: user, with_pleroma_settings: true})

     assert result.pleroma[:settings_store] == nil
 
     assert result.pleroma[:settings_store] == nil
 

-    result = AccountView.render("account.json", %{user: user, for: user})
+    result = AccountView.render("show.json", %{user: user, for: user})

     assert result.pleroma[:settings_store] == nil
   end
 
     assert result.pleroma[:settings_store] == nil
   end
 

-  test "sanitizes display names" do
+  test "doesn't sanitize display names" do

     user = insert(:user, name: "<marquee> username </marquee>")
     user = insert(:user, name: "<marquee> username </marquee>")

-    result = AccountView.render("account.json", %{user: user})
-    refute result.display_name == "<marquee> username </marquee>"
+    result = AccountView.render("show.json", %{user: user})
+    assert result.display_name == "<marquee> username </marquee>"
+  end
+
+  test "never display nil user follow counts" do
+    user = insert(:user, following_count: 0, follower_count: 0)
+    result = AccountView.render("show.json", %{user: user})
+
+    assert result.following_count == 0
+    assert result.followers_count == 0

   end
 
   describe "hiding follows/following" do
     test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do
   end
 
   describe "hiding follows/following" do
     test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do

-      info = %{
-        hide_followers: true,
-        hide_followers_count: true,
-        hide_follows: true,
-        hide_follows_count: true
-      }
-
-      user = insert(:user, info: info)
+      user =
+        insert(:user, %{
+          hide_followers: true,
+          hide_followers_count: true,
+          hide_follows: true,
+          hide_follows_count: true
+        })

 
       other_user = insert(:user)
       {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
 
       other_user = insert(:user)
       {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)


@@ -391,11 +430,11 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
                followers_count: 0,
                following_count: 0,
                pleroma: %{hide_follows_count: true, hide_followers_count: true}
                followers_count: 0,
                following_count: 0,
                pleroma: %{hide_follows_count: true, hide_followers_count: true}

-             } = AccountView.render("account.json", %{user: user})
+             } = AccountView.render("show.json", %{user: user})

     end
 
     test "shows when follows/followers are hidden" do
     end
 
     test "shows when follows/followers are hidden" do

-      user = insert(:user, info: %{hide_followers: true, hide_follows: true})
+      user = insert(:user, hide_followers: true, hide_follows: true)

       other_user = insert(:user)
       {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
       {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
       other_user = insert(:user)
       {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
       {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)


@@ -404,11 +443,11 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
                followers_count: 1,
                following_count: 1,
                pleroma: %{hide_follows: true, hide_followers: true}
                followers_count: 1,
                following_count: 1,
                pleroma: %{hide_follows: true, hide_followers: true}

-             } = AccountView.render("account.json", %{user: user})
+             } = AccountView.render("show.json", %{user: user})

     end
 
     test "shows actual follower/following count to the account owner" do
     end
 
     test "shows actual follower/following count to the account owner" do

-      user = insert(:user, info: %{hide_followers: true, hide_follows: true})
+      user = insert(:user, hide_followers: true, hide_follows: true)

       other_user = insert(:user)
       {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
       {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
       other_user = insert(:user)
       {:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
       {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)


@@ -416,7 +455,103 @@ defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
       assert %{
                followers_count: 1,
                following_count: 1
       assert %{
                followers_count: 1,
                following_count: 1

-             } = AccountView.render("account.json", %{user: user, for: user})
+             } = AccountView.render("show.json", %{user: user, for: user})
+    end
+
+    test "shows unread_conversation_count only to the account owner" do
+      user = insert(:user)
+      other_user = insert(:user)
+
+      {:ok, _activity} =
+        CommonAPI.post(other_user, %{
+          "status" => "Hey @#{user.nickname}.",
+          "visibility" => "direct"
+        })
+
+      user = User.get_cached_by_ap_id(user.ap_id)
+
+      assert AccountView.render("show.json", %{user: user, for: other_user})[:pleroma][
+               :unread_conversation_count
+             ] == nil
+
+      assert AccountView.render("show.json", %{user: user, for: user})[:pleroma][
+               :unread_conversation_count
+             ] == 1
+    end
+  end
+
+  describe "follow requests counter" do
+    test "shows zero when no follow requests are pending" do
+      user = insert(:user)
+
+      assert %{follow_requests_count: 0} =
+               AccountView.render("show.json", %{user: user, for: user})
+
+      other_user = insert(:user)
+      {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
+
+      assert %{follow_requests_count: 0} =
+               AccountView.render("show.json", %{user: user, for: user})
+    end
+
+    test "shows non-zero when follow requests are pending" do
+      user = insert(:user, locked: true)
+
+      assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})
+
+      other_user = insert(:user)
+      {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
+
+      assert %{locked: true, follow_requests_count: 1} =
+               AccountView.render("show.json", %{user: user, for: user})
+    end
+
+    test "decreases when accepting a follow request" do
+      user = insert(:user, locked: true)
+
+      assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})
+
+      other_user = insert(:user)
+      {:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)
+
+      assert %{locked: true, follow_requests_count: 1} =
+               AccountView.render("show.json", %{user: user, for: user})
+
+      {:ok, _other_user} = CommonAPI.accept_follow_request(other_user, user)
+
+      assert %{locked: true, follow_requests_count: 0} =
+               AccountView.render("show.json", %{user: user, for: user})
+    end
+
+    test "decreases when rejecting a follow request" do
+      user = insert(:user, locked: true)
+
+      assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})
+
+      other_user = insert(:user)
+      {:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)
+
+      assert %{locked: true, follow_requests_count: 1} =
+               AccountView.render("show.json", %{user: user, for: user})
+
+      {:ok, _other_user} = CommonAPI.reject_follow_request(other_user, user)
+
+      assert %{locked: true, follow_requests_count: 0} =
+               AccountView.render("show.json", %{user: user, for: user})
+    end
+
+    test "shows non-zero when historical unapproved requests are present" do
+      user = insert(:user, locked: true)
+
+      assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})
+
+      other_user = insert(:user)
+      {:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
+
+      {:ok, user} = User.update_and_set_cache(user, %{locked: false})
+
+      assert %{locked: false, follow_requests_count: 1} =
+               AccountView.render("show.json", %{user: user, for: user})

     end
   end
 end
     end
   end
 end