pleroma/test/web/twitter_api/twitter_api_test.exs

449 lines
13 KiB
Elixir
Raw Normal View History

2018-12-23 15:11:29 -05:00
# Pleroma: A lightweight social networking server
# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
2018-12-23 15:11:29 -05:00
# SPDX-License-Identifier: AGPL-3.0-only
2017-03-21 12:53:20 -04:00
defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
use Pleroma.DataCase
2019-02-10 16:57:38 -05:00
alias Pleroma.Repo
alias Pleroma.Tests.ObanHelpers
alias Pleroma.User
2019-02-10 16:57:38 -05:00
alias Pleroma.UserInviteToken
alias Pleroma.Web.MastodonAPI.AccountView
alias Pleroma.Web.TwitterAPI.TwitterAPI
2017-04-13 10:19:07 -04:00
setup_all do
Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
:ok
end
2017-04-16 04:25:27 -04:00
test "it registers a new user and returns the user." do
data = %{
"nickname" => "lain",
"email" => "lain@wired.jp",
"fullname" => "lain iwakura",
"password" => "bear",
"confirm" => "bear"
}
{:ok, user} = TwitterAPI.register_user(data)
2019-04-22 03:20:43 -04:00
fetched_user = User.get_cached_by_nickname("lain")
2018-03-30 09:01:53 -04:00
assert AccountView.render("account.json", %{user: user}) ==
AccountView.render("account.json", %{user: fetched_user})
2017-04-16 04:25:27 -04:00
end
test "it registers a new user with empty string in bio and returns the user." do
data = %{
"nickname" => "lain",
"email" => "lain@wired.jp",
"fullname" => "lain iwakura",
"bio" => "",
2017-04-16 04:25:27 -04:00
"password" => "bear",
"confirm" => "bear"
}
{:ok, user} = TwitterAPI.register_user(data)
2019-04-22 03:20:43 -04:00
fetched_user = User.get_cached_by_nickname("lain")
2018-03-30 09:01:53 -04:00
assert AccountView.render("account.json", %{user: user}) ==
AccountView.render("account.json", %{user: fetched_user})
2017-04-16 04:25:27 -04:00
end
test "it sends confirmation email if :account_activation_required is specified in instance config" do
setting = Pleroma.Config.get([:instance, :account_activation_required])
unless setting do
Pleroma.Config.put([:instance, :account_activation_required], true)
on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
end
data = %{
"nickname" => "lain",
"email" => "lain@wired.jp",
"fullname" => "lain iwakura",
"bio" => "",
"password" => "bear",
"confirm" => "bear"
}
{:ok, user} = TwitterAPI.register_user(data)
ObanHelpers.perform_all()
assert user.info.confirmation_pending
2019-04-13 03:55:42 -04:00
email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
notify_email = Pleroma.Config.get([:instance, :notify_email])
instance_name = Pleroma.Config.get([:instance, :name])
Swoosh.TestAssertions.assert_email_sent(
from: {instance_name, notify_email},
to: {user.name, user.email},
html_body: email.html_body
)
end
2018-12-02 14:03:53 -05:00
test "it registers a new user and parses mentions in the bio" do
data1 = %{
"nickname" => "john",
"email" => "john@gmail.com",
"fullname" => "John Doe",
"bio" => "test",
"password" => "bear",
"confirm" => "bear"
}
{:ok, user1} = TwitterAPI.register_user(data1)
data2 = %{
"nickname" => "lain",
"email" => "lain@wired.jp",
"fullname" => "lain iwakura",
"bio" => "@john test",
"password" => "bear",
"confirm" => "bear"
}
{:ok, user2} = TwitterAPI.register_user(data2)
2018-12-02 14:08:53 -05:00
expected_text =
~s(<span class="h-card"><a data-user="#{user1.id}" class="u-url mention" href="#{
user1.ap_id
}" rel="ugc">@<span>john</span></a></span> test)
2018-12-02 14:03:53 -05:00
assert user2.bio == expected_text
end
describe "register with one time token" do
setup do
setting = Pleroma.Config.get([:instance, :registrations_open])
2018-06-12 07:52:54 -04:00
if setting do
Pleroma.Config.put([:instance, :registrations_open], false)
on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
end
2018-06-12 07:52:54 -04:00
:ok
end
2018-06-12 07:52:54 -04:00
test "returns user on success" do
2019-04-06 09:24:22 -04:00
{:ok, invite} = UserInviteToken.create_invite()
2018-06-12 07:52:54 -04:00
data = %{
"nickname" => "vinny",
"email" => "pasta@pizza.vs",
"fullname" => "Vinny Vinesauce",
"bio" => "streamer",
"password" => "hiptofbees",
"confirm" => "hiptofbees",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
2018-06-12 08:01:40 -04:00
{:ok, user} = TwitterAPI.register_user(data)
2019-04-22 03:20:43 -04:00
fetched_user = User.get_cached_by_nickname("vinny")
2019-04-06 09:24:22 -04:00
invite = Repo.get_by(UserInviteToken, token: invite.token)
2019-04-06 09:24:22 -04:00
assert invite.used == true
assert AccountView.render("account.json", %{user: user}) ==
AccountView.render("account.json", %{user: fetched_user})
end
test "returns error on invalid token" do
data = %{
"nickname" => "GrimReaper",
"email" => "death@reapers.afterlife",
"fullname" => "Reaper Grim",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
"token" => "DudeLetMeInImAFairy"
}
{:error, msg} = TwitterAPI.register_user(data)
assert msg == "Invalid token"
2019-04-22 03:20:43 -04:00
refute User.get_cached_by_nickname("GrimReaper")
end
test "returns error on expired token" do
2019-04-06 09:24:22 -04:00
{:ok, invite} = UserInviteToken.create_invite()
UserInviteToken.update_invite!(invite, used: true)
data = %{
"nickname" => "GrimReaper",
"email" => "death@reapers.afterlife",
"fullname" => "Reaper Grim",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
{:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token"
2019-04-22 03:20:43 -04:00
refute User.get_cached_by_nickname("GrimReaper")
end
2018-06-12 07:52:54 -04:00
end
describe "registers with date limited token" do
setup do
setting = Pleroma.Config.get([:instance, :registrations_open])
if setting do
Pleroma.Config.put([:instance, :registrations_open], false)
on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
end
data = %{
"nickname" => "vinny",
"email" => "pasta@pizza.vs",
"fullname" => "Vinny Vinesauce",
"bio" => "streamer",
"password" => "hiptofbees",
"confirm" => "hiptofbees"
}
2019-04-06 09:24:22 -04:00
check_fn = fn invite ->
data = Map.put(data, "token", invite.token)
{:ok, user} = TwitterAPI.register_user(data)
2019-04-22 03:20:43 -04:00
fetched_user = User.get_cached_by_nickname("vinny")
assert AccountView.render("account.json", %{user: user}) ==
AccountView.render("account.json", %{user: fetched_user})
end
{:ok, data: data, check_fn: check_fn}
end
test "returns user on success", %{check_fn: check_fn} do
{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
2019-04-06 09:24:22 -04:00
check_fn.(invite)
2018-06-12 07:52:54 -04:00
2019-04-06 09:24:22 -04:00
invite = Repo.get_by(UserInviteToken, token: invite.token)
2019-04-06 09:24:22 -04:00
refute invite.used
end
test "returns user on token which expired tomorrow", %{check_fn: check_fn} do
{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), 1)})
2019-04-06 09:24:22 -04:00
check_fn.(invite)
2019-04-06 09:24:22 -04:00
invite = Repo.get_by(UserInviteToken, token: invite.token)
2019-04-06 09:24:22 -04:00
refute invite.used
end
2018-06-12 07:52:54 -04:00
test "returns an error on overdue date", %{data: data} do
{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1)})
2018-06-12 07:52:54 -04:00
2019-04-06 09:24:22 -04:00
data = Map.put(data, "token", invite.token)
2018-06-12 07:52:54 -04:00
{:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token"
2019-04-22 03:20:43 -04:00
refute User.get_cached_by_nickname("vinny")
2019-04-06 09:24:22 -04:00
invite = Repo.get_by(UserInviteToken, token: invite.token)
2019-04-08 09:08:16 -04:00
refute invite.used
end
2018-06-12 07:52:54 -04:00
end
describe "registers with reusable token" do
setup do
setting = Pleroma.Config.get([:instance, :registrations_open])
2018-06-12 07:52:54 -04:00
if setting do
Pleroma.Config.put([:instance, :registrations_open], false)
on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
end
:ok
end
test "returns user on success, after him registration fails" do
2019-04-06 09:24:22 -04:00
{:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})
2019-04-06 09:24:22 -04:00
UserInviteToken.update_invite!(invite, uses: 99)
data = %{
"nickname" => "vinny",
"email" => "pasta@pizza.vs",
"fullname" => "Vinny Vinesauce",
"bio" => "streamer",
"password" => "hiptofbees",
"confirm" => "hiptofbees",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
{:ok, user} = TwitterAPI.register_user(data)
2019-04-22 03:20:43 -04:00
fetched_user = User.get_cached_by_nickname("vinny")
2019-04-06 09:24:22 -04:00
invite = Repo.get_by(UserInviteToken, token: invite.token)
2019-04-06 09:24:22 -04:00
assert invite.used == true
assert AccountView.render("account.json", %{user: user}) ==
AccountView.render("account.json", %{user: fetched_user})
2018-06-12 07:52:54 -04:00
data = %{
"nickname" => "GrimReaper",
"email" => "death@reapers.afterlife",
"fullname" => "Reaper Grim",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
2018-06-12 07:52:54 -04:00
{:error, msg} = TwitterAPI.register_user(data)
2018-06-12 07:52:54 -04:00
assert msg == "Expired token"
2019-04-22 03:20:43 -04:00
refute User.get_cached_by_nickname("GrimReaper")
end
end
describe "registers with reusable date limited token" do
setup do
setting = Pleroma.Config.get([:instance, :registrations_open])
if setting do
Pleroma.Config.put([:instance, :registrations_open], false)
on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
end
:ok
end
test "returns user on success" do
{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
data = %{
"nickname" => "vinny",
"email" => "pasta@pizza.vs",
"fullname" => "Vinny Vinesauce",
"bio" => "streamer",
"password" => "hiptofbees",
"confirm" => "hiptofbees",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
{:ok, user} = TwitterAPI.register_user(data)
2019-04-22 03:20:43 -04:00
fetched_user = User.get_cached_by_nickname("vinny")
2019-04-06 09:24:22 -04:00
invite = Repo.get_by(UserInviteToken, token: invite.token)
2019-04-06 09:24:22 -04:00
refute invite.used
assert AccountView.render("account.json", %{user: user}) ==
AccountView.render("account.json", %{user: fetched_user})
end
test "error after max uses" do
{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
2019-04-06 09:24:22 -04:00
UserInviteToken.update_invite!(invite, uses: 99)
data = %{
"nickname" => "vinny",
"email" => "pasta@pizza.vs",
"fullname" => "Vinny Vinesauce",
"bio" => "streamer",
"password" => "hiptofbees",
"confirm" => "hiptofbees",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
{:ok, user} = TwitterAPI.register_user(data)
2019-04-22 03:20:43 -04:00
fetched_user = User.get_cached_by_nickname("vinny")
2019-04-06 09:24:22 -04:00
invite = Repo.get_by(UserInviteToken, token: invite.token)
assert invite.used == true
assert AccountView.render("account.json", %{user: user}) ==
AccountView.render("account.json", %{user: fetched_user})
data = %{
"nickname" => "GrimReaper",
"email" => "death@reapers.afterlife",
"fullname" => "Reaper Grim",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
{:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token"
2019-04-22 03:20:43 -04:00
refute User.get_cached_by_nickname("GrimReaper")
end
test "returns error on overdue date" do
2019-04-06 09:24:22 -04:00
{:ok, invite} =
UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
data = %{
"nickname" => "GrimReaper",
"email" => "death@reapers.afterlife",
"fullname" => "Reaper Grim",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
2018-06-12 07:52:54 -04:00
{:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token"
2019-04-22 03:20:43 -04:00
refute User.get_cached_by_nickname("GrimReaper")
end
test "returns error on with overdue date and after max" do
2019-04-06 09:24:22 -04:00
{:ok, invite} =
UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
2019-04-06 09:24:22 -04:00
UserInviteToken.update_invite!(invite, uses: 100)
data = %{
"nickname" => "GrimReaper",
"email" => "death@reapers.afterlife",
"fullname" => "Reaper Grim",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
2019-04-06 09:24:22 -04:00
"token" => invite.token
}
{:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token"
2019-04-22 03:20:43 -04:00
refute User.get_cached_by_nickname("GrimReaper")
end
2018-06-12 07:52:54 -04:00
end
2017-04-16 04:25:27 -04:00
test "it returns the error on registration problems" do
data = %{
"nickname" => "lain",
"email" => "lain@wired.jp",
"fullname" => "lain iwakura",
"bio" => "close the world.",
"password" => "bear"
}
{:error, error_object} = TwitterAPI.register_user(data)
assert is_binary(error_object[:error])
2019-04-22 03:20:43 -04:00
refute User.get_cached_by_nickname("lain")
2017-04-16 04:25:27 -04:00
end
setup do
Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
Supervisor.restart_child(Pleroma.Supervisor, Cachex)
:ok
end
2017-03-21 12:53:20 -04:00
end