No OneTemporary
Actions

Size

45 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index ec9c5e970..75e4101f2 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,71 +1,77 @@
	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.Repo
	alias Pleroma.{Activity, Object, Upload}
	import Ecto.Query

	def insert(map) when is_map(map) do
	map = Map.put_new_lazy(map, "id", &generate_activity_id/0)

	map = if is_map(map["object"]) do
	object = Map.put_new_lazy(map["object"], "id", &generate_object_id/0)
	Repo.insert!(%Object{data: object})
	Map.put(map, "object", object)
	else
	map
	end

	Repo.insert(%Activity{data: map})
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	generate_id("objects")
	end

	def generate_id(type) do
	"#{Pleroma.Web.base_url()}/#{type}/#{Ecto.UUID.generate}"
	end

	def fetch_public_activities(opts \\ %{}) do
	public = ["https://www.w3.org/ns/activitystreams#Public"]
	fetch_activities(public, opts)
	end

	def fetch_activities(recipients, opts \\ %{}) do
	since_id = opts["since_id"] \|\| 0

	query = from activity in Activity,
	limit: 20,
	order_by: [desc: :inserted_at]

	query = Enum.reduce(recipients, query, fn (recipient, q) ->
	map = %{ to: [recipient] }
	from activity in q,
	or_where: fragment(~s(? @> ?), activity.data, ^map)
	end)

	query = from activity in query,
	where: activity.id > ^since_id

	+ query = if opts["max_id"] do
	+ from activity in query, where: activity.id < ^opts["max_id"]
	+ else
	+ query
	+ end
	+
	Repo.all(query)
	\|> Enum.reverse
	end

	def fetch_activities_for_context(context) do
	query = from activity in Activity,
	where: fragment("? @> ?", activity.data, ^%{ context: context })
	Repo.all(query)
	end

	def upload(%Plug.Upload{} = file) do
	data = Upload.store(file)
	Repo.insert(%Object{data: data})
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index e37bd1f72..38052ba02 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,42 +1,45 @@
	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

	alias Pleroma.{Repo, User}

	def user_fetcher(username) do
	{:ok, Repo.get_by(User, %{nickname: username})}
	end

	pipeline :api do
	plug :accepts, ["json"]
	plug :fetch_session
	plug Pleroma.Plugs.AuthenticationPlug, %{fetcher: &Pleroma.Web.Router.user_fetcher/1, optional: true}
	end

	pipeline :authenticated_api do
	plug :accepts, ["json"]
	plug :fetch_session
	plug Pleroma.Plugs.AuthenticationPlug, %{fetcher: &Pleroma.Web.Router.user_fetcher/1}
	end

	scope "/api", Pleroma.Web do
	pipe_through :api

	get "/help/test", TwitterAPI.Controller, :help_test
	get "/statuses/public_timeline", TwitterAPI.Controller, :public_timeline
	get "/statuses/public_and_external_timeline", TwitterAPI.Controller, :public_timeline
	get "/statuses/show/:id", TwitterAPI.Controller, :fetch_status
	get "/statusnet/conversation/:id", TwitterAPI.Controller, :fetch_conversation
	+ get "/statusnet/config", TwitterAPI.Controller, :config
	end

	scope "/api", Pleroma.Web do
	pipe_through :authenticated_api

	+ get "/account/verify_credentials", TwitterAPI.Controller, :verify_credentials
	post "/account/verify_credentials", TwitterAPI.Controller, :verify_credentials
	post "/statuses/update", TwitterAPI.Controller, :status_update
	+ get "/statuses/home_timeline", TwitterAPI.Controller, :friends_timeline
	get "/statuses/friends_timeline", TwitterAPI.Controller, :friends_timeline
	post "/friendships/create", TwitterAPI.Controller, :follow
	post "/friendships/destroy", TwitterAPI.Controller, :unfollow
	post "/statusnet/media/upload", TwitterAPI.Controller, :upload
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/representers/activity_representer.ex b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	index 5fe0df359..9e4ffaefe 100644
	--- a/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	+++ b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	@@ -1,46 +1,59 @@
	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter do
	use Pleroma.Web.TwitterAPI.Representers.BaseRepresenter
	alias Pleroma.Web.TwitterAPI.Representers.{UserRepresenter, ObjectRepresenter}
	alias Pleroma.Activity

	+
	def to_map(%Activity{data: %{"type" => "Follow"}} = activity, %{user: user} = opts) do
	+ created_at = get_in(activity.data, ["published"])
	+ \|> date_to_asctime
	+
	%{
	"id" => activity.id,
	"user" => UserRepresenter.to_map(user, opts),
	"attentions" => [],
	"statusnet_html" => "", # TODO: add summary
	"text" => "",
	"is_local" => true,
	"is_post_verb" => false,
	- "created_at" => get_in(activity.data, ["published"]),
	+ "created_at" => created_at,
	"in_reply_to_status_id" => nil,
	}
	end

	def to_map(%Activity{} = activity, %{user: user} = opts) do
	content = get_in(activity.data, ["object", "content"])
	- published = get_in(activity.data, ["object", "published"])
	+ created_at = get_in(activity.data, ["object", "published"])
	+ \|> date_to_asctime

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

	attentions = activity.data["to"]
	\|> Enum.map(fn (ap_id) -> Enum.find(mentions, fn(user) -> ap_id == user.ap_id end) end)
	\|> Enum.filter(&(&1))
	\|> Enum.map(fn (user) -> UserRepresenter.to_map(user, opts) end)

	%{
	"id" => activity.id,
	"user" => UserRepresenter.to_map(user, opts),
	"attentions" => [],
	"statusnet_html" => content,
	- "text" => content,
	+ "text" => HtmlSanitizeEx.strip_tags(content),
	"is_local" => true,
	"is_post_verb" => true,
	- "created_at" => published,
	+ "created_at" => created_at,
	"in_reply_to_status_id" => activity.data["object"]["inReplyToStatusId"],
	"statusnet_conversation_id" => activity.data["object"]["statusnetConversationId"],
	"attachments" => (activity.data["object"]["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions
	}
	end
	+
	+ defp date_to_asctime(date) do
	+ with {:ok, date, _offset} <- date \|> DateTime.from_iso8601 do
	+ Calendar.Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	+ else e ->
	+ ""
	+ end
	+ end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index 0a942e880..0217b28d6 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,191 +1,191 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.{User, Activity, Repo, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter

	import Ecto.Query

	def create_status(user = %User{}, data = %{}) do
	attachments = Enum.map(data["media_ids"] \|\| [], fn (media_id) ->
	Repo.get(Object, media_id).data
	end)

	context = ActivityPub.generate_context_id

	content = HtmlSanitizeEx.strip_tags(data["status"])

	mentions = parse_mentions(content)

	default_to = [
	User.ap_followers(user),
	"https://www.w3.org/ns/activitystreams#Public"
	]

	to = default_to ++ Enum.map(mentions, fn ({_, %{ap_id: ap_id}}) -> ap_id end)

	content_html = add_user_links(content, mentions)

	date = make_date()

	activity = %{
	"type" => "Create",
	"to" => to,
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"to" => to,
	"content" => content_html,
	"published" => date,
	"context" => context,
	"attachment" => attachments
	},
	"published" => date,
	"context" => context
	}

	# Wire up reply info.
	activity = with inReplyToId when not is_nil(inReplyToId) <- data["in_reply_to_status_id"],
	inReplyTo <- Repo.get(Activity, inReplyToId),
	context <- inReplyTo.data["context"]
	do

	to = activity["to"] ++ [inReplyTo.data["actor"]]

	activity
	\|> put_in(["to"], to)
	\|> put_in(["context"], context)
	\|> put_in(["object", "context"], context)
	\|> put_in(["object", "inReplyTo"], inReplyTo.data["object"]["id"])
	\|> put_in(["object", "inReplyToStatusId"], inReplyToId)
	\|> put_in(["statusnetConversationId"], inReplyTo.data["statusnetConversationId"])
	\|> put_in(["object", "statusnetConversationId"], inReplyTo.data["statusnetConversationId"])
	else _e ->
	activity
	end

	with {:ok, activity} <- ActivityPub.insert(activity) do
	add_conversation_id(activity)
	end
	end

	def fetch_friend_statuses(user, opts \\ %{}) do
	- ActivityPub.fetch_activities(user.following, opts)
	+ ActivityPub.fetch_activities([user.ap_id \| user.following], opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_public_statuses(user, opts \\ %{}) do
	ActivityPub.fetch_public_activities(opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_conversation(user, id) do
	query = from activity in Activity,
	where: fragment("? @> ?", activity.data, ^%{ statusnetConversationId: id}),
	limit: 1

	with %Activity{} = activity <- Repo.one(query),
	context <- activity.data["context"],
	activities <- ActivityPub.fetch_activities_for_context(context),
	statuses <- activities \|> activities_to_statuses(%{for: user})
	do
	statuses
	else e ->
	IO.inspect(e)
	[]
	end
	end

	def fetch_status(user, id) do
	with %Activity{} = activity <- Repo.get(Activity, id) do
	activity_to_status(activity, %{for: user})
	end
	end

	def follow(%User{} = follower, followed_id) do
	with %User{} = followed <- Repo.get(User, followed_id),
	{ :ok, follower } <- User.follow(follower, followed),
	{ :ok, activity } <- ActivityPub.insert(%{
	"type" => "Follow",
	"actor" => follower.ap_id,
	"object" => followed.ap_id,
	"published" => make_date()
	})
	do
	{ :ok, follower, followed, activity }
	end
	end

	def unfollow(%User{} = follower, followed_id) do
	with %User{} = followed <- Repo.get(User, followed_id),
	{ :ok, follower } <- User.unfollow(follower, followed)
	do
	{ :ok, follower, followed }
	end
	end

	def upload(%Plug.Upload{} = file) do
	{:ok, object} = ActivityPub.upload(file)

	url = List.first(object.data["url"])
	href = url["href"]
	type = url["mediaType"]

	# Fake this as good as possible...
	"""
	<?xml version="1.0" encoding="UTF-8"?>
	<rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
	<mediaid>#{object.id}</mediaid>
	<media_id>#{object.id}</media_id>
	<media_id_string>#{object.id}</media_id_string>
	<media_url>#{href}</media_url>
	<mediaurl>#{href}</mediaurl>
	<atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
	</rsp>
	"""
	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])?)/

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

	def add_user_links(text, mentions) do
	Enum.reduce(mentions, text, fn ({match, %User{ap_id: ap_id}}, text) -> String.replace(text, match, "<a href='#{ap_id}'>#{match}</a>") end)
	end

	defp add_conversation_id(activity) do
	if is_integer(activity.data["statusnetConversationId"]) do
	{:ok, activity}
	else
	data = activity.data
	\|> put_in(["object", "statusnetConversationId"], activity.id)
	\|> put_in(["statusnetConversationId"], activity.id)

	changeset = Ecto.Changeset.change(activity, data: data)
	Repo.update(changeset)
	end
	end

	defp activities_to_statuses(activities, opts) do
	Enum.map(activities, fn(activity) ->
	activity_to_status(activity, opts)
	end)
	end

	defp activity_to_status(activity, opts) do
	actor = get_in(activity.data, ["actor"])
	user = Repo.get_by!(User, ap_id: actor)
	mentioned_users = Repo.all(from user in User, where: user.ap_id in ^activity.data["to"])
	ActivityRepresenter.to_map(activity, Map.merge(opts, %{user: user, mentioned: mentioned_users}))
	end

	defp make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api_controller.ex b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	index 8163897e7..766da6c93 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	@@ -1,95 +1,109 @@
	defmodule Pleroma.Web.TwitterAPI.Controller do
	use Pleroma.Web, :controller
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.Representers.{UserRepresenter, ActivityRepresenter}

	def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
	response = user \|> UserRepresenter.to_json(%{for: user})

	conn
	\|> json_reply(200, response)
	end

	def status_update(%{assigns: %{user: user}} = conn, status_data) do
	media_ids = extract_media_ids(status_data)
	{:ok, activity} = TwitterAPI.create_status(user, Map.put(status_data, "media_ids", media_ids ))
	conn
	\|> json_reply(200, ActivityRepresenter.to_json(activity, %{user: user}))
	end

	defp extract_media_ids(status_data) do
	with media_ids when not is_nil(media_ids) <- status_data["media_ids"],
	split_ids <- String.split(media_ids, ","),
	clean_ids <- Enum.reject(split_ids, fn (id) -> String.length(id) == 0 end)
	do
	clean_ids
	else _e -> []
	end
	end

	def public_timeline(%{assigns: %{user: user}} = conn, params) do
	statuses = TwitterAPI.fetch_public_statuses(user, params)
	{:ok, json} = Poison.encode(statuses)

	conn
	\|> json_reply(200, json)
	end

	def friends_timeline(%{assigns: %{user: user}} = conn, params) do
	statuses = TwitterAPI.fetch_friend_statuses(user, params)
	{:ok, json} = Poison.encode(statuses)

	conn
	\|> json_reply(200, json)
	end

	def follow(%{assigns: %{user: user}} = conn, %{ "user_id" => followed_id }) do
	- { :ok, _user, follower, _activity } = TwitterAPI.follow(user, followed_id)
	+ { :ok, user, follower, _activity } = TwitterAPI.follow(user, followed_id)

	response = follower \|> UserRepresenter.to_json(%{for: user})

	conn
	\|> json_reply(200, response)
	end

	def unfollow(%{assigns: %{user: user}} = conn, %{ "user_id" => followed_id }) do
	{ :ok, user, follower } = TwitterAPI.unfollow(user, followed_id)

	response = follower \|> UserRepresenter.to_json(%{for: user})

	conn
	\|> json_reply(200, response)
	end

	def fetch_status(%{assigns: %{user: user}} = conn, %{ "id" => id }) do
	response = TwitterAPI.fetch_status(user, id) \|> Poison.encode!

	conn
	\|> json_reply(200, response)
	end

	def fetch_conversation(%{assigns: %{user: user}} = conn, %{ "id" => id }) do
	id = String.to_integer(id)
	response = TwitterAPI.fetch_conversation(user, id) \|> Poison.encode!

	conn
	\|> json_reply(200, response)
	end

	def upload(conn, %{"media" => media}) do
	response = TwitterAPI.upload(media)
	conn
	\|> put_resp_content_type("application/atom+xml")
	\|> send_resp(200, response)
	end

	- def help_test(conn, _) do
	+ def help_test(conn, _params) do
	conn \|> json_reply(200, Poison.encode!("ok"))
	end

	+ def config(conn, _params) do
	+ response = %{
	+ site: %{
	+ name: Pleroma.Web.base_url,
	+ server: Pleroma.Web.base_url,
	+ textlimit: -1
	+ }
	+ }
	+ \|> Poison.encode!
	+
	+ conn
	+ \|> json_reply(200, response)
	+ end
	+
	defp json_reply(conn, status, json) do
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(status, json)
	end
	end
	diff --git a/mix.exs b/mix.exs
	index 90ecba514..43a93cc2c 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,54 +1,55 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[app: :pleroma,
	version: "0.0.1",
	elixir: "~> 1.4",
	elixirc_paths: elixirc_paths(Mix.env),
	compilers: [:phoenix, :gettext] ++ Mix.compilers,
	start_permanent: Mix.env == :prod,
	aliases: aliases(),
	deps: deps()]
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[mod: {Pleroma.Application, []},
	extra_applications: [:logger, :runtime_tools, :comeonin]]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[{:phoenix, "~> 1.3.0-rc"},
	{:phoenix_pubsub, "~> 1.0"},
	{:phoenix_ecto, "~> 3.2"},
	{:postgrex, ">= 0.0.0"},
	{:gettext, "~> 0.11"},
	{:cowboy, "~> 1.0", override: true},
	{:comeonin, "~> 3.0"},
	{:trailing_format_plug, "~> 0.0.5" },
	{:html_sanitize_ex, "~> 1.0.0"},
	+ {:calendar, "~> 0.16.1"},
	{:mix_test_watch, "~> 0.2", only: :dev}]
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	["ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	"test": ["ecto.create --quiet", "ecto.migrate", "test"]]
	end
	end
	diff --git a/mix.lock b/mix.lock
	index 072f5bce9..780a63221 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,23 +1,31 @@
	-%{"comeonin": {:hex, :comeonin, "3.0.2", "8b213268a6634bd2e31a8035a963e974681d13ccc1f73f2ae664b6ac4e993c96", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, optional: false]}]},
	+%{"calendar": {:hex, :calendar, "0.16.1", "782327ad8bae7c797b887840dc4ddb933f05ce6e333e5b04964d7a5d5f79bde3", [:mix], [{:tzdata, "~> 0.5.8 or ~> 0.1.201603", [hex: :tzdata, optional: false]}]},
	+ "certifi": {:hex, :certifi, "1.0.0", "1c787a85b1855ba354f0b8920392c19aa1d06b0ee1362f9141279620a5be2039", [:rebar3], []},
	+ "comeonin": {:hex, :comeonin, "3.0.2", "8b213268a6634bd2e31a8035a963e974681d13ccc1f73f2ae664b6ac4e993c96", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, optional: false]}]},
	"connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], []},
	"cowboy": {:hex, :cowboy, "1.1.2", "61ac29ea970389a88eca5a65601460162d370a70018afe6f949a29dca91f3bb0", [:rebar3], [{:cowlib, "~> 1.0.2", [hex: :cowlib, optional: false]}, {:ranch, "~> 1.3.2", [hex: :ranch, optional: false]}]},
	"cowlib": {:hex, :cowlib, "1.0.2", "9d769a1d062c9c3ac753096f868ca121e2730b9a377de23dec0f7e08b1df84ee", [:make], []},
	"db_connection": {:hex, :db_connection, "1.1.2", "2865c2a4bae0714e2213a0ce60a1b12d76a6efba0c51fbda59c9ab8d1accc7a8", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, optional: false]}, {:poolboy, "~> 1.5", [hex: :poolboy, optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, optional: true]}]},
	"decimal": {:hex, :decimal, "1.3.1", "157b3cedb2bfcb5359372a7766dd7a41091ad34578296e951f58a946fcab49c6", [:mix], []},
	"ecto": {:hex, :ecto, "2.1.4", "d1ba932813ec0e0d9db481ef2c17777f1cefb11fc90fa7c142ff354972dfba7e", [:mix], [{:db_connection, "~> 1.1", [hex: :db_connection, optional: true]}, {:decimal, "~> 1.2", [hex: :decimal, optional: false]}, {:mariaex, "~> 0.8.0", [hex: :mariaex, optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, optional: false]}, {:postgrex, "~> 0.13.0", [hex: :postgrex, optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, optional: true]}]},
	"elixir_make": {:hex, :elixir_make, "0.4.0", "992f38fabe705bb45821a728f20914c554b276838433349d4f2341f7a687cddf", [:mix], []},
	"fs": {:hex, :fs, "2.12.0", "ad631efacc9a5683c8eaa1b274e24fa64a1b8eb30747e9595b93bec7e492e25e", [:rebar3], []},
	"gettext": {:hex, :gettext, "0.13.1", "5e0daf4e7636d771c4c71ad5f3f53ba09a9ae5c250e1ab9c42ba9edccc476263", [:mix], []},
	+ "hackney": {:hex, :hackney, "1.7.1", "e238c52c5df3c3b16ce613d3a51c7220a784d734879b1e231c9babd433ac1cb4", [:rebar3], [{:certifi, "1.0.0", [hex: :certifi, optional: false]}, {:idna, "4.0.0", [hex: :idna, optional: false]}, {:metrics, "1.0.1", [hex: :metrics, optional: false]}, {:mimerl, "1.0.2", [hex: :mimerl, optional: false]}, {:ssl_verify_fun, "1.1.1", [hex: :ssl_verify_fun, optional: false]}]},
	"html_sanitize_ex": {:hex, :html_sanitize_ex, "1.0.1", "2572e7122c78ab7e57b613e7c7f5e42bf9b3c25e430e32f23f1413d86db8a0af", [:mix], [{:mochiweb, "~> 2.12.2", [hex: :mochiweb, optional: false]}]},
	+ "idna": {:hex, :idna, "4.0.0", "10aaa9f79d0b12cf0def53038547855b91144f1bfcc0ec73494f38bb7b9c4961", [:rebar3], []},
	+ "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], []},
	"mime": {:hex, :mime, "1.1.0", "01c1d6f4083d8aa5c7b8c246ade95139620ef8effb009edde934e0ec3b28090a", [:mix], []},
	+ "mimerl": {:hex, :mimerl, "1.0.2", "993f9b0e084083405ed8252b99460c4f0563e41729ab42d9074fd5e52439be88", [:rebar3], []},
	"mix_test_watch": {:hex, :mix_test_watch, "0.3.3", "70859889a8d1d43d1b75d69d87258a301f43209a17787cdb2bd9cab42adf271d", [:mix], [{:fs, "~> 2.12", [hex: :fs, optional: false]}]},
	"mochiweb": {:hex, :mochiweb, "2.12.2", "80804ad342afa3d7f3524040d4eed66ce74b17a555de454ac85b07c479928e46", [:make, :rebar], []},
	"phoenix": {:hex, :phoenix, "1.3.0-rc.1", "0d04948a4bd24823f101024c07b6a4d35e58f1fd92a465c1bc75dd37acd1041a", [:mix], [{:cowboy, "~> 1.0", [hex: :cowboy, optional: true]}, {:phoenix_pubsub, "~> 1.0", [hex: :phoenix_pubsub, optional: false]}, {:plug, "~> 1.3.2 or ~> 1.4", [hex: :plug, optional: false]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, optional: false]}]},
	"phoenix_ecto": {:hex, :phoenix_ecto, "3.2.3", "450c749876ff1de4a78fdb305a142a76817c77a1cd79aeca29e5fc9a6c630b26", [:mix], [{:ecto, "~> 2.1", [hex: :ecto, optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, optional: true]}, {:plug, "~> 1.0", [hex: :plug, optional: false]}]},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "1.0.1", "c10ddf6237007c804bf2b8f3c4d5b99009b42eca3a0dfac04ea2d8001186056a", [:mix], []},
	"plug": {:hex, :plug, "1.3.4", "b4ef3a383f991bfa594552ded44934f2a9853407899d47ecc0481777fb1906f6", [:mix], [{:cowboy, "~> 1.0.1 or ~> 1.1", [hex: :cowboy, optional: true]}, {:mime, "~> 1.0", [hex: :mime, optional: false]}]},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], []},
	"poolboy": {:hex, :poolboy, "1.5.1", "6b46163901cfd0a1b43d692657ed9d7e599853b3b21b95ae5ae0a777cf9b6ca8", [:rebar], []},
	"postgrex": {:hex, :postgrex, "0.13.2", "2b88168fc6a5456a27bfb54ccf0ba4025d274841a7a3af5e5deb1b755d95154e", [:mix], [{:connection, "~> 1.0", [hex: :connection, optional: false]}, {:db_connection, "~> 1.1", [hex: :db_connection, optional: false]}, {:decimal, "~> 1.0", [hex: :decimal, optional: false]}]},
	"ranch": {:hex, :ranch, "1.3.2", "e4965a144dc9fbe70e5c077c65e73c57165416a901bd02ea899cfd95aa890986", [:rebar3], []},
	- "trailing_format_plug": {:hex, :trailing_format_plug, "0.0.6", "777fd71bbc30e54cb36133bacd38fac88d44be410bc60353fe48e91e14c0b990", [:mix], [{:cowboy, "~> 1.0.0", [hex: :cowboy, optional: false]}, {:plug, "> 0.12.0", [hex: :plug, optional: false]}]}}
	+ "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.1", "28a4d65b7f59893bc2c7de786dec1e1555bd742d336043fe644ae956c3497fbe", [:make, :rebar], []},
	+ "trailing_format_plug": {:hex, :trailing_format_plug, "0.0.6", "777fd71bbc30e54cb36133bacd38fac88d44be410bc60353fe48e91e14c0b990", [:mix], [{:cowboy, "~> 1.0.0", [hex: :cowboy, optional: false]}, {:plug, "> 0.12.0", [hex: :plug, optional: false]}]},
	+ "tzdata": {:hex, :tzdata, "0.5.11", "3d5469a9f46bdf4a8760333dbdabdcc4751325035c454b10521f71e7c611ae50", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, optional: false]}]}}
	diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index 2c6f67621..5cfd46238 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,107 +1,121 @@
	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.{Activity, Object}
	alias Pleroma.Builders.ActivityBuilder

	describe "insertion" do
	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
	}

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

	test "adds an id to a given object if it lacks one and inserts it to the object database" do
	data = %{
	"object" => %{
	"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 "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(%{"context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"context" => "3hu"})

	activities = ActivityPub.fetch_activities_for_context("2hu")

	assert activities == [activity, activity_two]
	end
	end

	describe "public fetch activities" do
	test "retrieves public activities" do
	%{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 "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
	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 256d920c0..f1f2b4c9c 100644
	--- a/test/web/twitter_api/representers/activity_representer_test.exs
	+++ b/test/web/twitter_api/representers/activity_representer_test.exs
	@@ -1,75 +1,76 @@
	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenterTest do
	use Pleroma.DataCase
	alias Pleroma.{User, Activity, Object}
	alias Pleroma.Web.TwitterAPI.Representers.{UserRepresenter, ActivityRepresenter, ObjectRepresenter}
	alias Pleroma.Builders.UserBuilder

	test "an activity" do
	{:ok, user} = UserBuilder.insert
	{:ok, mentioned_user } = UserBuilder.insert(%{nickname: "shp", ap_id: "shp"})
	{:ok, follower} = UserBuilder.insert(%{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 = "Some content mentioning @shp"
	- date = DateTime.utc_now() \|> DateTime.to_iso8601
	+ content_html = "Some content mentioning <a href='shp'>@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

	activity = %Activity{
	id: 1,
	data: %{
	"type" => "Create",
	"to" => [
	User.ap_followers(user),
	"https://www.w3.org/ns/activitystreams#Public",
	mentioned_user.ap_id
	],
	"actor" => User.ap_id(user),
	"object" => %{
	"published" => date,
	"type" => "Note",
	- "content" => content,
	+ "content" => content_html,
	"inReplyToStatusId" => 213123,
	"statusnetConversationId" => 4711,
	"attachment" => [
	object
	]
	},
	"published" => date
	}
	}


	expected_status = %{
	"id" => activity.id,
	"user" => UserRepresenter.to_map(user, %{for: follower}),
	"is_local" => true,
	"attentions" => [],
	- "statusnet_html" => content,
	+ "statusnet_html" => content_html,
	"text" => content,
	"is_post_verb" => true,
	- "created_at" => date,
	+ "created_at" => "Tue May 24 13:26:08 +0000 2016",
	"in_reply_to_status_id" => 213123,
	"statusnet_conversation_id" => 4711,
	"attachments" => [
	ObjectRepresenter.to_map(object)
	],
	"attentions" => [
	UserRepresenter.to_map(mentioned_user, %{for: follower})
	]
	}

	assert ActivityRepresenter.to_map(activity, %{user: user, for: follower, mentioned: [mentioned_user]}) == expected_status
	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 bead7a5a1..80ec9e4bb 100644
	--- a/test/web/twitter_api/twitter_api_controller_test.exs
	+++ b/test/web/twitter_api/twitter_api_controller_test.exs
	@@ -1,173 +1,173 @@
	defmodule Pleroma.Web.TwitterAPI.ControllerTest do
	use Pleroma.Web.ConnCase
	alias Pleroma.Web.TwitterAPI.Representers.{UserRepresenter, ActivityRepresenter}
	alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
	alias Pleroma.{Repo, Activity, User}

	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
	conn = conn
	\|> with_credentials(user.nickname, "test")
	\|> post("/api/account/verify_credentials.json")

	assert json_response(conn, 200) == UserRepresenter.to_map(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 = conn
	\|> with_credentials(user.nickname, "test")
	\|> post("/api/statuses/update.json", %{ status: "Nice meme." })

	assert json_response(conn, 200) == ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
	end
	end

	describe "GET /statuses/public_timeline.json" do
	test "returns statuses", %{conn: conn} do
	{:ok, user} = UserBuilder.insert
	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
	end

	describe "GET /statuses/show/:id.json" do
	test "returns one status", %{conn: conn} do
	{:ok, user} = UserBuilder.insert
	{:ok, activity} = ActivityBuilder.insert(%{}, %{user: user})
	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 /statusnet/conversation/:id.json" do
	test "returns the statuses in the conversation", %{conn: conn} do
	{:ok, _user} = UserBuilder.insert
	{:ok, _activity} = ActivityBuilder.insert(%{"statusnetConversationId" => 1, "context" => "2hu"})
	{:ok, _activity_two} = ActivityBuilder.insert(%{"statusnetConversationId" => 1,"context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"context" => "3hu"})

	conn = conn
	\|> get("/api/statusnet/conversation/1.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
	{:ok, user} = UserBuilder.insert
	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})
	{:ok, other_user} = UserBuilder.insert(%{ap_id: "glimmung", nickname: "nockame"})
	ActivityBuilder.insert_list(10, %{}, %{user: other_user})
	since_id = List.last(activities).id

	current_user = Ecto.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, for: current_user}) end)
	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
	{:ok, followed } = UserBuilder.insert(%{name: "some guy"})

	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 current_user.following == [User.ap_followers(followed)]
	- assert json_response(conn, 200) == UserRepresenter.to_map(followed)
	+ assert json_response(conn, 200) == UserRepresenter.to_map(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
	{:ok, followed } = UserBuilder.insert(%{name: "some guy"})

	{:ok, current_user} = User.follow(current_user, followed)
	assert current_user.following == [User.ap_followers(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 == []
	- assert json_response(conn, 200) == UserRepresenter.to_map(followed)
	+ assert json_response(conn, 200) == UserRepresenter.to_map(followed, %{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

	defp valid_user(_context) do
	{ :ok, user } = UserBuilder.insert(%{nickname: "lambda", ap_id: "lambda"})
	[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
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index ad932131a..e8853a910 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,176 +1,179 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Builders.{UserBuilder, ActivityBuilder}
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.{Activity, User, Object, Repo}
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter

	test "create a status" do
	user = UserBuilder.build(%{ap_id: "142344"})
	_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>",
	"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>."
	assert get_in(activity.data, ["object", "type"]) == "Note"
	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")

	# Add a context + 'statusnet_conversation_id'
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(activity.data, ["object", "context"]))
	assert get_in(activity.data, ["object", "statusnetConversationId"]) == activity.id
	assert get_in(activity.data, ["statusnetConversationId"]) == activity.id

	assert is_list(activity.data["object"]["attachment"])
	end

	test "create a status that is a reply" do
	user = UserBuilder.build(%{ap_id: "some_cool_id"})
	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, ["statusnetConversationId"]) == get_in(activity.data, ["statusnetConversationId"])
	assert get_in(reply.data, ["object", "statusnetConversationId"]) == get_in(activity.data, ["object", "statusnetConversationId"])
	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"]), "some_cool_id")
	end

	test "fetch public statuses" do
	%{ public: activity, user: user } = ActivityBuilder.public_and_non_public
	{:ok, follower } = UserBuilder.insert(%{name: "dude", ap_id: "idididid", 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 friends' statuses" do
	ActivityBuilder.public_and_non_public
	+
	{:ok, activity} = ActivityBuilder.insert(%{"to" => ["someguy/followers"]})
	+ {:ok, direct_activity} = ActivityBuilder.insert(%{"to" => ["some other id"]})
	{:ok, user} = UserBuilder.insert(%{ap_id: "some other id", following: ["someguy/followers"]})

	statuses = TwitterAPI.fetch_friend_statuses(user)

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

	- assert length(statuses) == 1
	+ 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: activity_user, mentioned: [user]})
	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" do
	{ :ok, user } = UserBuilder.insert
	{ :ok, following } = UserBuilder.insert(%{nickname: "guy"})

	{:ok, user, following, activity } = TwitterAPI.follow(user, following.id)

	user = Repo.get(User, user.id)
	follow = Repo.get(Activity, activity.id)

	assert user.following == [User.ap_followers(following)]
	assert follow == activity
	end

	test "Unfollow another user" do
	{ :ok, following } = UserBuilder.insert(%{nickname: "guy"})
	{ :ok, user } = UserBuilder.insert(%{following: [User.ap_followers(following)]})

	{:ok, user, _following } = TwitterAPI.unfollow(user, following.id)

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

	assert user.following == []
	end

	test "fetch statuses in a context using the conversation id" do
	{:ok, user} = UserBuilder.insert()
	{:ok, activity} = ActivityBuilder.insert(%{"statusnetConversationId" => 1, "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"statusnetConversationId" => 1,"context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"context" => "3hu"})

	statuses = TwitterAPI.fetch_conversation(user, 1)

	assert length(statuses) == 2
	assert Enum.at(statuses, 0)["id"] == activity.id
	assert Enum.at(statuses, 1)["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 can parse mentions and return the relevant users" do
	text = "@gsimg According to @archaeme , that is @daggsy."

	{:ok, gsimg} = UserBuilder.insert(%{nickname: "gsimg"})
	{:ok, archaeme} = UserBuilder.insert(%{nickname: "archaeme"})

	expected_result = [
	{"@gsimg", gsimg},
	{"@archaeme", archaeme}
	]

	assert TwitterAPI.parse_mentions(text) == expected_result
	end

	test "it adds user links to an existing text" do
	text = "@gsimg According to @archaeme , that is @daggsy."

	{:ok, _gsimg} = UserBuilder.insert(%{nickname: "gsimg", ap_id: "first_link" })
	{:ok, _archaeme} = UserBuilder.insert(%{nickname: "archaeme", ap_id: "second_link"})

	mentions = TwitterAPI.parse_mentions(text)
	expected_text = "<a href='first_link'>@gsimg</a> According to <a href='second_link'>@archaeme</a> , that is @daggsy."

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

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 9, 3:00 AM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1784407
Default Alt Text: (45 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions