summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/media_proxy_test.exs113
-rw-r--r--test/plugs/user_is_admin_plug_test.exs39
-rw-r--r--test/web/admin_api/admin_api_controller_test.exs112
-rw-r--r--test/web/mastodon_api/mastodon_socket_test.exs33
-rw-r--r--test/web/retry_queue_test.exs31
-rw-r--r--test/web/streamer_test.exs109
6 files changed, 436 insertions, 1 deletions
diff --git a/test/media_proxy_test.exs b/test/media_proxy_test.exs
new file mode 100644
index 000000000..c69ed7ea4
--- /dev/null
+++ b/test/media_proxy_test.exs
@@ -0,0 +1,113 @@
+defmodule Pleroma.MediaProxyTest do
+ use ExUnit.Case
+ import Pleroma.Web.MediaProxy
+
+ describe "when enabled" do
+ setup do
+ enabled = Pleroma.Config.get([:media_proxy, :enabled])
+
+ unless enabled do
+ Pleroma.Config.put([:media_proxy, :enabled], true)
+ on_exit(fn -> Pleroma.Config.put([:media_proxy, :enabled], enabled) end)
+ end
+
+ :ok
+ end
+
+ test "ignores invalid url" do
+ assert url(nil) == nil
+ assert url("") == nil
+ end
+
+ test "ignores relative url" do
+ assert url("/local") == "/local"
+ assert url("/") == "/"
+ end
+
+ test "ignores local url" do
+ local_url = Pleroma.Web.Endpoint.url() <> "/hello"
+ local_root = Pleroma.Web.Endpoint.url()
+ assert url(local_url) == local_url
+ assert url(local_root) == local_root
+ end
+
+ test "encodes and decodes URL" do
+ url = "https://pleroma.soykaf.com/static/logo.png"
+ encoded = url(url)
+
+ assert String.starts_with?(
+ encoded,
+ Pleroma.Config.get([:media_proxy, :base_url], Pleroma.Web.base_url())
+ )
+
+ assert String.ends_with?(encoded, "/logo.png")
+
+ assert decode_result(encoded) == url
+ end
+
+ test "encodes and decodes URL without a path" do
+ url = "https://pleroma.soykaf.com"
+ encoded = url(url)
+ assert decode_result(encoded) == url
+ end
+
+ test "encodes and decodes URL without an extension" do
+ url = "https://pleroma.soykaf.com/path/"
+ encoded = url(url)
+ assert String.ends_with?(encoded, "/path")
+ assert decode_result(encoded) == url
+ end
+
+ test "encodes and decodes URL and ignores query params for the path" do
+ url = "https://pleroma.soykaf.com/static/logo.png?93939393939&bunny=true"
+ encoded = url(url)
+ assert String.ends_with?(encoded, "/logo.png")
+ assert decode_result(encoded) == url
+ end
+
+ test "validates signature" do
+ secret_key_base = Pleroma.Config.get([Pleroma.Web.Endpoint, :secret_key_base])
+
+ on_exit(fn ->
+ Pleroma.Config.put([Pleroma.Web.Endpoint, :secret_key_base], secret_key_base)
+ end)
+
+ encoded = url("https://pleroma.social")
+
+ Pleroma.Config.put(
+ [Pleroma.Web.Endpoint, :secret_key_base],
+ "00000000000000000000000000000000000000000000000"
+ )
+
+ [_, "proxy", sig, base64 | _] = URI.parse(encoded).path |> String.split("/")
+ assert decode_url(sig, base64) == {:error, :invalid_signature}
+ end
+ end
+
+ describe "when disabled" do
+ setup do
+ enabled = Pleroma.Config.get([:media_proxy, :enabled])
+
+ if enabled do
+ Pleroma.Config.put([:media_proxy, :enabled], false)
+
+ on_exit(fn ->
+ Pleroma.Config.put([:media_proxy, :enabled], enabled)
+ :ok
+ end)
+ end
+
+ :ok
+ end
+
+ test "does not encode remote urls" do
+ assert url("https://google.fr") == "https://google.fr"
+ end
+ end
+
+ defp decode_result(encoded) do
+ [_, "proxy", sig, base64 | _] = URI.parse(encoded).path |> String.split("/")
+ {:ok, decoded} = decode_url(sig, base64)
+ decoded
+ end
+end
diff --git a/test/plugs/user_is_admin_plug_test.exs b/test/plugs/user_is_admin_plug_test.exs
new file mode 100644
index 000000000..ddf9eb139
--- /dev/null
+++ b/test/plugs/user_is_admin_plug_test.exs
@@ -0,0 +1,39 @@
+defmodule Pleroma.Plugs.UserIsAdminPlugTest do
+ use Pleroma.Web.ConnCase, async: true
+
+ alias Pleroma.Plugs.UserIsAdminPlug
+ import Pleroma.Factory
+
+ test "accepts a user that is admin", %{conn: conn} do
+ user = insert(:user, info: %{"is_admin" => true})
+
+ conn =
+ build_conn()
+ |> assign(:user, user)
+
+ ret_conn =
+ conn
+ |> UserIsAdminPlug.call(%{})
+
+ assert conn == ret_conn
+ end
+
+ test "denies a user that isn't admin", %{conn: conn} do
+ user = insert(:user)
+
+ conn =
+ build_conn()
+ |> assign(:user, user)
+ |> UserIsAdminPlug.call(%{})
+
+ assert conn.status == 403
+ end
+
+ test "denies when a user isn't set", %{conn: conn} do
+ conn =
+ build_conn()
+ |> UserIsAdminPlug.call(%{})
+
+ assert conn.status == 403
+ end
+end
diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/admin_api_controller_test.exs
new file mode 100644
index 000000000..fa0cb71bf
--- /dev/null
+++ b/test/web/admin_api/admin_api_controller_test.exs
@@ -0,0 +1,112 @@
+defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
+ use Pleroma.Web.ConnCase
+
+ alias Pleroma.{Repo, User}
+
+ import Pleroma.Factory
+ import ExUnit.CaptureLog
+
+ describe "/api/pleroma/admin/user" do
+ test "Delete" do
+ admin = insert(:user, info: %{"is_admin" => true})
+ user = insert(:user)
+
+ conn =
+ build_conn()
+ |> assign(:user, admin)
+ |> put_req_header("accept", "application/json")
+ |> delete("/api/pleroma/admin/user?nickname=#{user.nickname}")
+
+ assert json_response(conn, 200) == user.nickname
+ end
+
+ test "Create" do
+ admin = insert(:user, info: %{"is_admin" => true})
+
+ conn =
+ build_conn()
+ |> assign(:user, admin)
+ |> put_req_header("accept", "application/json")
+ |> post("/api/pleroma/admin/user", %{
+ "nickname" => "lain",
+ "email" => "lain@example.org",
+ "password" => "test"
+ })
+
+ assert json_response(conn, 200) == "lain"
+ end
+ end
+
+ describe "/api/pleroma/admin/permission_group" do
+ test "GET is giving user_info" do
+ admin = insert(:user, info: %{"is_admin" => true})
+
+ conn =
+ build_conn()
+ |> assign(:user, admin)
+ |> put_req_header("accept", "application/json")
+ |> get("/api/pleroma/admin/permission_group/#{admin.nickname}")
+
+ assert json_response(conn, 200) == admin.info
+ end
+
+ test "/:right POST, can add to a permission group" do
+ admin = insert(:user, info: %{"is_admin" => true})
+ user = insert(:user)
+
+ user_info =
+ user.info
+ |> Map.put("is_admin", true)
+
+ conn =
+ build_conn()
+ |> assign(:user, admin)
+ |> put_req_header("accept", "application/json")
+ |> post("/api/pleroma/admin/permission_group/#{user.nickname}/admin")
+
+ assert json_response(conn, 200) == user_info
+ end
+
+ test "/:right DELETE, can remove from a permission group" do
+ admin = insert(:user, info: %{"is_admin" => true})
+ user = insert(:user, info: %{"is_admin" => true})
+
+ user_info =
+ user.info
+ |> Map.put("is_admin", false)
+
+ conn =
+ build_conn()
+ |> assign(:user, admin)
+ |> put_req_header("accept", "application/json")
+ |> delete("/api/pleroma/admin/permission_group/#{user.nickname}/admin")
+
+ assert json_response(conn, 200) == user_info
+ end
+ end
+
+ test "/api/pleroma/admin/invite_token" do
+ admin = insert(:user, info: %{"is_admin" => true})
+
+ conn =
+ build_conn()
+ |> assign(:user, admin)
+ |> put_req_header("accept", "application/json")
+ |> get("/api/pleroma/admin/invite_token")
+
+ assert conn.status == 200
+ end
+
+ test "/api/pleroma/admin/password_reset" do
+ admin = insert(:user, info: %{"is_admin" => true})
+ user = insert(:user, info: %{"is_admin" => true})
+
+ conn =
+ build_conn()
+ |> assign(:user, admin)
+ |> put_req_header("accept", "application/json")
+ |> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")
+
+ assert conn.status == 200
+ end
+end
diff --git a/test/web/mastodon_api/mastodon_socket_test.exs b/test/web/mastodon_api/mastodon_socket_test.exs
new file mode 100644
index 000000000..c7d71defc
--- /dev/null
+++ b/test/web/mastodon_api/mastodon_socket_test.exs
@@ -0,0 +1,33 @@
+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
+
+ test "public is working when non-authenticated" do
+ user = insert(:user)
+
+ task =
+ Task.async(fn ->
+ assert_receive {:text, _}, 4_000
+ end)
+
+ fake_socket = %{
+ transport_pid: task.pid,
+ assigns: %{}
+ }
+
+ topics = %{
+ "public" => [fake_socket]
+ }
+
+ {:ok, activity} = CommonAPI.post(user, %{"status" => "Test"})
+
+ Streamer.push_to_socket(topics, "public", activity)
+
+ Task.await(task)
+ end
+end
diff --git a/test/web/retry_queue_test.exs b/test/web/retry_queue_test.exs
new file mode 100644
index 000000000..ce2964993
--- /dev/null
+++ b/test/web/retry_queue_test.exs
@@ -0,0 +1,31 @@
+defmodule MockActivityPub do
+ def publish_one(ret) do
+ {ret, "success"}
+ end
+end
+
+defmodule Pleroma.ActivityTest do
+ use Pleroma.DataCase
+ alias Pleroma.Web.Federator.RetryQueue
+
+ @small_retry_count 0
+ @hopeless_retry_count 10
+
+ test "failed posts are retried" do
+ {:retry, _timeout} = RetryQueue.get_retry_params(@small_retry_count)
+
+ assert {:noreply, %{delivered: 1}} ==
+ RetryQueue.handle_info({:send, :ok, MockActivityPub, @small_retry_count}, %{
+ delivered: 0
+ })
+ end
+
+ test "posts that have been tried too many times are dropped" do
+ {:drop, _timeout} = RetryQueue.get_retry_params(@hopeless_retry_count)
+
+ assert {:noreply, %{dropped: 1}} ==
+ RetryQueue.handle_cast({:maybe_enqueue, %{}, nil, @hopeless_retry_count}, %{
+ dropped: 0
+ })
+ end
+end
diff --git a/test/web/streamer_test.exs b/test/web/streamer_test.exs
index 47d491d1b..df58441f0 100644
--- a/test/web/streamer_test.exs
+++ b/test/web/streamer_test.exs
@@ -2,7 +2,7 @@ defmodule Pleroma.Web.StreamerTest do
use Pleroma.DataCase
alias Pleroma.Web.Streamer
- alias Pleroma.User
+ alias Pleroma.{List, User}
alias Pleroma.Web.CommonAPI
import Pleroma.Factory
@@ -60,4 +60,111 @@ defmodule Pleroma.Web.StreamerTest do
Task.await(task)
end
+
+ test "it doesn't send unwanted DMs to list" do
+ user_a = insert(:user)
+ user_b = insert(:user)
+ user_c = insert(:user)
+
+ {:ok, user_a} = User.follow(user_a, user_b)
+
+ {:ok, list} = List.create("Test", user_a)
+ {:ok, list} = List.follow(list, user_b)
+
+ task =
+ Task.async(fn ->
+ refute_receive {:text, _}, 1_000
+ end)
+
+ fake_socket = %{
+ transport_pid: task.pid,
+ assigns: %{
+ user: user_a
+ }
+ }
+
+ {:ok, activity} =
+ CommonAPI.post(user_b, %{
+ "status" => "@#{user_c.nickname} Test",
+ "visibility" => "direct"
+ })
+
+ topics = %{
+ "list:#{list.id}" => [fake_socket]
+ }
+
+ Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
+
+ Task.await(task)
+ end
+
+ test "it doesn't send unwanted private posts to list" do
+ user_a = insert(:user)
+ user_b = insert(:user)
+
+ {:ok, list} = List.create("Test", user_a)
+ {:ok, list} = List.follow(list, user_b)
+
+ task =
+ Task.async(fn ->
+ refute_receive {:text, _}, 1_000
+ end)
+
+ fake_socket = %{
+ transport_pid: task.pid,
+ assigns: %{
+ user: user_a
+ }
+ }
+
+ {:ok, activity} =
+ CommonAPI.post(user_b, %{
+ "status" => "Test",
+ "visibility" => "private"
+ })
+
+ topics = %{
+ "list:#{list.id}" => [fake_socket]
+ }
+
+ Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
+
+ Task.await(task)
+ end
+
+ test "it send wanted private posts to list" do
+ user_a = insert(:user)
+ user_b = insert(:user)
+
+ {:ok, user_a} = User.follow(user_a, user_b)
+
+ {:ok, list} = List.create("Test", user_a)
+ {:ok, list} = List.follow(list, user_b)
+
+ task =
+ Task.async(fn ->
+ assert_receive {:text, _}, 1_000
+ end)
+
+ fake_socket = %{
+ transport_pid: task.pid,
+ assigns: %{
+ user: user_a
+ }
+ }
+
+ {:ok, activity} =
+ CommonAPI.post(user_b, %{
+ "status" => "Test",
+ "visibility" => "private"
+ })
+
+ topics = %{
+ "list:#{list.id}" => [fake_socket]
+ }
+
+ Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
+
+ Task.await(task)
+ end
end
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-29 08:40:30 +0000