No OneTemporary
Actions

Authored By

Unknown

Size

28 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/pleroma/activity_test.exs b/test/pleroma/activity_test.exs
	index e38384c9c..67943d879 100644
	--- a/test/pleroma/activity_test.exs
	+++ b/test/pleroma/activity_test.exs
	@@ -1,355 +1,356 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ActivityTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.ThreadMute
	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "returns an activity by it's AP id" do
	activity = insert(:note_activity)
	found_activity = Activity.get_by_ap_id(activity.data["id"])

	assert activity == found_activity
	end

	test "returns activities by it's objects AP ids" do
	activity = insert(:note_activity)
	object_data = Object.normalize(activity, fetch: false).data

	[found_activity] = Activity.get_all_create_by_object_ap_id(object_data["id"])

	assert activity == found_activity
	end

	test "returns the activity that created an object" do
	activity = insert(:note_activity)
	object_data = Object.normalize(activity, fetch: false).data

	found_activity = Activity.get_create_by_object_ap_id(object_data["id"])

	assert activity == found_activity
	end

	test "preloading a bookmark" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	activity = insert(:note_activity)
	{:ok, _bookmark} = Bookmark.create(user.id, activity.id)
	{:ok, _bookmark2} = Bookmark.create(user2.id, activity.id)
	{:ok, bookmark3} = Bookmark.create(user3.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Activity.with_preloaded_bookmark(user3)
	\|> Repo.one()

	assert queried_activity.bookmark == bookmark3
	end

	test "setting thread_muted?" do
	activity = insert(:note_activity)
	user = insert(:user)
	annoyed_user = insert(:user)
	{:ok, _} = ThreadMute.add_mute(annoyed_user.id, activity.data["context"])

	activity_with_unset_thread_muted_field =
	Ecto.Query.from(Activity)
	\|> Repo.one()

	activity_for_user =
	Ecto.Query.from(Activity)
	\|> Activity.with_set_thread_muted_field(user)
	\|> Repo.one()

	activity_for_annoyed_user =
	Ecto.Query.from(Activity)
	\|> Activity.with_set_thread_muted_field(annoyed_user)
	\|> Repo.one()

	assert activity_with_unset_thread_muted_field.thread_muted? == nil
	assert activity_for_user.thread_muted? == false
	assert activity_for_annoyed_user.thread_muted? == true
	end

	describe "getting a bookmark" do
	test "when association is loaded" do
	user = insert(:user)
	activity = insert(:note_activity)
	{:ok, bookmark} = Bookmark.create(user.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Activity.with_preloaded_bookmark(user)
	\|> Repo.one()

	assert Activity.get_bookmark(queried_activity, user) == bookmark
	end

	test "when association is not loaded" do
	user = insert(:user)
	activity = insert(:note_activity)
	{:ok, bookmark} = Bookmark.create(user.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Repo.one()

	assert Activity.get_bookmark(queried_activity, user) == bookmark
	end
	end

	describe "search" do
	setup do
	user = insert(:user)

	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "http://mastodon.example.org/users/admin",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "find me!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	{:ok, local_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "find me!"})
	{:ok, japanese_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "更新情報"})
	{:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params)
	{:ok, remote_activity} = ObanHelpers.perform(job)
	remote_activity = Activity.get_by_id_with_object(remote_activity.id)

	%{
	japanese_activity: japanese_activity,
	local_activity: local_activity,
	remote_activity: remote_activity,
	user: user
	}
	end

	setup do: clear_config([:instance, :limit_to_local_content])

	+ @tag :skip_darwin
	test "finds utf8 text in statuses", %{
	japanese_activity: japanese_activity,
	user: user
	} do
	activities = Activity.search(user, "更新情報")

	assert [^japanese_activity] = activities
	end

	test "find local and remote statuses for authenticated users", %{
	local_activity: local_activity,
	remote_activity: remote_activity,
	user: user
	} do
	activities = Enum.sort_by(Activity.search(user, "find me"), & &1.id)

	assert [^local_activity, ^remote_activity] = activities
	end

	test "find only local statuses for unauthenticated users", %{local_activity: local_activity} do
	assert [^local_activity] = Activity.search(nil, "find me")
	end

	test "find only local statuses for unauthenticated users when `limit_to_local_content` is `:all`",
	%{local_activity: local_activity} do
	clear_config([:instance, :limit_to_local_content], :all)
	assert [^local_activity] = Activity.search(nil, "find me")
	end

	test "find all statuses for unauthenticated users when `limit_to_local_content` is `false`",
	%{
	local_activity: local_activity,
	remote_activity: remote_activity
	} do
	clear_config([:instance, :limit_to_local_content], false)

	activities = Enum.sort_by(Activity.search(nil, "find me"), & &1.id)

	assert [^local_activity, ^remote_activity] = activities
	end
	end

	test "all_by_ids_with_object/1" do
	%{id: id1} = insert(:note_activity)
	%{id: id2} = insert(:note_activity)

	activities =
	[id1, id2]
	\|> Activity.all_by_ids_with_object()
	\|> Enum.sort(&(&1.id < &2.id))

	assert [%{id: ^id1, object: %Object{}}, %{id: ^id2, object: %Object{}}] = activities
	end

	test "get_by_id_with_user_actor/1" do
	user = insert(:user)
	activity = insert(:note_activity, note: insert(:note, user: user))

	assert Activity.get_by_id_with_user_actor(activity.id).user_actor == user
	end

	test "get_by_id_with_object/1" do
	%{id: id} = insert(:note_activity)

	assert %Activity{id: ^id, object: %Object{}} = Activity.get_by_id_with_object(id)
	end

	test "get_by_ap_id_with_object/1" do
	%{data: %{"id" => ap_id}} = insert(:note_activity)

	assert %Activity{data: %{"id" => ^ap_id}, object: %Object{}} =
	Activity.get_by_ap_id_with_object(ap_id)
	end

	test "get_by_id/1" do
	%{id: id} = insert(:note_activity)

	assert %Activity{id: ^id} = Activity.get_by_id(id)
	end

	test "all_by_actor_and_id/2" do
	user = insert(:user)

	{:ok, %{id: id1}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
	{:ok, %{id: id2}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofefe"})

	assert [] == Activity.all_by_actor_and_id(user, [])

	activities =
	user.ap_id
	\|> Activity.all_by_actor_and_id([id1, id2])
	\|> Enum.sort(&(&1.id < &2.id))

	assert [%Activity{id: ^id1}, %Activity{id: ^id2}] = activities
	end

	test "get_by_object_ap_id_with_object/1" do
	user = insert(:user)
	another = insert(:user)

	{:ok, %{id: id, object: %{data: %{"id" => obj_id}}}} =
	Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})

	Pleroma.Web.CommonAPI.favorite(another, id)

	assert obj_id
	\|> Pleroma.Activity.Queries.by_object_id()
	\|> Repo.aggregate(:count, :id) == 2

	assert %{id: ^id} = Activity.get_by_object_ap_id_with_object(obj_id)
	end

	test "add_by_params_query/3" do
	user = insert(:user)

	note = insert(:note_activity, user: user)

	insert(:add_activity, user: user, note: note)
	insert(:add_activity, user: user, note: note)
	insert(:add_activity, user: user)

	assert Repo.aggregate(Activity, :count, :id) == 4

	add_query =
	Activity.add_by_params_query(note.data["object"], user.ap_id, user.featured_address)

	assert Repo.aggregate(add_query, :count, :id) == 2

	Repo.delete_all(add_query)
	assert Repo.aggregate(add_query, :count, :id) == 0

	assert Repo.aggregate(Activity, :count, :id) == 2
	end

	describe "associated_object_id() sql function" do
	test "with json object" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": {"id":"foobar"}}'::jsonb);
	"""
	)

	assert object_id == "foobar"
	end

	test "with string object" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": "foobar"}'::jsonb);
	"""
	)

	assert object_id == "foobar"
	end

	test "with array object" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": ["foobar", {}]}'::jsonb);
	"""
	)

	assert object_id == "foobar"
	end

	test "invalid" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": {}}'::jsonb);
	"""
	)

	assert is_nil(object_id)
	end

	test "invalid object id" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": {"id": 123}}'::jsonb);
	"""
	)

	assert is_nil(object_id)
	end

	test "no object field" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{}'::jsonb);
	"""
	)

	assert is_nil(object_id)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	index 3654c6b20..b05487abe 100644
	--- a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	@@ -1,459 +1,460 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock
	import Mock

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	:ok
	end

	setup_all do
	mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe ".search2" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v2/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

	+ @tag :skip_darwin
	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu #private"})}")
	\|> json_response_and_validate_schema(200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == [
	%{"name" => "private", "url" => "#{Endpoint.url()}/tag/private"}
	]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)

	results =
	get(conn, "/api/v2/search?q=天子")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "天子", "url" => "#{Endpoint.url()}/tag/天子"}
	]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search local-only status as an authenticated user" do
	user = insert(:user)
	%{conn: conn} = oauth_access(["read:search"])

	{:ok, activity} =
	CommonAPI.post(user, %{status: "This is about 2hu private 天子", visibility: "local"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search local-only status as an unauthenticated user" do
	user = insert(:user)
	%{conn: conn} = oauth_access([])

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "This is about 2hu private 天子", visibility: "local"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

	assert [] = results["statuses"]
	end

	test "search local-only status as an anonymous user" do
	user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "This is about 2hu private 天子", visibility: "local"})

	results =
	build_conn()
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

	assert [] = results["statuses"]
	end

	@tag capture_log: true
	test "constructs hashtags from search query", %{conn: conn} do
	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "some text with #explicit #hashtags"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "explicit", "url" => "#{Endpoint.url()}/tag/explicit"},
	%{"name" => "hashtags", "url" => "#{Endpoint.url()}/tag/hashtags"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "john doe JOHN DOE"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "john", "url" => "#{Endpoint.url()}/tag/john"},
	%{"name" => "doe", "url" => "#{Endpoint.url()}/tag/doe"},
	%{"name" => "JohnDoe", "url" => "#{Endpoint.url()}/tag/JohnDoe"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "accident-prone"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "accident", "url" => "#{Endpoint.url()}/tag/accident"},
	%{"name" => "prone", "url" => "#{Endpoint.url()}/tag/prone"},
	%{"name" => "AccidentProne", "url" => "#{Endpoint.url()}/tag/AccidentProne"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "https://shpposter.club/users/shpuld"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "shpuld", "url" => "#{Endpoint.url()}/tag/shpuld"}
	]

	results =
	conn
	\|> get(
	"/api/v2/search?#{URI.encode_query(%{q: "https://www.washingtonpost.com/sports/2020/06/10/" <> "nascar-ban-display-confederate-flag-all-events-properties/"})}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "nascar", "url" => "#{Endpoint.url()}/tag/nascar"},
	%{"name" => "ban", "url" => "#{Endpoint.url()}/tag/ban"},
	%{"name" => "display", "url" => "#{Endpoint.url()}/tag/display"},
	%{"name" => "confederate", "url" => "#{Endpoint.url()}/tag/confederate"},
	%{"name" => "flag", "url" => "#{Endpoint.url()}/tag/flag"},
	%{"name" => "all", "url" => "#{Endpoint.url()}/tag/all"},
	%{"name" => "events", "url" => "#{Endpoint.url()}/tag/events"},
	%{"name" => "properties", "url" => "#{Endpoint.url()}/tag/properties"},
	%{
	"name" => "NascarBanDisplayConfederateFlagAllEventsProperties",
	"url" =>
	"#{Endpoint.url()}/tag/NascarBanDisplayConfederateFlagAllEventsProperties"
	}
	]
	end

	test "supports pagination of hashtags search results", %{conn: conn} do
	results =
	conn
	\|> get(
	"/api/v2/search?#{URI.encode_query(%{q: "#some #text #with #hashtags", limit: 2, offset: 1})}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "text", "url" => "#{Endpoint.url()}/tag/text"},
	%{"name" => "with", "url" => "#{Endpoint.url()}/tag/with"}
	]
	end

	test "excludes a blocked users from search results", %{conn: conn} do
	user = insert(:user)
	user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
	user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})

	{:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
	{:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
	{:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
	Pleroma.User.block(user, user_smith)

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v2/search?q=Agent")
	\|> json_response_and_validate_schema(200)

	status_ids = Enum.map(results["statuses"], fn g -> g["id"] end)

	assert act3.id in status_ids
	refute act2.id in status_ids
	refute act1.id in status_ids
	end
	end

	describe ".account_search" do
	test "account search", %{conn: conn} do
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp")
	\|> json_response_and_validate_schema(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_two.nickname in result_ids
	assert user_three.nickname in result_ids

	results =
	conn
	\|> get("/api/v1/accounts/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_three.nickname in result_ids
	end

	test "returns account if query contains a space", %{conn: conn} do
	insert(:user, %{nickname: "shp@shitposter.club"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp@shitposter.club xxx")
	\|> json_response_and_validate_schema(200)

	assert length(results) == 1
	end
	end

	describe ".search" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v1/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})

	results =
	conn
	\|> get("/api/v1/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == ["2hu"]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search fetches remote statuses and prefers them over other results", %{conn: conn} do
	old_version = :persistent_term.get({Pleroma.Repo, :postgres_version})
	:persistent_term.put({Pleroma.Repo, :postgres_version}, 10.0)
	on_exit(fn -> :persistent_term.put({Pleroma.Repo, :postgres_version}, old_version) end)

	capture_log(fn ->
	{:ok, %{id: activity_id}} =
	CommonAPI.post(insert(:user), %{
	status: "check out http://mastodon.example.org/@admin/99541947525187367"
	})

	results =
	conn
	\|> get("/api/v1/search?q=http://mastodon.example.org/@admin/99541947525187367")
	\|> json_response_and_validate_schema(200)

	assert [
	%{"url" => "http://mastodon.example.org/@admin/99541947525187367"},
	%{"id" => ^activity_id}
	] = results["statuses"]
	end)
	end

	test "search doesn't show statuses that it shouldn't", %{conn: conn} do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	capture_log(fn ->
	q = Object.normalize(activity, fetch: false).data["id"]

	results =
	conn
	\|> get("/api/v1/search?q=#{q}")
	\|> json_response_and_validate_schema(200)

	[] = results["statuses"]
	end)
	end

	test "search fetches remote accounts", %{conn: conn} do
	user = insert(:user)

	query = URI.encode_query(%{q: " mike@osada.macgirvin.com ", resolve: true})

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v1/search?#{query}")
	\|> json_response_and_validate_schema(200)

	[account] = results["accounts"]
	assert account["acct"] == "mike@osada.macgirvin.com"
	end

	test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
	results =
	conn
	\|> get("/api/v1/search?q=mike@osada.macgirvin.com&resolve=false")
	\|> json_response_and_validate_schema(200)

	assert [] == results["accounts"]
	end

	test "search with limit and offset", %{conn: conn} do
	user = insert(:user)
	_user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	_user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, _activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
	{:ok, _activity2} = CommonAPI.post(user, %{status: "This is also about 2hu"})

	result =
	conn
	\|> get("/api/v1/search?q=2hu&limit=1")

	assert results = json_response_and_validate_schema(result, 200)
	assert [%{"id" => activity_id1}] = results["statuses"]
	assert [_] = results["accounts"]

	results =
	conn
	\|> get("/api/v1/search?q=2hu&limit=1&offset=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert [] = results["accounts"]

	assert activity_id1 != activity_id2
	end

	test "search returns results only for the given type", %{conn: conn} do
	user = insert(:user)
	_user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, _activity} = CommonAPI.post(user, %{status: "This is about 2hu"})

	assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
	conn
	\|> get("/api/v1/search?q=2hu&type=statuses")
	\|> json_response_and_validate_schema(200)

	assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
	conn
	\|> get("/api/v1/search?q=2hu&type=accounts")
	\|> json_response_and_validate_schema(200)
	end

	test "search uses account_id to filter statuses by the author", %{conn: conn} do
	user = insert(:user, %{nickname: "shp@shitposter.club"})
	user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
	{:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})

	results =
	conn
	\|> get("/api/v1/search?q=2hu&account_id=#{user.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id1}] = results["statuses"]
	assert activity_id1 == activity1.id
	assert [_] = results["accounts"]

	results =
	conn
	\|> get("/api/v1/search?q=2hu&account_id=#{user_two.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert activity_id2 == activity2.id
	end
	end
	end
	diff --git a/test/test_helper.exs b/test/test_helper.exs
	index 27b777d5f..e65f7c1d1 100644
	--- a/test/test_helper.exs
	+++ b/test/test_helper.exs
	@@ -1,32 +1,38 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	Code.put_compiler_option(:warnings_as_errors, true)

	ExUnit.start(exclude: [:federated, :erratic])

	+if match?({:unix, :darwin}, :os.type()) do
	+ excluded = ExUnit.configuration() \|> Keyword.get(:exclude, [])
	+ excluded = excluded ++ [:skip_darwin]
	+ ExUnit.configure(exclude: excluded)
	+end
	+
	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, :manual)

	Mox.defmock(Pleroma.ReverseProxy.ClientMock, for: Pleroma.ReverseProxy.Client)
	Mox.defmock(Pleroma.GunMock, for: Pleroma.Gun)

	{:ok, _} = Application.ensure_all_started(:ex_machina)

	ExUnit.after_suite(fn _results ->
	uploads = Pleroma.Config.get([Pleroma.Uploaders.Local, :uploads], "test/uploads")
	File.rm_rf!(uploads)
	end)

	defmodule Pleroma.Test.StaticConfig do
	@moduledoc """
	This module provides a Config that is completely static, built at startup time from the environment. It's safe to use in testing as it will not modify any state.
	"""

	@behaviour Pleroma.Config.Getting
	@config Application.get_all_env(:pleroma)

	def get(path, default \\ nil) do
	get_in(@config, path) \|\| default
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 4:18 PM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798332
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions