1 defmodule Pleroma.Web.TwitterAPI.ControllerTest do
2 use Pleroma.Web.ConnCase
3 alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
4 alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
5 alias Pleroma.{Repo, Activity, User, Object, Notification}
6 alias Pleroma.Web.ActivityPub.ActivityPub
7 alias Pleroma.Web.TwitterAPI.UserView
8 alias Pleroma.Web.TwitterAPI.NotificationView
9 alias Pleroma.Web.CommonAPI
10 alias Pleroma.Web.TwitterAPI.TwitterAPI
13 import Pleroma.Factory
15 describe "POST /api/account/verify_credentials" do
18 test "without valid credentials", %{conn: conn} do
19 conn = post(conn, "/api/account/verify_credentials.json")
20 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
23 test "with credentials", %{conn: conn, user: user} do
26 |> with_credentials(user.nickname, "test")
27 |> post("/api/account/verify_credentials.json")
29 assert response = json_response(conn, 200)
30 assert response == UserView.render("show.json", %{user: user, token: response["token"]})
34 describe "POST /api/account/most_recent_notification" do
37 test "without valid credentials", %{conn: conn} do
38 conn = post(conn, "/api/account/most_recent_notification.json")
39 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
42 test "with credentials", %{conn: conn, user: user} do
45 |> with_credentials(user.nickname, "test")
46 |> post("/api/account/most_recent_notification.json", %{id: "200"})
48 assert json_response(conn, 200)
49 user = User.get_by_nickname(user.nickname)
50 assert user.info["most_recent_notification"] == 200
54 describe "POST /statuses/update.json" do
57 test "without valid credentials", %{conn: conn} do
58 conn = post(conn, "/api/statuses/update.json")
59 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
62 test "with credentials", %{conn: conn, user: user} do
63 conn_with_creds = conn |> with_credentials(user.nickname, "test")
64 request_path = "/api/statuses/update.json"
67 "request" => request_path,
68 "error" => "Client must provide a 'status' parameter with a value."
71 conn = conn_with_creds |> post(request_path)
72 assert json_response(conn, 400) == error_response
74 conn = conn_with_creds |> post(request_path, %{status: ""})
75 assert json_response(conn, 400) == error_response
77 conn = conn_with_creds |> post(request_path, %{status: " "})
78 assert json_response(conn, 400) == error_response
80 # we post with visibility private in order to avoid triggering relay
81 conn = conn_with_creds |> post(request_path, %{status: "Nice meme.", visibility: "private"})
83 assert json_response(conn, 200) ==
84 ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
88 describe "GET /statuses/public_timeline.json" do
89 test "returns statuses", %{conn: conn} do
90 {:ok, user} = UserBuilder.insert()
91 activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
92 ActivityBuilder.insert_list(10, %{}, %{user: user})
93 since_id = List.last(activities).id
97 |> get("/api/statuses/public_timeline.json", %{since_id: since_id})
99 response = json_response(conn, 200)
101 assert length(response) == 10
104 test "returns 403 to unauthenticated request when the instance is not public" do
106 Application.get_env(:pleroma, :instance)
107 |> Keyword.put(:public, false)
109 Application.put_env(:pleroma, :instance, instance)
112 |> get("/api/statuses/public_timeline.json")
113 |> json_response(403)
116 Application.get_env(:pleroma, :instance)
117 |> Keyword.put(:public, true)
119 Application.put_env(:pleroma, :instance, instance)
122 test "returns 200 to unauthenticated request when the instance is public" do
124 |> get("/api/statuses/public_timeline.json")
125 |> json_response(200)
129 describe "GET /statuses/public_and_external_timeline.json" do
130 test "returns 403 to unauthenticated request when the instance is not public" do
132 Application.get_env(:pleroma, :instance)
133 |> Keyword.put(:public, false)
135 Application.put_env(:pleroma, :instance, instance)
138 |> get("/api/statuses/public_and_external_timeline.json")
139 |> json_response(403)
142 Application.get_env(:pleroma, :instance)
143 |> Keyword.put(:public, true)
145 Application.put_env(:pleroma, :instance, instance)
148 test "returns 200 to unauthenticated request when the instance is public" do
150 |> get("/api/statuses/public_and_external_timeline.json")
151 |> json_response(200)
155 describe "GET /statuses/show/:id.json" do
156 test "returns one status", %{conn: conn} do
158 {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
159 actor = Repo.get_by!(User, ap_id: activity.data["actor"])
163 |> get("/api/statuses/show/#{activity.id}.json")
165 response = json_response(conn, 200)
167 assert response == ActivityRepresenter.to_map(activity, %{user: actor})
171 describe "GET /users/show.json" do
172 test "gets user with screen_name", %{conn: conn} do
177 |> get("/api/users/show.json", %{"screen_name" => user.nickname})
179 response = json_response(conn, 200)
181 assert response["id"] == user.id
184 test "gets user with user_id", %{conn: conn} do
189 |> get("/api/users/show.json", %{"user_id" => user.id})
191 response = json_response(conn, 200)
193 assert response["id"] == user.id
196 test "gets a user for a logged in user", %{conn: conn} do
198 logged_in = insert(:user)
200 {:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})
204 |> with_credentials(logged_in.nickname, "test")
205 |> get("/api/users/show.json", %{"user_id" => user.id})
207 response = json_response(conn, 200)
209 assert response["following"] == true
213 describe "GET /statusnet/conversation/:id.json" do
214 test "returns the statuses in the conversation", %{conn: conn} do
215 {:ok, _user} = UserBuilder.insert()
216 {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
217 {:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
218 {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
222 |> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")
224 response = json_response(conn, 200)
226 assert length(response) == 2
230 describe "GET /statuses/friends_timeline.json" do
233 test "without valid credentials", %{conn: conn} do
234 conn = get(conn, "/api/statuses/friends_timeline.json")
235 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
238 test "with credentials", %{conn: conn, user: current_user} do
242 ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
244 returned_activities =
245 ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
247 other_user = insert(:user)
248 ActivityBuilder.insert_list(10, %{}, %{user: other_user})
249 since_id = List.last(activities).id
252 Ecto.Changeset.change(current_user, following: [User.ap_followers(user)])
257 |> with_credentials(current_user.nickname, "test")
258 |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
260 response = json_response(conn, 200)
262 assert length(response) == 10
265 Enum.map(returned_activities, fn activity ->
266 ActivityRepresenter.to_map(activity, %{
267 user: User.get_cached_by_ap_id(activity.data["actor"]),
274 describe "GET /statuses/mentions.json" do
277 test "without valid credentials", %{conn: conn} do
278 conn = get(conn, "/api/statuses/mentions.json")
279 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
282 test "with credentials", %{conn: conn, user: current_user} do
284 ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
288 |> with_credentials(current_user.nickname, "test")
289 |> get("/api/statuses/mentions.json")
291 response = json_response(conn, 200)
293 assert length(response) == 1
295 assert Enum.at(response, 0) ==
296 ActivityRepresenter.to_map(activity, %{
298 mentioned: [current_user]
303 describe "GET /api/qvitter/statuses/notifications.json" do
306 test "without valid credentials", %{conn: conn} do
307 conn = get(conn, "/api/qvitter/statuses/notifications.json")
308 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
311 test "with credentials", %{conn: conn, user: current_user} do
312 other_user = insert(:user)
315 ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
319 |> with_credentials(current_user.nickname, "test")
320 |> get("/api/qvitter/statuses/notifications.json")
322 response = json_response(conn, 200)
324 assert length(response) == 1
327 NotificationView.render("notification.json", %{
328 notifications: Notification.for_user(current_user),
334 describe "GET /statuses/user_timeline.json" do
337 test "without any params", %{conn: conn} do
338 conn = get(conn, "/api/statuses/user_timeline.json")
340 assert json_response(conn, 400) == %{
341 "error" => "You need to specify screen_name or user_id",
342 "request" => "/api/statuses/user_timeline.json"
346 test "with user_id", %{conn: conn} do
348 {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
350 conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
351 response = json_response(conn, 200)
352 assert length(response) == 1
353 assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
356 test "with screen_name", %{conn: conn} do
358 {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
360 conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
361 response = json_response(conn, 200)
362 assert length(response) == 1
363 assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
366 test "with credentials", %{conn: conn, user: current_user} do
367 {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
371 |> with_credentials(current_user.nickname, "test")
372 |> get("/api/statuses/user_timeline.json")
374 response = json_response(conn, 200)
376 assert length(response) == 1
377 assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
380 test "with credentials with user_id", %{conn: conn, user: current_user} do
382 {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
386 |> with_credentials(current_user.nickname, "test")
387 |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
389 response = json_response(conn, 200)
391 assert length(response) == 1
392 assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
395 test "with credentials screen_name", %{conn: conn, user: current_user} do
397 {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
401 |> with_credentials(current_user.nickname, "test")
402 |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
404 response = json_response(conn, 200)
406 assert length(response) == 1
407 assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
411 describe "POST /friendships/create.json" do
414 test "without valid credentials", %{conn: conn} do
415 conn = post(conn, "/api/friendships/create.json")
416 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
419 test "with credentials", %{conn: conn, user: current_user} do
420 followed = insert(:user)
424 |> with_credentials(current_user.nickname, "test")
425 |> post("/api/friendships/create.json", %{user_id: followed.id})
427 current_user = Repo.get(User, current_user.id)
428 assert User.ap_followers(followed) in current_user.following
430 assert json_response(conn, 200) ==
431 UserView.render("show.json", %{user: followed, for: current_user})
435 describe "POST /friendships/destroy.json" do
438 test "without valid credentials", %{conn: conn} do
439 conn = post(conn, "/api/friendships/destroy.json")
440 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
443 test "with credentials", %{conn: conn, user: current_user} do
444 followed = insert(:user)
446 {:ok, current_user} = User.follow(current_user, followed)
447 assert User.ap_followers(followed) in current_user.following
448 ActivityPub.follow(current_user, followed)
452 |> with_credentials(current_user.nickname, "test")
453 |> post("/api/friendships/destroy.json", %{user_id: followed.id})
455 current_user = Repo.get(User, current_user.id)
456 assert current_user.following == [current_user.ap_id]
458 assert json_response(conn, 200) ==
459 UserView.render("show.json", %{user: followed, for: current_user})
463 describe "POST /blocks/create.json" do
466 test "without valid credentials", %{conn: conn} do
467 conn = post(conn, "/api/blocks/create.json")
468 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
471 test "with credentials", %{conn: conn, user: current_user} do
472 blocked = insert(:user)
476 |> with_credentials(current_user.nickname, "test")
477 |> post("/api/blocks/create.json", %{user_id: blocked.id})
479 current_user = Repo.get(User, current_user.id)
480 assert User.blocks?(current_user, blocked)
482 assert json_response(conn, 200) ==
483 UserView.render("show.json", %{user: blocked, for: current_user})
487 describe "POST /blocks/destroy.json" do
490 test "without valid credentials", %{conn: conn} do
491 conn = post(conn, "/api/blocks/destroy.json")
492 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
495 test "with credentials", %{conn: conn, user: current_user} do
496 blocked = insert(:user)
498 {:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
499 assert User.blocks?(current_user, blocked)
503 |> with_credentials(current_user.nickname, "test")
504 |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
506 current_user = Repo.get(User, current_user.id)
507 assert current_user.info["blocks"] == []
509 assert json_response(conn, 200) ==
510 UserView.render("show.json", %{user: blocked, for: current_user})
514 describe "GET /help/test.json" do
515 test "returns \"ok\"", %{conn: conn} do
516 conn = get(conn, "/api/help/test.json")
517 assert json_response(conn, 200) == "ok"
521 describe "POST /api/qvitter/update_avatar.json" do
524 test "without valid credentials", %{conn: conn} do
525 conn = post(conn, "/api/qvitter/update_avatar.json")
526 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
529 test "with credentials", %{conn: conn, user: current_user} do
530 avatar_image = File.read!("test/fixtures/avatar_data_uri")
534 |> with_credentials(current_user.nickname, "test")
535 |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
537 current_user = Repo.get(User, current_user.id)
538 assert is_map(current_user.avatar)
540 assert json_response(conn, 200) ==
541 UserView.render("show.json", %{user: current_user, for: current_user})
545 describe "GET /api/qvitter/mutes.json" do
548 test "unimplemented mutes without valid credentials", %{conn: conn} do
549 conn = get(conn, "/api/qvitter/mutes.json")
550 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
553 test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
556 |> with_credentials(current_user.nickname, "test")
557 |> get("/api/qvitter/mutes.json")
559 current_user = Repo.get(User, current_user.id)
561 assert [] = json_response(conn, 200)
565 describe "POST /api/favorites/create/:id" do
568 test "without valid credentials", %{conn: conn} do
569 note_activity = insert(:note_activity)
570 conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
571 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
574 test "with credentials", %{conn: conn, user: current_user} do
575 note_activity = insert(:note_activity)
579 |> with_credentials(current_user.nickname, "test")
580 |> post("/api/favorites/create/#{note_activity.id}.json")
582 assert json_response(conn, 200)
585 test "with credentials, invalid param", %{conn: conn, user: current_user} do
588 |> with_credentials(current_user.nickname, "test")
589 |> post("/api/favorites/create/wrong.json")
591 assert json_response(conn, 400)
594 test "with credentials, invalid activity", %{conn: conn, user: current_user} do
597 |> with_credentials(current_user.nickname, "test")
598 |> post("/api/favorites/create/1.json")
600 assert json_response(conn, 500)
604 describe "POST /api/favorites/destroy/:id" do
607 test "without valid credentials", %{conn: conn} do
608 note_activity = insert(:note_activity)
609 conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
610 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
613 test "with credentials", %{conn: conn, user: current_user} do
614 note_activity = insert(:note_activity)
615 object = Object.get_by_ap_id(note_activity.data["object"]["id"])
616 ActivityPub.like(current_user, object)
620 |> with_credentials(current_user.nickname, "test")
621 |> post("/api/favorites/destroy/#{note_activity.id}.json")
623 assert json_response(conn, 200)
627 describe "POST /api/statuses/retweet/:id" do
630 test "without valid credentials", %{conn: conn} do
631 note_activity = insert(:note_activity)
632 conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
633 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
636 test "with credentials", %{conn: conn, user: current_user} do
637 note_activity = insert(:note_activity)
639 request_path = "/api/statuses/retweet/#{note_activity.id}.json"
643 |> with_credentials(current_user.nickname, "test")
644 |> post(request_path)
646 activity = Repo.get(Activity, note_activity.id)
647 activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
649 assert json_response(response, 200) ==
650 ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
654 describe "POST /api/statuses/unretweet/:id" do
657 test "without valid credentials", %{conn: conn} do
658 note_activity = insert(:note_activity)
659 conn = post(conn, "/api/statuses/unretweet/#{note_activity.id}.json")
660 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
663 test "with credentials", %{conn: conn, user: current_user} do
664 note_activity = insert(:note_activity)
666 request_path = "/api/statuses/retweet/#{note_activity.id}.json"
670 |> with_credentials(current_user.nickname, "test")
671 |> post(request_path)
673 request_path = String.replace(request_path, "retweet", "unretweet")
677 |> with_credentials(current_user.nickname, "test")
678 |> post(request_path)
680 activity = Repo.get(Activity, note_activity.id)
681 activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
683 assert json_response(response, 200) ==
684 ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
688 describe "POST /api/account/register" do
689 test "it creates a new user", %{conn: conn} do
691 "nickname" => "lain",
692 "email" => "lain@wired.jp",
693 "fullname" => "lain iwakura",
694 "bio" => "close the world.",
695 "password" => "bear",
701 |> post("/api/account/register", data)
703 user = json_response(conn, 200)
705 fetched_user = Repo.get_by(User, nickname: "lain")
706 assert user == UserView.render("show.json", %{user: fetched_user})
709 test "it returns errors on a problem", %{conn: conn} do
711 "email" => "lain@wired.jp",
712 "fullname" => "lain iwakura",
713 "bio" => "close the world.",
714 "password" => "bear",
720 |> post("/api/account/register", data)
722 errors = json_response(conn, 400)
724 assert is_binary(errors["error"])
728 describe "GET /api/externalprofile/show" do
729 test "it returns the user", %{conn: conn} do
731 other_user = insert(:user)
735 |> assign(:user, user)
736 |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
738 assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
742 describe "GET /api/statuses/followers" do
743 test "it returns a user's followers", %{conn: conn} do
745 follower_one = insert(:user)
746 follower_two = insert(:user)
747 _not_follower = insert(:user)
749 {:ok, follower_one} = User.follow(follower_one, user)
750 {:ok, follower_two} = User.follow(follower_two, user)
754 |> assign(:user, user)
755 |> get("/api/statuses/followers")
757 expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
758 result = json_response(conn, 200)
759 assert Enum.sort(expected) == Enum.sort(result)
763 describe "GET /api/statuses/friends" do
764 test "it returns the logged in user's friends", %{conn: conn} do
766 followed_one = insert(:user)
767 followed_two = insert(:user)
768 _not_followed = insert(:user)
770 {:ok, user} = User.follow(user, followed_one)
771 {:ok, user} = User.follow(user, followed_two)
775 |> assign(:user, user)
776 |> get("/api/statuses/friends")
778 expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
779 result = json_response(conn, 200)
780 assert Enum.sort(expected) == Enum.sort(result)
783 test "it returns a given user's friends with user_id", %{conn: conn} do
785 followed_one = insert(:user)
786 followed_two = insert(:user)
787 _not_followed = insert(:user)
789 {:ok, user} = User.follow(user, followed_one)
790 {:ok, user} = User.follow(user, followed_two)
794 |> assign(:user, user)
795 |> get("/api/statuses/friends", %{"user_id" => user.id})
797 assert MapSet.equal?(
798 MapSet.new(json_response(conn, 200)),
800 UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
805 test "it returns a given user's friends with screen_name", %{conn: conn} do
807 followed_one = insert(:user)
808 followed_two = insert(:user)
809 _not_followed = insert(:user)
811 {:ok, user} = User.follow(user, followed_one)
812 {:ok, user} = User.follow(user, followed_two)
816 |> assign(:user, user)
817 |> get("/api/statuses/friends", %{"screen_name" => user.nickname})
819 assert MapSet.equal?(
820 MapSet.new(json_response(conn, 200)),
822 UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
828 describe "GET /friends/ids" do
829 test "it returns a user's friends", %{conn: conn} do
831 followed_one = insert(:user)
832 followed_two = insert(:user)
833 _not_followed = insert(:user)
835 {:ok, user} = User.follow(user, followed_one)
836 {:ok, user} = User.follow(user, followed_two)
840 |> assign(:user, user)
841 |> get("/api/friends/ids")
843 expected = [followed_one.id, followed_two.id]
845 assert MapSet.equal?(
846 MapSet.new(Poison.decode!(json_response(conn, 200))),
852 describe "POST /api/account/update_profile.json" do
853 test "it updates a user's profile", %{conn: conn} do
858 |> assign(:user, user)
859 |> post("/api/account/update_profile.json", %{
860 "name" => "new name",
861 "description" => "new description"
864 user = Repo.get!(User, user.id)
865 assert user.name == "new name"
866 assert user.bio == "new description"
868 assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
871 test "it locks an account", %{conn: conn} do
876 |> assign(:user, user)
877 |> post("/api/account/update_profile.json", %{
881 user = Repo.get!(User, user.id)
882 assert user.info["locked"] == true
884 assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
887 test "it unlocks an account", %{conn: conn} do
892 |> assign(:user, user)
893 |> post("/api/account/update_profile.json", %{
897 user = Repo.get!(User, user.id)
898 assert user.info["locked"] == false
900 assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
904 defp valid_user(_context) do
909 defp with_credentials(conn, username, password) do
910 header_content = "Basic " <> Base.encode64("#{username}:#{password}")
911 put_req_header(conn, "authorization", header_content)
914 describe "GET /api/search.json" do
915 test "it returns search results", %{conn: conn} do
917 user_two = insert(:user, %{nickname: "shp@shitposter.club"})
919 {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
920 {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
924 |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
926 assert [status] = json_response(conn, 200)
927 assert status["id"] == activity.id
931 describe "GET /api/statusnet/tags/timeline/:tag.json" do
932 test "it returns the tags timeline", %{conn: conn} do
934 user_two = insert(:user, %{nickname: "shp@shitposter.club"})
936 {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
937 {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
941 |> get("/api/statusnet/tags/timeline/2hu.json")
943 assert [status] = json_response(conn, 200)
944 assert status["id"] == activity.id
948 test "Convert newlines to <br> in bio", %{conn: conn} do
953 |> assign(:user, user)
954 |> post("/api/account/update_profile.json", %{
955 "description" => "Hello,\r\nWorld! I\n am a test."
958 user = Repo.get!(User, user.id)
959 assert user.bio == "Hello,<br>World! I<br> am a test."
962 describe "POST /api/pleroma/change_password" do
965 test "without credentials", %{conn: conn} do
966 conn = post(conn, "/api/pleroma/change_password")
967 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
970 test "with credentials and invalid password", %{conn: conn, user: current_user} do
973 |> with_credentials(current_user.nickname, "test")
974 |> post("/api/pleroma/change_password", %{
976 "new_password" => "newpass",
977 "new_password_confirmation" => "newpass"
980 assert json_response(conn, 200) == %{"error" => "Invalid password."}
983 test "with credentials, valid password and new password and confirmation not matching", %{
989 |> with_credentials(current_user.nickname, "test")
990 |> post("/api/pleroma/change_password", %{
991 "password" => "test",
992 "new_password" => "newpass",
993 "new_password_confirmation" => "notnewpass"
996 assert json_response(conn, 200) == %{
997 "error" => "New password does not match confirmation."
1001 test "with credentials, valid password and invalid new password", %{
1007 |> with_credentials(current_user.nickname, "test")
1008 |> post("/api/pleroma/change_password", %{
1009 "password" => "test",
1010 "new_password" => "",
1011 "new_password_confirmation" => ""
1014 assert json_response(conn, 200) == %{
1015 "error" => "New password can't be blank."
1019 test "with credentials, valid password and matching new password and confirmation", %{
1025 |> with_credentials(current_user.nickname, "test")
1026 |> post("/api/pleroma/change_password", %{
1027 "password" => "test",
1028 "new_password" => "newpass",
1029 "new_password_confirmation" => "newpass"
1032 assert json_response(conn, 200) == %{"status" => "success"}
1033 fetched_user = Repo.get(User, current_user.id)
1034 assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
1038 describe "POST /api/pleroma/delete_account" do
1041 test "without credentials", %{conn: conn} do
1042 conn = post(conn, "/api/pleroma/delete_account")
1043 assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
1046 test "with credentials and invalid password", %{conn: conn, user: current_user} do
1049 |> with_credentials(current_user.nickname, "test")
1050 |> post("/api/pleroma/delete_account", %{"password" => "hi"})
1052 assert json_response(conn, 200) == %{"error" => "Invalid password."}
1055 test "with credentials and valid password", %{conn: conn, user: current_user} do
1058 |> with_credentials(current_user.nickname, "test")
1059 |> post("/api/pleroma/delete_account", %{"password" => "test"})
1061 assert json_response(conn, 200) == %{"status" => "success"}
1062 # Wait a second for the started task to end
1067 describe "GET /api/pleroma/friend_requests" do
1068 test "it lists friend requests" do
1069 user = insert(:user, %{info: %{"locked" => true}})
1070 other_user = insert(:user)
1072 {:ok, activity} = ActivityPub.follow(other_user, user)
1074 user = Repo.get(User, user.id)
1075 other_user = Repo.get(User, other_user.id)
1077 assert User.following?(other_user, user) == false
1081 |> assign(:user, user)
1082 |> get("/api/pleroma/friend_requests")
1084 assert [relationship] = json_response(conn, 200)
1085 assert other_user.id == relationship["id"]
1089 describe "POST /api/pleroma/friendships/approve" do
1090 test "it approves a friend request" do
1091 user = insert(:user, %{info: %{"locked" => true}})
1092 other_user = insert(:user)
1094 {:ok, activity} = ActivityPub.follow(other_user, user)
1096 user = Repo.get(User, user.id)
1097 other_user = Repo.get(User, other_user.id)
1099 assert User.following?(other_user, user) == false
1103 |> assign(:user, user)
1104 |> post("/api/pleroma/friendships/approve", %{"user_id" => to_string(other_user.id)})
1106 assert relationship = json_response(conn, 200)
1107 assert other_user.id == relationship["id"]
1108 assert relationship["follows_you"] == true
1112 describe "POST /api/pleroma/friendships/deny" do
1113 test "it denies a friend request" do
1114 user = insert(:user, %{info: %{"locked" => true}})
1115 other_user = insert(:user)
1117 {:ok, activity} = ActivityPub.follow(other_user, user)
1119 user = Repo.get(User, user.id)
1120 other_user = Repo.get(User, other_user.id)
1122 assert User.following?(other_user, user) == false
1126 |> assign(:user, user)
1127 |> post("/api/pleroma/friendships/deny", %{"user_id" => to_string(other_user.id)})
1129 assert relationship = json_response(conn, 200)
1130 assert other_user.id == relationship["id"]
1131 assert relationship["follows_you"] == false