X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=test%2Fweb%2Ftwitter_api%2Ftwitter_api_test.exs;h=20a45cb6f94d74caa2f65c6333844576e512a7ff;hb=8bacdc36806efd01a7897359ff0fd2c8e24730d2;hp=b823bfd68f6e00a4c0486aa20816d09df6776f39;hpb=a32bcab04bed54984b76dc9ad59dd02e41f1e04d;p=akkoma
diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
index b823bfd68..20a45cb6f 100644
--- a/test/web/twitter_api/twitter_api_test.exs
+++ b/test/web/twitter_api/twitter_api_test.exs
@@ -1,442 +1,427 @@
# Pleroma: A lightweight social networking server
-# Copyright © 2017-2018 Pleroma Authors
+# Copyright © 2017-2020 Pleroma Authors
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
use Pleroma.DataCase
- alias Pleroma.Activity
- alias Pleroma.Object
+ import Pleroma.Factory
alias Pleroma.Repo
+ alias Pleroma.Tests.ObanHelpers
alias Pleroma.User
alias Pleroma.UserInviteToken
- alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.TwitterAPI.ActivityView
alias Pleroma.Web.TwitterAPI.TwitterAPI
- alias Pleroma.Web.TwitterAPI.UserView
-
- import Pleroma.Factory
-
- test "create a status" do
- user = insert(:user)
- mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})
-
- object_data = %{
- "type" => "Image",
- "url" => [
- %{
- "type" => "Link",
- "mediaType" => "image/jpg",
- "href" => "http://example.org/image.jpg"
- }
- ],
- "uuid" => 1
- }
- object = Repo.insert!(%Object{data: object_data})
+ setup_all do
+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
+ :ok
+ end
- input = %{
- "status" =>
- "Hello again, @shp.\nThis is on another :moominmamma: line. #2hu #epic #phantasmagoric",
- "media_ids" => [object.id]
+ test "it registers a new user and returns the user." do
+ data = %{
+ :username => "lain",
+ :email => "lain@wired.jp",
+ :fullname => "lain iwakura",
+ :password => "bear",
+ :confirm => "bear"
}
- {:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
-
- expected_text =
- "Hello again, @shp.<script></script>
This is on another :moominmamma: line. #2hu #epic #phantasmagoric
image.jpg"
-
- assert get_in(activity.data, ["object", "content"]) == expected_text
- assert get_in(activity.data, ["object", "type"]) == "Note"
- assert get_in(activity.data, ["object", "actor"]) == user.ap_id
- assert get_in(activity.data, ["actor"]) == user.ap_id
- assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))
-
- assert Enum.member?(
- get_in(activity.data, ["to"]),
- "https://www.w3.org/ns/activitystreams#Public"
- )
-
- assert Enum.member?(get_in(activity.data, ["to"]), "shp")
- assert activity.local == true
-
- assert %{"moominmamma" => "http://localhost:4001/finmoji/128px/moominmamma-128.png"} =
- activity.data["object"]["emoji"]
-
- # hashtags
- assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]
-
- # Add a context
- assert is_binary(get_in(activity.data, ["context"]))
- assert is_binary(get_in(activity.data, ["object", "context"]))
-
- assert is_list(activity.data["object"]["attachment"])
-
- assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data
-
- user = User.get_by_ap_id(user.ap_id)
+ {:ok, user} = TwitterAPI.register_user(data)
- assert user.info.note_count == 1
+ assert user == User.get_cached_by_nickname("lain")
end
- test "create a status that is a reply" do
- user = insert(:user)
-
- input = %{
- "status" => "Hello again."
- }
-
- {:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
-
- input = %{
- "status" => "Here's your (you).",
- "in_reply_to_status_id" => activity.id
+ test "it registers a new user with empty string in bio and returns the user" do
+ data = %{
+ :username => "lain",
+ :email => "lain@wired.jp",
+ :fullname => "lain iwakura",
+ :bio => "",
+ :password => "bear",
+ :confirm => "bear"
}
- {:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)
-
- assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])
-
- assert get_in(reply.data, ["object", "context"]) ==
- get_in(activity.data, ["object", "context"])
+ {:ok, user} = TwitterAPI.register_user(data)
- assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
- assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
+ assert user == User.get_cached_by_nickname("lain")
end
- test "Follow another user using user_id" do
- user = insert(:user)
- followed = insert(:user)
+ test "it sends confirmation email if :account_activation_required is specified in instance config" do
+ setting = Pleroma.Config.get([:instance, :account_activation_required])
- {:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
- assert User.ap_followers(followed) in user.following
+ unless setting do
+ Pleroma.Config.put([:instance, :account_activation_required], true)
+ on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
+ end
- {:error, msg} = TwitterAPI.follow(user, %{"user_id" => followed.id})
- assert msg == "Could not follow user: #{followed.nickname} is already on your list."
- end
+ data = %{
+ :username => "lain",
+ :email => "lain@wired.jp",
+ :fullname => "lain iwakura",
+ :bio => "",
+ :password => "bear",
+ :confirm => "bear"
+ }
- test "Follow another user using screen_name" do
- user = insert(:user)
- followed = insert(:user)
+ {:ok, user} = TwitterAPI.register_user(data)
+ ObanHelpers.perform_all()
- {:ok, user, followed, _activity} =
- TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
+ assert user.confirmation_pending
- assert User.ap_followers(followed) in user.following
+ email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
- followed = User.get_by_ap_id(followed.ap_id)
- assert followed.info.follower_count == 1
+ notify_email = Pleroma.Config.get([:instance, :notify_email])
+ instance_name = Pleroma.Config.get([:instance, :name])
- {:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
- assert msg == "Could not follow user: #{followed.nickname} is already on your list."
+ Swoosh.TestAssertions.assert_email_sent(
+ from: {instance_name, notify_email},
+ to: {user.name, user.email},
+ html_body: email.html_body
+ )
end
- test "Unfollow another user using user_id" do
- unfollowed = insert(:user)
- user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
- ActivityPub.follow(user, unfollowed)
-
- {:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
- assert user.following == []
+ test "it sends an admin email if :account_approval_required is specified in instance config" do
+ admin = insert(:user, is_admin: true)
+ setting = Pleroma.Config.get([:instance, :account_approval_required])
- {:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
- assert msg == "Not subscribed!"
- end
+ unless setting do
+ Pleroma.Config.put([:instance, :account_approval_required], true)
+ on_exit(fn -> Pleroma.Config.put([:instance, :account_approval_required], setting) end)
+ end
- test "Unfollow another user using screen_name" do
- unfollowed = insert(:user)
- user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
+ data = %{
+ :username => "lain",
+ :email => "lain@wired.jp",
+ :fullname => "lain iwakura",
+ :bio => "",
+ :password => "bear",
+ :confirm => "bear",
+ :reason => "I love anime"
+ }
- ActivityPub.follow(user, unfollowed)
+ {:ok, user} = TwitterAPI.register_user(data)
+ ObanHelpers.perform_all()
- {:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
- assert user.following == []
+ assert user.approval_pending
- {:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
- assert msg == "Not subscribed!"
- end
+ email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, user)
- test "Block another user using user_id" do
- user = insert(:user)
- blocked = insert(:user)
+ notify_email = Pleroma.Config.get([:instance, :notify_email])
+ instance_name = Pleroma.Config.get([:instance, :name])
- {:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
- assert User.blocks?(user, blocked)
+ Swoosh.TestAssertions.assert_email_sent(
+ from: {instance_name, notify_email},
+ to: {admin.name, admin.email},
+ html_body: email.html_body
+ )
end
- test "Block another user using screen_name" do
- user = insert(:user)
- blocked = insert(:user)
+ test "it registers a new user and parses mentions in the bio" do
+ data1 = %{
+ :username => "john",
+ :email => "john@gmail.com",
+ :fullname => "John Doe",
+ :bio => "test",
+ :password => "bear",
+ :confirm => "bear"
+ }
- {:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
- assert User.blocks?(user, blocked)
- end
+ {:ok, user1} = TwitterAPI.register_user(data1)
- test "Unblock another user using user_id" do
- unblocked = insert(:user)
- user = insert(:user)
- {:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})
+ data2 = %{
+ :username => "lain",
+ :email => "lain@wired.jp",
+ :fullname => "lain iwakura",
+ :bio => "@john test",
+ :password => "bear",
+ :confirm => "bear"
+ }
- {:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
- assert user.info.blocks == []
- end
+ {:ok, user2} = TwitterAPI.register_user(data2)
- test "Unblock another user using screen_name" do
- unblocked = insert(:user)
- user = insert(:user)
- {:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})
+ expected_text =
+ ~s(@john test)
- {:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
- assert user.info.blocks == []
+ assert user2.bio == expected_text
end
- test "upload a file" do
- user = insert(:user)
+ describe "register with one time token" do
+ setup do: clear_config([:instance, :registrations_open], false)
- file = %Plug.Upload{
- content_type: "image/jpg",
- path: Path.absname("test/fixtures/image.jpg"),
- filename: "an_image.jpg"
- }
+ test "returns user on success" do
+ {:ok, invite} = UserInviteToken.create_invite()
- response = TwitterAPI.upload(file, user)
+ data = %{
+ :username => "vinny",
+ :email => "pasta@pizza.vs",
+ :fullname => "Vinny Vinesauce",
+ :bio => "streamer",
+ :password => "hiptofbees",
+ :confirm => "hiptofbees",
+ :token => invite.token
+ }
- assert is_binary(response)
- end
+ {:ok, user} = TwitterAPI.register_user(data)
- test "it favorites a status, returns the updated activity" do
- user = insert(:user)
- other_user = insert(:user)
- note_activity = insert(:note_activity)
+ assert user == User.get_cached_by_nickname("vinny")
- {:ok, status} = TwitterAPI.fav(user, note_activity.id)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
- assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 1
-
- object = Object.normalize(note_activity.data["object"])
-
- assert object.data["like_count"] == 1
+ invite = Repo.get_by(UserInviteToken, token: invite.token)
+ assert invite.used == true
+ end
- assert status == updated_activity
+ test "returns error on invalid token" do
+ data = %{
+ :username => "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"
+ refute User.get_cached_by_nickname("GrimReaper")
+ end
- {:ok, _status} = TwitterAPI.fav(other_user, note_activity.id)
+ test "returns error on expired token" do
+ {:ok, invite} = UserInviteToken.create_invite()
+ UserInviteToken.update_invite!(invite, used: true)
- object = Object.normalize(note_activity.data["object"])
+ data = %{
+ :username => "GrimReaper",
+ :email => "death@reapers.afterlife",
+ :fullname => "Reaper Grim",
+ :bio => "Your time has come",
+ :password => "scythe",
+ :confirm => "scythe",
+ :token => invite.token
+ }
- assert object.data["like_count"] == 2
+ {:error, msg} = TwitterAPI.register_user(data)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
- assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 2
+ assert msg == "Expired token"
+ refute User.get_cached_by_nickname("GrimReaper")
+ end
end
- test "it unfavorites a status, returns the updated activity" do
- user = insert(:user)
- note_activity = insert(:note_activity)
- object = Object.get_by_ap_id(note_activity.data["object"]["id"])
+ describe "registers with date limited token" do
+ setup do: clear_config([:instance, :registrations_open], false)
- {:ok, _like_activity, _object} = ActivityPub.like(user, object)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
+ setup do
+ data = %{
+ :username => "vinny",
+ :email => "pasta@pizza.vs",
+ :fullname => "Vinny Vinesauce",
+ :bio => "streamer",
+ :password => "hiptofbees",
+ :confirm => "hiptofbees"
+ }
- assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1
+ check_fn = fn invite ->
+ data = Map.put(data, :token, invite.token)
+ {:ok, user} = TwitterAPI.register_user(data)
- {:ok, activity} = TwitterAPI.unfav(user, note_activity.id)
+ assert user == User.get_cached_by_nickname("vinny")
+ end
- assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
- end
+ {:ok, data: data, check_fn: check_fn}
+ end
- test "it retweets a status and returns the retweet" do
- user = insert(:user)
- note_activity = insert(:note_activity)
+ test "returns user on success", %{check_fn: check_fn} do
+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
- {:ok, status} = TwitterAPI.repeat(user, note_activity.id)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
+ check_fn.(invite)
- assert status == updated_activity
- end
+ invite = Repo.get_by(UserInviteToken, token: invite.token)
- test "it unretweets an already retweeted status" do
- user = insert(:user)
- note_activity = insert(:note_activity)
+ refute invite.used
+ end
- {:ok, _status} = TwitterAPI.repeat(user, note_activity.id)
- {:ok, status} = TwitterAPI.unrepeat(user, note_activity.id)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
+ 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)})
- assert status == updated_activity
- end
+ check_fn.(invite)
- 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"
- }
+ invite = Repo.get_by(UserInviteToken, token: invite.token)
- {:ok, user} = TwitterAPI.register_user(data)
+ refute invite.used
+ end
- fetched_user = Repo.get_by(User, nickname: "lain")
+ test "returns an error on overdue date", %{data: data} do
+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1)})
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
- end
+ data = Map.put(data, "token", invite.token)
- 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" => "",
- "password" => "bear",
- "confirm" => "bear"
- }
+ {:error, msg} = TwitterAPI.register_user(data)
- {:ok, user} = TwitterAPI.register_user(data)
+ assert msg == "Expired token"
+ refute User.get_cached_by_nickname("vinny")
+ invite = Repo.get_by(UserInviteToken, token: invite.token)
- fetched_user = Repo.get_by(User, nickname: "lain")
-
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
+ refute invite.used
+ end
end
- @moduletag skip: "needs 'account_activation_required: true' in config"
- test "it sends confirmation email if :account_activation_required is specified in instance config" do
- setting = Pleroma.Config.get([:instance, :account_activation_required])
+ describe "registers with reusable token" do
+ setup do: clear_config([:instance, :registrations_open], false)
- unless setting do
- Pleroma.Config.put([:instance, :account_activation_required], true)
- on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
- end
+ test "returns user on success, after him registration fails" do
+ {:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})
- data = %{
- "nickname" => "lain",
- "email" => "lain@wired.jp",
- "fullname" => "lain iwakura",
- "bio" => "",
- "password" => "bear",
- "confirm" => "bear"
- }
+ UserInviteToken.update_invite!(invite, uses: 99)
- {:ok, user} = TwitterAPI.register_user(data)
+ data = %{
+ :username => "vinny",
+ :email => "pasta@pizza.vs",
+ :fullname => "Vinny Vinesauce",
+ :bio => "streamer",
+ :password => "hiptofbees",
+ :confirm => "hiptofbees",
+ :token => invite.token
+ }
- assert user.info.confirmation_pending
+ {:ok, user} = TwitterAPI.register_user(data)
+ assert user == User.get_cached_by_nickname("vinny")
- Swoosh.TestAssertions.assert_email_sent(Pleroma.UserEmail.account_confirmation_email(user))
- end
-
- 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"
- }
+ invite = Repo.get_by(UserInviteToken, token: invite.token)
+ assert invite.used == true
- {:ok, user1} = TwitterAPI.register_user(data1)
+ data = %{
+ :username => "GrimReaper",
+ :email => "death@reapers.afterlife",
+ :fullname => "Reaper Grim",
+ :bio => "Your time has come",
+ :password => "scythe",
+ :confirm => "scythe",
+ :token => invite.token
+ }
- data2 = %{
- "nickname" => "lain",
- "email" => "lain@wired.jp",
- "fullname" => "lain iwakura",
- "bio" => "@john test",
- "password" => "bear",
- "confirm" => "bear"
- }
+ {:error, msg} = TwitterAPI.register_user(data)
- {:ok, user2} = TwitterAPI.register_user(data2)
+ assert msg == "Expired token"
+ refute User.get_cached_by_nickname("GrimReaper")
+ end
+ end
- expected_text =
- "@john test"
+ describe "registers with reusable date limited token" do
+ setup do: clear_config([:instance, :registrations_open], false)
- assert user2.bio == expected_text
- end
+ test "returns user on success" do
+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
- @moduletag skip: "needs 'registrations_open: false' in config"
- test "it registers a new user via invite token and returns the user." do
- {:ok, token} = UserInviteToken.create_token()
+ data = %{
+ :username => "vinny",
+ :email => "pasta@pizza.vs",
+ :fullname => "Vinny Vinesauce",
+ :bio => "streamer",
+ :password => "hiptofbees",
+ :confirm => "hiptofbees",
+ :token => invite.token
+ }
- data = %{
- "nickname" => "vinny",
- "email" => "pasta@pizza.vs",
- "fullname" => "Vinny Vinesauce",
- "bio" => "streamer",
- "password" => "hiptofbees",
- "confirm" => "hiptofbees",
- "token" => token.token
- }
+ {:ok, user} = TwitterAPI.register_user(data)
+ assert user == User.get_cached_by_nickname("vinny")
- {:ok, user} = TwitterAPI.register_user(data)
+ invite = Repo.get_by(UserInviteToken, token: invite.token)
+ refute invite.used
+ end
- fetched_user = Repo.get_by(User, nickname: "vinny")
- token = Repo.get_by(UserInviteToken, token: token.token)
+ test "error after max uses" do
+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
+
+ UserInviteToken.update_invite!(invite, uses: 99)
+
+ data = %{
+ :username => "vinny",
+ :email => "pasta@pizza.vs",
+ :fullname => "Vinny Vinesauce",
+ :bio => "streamer",
+ :password => "hiptofbees",
+ :confirm => "hiptofbees",
+ :token => invite.token
+ }
+
+ {:ok, user} = TwitterAPI.register_user(data)
+ assert user == User.get_cached_by_nickname("vinny")
+
+ invite = Repo.get_by(UserInviteToken, token: invite.token)
+ assert invite.used == true
+
+ data = %{
+ :username => "GrimReaper",
+ :email => "death@reapers.afterlife",
+ :fullname => "Reaper Grim",
+ :bio => "Your time has come",
+ :password => "scythe",
+ :confirm => "scythe",
+ :token => invite.token
+ }
+
+ {:error, msg} = TwitterAPI.register_user(data)
+
+ assert msg == "Expired token"
+ refute User.get_cached_by_nickname("GrimReaper")
+ end
- assert token.used == true
+ test "returns error on overdue date" do
+ {:ok, invite} =
+ UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
- end
+ data = %{
+ :username => "GrimReaper",
+ :email => "death@reapers.afterlife",
+ :fullname => "Reaper Grim",
+ :bio => "Your time has come",
+ :password => "scythe",
+ :confirm => "scythe",
+ :token => invite.token
+ }
- @moduletag skip: "needs 'registrations_open: false' in config"
- test "it returns an error if invalid token submitted" 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)
- {:error, msg} = TwitterAPI.register_user(data)
+ assert msg == "Expired token"
+ refute User.get_cached_by_nickname("GrimReaper")
+ end
- assert msg == "Invalid token"
- refute Repo.get_by(User, nickname: "GrimReaper")
- end
+ test "returns error on with overdue date and after max" do
+ {:ok, invite} =
+ UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
- @moduletag skip: "needs 'registrations_open: false' in config"
- test "it returns an error if expired token submitted" do
- {:ok, token} = UserInviteToken.create_token()
- UserInviteToken.mark_as_used(token.token)
+ 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",
- "token" => token.token
- }
+ data = %{
+ :username => "GrimReaper",
+ :email => "death@reapers.afterlife",
+ :fullname => "Reaper Grim",
+ :bio => "Your time has come",
+ :password => "scythe",
+ :confirm => "scythe",
+ :token => invite.token
+ }
- {:error, msg} = TwitterAPI.register_user(data)
+ {:error, msg} = TwitterAPI.register_user(data)
- assert msg == "Expired token"
- refute Repo.get_by(User, nickname: "GrimReaper")
+ assert msg == "Expired token"
+ refute User.get_cached_by_nickname("GrimReaper")
+ end
end
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"
+ :username => "lain",
+ :email => "lain@wired.jp",
+ :fullname => "lain iwakura",
+ :bio => "close the world."
}
- {:error, error_object} = TwitterAPI.register_user(data)
+ {:error, error} = TwitterAPI.register_user(data)
- assert is_binary(error_object[:error])
- refute Repo.get_by(User, nickname: "lain")
- end
-
- test "it assigns an integer conversation_id" do
- note_activity = insert(:note_activity)
- status = ActivityView.render("activity.json", activity: note_activity)
-
- assert is_number(status["statusnet_conversation_id"])
+ assert is_binary(error)
+ refute User.get_cached_by_nickname("lain")
end
setup do
@@ -444,19 +429,4 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
Supervisor.restart_child(Pleroma.Supervisor, Cachex)
:ok
end
-
- describe "fetching a user by uri" do
- test "fetches a user by uri" do
- id = "https://mastodon.social/users/lambadalambda"
- user = insert(:user)
- {:ok, represented} = TwitterAPI.get_external_profile(user, id)
- remote = User.get_by_ap_id(id)
-
- assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]
-
- # Also fetches the feed.
- # assert Activity.get_create_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
- # credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
- end
- end
end