No OneTemporary
Actions

Size

40 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/handle_object_fetch_failures.change b/changelog.d/handle_object_fetch_failures.change
	index 410f95efa..0b1dda38d 100644
	--- a/changelog.d/handle_object_fetch_failures.change
	+++ b/changelog.d/handle_object_fetch_failures.change
	@@ -1,3 +1,2 @@
	Remote object fetch failures will prevent the object fetch job from retrying if the object has been deleted or the fetch was denied with a 403 due to instance block behavior with authorized_fetch enabled.
	-Mark instances as unreachable when object fetch is denied due to instance block and authorized_fetch.
	Skip fetching objects from unreachable instances.
	diff --git a/lib/pleroma/object/fetcher.ex b/lib/pleroma/object/fetcher.ex
	index 431ad4845..8bcd6ed95 100644
	--- a/lib/pleroma/object/fetcher.ex
	+++ b/lib/pleroma/object/fetcher.ex
	@@ -1,369 +1,368 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.Fetcher do
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.Signature
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Federator

	require Logger
	require Pleroma.Constants

	@moduledoc """
	This module deals with correctly fetching Acitivity Pub objects in a safe way.

	The core function is `fetch_and_contain_remote_object_from_id/1` which performs
	the actual fetch and common safety and authenticity checks. Other `fetch_*`
	function use the former and perform some additional tasks
	"""

	@mix_env Mix.env()

	defp touch_changeset(changeset) do
	updated_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.truncate(:second)

	Ecto.Changeset.put_change(changeset, :updated_at, updated_at)
	end

	defp maybe_reinject_internal_fields(%{data: %{} = old_data}, new_data) do
	has_history? = fn
	%{"formerRepresentations" => %{"orderedItems" => list}} when is_list(list) -> true
	_ -> false
	end

	internal_fields = Map.take(old_data, Pleroma.Constants.object_internal_fields())

	remote_history_exists? = has_history?.(new_data)

	# If the remote history exists, we treat that as the only source of truth.
	new_data =
	if has_history?.(old_data) and not remote_history_exists? do
	Map.put(new_data, "formerRepresentations", old_data["formerRepresentations"])
	else
	new_data
	end

	# If the remote does not have history information, we need to manage it ourselves
	new_data =
	if not remote_history_exists? do
	changed? =
	Pleroma.Constants.status_updatable_fields()
	\|> Enum.any?(fn field -> Map.get(old_data, field) != Map.get(new_data, field) end)

	%{updated_object: updated_object} =
	new_data
	\|> Object.Updater.maybe_update_history(old_data,
	updated: changed?,
	use_history_in_new_object?: false
	)

	updated_object
	else
	new_data
	end

	Map.merge(new_data, internal_fields)
	end

	defp maybe_reinject_internal_fields(_, new_data), do: new_data

	@spec reinject_object(struct(), map()) :: {:ok, Object.t()} \| {:error, any()}
	defp reinject_object(%Object{data: %{"type" => "Question"}} = object, new_data) do
	Logger.debug("Reinjecting object #{new_data["id"]}")

	with data <- maybe_reinject_internal_fields(object, new_data),
	{:ok, data, _} <- ObjectValidator.validate(data, %{}),
	changeset <- Object.change(object, %{data: data}),
	changeset <- touch_changeset(changeset),
	{:ok, object} <- Repo.insert_or_update(changeset),
	{:ok, object} <- Object.set_cache(object) do
	{:ok, object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	defp reinject_object(%Object{} = object, new_data) do
	Logger.debug("Reinjecting object #{new_data["id"]}")

	with new_data <- Transmogrifier.fix_object(new_data),
	data <- maybe_reinject_internal_fields(object, new_data),
	changeset <- Object.change(object, %{data: data}),
	changeset <- touch_changeset(changeset),
	{:ok, object} <- Repo.insert_or_update(changeset),
	{:ok, object} <- Object.set_cache(object) do
	{:ok, object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	@doc "Assumes object already is in our database and refetches from remote to update (e.g. for polls)"
	def refetch_object(%Object{data: %{"id" => id}} = object) do
	with {:local, false} <- {:local, Object.local?(object)},
	{:ok, new_data} <- fetch_and_contain_remote_object_from_id(id),
	{:id, true} <- {:id, new_data["id"] == id},
	{:ok, object} <- reinject_object(object, new_data) do
	{:ok, object}
	else
	{:local, true} -> {:ok, object}
	{:id, false} -> {:error, "Object id changed on refetch"}
	e -> {:error, e}
	end
	end

	@doc """
	Fetches a new object and puts it through the processing pipeline for inbound objects

	Note: will also insert a fake Create activity, since atm we internally
	need everything to be traced back to a Create activity.
	"""
	def fetch_object_from_id(id, options \\ []) do
	with %URI{} = uri <- URI.parse(id),
	# let's check the URI is even vaguely valid first
	{:scheme, true} <- {:scheme, uri.scheme == "http" or uri.scheme == "https"},
	# If we have instance restrictions, apply them here to prevent fetching from unwanted instances
	{:ok, nil} <- Pleroma.Web.ActivityPub.MRF.SimplePolicy.check_reject(uri),
	{:ok, _} <- Pleroma.Web.ActivityPub.MRF.SimplePolicy.check_accept(uri),
	{_, nil} <- {:fetch_object, Object.get_cached_by_ap_id(id)},
	{_, true} <- {:allowed_depth, Federator.allowed_thread_distance?(options[:depth])},
	{_, {:ok, data}} <- {:fetch, fetch_and_contain_remote_object_from_id(id)},
	{_, nil} <- {:normalize, Object.normalize(data, fetch: false)},
	params <- prepare_activity_params(data),
	{_, {:ok, activity}} <-
	{:transmogrifier, Transmogrifier.handle_incoming(params, options)},
	{_, _data, %Object{} = object} <-
	{:object, data, Object.normalize(activity, fetch: false)} do
	{:ok, object}
	else
	{:allowed_depth, false} ->
	{:error, "Max thread distance exceeded."}

	{:scheme, false} ->
	{:error, "URI Scheme Invalid"}

	{:containment, e} ->
	Logger.info("Error while fetching #{id}: Object containment failed. #{inspect(e)}")
	{:error, e}

	{:transmogrifier, {:error, {:reject, e}}} ->
	Logger.info("Rejected #{id} while fetching: #{inspect(e)}")
	{:reject, e}

	{:transmogrifier, {:reject, e}} ->
	Logger.info("Rejected #{id} while fetching: #{inspect(e)}")
	{:reject, e}

	{:transmogrifier, _} = e ->
	{:error, e}

	{:object, data, nil} ->
	reinject_object(%Object{}, data)

	{:normalize, object = %Object{}} ->
	{:ok, object}

	{:fetch_object, %Object{} = object} ->
	{:ok, object}

	{:fetch, {:error, error}} ->
	Logger.error("Error while fetching #{id}: #{inspect(error)}")
	{:error, error}

	{:reject, reason} ->
	{:reject, reason}

	e ->
	Logger.error("Error while fetching #{id}: #{inspect(e)}")
	{:error, e}
	end
	end

	defp prepare_activity_params(data) do
	%{
	"type" => "Create",
	# Should we seriously keep this attributedTo thing?
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	}
	\|> Maps.put_if_present("to", data["to"])
	\|> Maps.put_if_present("cc", data["cc"])
	\|> Maps.put_if_present("bto", data["bto"])
	\|> Maps.put_if_present("bcc", data["bcc"])
	end

	defp make_signature(id, date) do
	uri = URI.parse(id)

	signature =
	InternalFetchActor.get_actor()
	\|> Signature.sign(%{
	"(request-target)": "get #{uri.path}",
	host: uri.host,
	date: date
	})

	{"signature", signature}
	end

	defp sign_fetch(headers, id, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[make_signature(id, date) \| headers]
	else
	headers
	end
	end

	defp maybe_date_fetch(headers, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[{"date", date} \| headers]
	else
	headers
	end
	end

	@doc "Fetches arbitrary remote object and performs basic safety and authenticity checks"
	def fetch_and_contain_remote_object_from_id(id)

	def fetch_and_contain_remote_object_from_id(%{"id" => id}),
	do: fetch_and_contain_remote_object_from_id(id)

	def fetch_and_contain_remote_object_from_id(id) when is_binary(id) do
	Logger.debug("Fetching object #{id} via AP")

	with {:scheme, true} <- {:scheme, String.starts_with?(id, "http")},
	{_, :ok} <- {:local_fetch, Containment.contain_local_fetch(id)},
	{:ok, final_id, body} <- get_object(id),
	{:ok, data} <- safe_json_decode(body),
	{_, :ok} <- {:strict_id, Containment.contain_id_to_fetch(final_id, data)},
	{_, :ok} <- {:containment, Containment.contain_origin(final_id, data)} do
	unless Instances.reachable?(final_id) do
	Instances.set_reachable(final_id)
	end

	{:ok, data}
	else
	{:strict_id, _} ->
	{:error, "Object's ActivityPub id/url does not match final fetch URL"}

	{:scheme, _} ->
	{:error, "Unsupported URI scheme"}

	{:local_fetch, _} ->
	{:error, "Trying to fetch local resource"}

	{:containment, _} ->
	{:error, "Object containment failed."}

	{:error, e} ->
	{:error, e}

	e ->
	{:error, e}
	end
	end

	def fetch_and_contain_remote_object_from_id(_id),
	do: {:error, "id must be a string"}

	defp check_crossdomain_redirect(final_host, original_url)

	# HOPEFULLY TEMPORARY
	# Basically none of our Tesla mocks in tests set the (supposed to
	# exist for Tesla proper) url parameter for their responses
	# causing almost every fetch in test to fail otherwise
	if @mix_env == :test do
	defp check_crossdomain_redirect(nil, _) do
	{:cross_domain_redirect, false}
	end
	end

	defp check_crossdomain_redirect(final_host, original_url) do
	{:cross_domain_redirect, final_host != URI.parse(original_url).host}
	end

	if @mix_env == :test do
	defp get_final_id(nil, initial_url), do: initial_url
	defp get_final_id("", initial_url), do: initial_url
	end

	defp get_final_id(final_url, _intial_url) do
	final_url
	end

	@doc "Do NOT use; only public for use in tests"
	def get_object(id) do
	date = Pleroma.Signature.signed_date()

	headers =
	[
	# The first is required by spec, the second provided as a fallback for buggy implementations
	{"accept", "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""},
	{"accept", "application/activity+json"}
	]
	\|> maybe_date_fetch(date)
	\|> sign_fetch(id, date)

	with {:ok, %{body: body, status: code, headers: headers, url: final_url}}
	when code in 200..299 <-
	HTTP.get(id, headers),
	remote_host <-
	URI.parse(final_url).host,
	{:cross_domain_redirect, false} <-
	check_crossdomain_redirect(remote_host, id),
	{:has_content_type, {_, content_type}} <-
	{:has_content_type, List.keyfind(headers, "content-type", 0)},
	{:parse_content_type, {:ok, "application", subtype, type_params}} <-
	{:parse_content_type, Plug.Conn.Utils.media_type(content_type)} do
	final_id = get_final_id(final_url, id)

	case {subtype, type_params} do
	{"activity+json", _} ->
	{:ok, final_id, body}

	{"ld+json", %{"profile" => "https://www.w3.org/ns/activitystreams"}} ->
	{:ok, final_id, body}

	_ ->
	{:error, {:content_type, content_type}}
	end
	else
	{:ok, %{status: 403}} ->
	- Instances.set_consistently_unreachable(id)
	{:error, "Object fetch has been denied"}

	{:ok, %{status: code}} when code in [404, 410] ->
	{:error, {"Object has been deleted", id, code}}

	{:error, e} ->
	{:error, e}

	{:has_content_type, _} ->
	{:error, {:content_type, nil}}

	{:parse_content_type, e} ->
	{:error, {:content_type, e}}

	e ->
	{:error, e}
	end
	end

	defp safe_json_decode(nil), do: {:ok, nil}
	defp safe_json_decode(json), do: Jason.decode(json)
	end
	diff --git a/test/pleroma/object/fetcher_test.exs b/test/pleroma/object/fetcher_test.exs
	index fa6259ff4..8617090d9 100644
	--- a/test/pleroma/object/fetcher_test.exs
	+++ b/test/pleroma/object/fetcher_test.exs
	@@ -1,828 +1,816 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.FetcherTest do
	use Pleroma.DataCase, async: false
	@moduletag :mocked

	alias Pleroma.Activity
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher

	import Mock
	import Tesla.Mock

	defp spoofed_object_with_ids(
	id \\ "https://patch.cx/objects/spoof",
	actor_id \\ "https://patch.cx/users/rin"
	) do
	File.read!("test/fixtures/spoofed-object.json")
	\|> Jason.decode!()
	\|> Map.put("id", id)
	\|> Map.put("actor", actor_id)
	\|> Jason.encode!()
	end

	setup do
	mock(fn
	%{method: :get, url: "https://mastodon.example.org/users/userisgone"} ->
	%Tesla.Env{status: 410}

	%{method: :get, url: "https://mastodon.example.org/users/userisgone404"} ->
	%Tesla.Env{status: 404}

	# Spoof: wrong Content-Type
	%{
	method: :get,
	url: "https://patch.cx/objects/spoof_content_type.json"
	} ->
	%Tesla.Env{
	status: 200,
	url: "https://patch.cx/objects/spoof_content_type.json",
	headers: [{"content-type", "application/json"}],
	body: spoofed_object_with_ids("https://patch.cx/objects/spoof_content_type.json")
	}

	# Spoof: no Content-Type
	%{
	method: :get,
	url: "https://patch.cx/objects/spoof_content_type"
	} ->
	%Tesla.Env{
	status: 200,
	url: "https://patch.cx/objects/spoof_content_type",
	headers: [],
	body: spoofed_object_with_ids("https://patch.cx/objects/spoof_content_type")
	}

	%{method: :get, url: "https://octodon.social/users/cwebber/statuses/111647596861000656"} ->
	%Tesla.Env{status: 403}
	# Spoof: mismatching ids
	# Variant 1: Non-exisitng fake id
	%{
	method: :get,
	url:
	"https://patch.cx/media/03ca3c8b4ac3ddd08bf0f84be7885f2f88de0f709112131a22d83650819e36c2.json"
	} ->
	%Tesla.Env{
	status: 200,
	url:
	"https://patch.cx/media/03ca3c8b4ac3ddd08bf0f84be7885f2f88de0f709112131a22d83650819e36c2.json",
	headers: [{"content-type", "application/activity+json"}],
	body: spoofed_object_with_ids()
	}

	%{method: :get, url: "https://patch.cx/objects/spoof"} ->
	%Tesla.Env{
	status: 404,
	url: "https://patch.cx/objects/spoof",
	headers: [],
	body: "Not found"
	}

	# Varaint 2: two-stage payload
	%{method: :get, url: "https://patch.cx/media/spoof_stage1.json"} ->
	%Tesla.Env{
	status: 200,
	url: "https://patch.cx/media/spoof_stage1.json",
	headers: [{"content-type", "application/activity+json"}],
	body: spoofed_object_with_ids("https://patch.cx/media/spoof_stage2.json")
	}

	%{method: :get, url: "https://patch.cx/media/spoof_stage2.json"} ->
	%Tesla.Env{
	status: 200,
	url: "https://patch.cx/media/spoof_stage2.json",
	headers: [{"content-type", "application/activity+json"}],
	body: spoofed_object_with_ids("https://patch.cx/media/unpredictable.json")
	}

	# Spoof: cross-domain redirect with original domain id
	%{method: :get, url: "https://patch.cx/objects/spoof_media_redirect1"} ->
	%Tesla.Env{
	status: 200,
	url: "https://media.patch.cx/objects/spoof",
	headers: [{"content-type", "application/activity+json"}],
	body: spoofed_object_with_ids("https://patch.cx/objects/spoof_media_redirect1")
	}

	# Spoof: cross-domain redirect with final domain id
	%{method: :get, url: "https://patch.cx/objects/spoof_media_redirect2"} ->
	%Tesla.Env{
	status: 200,
	url: "https://media.patch.cx/objects/spoof_media_redirect2",
	headers: [{"content-type", "application/activity+json"}],
	body: spoofed_object_with_ids("https://media.patch.cx/objects/spoof_media_redirect2")
	}

	# No-Spoof: same domain redirect
	%{method: :get, url: "https://patch.cx/objects/spoof_redirect"} ->
	%Tesla.Env{
	status: 200,
	url: "https://patch.cx/objects/spoof_redirect",
	headers: [{"content-type", "application/activity+json"}],
	body: spoofed_object_with_ids("https://patch.cx/objects/spoof_redirect")
	}

	# Spoof: Actor from another domain
	%{method: :get, url: "https://patch.cx/objects/spoof_foreign_actor"} ->
	%Tesla.Env{
	status: 200,
	url: "https://patch.cx/objects/spoof_foreign_actor",
	headers: [{"content-type", "application/activity+json"}],
	body:
	spoofed_object_with_ids(
	"https://patch.cx/objects/spoof_foreign_actor",
	"https://not.patch.cx/users/rin"
	)
	}

	env ->
	apply(HttpRequestMock, :request, [env])
	end)

	:ok
	end

	describe "error cases" do
	setup do
	mock(fn
	%{method: :get, url: "https://social.sakamoto.gq/notice/9wTkLEnuq47B25EehM"} ->
	%Tesla.Env{
	status: 200,
	url: "https://social.sakamoto.gq/objects/f20f2497-66d9-4a52-a2e1-1be2a39c32c1",
	body: File.read!("test/fixtures/fetch_mocks/9wTkLEnuq47B25EehM.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}

	%{method: :get, url: "https://social.sakamoto.gq/users/eal"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/fetch_mocks/eal.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}

	%{method: :get, url: "https://busshi.moe/users/tuxcrafting/statuses/104410921027210069"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/fetch_mocks/104410921027210069.json"),
	headers: HttpRequestMock.activitypub_object_headers()
	}

	%{method: :get, url: "https://busshi.moe/users/tuxcrafting"} ->
	%Tesla.Env{
	status: 500
	}

	%{
	method: :get,
	url: "https://stereophonic.space/objects/02997b83-3ea7-4b63-94af-ef3aa2d4ed17"
	} ->
	%Tesla.Env{
	status: 500
	}
	end)

	:ok
	end

	@tag capture_log: true
	test "it works when fetching the OP actor errors out" do
	# Here we simulate a case where the author of the OP can't be read
	assert {:ok, _} =
	Fetcher.fetch_object_from_id(
	"https://social.sakamoto.gq/notice/9wTkLEnuq47B25EehM"
	)
	end
	end

	describe "max thread distance restriction" do
	@ap_id "http://mastodon.example.org/@admin/99541947525187367"
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	test "it returns thread depth exceeded error if thread depth is exceeded" do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	assert {:error, "Max thread distance exceeded."} =
	Fetcher.fetch_object_from_id(@ap_id, depth: 1)
	end

	test "it fetches object if max thread depth is restricted to 0 and depth is not specified" do
	clear_config([:instance, :federation_incoming_replies_max_depth], 0)

	assert {:ok, _} = Fetcher.fetch_object_from_id(@ap_id)
	end

	test "it fetches object if requested depth does not exceed max thread depth" do
	clear_config([:instance, :federation_incoming_replies_max_depth], 10)

	assert {:ok, _} = Fetcher.fetch_object_from_id(@ap_id, depth: 10)
	end
	end

	describe "actor origin containment" do
	test "it rejects objects with a bogus origin" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity.json")
	end

	test "it rejects objects when attributedTo is wrong (variant 1)" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity2.json")
	end

	test "it rejects objects when attributedTo is wrong (variant 2)" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity3.json")
	end
	end

	describe "fetcher security and auth checks" do
	test "it does not fetch a spoofed object without content type" do
	assert {:error, {:content_type, nil}} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://patch.cx/objects/spoof_content_type"
	)
	end

	test "it does not fetch a spoofed object with wrong content type" do
	assert {:error, {:content_type, _}} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://patch.cx/objects/spoof_content_type.json"
	)
	end

	test "it does not fetch a spoofed object with id different from URL" do
	assert {:error, "Object's ActivityPub id/url does not match final fetch URL"} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://patch.cx/media/03ca3c8b4ac3ddd08bf0f84be7885f2f88de0f709112131a22d83650819e36c2.json"
	)

	assert {:error, "Object's ActivityPub id/url does not match final fetch URL"} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://patch.cx/media/spoof_stage1.json"
	)
	end

	test "it does not fetch an object via cross-domain redirects (initial id)" do
	assert {:error, {:cross_domain_redirect, true}} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://patch.cx/objects/spoof_media_redirect1"
	)
	end

	test "it does not fetch an object via cross-domain redirects (final id)" do
	assert {:error, {:cross_domain_redirect, true}} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://patch.cx/objects/spoof_media_redirect2"
	)
	end

	test "it accepts same-domain redirects" do
	assert {:ok, %{"id" => id} = _object} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://patch.cx/objects/spoof_redirect"
	)

	assert id == "https://patch.cx/objects/spoof_redirect"
	end

	test "it does not fetch a spoofed object with a foreign actor" do
	assert {:error, "Object containment failed."} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://patch.cx/objects/spoof_foreign_actor"
	)
	end

	test "it does not fetch from localhost" do
	assert {:error, "Trying to fetch local resource"} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	Pleroma.Web.Endpoint.url() <> "/spoof_local"
	)
	end
	end

	describe "fetching an object" do
	test "it fetches an object" do
	{:ok, object} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert _activity = Activity.get_create_by_object_ap_id(object.data["id"])

	{:ok, object_again} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert [attachment] = object.data["attachment"]
	assert is_list(attachment["url"])

	assert object == object_again
	end

	test "Return MRF reason when fetched status is rejected by one" do
	clear_config([:mrf_keyword, :reject], ["yeah"])
	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	assert {:reject, "[KeywordPolicy] Matches with rejected keyword"} ==
	Fetcher.fetch_object_from_id(
	"http://mastodon.example.org/@admin/99541947525187367"
	)
	end

	test "does not fetch anything from a rejected instance" do
	clear_config([:mrf_simple, :reject], [{"evil.example.org", "i said so"}])

	assert {:reject, _} =
	Fetcher.fetch_object_from_id("http://evil.example.org/@admin/99541947525187367")
	end

	test "does not fetch anything if mrf_simple accept is on" do
	clear_config([:mrf_simple, :accept], [{"mastodon.example.org", "i said so"}])
	clear_config([:mrf_simple, :reject], [])

	assert {:reject, _} =
	Fetcher.fetch_object_from_id(
	"http://notlisted.example.org/@admin/99541947525187367"
	)

	assert {:ok, _object} =
	Fetcher.fetch_object_from_id(
	"http://mastodon.example.org/@admin/99541947525187367"
	)
	end

	test "it resets instance reachability on successful fetch" do
	id = "http://mastodon.example.org/@admin/99541947525187367"
	Instances.set_consistently_unreachable(id)
	refute Instances.reachable?(id)

	{:ok, _object} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert Instances.reachable?(id)
	end
	end

	describe "implementation quirks" do
	test "it can fetch plume articles" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/"
	)

	assert object
	end

	test "it can fetch peertube videos" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	assert object
	end

	test "it can fetch Mobilizon events" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
	)

	assert object
	end

	test "it can fetch wedistribute articles" do
	{:ok, object} =
	Fetcher.fetch_object_from_id("https://wedistribute.org/wp-json/pterotype/v1/object/85810")

	assert object
	end

	test "all objects with fake directions are rejected by the object fetcher" do
	assert {:error, _} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://info.pleroma.site/activity4.json"
	)
	end

	test "handle HTTP 410 Gone response" do
	assert {:error,
	{"Object has been deleted", "https://mastodon.example.org/users/userisgone", 410}} ==
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://mastodon.example.org/users/userisgone"
	)
	end

	test "handle HTTP 404 response" do
	assert {:error,
	{"Object has been deleted", "https://mastodon.example.org/users/userisgone404", 404}} ==
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://mastodon.example.org/users/userisgone404"
	)
	end

	- test "handle HTTP 403 response" do
	- object_id = "https://octodon.social/users/cwebber/statuses/111647596861000656"
	- Instances.set_reachable(object_id)
	-
	- assert Instances.reachable?(object_id)
	-
	- assert {:error, "Object fetch has been denied"} ==
	- Fetcher.fetch_object_from_id(object_id)
	-
	- refute Instances.reachable?(object_id)
	- end
	-
	test "it can fetch pleroma polls with attachments" do
	{:ok, object} =
	Fetcher.fetch_object_from_id("https://patch.cx/objects/tesla_mock/poll_attachment")

	assert object
	end
	end

	describe "pruning" do
	test "it can refetch pruned objects" do
	object_id = "http://mastodon.example.org/@admin/99541947525187367"

	{:ok, object} = Fetcher.fetch_object_from_id(object_id)

	assert object

	{:ok, _object} = Object.prune(object)

	refute Object.get_by_ap_id(object_id)

	{:ok, %Object{} = object_two} = Fetcher.fetch_object_from_id(object_id)

	assert object.data["id"] == object_two.data["id"]
	assert object.id != object_two.id
	end
	end

	describe "signed fetches" do
	setup do: clear_config([:activitypub, :sign_object_fetches])

	test_with_mock "it signs fetches when configured to do so",
	Pleroma.Signature,
	[:passthrough],
	[] do
	clear_config([:activitypub, :sign_object_fetches], true)

	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert called(Pleroma.Signature.sign(:_, :_))
	end

	test_with_mock "it doesn't sign fetches when not configured to do so",
	Pleroma.Signature,
	[:passthrough],
	[] do
	clear_config([:activitypub, :sign_object_fetches], false)

	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	refute called(Pleroma.Signature.sign(:_, :_))
	end
	end

	describe "refetching" do
	setup do
	object1 = %{
	"id" => "https://mastodon.social/1",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"type" => "Note",
	"content" => "test 1",
	"bcc" => [],
	"bto" => [],
	"cc" => [],
	"to" => [],
	"summary" => ""
	}

	object2 = %{
	"id" => "https://mastodon.social/2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"type" => "Note",
	"content" => "test 2",
	"bcc" => [],
	"bto" => [],
	"cc" => [],
	"to" => [],
	"summary" => "",
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "orig 2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"bcc" => [],
	"bto" => [],
	"cc" => [],
	"to" => [],
	"summary" => ""
	}
	],
	"totalItems" => 1
	}
	}

	mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/1"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body: Jason.encode!(object1)
	}

	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body: Jason.encode!(object2)
	}

	%{
	method: :get,
	url: "https://mastodon.social/users/emelie/collections/featured"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body:
	Jason.encode!(%{
	"id" => "https://mastodon.social/users/emelie/collections/featured",
	"type" => "OrderedCollection",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"orderedItems" => [],
	"totalItems" => 0
	})
	}

	env ->
	apply(HttpRequestMock, :request, [env])
	end)

	%{object1: object1, object2: object2}
	end

	test "it keeps formerRepresentations if remote does not have this attr", %{object1: object1} do
	full_object1 =
	object1
	\|> Map.merge(%{
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "orig 2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"bcc" => [],
	"bto" => [],
	"cc" => [],
	"to" => [],
	"summary" => ""
	}
	],
	"totalItems" => 1
	}
	})

	{:ok, o} = Object.create(full_object1)

	assert {:ok, refetched} = Fetcher.refetch_object(o)

	assert %{"formerRepresentations" => %{"orderedItems" => [%{"content" => "orig 2"}]}} =
	refetched.data
	end

	test "it uses formerRepresentations from remote if possible", %{object2: object2} do
	{:ok, o} = Object.create(object2)

	assert {:ok, refetched} = Fetcher.refetch_object(o)

	assert %{"formerRepresentations" => %{"orderedItems" => [%{"content" => "orig 2"}]}} =
	refetched.data
	end

	test "it replaces formerRepresentations with the one from remote", %{object2: object2} do
	full_object2 =
	object2
	\|> Map.merge(%{
	"content" => "mew mew #def",
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{"type" => "Note", "content" => "mew mew 2"}
	],
	"totalItems" => 1
	}
	})

	{:ok, o} = Object.create(full_object2)

	assert {:ok, refetched} = Fetcher.refetch_object(o)

	assert %{
	"content" => "test 2",
	"formerRepresentations" => %{"orderedItems" => [%{"content" => "orig 2"}]}
	} = refetched.data
	end

	test "it adds to formerRepresentations if the remote does not have one and the object has changed",
	%{object1: object1} do
	full_object1 =
	object1
	\|> Map.merge(%{
	"content" => "mew mew #def",
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{"type" => "Note", "content" => "mew mew 1"}
	],
	"totalItems" => 1
	}
	})

	{:ok, o} = Object.create(full_object1)

	assert {:ok, refetched} = Fetcher.refetch_object(o)

	assert %{
	"content" => "test 1",
	"formerRepresentations" => %{
	"orderedItems" => [
	%{"content" => "mew mew #def"},
	%{"content" => "mew mew 1"}
	],
	"totalItems" => 2
	}
	} = refetched.data
	end
	end

	describe "fetch with history" do
	setup do
	object2 = %{
	"id" => "https://mastodon.social/2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"type" => "Note",
	"content" => "test 2",
	"bcc" => [],
	"bto" => [],
	"cc" => ["https://mastodon.social/users/emelie/followers"],
	"to" => [],
	"summary" => "",
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "orig 2",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"bcc" => [],
	"bto" => [],
	"cc" => ["https://mastodon.social/users/emelie/followers"],
	"to" => [],
	"summary" => ""
	}
	],
	"totalItems" => 1
	}
	}

	mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body: Jason.encode!(object2)
	}

	%{
	method: :get,
	url: "https://mastodon.social/users/emelie/collections/featured"
	} ->
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/activity+json"}],
	body:
	Jason.encode!(%{
	"id" => "https://mastodon.social/users/emelie/collections/featured",
	"type" => "OrderedCollection",
	"actor" => "https://mastodon.social/users/emelie",
	"attributedTo" => "https://mastodon.social/users/emelie",
	"orderedItems" => [],
	"totalItems" => 0
	})
	}

	env ->
	apply(HttpRequestMock, :request, [env])
	end)

	%{object2: object2}
	end

	test "it gets history", %{object2: object2} do
	{:ok, object} = Fetcher.fetch_object_from_id(object2["id"])

	assert %{
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [%{}]
	}
	} = object.data
	end
	end

	describe "get_object/1" do
	test "should return ok if the content type is application/activity+json" do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	url: "https://mastodon.social/2",
	headers: [{"content-type", "application/activity+json"}],
	body: "{}"
	}
	end)

	assert {:ok, _, "{}"} = Fetcher.get_object("https://mastodon.social/2")
	end

	test "should return ok if the content type is application/ld+json with a profile" do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	url: "https://mastodon.social/2",
	headers: [
	{"content-type",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""}
	],
	body: "{}"
	}
	end)

	assert {:ok, _, "{}"} = Fetcher.get_object("https://mastodon.social/2")
	end

	test "should not return ok with other content types" do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/2"
	} ->
	%Tesla.Env{
	status: 200,
	url: "https://mastodon.social/2",
	headers: [{"content-type", "application/json"}],
	body: "{}"
	}
	end)

	assert {:error, {:content_type, "application/json"}} =
	Fetcher.get_object("https://mastodon.social/2")
	end

	test "returns the url after redirects" do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://mastodon.social/5"
	} ->
	%Tesla.Env{
	status: 200,
	url: "https://mastodon.social/7",
	headers: [{"content-type", "application/activity+json"}],
	body: "{}"
	}
	end)

	assert {:ok, "https://mastodon.social/7", "{}"} =
	Fetcher.get_object("https://mastodon.social/5")
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 10, 1:12 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1784978
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions