worst/akkoma
1
0
Fork 0
forked from AkkomaGang/akkoma
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge branch 'get-cached-everywhere' into 'develop'

Browse source 
Use `User.get_cached*` everywhere

See merge request pleroma/pleroma!1021
This commit is contained in:
kaniini 2019-04-22 07:20:43 +00:00
commit 0b6d1d920e
42 changed files with 255 additions and 229 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
lib/mix/tasks/pleroma/user.ex
View file

@ -162,7 +162,7 @@ def run(["new", nickname, email | rest]) do
def run(["rm", nickname]) do def run(["rm", nickname]) do
Common.start_pleroma() Common.start_pleroma()
with %User{local: true} = user <- User.get_by_nickname(nickname) do with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
User.delete(user) User.delete(user)
Mix.shell().info("User #{nickname} deleted.") Mix.shell().info("User #{nickname} deleted.")
else else
@ -174,7 +174,7 @@ def run(["rm", nickname]) do
def run(["toggle_activated", nickname]) do def run(["toggle_activated", nickname]) do
Common.start_pleroma() Common.start_pleroma()
with %User{} = user <- User.get_by_nickname(nickname) do with %User{} = user <- User.get_cached_by_nickname(nickname) do
{:ok, user} = User.deactivate(user, !user.info.deactivated) {:ok, user} = User.deactivate(user, !user.info.deactivated)
Mix.shell().info( Mix.shell().info(
@ -189,7 +189,7 @@ def run(["toggle_activated", nickname]) do
def run(["reset_password", nickname]) do def run(["reset_password", nickname]) do
Common.start_pleroma() Common.start_pleroma()
with %User{local: true} = user <- User.get_by_nickname(nickname), with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
{:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do {:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
Mix.shell().info("Generated password reset token for #{user.nickname}") Mix.shell().info("Generated password reset token for #{user.nickname}")
@ -211,14 +211,14 @@ def run(["reset_password", nickname]) do
def run(["unsubscribe", nickname]) do def run(["unsubscribe", nickname]) do
Common.start_pleroma() Common.start_pleroma()
with %User{} = user <- User.get_by_nickname(nickname) do with %User{} = user <- User.get_cached_by_nickname(nickname) do
Mix.shell().info("Deactivating #{user.nickname}") Mix.shell().info("Deactivating #{user.nickname}")
User.deactivate(user) User.deactivate(user)
{:ok, friends} = User.get_friends(user) {:ok, friends} = User.get_friends(user)
Enum.each(friends, fn friend -> Enum.each(friends, fn friend ->
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
Mix.shell().info("Unsubscribing #{friend.nickname} from #{user.nickname}") Mix.shell().info("Unsubscribing #{friend.nickname} from #{user.nickname}")
User.unfollow(user, friend) User.unfollow(user, friend)
@ -226,7 +226,7 @@ def run(["unsubscribe", nickname]) do
:timer.sleep(500) :timer.sleep(500)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
if Enum.empty?(user.following) do if Enum.empty?(user.following) do
Mix.shell().info("Successfully unsubscribed all followers from #{user.nickname}") Mix.shell().info("Successfully unsubscribed all followers from #{user.nickname}")
@ -250,7 +250,7 @@ def run(["set", nickname | rest]) do
] ]
) )
with %User{local: true} = user <- User.get_by_nickname(nickname) do with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
user = user =
case Keyword.get(options, :moderator) do case Keyword.get(options, :moderator) do
nil -> user nil -> user
@ -277,7 +277,7 @@ def run(["set", nickname | rest]) do
def run(["tag", nickname | tags]) do def run(["tag", nickname | tags]) do
Common.start_pleroma() Common.start_pleroma()
with %User{} = user <- User.get_by_nickname(nickname) do with %User{} = user <- User.get_cached_by_nickname(nickname) do
user = user |> User.tag(tags) user = user |> User.tag(tags)
Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}") Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}")
@ -290,7 +290,7 @@ def run(["tag", nickname | tags]) do
def run(["untag", nickname | tags]) do def run(["untag", nickname | tags]) do
Common.start_pleroma() Common.start_pleroma()
with %User{} = user <- User.get_by_nickname(nickname) do with %User{} = user <- User.get_cached_by_nickname(nickname) do
user = user |> User.untag(tags) user = user |> User.untag(tags)
Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}") Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}")
@ -379,7 +379,7 @@ def run(["revoke_invite", token]) do
def run(["delete_activities", nickname]) do def run(["delete_activities", nickname]) do
Common.start_pleroma() Common.start_pleroma()
with %User{local: true} = user <- User.get_by_nickname(nickname) do with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
User.delete_user_activities(user) User.delete_user_activities(user)
Mix.shell().info("User #{nickname} statuses deleted.") Mix.shell().info("User #{nickname} statuses deleted.")
else else

2
lib/pleroma/PasswordResetToken.ex
View file

@ -39,7 +39,7 @@ def used_changeset(struct) do
def reset_password(token, data) do def reset_password(token, data) do
with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}), with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
%User{} = user <- User.get_by_id(token.user_id), %User{} = user <- User.get_cached_by_id(token.user_id),
{:ok, _user} <- User.reset_password(user, data), {:ok, _user} <- User.reset_password(user, data),
{:ok, token} <- Repo.update(used_changeset(token)) do {:ok, token} <- Repo.update(used_changeset(token)) do
{:ok, token} {:ok, token}

2
lib/pleroma/list.ex
View file

@ -80,7 +80,7 @@ def get_lists_from_activity(%Activity{actor: ap_id}) do
# Get lists to which the account belongs. # Get lists to which the account belongs.
def get_lists_account_belongs(%User{} = owner, account_id) do def get_lists_account_belongs(%User{} = owner, account_id) do
user = User.get_by_id(account_id) user = User.get_cached_by_id(account_id)
query = query =
from( from(

2
lib/pleroma/notification.ex
View file

@ -196,7 +196,7 @@ def skip?(
def skip?(:follows, activity, %{info: %{notification_settings: %{"follows" => false}}} = user) do def skip?(:follows, activity, %{info: %{notification_settings: %{"follows" => false}}} = user) do
actor = activity.data["actor"] actor = activity.data["actor"]
followed = User.get_by_ap_id(actor) followed = User.get_cached_by_ap_id(actor)
User.following?(user, followed) User.following?(user, followed)
end end

37
lib/pleroma/user.ex
View file

@ -269,6 +269,7 @@ defp autofollow_users(user) do
def register(%Ecto.Changeset{} = changeset) do def register(%Ecto.Changeset{} = changeset) do
with {:ok, user} <- Repo.insert(changeset), with {:ok, user} <- Repo.insert(changeset),
{:ok, user} <- autofollow_users(user), {:ok, user} <- autofollow_users(user),
{:ok, user} <- set_cache(user),
{:ok, _} <- Pleroma.User.WelcomeMessage.post_welcome_message_to_user(user), {:ok, _} <- Pleroma.User.WelcomeMessage.post_welcome_message_to_user(user),
{:ok, _} <- try_send_confirmation_email(user) do {:ok, _} <- try_send_confirmation_email(user) do
{:ok, user} {:ok, user}
@ -453,10 +454,13 @@ def get_by_guessed_nickname(ap_id) do
name = List.last(String.split(ap_id, "/")) name = List.last(String.split(ap_id, "/"))
nickname = "#{name}@#{domain}" nickname = "#{name}@#{domain}"
get_by_nickname(nickname) get_cached_by_nickname(nickname)
end end
def set_cache(user) do def set_cache({:ok, user}), do: set_cache(user)
def set_cache({:error, err}), do: {:error, err}
def set_cache(%User{} = user) do
Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user) Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
Cachex.put(:user_cache, "nickname:#{user.nickname}", user) Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user)) Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user))
@ -544,6 +548,7 @@ def get_or_fetch_by_nickname(nickname) do
with [_nick, _domain] <- String.split(nickname, "@"), with [_nick, _domain] <- String.split(nickname, "@"),
{:ok, user} <- fetch_by_nickname(nickname) do {:ok, user} <- fetch_by_nickname(nickname) do
if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do
# TODO turn into job
{:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user]) {:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
end end
@ -1002,7 +1007,7 @@ def block(blocker, %User{ap_id: ap_id} = blocked) do
# helper to handle the block given only an actor's AP id # helper to handle the block given only an actor's AP id
def block(blocker, %{ap_id: ap_id}) do def block(blocker, %{ap_id: ap_id}) do
block(blocker, User.get_by_ap_id(ap_id)) block(blocker, get_cached_by_ap_id(ap_id))
end end
def unblock(blocker, %{ap_id: ap_id}) do def unblock(blocker, %{ap_id: ap_id}) do
@ -1032,7 +1037,7 @@ def blocks?(user, %{ap_id: ap_id}) do
end end
def subscribed_to?(user, %{ap_id: ap_id}) do def subscribed_to?(user, %{ap_id: ap_id}) do
with %User{} = target <- User.get_by_ap_id(ap_id) do with %User{} = target <- get_cached_by_ap_id(ap_id) do
Enum.member?(target.info.subscribers, user.ap_id) Enum.member?(target.info.subscribers, user.ap_id)
end end
end end
@ -1207,7 +1212,7 @@ def fetch_by_ap_id(ap_id) do
end end
def get_or_fetch_by_ap_id(ap_id) do def get_or_fetch_by_ap_id(ap_id) do
user = get_by_ap_id(ap_id) user = get_cached_by_ap_id(ap_id)
if !is_nil(user) and !User.needs_update?(user) do if !is_nil(user) and !User.needs_update?(user) do
user user
@ -1230,7 +1235,7 @@ def get_or_fetch_by_ap_id(ap_id) do
def get_or_create_instance_user do def get_or_create_instance_user do
relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay" relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
if user = get_by_ap_id(relay_uri) do if user = get_cached_by_ap_id(relay_uri) do
user user
else else
changes = changes =
@ -1277,13 +1282,11 @@ defp blank?(""), do: nil
defp blank?(n), do: n defp blank?(n), do: n
def insert_or_update_user(data) do def insert_or_update_user(data) do
data =
data data
|> Map.put(:name, blank?(data[:name]) || data[:nickname]) |> Map.put(:name, blank?(data[:name]) || data[:nickname])
|> remote_user_creation()
cs = User.remote_user_creation(data) |> Repo.insert(on_conflict: :replace_all, conflict_target: :nickname)
|> set_cache()
Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
end end
def ap_enabled?(%User{local: true}), do: true def ap_enabled?(%User{local: true}), do: true
@ -1299,8 +1302,8 @@ def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
# this is because we have synchronous follow APIs and need to simulate them # this is because we have synchronous follow APIs and need to simulate them
# with an async handshake # with an async handshake
def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
with %User{} = a <- User.get_by_id(a.id), with %User{} = a <- User.get_cached_by_id(a.id),
%User{} = b <- User.get_by_id(b.id) do %User{} = b <- User.get_cached_by_id(b.id) do
{:ok, a, b} {:ok, a, b}
else else
_e -> _e ->
@ -1310,8 +1313,8 @@ def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
def wait_and_refresh(timeout, %User{} = a, %User{} = b) do def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
with :ok <- :timer.sleep(timeout), with :ok <- :timer.sleep(timeout),
%User{} = a <- User.get_by_id(a.id), %User{} = a <- User.get_cached_by_id(a.id),
%User{} = b <- User.get_by_id(b.id) do %User{} = b <- User.get_cached_by_id(b.id) do
{:ok, a, b} {:ok, a, b}
else else
_e -> _e ->
@ -1350,7 +1353,7 @@ def tag(user_identifiers, tags) when is_list(user_identifiers) do
end end
def tag(nickname, tags) when is_binary(nickname), def tag(nickname, tags) when is_binary(nickname),
do: tag(User.get_by_nickname(nickname), tags) do: tag(get_by_nickname(nickname), tags)
def tag(%User{} = user, tags), def tag(%User{} = user, tags),
do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags))) do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
@ -1362,7 +1365,7 @@ def untag(user_identifiers, tags) when is_list(user_identifiers) do
end end
def untag(nickname, tags) when is_binary(nickname), def untag(nickname, tags) when is_binary(nickname),
do: untag(User.get_by_nickname(nickname), tags) do: untag(get_by_nickname(nickname), tags)
def untag(%User{} = user, tags), def untag(%User{} = user, tags),
do: update_tags(user, (user.tags || []) -- normalize_tags(tags)) do: update_tags(user, (user.tags || []) -- normalize_tags(tags))

4
lib/pleroma/web/activity_pub/activity_pub.ex
View file

@ -197,7 +197,7 @@ def stream_out(activity) do
if !Enum.member?(activity.data["cc"] || [], public) && if !Enum.member?(activity.data["cc"] || [], public) &&
!Enum.member?( !Enum.member?(
activity.data["to"], activity.data["to"],
User.get_by_ap_id(activity.data["actor"]).follower_address User.get_cached_by_ap_id(activity.data["actor"]).follower_address
), ),
do: Pleroma.Web.Streamer.stream("direct", activity) do: Pleroma.Web.Streamer.stream("direct", activity)
end end
@ -889,7 +889,7 @@ def fetch_and_prepare_user_from_ap_id(ap_id) do
end end
def make_user_from_ap_id(ap_id) do def make_user_from_ap_id(ap_id) do
if _user = User.get_by_ap_id(ap_id) do if _user = User.get_cached_by_ap_id(ap_id) do
Transmogrifier.upgrade_user_from_ap_id(ap_id) Transmogrifier.upgrade_user_from_ap_id(ap_id)
else else
with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do

4
lib/pleroma/web/activity_pub/transmogrifier.ex
View file

@ -537,7 +537,7 @@ def handle_incoming(
data data
) )
when object_type in ["Person", "Application", "Service", "Organization"] do when object_type in ["Person", "Application", "Service", "Organization"] do
with %User{ap_id: ^actor_id} = actor <- User.get_by_ap_id(object["id"]) do with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
{:ok, new_user_data} = ActivityPub.user_data_from_user_object(object) {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
banner = new_user_data[:info]["banner"] banner = new_user_data[:info]["banner"]
@ -964,7 +964,7 @@ def perform(:user_upgrade, user) do
end end
def upgrade_user_from_ap_id(ap_id) do def upgrade_user_from_ap_id(ap_id) do
with %User{local: false} = user <- User.get_by_ap_id(ap_id), with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
{:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id), {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
already_ap <- User.ap_enabled?(user), already_ap <- User.ap_enabled?(user),
{:ok, user} <- user |> User.upgrade_changeset(data) |> User.update_and_set_cache() do {:ok, user} <- user |> User.upgrade_changeset(data) |> User.update_and_set_cache() do

24
lib/pleroma/web/admin_api/admin_api_controller.ex
View file

@ -19,7 +19,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do
action_fallback(:errors) action_fallback(:errors)
def user_delete(conn, %{"nickname" => nickname}) do def user_delete(conn, %{"nickname" => nickname}) do
User.get_by_nickname(nickname) User.get_cached_by_nickname(nickname)
|> User.delete() |> User.delete()
conn conn
@ -27,8 +27,8 @@ def user_delete(conn, %{"nickname" => nickname}) do
end end
def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
with %User{} = follower <- User.get_by_nickname(follower_nick), with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
%User{} = followed <- User.get_by_nickname(followed_nick) do %User{} = followed <- User.get_cached_by_nickname(followed_nick) do
User.follow(follower, followed) User.follow(follower, followed)
end end
@ -37,8 +37,8 @@ def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick
end end
def user_unfollow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do def user_unfollow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
with %User{} = follower <- User.get_by_nickname(follower_nick), with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
%User{} = followed <- User.get_by_nickname(followed_nick) do %User{} = followed <- User.get_cached_by_nickname(followed_nick) do
User.unfollow(follower, followed) User.unfollow(follower, followed)
end end
@ -67,7 +67,7 @@ def user_create(
end end
def user_show(conn, %{"nickname" => nickname}) do def user_show(conn, %{"nickname" => nickname}) do
with %User{} = user <- User.get_by_nickname(nickname) do with %User{} = user <- User.get_cached_by_nickname(nickname) do
conn conn
|> json(AccountView.render("show.json", %{user: user})) |> json(AccountView.render("show.json", %{user: user}))
else else
@ -76,7 +76,7 @@ def user_show(conn, %{"nickname" => nickname}) do
end end
def user_toggle_activation(conn, %{"nickname" => nickname}) do def user_toggle_activation(conn, %{"nickname" => nickname}) do
user = User.get_by_nickname(nickname) user = User.get_cached_by_nickname(nickname)
{:ok, updated_user} = User.deactivate(user, !user.info.deactivated) {:ok, updated_user} = User.deactivate(user, !user.info.deactivated)
@ -131,7 +131,7 @@ defp maybe_parse_filters(filters) do
def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname}) def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname})
when permission_group in ["moderator", "admin"] do when permission_group in ["moderator", "admin"] do
user = User.get_by_nickname(nickname) user = User.get_cached_by_nickname(nickname)
info = info =
%{} %{}
@ -156,7 +156,7 @@ def right_add(conn, _) do
end end
def right_get(conn, %{"nickname" => nickname}) do def right_get(conn, %{"nickname" => nickname}) do
user = User.get_by_nickname(nickname) user = User.get_cached_by_nickname(nickname)
conn conn
|> json(%{ |> json(%{
@ -178,7 +178,7 @@ def right_delete(
|> put_status(403) |> put_status(403)
|> json(%{error: "You can't revoke your own admin status."}) |> json(%{error: "You can't revoke your own admin status."})
else else
user = User.get_by_nickname(nickname) user = User.get_cached_by_nickname(nickname)
info = info =
%{} %{}
@ -204,7 +204,7 @@ def right_delete(conn, _) do
def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do
with {:ok, status} <- Ecto.Type.cast(:boolean, status), with {:ok, status} <- Ecto.Type.cast(:boolean, status),
%User{} = user <- User.get_by_nickname(nickname), %User{} = user <- User.get_cached_by_nickname(nickname),
{:ok, _} <- User.deactivate(user, !status), {:ok, _} <- User.deactivate(user, !status),
do: json_response(conn, :no_content, "") do: json_response(conn, :no_content, "")
end end
@ -277,7 +277,7 @@ def revoke_invite(conn, %{"token" => token}) do
@doc "Get a password reset token (base64 string) for given nickname" @doc "Get a password reset token (base64 string) for given nickname"
def get_password_reset(conn, %{"nickname" => nickname}) do def get_password_reset(conn, %{"nickname" => nickname}) do
(%User{local: true} = user) = User.get_by_nickname(nickname) (%User{local: true} = user) = User.get_cached_by_nickname(nickname)
{:ok, token} = Pleroma.PasswordResetToken.create_token(user) {:ok, token} = Pleroma.PasswordResetToken.create_token(user)
conn conn

2
lib/pleroma/web/channels/user_socket.ex
View file

@ -24,7 +24,7 @@ defmodule Pleroma.Web.UserSocket do
def connect(%{"token" => token}, socket) do def connect(%{"token" => token}, socket) do
with true <- Pleroma.Config.get([:chat, :enabled]), with true <- Pleroma.Config.get([:chat, :enabled]),
{:ok, user_id} <- Phoenix.Token.verify(socket, "user socket", token, max_age: 84_600), {:ok, user_id} <- Phoenix.Token.verify(socket, "user socket", token, max_age: 84_600),
%User{} = user <- Pleroma.User.get_by_id(user_id) do %User{} = user <- Pleroma.User.get_cached_by_id(user_id) do
{:ok, assign(socket, :user_name, user.nickname)} {:ok, assign(socket, :user_name, user.nickname)}
else else
_e -> :error _e -> :error

2
lib/pleroma/web/common_api/common_api.ex
View file

@ -284,7 +284,7 @@ def thread_muted?(user, activity) do
def report(user, data) do def report(user, data) do
with {:account_id, %{"account_id" => account_id}} <- {:account_id, data}, with {:account_id, %{"account_id" => account_id}} <- {:account_id, data},
{:account, %User{} = account} <- {:account, User.get_by_id(account_id)}, {:account, %User{} = account} <- {:account, User.get_cached_by_id(account_id)},
{:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]), {:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]),
{:ok, statuses} <- get_report_statuses(account, data), {:ok, statuses} <- get_report_statuses(account, data),
{:ok, activity} <- {:ok, activity} <-

2
lib/pleroma/web/common_api/utils.ex
View file

@ -284,7 +284,7 @@ defp shortname(name) do
end end
def confirm_current_password(user, password) do def confirm_current_password(user, password) do
with %User{local: true} = db_user <- User.get_by_id(user.id), with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
true <- Pbkdf2.checkpw(password, db_user.password_hash) do true <- Pbkdf2.checkpw(password, db_user.password_hash) do
{:ok, db_user} {:ok, db_user}
else else

2
lib/pleroma/web/federator/federator.ex
View file

@ -186,7 +186,7 @@ def perform(type, _) do
end end
def ap_enabled_actor(id) do def ap_enabled_actor(id) do
user = User.get_by_ap_id(id) user = User.get_cached_by_ap_id(id)
if User.ap_enabled?(user) do if User.ap_enabled?(user) do
{:ok, user} {:ok, user}

30
lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
View file

@ -304,7 +304,7 @@ def public_timeline(%{assigns: %{user: user}} = conn, params) do
end end
def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
with %User{} = user <- User.get_by_id(params["id"]) do with %User{} = user <- User.get_cached_by_id(params["id"]) do
activities = ActivityPub.fetch_user_activities(user, reading_user, params) activities = ActivityPub.fetch_user_activities(user, reading_user, params)
conn conn
@ -546,7 +546,7 @@ def unpin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
with %Activity{} = activity <- Activity.get_by_id_with_object(id), with %Activity{} = activity <- Activity.get_by_id_with_object(id),
%Object{} = object <- Object.normalize(activity), %Object{} = object <- Object.normalize(activity),
%User{} = user <- User.get_by_nickname(user.nickname), %User{} = user <- User.get_cached_by_nickname(user.nickname),
true <- Visibility.visible_for_user?(activity, user), true <- Visibility.visible_for_user?(activity, user),
{:ok, user} <- User.bookmark(user, object.data["id"]) do {:ok, user} <- User.bookmark(user, object.data["id"]) do
conn conn
@ -558,7 +558,7 @@ def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
def unbookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do def unbookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
with %Activity{} = activity <- Activity.get_by_id_with_object(id), with %Activity{} = activity <- Activity.get_by_id_with_object(id),
%Object{} = object <- Object.normalize(activity), %Object{} = object <- Object.normalize(activity),
%User{} = user <- User.get_by_nickname(user.nickname), %User{} = user <- User.get_cached_by_nickname(user.nickname),
true <- Visibility.visible_for_user?(activity, user), true <- Visibility.visible_for_user?(activity, user),
{:ok, user} <- User.unbookmark(user, object.data["id"]) do {:ok, user} <- User.unbookmark(user, object.data["id"]) do
conn conn
@ -750,7 +750,7 @@ def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
end end
def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
with %User{} = user <- User.get_by_id(id), with %User{} = user <- User.get_cached_by_id(id),
followers <- MastodonAPI.get_followers(user, params) do followers <- MastodonAPI.get_followers(user, params) do
followers = followers =
cond do cond do
@ -767,7 +767,7 @@ def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
end end
def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
with %User{} = user <- User.get_by_id(id), with %User{} = user <- User.get_cached_by_id(id),
followers <- MastodonAPI.get_friends(user, params) do followers <- MastodonAPI.get_friends(user, params) do
followers = followers =
cond do cond do
@ -792,7 +792,7 @@ def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
end end
def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
with %User{} = follower <- User.get_by_id(id), with %User{} = follower <- User.get_cached_by_id(id),
{:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do {:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
conn conn
|> put_view(AccountView) |> put_view(AccountView)
@ -806,7 +806,7 @@ def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}
end end
def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
with %User{} = follower <- User.get_by_id(id), with %User{} = follower <- User.get_cached_by_id(id),
{:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
conn conn
|> put_view(AccountView) |> put_view(AccountView)
@ -872,7 +872,7 @@ def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
end end
def mute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do def mute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
with %User{} = muted <- User.get_by_id(id), with %User{} = muted <- User.get_cached_by_id(id),
{:ok, muter} <- User.mute(muter, muted) do {:ok, muter} <- User.mute(muter, muted) do
conn conn
|> put_view(AccountView) |> put_view(AccountView)
@ -886,7 +886,7 @@ def mute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
end end
def unmute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do def unmute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
with %User{} = muted <- User.get_by_id(id), with %User{} = muted <- User.get_cached_by_id(id),
{:ok, muter} <- User.unmute(muter, muted) do {:ok, muter} <- User.unmute(muter, muted) do
conn conn
|> put_view(AccountView) |> put_view(AccountView)
@ -907,7 +907,7 @@ def mutes(%{assigns: %{user: user}} = conn, _) do
end end
def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
with %User{} = blocked <- User.get_by_id(id), with %User{} = blocked <- User.get_cached_by_id(id),
{:ok, blocker} <- User.block(blocker, blocked), {:ok, blocker} <- User.block(blocker, blocked),
{:ok, _activity} <- ActivityPub.block(blocker, blocked) do {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
conn conn
@ -922,7 +922,7 @@ def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
end end
def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
with %User{} = blocked <- User.get_by_id(id), with %User{} = blocked <- User.get_cached_by_id(id),
{:ok, blocker} <- User.unblock(blocker, blocked), {:ok, blocker} <- User.unblock(blocker, blocked),
{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
conn conn
@ -1088,7 +1088,7 @@ def favourites(%{assigns: %{user: user}} = conn, params) do
end end
def bookmarks(%{assigns: %{user: user}} = conn, _) do def bookmarks(%{assigns: %{user: user}} = conn, _) do
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
activities = activities =
user.bookmarks user.bookmarks
@ -1145,7 +1145,7 @@ def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" =>
accounts accounts
|> Enum.each(fn account_id -> |> Enum.each(fn account_id ->
with %Pleroma.List{} = list <- Pleroma.List.get(id, user), with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
%User{} = followed <- User.get_by_id(account_id) do %User{} = followed <- User.get_cached_by_id(account_id) do
Pleroma.List.follow(list, followed) Pleroma.List.follow(list, followed)
end end
end) end)
@ -1157,7 +1157,7 @@ def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_id
accounts accounts
|> Enum.each(fn account_id -> |> Enum.each(fn account_id ->
with %Pleroma.List{} = list <- Pleroma.List.get(id, user), with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
%User{} = followed <- Pleroma.User.get_by_id(account_id) do %User{} = followed <- Pleroma.User.get_cached_by_id(account_id) do
Pleroma.List.unfollow(list, followed) Pleroma.List.unfollow(list, followed)
end end
end) end)
@ -1450,7 +1450,7 @@ def logout(conn, _) do
def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
Logger.debug("Unimplemented, returning unmodified relationship") Logger.debug("Unimplemented, returning unmodified relationship")
with %User{} = target <- User.get_by_id(id) do with %User{} = target <- User.get_cached_by_id(id) do
conn conn
|> put_view(AccountView) |> put_view(AccountView)
|> render("relationship.json", %{user: user, target: target}) |> render("relationship.json", %{user: user, target: target})

2
lib/pleroma/web/mastodon_api/views/account_view.ex
View file

@ -68,7 +68,7 @@ def render("relationships.json", %{user: user, targets: targets}) do
defp do_render("account.json", %{user: user} = opts) do defp do_render("account.json", %{user: user} = opts) do
image = User.avatar_url(user) |> MediaProxy.url() image = User.avatar_url(user) |> MediaProxy.url()
header = User.banner_url(user) |> MediaProxy.url() header = User.banner_url(user) |> MediaProxy.url()
user_info = User.user_info(user) user_info = User.get_cached_user_info(user)
bot = (user.info.source_data["type"] || "Person") in ["Application", "Service"] bot = (user.info.source_data["type"] || "Person") in ["Application", "Service"]
emojis = emojis =

2
lib/pleroma/web/mastodon_api/websocket_handler.ex
View file

@ -90,7 +90,7 @@ defp allow_request(stream, nil) when stream in @anonymous_streams do
# Authenticated streams. # Authenticated streams.
defp allow_request(stream, {"access_token", access_token}) when stream in @streams do defp allow_request(stream, {"access_token", access_token}) when stream in @streams do
with %Token{user_id: user_id} <- Repo.get_by(Token, token: access_token), with %Token{user_id: user_id} <- Repo.get_by(Token, token: access_token),
user = %User{} <- User.get_by_id(user_id) do user = %User{} <- User.get_cached_by_id(user_id) do
{:ok, user} {:ok, user}
else else
_ -> {:error, 403} _ -> {:error, 403}

2
lib/pleroma/web/oauth/oauth_controller.ex
View file

@ -143,7 +143,7 @@ def token_exchange(conn, %{"grant_type" => "authorization_code"} = params) do
fixed_token = fix_padding(params["code"]), fixed_token = fix_padding(params["code"]),
%Authorization{} = auth <- %Authorization{} = auth <-
Repo.get_by(Authorization, token: fixed_token, app_id: app.id), Repo.get_by(Authorization, token: fixed_token, app_id: app.id),
%User{} = user <- User.get_by_id(auth.user_id), %User{} = user <- User.get_cached_by_id(auth.user_id),
{:ok, token} <- Token.exchange_token(app, auth), {:ok, token} <- Token.exchange_token(app, auth),
{:ok, inserted_at} <- DateTime.from_naive(token.inserted_at, "Etc/UTC") do {:ok, inserted_at} <- DateTime.from_naive(token.inserted_at, "Etc/UTC") do
response = %{ response = %{

2
lib/pleroma/web/oauth/token.ex
View file

@ -27,7 +27,7 @@ defmodule Pleroma.Web.OAuth.Token do
def exchange_token(app, auth) do def exchange_token(app, auth) do
with {:ok, auth} <- Authorization.use_token(auth), with {:ok, auth} <- Authorization.use_token(auth),
true <- auth.app_id == app.id do true <- auth.app_id == app.id do
create_token(app, User.get_by_id(auth.user_id), auth.scopes) create_token(app, User.get_cached_by_id(auth.user_id), auth.scopes)
end end
end end

2
lib/pleroma/web/ostatus/ostatus.ex
View file

@ -294,7 +294,7 @@ def make_user(uri, update \\ false) do
} }
with false <- update, with false <- update,
%User{} = user <- User.get_by_ap_id(data.ap_id) do %User{} = user <- User.get_cached_by_ap_id(data.ap_id) do
{:ok, user} {:ok, user}
else else
_e -> User.insert_or_update_user(data) _e -> User.insert_or_update_user(data)

2
lib/pleroma/web/streamer.ex
View file

@ -81,7 +81,7 @@ def handle_cast(%{action: :stream, topic: "list", item: item}, topics) do
_ -> _ ->
Pleroma.List.get_lists_from_activity(item) Pleroma.List.get_lists_from_activity(item)
|> Enum.filter(fn list -> |> Enum.filter(fn list ->
owner = User.get_by_id(list.user_id) owner = User.get_cached_by_id(list.user_id)
Visibility.visible_for_user?(item, owner) Visibility.visible_for_user?(item, owner)
end) end)

8
lib/pleroma/web/twitter_api/controllers/util_controller.ex
View file

@ -22,7 +22,7 @@ defmodule Pleroma.Web.TwitterAPI.UtilController do
def show_password_reset(conn, %{"token" => token}) do def show_password_reset(conn, %{"token" => token}) do
with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}), with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
%User{} = user <- User.get_by_id(token.user_id) do %User{} = user <- User.get_cached_by_id(token.user_id) do
render(conn, "password_reset.html", %{ render(conn, "password_reset.html", %{
token: token, token: token,
user: user user: user
@ -113,13 +113,13 @@ defp is_status?(acct) do
def do_remote_follow(conn, %{ def do_remote_follow(conn, %{
"authorization" => %{"name" => username, "password" => password, "id" => id} "authorization" => %{"name" => username, "password" => password, "id" => id}
}) do }) do
followee = User.get_by_id(id) followee = User.get_cached_by_id(id)
avatar = User.avatar_url(followee) avatar = User.avatar_url(followee)
name = followee.nickname name = followee.nickname
with %User{} = user <- User.get_cached_by_nickname(username), with %User{} = user <- User.get_cached_by_nickname(username),
true <- Pbkdf2.checkpw(password, user.password_hash), true <- Pbkdf2.checkpw(password, user.password_hash),
%User{} = _followed <- User.get_by_id(id), %User{} = _followed <- User.get_cached_by_id(id),
{:ok, follower} <- User.follow(user, followee), {:ok, follower} <- User.follow(user, followee),
{:ok, _activity} <- ActivityPub.follow(follower, followee) do {:ok, _activity} <- ActivityPub.follow(follower, followee) do
conn conn
@ -141,7 +141,7 @@ def do_remote_follow(conn, %{
end end
def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
with %User{} = followee <- User.get_by_id(id), with %User{} = followee <- User.get_cached_by_id(id),
{:ok, follower} <- User.follow(user, followee), {:ok, follower} <- User.follow(user, followee),
{:ok, _activity} <- ActivityPub.follow(follower, followee) do {:ok, _activity} <- ActivityPub.follow(follower, followee) do
conn conn

2
lib/pleroma/web/twitter_api/twitter_api.ex
View file

@ -240,7 +240,7 @@ def get_user(user \\ nil, params) do
end end
%{"screen_name" => nickname} -> %{"screen_name" => nickname} ->
case User.get_by_nickname(nickname) do case User.get_cached_by_nickname(nickname) do
nil -> {:error, "No user with such screen_name"} nil -> {:error, "No user with such screen_name"}
target -> {:ok, target} target -> {:ok, target}
end end

6
lib/pleroma/web/twitter_api/twitter_api_controller.ex
View file

@ -434,7 +434,7 @@ def password_reset(conn, params) do
end end
def confirm_email(conn, %{"user_id" => uid, "token" => token}) do def confirm_email(conn, %{"user_id" => uid, "token" => token}) do
with %User{} = user <- User.get_by_id(uid), with %User{} = user <- User.get_cached_by_id(uid),
true <- user.local, true <- user.local,
true <- user.info.confirmation_pending, true <- user.info.confirmation_pending,
true <- user.info.confirmation_token == token, true <- user.info.confirmation_token == token,
@ -587,7 +587,7 @@ def friend_requests(conn, params) do
def approve_friend_request(conn, %{"user_id" => uid} = _params) do def approve_friend_request(conn, %{"user_id" => uid} = _params) do
with followed <- conn.assigns[:user], with followed <- conn.assigns[:user],
%User{} = follower <- User.get_by_id(uid), %User{} = follower <- User.get_cached_by_id(uid),
{:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do {:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
conn conn
|> put_view(UserView) |> put_view(UserView)
@ -599,7 +599,7 @@ def approve_friend_request(conn, %{"user_id" => uid} = _params) do
def deny_friend_request(conn, %{"user_id" => uid} = _params) do def deny_friend_request(conn, %{"user_id" => uid} = _params) do
with followed <- conn.assigns[:user], with followed <- conn.assigns[:user],
%User{} = follower <- User.get_by_id(uid), %User{} = follower <- User.get_cached_by_id(uid),
{:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
conn conn
|> put_view(UserView) |> put_view(UserView)

2
lib/pleroma/web/web_finger/web_finger.ex
View file

@ -37,7 +37,7 @@ def webfinger(resource, fmt) when fmt in ["XML", "JSON"] do
regex = ~r/(acct:)?(?<username>\w+)@#{host}/ regex = ~r/(acct:)?(?<username>\w+)@#{host}/
with %{"username" => username} <- Regex.named_captures(regex, resource), with %{"username" => username} <- Regex.named_captures(regex, resource),
%User{} = user <- User.get_by_nickname(username) do %User{} = user <- User.get_cached_by_nickname(username) do
{:ok, represent_user(user, fmt)} {:ok, represent_user(user, fmt)}
else else
_e -> _e ->

4
test/notification_test.exs
View file

@ -46,7 +46,7 @@ test "it creates a notification for subscribed users" do
describe "create_notification" do describe "create_notification" do
test "it doesn't create a notification for user if the user blocks the activity author" do test "it doesn't create a notification for user if the user blocks the activity author" do
activity = insert(:note_activity) activity = insert(:note_activity)
author = User.get_by_ap_id(activity.data["actor"]) author = User.get_cached_by_ap_id(activity.data["actor"])
user = insert(:user) user = insert(:user)
{:ok, user} = User.block(user, author) {:ok, user} = User.block(user, author)
@ -124,7 +124,7 @@ test "it disables notifications from people the user follows" do
test "it doesn't create a notification for user if he is the activity author" do test "it doesn't create a notification for user if he is the activity author" do
activity = insert(:note_activity) activity = insert(:note_activity)
author = User.get_by_ap_id(activity.data["actor"]) author = User.get_cached_by_ap_id(activity.data["actor"])
assert nil == Notification.create_notification(activity, author) assert nil == Notification.create_notification(activity, author)
end end

4
test/tasks/relay_test.exs
View file

@ -31,7 +31,7 @@ test "relay is followed" do
local_user = Relay.get_actor() local_user = Relay.get_actor()
assert local_user.ap_id =~ "/relay" assert local_user.ap_id =~ "/relay"
target_user = User.get_by_ap_id(target_instance) target_user = User.get_cached_by_ap_id(target_instance)
refute target_user.local refute target_user.local
activity = Utils.fetch_latest_follow(local_user, target_user) activity = Utils.fetch_latest_follow(local_user, target_user)
@ -48,7 +48,7 @@ test "relay is unfollowed" do
Mix.Tasks.Pleroma.Relay.run(["follow", target_instance]) Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])
%User{ap_id: follower_id} = local_user = Relay.get_actor() %User{ap_id: follower_id} = local_user = Relay.get_actor()
target_user = User.get_by_ap_id(target_instance) target_user = User.get_cached_by_ap_id(target_instance)
follow_activity = Utils.fetch_latest_follow(local_user, target_user) follow_activity = Utils.fetch_latest_follow(local_user, target_user)
Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance]) Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance])

16
test/tasks/user_test.exs
View file

@ -50,7 +50,7 @@ test "user is created" do
assert_received {:mix_shell, :info, [message]} assert_received {:mix_shell, :info, [message]}
assert message =~ "created" assert message =~ "created"
user = User.get_by_nickname(unsaved.nickname) user = User.get_cached_by_nickname(unsaved.nickname)
assert user.name == unsaved.name assert user.name == unsaved.name
assert user.email == unsaved.email assert user.email == unsaved.email
assert user.bio == unsaved.bio assert user.bio == unsaved.bio
@ -75,7 +75,7 @@ test "user is not created" do
assert_received {:mix_shell, :info, [message]} assert_received {:mix_shell, :info, [message]}
assert message =~ "will not be created" assert message =~ "will not be created"
refute User.get_by_nickname(unsaved.nickname) refute User.get_cached_by_nickname(unsaved.nickname)
end end
end end
@ -88,7 +88,7 @@ test "user is deleted" do
assert_received {:mix_shell, :info, [message]} assert_received {:mix_shell, :info, [message]}
assert message =~ " deleted" assert message =~ " deleted"
user = User.get_by_nickname(user.nickname) user = User.get_cached_by_nickname(user.nickname)
assert user.info.deactivated assert user.info.deactivated
end end
@ -109,7 +109,7 @@ test "user is deactivated" do
assert_received {:mix_shell, :info, [message]} assert_received {:mix_shell, :info, [message]}
assert message =~ " deactivated" assert message =~ " deactivated"
user = User.get_by_nickname(user.nickname) user = User.get_cached_by_nickname(user.nickname)
assert user.info.deactivated assert user.info.deactivated
end end
@ -121,7 +121,7 @@ test "user is activated" do
assert_received {:mix_shell, :info, [message]} assert_received {:mix_shell, :info, [message]}
assert message =~ " activated" assert message =~ " activated"
user = User.get_by_nickname(user.nickname) user = User.get_cached_by_nickname(user.nickname)
refute user.info.deactivated refute user.info.deactivated
end end
@ -150,7 +150,7 @@ test "user is unsubscribed" do
assert_received {:mix_shell, :info, [message]} assert_received {:mix_shell, :info, [message]}
assert message =~ "Successfully unsubscribed" assert message =~ "Successfully unsubscribed"
user = User.get_by_nickname(user.nickname) user = User.get_cached_by_nickname(user.nickname)
assert Enum.empty?(user.following) assert Enum.empty?(user.following)
assert user.info.deactivated assert user.info.deactivated
end end
@ -178,7 +178,7 @@ test "All statuses set" do
assert_received {:mix_shell, :info, [message]} assert_received {:mix_shell, :info, [message]}
assert message =~ ~r/Admin status .* true/ assert message =~ ~r/Admin status .* true/
user = User.get_by_nickname(user.nickname) user = User.get_cached_by_nickname(user.nickname)
assert user.info.is_moderator assert user.info.is_moderator
assert user.info.locked assert user.info.locked
assert user.info.is_admin assert user.info.is_admin
@ -204,7 +204,7 @@ test "All statuses unset" do
assert_received {:mix_shell, :info, [message]} assert_received {:mix_shell, :info, [message]}
assert message =~ ~r/Admin status .* false/ assert message =~ ~r/Admin status .* false/
user = User.get_by_nickname(user.nickname) user = User.get_cached_by_nickname(user.nickname)
refute user.info.is_moderator refute user.info.is_moderator
refute user.info.locked refute user.info.locked
refute user.info.is_admin refute user.info.is_admin

32
test/user_test.exs
View file

@ -123,9 +123,9 @@ test "follow takes a user and another user" do
{:ok, user} = User.follow(user, followed) {:ok, user} = User.follow(user, followed)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
followed = User.get_by_ap_id(followed.ap_id) followed = User.get_cached_by_ap_id(followed.ap_id)
assert followed.info.follower_count == 1 assert followed.info.follower_count == 1
assert User.ap_followers(followed) in user.following assert User.ap_followers(followed) in user.following
@ -188,7 +188,7 @@ test "unfollow takes a user and another user" do
{:ok, user, _activity} = User.unfollow(user, followed) {:ok, user, _activity} = User.unfollow(user, followed)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.following == [] assert user.following == []
end end
@ -198,7 +198,7 @@ test "unfollow doesn't unfollow yourself" do
{:error, _} = User.unfollow(user, user) {:error, _} = User.unfollow(user, user)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.following == [user.ap_id] assert user.following == [user.ap_id]
end end
@ -556,8 +556,8 @@ test "gets all friends (followed users) for a given user" do
{:ok, res} = User.get_friends(user) {:ok, res} = User.get_friends(user)
followed_one = User.get_by_ap_id(followed_one.ap_id) followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
followed_two = User.get_by_ap_id(followed_two.ap_id) followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
assert Enum.member?(res, followed_one) assert Enum.member?(res, followed_one)
assert Enum.member?(res, followed_two) assert Enum.member?(res, followed_two)
refute Enum.member?(res, not_followed) refute Enum.member?(res, not_followed)
@ -568,7 +568,7 @@ test "gets all friends (followed users) for a given user" do
test "it sets the info->note_count property" do test "it sets the info->note_count property" do
note = insert(:note) note = insert(:note)
user = User.get_by_ap_id(note.data["actor"]) user = User.get_cached_by_ap_id(note.data["actor"])
assert user.info.note_count == 0 assert user.info.note_count == 0
@ -579,7 +579,7 @@ test "it sets the info->note_count property" do
test "it increases the info->note_count property" do test "it increases the info->note_count property" do
note = insert(:note) note = insert(:note)
user = User.get_by_ap_id(note.data["actor"]) user = User.get_cached_by_ap_id(note.data["actor"])
assert user.info.note_count == 0 assert user.info.note_count == 0
@ -594,7 +594,7 @@ test "it increases the info->note_count property" do
test "it decreases the info->note_count property" do test "it decreases the info->note_count property" do
note = insert(:note) note = insert(:note)
user = User.get_by_ap_id(note.data["actor"]) user = User.get_cached_by_ap_id(note.data["actor"])
assert user.info.note_count == 0 assert user.info.note_count == 0
@ -696,7 +696,7 @@ test "blocks tear down cyclical follow relationships" do
assert User.following?(blocked, blocker) assert User.following?(blocked, blocker)
{:ok, blocker} = User.block(blocker, blocked) {:ok, blocker} = User.block(blocker, blocked)
blocked = User.get_by_id(blocked.id) blocked = User.get_cached_by_id(blocked.id)
assert User.blocks?(blocker, blocked) assert User.blocks?(blocker, blocked)
@ -714,7 +714,7 @@ test "blocks tear down blocker->blocked follow relationships" do
refute User.following?(blocked, blocker) refute User.following?(blocked, blocker)
{:ok, blocker} = User.block(blocker, blocked) {:ok, blocker} = User.block(blocker, blocked)
blocked = User.get_by_id(blocked.id) blocked = User.get_cached_by_id(blocked.id)
assert User.blocks?(blocker, blocked) assert User.blocks?(blocker, blocked)
@ -732,7 +732,7 @@ test "blocks tear down blocked->blocker follow relationships" do
assert User.following?(blocked, blocker) assert User.following?(blocked, blocker)
{:ok, blocker} = User.block(blocker, blocked) {:ok, blocker} = User.block(blocker, blocked)
blocked = User.get_by_id(blocked.id) blocked = User.get_cached_by_id(blocked.id)
assert User.blocks?(blocker, blocked) assert User.blocks?(blocker, blocked)
@ -852,9 +852,9 @@ test ".delete deactivates a user, all follow relationships and all create activi
{:ok, _} = User.delete(user) {:ok, _} = User.delete(user)
followed = User.get_by_id(followed.id) followed = User.get_cached_by_id(followed.id)
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.info.deactivated assert user.info.deactivated
@ -1008,7 +1008,7 @@ test "works with URIs" do
results = User.search("http://mastodon.example.org/users/admin", resolve: true) results = User.search("http://mastodon.example.org/users/admin", resolve: true)
result = results |> List.first() result = results |> List.first()
user = User.get_by_ap_id("http://mastodon.example.org/users/admin") user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")
assert length(results) == 1 assert length(results) == 1
assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil) assert user == result |> Map.put(:search_rank, nil) |> Map.put(:search_type, nil)

8
test/web/activity_pub/activity_pub_controller_test.exs
View file

@ -50,7 +50,7 @@ test "it returns a json representation of the user with accept application/json"
|> put_req_header("accept", "application/json") |> put_req_header("accept", "application/json")
|> get("/users/#{user.nickname}") |> get("/users/#{user.nickname}")
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert json_response(conn, 200) == UserView.render("user.json", %{user: user}) assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
end end
@ -65,7 +65,7 @@ test "it returns a json representation of the user with accept application/activ
|> put_req_header("accept", "application/activity+json") |> put_req_header("accept", "application/activity+json")
|> get("/users/#{user.nickname}") |> get("/users/#{user.nickname}")
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert json_response(conn, 200) == UserView.render("user.json", %{user: user}) assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
end end
@ -83,7 +83,7 @@ test "it returns a json representation of the user with accept application/ld+js
) )
|> get("/users/#{user.nickname}") |> get("/users/#{user.nickname}")
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert json_response(conn, 200) == UserView.render("user.json", %{user: user}) assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
end end
@ -572,7 +572,7 @@ test "it works for more than 10 users", %{conn: conn} do
user = insert(:user) user = insert(:user)
Enum.each(1..15, fn _ -> Enum.each(1..15, fn _ ->
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = insert(:user) other_user = insert(:user)
User.follow(user, other_user) User.follow(user, other_user)
end) end)

44
test/web/activity_pub/activity_pub_test.exs
View file

@ -228,18 +228,30 @@ test "increases user note count only for public activities" do
user = insert(:user) user = insert(:user)
{:ok, _} = {:ok, _} =
CommonAPI.post(User.get_by_id(user.id), %{"status" => "1", "visibility" => "public"}) CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "1",
"visibility" => "public"
})
{:ok, _} = {:ok, _} =
CommonAPI.post(User.get_by_id(user.id), %{"status" => "2", "visibility" => "unlisted"}) CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "2",
"visibility" => "unlisted"
})
{:ok, _} = {:ok, _} =
CommonAPI.post(User.get_by_id(user.id), %{"status" => "2", "visibility" => "private"}) CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "2",
"visibility" => "private"
})
{:ok, _} = {:ok, _} =
CommonAPI.post(User.get_by_id(user.id), %{"status" => "3", "visibility" => "direct"}) CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "3",
"visibility" => "direct"
})
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.info.note_count == 2 assert user.info.note_count == 2
end end
@ -772,23 +784,35 @@ test "decrements user note count only for public activities" do
user = insert(:user, info: %{note_count: 10}) user = insert(:user, info: %{note_count: 10})
{:ok, a1} = {:ok, a1} =
CommonAPI.post(User.get_by_id(user.id), %{"status" => "yeah", "visibility" => "public"}) CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "yeah",
"visibility" => "public"
})
{:ok, a2} = {:ok, a2} =
CommonAPI.post(User.get_by_id(user.id), %{"status" => "yeah", "visibility" => "unlisted"}) CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "yeah",
"visibility" => "unlisted"
})
{:ok, a3} = {:ok, a3} =
CommonAPI.post(User.get_by_id(user.id), %{"status" => "yeah", "visibility" => "private"}) CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "yeah",
"visibility" => "private"
})
{:ok, a4} = {:ok, a4} =
CommonAPI.post(User.get_by_id(user.id), %{"status" => "yeah", "visibility" => "direct"}) CommonAPI.post(User.get_cached_by_id(user.id), %{
"status" => "yeah",
"visibility" => "direct"
})
{:ok, _} = Object.normalize(a1) |> ActivityPub.delete() {:ok, _} = Object.normalize(a1) |> ActivityPub.delete()
{:ok, _} = Object.normalize(a2) |> ActivityPub.delete() {:ok, _} = Object.normalize(a2) |> ActivityPub.delete()
{:ok, _} = Object.normalize(a3) |> ActivityPub.delete() {:ok, _} = Object.normalize(a3) |> ActivityPub.delete()
{:ok, _} = Object.normalize(a4) |> ActivityPub.delete() {:ok, _} = Object.normalize(a4) |> ActivityPub.delete()
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.info.note_count == 10 assert user.info.note_count == 10
end end

36
test/web/activity_pub/transmogrifier_test.exs
View file

@ -99,7 +99,7 @@ test "it works for incoming notices" do
assert object["sensitive"] == true assert object["sensitive"] == true
user = User.get_by_ap_id(object["actor"]) user = User.get_cached_by_ap_id(object["actor"])
assert user.info.note_count == 1 assert user.info.note_count == 1
end end
@ -212,7 +212,7 @@ test "it works for incoming follow requests" do
assert data["actor"] == "http://mastodon.example.org/users/admin" assert data["actor"] == "http://mastodon.example.org/users/admin"
assert data["type"] == "Follow" assert data["type"] == "Follow"
assert data["id"] == "http://mastodon.example.org/users/admin#follows/2" assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"
assert User.following?(User.get_by_ap_id(data["actor"]), user) assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
end end
test "it works for incoming follow requests from hubzilla" do test "it works for incoming follow requests from hubzilla" do
@ -229,7 +229,7 @@ test "it works for incoming follow requests from hubzilla" do
assert data["actor"] == "https://hubzilla.example.org/channel/kaniini" assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
assert data["type"] == "Follow" assert data["type"] == "Follow"
assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2" assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
assert User.following?(User.get_by_ap_id(data["actor"]), user) assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
end end
test "it works for incoming likes" do test "it works for incoming likes" do
@ -540,7 +540,7 @@ test "it works for incomming unfollows with an existing follow" do
assert data["object"]["object"] == user.ap_id assert data["object"]["object"] == user.ap_id
assert data["actor"] == "http://mastodon.example.org/users/admin" assert data["actor"] == "http://mastodon.example.org/users/admin"
refute User.following?(User.get_by_ap_id(data["actor"]), user) refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
end end
test "it works for incoming blocks" do test "it works for incoming blocks" do
@ -557,7 +557,7 @@ test "it works for incoming blocks" do
assert data["object"] == user.ap_id assert data["object"] == user.ap_id
assert data["actor"] == "http://mastodon.example.org/users/admin" assert data["actor"] == "http://mastodon.example.org/users/admin"
blocker = User.get_by_ap_id(data["actor"]) blocker = User.get_cached_by_ap_id(data["actor"])
assert User.blocks?(blocker, user) assert User.blocks?(blocker, user)
end end
@ -584,8 +584,8 @@ test "incoming blocks successfully tear down any follow relationship" do
assert data["object"] == blocked.ap_id assert data["object"] == blocked.ap_id
assert data["actor"] == blocker.ap_id assert data["actor"] == blocker.ap_id
blocker = User.get_by_ap_id(data["actor"]) blocker = User.get_cached_by_ap_id(data["actor"])
blocked = User.get_by_ap_id(data["object"]) blocked = User.get_cached_by_ap_id(data["object"])
assert User.blocks?(blocker, blocked) assert User.blocks?(blocker, blocked)
@ -614,7 +614,7 @@ test "it works for incoming unblocks with an existing block" do
assert data["object"]["object"] == user.ap_id assert data["object"]["object"] == user.ap_id
assert data["actor"] == "http://mastodon.example.org/users/admin" assert data["actor"] == "http://mastodon.example.org/users/admin"
blocker = User.get_by_ap_id(data["actor"]) blocker = User.get_cached_by_ap_id(data["actor"])
refute User.blocks?(blocker, user) refute User.blocks?(blocker, user)
end end
@ -645,7 +645,7 @@ test "it works for incoming accepts which were pre-accepted" do
assert activity.data["object"] == follow_activity.data["id"] assert activity.data["object"] == follow_activity.data["id"]
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
assert User.following?(follower, followed) == true assert User.following?(follower, followed) == true
end end
@ -667,7 +667,7 @@ test "it works for incoming accepts which were orphaned" do
{:ok, activity} = Transmogrifier.handle_incoming(accept_data) {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
assert activity.data["object"] == follow_activity.data["id"] assert activity.data["object"] == follow_activity.data["id"]
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
assert User.following?(follower, followed) == true assert User.following?(follower, followed) == true
end end
@ -687,7 +687,7 @@ test "it works for incoming accepts which are referenced by IRI only" do
{:ok, activity} = Transmogrifier.handle_incoming(accept_data) {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
assert activity.data["object"] == follow_activity.data["id"] assert activity.data["object"] == follow_activity.data["id"]
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
assert User.following?(follower, followed) == true assert User.following?(follower, followed) == true
end end
@ -706,7 +706,7 @@ test "it fails for incoming accepts which cannot be correlated" do
:error = Transmogrifier.handle_incoming(accept_data) :error = Transmogrifier.handle_incoming(accept_data)
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
refute User.following?(follower, followed) == true refute User.following?(follower, followed) == true
end end
@ -725,7 +725,7 @@ test "it fails for incoming rejects which cannot be correlated" do
:error = Transmogrifier.handle_incoming(accept_data) :error = Transmogrifier.handle_incoming(accept_data)
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
refute User.following?(follower, followed) == true refute User.following?(follower, followed) == true
end end
@ -750,7 +750,7 @@ test "it works for incoming rejects which are orphaned" do
{:ok, activity} = Transmogrifier.handle_incoming(reject_data) {:ok, activity} = Transmogrifier.handle_incoming(reject_data)
refute activity.local refute activity.local
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
assert User.following?(follower, followed) == false assert User.following?(follower, followed) == false
end end
@ -772,7 +772,7 @@ test "it works for incoming rejects which are referenced by IRI only" do
{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data) {:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
assert User.following?(follower, followed) == false assert User.following?(follower, followed) == false
end end
@ -1026,7 +1026,7 @@ test "it upgrades a user to activitypub" do
{:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"}) {:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.info.note_count == 1 assert user.info.note_count == 1
{:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye") {:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
@ -1034,7 +1034,7 @@ test "it upgrades a user to activitypub" do
assert user.info.note_count == 1 assert user.info.note_count == 1
assert user.follower_address == "https://niu.moe/users/rye/followers" assert user.follower_address == "https://niu.moe/users/rye/followers"
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.info.note_count == 1 assert user.info.note_count == 1
activity = Activity.get_by_id(activity.id) activity = Activity.get_by_id(activity.id)
@ -1063,7 +1063,7 @@ test "it upgrades a user to activitypub" do
unrelated_activity = Activity.get_by_id(unrelated_activity.id) unrelated_activity = Activity.get_by_id(unrelated_activity.id)
refute user.follower_address in unrelated_activity.recipients refute user.follower_address in unrelated_activity.recipients
user_two = User.get_by_id(user_two.id) user_two = User.get_cached_by_id(user_two.id)
assert user.follower_address in user_two.following assert user.follower_address in user_two.following
refute "..." in user_two.following refute "..." in user_two.following
end end

5
test/web/activity_pub/utils_test.exs
View file

@ -1,7 +1,6 @@
defmodule Pleroma.Web.ActivityPub.UtilsTest do defmodule Pleroma.Web.ActivityPub.UtilsTest do
use Pleroma.DataCase use Pleroma.DataCase
alias Pleroma.Activity alias Pleroma.Activity
alias Pleroma.Repo
alias Pleroma.User alias Pleroma.User
alias Pleroma.Web.ActivityPub.ActivityPub alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Utils alias Pleroma.Web.ActivityPub.Utils
@ -12,8 +11,8 @@ defmodule Pleroma.Web.ActivityPub.UtilsTest do
describe "fetch the latest Follow" do describe "fetch the latest Follow" do
test "fetches the latest Follow activity" do test "fetches the latest Follow activity" do
%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity) %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
follower = Repo.get_by(User, ap_id: activity.data["actor"]) follower = User.get_cached_by_ap_id(activity.data["actor"])
followed = Repo.get_by(User, ap_id: activity.data["object"]) followed = User.get_cached_by_ap_id(activity.data["object"])
assert activity == Utils.fetch_latest_follow(follower, followed) assert activity == Utils.fetch_latest_follow(follower, followed)
end end

24
test/web/admin_api/admin_api_controller_test.exs
View file

@ -89,8 +89,8 @@ test "allows to force-follow another user" do
"followed" => user.nickname "followed" => user.nickname
}) })
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
assert User.following?(follower, user) assert User.following?(follower, user)
end end
@ -112,8 +112,8 @@ test "allows to force-unfollow another user" do
"followed" => user.nickname "followed" => user.nickname
}) })
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
follower = User.get_by_id(follower.id) follower = User.get_cached_by_id(follower.id)
refute User.following?(follower, user) refute User.following?(follower, user)
end end
@ -145,13 +145,13 @@ test "it appends specified tags to users with specified nicknames", %{
user2: user2 user2: user2
} do } do
assert json_response(conn, :no_content) assert json_response(conn, :no_content)
assert User.get_by_id(user1.id).tags == ["x", "foo", "bar"] assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
assert User.get_by_id(user2.id).tags == ["y", "foo", "bar"] assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
end end
test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
assert json_response(conn, :no_content) assert json_response(conn, :no_content)
assert User.get_by_id(user3.id).tags == ["unchanged"] assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
end end
end end
@ -181,13 +181,13 @@ test "it removes specified tags from users with specified nicknames", %{
user2: user2 user2: user2
} do } do
assert json_response(conn, :no_content) assert json_response(conn, :no_content)
assert User.get_by_id(user1.id).tags == [] assert User.get_cached_by_id(user1.id).tags == []
assert User.get_by_id(user2.id).tags == ["y"] assert User.get_cached_by_id(user2.id).tags == ["y"]
end end
test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
assert json_response(conn, :no_content) assert json_response(conn, :no_content)
assert User.get_by_id(user3.id).tags == ["unchanged"] assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
end end
end end
@ -257,7 +257,7 @@ test "deactivates the user", %{conn: conn} do
conn conn
|> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false}) |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.info.deactivated == true assert user.info.deactivated == true
assert json_response(conn, :no_content) assert json_response(conn, :no_content)
end end
@ -269,7 +269,7 @@ test "activates the user", %{conn: conn} do
conn conn
|> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: true}) |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: true})
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
assert user.info.deactivated == false assert user.info.deactivated == false
assert json_response(conn, :no_content) assert json_response(conn, :no_content)
end end

6
test/web/mastodon_api/account_view_test.exs
View file

@ -169,15 +169,15 @@ test "represent a relationship" do
test "represent an embedded relationship" do test "represent an embedded relationship" do
user = user =
insert(:user, %{ insert(:user, %{
info: %{note_count: 5, follower_count: 3, source_data: %{"type" => "Service"}}, info: %{note_count: 5, follower_count: 0, source_data: %{"type" => "Service"}},
nickname: "shp@shitposter.club", nickname: "shp@shitposter.club",
inserted_at: ~N[2017-08-15 15:47:06.597036] inserted_at: ~N[2017-08-15 15:47:06.597036]
}) })
other_user = insert(:user) other_user = insert(:user)
{:ok, other_user} = User.follow(other_user, user) {:ok, other_user} = User.follow(other_user, user)
{:ok, other_user} = User.block(other_user, user) {:ok, other_user} = User.block(other_user, user)
{:ok, _} = User.follow(insert(:user), user)
expected = %{ expected = %{
id: to_string(user.id), id: to_string(user.id),
@ -186,7 +186,7 @@ test "represent an embedded relationship" do
display_name: user.name, display_name: user.name,
locked: false, locked: false,
created_at: "2017-08-15T15:47:06.000Z", created_at: "2017-08-15T15:47:06.000Z",
followers_count: 3, followers_count: 1,
following_count: 0, following_count: 0,
statuses_count: 5, statuses_count: 5,
note: user.bio, note: user.bio,

34
test/web/mastodon_api/mastodon_api_controller_test.exs
View file

@ -445,7 +445,7 @@ test "get a status", %{conn: conn} do
describe "deleting a status" do describe "deleting a status" do
test "when you created it", %{conn: conn} do test "when you created it", %{conn: conn} do
activity = insert(:note_activity) activity = insert(:note_activity)
author = User.get_by_ap_id(activity.data["actor"]) author = User.get_cached_by_ap_id(activity.data["actor"])
conn = conn =
conn conn
@ -1167,7 +1167,7 @@ test "gets a users statuses", %{conn: conn} do
test "unimplemented pinned statuses feature", %{conn: conn} do test "unimplemented pinned statuses feature", %{conn: conn} do
note = insert(:note_activity) note = insert(:note_activity)
user = User.get_by_ap_id(note.data["actor"]) user = User.get_cached_by_ap_id(note.data["actor"])
conn = conn =
conn conn
@ -1178,7 +1178,7 @@ test "unimplemented pinned statuses feature", %{conn: conn} do
test "gets an users media", %{conn: conn} do test "gets an users media", %{conn: conn} do
note = insert(:note_activity) note = insert(:note_activity)
user = User.get_by_ap_id(note.data["actor"]) user = User.get_cached_by_ap_id(note.data["actor"])
file = %Plug.Upload{ file = %Plug.Upload{
content_type: "image/jpg", content_type: "image/jpg",
@ -1253,8 +1253,8 @@ test "/api/v1/follow_requests works" do
{:ok, _activity} = ActivityPub.follow(other_user, user) {:ok, _activity} = ActivityPub.follow(other_user, user)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
assert User.following?(other_user, user) == false assert User.following?(other_user, user) == false
@ -1273,8 +1273,8 @@ test "/api/v1/follow_requests/:id/authorize works" do
{:ok, _activity} = ActivityPub.follow(other_user, user) {:ok, _activity} = ActivityPub.follow(other_user, user)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
assert User.following?(other_user, user) == false assert User.following?(other_user, user) == false
@ -1286,8 +1286,8 @@ test "/api/v1/follow_requests/:id/authorize works" do
assert relationship = json_response(conn, 200) assert relationship = json_response(conn, 200)
assert to_string(other_user.id) == relationship["id"] assert to_string(other_user.id) == relationship["id"]
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
assert User.following?(other_user, user) == true assert User.following?(other_user, user) == true
end end
@ -1310,7 +1310,7 @@ test "/api/v1/follow_requests/:id/reject works" do
{:ok, _activity} = ActivityPub.follow(other_user, user) {:ok, _activity} = ActivityPub.follow(other_user, user)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
conn = conn =
build_conn() build_conn()
@ -1320,8 +1320,8 @@ test "/api/v1/follow_requests/:id/reject works" do
assert relationship = json_response(conn, 200) assert relationship = json_response(conn, 200)
assert to_string(other_user.id) == relationship["id"] assert to_string(other_user.id) == relationship["id"]
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
assert User.following?(other_user, user) == false assert User.following?(other_user, user) == false
end end
@ -1606,7 +1606,7 @@ test "following / unfollowing a user", %{conn: conn} do
assert %{"id" => _id, "following" => true} = json_response(conn, 200) assert %{"id" => _id, "following" => true} = json_response(conn, 200)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
conn = conn =
build_conn() build_conn()
@ -1615,7 +1615,7 @@ test "following / unfollowing a user", %{conn: conn} do
assert %{"id" => _id, "following" => false} = json_response(conn, 200) assert %{"id" => _id, "following" => false} = json_response(conn, 200)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
conn = conn =
build_conn() build_conn()
@ -1709,7 +1709,7 @@ test "muting / unmuting a user", %{conn: conn} do
assert %{"id" => _id, "muting" => true} = json_response(conn, 200) assert %{"id" => _id, "muting" => true} = json_response(conn, 200)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
conn = conn =
build_conn() build_conn()
@ -1764,7 +1764,7 @@ test "blocking / unblocking a user", %{conn: conn} do
assert %{"id" => _id, "blocking" => true} = json_response(conn, 200) assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
conn = conn =
build_conn() build_conn()
@ -2124,7 +2124,7 @@ test "get instance stats", %{conn: conn} do
{:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"}) {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
# Stats should count users with missing or nil `info.deactivated` value # Stats should count users with missing or nil `info.deactivated` value
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
info_change = Changeset.change(user.info, %{deactivated: nil}) info_change = Changeset.change(user.info, %{deactivated: nil})
{:ok, _user} = {:ok, _user} =

2
test/web/mastodon_api/notification_view_test.exs
View file

@ -21,7 +21,7 @@ test "Mention notification" do
mentioned_user = insert(:user) mentioned_user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{mentioned_user.nickname}"}) {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{mentioned_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity) {:ok, [notification]} = Notification.create_notifications(activity)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
expected = %{ expected = %{
id: to_string(notification.id), id: to_string(notification.id),

2
test/web/mastodon_api/status_view_test.exs
View file

@ -178,7 +178,7 @@ test "contains mentions" do
status = StatusView.render("status.json", %{activity: activity}) status = StatusView.render("status.json", %{activity: activity})
actor = User.get_by_ap_id(activity.actor) actor = User.get_cached_by_ap_id(activity.actor)
assert status.mentions == assert status.mentions ==
Enum.map([user, actor], fn u -> AccountView.render("mention.json", %{user: u}) end) Enum.map([user, actor], fn u -> AccountView.render("mention.json", %{user: u}) end)

8
test/web/ostatus/ostatus_controller_test.exs
View file

@ -6,7 +6,6 @@ defmodule Pleroma.Web.OStatus.OStatusControllerTest do
use Pleroma.Web.ConnCase use Pleroma.Web.ConnCase
import Pleroma.Factory import Pleroma.Factory
alias Pleroma.Object alias Pleroma.Object
alias Pleroma.Repo
alias Pleroma.User alias Pleroma.User
alias Pleroma.Web.CommonAPI alias Pleroma.Web.CommonAPI
alias Pleroma.Web.OStatus.ActivityRepresenter alias Pleroma.Web.OStatus.ActivityRepresenter
@ -41,7 +40,8 @@ test "decodes a salmon with a changed magic key", %{conn: conn} do
assert response(conn, 200) assert response(conn, 200)
# Set a wrong magic-key for a user so it has to refetch # Set a wrong magic-key for a user so it has to refetch
salmon_user = User.get_by_ap_id("http://gs.example.org:4040/index.php/user/1") salmon_user = User.get_cached_by_ap_id("http://gs.example.org:4040/index.php/user/1")
# Wrong key # Wrong key
info_cng = info_cng =
User.Info.remote_user_creation(salmon_user.info, %{ User.Info.remote_user_creation(salmon_user.info, %{
@ -52,7 +52,7 @@ test "decodes a salmon with a changed magic key", %{conn: conn} do
salmon_user salmon_user
|> Ecto.Changeset.change() |> Ecto.Changeset.change()
|> Ecto.Changeset.put_embed(:info, info_cng) |> Ecto.Changeset.put_embed(:info, info_cng)
|> Repo.update() |> User.update_and_set_cache()
conn = conn =
build_conn() build_conn()
@ -86,7 +86,7 @@ test "returns 404 for a missing feed", %{conn: conn} do
test "gets an object", %{conn: conn} do test "gets an object", %{conn: conn} do
note_activity = insert(:note_activity) note_activity = insert(:note_activity)
user = User.get_by_ap_id(note_activity.data["actor"]) user = User.get_cached_by_ap_id(note_activity.data["actor"])
[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["object"]["id"])) [_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["object"]["id"]))
url = "/objects/#{uuid}" url = "/objects/#{uuid}"

12
test/web/ostatus/ostatus_test.exs
View file

@ -30,7 +30,7 @@ test "handle incoming note - GS, Salmon" do
{:ok, [activity]} = OStatus.handle_incoming(incoming) {:ok, [activity]} = OStatus.handle_incoming(incoming)
object = Object.normalize(activity.data["object"]) object = Object.normalize(activity.data["object"])
user = User.get_by_ap_id(activity.data["actor"]) user = User.get_cached_by_ap_id(activity.data["actor"])
assert user.info.note_count == 1 assert user.info.note_count == 1
assert activity.data["type"] == "Create" assert activity.data["type"] == "Create"
assert object.data["type"] == "Note" assert object.data["type"] == "Note"
@ -296,8 +296,8 @@ test "handle incoming follows" do
assert activity.data["object"] == "https://pawoo.net/users/pekorino" assert activity.data["object"] == "https://pawoo.net/users/pekorino"
refute activity.local refute activity.local
follower = User.get_by_ap_id(activity.data["actor"]) follower = User.get_cached_by_ap_id(activity.data["actor"])
followed = User.get_by_ap_id(activity.data["object"]) followed = User.get_cached_by_ap_id(activity.data["object"])
assert User.following?(follower, followed) assert User.following?(follower, followed)
end end
@ -320,8 +320,8 @@ test "handle incoming unfollows with existing follow" do
assert activity.data["object"]["object"] == "https://pawoo.net/users/pekorino" assert activity.data["object"]["object"] == "https://pawoo.net/users/pekorino"
refute activity.local refute activity.local
follower = User.get_by_ap_id(activity.data["actor"]) follower = User.get_cached_by_ap_id(activity.data["actor"])
followed = User.get_by_ap_id(activity.data["object"]["object"]) followed = User.get_cached_by_ap_id(activity.data["object"]["object"])
refute User.following?(follower, followed) refute User.following?(follower, followed)
end end
@ -355,7 +355,7 @@ test "tries to use the information in poco fields" do
{:ok, user} = OStatus.find_or_make_user(uri) {:ok, user} = OStatus.find_or_make_user(uri)
user = Pleroma.User.get_by_id(user.id) user = Pleroma.User.get_cached_by_id(user.id)
assert user.name == "Constance Variable" assert user.name == "Constance Variable"
assert user.nickname == "lambadalambda@social.heldscal.la" assert user.nickname == "lambadalambda@social.heldscal.la"
assert user.local == false assert user.local == false

2
test/web/salmon/salmon_test.exs
View file

@ -99,7 +99,7 @@ test "it pushes an activity to remote accounts it's addressed to" do
} }
{:ok, activity} = Repo.insert(%Activity{data: activity_data, recipients: activity_data["to"]}) {:ok, activity} = Repo.insert(%Activity{data: activity_data, recipients: activity_data["to"]})
user = User.get_by_ap_id(activity.data["actor"]) user = User.get_cached_by_ap_id(activity.data["actor"])
{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user) {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
poster = fn url, _data, _headers -> poster = fn url, _data, _headers ->

40
test/web/twitter_api/twitter_api_controller_test.exs
View file

@ -270,7 +270,7 @@ test "returns 200 to authenticated request when the instance is public",
test "returns one status", %{conn: conn} do test "returns one status", %{conn: conn} do
user = insert(:user) user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"}) {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
actor = Repo.get_by!(User, ap_id: activity.data["actor"]) actor = User.get_cached_by_ap_id(activity.data["actor"])
conn = conn =
conn conn
@ -720,7 +720,7 @@ test "with credentials", %{conn: conn, user: current_user} do
|> with_credentials(current_user.nickname, "test") |> with_credentials(current_user.nickname, "test")
|> post("/api/friendships/create.json", %{user_id: followed.id}) |> post("/api/friendships/create.json", %{user_id: followed.id})
current_user = User.get_by_id(current_user.id) current_user = User.get_cached_by_id(current_user.id)
assert User.ap_followers(followed) in current_user.following assert User.ap_followers(followed) in current_user.following
assert json_response(conn, 200) == assert json_response(conn, 200) ==
@ -735,8 +735,8 @@ test "for restricted account", %{conn: conn, user: current_user} do
|> with_credentials(current_user.nickname, "test") |> with_credentials(current_user.nickname, "test")
|> post("/api/friendships/create.json", %{user_id: followed.id}) |> post("/api/friendships/create.json", %{user_id: followed.id})
current_user = User.get_by_id(current_user.id) current_user = User.get_cached_by_id(current_user.id)
followed = User.get_by_id(followed.id) followed = User.get_cached_by_id(followed.id)
refute User.ap_followers(followed) in current_user.following refute User.ap_followers(followed) in current_user.following
@ -765,7 +765,7 @@ test "with credentials", %{conn: conn, user: current_user} do
|> with_credentials(current_user.nickname, "test") |> with_credentials(current_user.nickname, "test")
|> post("/api/friendships/destroy.json", %{user_id: followed.id}) |> post("/api/friendships/destroy.json", %{user_id: followed.id})
current_user = User.get_by_id(current_user.id) current_user = User.get_cached_by_id(current_user.id)
assert current_user.following == [current_user.ap_id] assert current_user.following == [current_user.ap_id]
assert json_response(conn, 200) == assert json_response(conn, 200) ==
@ -789,7 +789,7 @@ test "with credentials", %{conn: conn, user: current_user} do
|> with_credentials(current_user.nickname, "test") |> with_credentials(current_user.nickname, "test")
|> post("/api/blocks/create.json", %{user_id: blocked.id}) |> post("/api/blocks/create.json", %{user_id: blocked.id})
current_user = User.get_by_id(current_user.id) current_user = User.get_cached_by_id(current_user.id)
assert User.blocks?(current_user, blocked) assert User.blocks?(current_user, blocked)
assert json_response(conn, 200) == assert json_response(conn, 200) ==
@ -816,7 +816,7 @@ test "with credentials", %{conn: conn, user: current_user} do
|> with_credentials(current_user.nickname, "test") |> with_credentials(current_user.nickname, "test")
|> post("/api/blocks/destroy.json", %{user_id: blocked.id}) |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
current_user = User.get_by_id(current_user.id) current_user = User.get_cached_by_id(current_user.id)
assert current_user.info.blocks == [] assert current_user.info.blocks == []
assert json_response(conn, 200) == assert json_response(conn, 200) ==
@ -847,7 +847,7 @@ test "with credentials", %{conn: conn, user: current_user} do
|> with_credentials(current_user.nickname, "test") |> with_credentials(current_user.nickname, "test")
|> post("/api/qvitter/update_avatar.json", %{img: avatar_image}) |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
current_user = User.get_by_id(current_user.id) current_user = User.get_cached_by_id(current_user.id)
assert is_map(current_user.avatar) assert is_map(current_user.avatar)
assert json_response(conn, 200) == assert json_response(conn, 200) ==
@ -956,7 +956,7 @@ test "with credentials", %{conn: conn, user: current_user} do
|> post(request_path) |> post(request_path)
activity = Activity.get_by_id(note_activity.id) activity = Activity.get_by_id(note_activity.id)
activity_user = User.get_by_ap_id(note_activity.data["actor"]) activity_user = User.get_cached_by_ap_id(note_activity.data["actor"])
assert json_response(response, 200) == assert json_response(response, 200) ==
ActivityView.render("activity.json", %{ ActivityView.render("activity.json", %{
@ -994,7 +994,7 @@ test "with credentials", %{conn: conn, user: current_user} do
|> post(request_path) |> post(request_path)
activity = Activity.get_by_id(note_activity.id) activity = Activity.get_by_id(note_activity.id)
activity_user = User.get_by_ap_id(note_activity.data["actor"]) activity_user = User.get_cached_by_ap_id(note_activity.data["actor"])
assert json_response(response, 200) == assert json_response(response, 200) ==
ActivityView.render("activity.json", %{ ActivityView.render("activity.json", %{
@ -1022,7 +1022,7 @@ test "it creates a new user", %{conn: conn} do
user = json_response(conn, 200) user = json_response(conn, 200)
fetched_user = User.get_by_nickname("lain") fetched_user = User.get_cached_by_nickname("lain")
assert user == UserView.render("show.json", %{user: fetched_user}) assert user == UserView.render("show.json", %{user: fetched_user})
end end
@ -1116,7 +1116,7 @@ test "it redirects to root url", %{conn: conn, user: user} do
test "it confirms the user account", %{conn: conn, user: user} do test "it confirms the user account", %{conn: conn, user: user} do
get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}") get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
refute user.info.confirmation_pending refute user.info.confirmation_pending
refute user.info.confirmation_token refute user.info.confirmation_token
@ -1742,7 +1742,7 @@ test "with credentials, valid password and matching new password and confirmatio
}) })
assert json_response(conn, 200) == %{"status" => "success"} assert json_response(conn, 200) == %{"status" => "success"}
fetched_user = User.get_by_id(current_user.id) fetched_user = User.get_cached_by_id(current_user.id)
assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
end end
end end
@ -1783,8 +1783,8 @@ test "it lists friend requests" do
{:ok, _activity} = ActivityPub.follow(other_user, user) {:ok, _activity} = ActivityPub.follow(other_user, user)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
assert User.following?(other_user, user) == false assert User.following?(other_user, user) == false
@ -1823,8 +1823,8 @@ test "it approves a friend request" do
{:ok, _activity} = ActivityPub.follow(other_user, user) {:ok, _activity} = ActivityPub.follow(other_user, user)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
assert User.following?(other_user, user) == false assert User.following?(other_user, user) == false
@ -1846,8 +1846,8 @@ test "it denies a friend request" do
{:ok, _activity} = ActivityPub.follow(other_user, user) {:ok, _activity} = ActivityPub.follow(other_user, user)
user = User.get_by_id(user.id) user = User.get_cached_by_id(user.id)
other_user = User.get_by_id(other_user.id) other_user = User.get_cached_by_id(other_user.id)
assert User.following?(other_user, user) == false assert User.following?(other_user, user) == false
@ -1916,7 +1916,7 @@ test "it performs the upload and sets `data[actor]` with AP id of uploader user"
describe "POST /api/media/metadata/create" do describe "POST /api/media/metadata/create" do
setup do setup do
object = insert(:note) object = insert(:note)
user = User.get_by_ap_id(object.data["actor"]) user = User.get_cached_by_ap_id(object.data["actor"])
%{object: object, user: user} %{object: object, user: user}
end end

36
test/web/twitter_api/twitter_api_test.exs
View file

@ -78,7 +78,7 @@ test "create a status" do
assert activity.data["object"] == object.data["id"] assert activity.data["object"] == object.data["id"]
user = User.get_by_ap_id(user.ap_id) user = User.get_cached_by_ap_id(user.ap_id)
assert user.info.note_count == 1 assert user.info.note_count == 1
end end
@ -129,7 +129,7 @@ test "Follow another user using screen_name" do
assert User.ap_followers(followed) in user.following assert User.ap_followers(followed) in user.following
followed = User.get_by_ap_id(followed.ap_id) followed = User.get_cached_by_ap_id(followed.ap_id)
assert followed.info.follower_count == 1 assert followed.info.follower_count == 1
{:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname}) {:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
@ -281,7 +281,7 @@ test "it registers a new user and returns the user." do
{:ok, user} = TwitterAPI.register_user(data) {:ok, user} = TwitterAPI.register_user(data)
fetched_user = User.get_by_nickname("lain") fetched_user = User.get_cached_by_nickname("lain")
assert UserView.render("show.json", %{user: user}) == assert UserView.render("show.json", %{user: user}) ==
UserView.render("show.json", %{user: fetched_user}) UserView.render("show.json", %{user: fetched_user})
@ -299,7 +299,7 @@ test "it registers a new user with empty string in bio and returns the user." do
{:ok, user} = TwitterAPI.register_user(data) {:ok, user} = TwitterAPI.register_user(data)
fetched_user = User.get_by_nickname("lain") fetched_user = User.get_cached_by_nickname("lain")
assert UserView.render("show.json", %{user: user}) == assert UserView.render("show.json", %{user: user}) ==
UserView.render("show.json", %{user: fetched_user}) UserView.render("show.json", %{user: fetched_user})
@ -394,7 +394,7 @@ test "returns user on success" do
{:ok, user} = TwitterAPI.register_user(data) {:ok, user} = TwitterAPI.register_user(data)
fetched_user = User.get_by_nickname("vinny") fetched_user = User.get_cached_by_nickname("vinny")
invite = Repo.get_by(UserInviteToken, token: invite.token) invite = Repo.get_by(UserInviteToken, token: invite.token)
assert invite.used == true assert invite.used == true
@ -417,7 +417,7 @@ test "returns error on invalid token" do
{:error, msg} = TwitterAPI.register_user(data) {:error, msg} = TwitterAPI.register_user(data)
assert msg == "Invalid token" assert msg == "Invalid token"
refute User.get_by_nickname("GrimReaper") refute User.get_cached_by_nickname("GrimReaper")
end end
test "returns error on expired token" do test "returns error on expired token" do
@ -437,7 +437,7 @@ test "returns error on expired token" do
{:error, msg} = TwitterAPI.register_user(data) {:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token" assert msg == "Expired token"
refute User.get_by_nickname("GrimReaper") refute User.get_cached_by_nickname("GrimReaper")
end end
end end
@ -462,7 +462,7 @@ test "returns error on expired token" do
check_fn = fn invite -> check_fn = fn invite ->
data = Map.put(data, "token", invite.token) data = Map.put(data, "token", invite.token)
{:ok, user} = TwitterAPI.register_user(data) {:ok, user} = TwitterAPI.register_user(data)
fetched_user = User.get_by_nickname("vinny") fetched_user = User.get_cached_by_nickname("vinny")
assert UserView.render("show.json", %{user: user}) == assert UserView.render("show.json", %{user: user}) ==
UserView.render("show.json", %{user: fetched_user}) UserView.render("show.json", %{user: fetched_user})
@ -499,7 +499,7 @@ test "returns an error on overdue date", %{data: data} do
{:error, msg} = TwitterAPI.register_user(data) {:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token" assert msg == "Expired token"
refute User.get_by_nickname("vinny") refute User.get_cached_by_nickname("vinny")
invite = Repo.get_by(UserInviteToken, token: invite.token) invite = Repo.get_by(UserInviteToken, token: invite.token)
refute invite.used refute invite.used
@ -534,7 +534,7 @@ test "returns user on success, after him registration fails" do
} }
{:ok, user} = TwitterAPI.register_user(data) {:ok, user} = TwitterAPI.register_user(data)
fetched_user = User.get_by_nickname("vinny") fetched_user = User.get_cached_by_nickname("vinny")
invite = Repo.get_by(UserInviteToken, token: invite.token) invite = Repo.get_by(UserInviteToken, token: invite.token)
assert invite.used == true assert invite.used == true
@ -555,7 +555,7 @@ test "returns user on success, after him registration fails" do
{:error, msg} = TwitterAPI.register_user(data) {:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token" assert msg == "Expired token"
refute User.get_by_nickname("GrimReaper") refute User.get_cached_by_nickname("GrimReaper")
end end
end end
@ -585,7 +585,7 @@ test "returns user on success" do
} }
{:ok, user} = TwitterAPI.register_user(data) {:ok, user} = TwitterAPI.register_user(data)
fetched_user = User.get_by_nickname("vinny") fetched_user = User.get_cached_by_nickname("vinny")
invite = Repo.get_by(UserInviteToken, token: invite.token) invite = Repo.get_by(UserInviteToken, token: invite.token)
refute invite.used refute invite.used
@ -610,7 +610,7 @@ test "error after max uses" do
} }
{:ok, user} = TwitterAPI.register_user(data) {:ok, user} = TwitterAPI.register_user(data)
fetched_user = User.get_by_nickname("vinny") fetched_user = User.get_cached_by_nickname("vinny")
invite = Repo.get_by(UserInviteToken, token: invite.token) invite = Repo.get_by(UserInviteToken, token: invite.token)
assert invite.used == true assert invite.used == true
@ -630,7 +630,7 @@ test "error after max uses" do
{:error, msg} = TwitterAPI.register_user(data) {:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token" assert msg == "Expired token"
refute User.get_by_nickname("GrimReaper") refute User.get_cached_by_nickname("GrimReaper")
end end
test "returns error on overdue date" do test "returns error on overdue date" do
@ -650,7 +650,7 @@ test "returns error on overdue date" do
{:error, msg} = TwitterAPI.register_user(data) {:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token" assert msg == "Expired token"
refute User.get_by_nickname("GrimReaper") refute User.get_cached_by_nickname("GrimReaper")
end end
test "returns error on with overdue date and after max" do test "returns error on with overdue date and after max" do
@ -672,7 +672,7 @@ test "returns error on with overdue date and after max" do
{:error, msg} = TwitterAPI.register_user(data) {:error, msg} = TwitterAPI.register_user(data)
assert msg == "Expired token" assert msg == "Expired token"
refute User.get_by_nickname("GrimReaper") refute User.get_cached_by_nickname("GrimReaper")
end end
end end
@ -688,7 +688,7 @@ test "it returns the error on registration problems" do
{:error, error_object} = TwitterAPI.register_user(data) {:error, error_object} = TwitterAPI.register_user(data)
assert is_binary(error_object[:error]) assert is_binary(error_object[:error])
refute User.get_by_nickname("lain") refute User.get_cached_by_nickname("lain")
end end
test "it assigns an integer conversation_id" do test "it assigns an integer conversation_id" do
@ -709,7 +709,7 @@ test "fetches a user by uri" do
id = "https://mastodon.social/users/lambadalambda" id = "https://mastodon.social/users/lambadalambda"
user = insert(:user) user = insert(:user)
{:ok, represented} = TwitterAPI.get_external_profile(user, id) {:ok, represented} = TwitterAPI.get_external_profile(user, id)
remote = User.get_by_ap_id(id) remote = User.get_cached_by_ap_id(id)
assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"] assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

2
test/web/twitter_api/views/user_view_test.exs
View file

@ -292,7 +292,7 @@ test "A blocked user for the blocker" do
} }
} }
blocker = User.get_by_id(blocker.id) blocker = User.get_cached_by_id(blocker.id)
assert represented == UserView.render("show.json", %{user: user, for: blocker}) assert represented == UserView.render("show.json", %{user: user, for: blocker})
end end