git.squeep.com Git - akkoma/blob - test/pleroma/web/twitter_api/twitter_api_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
   6   use Pleroma.DataCase
   7   import Pleroma.Factory
   8   alias Pleroma.Repo
   9   alias Pleroma.Tests.ObanHelpers
  10   alias Pleroma.User
  11   alias Pleroma.UserInviteToken
  12   alias Pleroma.Web.TwitterAPI.TwitterAPI
  13
  14   setup_all do
  15     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  16     :ok
  17   end
  18
  19   test "it registers a new user and returns the user." do
  20     data = %{
  21       :username => "lain",
  22       :email => "lain@wired.jp",
  23       :fullname => "lain iwakura",
  24       :password => "bear",
  25       :confirm => "bear"
  26     }
  27
  28     {:ok, user} = TwitterAPI.register_user(data)
  29
  30     assert user == User.get_cached_by_nickname("lain")
  31   end
  32
  33   test "it registers a new user with empty string in bio and returns the user" do
  34     data = %{
  35       :username => "lain",
  36       :email => "lain@wired.jp",
  37       :fullname => "lain iwakura",
  38       :bio => "",
  39       :password => "bear",
  40       :confirm => "bear"
  41     }
  42
  43     {:ok, user} = TwitterAPI.register_user(data)
  44
  45     assert user == User.get_cached_by_nickname("lain")
  46   end
  47
  48   test "it sends confirmation email if :account_activation_required is specified in instance config" do
  49     setting = Pleroma.Config.get([:instance, :account_activation_required])
  50
  51     unless setting do
  52       Pleroma.Config.put([:instance, :account_activation_required], true)
  53       on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
  54     end
  55
  56     data = %{
  57       :username => "lain",
  58       :email => "lain@wired.jp",
  59       :fullname => "lain iwakura",
  60       :bio => "",
  61       :password => "bear",
  62       :confirm => "bear"
  63     }
  64
  65     {:ok, user} = TwitterAPI.register_user(data)
  66     ObanHelpers.perform_all()
  67
  68     assert user.confirmation_pending
  69
  70     email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
  71
  72     notify_email = Pleroma.Config.get([:instance, :notify_email])
  73     instance_name = Pleroma.Config.get([:instance, :name])
  74
  75     Swoosh.TestAssertions.assert_email_sent(
  76       from: {instance_name, notify_email},
  77       to: {user.name, user.email},
  78       html_body: email.html_body
  79     )
  80   end
  81
  82   test "it sends an admin email if :account_approval_required is specified in instance config" do
  83     clear_config([:instance, :account_approval_required], true)
  84
  85     admin = insert(:user, is_admin: true)
  86
  87     data = %{
  88       :username => "lain",
  89       :email => "lain@wired.jp",
  90       :fullname => "lain iwakura",
  91       :bio => "",
  92       :password => "bear",
  93       :confirm => "bear",
  94       :reason => "I love anime"
  95     }
  96
  97     {:ok, user} = TwitterAPI.register_user(data)
  98     ObanHelpers.perform_all()
  99
 100     assert user.approval_pending
 101
 102     user_email = Pleroma.Emails.UserEmail.approval_pending_email(user)
 103     admin_email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, user)
 104
 105     notify_email = Pleroma.Config.get([:instance, :notify_email])
 106     instance_name = Pleroma.Config.get([:instance, :name])
 107
 108     # User approval email
 109     Swoosh.TestAssertions.assert_email_sent(
 110       from: {instance_name, notify_email},
 111       to: {user.name, user.email},
 112       html_body: user_email.html_body
 113     )
 114
 115     # Admin email
 116     Swoosh.TestAssertions.assert_email_sent(
 117       from: {instance_name, notify_email},
 118       to: {admin.name, admin.email},
 119       html_body: admin_email.html_body
 120     )
 121   end
 122
 123   test "it registers a new user and parses mentions in the bio" do
 124     data1 = %{
 125       :username => "john",
 126       :email => "john@gmail.com",
 127       :fullname => "John Doe",
 128       :bio => "test",
 129       :password => "bear",
 130       :confirm => "bear"
 131     }
 132
 133     {:ok, user1} = TwitterAPI.register_user(data1)
 134
 135     data2 = %{
 136       :username => "lain",
 137       :email => "lain@wired.jp",
 138       :fullname => "lain iwakura",
 139       :bio => "@john test",
 140       :password => "bear",
 141       :confirm => "bear"
 142     }
 143
 144     {:ok, user2} = TwitterAPI.register_user(data2)
 145
 146     expected_text =
 147       ~s(<span class="h-card"><a class="u-url mention" data-user="#{user1.id}" href="#{
 148         user1.ap_id
 149       }" rel="ugc">@<span>john</span></a></span> test)
 150
 151     assert user2.bio == expected_text
 152   end
 153
 154   describe "register with one time token" do
 155     setup do: clear_config([:instance, :registrations_open], false)
 156
 157     test "returns user on success" do
 158       {:ok, invite} = UserInviteToken.create_invite()
 159
 160       data = %{
 161         :username => "vinny",
 162         :email => "pasta@pizza.vs",
 163         :fullname => "Vinny Vinesauce",
 164         :bio => "streamer",
 165         :password => "hiptofbees",
 166         :confirm => "hiptofbees",
 167         :token => invite.token
 168       }
 169
 170       {:ok, user} = TwitterAPI.register_user(data)
 171
 172       assert user == User.get_cached_by_nickname("vinny")
 173
 174       invite = Repo.get_by(UserInviteToken, token: invite.token)
 175       assert invite.used == true
 176     end
 177
 178     test "returns error on invalid token" do
 179       data = %{
 180         :username => "GrimReaper",
 181         :email => "death@reapers.afterlife",
 182         :fullname => "Reaper Grim",
 183         :bio => "Your time has come",
 184         :password => "scythe",
 185         :confirm => "scythe",
 186         :token => "DudeLetMeInImAFairy"
 187       }
 188
 189       {:error, msg} = TwitterAPI.register_user(data)
 190
 191       assert msg == "Invalid token"
 192       refute User.get_cached_by_nickname("GrimReaper")
 193     end
 194
 195     test "returns error on expired token" do
 196       {:ok, invite} = UserInviteToken.create_invite()
 197       UserInviteToken.update_invite!(invite, used: true)
 198
 199       data = %{
 200         :username => "GrimReaper",
 201         :email => "death@reapers.afterlife",
 202         :fullname => "Reaper Grim",
 203         :bio => "Your time has come",
 204         :password => "scythe",
 205         :confirm => "scythe",
 206         :token => invite.token
 207       }
 208
 209       {:error, msg} = TwitterAPI.register_user(data)
 210
 211       assert msg == "Expired token"
 212       refute User.get_cached_by_nickname("GrimReaper")
 213     end
 214   end
 215
 216   describe "registers with date limited token" do
 217     setup do: clear_config([:instance, :registrations_open], false)
 218
 219     setup do
 220       data = %{
 221         :username => "vinny",
 222         :email => "pasta@pizza.vs",
 223         :fullname => "Vinny Vinesauce",
 224         :bio => "streamer",
 225         :password => "hiptofbees",
 226         :confirm => "hiptofbees"
 227       }
 228
 229       check_fn = fn invite ->
 230         data = Map.put(data, :token, invite.token)
 231         {:ok, user} = TwitterAPI.register_user(data)
 232
 233         assert user == User.get_cached_by_nickname("vinny")
 234       end
 235
 236       {:ok, data: data, check_fn: check_fn}
 237     end
 238
 239     test "returns user on success", %{check_fn: check_fn} do
 240       {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
 241
 242       check_fn.(invite)
 243
 244       invite = Repo.get_by(UserInviteToken, token: invite.token)
 245
 246       refute invite.used
 247     end
 248
 249     test "returns user on token which expired tomorrow", %{check_fn: check_fn} do
 250       {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), 1)})
 251
 252       check_fn.(invite)
 253
 254       invite = Repo.get_by(UserInviteToken, token: invite.token)
 255
 256       refute invite.used
 257     end
 258
 259     test "returns an error on overdue date", %{data: data} do
 260       {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1)})
 261
 262       data = Map.put(data, "token", invite.token)
 263
 264       {:error, msg} = TwitterAPI.register_user(data)
 265
 266       assert msg == "Expired token"
 267       refute User.get_cached_by_nickname("vinny")
 268       invite = Repo.get_by(UserInviteToken, token: invite.token)
 269
 270       refute invite.used
 271     end
 272   end
 273
 274   describe "registers with reusable token" do
 275     setup do: clear_config([:instance, :registrations_open], false)
 276
 277     test "returns user on success, after him registration fails" do
 278       {:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})
 279
 280       UserInviteToken.update_invite!(invite, uses: 99)
 281
 282       data = %{
 283         :username => "vinny",
 284         :email => "pasta@pizza.vs",
 285         :fullname => "Vinny Vinesauce",
 286         :bio => "streamer",
 287         :password => "hiptofbees",
 288         :confirm => "hiptofbees",
 289         :token => invite.token
 290       }
 291
 292       {:ok, user} = TwitterAPI.register_user(data)
 293       assert user == User.get_cached_by_nickname("vinny")
 294
 295       invite = Repo.get_by(UserInviteToken, token: invite.token)
 296       assert invite.used == true
 297
 298       data = %{
 299         :username => "GrimReaper",
 300         :email => "death@reapers.afterlife",
 301         :fullname => "Reaper Grim",
 302         :bio => "Your time has come",
 303         :password => "scythe",
 304         :confirm => "scythe",
 305         :token => invite.token
 306       }
 307
 308       {:error, msg} = TwitterAPI.register_user(data)
 309
 310       assert msg == "Expired token"
 311       refute User.get_cached_by_nickname("GrimReaper")
 312     end
 313   end
 314
 315   describe "registers with reusable date limited token" do
 316     setup do: clear_config([:instance, :registrations_open], false)
 317
 318     test "returns user on success" do
 319       {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
 320
 321       data = %{
 322         :username => "vinny",
 323         :email => "pasta@pizza.vs",
 324         :fullname => "Vinny Vinesauce",
 325         :bio => "streamer",
 326         :password => "hiptofbees",
 327         :confirm => "hiptofbees",
 328         :token => invite.token
 329       }
 330
 331       {:ok, user} = TwitterAPI.register_user(data)
 332       assert user == User.get_cached_by_nickname("vinny")
 333
 334       invite = Repo.get_by(UserInviteToken, token: invite.token)
 335       refute invite.used
 336     end
 337
 338     test "error after max uses" do
 339       {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
 340
 341       UserInviteToken.update_invite!(invite, uses: 99)
 342
 343       data = %{
 344         :username => "vinny",
 345         :email => "pasta@pizza.vs",
 346         :fullname => "Vinny Vinesauce",
 347         :bio => "streamer",
 348         :password => "hiptofbees",
 349         :confirm => "hiptofbees",
 350         :token => invite.token
 351       }
 352
 353       {:ok, user} = TwitterAPI.register_user(data)
 354       assert user == User.get_cached_by_nickname("vinny")
 355
 356       invite = Repo.get_by(UserInviteToken, token: invite.token)
 357       assert invite.used == true
 358
 359       data = %{
 360         :username => "GrimReaper",
 361         :email => "death@reapers.afterlife",
 362         :fullname => "Reaper Grim",
 363         :bio => "Your time has come",
 364         :password => "scythe",
 365         :confirm => "scythe",
 366         :token => invite.token
 367       }
 368
 369       {:error, msg} = TwitterAPI.register_user(data)
 370
 371       assert msg == "Expired token"
 372       refute User.get_cached_by_nickname("GrimReaper")
 373     end
 374
 375     test "returns error on overdue date" do
 376       {:ok, invite} =
 377         UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
 378
 379       data = %{
 380         :username => "GrimReaper",
 381         :email => "death@reapers.afterlife",
 382         :fullname => "Reaper Grim",
 383         :bio => "Your time has come",
 384         :password => "scythe",
 385         :confirm => "scythe",
 386         :token => invite.token
 387       }
 388
 389       {:error, msg} = TwitterAPI.register_user(data)
 390
 391       assert msg == "Expired token"
 392       refute User.get_cached_by_nickname("GrimReaper")
 393     end
 394
 395     test "returns error on with overdue date and after max" do
 396       {:ok, invite} =
 397         UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
 398
 399       UserInviteToken.update_invite!(invite, uses: 100)
 400
 401       data = %{
 402         :username => "GrimReaper",
 403         :email => "death@reapers.afterlife",
 404         :fullname => "Reaper Grim",
 405         :bio => "Your time has come",
 406         :password => "scythe",
 407         :confirm => "scythe",
 408         :token => invite.token
 409       }
 410
 411       {:error, msg} = TwitterAPI.register_user(data)
 412
 413       assert msg == "Expired token"
 414       refute User.get_cached_by_nickname("GrimReaper")
 415     end
 416   end
 417
 418   test "it returns the error on registration problems" do
 419     data = %{
 420       :username => "lain",
 421       :email => "lain@wired.jp",
 422       :fullname => "lain iwakura",
 423       :bio => "close the world."
 424     }
 425
 426     {:error, error} = TwitterAPI.register_user(data)
 427
 428     assert is_binary(error)
 429     refute User.get_cached_by_nickname("lain")
 430   end
 431
 432   setup do
 433     Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
 434     Supervisor.restart_child(Pleroma.Supervisor, Cachex)
 435     :ok
 436   end
 437 end