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