No OneTemporary
Actions

Size

47 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/user/info.ex b/lib/pleroma/user/info.ex
	index 49387163a..4e2c5472d 100644
	--- a/lib/pleroma/user/info.ex
	+++ b/lib/pleroma/user/info.ex
	@@ -1,133 +1,137 @@
	defmodule Pleroma.User.Info do
	use Ecto.Schema
	import Ecto.Changeset

	embedded_schema do
	field(:banner, :map, default: %{})
	field(:background, :string, default: nil)
	field(:source_data, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	field(:locked, :boolean, default: false)
	field(:default_scope, :string, default: "public")
	field(:blocks, {:array, :string}, default: [])
	field(:domain_blocks, {:array, :string}, default: [])
	field(:deactivated, :boolean, default: false)
	field(:no_rich_text, :boolean, default: false)
	field(:ap_enabled, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:keys, :string, default: nil)
	field(:settings, :map, default: nil)
	field(:magic_key, :string, default: nil)
	field(:uri, :string, default: nil)
	+ field(:topic, :string, default: nil)
	+ field(:hub, :string, default: nil)
	# topic, subject, salmon, subscribe_address, uri
	end

	def set_activation_status(info, deactivated) do
	params = %{deactivated: deactivated}

	info
	\|> cast(params, [:deactivated])
	\|> validate_required([:deactivated])
	end

	def add_to_note_count(info, number) do
	set_note_count(info, info.note_count + number)
	end

	def set_note_count(info, number) do
	params = %{note_count: Enum.max([0, number])}

	info
	\|> cast(params, [:note_count])
	\|> validate_required([:note_count])
	end

	def set_follower_count(info, number) do
	params = %{follower_count: Enum.max([0, number])}

	info
	\|> cast(params, [:follower_count])
	\|> validate_required([:follower_count])
	end

	def set_blocks(info, blocks) do
	params = %{blocks: blocks}

	info
	\|> cast(params, [:blocks])
	\|> validate_required([:blocks])
	end

	def add_to_block(info, blocked) do
	set_blocks(info, Enum.uniq([blocked \| info.blocks]))
	end

	def remove_from_block(info, blocked) do
	set_blocks(info, List.delete(info.blocks, blocked))
	end

	def set_domain_blocks(info, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

	info
	\|> cast(params, [:domain_blocks])
	\|> validate_required([:domain_blocks])
	end

	def add_to_domain_block(info, domain_blocked) do
	set_domain_blocks(info, Enum.uniq([domain_blocked \| info.domain_blocks]))
	end

	def remove_from_domain_block(info, domain_blocked) do
	set_domain_blocks(info, List.delete(info.domain_blocks, domain_blocked))
	end

	def set_keys(info, keys) do
	params = %{keys: keys}

	info
	\|> cast(params, [:keys])
	\|> validate_required([:keys])
	end

	def remote_user_creation(info, params) do
	info
	\|> cast(params, [
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key,
	- :uri
	+ :uri,
	+ :hub,
	+ :topic
	])
	end

	def user_upgrade(info, params) do
	info
	\|> cast(params, [
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key
	])
	end

	def profile_update(info, params) do
	info
	\|> cast(params, [
	:locked,
	:no_rich_text,
	:default_scope
	])
	end

	def set_source_data(info, source_data) do
	params = %{source_data: source_data}

	info
	\|> cast(params, [:source_data])
	\|> validate_required([:source_data])
	end
	end
	diff --git a/lib/pleroma/web/websub/websub.ex b/lib/pleroma/web/websub/websub.ex
	index e494811f9..440b48665 100644
	--- a/lib/pleroma/web/websub/websub.ex
	+++ b/lib/pleroma/web/websub/websub.ex
	@@ -1,255 +1,255 @@
	defmodule Pleroma.Web.Websub do
	alias Ecto.Changeset
	alias Pleroma.Repo
	alias Pleroma.Web.Websub.{WebsubServerSubscription, WebsubClientSubscription}
	alias Pleroma.Web.OStatus.FeedRepresenter
	alias Pleroma.Web.{XML, Endpoint, OStatus}
	alias Pleroma.Web.Router.Helpers
	require Logger

	import Ecto.Query

	@httpoison Application.get_env(:pleroma, :httpoison)

	def verify(subscription, getter \\ &@httpoison.get/3) do
	challenge = Base.encode16(:crypto.strong_rand_bytes(8))
	lease_seconds = NaiveDateTime.diff(subscription.valid_until, subscription.updated_at)
	lease_seconds = lease_seconds \|> to_string

	params = %{
	"hub.challenge": challenge,
	"hub.lease_seconds": lease_seconds,
	"hub.topic": subscription.topic,
	"hub.mode": "subscribe"
	}

	url = hd(String.split(subscription.callback, "?"))
	query = URI.parse(subscription.callback).query \|\| ""
	params = Map.merge(params, URI.decode_query(query))

	with {:ok, response} <- getter.(url, [], params: params),
	^challenge <- response.body do
	changeset = Changeset.change(subscription, %{state: "active"})
	Repo.update(changeset)
	else
	e ->
	Logger.debug("Couldn't verify subscription")
	Logger.debug(inspect(e))
	{:error, subscription}
	end
	end

	@supported_activities [
	"Create",
	"Follow",
	"Like",
	"Announce",
	"Undo",
	"Delete"
	]
	def publish(topic, user, %{data: %{"type" => type}} = activity)
	when type in @supported_activities do
	# TODO: Only send to still valid subscriptions.
	query =
	from(
	sub in WebsubServerSubscription,
	where: sub.topic == ^topic and sub.state == "active",
	where: fragment("? > NOW()", sub.valid_until)
	)

	subscriptions = Repo.all(query)

	Enum.each(subscriptions, fn sub ->
	response =
	user
	\|> FeedRepresenter.to_simple_form([activity], [user])
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	data = %{
	xml: response,
	topic: topic,
	callback: sub.callback,
	secret: sub.secret
	}

	Pleroma.Web.Federator.enqueue(:publish_single_websub, data)
	end)
	end

	def publish(_, _, _), do: ""

	def sign(secret, doc) do
	:crypto.hmac(:sha, secret, to_string(doc)) \|> Base.encode16() \|> String.downcase()
	end

	def incoming_subscription_request(user, %{"hub.mode" => "subscribe"} = params) do
	with {:ok, topic} <- valid_topic(params, user),
	{:ok, lease_time} <- lease_time(params),
	secret <- params["hub.secret"],
	callback <- params["hub.callback"] do
	subscription = get_subscription(topic, callback)

	data = %{
	state: subscription.state \|\| "requested",
	topic: topic,
	secret: secret,
	callback: callback
	}

	change = Changeset.change(subscription, data)
	websub = Repo.insert_or_update!(change)

	change =
	Changeset.change(websub, %{valid_until: NaiveDateTime.add(websub.updated_at, lease_time)})

	websub = Repo.update!(change)

	Pleroma.Web.Federator.enqueue(:verify_websub, websub)

	{:ok, websub}
	else
	{:error, reason} ->
	Logger.debug("Couldn't create subscription")
	Logger.debug(inspect(reason))

	{:error, reason}
	end
	end

	defp get_subscription(topic, callback) do
	Repo.get_by(WebsubServerSubscription, topic: topic, callback: callback) \|\|
	%WebsubServerSubscription{}
	end

	# Temp hack for mastodon.
	defp lease_time(%{"hub.lease_seconds" => ""}) do
	# three days
	{:ok, 60 * 60 * 24 * 3}
	end

	defp lease_time(%{"hub.lease_seconds" => lease_seconds}) do
	{:ok, String.to_integer(lease_seconds)}
	end

	defp lease_time(_) do
	# three days
	{:ok, 60 * 60 * 24 * 3}
	end

	defp valid_topic(%{"hub.topic" => topic}, user) do
	if topic == OStatus.feed_path(user) do
	{:ok, OStatus.feed_path(user)}
	else
	{:error, "Wrong topic requested, expected #{OStatus.feed_path(user)}, got #{topic}"}
	end
	end

	def subscribe(subscriber, subscribed, requester \\ &request_subscription/1) do
	- topic = subscribed.info["topic"]
	+ topic = subscribed.info.topic
	# FIXME: Race condition, use transactions
	{:ok, subscription} =
	with subscription when not is_nil(subscription) <-
	Repo.get_by(WebsubClientSubscription, topic: topic) do
	subscribers = [subscriber.ap_id \| subscription.subscribers] \|> Enum.uniq()
	change = Ecto.Changeset.change(subscription, %{subscribers: subscribers})
	Repo.update(change)
	else
	_e ->
	subscription = %WebsubClientSubscription{
	topic: topic,
	- hub: subscribed.info["hub"],
	+ hub: subscribed.info.hub,
	subscribers: [subscriber.ap_id],
	state: "requested",
	secret: :crypto.strong_rand_bytes(8) \|> Base.url_encode64(),
	user: subscribed
	}

	Repo.insert(subscription)
	end

	requester.(subscription)
	end

	def gather_feed_data(topic, getter \\ &@httpoison.get/1) do
	with {:ok, response} <- getter.(topic),
	status_code when status_code in 200..299 <- response.status_code,
	body <- response.body,
	doc <- XML.parse_document(body),
	uri when not is_nil(uri) <- XML.string_from_xpath("/feed/author[1]/uri", doc),
	hub when not is_nil(hub) <- XML.string_from_xpath(~S{/feed/link[@rel="hub"]/@href}, doc) do
	name = XML.string_from_xpath("/feed/author[1]/name", doc)
	preferredUsername = XML.string_from_xpath("/feed/author[1]/poco:preferredUsername", doc)
	displayName = XML.string_from_xpath("/feed/author[1]/poco:displayName", doc)
	avatar = OStatus.make_avatar_object(doc)
	bio = XML.string_from_xpath("/feed/author[1]/summary", doc)

	{:ok,
	%{
	"uri" => uri,
	"hub" => hub,
	"nickname" => preferredUsername \|\| name,
	"name" => displayName \|\| name,
	"host" => URI.parse(uri).host,
	"avatar" => avatar,
	"bio" => bio
	}}
	else
	e ->
	{:error, e}
	end
	end

	def request_subscription(websub, poster \\ &@httpoison.post/3, timeout \\ 10_000) do
	data = [
	"hub.mode": "subscribe",
	"hub.topic": websub.topic,
	"hub.secret": websub.secret,
	"hub.callback": Helpers.websub_url(Endpoint, :websub_subscription_confirmation, websub.id)
	]

	# This checks once a second if we are confirmed yet
	websub_checker = fn ->
	helper = fn helper ->
	:timer.sleep(1000)
	websub = Repo.get_by(WebsubClientSubscription, id: websub.id, state: "accepted")
	if websub, do: websub, else: helper.(helper)
	end

	helper.(helper)
	end

	task = Task.async(websub_checker)

	with {:ok, %{status_code: 202}} <-
	poster.(websub.hub, {:form, data}, "Content-type": "application/x-www-form-urlencoded"),
	{:ok, websub} <- Task.yield(task, timeout) do
	{:ok, websub}
	else
	e ->
	Task.shutdown(task)

	change = Ecto.Changeset.change(websub, %{state: "rejected"})
	{:ok, websub} = Repo.update(change)

	Logger.debug(fn -> "Couldn't confirm subscription: #{inspect(websub)}" end)
	Logger.debug(fn -> "error: #{inspect(e)}" end)

	{:error, websub}
	end
	end

	def refresh_subscriptions(delta \\ 60 * 60 * 24) do
	Logger.debug("Refreshing subscriptions")

	cut_off = NaiveDateTime.add(NaiveDateTime.utc_now(), delta)

	query = from(sub in WebsubClientSubscription, where: sub.valid_until < ^cut_off)

	subs = Repo.all(query)

	Enum.each(subs, fn sub ->
	Pleroma.Web.Federator.enqueue(:request_subscription, sub)
	end)
	end
	end
	diff --git a/test/web/ostatus/ostatus_test.exs b/test/web/ostatus/ostatus_test.exs
	index b2f25d215..6e5263014 100644
	--- a/test/web/ostatus/ostatus_test.exs
	+++ b/test/web/ostatus/ostatus_test.exs
	@@ -1,483 +1,483 @@
	defmodule Pleroma.Web.OStatusTest do
	use Pleroma.DataCase
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.XML
	alias Pleroma.{Object, Repo, User, Activity}
	import Pleroma.Factory
	import ExUnit.CaptureLog

	test "don't insert create notes twice" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert {:ok, [activity]} == OStatus.handle_incoming(incoming)
	end

	test "handle incoming note - GS, Salmon" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	user = User.get_by_ap_id(activity.data["actor"])
	assert user.info.note_count == 1
	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"

	assert activity.data["object"]["id"] ==
	"tag:gs.example.org:4040,2017-04-23:noticeId=29:objectType=note"

	assert activity.data["published"] == "2017-04-23T14:51:03+00:00"
	assert activity.data["object"]["published"] == "2017-04-23T14:51:03+00:00"

	assert activity.data["context"] ==
	"tag:gs.example.org:4040,2017-04-23:objectType=thread:nonce=f09e22f58abd5c7b"

	assert "http://pleroma.example.org:4000/users/lain3" in activity.data["to"]
	assert activity.data["object"]["emoji"] == %{"marko" => "marko.png", "reimu" => "reimu.png"}
	assert activity.local == false
	end

	test "handle incoming notes - GS, subscription" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["content"] == "Will it blend?"
	user = User.get_cached_by_ap_id(activity.data["actor"])
	assert User.ap_followers(user) in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes with attachments - GS, subscription" do
	incoming = File.read!("test/fixtures/incoming_websub_gnusocial_attachments.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["attachment"] \|> length == 2
	assert activity.data["object"]["external_url"] == "https://social.heldscal.la/notice/2020923"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes with tags" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post_tag.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["object"]["tag"] == ["nsfw"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes - Mastodon, salmon, reply" do
	# It uses the context of the replied to object
	Repo.insert!(%Object{
	data: %{
	"id" => "https://pleroma.soykaf.com/objects/c237d966-ac75-4fe3-a87a-d89d71a3a7a4",
	"context" => "2hu"
	}
	})

	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["context"] == "2hu"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes - Mastodon, with CW" do
	incoming = File.read!("test/fixtures/mastodon-note-cw.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["object"]["summary"] == "technologic"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming unlisted messages, put public into cc" do
	incoming = File.read!("test/fixtures/mastodon-note-unlisted.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	refute "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["cc"]
	refute "https://www.w3.org/ns/activitystreams#Public" in activity.data["object"]["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["object"]["cc"]
	end

	test "handle incoming retweets - Mastodon, with CW" do
	incoming = File.read!("test/fixtures/cw_retweet.xml")
	{:ok, [[_activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert retweeted_activity.data["object"]["summary"] == "Hey."
	end

	test "handle incoming notes - GS, subscription, reply" do
	incoming = File.read!("test/fixtures/ostatus_incoming_reply.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"

	assert activity.data["object"]["content"] ==
	"@<a href=\"https://gs.archae.me/user/4687\" class=\"h-card u-url p-nickname mention\" title=\"shpbot\">shpbot</a> why not indeed."

	assert activity.data["object"]["inReplyTo"] ==
	"tag:gs.archae.me,2017-04-30:noticeId=778260:objectType=note"

	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming retweets - GS, subscription" do
	incoming = File.read!("test/fixtures/share-gs.xml")
	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	assert "https://pleroma.soykaf.com/users/lain" in activity.data["to"]
	refute activity.local

	retweeted_activity = Repo.get(Activity, retweeted_activity.id)
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == "https://pleroma.soykaf.com/users/lain"
	refute retweeted_activity.local
	assert retweeted_activity.data["object"]["announcement_count"] == 1
	assert String.contains?(retweeted_activity.data["object"]["content"], "mastodon")
	refute String.contains?(retweeted_activity.data["object"]["content"], "Test account")
	end

	test "handle incoming retweets - GS, subscription - local message" do
	incoming = File.read!("test/fixtures/share-gs-local.xml")
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	incoming =
	incoming
	\|> String.replace("LOCAL_ID", note_activity.data["object"]["id"])
	\|> String.replace("LOCAL_USER", user.ap_id)

	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	assert user.ap_id in activity.data["to"]
	refute activity.local

	retweeted_activity = Repo.get(Activity, retweeted_activity.id)
	assert note_activity.id == retweeted_activity.id
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == user.ap_id
	assert retweeted_activity.local
	assert retweeted_activity.data["object"]["announcement_count"] == 1
	end

	test "handle incoming retweets - Mastodon, salmon" do
	incoming = File.read!("test/fixtures/share.xml")
	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]

	assert activity.data["id"] ==
	"tag:mastodon.social,2017-05-03:objectId=4934452:objectType=Status"

	refute activity.local
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == "https://pleroma.soykaf.com/users/lain"
	refute retweeted_activity.local
	refute String.contains?(retweeted_activity.data["object"]["content"], "Test account")
	end

	test "handle incoming favorites - GS, websub" do
	capture_log(fn ->
	incoming = File.read!("test/fixtures/favorite.xml")
	{:ok, [[activity, favorited_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == favorited_activity.data["object"]["id"]

	assert activity.data["id"] ==
	"tag:social.heldscal.la,2017-05-05:fave:23211:comment:2061643:2017-05-05T09:12:50+00:00"

	refute activity.local
	assert favorited_activity.data["type"] == "Create"
	assert favorited_activity.data["actor"] == "https://shitposter.club/user/1"

	assert favorited_activity.data["object"]["id"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"

	refute favorited_activity.local
	end)
	end

	test "handle conversation references" do
	incoming = File.read!("test/fixtures/mastodon_conversation.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["context"] ==
	"tag:mastodon.social,2017-08-28:objectId=7876885:objectType=Conversation"
	end

	test "handle incoming favorites with locally available object - GS, websub" do
	note_activity = insert(:note_activity)

	incoming =
	File.read!("test/fixtures/favorite_with_local_note.xml")
	\|> String.replace("localid", note_activity.data["object"]["id"])

	{:ok, [[activity, favorited_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == favorited_activity.data["object"]["id"]
	refute activity.local
	assert note_activity.id == favorited_activity.id
	assert favorited_activity.local
	end

	test "handle incoming replies" do
	incoming = File.read!("test/fixtures/incoming_note_activity_answer.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"

	assert activity.data["object"]["inReplyTo"] ==
	"http://pleroma.example.org:4000/objects/55bce8fc-b423-46b1-af71-3759ab4670bc"

	assert "http://pleroma.example.org:4000/users/lain5" in activity.data["to"]

	assert activity.data["object"]["id"] ==
	"tag:gs.example.org:4040,2017-04-25:noticeId=55:objectType=note"

	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming follows" do
	incoming = File.read!("test/fixtures/follow.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert activity.data["type"] == "Follow"

	assert activity.data["id"] ==
	"tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"

	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == "https://pawoo.net/users/pekorino"
	refute activity.local

	follower = User.get_by_ap_id(activity.data["actor"])
	followed = User.get_by_ap_id(activity.data["object"])

	assert User.following?(follower, followed)
	end

	test "handle incoming unfollows with existing follow" do
	incoming_follow = File.read!("test/fixtures/follow.xml")
	{:ok, [_activity]} = OStatus.handle_incoming(incoming_follow)

	incoming = File.read!("test/fixtures/unfollow.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Undo"

	assert activity.data["id"] ==
	"undo:tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"

	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Follow"
	assert activity.data["object"]["object"] == "https://pawoo.net/users/pekorino"
	refute activity.local

	follower = User.get_by_ap_id(activity.data["actor"])
	followed = User.get_by_ap_id(activity.data["object"]["object"])

	refute User.following?(follower, followed)
	end

	describe "new remote user creation" do
	test "returns local users" do
	local_user = insert(:user)
	{:ok, user} = OStatus.find_or_make_user(local_user.ap_id)

	assert user == local_user
	end

	test "tries to use the information in poco fields" do
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)

	user = Repo.get(Pleroma.User, user.id)
	assert user.name == "Constance Variable"
	assert user.nickname == "lambadalambda@social.heldscal.la"
	assert user.local == false
	assert user.info.uri == uri
	assert user.ap_id == uri
	assert user.bio == "Call me Deacon Blues."
	assert user.avatar["type"] == "Image"

	{:ok, user_again} = OStatus.find_or_make_user(uri)

	assert user == user_again
	end

	test "find_make_or_update_user takes an author element and returns an updated user" do
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)
	old_name = user.name
	old_bio = user.bio
	change = Ecto.Changeset.change(user, %{avatar: nil, bio: nil, old_name: nil})

	{:ok, user} = Repo.update(change)
	refute user.avatar

	doc = XML.parse_document(File.read!("test/fixtures/23211.atom"))
	[author] = :xmerl_xpath.string('//author[1]', doc)
	{:ok, user} = OStatus.find_make_or_update_user(author)
	assert user.avatar["type"] == "Image"
	assert user.name == old_name
	assert user.bio == old_bio

	{:ok, user_again} = OStatus.find_make_or_update_user(author)
	assert user_again == user
	end
	end

	describe "gathering user info from a user id" do
	test "it returns user info in a hash" do
	user = "shp@social.heldscal.la"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	"hub" => "https://social.heldscal.la/main/push/hub",
	"magic_key" =>
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	"name" => "shp",
	"nickname" => "shp",
	"salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	"subject" => "acct:shp@social.heldscal.la",
	"topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	"uri" => "https://social.heldscal.la/user/29191",
	"host" => "social.heldscal.la",
	"fqn" => user,
	"bio" => "cofe",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	},
	"subscribe_address" => "https://social.heldscal.la/main/ostatussub?profile={uri}",
	"ap_id" => nil
	}

	assert data == expected
	end

	test "it works with the uri" do
	user = "https://social.heldscal.la/user/29191"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	"hub" => "https://social.heldscal.la/main/push/hub",
	"magic_key" =>
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	"name" => "shp",
	"nickname" => "shp",
	"salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	"subject" => "https://social.heldscal.la/user/29191",
	"topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	"uri" => "https://social.heldscal.la/user/29191",
	"host" => "social.heldscal.la",
	"fqn" => user,
	"bio" => "cofe",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	},
	"subscribe_address" => "https://social.heldscal.la/main/ostatussub?profile={uri}",
	"ap_id" => nil
	}

	assert data == expected
	end
	end

	describe "fetching a status by it's HTML url" do
	test "it builds a missing status from an html url" do
	capture_log(fn ->
	url = "https://shitposter.club/notice/2827873"
	{:ok, [activity]} = OStatus.fetch_activity_from_url(url)

	assert activity.data["actor"] == "https://shitposter.club/user/1"

	assert activity.data["object"]["id"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

	test "it works for atom notes, too" do
	url = "https://social.sakamoto.gq/objects/0ccc1a2c-66b0-4305-b23a-7f7f2b040056"
	{:ok, [activity]} = OStatus.fetch_activity_from_url(url)
	assert activity.data["actor"] == "https://social.sakamoto.gq/users/eal"
	assert activity.data["object"]["id"] == url
	end
	end

	- test "it doesn't add nil in the do field" do
	+ test "it doesn't add nil in the to field" do
	incoming = File.read!("test/fixtures/nil_mention_entry.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["to"] == [
	"http://localhost:4001/users/atarifrosch@social.stopwatchingus-heidelberg.de/followers",
	"https://www.w3.org/ns/activitystreams#Public"
	]
	end

	describe "is_representable?" do
	test "Note objects are representable" do
	note_activity = insert(:note_activity)

	assert OStatus.is_representable?(note_activity)
	end

	test "Article objects are not representable" do
	note_activity = insert(:note_activity)

	note_object = Object.normalize(note_activity.data["object"])

	note_data =
	note_object.data
	\|> Map.put("type", "Article")

	cs = Object.change(note_object, %{data: note_data})
	{:ok, article_object} = Repo.update(cs)

	# the underlying object is now an Article instead of a note, so this should fail
	refute OStatus.is_representable?(note_activity)
	end
	end
	end
	diff --git a/test/web/twitter_api/views/user_view_test.exs b/test/web/twitter_api/views/user_view_test.exs
	index 2c583c0d3..e69ca24a9 100644
	--- a/test/web/twitter_api/views/user_view_test.exs
	+++ b/test/web/twitter_api/views/user_view_test.exs
	@@ -1,263 +1,263 @@
	defmodule Pleroma.Web.TwitterAPI.UserViewTest do
	use Pleroma.DataCase

	alias Pleroma.User
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Builders.UserBuilder

	import Pleroma.Factory

	setup do
	user = insert(:user, bio: "<span>Here's some html</span>")
	[user: user]
	end

	test "A user with only a nickname", %{user: user} do
	user = %{user \| name: nil, nickname: "scarlett@catgirl.science"}
	represented = UserView.render("show.json", %{user: user})
	assert represented["name"] == user.nickname
	assert represented["name_html"] == user.nickname
	end

	test "A user with an avatar object", %{user: user} do
	image = "image"
	user = %{user \| avatar: %{"url" => [%{"href" => image}]}}
	represented = UserView.render("show.json", %{user: user})
	assert represented["profile_image_url"] == image
	end

	test "A user with emoji in username", %{user: user} do
	expected =
	"<img height=\"32px\" width=\"32px\" alt=\"karjalanpiirakka\" title=\"karjalanpiirakka\" src=\"/file.png\" /> man"

	- user = %{
	- user
	- \| info: %{
	- "source_data" => %{
	+ user =
	+ insert(:user, %{
	+ info: %{
	+ source_data: %{
	"tag" => [
	%{
	"type" => "Emoji",
	"icon" => %{"url" => "/file.png"},
	"name" => ":karjalanpiirakka:"
	}
	]
	}
	- }
	- }
	+ },
	+ name: ":karjalanpiirakka: man"
	+ })

	- user = %{user \| name: ":karjalanpiirakka: man"}
	represented = UserView.render("show.json", %{user: user})
	assert represented["name_html"] == expected
	end

	test "A user" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	{:ok, user} = User.update_note_count(user)
	follower = insert(:user)
	second_follower = insert(:user)

	User.follow(follower, user)
	User.follow(second_follower, user)
	User.follow(user, follower)
	{:ok, user} = User.update_follower_count(user)
	Cachex.put(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))

	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"name_html" => user.name,
	"description" => HtmlSanitizeEx.strip_tags(user.bio \|> String.replace("<br>", "\n")),
	"description_html" => HtmlSanitizeEx.basic_html(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 1,
	"friends_count" => 1,
	"followers_count" => 2,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => false,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true,
	"locked" => false,
	"default_scope" => "public",
	"no_rich_text" => false,
	"fields" => []
	}

	assert represented == UserView.render("show.json", %{user: user})
	end

	test "A user for a given other follower", %{user: user} do
	- {:ok, follower} = UserBuilder.insert(%{following: [User.ap_followers(user)]})
	+ follower = insert(:user, %{following: [User.ap_followers(user)]})
	{:ok, user} = User.update_follower_count(user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"name_html" => user.name,
	"description" => HtmlSanitizeEx.strip_tags(user.bio \|> String.replace("<br>", "\n")),
	"description_html" => HtmlSanitizeEx.basic_html(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 0,
	"followers_count" => 1,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => true,
	"follows_you" => false,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true,
	"locked" => false,
	"default_scope" => "public",
	"no_rich_text" => false,
	"fields" => []
	}

	assert represented == UserView.render("show.json", %{user: user, for: follower})
	end

	test "A user that follows you", %{user: user} do
	follower = insert(:user)
	{:ok, follower} = User.follow(follower, user)
	{:ok, user} = User.update_follower_count(user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => follower.id,
	"name" => follower.name,
	"screen_name" => follower.nickname,
	"name_html" => follower.name,
	"description" => HtmlSanitizeEx.strip_tags(follower.bio \|> String.replace("<br>", "\n")),
	"description_html" => HtmlSanitizeEx.basic_html(follower.bio),
	"created_at" => follower.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 1,
	"followers_count" => 0,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => true,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => follower.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true,
	"locked" => false,
	"default_scope" => "public",
	"no_rich_text" => false,
	"fields" => []
	}

	assert represented == UserView.render("show.json", %{user: follower, for: user})
	end

	test "a user that is a moderator" do
	- user = insert(:user, %{info: %{"is_moderator" => true}})
	+ user = insert(:user, %{info: %{is_moderator: true}})
	represented = UserView.render("show.json", %{user: user, for: user})

	assert represented["rights"]["delete_others_notice"]
	end

	test "A blocked user for the blocker" do
	user = insert(:user)
	blocker = insert(:user)
	User.block(blocker, user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"name_html" => user.name,
	"description" => HtmlSanitizeEx.strip_tags(user.bio \|> String.replace("<br>", "\n")),
	"description_html" => HtmlSanitizeEx.basic_html(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 0,
	"followers_count" => 0,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => false,
	"statusnet_blocking" => true,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true,
	"locked" => false,
	"default_scope" => "public",
	"no_rich_text" => false,
	"fields" => []
	}

	blocker = Repo.get(User, blocker.id)
	assert represented == UserView.render("show.json", %{user: user, for: blocker})
	end

	test "a user with mastodon fields" do
	fields = [
	%{
	"name" => "Pronouns",
	"value" => "she/her"
	},
	%{
	"name" => "Website",
	"value" => "https://example.org/"
	}
	]

	user =
	insert(:user, %{
	info: %{
	- "source_data" => %{
	+ source_data: %{
	"attachment" =>
	Enum.map(fields, fn field -> Map.put(field, "type", "PropertyValue") end)
	}
	}
	})

	userview = UserView.render("show.json", %{user: user})
	assert userview["fields"] == fields
	end
	end
	diff --git a/test/web/websub/websub_test.exs b/test/web/websub/websub_test.exs
	index 5914a37fc..da7bc9112 100644
	--- a/test/web/websub/websub_test.exs
	+++ b/test/web/websub/websub_test.exs
	@@ -1,228 +1,228 @@
	defmodule Pleroma.Web.WebsubMock do
	def verify(sub) do
	{:ok, sub}
	end
	end

	defmodule Pleroma.Web.WebsubTest do
	use Pleroma.DataCase
	alias Pleroma.Web.Websub
	alias Pleroma.Web.Websub.{WebsubServerSubscription, WebsubClientSubscription}
	import Pleroma.Factory
	alias Pleroma.Web.Router.Helpers

	test "a verification of a request that is accepted" do
	sub = insert(:websub_subscription)
	topic = sub.topic

	getter = fn _path, _headers, options ->
	%{
	"hub.challenge": challenge,
	"hub.lease_seconds": seconds,
	"hub.topic": ^topic,
	"hub.mode": "subscribe"
	} = Keyword.get(options, :params)

	assert String.to_integer(seconds) > 0

	{:ok,
	%HTTPoison.Response{
	status_code: 200,
	body: challenge
	}}
	end

	{:ok, sub} = Websub.verify(sub, getter)
	assert sub.state == "active"
	end

	test "a verification of a request that doesn't return 200" do
	sub = insert(:websub_subscription)

	getter = fn _path, _headers, _options ->
	{:ok,
	%HTTPoison.Response{
	status_code: 500,
	body: ""
	}}
	end

	{:error, sub} = Websub.verify(sub, getter)
	# Keep the current state.
	assert sub.state == "requested"
	end

	test "an incoming subscription request" do
	user = insert(:user)

	data = %{
	"hub.callback" => "http://example.org/sub",
	"hub.mode" => "subscribe",
	"hub.topic" => Pleroma.Web.OStatus.feed_path(user),
	"hub.secret" => "a random secret",
	"hub.lease_seconds" => "100"
	}

	{:ok, subscription} = Websub.incoming_subscription_request(user, data)
	assert subscription.topic == Pleroma.Web.OStatus.feed_path(user)
	assert subscription.state == "requested"
	assert subscription.secret == "a random secret"
	assert subscription.callback == "http://example.org/sub"
	end

	test "an incoming subscription request for an existing subscription" do
	user = insert(:user)

	sub =
	insert(:websub_subscription, state: "accepted", topic: Pleroma.Web.OStatus.feed_path(user))

	data = %{
	"hub.callback" => sub.callback,
	"hub.mode" => "subscribe",
	"hub.topic" => Pleroma.Web.OStatus.feed_path(user),
	"hub.secret" => "a random secret",
	"hub.lease_seconds" => "100"
	}

	{:ok, subscription} = Websub.incoming_subscription_request(user, data)
	assert subscription.topic == Pleroma.Web.OStatus.feed_path(user)
	assert subscription.state == sub.state
	assert subscription.secret == "a random secret"
	assert subscription.callback == sub.callback
	assert length(Repo.all(WebsubServerSubscription)) == 1
	assert subscription.id == sub.id
	end

	def accepting_verifier(subscription) do
	{:ok, %{subscription \| state: "accepted"}}
	end

	test "initiate a subscription for a given user and topic" do
	subscriber = insert(:user)
	- user = insert(:user, %{info: %{"topic" => "some_topic", "hub" => "some_hub"}})
	+ user = insert(:user, %{info: %Pleroma.User.Info{topic: "some_topic", hub: "some_hub"}})

	{:ok, websub} = Websub.subscribe(subscriber, user, &accepting_verifier/1)
	assert websub.subscribers == [subscriber.ap_id]
	assert websub.topic == "some_topic"
	assert websub.hub == "some_hub"
	assert is_binary(websub.secret)
	assert websub.user == user
	assert websub.state == "accepted"
	end

	test "discovers the hub and canonical url" do
	topic = "https://mastodon.social/users/lambadalambda.atom"

	getter = fn ^topic ->
	doc = File.read!("test/fixtures/lambadalambda.atom")
	{:ok, %{status_code: 200, body: doc}}
	end

	{:ok, discovered} = Websub.gather_feed_data(topic, getter)

	expected = %{
	"hub" => "https://mastodon.social/api/push",
	"uri" => "https://mastodon.social/users/lambadalambda",
	"nickname" => "lambadalambda",
	"name" => "Critical Value",
	"host" => "mastodon.social",
	"bio" => "a cool dude.",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" =>
	"https://files.mastodon.social/accounts/avatars/000/000/264/original/1429214160519.gif?1492379244",
	"mediaType" => "image/gif",
	"type" => "Link"
	}
	]
	}
	}

	assert expected == discovered
	end

	test "calls the hub, requests topic" do
	hub = "https://social.heldscal.la/main/push/hub"
	topic = "https://social.heldscal.la/api/statuses/user_timeline/23211.atom"
	websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})

	poster = fn ^hub, {:form, data}, _headers ->
	assert Keyword.get(data, :"hub.mode") == "subscribe"

	assert Keyword.get(data, :"hub.callback") ==
	Helpers.websub_url(
	Pleroma.Web.Endpoint,
	:websub_subscription_confirmation,
	websub.id
	)

	{:ok, %{status_code: 202}}
	end

	task = Task.async(fn -> Websub.request_subscription(websub, poster) end)

	change = Ecto.Changeset.change(websub, %{state: "accepted"})
	{:ok, _} = Repo.update(change)

	{:ok, websub} = Task.await(task)

	assert websub.state == "accepted"
	end

	test "rejects the subscription if it can't be accepted" do
	hub = "https://social.heldscal.la/main/push/hub"
	topic = "https://social.heldscal.la/api/statuses/user_timeline/23211.atom"
	websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})

	poster = fn ^hub, {:form, _data}, _headers ->
	{:ok, %{status_code: 202}}
	end

	{:error, websub} = Websub.request_subscription(websub, poster, 1000)
	assert websub.state == "rejected"

	websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})

	poster = fn ^hub, {:form, _data}, _headers ->
	{:ok, %{status_code: 400}}
	end

	{:error, websub} = Websub.request_subscription(websub, poster, 1000)
	assert websub.state == "rejected"
	end

	test "sign a text" do
	signed = Websub.sign("secret", "text")
	assert signed == "B8392C23690CCF871F37EC270BE1582DEC57A503" \|> String.downcase()

	_signed = Websub.sign("secret", [["て"], ['す']])
	end

	describe "renewing subscriptions" do
	test "it renews subscriptions that have less than a day of time left" do
	day = 60 * 60 * 24
	now = NaiveDateTime.utc_now()

	still_good =
	insert(:websub_client_subscription, %{
	valid_until: NaiveDateTime.add(now, 2 * day),
	topic: "http://example.org/still_good",
	state: "accepted"
	})

	needs_refresh =
	insert(:websub_client_subscription, %{
	valid_until: NaiveDateTime.add(now, day - 100),
	topic: "http://example.org/needs_refresh",
	state: "accepted"
	})

	_refresh = Websub.refresh_subscriptions()

	assert still_good == Repo.get(WebsubClientSubscription, still_good.id)
	refute needs_refresh == Repo.get(WebsubClientSubscription, needs_refresh.id)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 4, 6:42 PM (1 d, 2 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1539175
Default Alt Text: (47 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions