No OneTemporary
Actions

Authored By

Unknown

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/activity.ex b/lib/pleroma/activity.ex
	index 510d3273c..896cbb3c5 100644
	--- a/lib/pleroma/activity.ex
	+++ b/lib/pleroma/activity.ex
	@@ -1,334 +1,332 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.Activity.Queries
	alias Pleroma.ActivityExpiration
	alias Pleroma.Bookmark
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ReportNote
	alias Pleroma.ThreadMute
	alias Pleroma.User

	import Ecto.Changeset
	import Ecto.Query

	@type t :: %__MODULE__{}
	@type actor :: String.t()

	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	# https://github.com/tootsuite/mastodon/blob/master/app/models/notification.rb#L19
	@mastodon_notification_types %{
	"Create" => "mention",
	"Follow" => "follow",
	"Announce" => "reblog",
	"Like" => "favourite",
	"Move" => "move"
	}

	@mastodon_to_ap_notification_types for {k, v} <- @mastodon_notification_types,
	into: %{},
	do: {v, k}

	schema "activities" do
	field(:data, :map)
	field(:local, :boolean, default: true)
	field(:actor, :string)
	field(:recipients, {:array, :string}, default: [])
	field(:thread_muted?, :boolean, virtual: true)

	# This is a fake relation,
	# do not use outside of with_preloaded_user_actor/with_joined_user_actor
	has_one(:user_actor, User, on_delete: :nothing, foreign_key: :id)
	# This is a fake relation, do not use outside of with_preloaded_bookmark/get_bookmark
	has_one(:bookmark, Bookmark)
	# This is a fake relation, do not use outside of with_preloaded_report_notes
	has_many(:report_notes, ReportNote)
	has_many(:notifications, Notification, on_delete: :delete_all)

	# Attention: this is a fake relation, don't try to preload it blindly and expect it to work!
	# The foreign key is embedded in a jsonb field.
	#
	# To use it, you probably want to do an inner join and a preload:
	#
	# ```
	# \|> join(:inner, [activity], o in Object,
	# on: fragment("(?->>'id') = COALESCE((?)->'object'->> 'id', (?)->>'object')",
	# o.data, activity.data, activity.data))
	# \|> preload([activity, object], [object: object])
	# ```
	#
	# As a convenience, Activity.with_preloaded_object() sets up an inner join and preload for the
	# typical case.
	has_one(:object, Object, on_delete: :nothing, foreign_key: :id)

	has_one(:expiration, ActivityExpiration, on_delete: :delete_all)

	timestamps()
	end

	def with_joined_object(query, join_type \\ :inner) do
	join(query, join_type, [activity], o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	as: :object
	)
	end

	def with_preloaded_object(query, join_type \\ :inner) do
	query
	\|> has_named_binding?(:object)
	\|> if(do: query, else: with_joined_object(query, join_type))
	\|> preload([activity, object: object], object: object)
	end

	def with_joined_user_actor(query, join_type \\ :inner) do
	join(query, join_type, [activity], u in User,
	on: u.ap_id == activity.actor,
	as: :user_actor
	)
	end

	def with_preloaded_user_actor(query, join_type \\ :inner) do
	query
	\|> with_joined_user_actor(join_type)
	\|> preload([activity, user_actor: user_actor], user_actor: user_actor)
	end

	def with_preloaded_bookmark(query, %User{} = user) do
	from([a] in query,
	left_join: b in Bookmark,
	on: b.user_id == ^user.id and b.activity_id == a.id,
	preload: [bookmark: b]
	)
	end

	def with_preloaded_bookmark(query, _), do: query

	def with_preloaded_report_notes(query) do
	from([a] in query,
	left_join: r in ReportNote,
	on: a.id == r.activity_id,
	preload: [report_notes: r]
	)
	end

	def with_preloaded_report_notes(query, _), do: query

	def with_set_thread_muted_field(query, %User{} = user) do
	from([a] in query,
	left_join: tm in ThreadMute,
	on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data),
	as: :thread_mute,
	select: %Activity{a \| thread_muted?: not is_nil(tm.id)}
	)
	end

	def with_set_thread_muted_field(query, _), do: query

	def get_by_ap_id(ap_id) do
	ap_id
	\|> Queries.by_ap_id()
	\|> Repo.one()
	end

	def get_bookmark(%Activity{} = activity, %User{} = user) do
	if Ecto.assoc_loaded?(activity.bookmark) do
	activity.bookmark
	else
	Bookmark.get(user.id, activity.id)
	end
	end

	def get_bookmark(_, _), do: nil

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data, :recipients])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :activities_unique_apid_index)
	end

	def get_by_ap_id_with_object(ap_id) do
	ap_id
	\|> Queries.by_ap_id()
	\|> with_preloaded_object(:left)
	\|> Repo.one()
	end

	@spec get_by_id(String.t()) :: Activity.t() \| nil
	def get_by_id(id) do
	case FlakeId.flake_id?(id) do
	true ->
	Activity
	\|> where([a], a.id == ^id)
	\|> restrict_deactivated_users()
	\|> Repo.one()

	_ ->
	nil
	end
	end

	def get_by_id_with_object(id) do
	Activity
	\|> where(id: ^id)
	\|> with_preloaded_object()
	\|> Repo.one()
	end

	def all_by_ids_with_object(ids) do
	Activity
	\|> where([a], a.id in ^ids)
	\|> with_preloaded_object()
	\|> Repo.all()
	end

	@doc """
	Accepts `ap_id` or list of `ap_id`.
	Returns a query.
	"""
	@spec create_by_object_ap_id(String.t() \| [String.t()]) :: Ecto.Queryable.t()
	def create_by_object_ap_id(ap_id) do
	ap_id
	\|> Queries.by_object_id()
	\|> Queries.by_type("Create")
	end

	def get_all_create_by_object_ap_id(ap_id) do
	ap_id
	\|> create_by_object_ap_id()
	\|> Repo.all()
	end

	def get_create_by_object_ap_id(ap_id) when is_binary(ap_id) do
	create_by_object_ap_id(ap_id)
	\|> restrict_deactivated_users()
	\|> Repo.one()
	end

	def get_create_by_object_ap_id(_), do: nil

	@doc """
	Accepts `ap_id` or list of `ap_id`.
	Returns a query.
	"""
	@spec create_by_object_ap_id_with_object(String.t() \| [String.t()]) :: Ecto.Queryable.t()
	def create_by_object_ap_id_with_object(ap_id) do
	ap_id
	\|> create_by_object_ap_id()
	\|> with_preloaded_object()
	end

	def get_create_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
	ap_id
	\|> create_by_object_ap_id_with_object()
	\|> Repo.one()
	end

	def get_create_by_object_ap_id_with_object(_), do: nil

	defp get_in_reply_to_activity_from_object(%Object{data: %{"inReplyTo" => ap_id}}) do
	get_create_by_object_ap_id_with_object(ap_id)
	end

	defp get_in_reply_to_activity_from_object(_), do: nil

	def get_in_reply_to_activity(%Activity{} = activity) do
	get_in_reply_to_activity_from_object(Object.normalize(activity))
	end

	def normalize(obj) when is_map(obj), do: get_by_ap_id_with_object(obj["id"])
	def normalize(ap_id) when is_binary(ap_id), do: get_by_ap_id_with_object(ap_id)
	def normalize(_), do: nil

	def delete_all_by_object_ap_id(id) when is_binary(id) do
	id
	\|> Queries.by_object_id()
	\|> Queries.exclude_type("Delete")
	\|> select([u], u)
	\|> Repo.delete_all()
	\|> elem(1)
	\|> Enum.find(fn
	%{data: %{"type" => "Create", "object" => ap_id}} when is_binary(ap_id) -> ap_id == id
	%{data: %{"type" => "Create", "object" => %{"id" => ap_id}}} -> ap_id == id
	_ -> nil
	end)
	\|> purge_web_resp_cache()
	end

	def delete_all_by_object_ap_id(_), do: nil

	defp purge_web_resp_cache(%Activity{} = activity) do
	%{path: path} = URI.parse(activity.data["id"])
	Cachex.del(:web_resp_cache, path)
	activity
	end

	defp purge_web_resp_cache(nil), do: nil

	for {ap_type, type} <- @mastodon_notification_types do
	def mastodon_notification_type(%Activity{data: %{"type" => unquote(ap_type)}}),
	do: unquote(type)
	end

	def mastodon_notification_type(%Activity{}), do: nil

	def from_mastodon_notification_type(type) do
	Map.get(@mastodon_to_ap_notification_types, type)
	end

	def all_by_actor_and_id(actor, status_ids \\ [])
	def all_by_actor_and_id(_actor, []), do: []

	def all_by_actor_and_id(actor, status_ids) do
	Activity
	\|> where([s], s.id in ^status_ids)
	\|> where([s], s.actor == ^actor)
	\|> Repo.all()
	end

	def follow_requests_for_actor(%Pleroma.User{ap_id: ap_id}) do
	ap_id
	\|> Queries.by_object_id()
	\|> Queries.by_type("Follow")
	\|> where([a], fragment("? ->> 'state' = 'pending'", a.data))
	end

	def restrict_deactivated_users(query) do
	deactivated_users =
	from(u in User.Query.build(deactivated: true), select: u.ap_id)
	\|> Repo.all()

	- from(activity in query,
	- where: activity.actor not in ^deactivated_users
	- )
	+ Activity.Queries.exclude_authors(query, deactivated_users)
	end

	defdelegate search(user, query, options \\ []), to: Pleroma.Activity.Search

	def direct_conversation_id(activity, for_user) do
	alias Pleroma.Conversation.Participation

	with %{data: %{"context" => context}} when is_binary(context) <- activity,
	%Pleroma.Conversation{} = conversation <- Pleroma.Conversation.get_for_ap_id(context),
	%Participation{id: participation_id} <-
	Participation.for_user_and_conversation(for_user, conversation) do
	participation_id
	else
	_ -> nil
	end
	end
	end
	diff --git a/lib/pleroma/activity/queries.ex b/lib/pleroma/activity/queries.ex
	index 26bc1099d..79f305201 100644
	--- a/lib/pleroma/activity/queries.ex
	+++ b/lib/pleroma/activity/queries.ex
	@@ -1,75 +1,85 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity.Queries do
	@moduledoc """
	Contains queries for Activity.
	"""

	import Ecto.Query, only: [from: 2]

	@type query :: Ecto.Queryable.t() \| Activity.t()

	alias Pleroma.Activity
	+ alias Pleroma.User

	@spec by_ap_id(query, String.t()) :: query
	def by_ap_id(query \\ Activity, ap_id) do
	from(
	activity in query,
	where: fragment("(?)->>'id' = ?", activity.data, ^to_string(ap_id))
	)
	end

	@spec by_actor(query, String.t()) :: query
	def by_actor(query \\ Activity, actor) do
	from(
	activity in query,
	where: fragment("(?)->>'actor' = ?", activity.data, ^actor)
	)
	end

	+ @spec by_author(query, String.t()) :: query
	+ def by_author(query \\ Activity, %User{ap_id: ap_id}) do
	+ from(a in query, where: a.actor == ^ap_id)
	+ end
	+
	@spec by_object_id(query, String.t() \| [String.t()]) :: query
	def by_object_id(query \\ Activity, object_id)

	def by_object_id(query, object_ids) when is_list(object_ids) do
	from(
	activity in query,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ANY(?)",
	activity.data,
	activity.data,
	^object_ids
	)
	)
	end

	def by_object_id(query, object_id) when is_binary(object_id) do
	from(activity in query,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^object_id
	)
	)
	end

	@spec by_type(query, String.t()) :: query
	def by_type(query \\ Activity, activity_type) do
	from(
	activity in query,
	where: fragment("(?)->>'type' = ?", activity.data, ^activity_type)
	)
	end

	@spec exclude_type(query, String.t()) :: query
	def exclude_type(query \\ Activity, activity_type) do
	from(
	activity in query,
	where: fragment("(?)->>'type' != ?", activity.data, ^activity_type)
	)
	end
	+
	+ def exclude_authors(query \\ Activity, actors) do
	+ from(activity in query, where: activity.actor not in ^actors)
	+ end
	end
	diff --git a/lib/pleroma/activity/search.ex b/lib/pleroma/activity/search.ex
	index d30a5a6a5..f96e208da 100644
	--- a/lib/pleroma/activity/search.ex
	+++ b/lib/pleroma/activity/search.ex
	@@ -1,94 +1,99 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity.Search do
	alias Pleroma.Activity
	alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Visibility

	require Pleroma.Constants

	import Ecto.Query

	def search(user, search_query, options \\ []) do
	index_type = if Pleroma.Config.get([:database, :rum_enabled]), do: :rum, else: :gin
	limit = Enum.min([Keyword.get(options, :limit), 40])
	offset = Keyword.get(options, :offset, 0)
	author = Keyword.get(options, :author)

	Activity
	\|> Activity.with_preloaded_object()
	\|> Activity.restrict_deactivated_users()
	\|> restrict_public()
	\|> query_with(index_type, search_query)
	\|> maybe_restrict_local(user)
	\|> maybe_restrict_author(author)
	+ \|> maybe_restrict_blocked(user)
	\|> Pagination.fetch_paginated(%{"offset" => offset, "limit" => limit}, :offset)
	\|> maybe_fetch(user, search_query)
	end

	def maybe_restrict_author(query, %User{} = author) do
	- from([a, o] in query,
	- where: a.actor == ^author.ap_id
	- )
	+ Activity.Queries.by_author(query, author)
	end

	def maybe_restrict_author(query, _), do: query

	+ def maybe_restrict_blocked(query, %User{} = user) do
	+ Activity.Queries.exclude_authors(query, User.blocked_users_ap_ids(user))
	+ end
	+
	+ def maybe_restrict_blocked(query, _), do: query
	+
	defp restrict_public(q) do
	from([a, o] in q,
	where: fragment("?->>'type' = 'Create'", a.data),
	where: ^Pleroma.Constants.as_public() in a.recipients
	)
	end

	defp query_with(q, :gin, search_query) do
	from([a, o] in q,
	where:
	fragment(
	"to_tsvector('english', ?->>'content') @@ plainto_tsquery('english', ?)",
	o.data,
	^search_query
	)
	)
	end

	defp query_with(q, :rum, search_query) do
	from([a, o] in q,
	where:
	fragment(
	"? @@ plainto_tsquery('english', ?)",
	o.fts_content,
	^search_query
	),
	order_by: [fragment("? <=> now()::date", o.inserted_at)]
	)
	end

	defp maybe_restrict_local(q, user) do
	limit = Pleroma.Config.get([:instance, :limit_to_local_content], :unauthenticated)

	case {limit, user} do
	{:all, _} -> restrict_local(q)
	{:unauthenticated, %User{}} -> q
	{:unauthenticated, _} -> restrict_local(q)
	{false, _} -> q
	end
	end

	defp restrict_local(q), do: where(q, local: true)

	defp maybe_fetch(activities, user, search_query) do
	with true <- Regex.match?(~r/https?:/, search_query),
	{:ok, object} <- Fetcher.fetch_object_from_id(search_query),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
	true <- Visibility.visible_for_user?(activity, user) do
	[activity \| activities]
	else
	_ -> activities
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/search_controller.ex b/lib/pleroma/web/mastodon_api/controllers/search_controller.ex
	index 0a929f55b..5a5db8e00 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/search_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/search_controller.ex
	@@ -1,128 +1,128 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.SearchController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Plugs.RateLimiter
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ControllerHelper
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView

	require Logger

	# Note: Mastodon doesn't allow unauthenticated access (requires read:accounts / read:search)
	plug(OAuthScopesPlug, %{scopes: ["read:search"], fallback: :proceed_unauthenticated})

	plug(Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug)

	plug(RateLimiter, [name: :search] when action in [:search, :search2, :account_search])

	def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, search_options(params, user))

	conn
	\|> put_view(AccountView)
	\|> render("index.json", users: accounts, for: user, as: :user)
	end

	def search2(conn, params), do: do_search(:v2, conn, params)
	def search(conn, params), do: do_search(:v1, conn, params)

	defp do_search(version, %{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	options = search_options(params, user)
	timeout = Keyword.get(Repo.config(), :timeout, 15_000)
	default_values = %{"statuses" => [], "accounts" => [], "hashtags" => []}

	result =
	default_values
	\|> Enum.map(fn {resource, default_value} ->
	- if params["type"] == nil or params["type"] == resource do
	+ if params["type"] in [nil, resource] do
	{resource, fn -> resource_search(version, resource, query, options) end}
	else
	{resource, fn -> default_value end}
	end
	end)
	\|> Task.async_stream(fn {resource, f} -> {resource, with_fallback(f)} end,
	timeout: timeout,
	on_timeout: :kill_task
	)
	\|> Enum.reduce(default_values, fn
	{:ok, {resource, result}}, acc ->
	Map.put(acc, resource, result)

	_error, acc ->
	acc
	end)

	json(conn, result)
	end

	defp search_options(params, user) do
	[
	resolve: params["resolve"] == "true",
	following: params["following"] == "true",
	limit: ControllerHelper.fetch_integer_param(params, "limit"),
	offset: ControllerHelper.fetch_integer_param(params, "offset"),
	type: params["type"],
	author: get_author(params),
	for_user: user
	]
	\|> Enum.filter(&elem(&1, 1))
	end

	defp resource_search(_, "accounts", query, options) do
	accounts = with_fallback(fn -> User.search(query, options) end)
	AccountView.render("index.json", users: accounts, for: options[:for_user], as: :user)
	end

	defp resource_search(_, "statuses", query, options) do
	statuses = with_fallback(fn -> Activity.search(options[:for_user], query, options) end)
	StatusView.render("index.json", activities: statuses, for: options[:for_user], as: :activity)
	end

	defp resource_search(:v2, "hashtags", query, _options) do
	tags_path = Web.base_url() <> "/tag/"

	query
	\|> prepare_tags()
	\|> Enum.map(fn tag ->
	tag = String.trim_leading(tag, "#")
	%{name: tag, url: tags_path <> tag}
	end)
	end

	defp resource_search(:v1, "hashtags", query, _options) do
	query
	\|> prepare_tags()
	\|> Enum.map(fn tag -> String.trim_leading(tag, "#") end)
	end

	defp prepare_tags(query) do
	query
	\|> String.split()
	\|> Enum.uniq()
	\|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
	end

	defp with_fallback(f, fallback \\ []) do
	try do
	f.()
	rescue
	error ->
	Logger.error("#{__MODULE__} search error: #{inspect(error)}")
	fallback
	end
	end

	defp get_author(%{"account_id" => account_id}) when is_binary(account_id),
	do: User.get_cached_by_id(account_id)

	defp get_author(_params), do: nil
	end
	diff --git a/test/web/mastodon_api/controllers/search_controller_test.exs b/test/web/mastodon_api/controllers/search_controller_test.exs
	index 7fedf42e5..effae130c 100644
	--- a/test/web/mastodon_api/controllers/search_controller_test.exs
	+++ b/test/web/mastodon_api/controllers/search_controller_test.exs
	@@ -1,294 +1,316 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 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
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock
	import Mock

	setup 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(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 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 =
	- get(conn, "/api/v2/search", %{"q" => "2hu #private"})
	+ conn
	+ \|> get("/api/v2/search", %{"q" => "2hu #private"})
	\|> json_response(200)

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

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

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

	results =
	get(conn, "/api/v2/search", %{"q" => "天子"})
	\|> json_response(200)

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	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(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(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(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(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(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"})

	- conn =
	+ results =
	conn
	\|> get("/api/v1/search", %{"q" => "2hu"})
	-
	- assert results = json_response(conn, 200)
	+ \|> json_response(200)

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

	assert results["hashtags"] == []

	[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
	capture_log(fn ->
	{:ok, %{id: activity_id}} =
	CommonAPI.post(insert(:user), %{
	"status" => "check out https://shitposter.club/notice/2827873"
	})

	- conn =
	+ results =
	conn
	\|> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
	-
	- assert results = json_response(conn, 200)
	+ \|> json_response(200)

	[status, %{"id" => ^activity_id}] = results["statuses"]

	assert status["uri"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	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 ->
	- conn =
	+ results =
	conn
	\|> get("/api/v1/search", %{"q" => Object.normalize(activity).data["id"]})
	-
	- assert results = json_response(conn, 200)
	+ \|> json_response(200)

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

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

	- conn =
	+ results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v1/search", %{"q" => "mike@osada.macgirvin.com", "resolve" => "true"})
	+ \|> json_response(200)

	- assert results = json_response(conn, 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
	- conn =
	+ results =
	conn
	\|> get("/api/v1/search", %{"q" => "mike@osada.macgirvin.com", "resolve" => "false"})
	+ \|> json_response(200)

	- assert results = json_response(conn, 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(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(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(200)

	assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
	conn
	\|> get("/api/v1/search", %{"q" => "2hu", "type" => "accounts"})
	\|> json_response(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(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(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert activity_id2 == activity2.id
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 5:31 AM (16 h, 17 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802562
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions