end
def maybe_direct_follow(%User{} = follower, %User{} = followed) do
- if !User.ap_enabled?(followed) do
+ if not User.ap_enabled?(followed) do
follow(follower, followed)
else
{:ok, follower}
source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
}) do
key =
- :public_key.pem_decode(public_key_pem)
+ public_key_pem
+ |> :public_key.pem_decode()
|> hd()
|> :public_key.pem_entry_decode()
def ap_enabled?(%User{info: info}), do: info.ap_enabled
def ap_enabled?(_), do: false
- def get_or_fetch(uri_or_nickname) do
- if String.starts_with?(uri_or_nickname, "http") do
- get_or_fetch_by_ap_id(uri_or_nickname)
- else
- get_or_fetch_by_nickname(uri_or_nickname)
- end
- end
+ @doc "Gets or fetch a user by uri or nickname."
+ @spec get_or_fetch(String.t()) :: User.t()
+ def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
+ def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
# wait a period of time and return newest version of the User structs
# this is because we have synchronous follow APIs and need to simulate them
{String.trim(name, ":"), url}
end)
- CommonUtils.format_input(bio, mentions, tags, "text/plain") |> Formatter.emojify(emoji)
+ bio
+ |> CommonUtils.format_input(mentions, tags, "text/plain")
+ |> Formatter.emojify(emoji)
end
def tag(user_identifiers, tags) when is_list(user_identifiers) do
defmodule Pleroma.Web.CommonAPI.Utils do
- alias Pleroma.{Repo, Object, Formatter, Activity}
+ alias Calendar.Strftime
+ alias Comeonin.Pbkdf2
+ alias Pleroma.{Activity, Formatter, Object, Repo}
+ alias Pleroma.User
+ alias Pleroma.Web
alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.Endpoint
alias Pleroma.Web.MediaProxy
- alias Pleroma.User
- alias Calendar.Strftime
- alias Comeonin.Pbkdf2
# This is a hack for twidere.
def get_by_id_or_ap_id(id) do
|> Enum.sort_by(fn {tag, _} -> -String.length(tag) end)
Enum.reduce(tags, text, fn {full, tag}, text ->
- url = "<a href='#{Pleroma.Web.base_url()}/tag/#{tag}' rel='tag'>##{tag}</a>"
+ url = "<a href='#{Web.base_url()}/tag/#{tag}' rel='tag'>##{tag}</a>"
String.replace(text, full, url)
end)
end
"Undo",
"Delete"
]
- def publish(user, activity, poster \\ &@httpoison.post/4)
+ def publish(user, activity, poster \\ &@httpoison.post/3)
def publish(%{info: %{keys: keys}} = user, %{data: %{"type" => type}} = activity, poster)
when type in @supported_activities do
with response <-
@httpoison.get(
address,
- [Accept: "application/xrd+xml,application/jrd+json"],
- follow_redirect: true
+ Accept: "application/xrd+xml,application/jrd+json"
),
{:ok, %{status: status, body: body}} when status in 200..299 <- response do
doc = XML.parse_document(body)
{doc, _rest} =
text
|> :binary.bin_to_list()
- |> :xmerl_scan.string()
+ |> :xmerl_scan.string(quiet: true)
doc
rescue
defmodule Pleroma.FilterTest do
- alias Pleroma.{User, Repo}
+ alias Pleroma.Repo
use Pleroma.DataCase
import Pleroma.Factory
- import Ecto.Query
describe "creating filters" do
test "creating one filter" do
context: ["home"]
}
- {:ok, filter} = Pleroma.Filter.create(query)
+ {:ok, _filter} = Pleroma.Filter.create(query)
{:ok, filter} = Pleroma.Filter.delete(query)
assert is_nil(Repo.get(Pleroma.Filter, filter.filter_id))
end
defmodule Pleroma.ListTest do
- alias Pleroma.{User, Repo}
+ alias Pleroma.Repo
use Pleroma.DataCase
import Pleroma.Factory
- import Ecto.Query
test "creating a list" do
user = insert(:user)
user = insert(:user)
other_user = insert(:user)
{:ok, list} = Pleroma.List.create("title", user)
- {:ok, %{following: following}} = Pleroma.List.follow(list, other_user)
+ {:ok, %{following: _following}} = Pleroma.List.follow(list, other_user)
{:ok, %{following: following}} = Pleroma.List.unfollow(list, other_user)
assert [] == following
end
user = insert(:user)
other_user = insert(:user)
- {:ok, activity} =
+ {:ok, _activity} =
TwitterAPI.create_status(user, %{
"status" => "hey @#{other_user.nickname}!"
})
- {:ok, activity} =
+ {:ok, _activity} =
TwitterAPI.create_status(user, %{
"status" => "hey again @#{other_user.nickname}!"
})
assert n2.id > n1.id
- {:ok, activity} =
+ {:ok, _activity} =
TwitterAPI.create_status(user, %{
"status" => "hey yet again @#{other_user.nickname}!"
})
Notification.set_read_up_to(other_user, n2.id)
- [n3, n2, n1] = notifs = Notification.for_user(other_user)
+ [n3, n2, n1] = Notification.for_user(other_user)
assert n1.seen == true
assert n2.seen == true
alias Pleroma.Plugs.UserIsAdminPlug
import Pleroma.Factory
- test "accepts a user that is admin", %{conn: conn} do
+ test "accepts a user that is admin" do
user = insert(:user, info: %{is_admin: true})
conn =
assert conn == ret_conn
end
- test "denies a user that isn't admin", %{conn: conn} do
+ test "denies a user that isn't admin" do
user = insert(:user)
conn =
assert conn.status == 403
end
- test "denies when a user isn't set", %{conn: conn} do
+ test "denies when a user isn't set" do
conn =
build_conn()
|> UserIsAdminPlug.call(%{})
quote do
# Import conveniences for testing with connections
use Phoenix.ConnTest
+ use Pleroma.Tests.Helpers
import Pleroma.Web.Router.Helpers
# The default endpoint for testing
import Ecto.Changeset
import Ecto.Query
import Pleroma.DataCase
+ use Pleroma.Tests.Helpers
end
end
--- /dev/null
+defmodule Pleroma.Tests.Helpers do
+ @moduledoc """
+ Helpers for use in tests.
+ """
+
+ defmacro __using__(_opts) do
+ quote do
+ def refresh_record(%{id: id, __struct__: model} = _),
+ do: refresh_record(model, %{id: id})
+
+ def refresh_record(model, %{id: id} = _) do
+ Pleroma.Repo.get_by(model, id: id)
+ end
+
+ # Used for comparing json rendering during tests.
+ def render_json(view, template, assigns) do
+ assigns = Map.new(assigns)
+
+ view.render(template, assigns)
+ |> Poison.encode!()
+ |> Poison.decode!()
+ end
+ end
+ end
+end
defmodule Pleroma.UserTest do
alias Pleroma.Builders.UserBuilder
alias Pleroma.{User, Repo, Activity}
- alias Pleroma.Web.OStatus
- alias Pleroma.Web.Websub.WebsubClientSubscription
alias Pleroma.Web.CommonAPI
use Pleroma.DataCase
import Pleroma.Factory
- import Ecto.Query
setup_all do
Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
end
end
+ describe "get_or_fetch/1" do
+ test "gets an existing user by nickname" do
+ user = insert(:user)
+ fetched_user = User.get_or_fetch(user.nickname)
+
+ assert user == fetched_user
+ end
+
+ test "gets an existing user by ap_id" do
+ ap_id = "http://mastodon.example.org/users/admin"
+
+ user =
+ insert(
+ :user,
+ local: false,
+ nickname: "admin@mastodon.example.org",
+ ap_id: ap_id,
+ info: %{}
+ )
+
+ fetched_user = User.get_or_fetch(ap_id)
+ freshed_user = refresh_record(user)
+ assert freshed_user == fetched_user
+ end
+ end
+
describe "fetching a user from nickname or trying to build one" do
test "gets an existing user" do
user = insert(:user)
describe "caching" do
test "invalidate_cache works" do
user = insert(:user)
- user_info = User.get_cached_user_info(user)
+ _user_info = User.get_cached_user_info(user)
User.invalidate_cache(user)
describe "User.search" do
test "finds a user, ranking by similarity" do
- user = insert(:user, %{name: "lain"})
- user_two = insert(:user, %{name: "ean"})
- user_three = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
+ _user = insert(:user, %{name: "lain"})
+ _user_two = insert(:user, %{name: "ean"})
+ _user_three = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
user_four = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})
assert user_four ==
test "with the relay disabled, it returns 404", %{conn: conn} do
Pleroma.Config.put([:instance, :allow_relay], false)
- res =
- conn
- |> get(activity_pub_path(conn, :relay))
- |> json_response(404)
+ conn
+ |> get(activity_pub_path(conn, :relay))
+ |> json_response(404)
+ |> assert
Pleroma.Config.put([:instance, :allow_relay], true)
end
test "doesn't retrieve unlisted activities" do
user = insert(:user)
- {:ok, unlisted_activity} =
+ {:ok, _unlisted_activity} =
CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
{:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})
end
test "users cannot be collided through fake direction spoofing attempts" do
- user =
- insert(:user, %{
- nickname: "rye@niu.moe",
- local: false,
- ap_id: "https://niu.moe/users/rye",
- follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
- })
+ insert(:user, %{
+ nickname: "rye@niu.moe",
+ local: false,
+ ap_id: "https://niu.moe/users/rye",
+ follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
+ })
{:error, _} = User.get_or_fetch_by_ap_id("https://n1u.moe/users/rye")
end
use Pleroma.Web.ConnCase
alias Pleroma.{Repo, User}
-
import Pleroma.Factory
- import ExUnit.CaptureLog
describe "/api/pleroma/admin/user" do
test "Delete" do
:ok
end
- @private_key hd(:public_key.pem_decode(File.read!("test/web/http_sigs/priv.key")))
- |> :public_key.pem_entry_decode()
-
@public_key hd(:public_key.pem_decode(File.read!("test/web/http_sigs/pub.key")))
|> :public_key.pem_entry_decode()
"content-length" => "18"
}
- @body "{\"hello\": \"world\"}"
-
@default_signature """
keyId="Test",algorithm="rsa-sha256",signature="jKyvPcxB4JbmYY4mByyBY7cZfNl4OW9HpFQlG7N4YcJPteKTu4MWCLyk+gIr0wDgqtLWf9NLpMAMimdfsH7FSWGfbMFSrsVTHNTk0rK3usrfFnti1dxsM4jl0kYJCKTGI/UWkqiaxwNiKqGcdlEDrTcUhhsFsOIo8VhddmZTZ8w="
"""
use Pleroma.DataCase
import Pleroma.Factory
alias Pleroma.Web.MastodonAPI.ListView
- alias Pleroma.List
test "Represent a list" do
user = insert(:user)
alias Pleroma.{Repo, User, Object, Activity, Notification}
alias Pleroma.Web.{OStatus, CommonAPI}
alias Pleroma.Web.ActivityPub.ActivityPub
-
+ alias Pleroma.Web.MastodonAPI.FilterView
import Pleroma.Factory
import ExUnit.CaptureLog
import Tesla.Mock
{:ok, filter_one} = Pleroma.Filter.create(query_one)
{:ok, filter_two} = Pleroma.Filter.create(query_two)
- conn =
+ response =
conn
|> assign(:user, user)
|> get("/api/v1/filters")
-
- assert response = json_response(conn, 200)
+ |> json_response(200)
+
+ assert response ==
+ render_json(
+ FilterView,
+ "filters.json",
+ filters: [filter_two, filter_one]
+ )
end
test "get a filter", %{conn: conn} do
context: ["home"]
}
- {:ok, filter} = Pleroma.Filter.create(query)
+ {:ok, _filter} = Pleroma.Filter.create(query)
new = %Pleroma.Filter{
phrase: "nii",
other_user = insert(:user)
{:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
- {:ok, activity_two} =
+ {:ok, _activity_two} =
TwitterAPI.create_status(other_user, %{
"status" => "Marisa is cute.",
"visibility" => "private"
user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
other_user = insert(:user)
- {:ok, activity} = ActivityPub.follow(other_user, user)
+ {:ok, _activity} = ActivityPub.follow(other_user, user)
user = Repo.get(User, user.id)
other_user = Repo.get(User, other_user.id)
user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
other_user = insert(:user)
- {:ok, activity} = ActivityPub.follow(other_user, user)
+ {:ok, _activity} = ActivityPub.follow(other_user, user)
user = Repo.get(User, user.id)
other_user = Repo.get(User, other_user.id)
user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
other_user = insert(:user)
- {:ok, activity} = ActivityPub.follow(other_user, user)
+ {:ok, _activity} = ActivityPub.follow(other_user, user)
conn =
build_conn()
test "getting followers, hide_network", %{conn: conn} do
user = insert(:user)
other_user = insert(:user, %{info: %{hide_network: true}})
- {:ok, user} = User.follow(user, other_user)
+ {:ok, _user} = User.follow(user, other_user)
conn =
conn
test "getting followers, hide_network, same user requesting", %{conn: conn} do
user = insert(:user)
other_user = insert(:user, %{info: %{hide_network: true}})
- {:ok, user} = User.follow(user, other_user)
+ {:ok, _user} = User.follow(user, other_user)
conn =
conn
defmodule Pleroma.Web.MastodonApi.MastodonSocketTest do
use Pleroma.DataCase
- alias Pleroma.Web.MastodonApi.MastodonSocket
alias Pleroma.Web.{Streamer, CommonAPI}
- alias Pleroma.User
import Pleroma.Factory
{:ok, auth} = Authorization.create_authorization(app, user)
{:ok, auth} = Authorization.use_token(auth)
- {auths, _} = Authorization.delete_user_authorizations(user)
+ Authorization.delete_user_authorizations(user)
{_, invalid} = Authorization.use_token(auth)
{:ok, auth1} = Authorization.create_authorization(app1, user)
{:ok, auth2} = Authorization.create_authorization(app2, user)
- {:ok, token1} = Token.exchange_token(app1, auth1)
- {:ok, token2} = Token.exchange_token(app2, auth2)
+ {:ok, _token1} = Token.exchange_token(app1, auth1)
+ {:ok, _token2} = Token.exchange_token(app2, auth2)
{tokens, _} = Token.delete_user_tokens(user)
"RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwrong1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"
})
- cng =
- Ecto.Changeset.change(salmon_user)
- |> Ecto.Changeset.put_embed(:info, info_cng)
- |> Repo.update()
+ salmon_user
+ |> Ecto.Changeset.change()
+ |> Ecto.Changeset.put_embed(:info, info_cng)
+ |> Repo.update()
conn =
build_conn()
test "404s on private objects", %{conn: conn} do
note_activity = insert(:direct_note_activity)
- user = User.get_by_ap_id(note_activity.data["actor"])
[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["object"]["id"]))
- url = "/objects/#{uuid}"
-
- conn =
- conn
- |> get(url)
- assert response(conn, 404)
+ conn
+ |> get("/objects/#{uuid}")
+ |> response(404)
end
test "404s on nonexisting objects", %{conn: conn} do
- url = "/objects/123"
-
- conn =
- conn
- |> get(url)
-
- assert response(conn, 404)
+ conn
+ |> get("/objects/123")
+ |> response(404)
end
test "gets an activity", %{conn: conn} do
note_activity = insert(:note_activity)
[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))
- url = "/activities/#{uuid}"
- conn =
- conn
- |> get(url)
-
- assert response(conn, 200)
+ conn
+ |> get("/activities/#{uuid}")
+ |> response(200)
end
test "404s on private activities", %{conn: conn} do
note_activity = insert(:direct_note_activity)
[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))
- url = "/activities/#{uuid}"
-
- conn =
- conn
- |> get(url)
- assert response(conn, 404)
+ conn
+ |> get("/activities/#{uuid}")
+ |> response(404)
end
test "404s on nonexistent activities", %{conn: conn} do
- url = "/activities/123"
-
- conn =
- conn
- |> get(url)
-
- assert response(conn, 404)
+ conn
+ |> get("/activities/123")
+ |> response(404)
end
test "gets a notice", %{conn: conn} do
note_activity = insert(:note_activity)
- url = "/notice/#{note_activity.id}"
-
- conn =
- conn
- |> get(url)
- assert response(conn, 200)
+ conn
+ |> get("/notice/#{note_activity.id}")
+ |> response(200)
end
test "gets a notice in AS2 format", %{conn: conn} do
note_activity = insert(:note_activity)
- url = "/notice/#{note_activity.id}"
- conn =
- conn
- |> put_req_header("accept", "application/activity+json")
- |> get(url)
-
- assert json_response(conn, 200)
+ conn
+ |> put_req_header("accept", "application/activity+json")
+ |> get("/notice/#{note_activity.id}")
+ |> json_response(200)
end
test "only gets a notice in AS2 format for Create messages", %{conn: conn} do
|> Map.put("type", "Article")
cs = Object.change(note_object, %{data: note_data})
- {:ok, article_object} = Repo.update(cs)
+ {:ok, _article_object} = Repo.update(cs)
# the underlying object is now an Article instead of a note, so this should fail
refute OStatus.is_representable?(note_activity)
end
end
-defmodule Pleroma.ActivityTest do
+defmodule Pleroma.Web.Federator.RetryQueueTest do
use Pleroma.DataCase
alias Pleroma.Web.Federator.RetryQueue
alias Pleroma.Web.Salmon
alias Pleroma.{Repo, Activity, User}
import Pleroma.Factory
- import Tesla.Mock
@magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"
@magickey_friendica "RSA.AMwa8FUs2fWEjX0xN7yRQgegQffhBpuKNC6fa5VNSVorFjGZhRrlPMn7TQOeihlc9lBz2OsHlIedbYn2uJ7yCs0.AQAB"
- setup do
- mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
+ setup_all do
+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
:ok
end
test "it pushes an activity to remote accounts it's addressed to" do
user_data = %{
info: %{
- "salmon" => "http://example.org/salmon"
+ salmon: "http://test-example.org/salmon"
},
local: false
}
user = Repo.get_by(User, ap_id: activity.data["actor"])
{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
- poster = fn url, _data, _headers, _options ->
- assert url == "http://example.org/salmon"
+ poster = fn url, _data, _headers ->
+ assert url == "http://test-example.org/salmon"
end
Salmon.publish(user, activity, poster)
alias Pleroma.{User, Activity, Object}
alias Pleroma.Web.TwitterAPI.Representers.{ActivityRepresenter, ObjectRepresenter}
alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Builders.UserBuilder
alias Pleroma.Web.TwitterAPI.UserView
import Pleroma.Factory
import Pleroma.Factory
+ @banner "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
+
describe "POST /api/account/update_profile_banner" do
test "it updates the banner", %{conn: conn} do
user = insert(:user)
- new_banner =
- "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
-
- response =
- conn
- |> assign(:user, user)
- |> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => new_banner})
- |> json_response(200)
+ conn
+ |> assign(:user, user)
+ |> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => @banner})
+ |> json_response(200)
- user = Repo.get(User, user.id)
+ user = refresh_record(user)
assert user.info.banner["type"] == "Image"
end
end
test "it updates the background", %{conn: conn} do
user = insert(:user)
- new_bg =
- "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
-
- response =
- conn
- |> assign(:user, user)
- |> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => new_bg})
- |> json_response(200)
+ conn
+ |> assign(:user, user)
+ |> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => @banner})
+ |> json_response(200)
- user = Repo.get(User, user.id)
+ user = refresh_record(user)
assert user.info.background["type"] == "Image"
end
end
end
test "with credentials", %{conn: conn, user: user} do
- conn =
+ response =
conn
|> with_credentials(user.nickname, "test")
|> post("/api/account/verify_credentials.json")
+ |> json_response(200)
- assert response = json_response(conn, 200)
assert response == UserView.render("show.json", %{user: user, token: response["token"]})
end
end
"error" => "Client must provide a 'status' parameter with a value."
}
- conn = conn_with_creds |> post(request_path)
+ conn =
+ conn_with_creds
+ |> post(request_path)
+
assert json_response(conn, 400) == error_response
- conn = conn_with_creds |> post(request_path, %{status: ""})
+ conn =
+ conn_with_creds
+ |> post(request_path, %{status: ""})
+
assert json_response(conn, 400) == error_response
- conn = conn_with_creds |> post(request_path, %{status: " "})
+ conn =
+ conn_with_creds
+ |> post(request_path, %{status: " "})
+
assert json_response(conn, 400) == error_response
# we post with visibility private in order to avoid triggering relay
- conn = conn_with_creds |> post(request_path, %{status: "Nice meme.", visibility: "private"})
+ conn =
+ conn_with_creds
+ |> post(request_path, %{status: "Nice meme.", visibility: "private"})
assert json_response(conn, 200) ==
ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
assert length(response) == 10
end
- test "returns 403 to unauthenticated request when the instance is not public" do
+ test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
instance =
Application.get_env(:pleroma, :instance)
|> Keyword.put(:public, false)
Application.put_env(:pleroma, :instance, instance)
end
- test "returns 200 to unauthenticated request when the instance is public" do
+ test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
conn
|> get("/api/statuses/public_timeline.json")
|> json_response(200)
end
describe "GET /statuses/public_and_external_timeline.json" do
- test "returns 403 to unauthenticated request when the instance is not public" do
+ test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
instance =
Application.get_env(:pleroma, :instance)
|> Keyword.put(:public, false)
Application.put_env(:pleroma, :instance, instance)
end
- test "returns 200 to unauthenticated request when the instance is public" do
+ test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
conn
|> get("/api/statuses/public_and_external_timeline.json")
|> json_response(200)
end
test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
- conn =
+ response =
conn
|> with_credentials(current_user.nickname, "test")
|> get("/api/qvitter/mutes.json")
+ |> json_response(200)
- current_user = Repo.get(User, current_user.id)
-
- assert [] = json_response(conn, 200)
+ assert [] = response
end
end
follower_two = insert(:user)
not_follower = insert(:user)
- {:ok, follower_one} = User.follow(follower_one, user)
- {:ok, follower_two} = User.follow(follower_two, user)
+ {:ok, _follower_one} = User.follow(follower_one, user)
+ {:ok, _follower_two} = User.follow(follower_two, user)
- conn =
+ response =
conn
|> assign(:user, not_follower)
|> get("/api/statuses/followers", %{"user_id" => user.id})
+ |> json_response(200)
- assert [] == json_response(conn, 200)
+ assert [] == response
end
test "it returns the followers for a hidden network if requested by the user themselves", %{
user = insert(:user, %{info: %{hide_network: true}})
follower_one = insert(:user)
follower_two = insert(:user)
- not_follower = insert(:user)
+ _not_follower = insert(:user)
- {:ok, follower_one} = User.follow(follower_one, user)
- {:ok, follower_two} = User.follow(follower_two, user)
+ {:ok, _follower_one} = User.follow(follower_one, user)
+ {:ok, _follower_two} = User.follow(follower_two, user)
conn =
conn
user = insert(:user, %{info: %{hide_network: true}})
followed_one = insert(:user)
followed_two = insert(:user)
- not_followed = insert(:user)
+ _not_followed = insert(:user)
- {:ok, user} = User.follow(user, followed_one)
- {:ok, user} = User.follow(user, followed_two)
+ {:ok, _user} = User.follow(user, followed_one)
+ {:ok, _user} = User.follow(user, followed_two)
- conn =
+ response =
conn
|> assign(:user, user)
|> get("/api/statuses/friends", %{"user_id" => user.id})
+ |> json_response(200)
- refute [] == json_response(conn, 200)
+ refute [] == response
end
test "it returns a given user's friends with screen_name", %{conn: conn} do
defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
use Pleroma.DataCase
- alias Pleroma.Builders.UserBuilder
alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView}
alias Pleroma.{Activity, User, Object, Repo, UserInviteToken}
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.TwitterAPI.ActivityView
alias Pleroma.Web.CommonAPI.Utils
alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Builders.UserBuilder
import Pleroma.Factory
user = User.get_cached_by_ap_id(note_activity.data["actor"])
repeater = insert(:user)
- {:ok, activity} = TwitterAPI.repeat(repeater, note_activity.id)
+ {:ok, _activity} = TwitterAPI.repeat(repeater, note_activity.id)
[notification] = Notification.for_user(user)
represented = %{
user = User.get_cached_by_ap_id(note_activity.data["actor"])
liker = insert(:user)
- {:ok, activity} = TwitterAPI.fav(liker, note_activity.id)
+ {:ok, _activity} = TwitterAPI.fav(liker, note_activity.id)
[notification] = Notification.for_user(user)
represented = %{
alias Pleroma.User
alias Pleroma.Web.TwitterAPI.UserView
alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Builders.UserBuilder
import Pleroma.Factory
assert represented["profile_image_url"] == image
end
- test "A user with emoji in username", %{user: user} do
+ test "A user with emoji in username" do
expected =
"<img height=\"32px\" width=\"32px\" alt=\"karjalanpiirakka\" title=\"karjalanpiirakka\" src=\"/file.png\" /> man"
projects / akkoma / commitdiff