No OneTemporary
Actions

Authored By

Unknown

Size

46 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/web/activity_pub/utils_test.exs b/test/web/activity_pub/utils_test.exs
	index eb429b2c4..9b6403803 100644
	--- a/test/web/activity_pub/utils_test.exs
	+++ b/test/web/activity_pub/utils_test.exs
	@@ -1,404 +1,406 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.UtilsTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = User.get_cached_by_ap_id(activity.data["actor"])
	followed = User.get_cached_by_ap_id(activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "fetch the latest Block" do
	test "fetches the latest Block activity" do
	blocker = insert(:user)
	blocked = insert(:user)
	{:ok, activity} = ActivityPub.block(blocker, blocked)

	assert activity == Utils.fetch_latest_block(blocker, blocked)
	end
	end

	describe "determine_explicit_mentions()" do
	test "works with an object that has mentions" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that does not have mentions" do
	object = %{
	"tag" => [
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has mentions and other tags" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	},
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that has no tags" do
	object = %{}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has only IR tags" do
	object = %{"tag" => ["2hu"]}

	assert Utils.determine_explicit_mentions(object) == []
	end
	end

	describe "make_unlike_data/3" do
	test "returns data for unlike activity" do
	user = insert(:user)
	like_activity = insert(:like_activity, data_attrs: %{"context" => "test context"})

	assert Utils.make_unlike_data(user, like_activity, nil) == %{
	"type" => "Undo",
	"actor" => user.ap_id,
	"object" => like_activity.data,
	"to" => [user.follower_address, like_activity.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => like_activity.data["context"]
	}

	assert Utils.make_unlike_data(user, like_activity, "9mJEZK0tky1w2xD2vY") == %{
	"type" => "Undo",
	"actor" => user.ap_id,
	"object" => like_activity.data,
	"to" => [user.follower_address, like_activity.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => like_activity.data["context"],
	"id" => "9mJEZK0tky1w2xD2vY"
	}
	end
	end

	describe "make_like_data" do
	setup do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	[user: user, other_user: other_user, third_user: third_user]
	end

	test "addresses actor's follower address if the activity is public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id, other_user.follower_address])
	expected_cc = Enum.sort(["https://www.w3.org/ns/activitystreams#Public", third_user.ap_id])

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end

	test "does not adress actor's follower address if the activity is not public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id])
	expected_cc = [third_user.ap_id]

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
	"visibility" => "private"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end
	end

	describe "fetch_ordered_collection" do
	import Tesla.Mock

	test "fetches the first OrderedCollectionPage when an OrderedCollection is encountered" do
	mock(fn
	%{method: :get, url: "http://mastodon.com/outbox"} ->
	json(%{"type" => "OrderedCollection", "first" => "http://mastodon.com/outbox?page=true"})

	%{method: :get, url: "http://mastodon.com/outbox?page=true"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => ["ok"]})
	end)

	assert Utils.fetch_ordered_collection("http://mastodon.com/outbox", 1) == ["ok"]
	end

	test "fetches several pages in the right order one after another, but only the specified amount" do
	mock(fn
	%{method: :get, url: "http://example.com/outbox"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [0],
	"next" => "http://example.com/outbox?page=1"
	})

	%{method: :get, url: "http://example.com/outbox?page=1"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [1],
	"next" => "http://example.com/outbox?page=2"
	})

	%{method: :get, url: "http://example.com/outbox?page=2"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => [2]})
	end)

	assert Utils.fetch_ordered_collection("http://example.com/outbox", 0) == [0]
	assert Utils.fetch_ordered_collection("http://example.com/outbox", 1) == [0, 1]
	end

	test "returns an error if the url doesn't have an OrderedCollection/Page" do
	mock(fn
	%{method: :get, url: "http://example.com/not-an-outbox"} ->
	json(%{"type" => "NotAnOutbox"})
	end)

	assert {:error, _} = Utils.fetch_ordered_collection("http://example.com/not-an-outbox", 1)
	end

	test "returns the what was collected if there are less pages than specified" do
	mock(fn
	%{method: :get, url: "http://example.com/outbox"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [0],
	"next" => "http://example.com/outbox?page=1"
	})

	%{method: :get, url: "http://example.com/outbox?page=1"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => [1]})
	end)

	assert Utils.fetch_ordered_collection("http://example.com/outbox", 5) == [0, 1]
	end
	end

	test "make_json_ld_header/0" do
	assert Utils.make_json_ld_header() == %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{
	- "@language" => "und"
	+ "@language" => "und",
	+ "discoverable" => "mastodon:discoverable",
	+ "mastodon" => "http://joinmastodon.org/ns#"
	}
	]
	}
	end

	describe "get_existing_votes" do
	test "fetches existing votes" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "How do I pronounce LaTeX?",
	"poll" => %{
	"options" => ["laytekh", "lahtekh", "latex"],
	"expires_in" => 20,
	"multiple" => true
	}
	})

	object = Object.normalize(activity)
	{:ok, votes, object} = CommonAPI.vote(other_user, object, [0, 1])
	assert Enum.sort(Utils.get_existing_votes(other_user.ap_id, object)) == Enum.sort(votes)
	end

	test "fetches only Create activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Are we living in a society?",
	"poll" => %{
	"options" => ["yes", "no"],
	"expires_in" => 20
	}
	})

	object = Object.normalize(activity)
	{:ok, [vote], object} = CommonAPI.vote(other_user, object, [0])
	vote_object = Object.normalize(vote)
	{:ok, _activity, _object} = ActivityPub.like(user, vote_object)
	[fetched_vote] = Utils.get_existing_votes(other_user.ap_id, object)
	assert fetched_vote.id == vote.id
	end
	end

	describe "update_follow_state_for_all/2" do
	test "updates the state of all Follow activities with the same actor and object" do
	user = insert(:user, info: %{locked: true})
	follower = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "accept")

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	end
	end

	describe "update_follow_state/2" do
	test "updates the state of the given follow activity" do
	user = insert(:user, info: %{locked: true})
	follower = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} = Utils.update_follow_state(follow_activity_two, "reject")

	assert Repo.get(Activity, follow_activity.id).data["state"] == "pending"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	end
	end

	describe "update_element_in_object/3" do
	test "updates likes" do
	user = insert(:user)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	assert {:ok, updated_object} =
	Utils.update_element_in_object(
	"like",
	[user.ap_id],
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "add_like_to_object/2" do
	test "add actor to likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note)

	assert {:ok, updated_object} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1

	assert {:ok, updated_object2} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user2.ap_id}},
	updated_object
	)

	assert updated_object2.data["likes"] == [user2.ap_id, user.ap_id]
	assert updated_object2.data["like_count"] == 2
	end
	end

	describe "remove_like_from_object/2" do
	test "removes ap_id from likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note, data: %{"likes" => [user.ap_id, user2.ap_id], "like_count" => 2})

	assert {:ok, updated_object} =
	Utils.remove_like_from_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user2.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "get_existing_like/2" do
	test "fetches existing like" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity)

	user = insert(:user)
	refute Utils.get_existing_like(user.ap_id, object)
	{:ok, like_activity, _object} = ActivityPub.like(user, object)

	assert ^like_activity = Utils.get_existing_like(user.ap_id, object)
	end
	end
	end
	diff --git a/test/web/mastodon_api/views/account_view_test.exs b/test/web/mastodon_api/views/account_view_test.exs
	index 1d8b28339..419d5340b 100644
	--- a/test/web/mastodon_api/views/account_view_test.exs
	+++ b/test/web/mastodon_api/views/account_view_test.exs
	@@ -1,389 +1,392 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView

	test "Represent a user account" do
	source_data = %{
	"tag" => [
	%{
	"type" => "Emoji",
	"icon" => %{"url" => "/file.png"},
	"name" => ":karjalanpiirakka:"
	}
	]
	}

	background_image = %{
	"url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
	}

	user =
	insert(:user, %{
	info: %{
	note_count: 5,
	follower_count: 3,
	source_data: source_data,
	background: background_image
	},
	nickname: "shp@shitposter.club",
	name: ":karjalanpiirakka: shp",
	bio: "<script src=\"invalid-html\"></script><span>valid html</span>",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: "<span>valid html</span>",
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [
	%{
	"static_url" => "/file.png",
	"url" => "/file.png",
	"shortcode" => "karjalanpiirakka",
	"visible_in_picker" => false
	}
	],
	fields: [],
	bot: false,
	+ discoverable: false,
	source: %{
	note: "valid html",
	sensitive: false,
	pleroma: %{},
	fields: []
	},
	pleroma: %{
	background_image: "https://example.com/images/asuka_hospital.png",
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("account.json", %{user: user})
	end

	test "Represent the user account for the account owner" do
	user = insert(:user)

	notification_settings = %{
	"followers" => true,
	"follows" => true,
	"non_follows" => true,
	"non_followers" => true
	}

	privacy = user.info.default_scope

	assert %{
	pleroma: %{notification_settings: ^notification_settings},
	source: %{privacy: ^privacy}
	} = AccountView.render("account.json", %{user: user, for: user})
	end

	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 3, source_data: %{"type" => "Service"}},
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	+ discoverable: false,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{},
	fields: []
	},
	pleroma: %{
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("account.json", %{user: user})
	end

	test "Represent a deactivated user for an admin" do
	admin = insert(:user, %{info: %{is_admin: true}})
	deactivated_user = insert(:user, %{info: %{deactivated: true}})
	represented = AccountView.render("account.json", %{user: deactivated_user, for: admin})
	assert represented[:pleroma][:deactivated] == true
	end

	test "Represent a smaller mention" do
	user = insert(:user)

	expected = %{
	id: to_string(user.id),
	acct: user.nickname,
	username: user.nickname,
	url: user.ap_id
	}

	assert expected == AccountView.render("mention.json", %{user: user})
	end

	describe "relationship" do
	test "represent a relationship for the following and followed user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, other_user} = User.subscribe(user, other_user)
	{:ok, user} = User.mute(user, other_user, true)
	{:ok, user} = CommonAPI.hide_reblogs(user, other_user)

	expected = %{
	id: to_string(other_user.id),
	following: true,
	followed_by: true,
	blocking: false,
	blocked_by: false,
	muting: true,
	muting_notifications: true,
	subscribing: true,
	requested: false,
	domain_blocking: false,
	showing_reblogs: false,
	endorsed: false
	}

	assert expected ==
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent a relationship for the blocking and blocked user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, other_user} = User.subscribe(user, other_user)
	{:ok, user} = User.block(user, other_user)
	{:ok, other_user} = User.block(other_user, user)

	expected = %{
	id: to_string(other_user.id),
	following: false,
	followed_by: false,
	blocking: true,
	blocked_by: true,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	assert expected ==
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent a relationship for the user blocking a domain" do
	user = insert(:user)
	other_user = insert(:user, ap_id: "https://bad.site/users/other_user")

	{:ok, user} = User.block_domain(user, "bad.site")

	assert %{domain_blocking: true, blocking: false} =
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent a relationship for the user with a pending follow request" do
	user = insert(:user)
	other_user = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	expected = %{
	id: to_string(other_user.id),
	following: false,
	followed_by: false,
	blocking: false,
	blocked_by: false,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	requested: true,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	assert expected ==
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end
	end

	test "represent an embedded relationship" do
	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 0, source_data: %{"type" => "Service"}},
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	other_user = insert(:user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, other_user} = User.block(other_user, user)
	{:ok, _} = User.follow(insert(:user), user)

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 1,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	+ discoverable: false,
	bot: true,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{},
	fields: []
	},
	pleroma: %{
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	relationship: %{
	id: to_string(user.id),
	following: false,
	followed_by: false,
	blocking: true,
	blocked_by: false,
	subscribing: false,
	muting: false,
	muting_notifications: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("account.json", %{user: user, for: other_user})
	end

	test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
	user = insert(:user, %{info: %User.Info{pleroma_settings_store: %{fe: "test"}}})

	result =
	AccountView.render("account.json", %{user: user, for: user, with_pleroma_settings: true})

	assert result.pleroma.settings_store == %{:fe => "test"}

	result = AccountView.render("account.json", %{user: user, with_pleroma_settings: true})
	assert result.pleroma[:settings_store] == nil

	result = AccountView.render("account.json", %{user: user, for: user})
	assert result.pleroma[:settings_store] == nil
	end

	test "sanitizes display names" do
	user = insert(:user, name: "<marquee> username </marquee>")
	result = AccountView.render("account.json", %{user: user})
	refute result.display_name == "<marquee> username </marquee>"
	end

	describe "hiding follows/following" do
	test "shows when follows/following are hidden and sets follower/following count to 0" do
	user = insert(:user, info: %{hide_followers: true, hide_follows: true})
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 0,
	following_count: 0,
	pleroma: %{hide_follows: true, hide_followers: true}
	} = AccountView.render("account.json", %{user: user})
	end

	test "shows actual follower/following count to the account owner" do
	user = insert(:user, info: %{hide_followers: true, hide_follows: true})
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1
	} = AccountView.render("account.json", %{user: user, for: user})
	end
	end
	end
	diff --git a/test/web/ostatus/ostatus_controller_test.exs b/test/web/ostatus/ostatus_controller_test.exs
	index 095ae7041..3b2062b0d 100644
	--- a/test/web/ostatus/ostatus_controller_test.exs
	+++ b/test/web/ostatus/ostatus_controller_test.exs
	@@ -1,635 +1,643 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.OStatusControllerTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OStatus.ActivityRepresenter

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

	clear_config_all([:instance, :federating]) do
	Pleroma.Config.put([:instance, :federating], true)
	end

	describe "salmon_incoming" do
	test "decodes a salmon", %{conn: conn} do
	user = insert(:user)
	salmon = File.read!("test/fixtures/salmon.xml")

	assert capture_log(fn ->
	conn =
	conn
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/users/#{user.nickname}/salmon", salmon)

	assert response(conn, 200)
	end) =~ "[error]"
	end

	test "decodes a salmon with a changed magic key", %{conn: conn} do
	user = insert(:user)
	salmon = File.read!("test/fixtures/salmon.xml")

	assert capture_log(fn ->
	conn =
	conn
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/users/#{user.nickname}/salmon", salmon)

	assert response(conn, 200)
	end) =~ "[error]"

	# Set a wrong magic-key for a user so it has to refetch
	salmon_user = User.get_cached_by_ap_id("http://gs.example.org:4040/index.php/user/1")

	# Wrong key
	info_cng =
	User.Info.remote_user_creation(salmon_user.info, %{
	magic_key:
	"RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwrong1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"
	})

	salmon_user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, info_cng)
	\|> User.update_and_set_cache()

	assert capture_log(fn ->
	conn =
	build_conn()
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/users/#{user.nickname}/salmon", salmon)

	assert response(conn, 200)
	end) =~ "[error]"
	end
	end

	test "gets a feed", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("content-type", "application/atom+xml")
	\|> get("/users/#{user.nickname}/feed.atom")

	assert response(conn, 200) =~ object.data["content"]
	end

	test "returns 404 for a missing feed", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/atom+xml")
	\|> get("/users/nonexisting/feed.atom")

	assert response(conn, 404)
	end

	describe "GET object/2" do
	test "gets an object", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))
	url = "/objects/#{uuid}"

	conn =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get(url)

	expected =
	ActivityRepresenter.to_simple_form(note_activity, user, true)
	\|> ActivityRepresenter.wrap_with_entry()
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	assert response(conn, 200) == expected
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))
	url = "/objects/#{uuid}"

	conn =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get(url)

	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "500s when user not found", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	User.invalidate_cache(user)
	Pleroma.Repo.delete(user)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))
	url = "/objects/#{uuid}"

	conn =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get(url)

	assert response(conn, 500) == ~S({"error":"Something went wrong"})
	end

	test "404s on private objects", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	object = Object.normalize(note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))

	conn
	\|> get("/objects/#{uuid}")
	\|> response(404)
	end

	test "404s on nonexisting objects", %{conn: conn} do
	conn
	\|> get("/objects/123")
	\|> response(404)
	end
	end

	describe "GET activity/2" do
	test "gets an activity in xml format", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/activities/#{uuid}")
	\|> response(200)
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/activities/#{uuid}")

	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "505s when user not found", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	User.invalidate_cache(user)
	Pleroma.Repo.delete(user)

	conn =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/activities/#{uuid}")

	assert response(conn, 500) == ~S({"error":"Something went wrong"})
	end

	test "404s on deleted objects", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))

	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/objects/#{uuid}")
	\|> response(200)

	Object.delete(object)

	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/objects/#{uuid}")
	\|> response(404)
	end

	test "404s on private activities", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn
	\|> get("/activities/#{uuid}")
	\|> response(404)
	end

	test "404s on nonexistent activities", %{conn: conn} do
	conn
	\|> get("/activities/123")
	\|> response(404)
	end

	test "gets an activity in AS2 format", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))
	url = "/activities/#{uuid}"

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(url)

	assert json_response(conn, 200)
	end
	end

	describe "GET notice/2" do
	test "gets a notice in xml format", %{conn: conn} do
	note_activity = insert(:note_activity)

	conn
	\|> get("/notice/#{note_activity.id}")
	\|> response(200)
	end

	test "gets a notice in AS2 format", %{conn: conn} do
	note_activity = insert(:note_activity)

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> json_response(200)
	end

	test "500s when actor not found", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	User.invalidate_cache(user)
	Pleroma.Repo.delete(user)

	conn =
	conn
	\|> get("/notice/#{note_activity.id}")

	assert response(conn, 500) == ~S({"error":"Something went wrong"})
	end

	test "only gets a notice in AS2 format for Create messages", %{conn: conn} do
	note_activity = insert(:note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(url)

	assert json_response(conn, 200)

	user = insert(:user)

	{:ok, like_activity, _} = CommonAPI.favorite(note_activity.id, user)
	url = "/notice/#{like_activity.id}"

	assert like_activity.data["type"] == "Like"

	conn =
	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> get(url)

	assert response(conn, 404)
	end

	test "render html for redirect for html format", %{conn: conn} do
	note_activity = insert(:note_activity)

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}")
	\|> response(200)

	assert resp =~
	"<meta content=\"#{Pleroma.Web.base_url()}/notice/#{note_activity.id}\" property=\"og:url\">"

	user = insert(:user)

	{:ok, like_activity, _} = CommonAPI.favorite(note_activity.id, user)

	assert like_activity.data["type"] == "Like"

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{like_activity.id}")
	\|> response(200)

	assert resp =~ "<!--server-generated-meta-->"
	end

	test "404s a private notice", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "404s a nonexisting notice", %{conn: conn} do
	url = "/notice/123"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end
	end

	describe "feed_redirect" do
	test "undefined format. it redirects to feed", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/users/#{user.nickname}")
	\|> response(302)

	assert response ==
	"<html><body>You are being <a href=\"#{Pleroma.Web.base_url()}/users/#{
	user.nickname
	}/feed.atom\">redirected</a>.</body></html>"
	end

	test "undefined format. it returns error when user not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/users/jimm")
	\|> response(404)

	assert response == ~S({"error":"Not found"})
	end

	test "activity+json format. it redirects on actual feed of user", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	response =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}")
	\|> json_response(200)

	assert response["endpoints"] == %{
	"oauthAuthorizationEndpoint" => "#{Pleroma.Web.base_url()}/oauth/authorize",
	"oauthRegistrationEndpoint" => "#{Pleroma.Web.base_url()}/api/v1/apps",
	"oauthTokenEndpoint" => "#{Pleroma.Web.base_url()}/oauth/token",
	"sharedInbox" => "#{Pleroma.Web.base_url()}/inbox"
	}

	assert response["@context"] == [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	- %{"@language" => "und"}
	+ %{
	+ "@language" => "und",
	+ "discoverable" => "mastodon:discoverable",
	+ "mastodon" => "http://joinmastodon.org/ns#"
	+ }
	]

	assert Map.take(response, [
	"followers",
	"following",
	"id",
	"inbox",
	"manuallyApprovesFollowers",
	"name",
	"outbox",
	"preferredUsername",
	"summary",
	"tag",
	"type",
	"url"
	]) == %{
	"followers" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/followers",
	"following" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/following",
	"id" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}",
	"inbox" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/inbox",
	"manuallyApprovesFollowers" => false,
	"name" => user.name,
	"outbox" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/outbox",
	"preferredUsername" => user.nickname,
	"summary" => user.bio,
	"tag" => [],
	"type" => "Person",
	"url" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
	}
	end

	test "activity+json format. it returns error whe use not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == "Not found"
	end

	test "json format. it redirects on actual feed of user", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}")
	\|> json_response(200)

	assert response["endpoints"] == %{
	"oauthAuthorizationEndpoint" => "#{Pleroma.Web.base_url()}/oauth/authorize",
	"oauthRegistrationEndpoint" => "#{Pleroma.Web.base_url()}/api/v1/apps",
	"oauthTokenEndpoint" => "#{Pleroma.Web.base_url()}/oauth/token",
	"sharedInbox" => "#{Pleroma.Web.base_url()}/inbox"
	}

	assert response["@context"] == [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	- %{"@language" => "und"}
	+ %{
	+ "@language" => "und",
	+ "discoverable" => "mastodon:discoverable",
	+ "mastodon" => "http://joinmastodon.org/ns#"
	+ }
	]

	assert Map.take(response, [
	"followers",
	"following",
	"id",
	"inbox",
	"manuallyApprovesFollowers",
	"name",
	"outbox",
	"preferredUsername",
	"summary",
	"tag",
	"type",
	"url"
	]) == %{
	"followers" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/followers",
	"following" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/following",
	"id" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}",
	"inbox" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/inbox",
	"manuallyApprovesFollowers" => false,
	"name" => user.name,
	"outbox" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/outbox",
	"preferredUsername" => user.nickname,
	"summary" => user.bio,
	"tag" => [],
	"type" => "Person",
	"url" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
	}
	end

	test "json format. it returns error whe use not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == "Not found"
	end

	test "html format. it redirects on actual feed of user", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	response =
	conn
	\|> get("/users/#{user.nickname}")
	\|> response(200)

	assert response ==
	Fallback.RedirectController.redirector_with_meta(
	conn,
	%{user: user}
	).resp_body
	end

	test "html format. it returns error when user not found", %{conn: conn} do
	response =
	conn
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == %{"error" => "Not found"}
	end
	end

	describe "GET /notice/:id/embed_player" do
	test "render embed player", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	conn =
	conn
	\|> get("/notice/#{note_activity.id}/embed_player")

	assert Plug.Conn.get_resp_header(conn, "x-frame-options") == ["ALLOW"]

	assert Plug.Conn.get_resp_header(
	conn,
	"content-security-policy"
	) == [
	"default-src 'none';style-src 'self' 'unsafe-inline';img-src 'self' data: https:; media-src 'self' https:;"
	]

	assert response(conn, 200) =~
	"<video controls loop><source src=\"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4\" type=\"video/mp4\">Your browser does not support video/mp4 playback.</video>"
	end

	test "404s when activity isn't create", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"type" => "Like"})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when activity is direct message", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"directMessage" => true})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment is empty", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)
	object_data = Map.put(object.data, "attachment", [])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment isn't audio or video", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" => "https://peertube.moe/static/webseed/480.jpg",
	"mediaType" => "image/jpg",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 2:05 PM (13 h, 24 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803089
Default Alt Text: (46 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions