1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
9 alias Pleroma.Tests.ObanHelpers
11 alias Pleroma.UserInviteToken
12 alias Pleroma.Web.TwitterAPI.TwitterAPI
15 Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
19 test "it registers a new user and returns the user." do
22 :email => "lain@wired.jp",
23 :fullname => "lain iwakura",
28 {:ok, user} = TwitterAPI.register_user(data)
30 assert user == User.get_cached_by_nickname("lain")
33 test "it registers a new user with empty string in bio and returns the user" do
36 :email => "lain@wired.jp",
37 :fullname => "lain iwakura",
43 {:ok, user} = TwitterAPI.register_user(data)
45 assert user == User.get_cached_by_nickname("lain")
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])
52 Pleroma.Config.put([:instance, :account_activation_required], true)
53 on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
58 :email => "lain@wired.jp",
59 :fullname => "lain iwakura",
65 {:ok, user} = TwitterAPI.register_user(data)
66 ObanHelpers.perform_all()
68 assert user.confirmation_pending
70 email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
72 notify_email = Pleroma.Config.get([:instance, :notify_email])
73 instance_name = Pleroma.Config.get([:instance, :name])
75 Swoosh.TestAssertions.assert_email_sent(
76 from: {instance_name, notify_email},
77 to: {user.name, user.email},
78 html_body: email.html_body
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)
85 admin = insert(:user, is_admin: true)
89 :email => "lain@wired.jp",
90 :fullname => "lain iwakura",
94 :reason => "I love anime"
97 {:ok, user} = TwitterAPI.register_user(data)
98 ObanHelpers.perform_all()
100 assert user.approval_pending
102 user_email = Pleroma.Emails.UserEmail.approval_pending_email(user)
103 admin_email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, user)
105 notify_email = Pleroma.Config.get([:instance, :notify_email])
106 instance_name = Pleroma.Config.get([:instance, :name])
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
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
123 test "it registers a new user and parses mentions in the bio" do
126 :email => "john@gmail.com",
127 :fullname => "John Doe",
133 {:ok, user1} = TwitterAPI.register_user(data1)
137 :email => "lain@wired.jp",
138 :fullname => "lain iwakura",
139 :bio => "@john test",
144 {:ok, user2} = TwitterAPI.register_user(data2)
147 ~s(<span class="h-card"><a class="u-url mention" data-user="#{user1.id}" href="#{
149 }" rel="ugc">@<span>john</span></a></span> test)
151 assert user2.bio == expected_text
154 describe "register with one time token" do
155 setup do: clear_config([:instance, :registrations_open], false)
157 test "returns user on success" do
158 {:ok, invite} = UserInviteToken.create_invite()
161 :username => "vinny",
162 :email => "pasta@pizza.vs",
163 :fullname => "Vinny Vinesauce",
165 :password => "hiptofbees",
166 :confirm => "hiptofbees",
167 :token => invite.token
170 {:ok, user} = TwitterAPI.register_user(data)
172 assert user == User.get_cached_by_nickname("vinny")
174 invite = Repo.get_by(UserInviteToken, token: invite.token)
175 assert invite.used == true
178 test "returns error on invalid token" do
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"
189 {:error, msg} = TwitterAPI.register_user(data)
191 assert msg == "Invalid token"
192 refute User.get_cached_by_nickname("GrimReaper")
195 test "returns error on expired token" do
196 {:ok, invite} = UserInviteToken.create_invite()
197 UserInviteToken.update_invite!(invite, used: true)
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
209 {:error, msg} = TwitterAPI.register_user(data)
211 assert msg == "Expired token"
212 refute User.get_cached_by_nickname("GrimReaper")
216 describe "registers with date limited token" do
217 setup do: clear_config([:instance, :registrations_open], false)
221 :username => "vinny",
222 :email => "pasta@pizza.vs",
223 :fullname => "Vinny Vinesauce",
225 :password => "hiptofbees",
226 :confirm => "hiptofbees"
229 check_fn = fn invite ->
230 data = Map.put(data, :token, invite.token)
231 {:ok, user} = TwitterAPI.register_user(data)
233 assert user == User.get_cached_by_nickname("vinny")
236 {:ok, data: data, check_fn: check_fn}
239 test "returns user on success", %{check_fn: check_fn} do
240 {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
244 invite = Repo.get_by(UserInviteToken, token: invite.token)
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)})
254 invite = Repo.get_by(UserInviteToken, token: invite.token)
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)})
262 data = Map.put(data, "token", invite.token)
264 {:error, msg} = TwitterAPI.register_user(data)
266 assert msg == "Expired token"
267 refute User.get_cached_by_nickname("vinny")
268 invite = Repo.get_by(UserInviteToken, token: invite.token)
274 describe "registers with reusable token" do
275 setup do: clear_config([:instance, :registrations_open], false)
277 test "returns user on success, after him registration fails" do
278 {:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})
280 UserInviteToken.update_invite!(invite, uses: 99)
283 :username => "vinny",
284 :email => "pasta@pizza.vs",
285 :fullname => "Vinny Vinesauce",
287 :password => "hiptofbees",
288 :confirm => "hiptofbees",
289 :token => invite.token
292 {:ok, user} = TwitterAPI.register_user(data)
293 assert user == User.get_cached_by_nickname("vinny")
295 invite = Repo.get_by(UserInviteToken, token: invite.token)
296 assert invite.used == true
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
308 {:error, msg} = TwitterAPI.register_user(data)
310 assert msg == "Expired token"
311 refute User.get_cached_by_nickname("GrimReaper")
315 describe "registers with reusable date limited token" do
316 setup do: clear_config([:instance, :registrations_open], false)
318 test "returns user on success" do
319 {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
322 :username => "vinny",
323 :email => "pasta@pizza.vs",
324 :fullname => "Vinny Vinesauce",
326 :password => "hiptofbees",
327 :confirm => "hiptofbees",
328 :token => invite.token
331 {:ok, user} = TwitterAPI.register_user(data)
332 assert user == User.get_cached_by_nickname("vinny")
334 invite = Repo.get_by(UserInviteToken, token: invite.token)
338 test "error after max uses" do
339 {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
341 UserInviteToken.update_invite!(invite, uses: 99)
344 :username => "vinny",
345 :email => "pasta@pizza.vs",
346 :fullname => "Vinny Vinesauce",
348 :password => "hiptofbees",
349 :confirm => "hiptofbees",
350 :token => invite.token
353 {:ok, user} = TwitterAPI.register_user(data)
354 assert user == User.get_cached_by_nickname("vinny")
356 invite = Repo.get_by(UserInviteToken, token: invite.token)
357 assert invite.used == true
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
369 {:error, msg} = TwitterAPI.register_user(data)
371 assert msg == "Expired token"
372 refute User.get_cached_by_nickname("GrimReaper")
375 test "returns error on overdue date" do
377 UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
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
389 {:error, msg} = TwitterAPI.register_user(data)
391 assert msg == "Expired token"
392 refute User.get_cached_by_nickname("GrimReaper")
395 test "returns error on with overdue date and after max" do
397 UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
399 UserInviteToken.update_invite!(invite, uses: 100)
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
411 {:error, msg} = TwitterAPI.register_user(data)
413 assert msg == "Expired token"
414 refute User.get_cached_by_nickname("GrimReaper")
418 test "it returns the error on registration problems" do
421 :email => "lain@wired.jp",
422 :fullname => "lain iwakura",
423 :bio => "close the world."
426 {:error, error} = TwitterAPI.register_user(data)
428 assert is_binary(error)
429 refute User.get_cached_by_nickname("lain")