No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/twitter_api/representers/activity_representer.ex b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	index bb77e61f3..26bfb79af 100644
	--- a/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	+++ b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	@@ -1,217 +1,218 @@
	# THIS MODULE IS DEPRECATED! DON'T USE IT!
	# USE THE Pleroma.Web.TwitterAPI.Views.ActivityView MODULE!
	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter do
	use Pleroma.Web.TwitterAPI.Representers.BaseRepresenter
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.{Activity, User}
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView}
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Formatter

	defp user_by_ap_id(user_list, ap_id) do
	Enum.find(user_list, fn %{ap_id: user_id} -> ap_id == user_id end)
	end

	def to_map(
	%Activity{data: %{"type" => "Announce", "actor" => actor, "published" => created_at}} =
	activity,
	%{users: users, announced_activity: announced_activity} = opts
	) do
	user = user_by_ap_id(users, actor)
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} retweeted a status."

	announced_user = user_by_ap_id(users, announced_activity.data["actor"])
	retweeted_status = to_map(announced_activity, Map.merge(%{user: announced_user}, opts))

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=note",
	"created_at" => created_at,
	"retweeted_status" => retweeted_status,
	"statusnet_conversation_id" => conversation_id(announced_activity),
	"external_url" => activity.data["id"],
	"activity_type" => "repeat"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Like", "published" => created_at}} = activity,
	%{user: user, liked_activity: liked_activity} = opts
	) do
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} favorited a status."

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=Favourite",
	"created_at" => created_at,
	"in_reply_to_status_id" => liked_activity.id,
	"external_url" => activity.data["id"],
	"activity_type" => "like"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Follow", "object" => followed_id}} = activity,
	%{user: user} = opts
	) do
	created_at = activity.data["published"] \|\| DateTime.to_iso8601(activity.inserted_at)
	created_at = created_at \|> Utils.date_to_asctime()

	followed = User.get_cached_by_ap_id(followed_id)
	text = "#{user.nickname} started following #{followed.nickname}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "follow"
	}
	end

	# TODO:
	# Make this more proper. Just a placeholder to not break the frontend.
	def to_map(
	%Activity{
	data: %{"type" => "Undo", "published" => created_at, "object" => undid_activity}
	} = activity,
	%{user: user} = opts
	) do
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} undid the action at #{undid_activity["id"]}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "undo"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Delete", "published" => created_at, "object" => _}} =
	activity,
	%{user: user} = opts
	) do
	created_at = created_at \|> Utils.date_to_asctime()

	%{
	"id" => activity.id,
	"uri" => activity.data["object"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "delete"
	}
	end

	def to_map(
	%Activity{data: %{"object" => %{"content" => content} = object}} = activity,
	%{user: user} = opts
	) do
	created_at = object["published"] \|> Utils.date_to_asctime()
	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0
	favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])
	repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])

	mentions = opts[:mentioned] \|\| []

	attentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> Enum.find(mentions, fn user -> ap_id == user.ap_id end) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)

	conversation_id = conversation_id(activity)

	tags = activity.data["object"]["tag"] \|\| []
	possibly_sensitive = activity.data["object"]["sensitive"] \|\| Enum.member?(tags, "nsfw")

	tags = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	{summary, content} = ActivityView.render_content(object)

	html =
	HtmlSanitizeEx.basic_html(content)
	\|> Formatter.emojify(object["emoji"])

	%{
	"id" => activity.id,
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => HtmlSanitizeEx.strip_tags(content),
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => object["inReplyToStatusId"],
	"statusnet_conversation_id" => conversation_id,
	"attachments" => (object["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => to_boolean(favorited),
	"repeated" => to_boolean(repeated),
	"external_url" => object["external_url"] \|\| object["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	- "visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object)
	+ "visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object),
	+ "summary" => object["summary"]
	}
	end

	def conversation_id(activity) do
	with context when not is_nil(context) <- activity.data["context"] do
	TwitterAPI.context_to_conversation_id(context)
	else
	_e -> nil
	end
	end

	defp to_boolean(false) do
	false
	end

	defp to_boolean(nil) do
	false
	end

	defp to_boolean(_) do
	true
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/views/activity_view.ex b/lib/pleroma/web/twitter_api/views/activity_view.ex
	index f418249e2..55b5287f5 100644
	--- a/lib/pleroma/web/twitter_api/views/activity_view.ex
	+++ b/lib/pleroma/web/twitter_api/views/activity_view.ex
	@@ -1,294 +1,295 @@
	defmodule Pleroma.Web.TwitterAPI.ActivityView do
	use Pleroma.Web, :view
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.User
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Repo
	alias Pleroma.Formatter

	import Ecto.Query

	defp query_context_ids([]), do: []

	defp query_context_ids(contexts) do
	query = from(o in Object, where: fragment("(?)->>'id' = ANY(?)", o.data, ^contexts))

	Repo.all(query)
	end

	defp query_users([]), do: []

	defp query_users(user_ids) do
	query = from(user in User, where: user.ap_id in ^user_ids)

	Repo.all(query)
	end

	defp collect_context_ids(activities) do
	_contexts =
	activities
	\|> Enum.reject(& &1.data["context_id"])
	\|> Enum.map(fn %{data: data} ->
	data["context"]
	end)
	\|> Enum.filter(& &1)
	\|> query_context_ids()
	\|> Enum.reduce(%{}, fn %{data: %{"id" => ap_id}, id: id}, acc ->
	Map.put(acc, ap_id, id)
	end)
	end

	defp collect_users(activities) do
	activities
	\|> Enum.map(fn activity ->
	case activity.data do
	data = %{"type" => "Follow"} ->
	[data["actor"], data["object"]]

	data ->
	[data["actor"]]
	end ++ activity.recipients
	end)
	\|> List.flatten()
	\|> Enum.uniq()
	\|> query_users()
	\|> Enum.reduce(%{}, fn user, acc ->
	Map.put(acc, user.ap_id, user)
	end)
	end

	defp get_context_id(%{data: %{"context_id" => context_id}}, _) when not is_nil(context_id),
	do: context_id

	defp get_context_id(%{data: %{"context" => nil}}, _), do: nil

	defp get_context_id(%{data: %{"context" => context}}, options) do
	cond do
	id = options[:context_ids][context] -> id
	true -> TwitterAPI.context_to_conversation_id(context)
	end
	end

	defp get_context_id(_, _), do: nil

	defp get_user(ap_id, opts) do
	cond do
	user = opts[:users][ap_id] ->
	user

	String.ends_with?(ap_id, "/followers") ->
	nil

	ap_id == "https://www.w3.org/ns/activitystreams#Public" ->
	nil

	true ->
	User.get_cached_by_ap_id(ap_id)
	end
	end

	def render("index.json", opts) do
	context_ids = collect_context_ids(opts.activities)
	users = collect_users(opts.activities)

	opts =
	opts
	\|> Map.put(:context_ids, context_ids)
	\|> Map.put(:users, users)

	render_many(
	opts.activities,
	ActivityView,
	"activity.json",
	opts
	)
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Delete"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|> Utils.date_to_asctime()

	%{
	"id" => activity.id,
	"uri" => activity.data["object"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "delete"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Follow"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|\| DateTime.to_iso8601(activity.inserted_at)
	created_at = created_at \|> Utils.date_to_asctime()

	followed = get_user(activity.data["object"], opts)
	text = "#{user.nickname} started following #{followed.nickname}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "follow"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Announce"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|> Utils.date_to_asctime()
	announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])

	text = "#{user.nickname} retweeted a status."

	retweeted_status = render("activity.json", Map.merge(opts, %{activity: announced_activity}))

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=note",
	"created_at" => created_at,
	"retweeted_status" => retweeted_status,
	"statusnet_conversation_id" => get_context_id(announced_activity, opts),
	"external_url" => activity.data["id"],
	"activity_type" => "repeat"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Like"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])

	created_at =
	activity.data["published"]
	\|> Utils.date_to_asctime()

	text = "#{user.nickname} favorited a status."

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=Favourite",
	"created_at" => created_at,
	"in_reply_to_status_id" => liked_activity.id,
	"external_url" => activity.data["id"],
	"activity_type" => "like"
	}
	end

	def render(
	"activity.json",
	%{activity: %{data: %{"type" => "Create", "object" => object}} = activity} = opts
	) do
	user = get_user(activity.data["actor"], opts)

	created_at = object["published"] \|> Utils.date_to_asctime()
	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0
	favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])
	repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])

	attentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> get_user(ap_id, opts) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)

	conversation_id = get_context_id(activity, opts)

	tags = activity.data["object"]["tag"] \|\| []
	possibly_sensitive = activity.data["object"]["sensitive"] \|\| Enum.member?(tags, "nsfw")

	tags = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	{summary, content} = render_content(object)

	html =
	HtmlSanitizeEx.basic_html(content)
	\|> Formatter.emojify(object["emoji"])

	%{
	"id" => activity.id,
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => HtmlSanitizeEx.strip_tags(content),
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => object["inReplyToStatusId"],
	"statusnet_conversation_id" => conversation_id,
	"attachments" => (object["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => !!favorited,
	"repeated" => !!repeated,
	"external_url" => object["external_url"] \|\| object["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	- "visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object)
	+ "visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object),
	+ "summary" => summary
	}
	end

	def render_content(%{"type" => "Note"} = object) do
	summary = object["summary"]

	content =
	if !!summary and summary != "" do
	"<p>#{summary}</p>#{object["content"]}"
	else
	object["content"]
	end

	{summary, content}
	end

	def render_content(%{"type" => "Article"} = object) do
	summary = object["name"] \|\| object["summary"]

	content =
	if !!summary and summary != "" do
	"<p><a href=\"#{object["url"]}\">#{summary}</a></p>#{object["content"]}"
	else
	object["content"]
	end

	{summary, content}
	end

	def render_content(object) do
	summary = object["summary"] \|\| "Unhandled activity type: #{object["type"]}"
	content = "<p>#{summary}</p>#{object["content"]}"

	{summary, content}
	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 7505093dd..3f85e028b 100644
	--- a/test/web/twitter_api/representers/activity_representer_test.exs
	+++ b/test/web/twitter_api/representers/activity_representer_test.exs
	@@ -1,192 +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=\"#{
	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"
	+ "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/activity_view_test.exs b/test/web/twitter_api/views/activity_view_test.exs
	index 5b2a7466b..a101e4ae8 100644
	--- a/test/web/twitter_api/views/activity_view_test.exs
	+++ b/test/web/twitter_api/views/activity_view_test.exs
	@@ -1,210 +1,211 @@
	defmodule Pleroma.Web.TwitterAPI.ActivityViewTest do
	use Pleroma.DataCase

	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Repo
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Pleroma.Factory
	import Mock

	test "a create activity with a note" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	result = ActivityView.render("activity.json", activity: activity)

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["context"])

	expected = %{
	"activity_type" => "post",
	"attachments" => [],
	"attentions" => [
	UserView.render("show.json", %{user: other_user})
	],
	"created_at" => activity.data["object"]["published"] \|> Utils.date_to_asctime(),
	"external_url" => activity.data["object"]["id"],
	"fave_num" => 0,
	"favorited" => false,
	"id" => activity.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => true,
	"possibly_sensitive" => false,
	"repeat_num" => 0,
	"repeated" => false,
	"statusnet_conversation_id" => convo_id,
	"statusnet_html" =>
	"Hey <span><a href=\"#{other_user.ap_id}\">@<span>shp</span></a></span>!",
	"tags" => [],
	"text" => "Hey @shp!",
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user}),
	- "visibility" => "direct"
	+ "visibility" => "direct",
	+ "summary" => nil
	}

	assert result == expected
	end

	test "a list of activities" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["context"])

	mocks = [
	{
	TwitterAPI,
	[],
	[context_to_conversation_id: fn _ -> false end]
	},
	{
	User,
	[:passthrough],
	[get_cached_by_ap_id: fn _ -> nil end]
	}
	]

	with_mocks mocks do
	[result] = ActivityView.render("index.json", activities: [activity])

	assert result["statusnet_conversation_id"] == convo_id
	assert result["user"]
	refute called(TwitterAPI.context_to_conversation_id(:_))
	refute called(User.get_cached_by_ap_id(user.ap_id))
	refute called(User.get_cached_by_ap_id(other_user.ap_id))
	end
	end

	test "an activity that is a reply" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})

	{:ok, answer} =
	CommonAPI.post(other_user, %{"status" => "Hi!", "in_reply_to_status_id" => activity.id})

	result = ActivityView.render("activity.json", %{activity: answer})

	assert result["in_reply_to_status_id"] == activity.id
	end

	test "a like activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, like, _object} = CommonAPI.favorite(activity.id, other_user)

	result = ActivityView.render("activity.json", activity: like)

	expected = %{
	"activity_type" => "like",
	"created_at" => like.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => like.data["id"],
	"id" => like.id,
	"in_reply_to_status_id" => activity.id,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "shp favorited a status.",
	"text" => "shp favorited a status.",
	"uri" => "tag:#{like.data["id"]}:objectType=Favourite",
	"user" => UserView.render("show.json", user: other_user)
	}

	assert result == expected
	end

	test "an announce activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, announce, _object} = CommonAPI.repeat(activity.id, other_user)

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["context"])

	activity = Repo.get(Activity, activity.id)

	result = ActivityView.render("activity.json", activity: announce)

	expected = %{
	"activity_type" => "repeat",
	"created_at" => announce.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => announce.data["id"],
	"id" => announce.id,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "shp retweeted a status.",
	"text" => "shp retweeted a status.",
	"uri" => "tag:#{announce.data["id"]}:objectType=note",
	"user" => UserView.render("show.json", user: other_user),
	"retweeted_status" => ActivityView.render("activity.json", activity: activity),
	"statusnet_conversation_id" => convo_id
	}

	assert result == expected
	end

	test "A follow activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

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

	result = ActivityView.render("activity.json", activity: follow)

	expected = %{
	"activity_type" => "follow",
	"attentions" => [],
	"created_at" => follow.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => follow.data["id"],
	"id" => follow.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "#{user.nickname} started following shp",
	"text" => "#{user.nickname} started following shp",
	"user" => UserView.render("show.json", user: user)
	}

	assert result == expected
	end

	test "a delete activity" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, delete} = CommonAPI.delete(activity.id, user)

	result = ActivityView.render("activity.json", activity: delete)

	expected = %{
	"activity_type" => "delete",
	"attentions" => [],
	"created_at" => delete.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => delete.data["id"],
	"id" => delete.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"uri" => delete.data["object"],
	"user" => UserView.render("show.json", user: user)
	}

	assert result == expected
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 28, 5:30 AM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 40869
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions