git.squeep.com Git - akkoma/blob - test/web/mastodon_api/account_view_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
   6   use Pleroma.DataCase
   7   import Pleroma.Factory
   8   alias Pleroma.User
   9   alias Pleroma.Web.CommonAPI
  10   alias Pleroma.Web.MastodonAPI.AccountView
  11
  12   test "Represent a user account" do
  13     source_data = %{
  14       "tag" => [
  15         %{
  16           "type" => "Emoji",
  17           "icon" => %{"url" => "/file.png"},
  18           "name" => ":karjalanpiirakka:"
  19         }
  20       ]
  21     }
  22
  23     background_image = %{
  24       "url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
  25     }
  26
  27     user =
  28       insert(:user, %{
  29         info: %{
  30           note_count: 5,
  31           follower_count: 3,
  32           source_data: source_data,
  33           background: background_image
  34         },
  35         nickname: "shp@shitposter.club",
  36         name: ":karjalanpiirakka: shp",
  37         bio: "<script src=\"invalid-html\"></script><span>valid html</span>",
  38         inserted_at: ~N[2017-08-15 15:47:06.597036]
  39       })
  40
  41     expected = %{
  42       id: to_string(user.id),
  43       username: "shp",
  44       acct: user.nickname,
  45       display_name: user.name,
  46       locked: false,
  47       created_at: "2017-08-15T15:47:06.000Z",
  48       followers_count: 3,
  49       following_count: 0,
  50       statuses_count: 5,
  51       note: "<span>valid html</span>",
  52       url: user.ap_id,
  53       avatar: "http://localhost:4001/images/avi.png",
  54       avatar_static: "http://localhost:4001/images/avi.png",
  55       header: "http://localhost:4001/images/banner.png",
  56       header_static: "http://localhost:4001/images/banner.png",
  57       emojis: [
  58         %{
  59           "static_url" => "/file.png",
  60           "url" => "/file.png",
  61           "shortcode" => "karjalanpiirakka",
  62           "visible_in_picker" => false
  63         }
  64       ],
  65       fields: [],
  66       bot: false,
  67       source: %{
  68         note: "valid html",
  69         sensitive: false,
  70         pleroma: %{}
  71       },
  72       pleroma: %{
  73         background_image: "https://example.com/images/asuka_hospital.png",
  74         confirmation_pending: false,
  75         tags: [],
  76         is_admin: false,
  77         is_moderator: false,
  78         hide_favorites: true,
  79         hide_followers: false,
  80         hide_follows: false,
  81         relationship: %{},
  82         skip_thread_containment: false
  83       }
  84     }
  85
  86     assert expected == AccountView.render("account.json", %{user: user})
  87   end
  88
  89   test "Represent the user account for the account owner" do
  90     user = insert(:user)
  91
  92     notification_settings = %{
  93       "followers" => true,
  94       "follows" => true,
  95       "non_follows" => true,
  96       "non_followers" => true
  97     }
  98
  99     privacy = user.info.default_scope
 100
 101     assert %{
 102              pleroma: %{notification_settings: ^notification_settings},
 103              source: %{privacy: ^privacy}
 104            } = AccountView.render("account.json", %{user: user, for: user})
 105   end
 106
 107   test "Represent a Service(bot) account" do
 108     user =
 109       insert(:user, %{
 110         info: %{note_count: 5, follower_count: 3, source_data: %{"type" => "Service"}},
 111         nickname: "shp@shitposter.club",
 112         inserted_at: ~N[2017-08-15 15:47:06.597036]
 113       })
 114
 115     expected = %{
 116       id: to_string(user.id),
 117       username: "shp",
 118       acct: user.nickname,
 119       display_name: user.name,
 120       locked: false,
 121       created_at: "2017-08-15T15:47:06.000Z",
 122       followers_count: 3,
 123       following_count: 0,
 124       statuses_count: 5,
 125       note: user.bio,
 126       url: user.ap_id,
 127       avatar: "http://localhost:4001/images/avi.png",
 128       avatar_static: "http://localhost:4001/images/avi.png",
 129       header: "http://localhost:4001/images/banner.png",
 130       header_static: "http://localhost:4001/images/banner.png",
 131       emojis: [],
 132       fields: [],
 133       bot: true,
 134       source: %{
 135         note: user.bio,
 136         sensitive: false,
 137         pleroma: %{}
 138       },
 139       pleroma: %{
 140         background_image: nil,
 141         confirmation_pending: false,
 142         tags: [],
 143         is_admin: false,
 144         is_moderator: false,
 145         hide_favorites: true,
 146         hide_followers: false,
 147         hide_follows: false,
 148         relationship: %{},
 149         skip_thread_containment: false
 150       }
 151     }
 152
 153     assert expected == AccountView.render("account.json", %{user: user})
 154   end
 155
 156   test "Represent a deactivated user for an admin" do
 157     admin = insert(:user, %{info: %{is_admin: true}})
 158     deactivated_user = insert(:user, %{info: %{deactivated: true}})
 159     represented = AccountView.render("account.json", %{user: deactivated_user, for: admin})
 160     assert represented[:pleroma][:deactivated] == true
 161   end
 162
 163   test "Represent a smaller mention" do
 164     user = insert(:user)
 165
 166     expected = %{
 167       id: to_string(user.id),
 168       acct: user.nickname,
 169       username: user.nickname,
 170       url: user.ap_id
 171     }
 172
 173     assert expected == AccountView.render("mention.json", %{user: user})
 174   end
 175
 176   describe "relationship" do
 177     test "represent a relationship for the following and followed user" do
 178       user = insert(:user)
 179       other_user = insert(:user)
 180
 181       {:ok, user} = User.follow(user, other_user)
 182       {:ok, other_user} = User.follow(other_user, user)
 183       {:ok, other_user} = User.subscribe(user, other_user)
 184       {:ok, user} = User.mute(user, other_user, true)
 185       {:ok, user} = CommonAPI.hide_reblogs(user, other_user)
 186
 187       expected = %{
 188         id: to_string(other_user.id),
 189         following: true,
 190         followed_by: true,
 191         blocking: false,
 192         blocked_by: false,
 193         muting: true,
 194         muting_notifications: true,
 195         subscribing: true,
 196         requested: false,
 197         domain_blocking: false,
 198         showing_reblogs: false,
 199         endorsed: false
 200       }
 201
 202       assert expected ==
 203                AccountView.render("relationship.json", %{user: user, target: other_user})
 204     end
 205
 206     test "represent a relationship for the blocking and blocked user" do
 207       user = insert(:user)
 208       other_user = insert(:user)
 209
 210       {:ok, user} = User.follow(user, other_user)
 211       {:ok, other_user} = User.subscribe(user, other_user)
 212       {:ok, user} = User.block(user, other_user)
 213       {:ok, other_user} = User.block(other_user, user)
 214
 215       expected = %{
 216         id: to_string(other_user.id),
 217         following: false,
 218         followed_by: false,
 219         blocking: true,
 220         blocked_by: true,
 221         muting: false,
 222         muting_notifications: false,
 223         subscribing: false,
 224         requested: false,
 225         domain_blocking: false,
 226         showing_reblogs: true,
 227         endorsed: false
 228       }
 229
 230       assert expected ==
 231                AccountView.render("relationship.json", %{user: user, target: other_user})
 232     end
 233
 234     test "represent a relationship for the user with a pending follow request" do
 235       user = insert(:user)
 236       other_user = insert(:user, %{info: %User.Info{locked: true}})
 237
 238       {:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
 239       user = User.get_cached_by_id(user.id)
 240       other_user = User.get_cached_by_id(other_user.id)
 241
 242       expected = %{
 243         id: to_string(other_user.id),
 244         following: false,
 245         followed_by: false,
 246         blocking: false,
 247         blocked_by: false,
 248         muting: false,
 249         muting_notifications: false,
 250         subscribing: false,
 251         requested: true,
 252         domain_blocking: false,
 253         showing_reblogs: true,
 254         endorsed: false
 255       }
 256
 257       assert expected ==
 258                AccountView.render("relationship.json", %{user: user, target: other_user})
 259     end
 260   end
 261
 262   test "represent an embedded relationship" do
 263     user =
 264       insert(:user, %{
 265         info: %{note_count: 5, follower_count: 0, source_data: %{"type" => "Service"}},
 266         nickname: "shp@shitposter.club",
 267         inserted_at: ~N[2017-08-15 15:47:06.597036]
 268       })
 269
 270     other_user = insert(:user)
 271     {:ok, other_user} = User.follow(other_user, user)
 272     {:ok, other_user} = User.block(other_user, user)
 273     {:ok, _} = User.follow(insert(:user), user)
 274
 275     expected = %{
 276       id: to_string(user.id),
 277       username: "shp",
 278       acct: user.nickname,
 279       display_name: user.name,
 280       locked: false,
 281       created_at: "2017-08-15T15:47:06.000Z",
 282       followers_count: 1,
 283       following_count: 0,
 284       statuses_count: 5,
 285       note: user.bio,
 286       url: user.ap_id,
 287       avatar: "http://localhost:4001/images/avi.png",
 288       avatar_static: "http://localhost:4001/images/avi.png",
 289       header: "http://localhost:4001/images/banner.png",
 290       header_static: "http://localhost:4001/images/banner.png",
 291       emojis: [],
 292       fields: [],
 293       bot: true,
 294       source: %{
 295         note: user.bio,
 296         sensitive: false,
 297         pleroma: %{}
 298       },
 299       pleroma: %{
 300         background_image: nil,
 301         confirmation_pending: false,
 302         tags: [],
 303         is_admin: false,
 304         is_moderator: false,
 305         hide_favorites: true,
 306         hide_followers: false,
 307         hide_follows: false,
 308         relationship: %{
 309           id: to_string(user.id),
 310           following: false,
 311           followed_by: false,
 312           blocking: true,
 313           blocked_by: false,
 314           subscribing: false,
 315           muting: false,
 316           muting_notifications: false,
 317           requested: false,
 318           domain_blocking: false,
 319           showing_reblogs: true,
 320           endorsed: false
 321         },
 322         skip_thread_containment: false
 323       }
 324     }
 325
 326     assert expected == AccountView.render("account.json", %{user: user, for: other_user})
 327   end
 328
 329   test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
 330     user = insert(:user, %{info: %User.Info{pleroma_settings_store: %{fe: "test"}}})
 331
 332     result =
 333       AccountView.render("account.json", %{user: user, for: user, with_pleroma_settings: true})
 334
 335     assert result.pleroma.settings_store == %{:fe => "test"}
 336
 337     result = AccountView.render("account.json", %{user: user, with_pleroma_settings: true})
 338     assert result.pleroma[:settings_store] == nil
 339
 340     result = AccountView.render("account.json", %{user: user, for: user})
 341     assert result.pleroma[:settings_store] == nil
 342   end
 343
 344   test "sanitizes display names" do
 345     user = insert(:user, name: "<marquee> username </marquee>")
 346     result = AccountView.render("account.json", %{user: user})
 347     refute result.display_name == "<marquee> username </marquee>"
 348   end
 349 end