git.squeep.com Git - akkoma/blob - test/web/twitter_api/twitter_api_controller_test.exs

   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}
   6   alias Pleroma.Web.ActivityPub.ActivityPub
   7   alias Pleroma.Web.TwitterAPI.UserView
   8   alias Pleroma.Web.CommonAPI
   9
  10   import Pleroma.Factory
  11
  12   describe "POST /api/account/verify_credentials" do
  13     setup [:valid_user]
  14     test "without valid credentials", %{conn: conn} do
  15       conn = post conn, "/api/account/verify_credentials.json"
  16       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  17     end
  18
  19     test "with credentials", %{conn: conn, user: user} do
  20       conn = conn
  21         |> with_credentials(user.nickname, "test")
  22         |> post("/api/account/verify_credentials.json")
  23
  24       assert json_response(conn, 200) == UserView.render("show.json", %{user: user})
  25     end
  26   end
  27
  28   describe "POST /api/account/most_recent_notification" do
  29     setup [:valid_user]
  30     test "without valid credentials", %{conn: conn} do
  31       conn = post conn, "/api/account/most_recent_notification.json"
  32       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  33     end
  34
  35     test "with credentials", %{conn: conn, user: user} do
  36       conn = conn
  37         |> with_credentials(user.nickname, "test")
  38         |> post("/api/account/most_recent_notification.json", %{id: "200"})
  39
  40       assert json_response(conn, 200)
  41       user = User.get_by_nickname(user.nickname)
  42       assert user.info["most_recent_notification"] == 200
  43     end
  44   end
  45
  46   describe "POST /statuses/update.json" do
  47     setup [:valid_user]
  48     test "without valid credentials", %{conn: conn} do
  49       conn = post conn, "/api/statuses/update.json"
  50       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  51     end
  52
  53     test "with credentials", %{conn: conn, user: user} do
  54       conn_with_creds = conn |> with_credentials(user.nickname, "test")
  55       request_path = "/api/statuses/update.json"
  56
  57       error_response = %{"request" => request_path,
  58                          "error" => "Client must provide a 'status' parameter with a value."}
  59       conn = conn_with_creds |> post(request_path)
  60       assert json_response(conn, 400) == error_response
  61
  62       conn = conn_with_creds |> post(request_path, %{ status: "" })
  63       assert json_response(conn, 400) == error_response
  64
  65       conn = conn_with_creds |> post(request_path, %{ status: " " })
  66       assert json_response(conn, 400) == error_response
  67
  68       conn =  conn_with_creds |> post(request_path, %{ status: "Nice meme." })
  69       assert json_response(conn, 200) == ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
  70     end
  71   end
  72
  73   describe "GET /statuses/public_timeline.json" do
  74     test "returns statuses", %{conn: conn} do
  75       {:ok, user} = UserBuilder.insert
  76       activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
  77       ActivityBuilder.insert_list(10, %{}, %{user: user})
  78       since_id = List.last(activities).id
  79
  80       conn = conn
  81         |> get("/api/statuses/public_timeline.json", %{since_id: since_id})
  82
  83       response = json_response(conn, 200)
  84
  85       assert length(response) == 10
  86     end
  87   end
  88
  89   describe "GET /statuses/show/:id.json" do
  90     test "returns one status", %{conn: conn} do
  91       {:ok, user} = UserBuilder.insert
  92       {:ok, activity} = ActivityBuilder.insert(%{}, %{user: user})
  93       actor = Repo.get_by!(User, ap_id: activity.data["actor"])
  94
  95       conn = conn
  96       |> get("/api/statuses/show/#{activity.id}.json")
  97
  98       response = json_response(conn, 200)
  99
 100       assert response == ActivityRepresenter.to_map(activity, %{user: actor})
 101     end
 102   end
 103
 104   describe "GET /statusnet/conversation/:id.json" do
 105     test "returns the statuses in the conversation", %{conn: conn} do
 106       {:ok, _user} = UserBuilder.insert
 107       {:ok, _activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 108       {:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 109       {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
 110
 111       {:ok, object} = Object.context_mapping("2hu") |> Repo.insert
 112       conn = conn
 113       |> get("/api/statusnet/conversation/#{object.id}.json")
 114
 115       response = json_response(conn, 200)
 116
 117       assert length(response) == 2
 118     end
 119   end
 120
 121   describe "GET /statuses/friends_timeline.json" do
 122     setup [:valid_user]
 123     test "without valid credentials", %{conn: conn} do
 124       conn = get conn, "/api/statuses/friends_timeline.json"
 125       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 126     end
 127
 128     test "with credentials", %{conn: conn, user: current_user} do
 129       user = insert(:user)
 130       activities = ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
 131       returned_activities = ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
 132       other_user = insert(:user)
 133       ActivityBuilder.insert_list(10, %{}, %{user: other_user})
 134       since_id = List.last(activities).id
 135
 136       current_user = Ecto.Changeset.change(current_user, following: [User.ap_followers(user)]) |> Repo.update!
 137
 138       conn = conn
 139         |> with_credentials(current_user.nickname, "test")
 140         |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
 141
 142       response = json_response(conn, 200)
 143
 144       assert length(response) == 10
 145       assert response == Enum.map(returned_activities, fn (activity) -> ActivityRepresenter.to_map(activity, %{user: User.get_cached_by_ap_id(activity.data["actor"]), for: current_user}) end)
 146     end
 147   end
 148
 149   describe "GET /statuses/mentions.json" do
 150     setup [:valid_user]
 151     test "without valid credentials", %{conn: conn} do
 152       conn = get conn, "/api/statuses/mentions.json"
 153       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 154     end
 155
 156     test "with credentials", %{conn: conn, user: current_user} do
 157       {:ok, activity} = ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
 158
 159       conn = conn
 160         |> with_credentials(current_user.nickname, "test")
 161         |> get("/api/statuses/mentions.json")
 162
 163       response = json_response(conn, 200)
 164
 165       assert length(response) == 1
 166       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user, mentioned: [current_user]})
 167     end
 168   end
 169
 170   describe "GET /statuses/user_timeline.json" do
 171     setup [:valid_user]
 172     test "without any params", %{conn: conn} do
 173       conn = get(conn, "/api/statuses/user_timeline.json")
 174       assert json_response(conn, 400) == %{"error" => "You need to specify screen_name or user_id", "request" => "/api/statuses/user_timeline.json"}
 175     end
 176
 177     test "with user_id", %{conn: conn} do
 178       user = insert(:user)
 179       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 180
 181       conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
 182       response = json_response(conn, 200)
 183       assert length(response) == 1
 184       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 185     end
 186
 187     test "with screen_name", %{conn: conn} do
 188       user = insert(:user)
 189       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 190
 191       conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 192       response = json_response(conn, 200)
 193       assert length(response) == 1
 194       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 195     end
 196
 197     test "with credentials", %{conn: conn, user: current_user} do
 198       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
 199       conn = conn
 200       |> with_credentials(current_user.nickname, "test")
 201       |> get("/api/statuses/user_timeline.json")
 202
 203       response = json_response(conn, 200)
 204
 205       assert length(response) == 1
 206       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
 207     end
 208
 209     test "with credentials with user_id", %{conn: conn, user: current_user} do
 210       user = insert(:user)
 211       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 212       conn = conn
 213       |> with_credentials(current_user.nickname, "test")
 214       |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
 215
 216       response = json_response(conn, 200)
 217
 218       assert length(response) == 1
 219       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 220     end
 221
 222     test "with credentials screen_name", %{conn: conn, user: current_user} do
 223       user = insert(:user)
 224       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 225       conn = conn
 226       |> with_credentials(current_user.nickname, "test")
 227       |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 228
 229       response = json_response(conn, 200)
 230
 231       assert length(response) == 1
 232       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 233     end
 234   end
 235
 236   describe "POST /friendships/create.json" do
 237     setup [:valid_user]
 238     test "without valid credentials", %{conn: conn} do
 239       conn = post conn, "/api/friendships/create.json"
 240       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 241     end
 242
 243     test "with credentials", %{conn: conn, user: current_user} do
 244       followed = insert(:user)
 245
 246       conn = conn
 247       |> with_credentials(current_user.nickname, "test")
 248       |> post("/api/friendships/create.json", %{user_id: followed.id})
 249
 250       current_user = Repo.get(User, current_user.id)
 251       assert current_user.following == [User.ap_followers(followed)]
 252       assert json_response(conn, 200) == UserView.render("show.json", %{user: followed, for: current_user})
 253     end
 254   end
 255
 256   describe "POST /friendships/destroy.json" do
 257     setup [:valid_user]
 258     test "without valid credentials", %{conn: conn} do
 259       conn = post conn, "/api/friendships/destroy.json"
 260       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 261     end
 262
 263     test "with credentials", %{conn: conn, user: current_user} do
 264       followed = insert(:user)
 265
 266       {:ok, current_user} = User.follow(current_user, followed)
 267       assert current_user.following == [User.ap_followers(followed)]
 268       ActivityPub.follow(current_user, followed)
 269
 270       conn = conn
 271       |> with_credentials(current_user.nickname, "test")
 272       |> post("/api/friendships/destroy.json", %{user_id: followed.id})
 273
 274       current_user = Repo.get(User, current_user.id)
 275       assert current_user.following == []
 276       assert json_response(conn, 200) == UserView.render("show.json", %{user: followed, for: current_user})
 277     end
 278   end
 279
 280   describe "POST /blocks/create.json" do
 281     setup [:valid_user]
 282     test "without valid credentials", %{conn: conn} do
 283       conn = post conn, "/api/blocks/create.json"
 284       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 285     end
 286
 287     test "with credentials", %{conn: conn, user: current_user} do
 288       blocked = insert(:user)
 289
 290       conn = conn
 291       |> with_credentials(current_user.nickname, "test")
 292       |> post("/api/blocks/create.json", %{user_id: blocked.id})
 293
 294       current_user = Repo.get(User, current_user.id)
 295       assert User.blocks?(current_user, blocked)
 296       assert json_response(conn, 200) == UserView.render("show.json", %{user: blocked, for: current_user})
 297     end
 298   end
 299
 300   describe "POST /blocks/destroy.json" do
 301     setup [:valid_user]
 302     test "without valid credentials", %{conn: conn} do
 303       conn = post conn, "/api/blocks/destroy.json"
 304       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 305     end
 306
 307     test "with credentials", %{conn: conn, user: current_user} do
 308       blocked = insert(:user)
 309
 310       {:ok, current_user} = User.block(current_user, blocked)
 311       assert User.blocks?(current_user, blocked)
 312
 313       conn = conn
 314       |> with_credentials(current_user.nickname, "test")
 315       |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
 316
 317       current_user = Repo.get(User, current_user.id)
 318       assert current_user.info["blocks"] == []
 319       assert json_response(conn, 200) == UserView.render("show.json", %{user: blocked, for: current_user})
 320     end
 321   end
 322
 323   describe "GET /help/test.json" do
 324     test "returns \"ok\"", %{conn: conn} do
 325       conn = get conn, "/api/help/test.json"
 326       assert json_response(conn, 200) == "ok"
 327     end
 328   end
 329
 330   describe "POST /api/qvitter/update_avatar.json" do
 331     setup [:valid_user]
 332     test "without valid credentials", %{conn: conn} do
 333       conn = post conn, "/api/qvitter/update_avatar.json"
 334       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 335     end
 336
 337     test "with credentials", %{conn: conn, user: current_user} do
 338       conn = conn
 339       |> with_credentials(current_user.nickname, "test")
 340       |> post("/api/qvitter/update_avatar.json", %{img: Pleroma.Web.ActivityPub.ActivityPubTest.data_uri})
 341
 342       current_user = Repo.get(User, current_user.id)
 343       assert is_map(current_user.avatar)
 344       assert json_response(conn, 200) == UserView.render("show.json", %{user: current_user, for: current_user})
 345     end
 346   end
 347
 348   describe "POST /api/favorites/create/:id" do
 349     setup [:valid_user]
 350     test "without valid credentials", %{conn: conn} do
 351       note_activity = insert(:note_activity)
 352       conn = post conn, "/api/favorites/create/#{note_activity.id}.json"
 353       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 354     end
 355
 356     test "with credentials", %{conn: conn, user: current_user} do
 357       note_activity = insert(:note_activity)
 358
 359       conn = conn
 360       |> with_credentials(current_user.nickname, "test")
 361       |> post("/api/favorites/create/#{note_activity.id}.json")
 362
 363       assert json_response(conn, 200)
 364     end
 365   end
 366
 367   describe "POST /api/favorites/destroy/:id" do
 368     setup [:valid_user]
 369     test "without valid credentials", %{conn: conn} do
 370       note_activity = insert(:note_activity)
 371       conn = post conn, "/api/favorites/destroy/#{note_activity.id}.json"
 372       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 373     end
 374
 375     test "with credentials", %{conn: conn, user: current_user} do
 376       note_activity = insert(:note_activity)
 377       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 378       ActivityPub.like(current_user, object)
 379
 380       conn = conn
 381       |> with_credentials(current_user.nickname, "test")
 382       |> post("/api/favorites/destroy/#{note_activity.id}.json")
 383
 384       assert json_response(conn, 200)
 385     end
 386   end
 387
 388   describe "POST /api/statuses/retweet/:id" do
 389     setup [:valid_user]
 390     test "without valid credentials", %{conn: conn} do
 391       note_activity = insert(:note_activity)
 392       conn = post conn, "/api/statuses/retweet/#{note_activity.id}.json"
 393       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 394     end
 395
 396     test "with credentials", %{conn: conn, user: current_user} do
 397       note_activity = insert(:note_activity)
 398
 399       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 400
 401       response = conn
 402       |> with_credentials(current_user.nickname, "test")
 403       |> post(request_path)
 404       activity = Repo.get(Activity, note_activity.id)
 405       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 406       assert json_response(response, 200) == ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 407     end
 408   end
 409
 410   describe "POST /api/account/register" do
 411     test "it creates a new user", %{conn: conn} do
 412       data = %{
 413         "nickname" => "lain",
 414         "email" => "lain@wired.jp",
 415         "fullname" => "lain iwakura",
 416         "bio" => "close the world.",
 417         "password" => "bear",
 418         "confirm" => "bear"
 419       }
 420
 421       conn = conn
 422       |> post("/api/account/register", data)
 423
 424       user = json_response(conn, 200)
 425
 426       fetched_user = Repo.get_by(User, nickname: "lain")
 427       assert user == UserView.render("show.json", %{user: fetched_user})
 428     end
 429
 430     test "it returns errors on a problem", %{conn: conn} do
 431       data = %{
 432         "email" => "lain@wired.jp",
 433         "fullname" => "lain iwakura",
 434         "bio" => "close the world.",
 435         "password" => "bear",
 436         "confirm" => "bear"
 437       }
 438
 439       conn = conn
 440       |> post("/api/account/register", data)
 441
 442       errors = json_response(conn, 400)
 443
 444       assert is_binary(errors["error"])
 445     end
 446   end
 447
 448   describe "GET /api/externalprofile/show" do
 449     test "it returns the user", %{conn: conn} do
 450       user = insert(:user)
 451       other_user = insert(:user)
 452
 453       conn = conn
 454       |> assign(:user, user)
 455       |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
 456
 457       assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
 458     end
 459   end
 460
 461   describe "GET /api/statuses/followers" do
 462     test "it returns a user's followers", %{conn: conn} do
 463       user = insert(:user)
 464       follower_one = insert(:user)
 465       follower_two = insert(:user)
 466       not_follower = insert(:user)
 467
 468       {:ok, follower_one} = User.follow(follower_one, user)
 469       {:ok, follower_two} = User.follow(follower_two, user)
 470
 471       conn = conn
 472       |> assign(:user, user)
 473       |> get("/api/statuses/followers")
 474
 475       assert json_response(conn, 200) == UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
 476     end
 477   end
 478
 479   describe "GET /api/statuses/friends" do
 480     test "it returns a user's friends", %{conn: conn} do
 481       user = insert(:user)
 482       followed_one = insert(:user)
 483       followed_two = insert(:user)
 484       not_followed = insert(:user)
 485
 486       {:ok, user} = User.follow(user, followed_one)
 487       {:ok, user} = User.follow(user, followed_two)
 488
 489       conn = conn
 490       |> assign(:user, user)
 491       |> get("/api/statuses/friends")
 492
 493       assert json_response(conn, 200) == UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 494     end
 495   end
 496
 497   describe "GET /friends/ids" do
 498     test "it returns a user's friends", %{conn: conn} do
 499       user = insert(:user)
 500       followed_one = insert(:user)
 501       followed_two = insert(:user)
 502       not_followed = insert(:user)
 503
 504       {:ok, user} = User.follow(user, followed_one)
 505       {:ok, user} = User.follow(user, followed_two)
 506
 507       conn = conn
 508       |> assign(:user, user)
 509       |> get("/api/friends/ids")
 510
 511       expected = Poison.encode!([followed_one.id, followed_two.id])
 512       assert json_response(conn, 200) == expected
 513     end
 514   end
 515
 516   describe "POST /api/account/update_profile.json" do
 517     test "it updates a user's profile" do
 518       user = insert(:user)
 519
 520       conn = conn
 521       |> assign(:user, user)
 522       |> post("/api/account/update_profile.json", %{"name" => "new name", "description" => "new description"})
 523
 524       user = Repo.get!(User, user.id)
 525       assert user.name == "new name"
 526       assert user.bio == "new description"
 527
 528       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 529     end
 530   end
 531
 532   defp valid_user(_context) do
 533     user = insert(:user)
 534     [user: user]
 535   end
 536
 537   defp with_credentials(conn, username, password) do
 538     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
 539     put_req_header(conn, "authorization", header_content)
 540   end
 541
 542   describe "GET /api/search.json" do
 543     test "it returns search results", %{conn: conn} do
 544       user = insert(:user)
 545       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 546
 547       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 548       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 549
 550       conn = conn
 551       |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
 552
 553       assert [status] = json_response(conn, 200)
 554       assert status["id"] == activity.id
 555     end
 556   end
 557
 558   describe "GET /api/statusnet/tags/timeline/:tag.json" do
 559     test "it returns the tags timeline" do
 560       user = insert(:user)
 561       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 562
 563       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
 564       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 565
 566       conn = conn
 567       |> get("/api/statusnet/tags/timeline/2hu.json")
 568
 569       assert [status] = json_response(conn, 200)
 570       assert status["id"] == activity.id
 571     end
 572   end
 573 end