No OneTemporary
Actions

Authored By

Unknown

Size

26 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/web/mastodon_api/mastodon_api_controller_test.exs b/test/web/mastodon_api/mastodon_api_controller_test.exs
	index b97ca06e8..6569b8c45 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,382 +1,382 @@
	defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.{Repo, User, Activity}
	alias Pleroma.Web.{OStatus, CommonAPI}

	import Pleroma.Factory

	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

	{: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)

	{: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")

	assert length(json_response(conn, 200)) == 2

	conn = build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "True"})

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end

	test "posting a status", %{conn: conn} do
	user = insert(:user)

	conn = conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "cofe"})

	assert %{"content" => "cofe", "id" => id} = json_response(conn, 200)
	assert Repo.get(Activity, 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 "verify_credentials", %{conn: conn} do
	user = insert(:user)

	conn = conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == 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 == activity.id
	+ 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)

	assert Repo.get(Activity, activity.id) == nil
	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 "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 %{"id" => id, "reblogged" => true, "reblogs_count" => 1} = json_response(conn, 200)
	- assert activity.id == id
	+ 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 activity.id == id
	+ assert to_string(activity.id) == id
	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 activity.id == id
	+ assert to_string(activity.id) == id
	end
	end

	describe "user timelines" do
	test "gets a users statuses", %{conn: conn} do
	_note = insert(:note_activity)
	note_two = insert(:note_activity)

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

	conn = conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")

	assert [%{"id" => id}] = json_response(conn, 200)

	- assert id == note_two.id
	+ assert id == to_string(note_two.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 other_user.id == relationship["id"]
	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 == 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"}

	user = insert(:user)

	conn = conn
	\|> assign(:user, user)
	\|> post("/api/v1/media", %{"file" => file})

	assert media = json_response(conn, 200)

	assert media["type"] == "image"
	end

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	{:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
	{:ok, [_activity]} = OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	conn = conn
	\|> get("/api/v1/timelines/tag/2hu")

	assert [%{"id" => id}] = json_response(conn, 200)

	- assert id == activity.id
	+ assert id == to_string(activity.id)
	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 = user.id
	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 = other_user.id
	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 == other_user.id
	end

	test "unimplemented block/mute endpoints" do
	user = insert(:user)
	other_user = insert(:user)

	["block", "unblock", "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 == 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"})

	conn = conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "2hu"})

	assert [account] = json_response(conn, 200)
	assert account["id"] == user_three.id
	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, _} = 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"] == user_three.id

	assert results["hashtags"] == []

	[status] = results["statuses"]
	- assert status["id"] == activity.id
	+ assert status["id"] == to_string(activity.id)
	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)

	conn = conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites")

	assert [status] = json_response(conn, 200)
	- assert status["id"] == activity.id
	+ assert status["id"] == to_string(activity.id)
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index 1cf48dd4b..1ec9ef388 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,374 +1,374 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Builders.{UserBuilder, ActivityBuilder}
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView}
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.{Activity, User, Object, Repo}
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Pleroma.Factory

	test "create a status" do
	user = insert(:user)
	_mentioned_user = UserBuilder.insert(%{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 line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{ :ok, activity = %Activity{} } = TwitterAPI.create_status(user, input)

	assert get_in(activity.data, ["object", "content"]) == "Hello again, <a href='shp'>@shp</a>.<br>\nThis is on another line. #2hu #epic #phantasmagoric<br>\n<a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"
	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, ["to"]), 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

	# 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
	assert Enum.member?(get_in(reply.data, ["to"]), user.ap_id)
	end

	test "fetch public statuses, excluding remote ones." do
	%{ public: activity, user: user } = ActivityBuilder.public_and_non_public
	insert(:note_activity, %{local: false})

	follower = insert(:user, following: [User.ap_followers(user)])

	statuses = TwitterAPI.fetch_public_statuses(follower)

	assert length(statuses) == 1
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: user, for: follower})
	end

	test "fetch whole known network statuses" do
	%{ public: activity, user: user } = ActivityBuilder.public_and_non_public
	insert(:note_activity, %{local: false})

	follower = insert(:user, following: [User.ap_followers(user)])

	statuses = TwitterAPI.fetch_public_and_external_statuses(follower)

	assert length(statuses) == 2
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: user, for: follower})
	end

	test "fetch friends' statuses" do
	user = insert(:user, %{following: ["someguy/followers"]})
	{:ok, activity} = ActivityBuilder.insert(%{"to" => ["someguy/followers"]})
	{:ok, direct_activity} = ActivityBuilder.insert(%{"to" => [user.ap_id]})

	statuses = TwitterAPI.fetch_friend_statuses(user)

	activity_user = Repo.get_by(User, ap_id: activity.data["actor"])
	direct_activity_user = Repo.get_by(User, ap_id: direct_activity.data["actor"])

	assert length(statuses) == 2
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: activity_user})
	assert Enum.at(statuses, 1) == ActivityRepresenter.to_map(direct_activity, %{user: direct_activity_user, mentioned: [user]})
	end

	test "fetch user's mentions" do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"to" => [user.ap_id]})
	activity_user = Repo.get_by(User, ap_id: activity.data["actor"])

	statuses = TwitterAPI.fetch_mentions(user)

	assert length(statuses) == 1
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: activity_user, mentioned: [user]})
	end

	test "get a user by params" do
	user1_result = {:ok, user1} = UserBuilder.insert(%{ap_id: "some id", email: "test@pleroma"})
	{:ok, user2} = UserBuilder.insert(%{ap_id: "some other id", nickname: "testname2", email: "test2@pleroma"})

	assert {:error, "You need to specify screen_name or user_id"} == TwitterAPI.get_user(nil, nil)
	assert user1_result == TwitterAPI.get_user(nil, %{"user_id" => user1.id})
	assert user1_result == TwitterAPI.get_user(nil, %{"user_id" => user1.nickname})
	assert user1_result == TwitterAPI.get_user(nil, %{"screen_name" => user1.nickname})
	assert user1_result == TwitterAPI.get_user(user1, nil)
	assert user1_result == TwitterAPI.get_user(user2, %{"user_id" => user1.id})
	assert user1_result == TwitterAPI.get_user(user2, %{"screen_name" => user1.nickname})
	assert {:error, "No user with such screen_name"} == TwitterAPI.get_user(nil, %{"screen_name" => "Satan"})
	assert {:error, "No user with such user_id"} == TwitterAPI.get_user(nil, %{"user_id" => 666})
	end

	test "fetch user's statuses" do
	{:ok, user1} = UserBuilder.insert(%{ap_id: "some id", email: "test@pleroma"})
	{:ok, user2} = UserBuilder.insert(%{ap_id: "some other id", nickname: "testname2", email: "test2@pleroma"})

	{:ok, status1} = ActivityBuilder.insert(%{"id" => 1}, %{user: user1})
	{:ok, status2} = ActivityBuilder.insert(%{"id" => 2}, %{user: user2})

	user1_statuses = TwitterAPI.fetch_user_statuses(user1, %{"actor_id" => user1.ap_id})

	assert length(user1_statuses) == 1
	assert Enum.at(user1_statuses, 0) == ActivityRepresenter.to_map(status1, %{user: user1})

	user2_statuses = TwitterAPI.fetch_user_statuses(user1, %{"actor_id" => user2.ap_id})

	assert length(user2_statuses) == 1
	assert Enum.at(user2_statuses, 0) == ActivityRepresenter.to_map(status2, %{user: user2})
	end

	test "fetch a single status" do
	{:ok, activity} = ActivityBuilder.insert()
	{:ok, user} = UserBuilder.insert()
	actor = Repo.get_by!(User, ap_id: activity.data["actor"])

	status = TwitterAPI.fetch_status(user, activity.id)

	assert status == ActivityRepresenter.to_map(activity, %{for: user, user: actor})
	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.following == [User.ap_followers(followed)]

	{ :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.following == [User.ap_followers(followed)]

	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 "fetch statuses in a context using the conversation id" 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"})

	{:ok, object} = Object.context_mapping("2hu") \|> Repo.insert

	statuses = TwitterAPI.fetch_conversation(user, object.id)

	assert length(statuses) == 2
	assert Enum.at(statuses, 1)["id"] == activity.id
	assert Enum.at(statuses, 0)["id"] == activity_two.id
	end

	test "upload a file" do
	file = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}

	response = TwitterAPI.upload(file)

	assert is_binary(response)
	end

	test "it adds user links to an existing text" 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"})

	mentions = Pleroma.Formatter.parse_mentions(text)
	expected_text = "<a href='#{gsimg.ap_id}'>@gsimg</a> According to <a href='#{archaeme.ap_id}'>@archaeme</a>, that is @daggsy. Also hello <a href='#{archaeme_remote.ap_id}'>@archaeme</a>"

	assert Utils.add_user_links(text, mentions) == expected_text
	end

	test "it favorites a status, returns the updated status" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_user = Repo.get_by!(User, ap_id: note_activity.data["actor"])

	{:ok, status} = TwitterAPI.fav(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == ActivityRepresenter.to_map(updated_activity, %{user: activity_user, for: user})
	end

	test "it unfavorites a status, returns the updated status" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_user = Repo.get_by!(User, ap_id: note_activity.data["actor"])
	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 ActivityRepresenter.to_map(updated_activity, %{user: activity_user, for: user})["fave_num"] == 1

	{:ok, status} = TwitterAPI.unfav(user, note_activity.id)

	assert status["fave_num"] == 0
	end

	test "it retweets a status and returns the retweet" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_user = Repo.get_by!(User, ap_id: note_activity.data["actor"])

	{:ok, status} = TwitterAPI.repeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == ActivityRepresenter.to_map(updated_activity, %{user: activity_user, for: user})
	end

	test "it registers a new user and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"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 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)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	status = ActivityRepresenter.to_map(note_activity, %{user: user})

	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 == UserView.render("show.json", %{user: remote, for: user})
	+ assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

	# Also fetches the feed.
	assert Activity.get_create_activity_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 2:47 PM (1 d, 8 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798217
Default Alt Text: (26 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions