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, 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
  11   alias Comeonin.Pbkdf2
  12
  13   import Pleroma.Factory
  14
  15   describe "POST /api/account/verify_credentials" do
  16     setup [:valid_user]
  17
  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."}
  21     end
  22
  23     test "with credentials", %{conn: conn, user: user} do
  24       conn =
  25         conn
  26         |> with_credentials(user.nickname, "test")
  27         |> post("/api/account/verify_credentials.json")
  28
  29       assert response = json_response(conn, 200)
  30       assert response == UserView.render("show.json", %{user: user, token: response["token"]})
  31     end
  32   end
  33
  34   describe "POST /api/account/most_recent_notification" do
  35     setup [:valid_user]
  36
  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."}
  40     end
  41
  42     test "with credentials", %{conn: conn, user: user} do
  43       conn =
  44         conn
  45         |> with_credentials(user.nickname, "test")
  46         |> post("/api/account/most_recent_notification.json", %{id: "200"})
  47
  48       assert json_response(conn, 200)
  49       user = User.get_by_nickname(user.nickname)
  50       assert user.info["most_recent_notification"] == 200
  51     end
  52   end
  53
  54   describe "POST /statuses/update.json" do
  55     setup [:valid_user]
  56
  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."}
  60     end
  61
  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"
  65
  66       error_response = %{
  67         "request" => request_path,
  68         "error" => "Client must provide a 'status' parameter with a value."
  69       }
  70
  71       conn = conn_with_creds |> post(request_path)
  72       assert json_response(conn, 400) == error_response
  73
  74       conn = conn_with_creds |> post(request_path, %{status: ""})
  75       assert json_response(conn, 400) == error_response
  76
  77       conn = conn_with_creds |> post(request_path, %{status: " "})
  78       assert json_response(conn, 400) == error_response
  79
  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"})
  82
  83       assert json_response(conn, 200) ==
  84                ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
  85     end
  86   end
  87
  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
  94
  95       conn =
  96         conn
  97         |> get("/api/statuses/public_timeline.json", %{since_id: since_id})
  98
  99       response = json_response(conn, 200)
 100
 101       assert length(response) == 10
 102     end
 103
 104     test "returns 403 to unauthenticated request when the instance is not public" do
 105       instance =
 106         Application.get_env(:pleroma, :instance)
 107         |> Keyword.put(:public, false)
 108
 109       Application.put_env(:pleroma, :instance, instance)
 110
 111       conn
 112       |> get("/api/statuses/public_timeline.json")
 113       |> json_response(403)
 114
 115       instance =
 116         Application.get_env(:pleroma, :instance)
 117         |> Keyword.put(:public, true)
 118
 119       Application.put_env(:pleroma, :instance, instance)
 120     end
 121
 122     test "returns 200 to unauthenticated request when the instance is public" do
 123       conn
 124       |> get("/api/statuses/public_timeline.json")
 125       |> json_response(200)
 126     end
 127   end
 128
 129   describe "GET /statuses/public_and_external_timeline.json" do
 130     test "returns 403 to unauthenticated request when the instance is not public" do
 131       instance =
 132         Application.get_env(:pleroma, :instance)
 133         |> Keyword.put(:public, false)
 134
 135       Application.put_env(:pleroma, :instance, instance)
 136
 137       conn
 138       |> get("/api/statuses/public_and_external_timeline.json")
 139       |> json_response(403)
 140
 141       instance =
 142         Application.get_env(:pleroma, :instance)
 143         |> Keyword.put(:public, true)
 144
 145       Application.put_env(:pleroma, :instance, instance)
 146     end
 147
 148     test "returns 200 to unauthenticated request when the instance is public" do
 149       conn
 150       |> get("/api/statuses/public_and_external_timeline.json")
 151       |> json_response(200)
 152     end
 153   end
 154
 155   describe "GET /statuses/show/:id.json" do
 156     test "returns one status", %{conn: conn} do
 157       user = insert(:user)
 158       {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
 159       actor = Repo.get_by!(User, ap_id: activity.data["actor"])
 160
 161       conn =
 162         conn
 163         |> get("/api/statuses/show/#{activity.id}.json")
 164
 165       response = json_response(conn, 200)
 166
 167       assert response == ActivityRepresenter.to_map(activity, %{user: actor})
 168     end
 169   end
 170
 171   describe "GET /users/show.json" do
 172     test "gets user with screen_name", %{conn: conn} do
 173       user = insert(:user)
 174
 175       conn =
 176         conn
 177         |> get("/api/users/show.json", %{"screen_name" => user.nickname})
 178
 179       response = json_response(conn, 200)
 180
 181       assert response["id"] == user.id
 182     end
 183
 184     test "gets user with user_id", %{conn: conn} do
 185       user = insert(:user)
 186
 187       conn =
 188         conn
 189         |> get("/api/users/show.json", %{"user_id" => user.id})
 190
 191       response = json_response(conn, 200)
 192
 193       assert response["id"] == user.id
 194     end
 195
 196     test "gets a user for a logged in user", %{conn: conn} do
 197       user = insert(:user)
 198       logged_in = insert(:user)
 199
 200       {:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})
 201
 202       conn =
 203         conn
 204         |> with_credentials(logged_in.nickname, "test")
 205         |> get("/api/users/show.json", %{"user_id" => user.id})
 206
 207       response = json_response(conn, 200)
 208
 209       assert response["following"] == true
 210     end
 211   end
 212
 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"})
 219
 220       conn =
 221         conn
 222         |> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")
 223
 224       response = json_response(conn, 200)
 225
 226       assert length(response) == 2
 227     end
 228   end
 229
 230   describe "GET /statuses/friends_timeline.json" do
 231     setup [:valid_user]
 232
 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."}
 236     end
 237
 238     test "with credentials", %{conn: conn, user: current_user} do
 239       user = insert(:user)
 240
 241       activities =
 242         ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
 243
 244       returned_activities =
 245         ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
 246
 247       other_user = insert(:user)
 248       ActivityBuilder.insert_list(10, %{}, %{user: other_user})
 249       since_id = List.last(activities).id
 250
 251       current_user =
 252         Ecto.Changeset.change(current_user, following: [User.ap_followers(user)])
 253         |> Repo.update!()
 254
 255       conn =
 256         conn
 257         |> with_credentials(current_user.nickname, "test")
 258         |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
 259
 260       response = json_response(conn, 200)
 261
 262       assert length(response) == 10
 263
 264       assert response ==
 265                Enum.map(returned_activities, fn activity ->
 266                  ActivityRepresenter.to_map(activity, %{
 267                    user: User.get_cached_by_ap_id(activity.data["actor"]),
 268                    for: current_user
 269                  })
 270                end)
 271     end
 272   end
 273
 274   describe "GET /statuses/mentions.json" do
 275     setup [:valid_user]
 276
 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."}
 280     end
 281
 282     test "with credentials", %{conn: conn, user: current_user} do
 283       {:ok, activity} =
 284         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
 285
 286       conn =
 287         conn
 288         |> with_credentials(current_user.nickname, "test")
 289         |> get("/api/statuses/mentions.json")
 290
 291       response = json_response(conn, 200)
 292
 293       assert length(response) == 1
 294
 295       assert Enum.at(response, 0) ==
 296                ActivityRepresenter.to_map(activity, %{
 297                  user: current_user,
 298                  mentioned: [current_user]
 299                })
 300     end
 301   end
 302
 303   describe "GET /api/qvitter/statuses/notifications.json" do
 304     setup [:valid_user]
 305
 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."}
 309     end
 310
 311     test "with credentials", %{conn: conn, user: current_user} do
 312       other_user = insert(:user)
 313
 314       {:ok, _activity} =
 315         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
 316
 317       conn =
 318         conn
 319         |> with_credentials(current_user.nickname, "test")
 320         |> get("/api/qvitter/statuses/notifications.json")
 321
 322       response = json_response(conn, 200)
 323
 324       assert length(response) == 1
 325
 326       assert response ==
 327                NotificationView.render("notification.json", %{
 328                  notifications: Notification.for_user(current_user),
 329                  for: current_user
 330                })
 331     end
 332   end
 333
 334   describe "POST /api/qvitter/statuses/notifications/read" do
 335     setup [:valid_user]
 336
 337     test "without valid credentials", %{conn: conn} do
 338       conn = post(conn, "/api/qvitter/statuses/notifications/read", %{"latest_id" => 1_234_567})
 339       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 340     end
 341
 342     test "with credentials, without any params", %{conn: conn, user: current_user} do
 343       conn =
 344         conn
 345         |> with_credentials(current_user.nickname, "test")
 346         |> post("/api/qvitter/statuses/notifications/read")
 347
 348       assert json_response(conn, 400) == %{
 349                "error" => "You need to specify latest_id",
 350                "request" => "/api/qvitter/statuses/notifications/read"
 351              }
 352     end
 353
 354     test "with credentials, with params", %{conn: conn, user: current_user} do
 355       other_user = insert(:user)
 356
 357       {:ok, _activity} =
 358         ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
 359
 360       response_conn =
 361         conn
 362         |> with_credentials(current_user.nickname, "test")
 363         |> get("/api/qvitter/statuses/notifications.json")
 364
 365       [notification] = response = json_response(response_conn, 200)
 366
 367       assert length(response) == 1
 368
 369       assert notification["is_seen"] == 0
 370
 371       response_conn =
 372         conn
 373         |> with_credentials(current_user.nickname, "test")
 374         |> post("/api/qvitter/statuses/notifications/read", %{"latest_id" => notification["id"]})
 375
 376       [notification] = response = json_response(response_conn, 200)
 377
 378       assert length(response) == 1
 379
 380       assert notification["is_seen"] == 1
 381     end
 382   end
 383
 384   describe "GET /statuses/user_timeline.json" do
 385     setup [:valid_user]
 386
 387     test "without any params", %{conn: conn} do
 388       conn = get(conn, "/api/statuses/user_timeline.json")
 389
 390       assert json_response(conn, 400) == %{
 391                "error" => "You need to specify screen_name or user_id",
 392                "request" => "/api/statuses/user_timeline.json"
 393              }
 394     end
 395
 396     test "with user_id", %{conn: conn} do
 397       user = insert(:user)
 398       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 399
 400       conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
 401       response = json_response(conn, 200)
 402       assert length(response) == 1
 403       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 404     end
 405
 406     test "with screen_name", %{conn: conn} do
 407       user = insert(:user)
 408       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 409
 410       conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 411       response = json_response(conn, 200)
 412       assert length(response) == 1
 413       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 414     end
 415
 416     test "with credentials", %{conn: conn, user: current_user} do
 417       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
 418
 419       conn =
 420         conn
 421         |> with_credentials(current_user.nickname, "test")
 422         |> get("/api/statuses/user_timeline.json")
 423
 424       response = json_response(conn, 200)
 425
 426       assert length(response) == 1
 427       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
 428     end
 429
 430     test "with credentials with user_id", %{conn: conn, user: current_user} do
 431       user = insert(:user)
 432       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 433
 434       conn =
 435         conn
 436         |> with_credentials(current_user.nickname, "test")
 437         |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
 438
 439       response = json_response(conn, 200)
 440
 441       assert length(response) == 1
 442       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 443     end
 444
 445     test "with credentials screen_name", %{conn: conn, user: current_user} do
 446       user = insert(:user)
 447       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 448
 449       conn =
 450         conn
 451         |> with_credentials(current_user.nickname, "test")
 452         |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 453
 454       response = json_response(conn, 200)
 455
 456       assert length(response) == 1
 457       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 458     end
 459   end
 460
 461   describe "POST /friendships/create.json" do
 462     setup [:valid_user]
 463
 464     test "without valid credentials", %{conn: conn} do
 465       conn = post(conn, "/api/friendships/create.json")
 466       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 467     end
 468
 469     test "with credentials", %{conn: conn, user: current_user} do
 470       followed = insert(:user)
 471
 472       conn =
 473         conn
 474         |> with_credentials(current_user.nickname, "test")
 475         |> post("/api/friendships/create.json", %{user_id: followed.id})
 476
 477       current_user = Repo.get(User, current_user.id)
 478       assert User.ap_followers(followed) in current_user.following
 479
 480       assert json_response(conn, 200) ==
 481                UserView.render("show.json", %{user: followed, for: current_user})
 482     end
 483   end
 484
 485   describe "POST /friendships/destroy.json" do
 486     setup [:valid_user]
 487
 488     test "without valid credentials", %{conn: conn} do
 489       conn = post(conn, "/api/friendships/destroy.json")
 490       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 491     end
 492
 493     test "with credentials", %{conn: conn, user: current_user} do
 494       followed = insert(:user)
 495
 496       {:ok, current_user} = User.follow(current_user, followed)
 497       assert User.ap_followers(followed) in current_user.following
 498       ActivityPub.follow(current_user, followed)
 499
 500       conn =
 501         conn
 502         |> with_credentials(current_user.nickname, "test")
 503         |> post("/api/friendships/destroy.json", %{user_id: followed.id})
 504
 505       current_user = Repo.get(User, current_user.id)
 506       assert current_user.following == [current_user.ap_id]
 507
 508       assert json_response(conn, 200) ==
 509                UserView.render("show.json", %{user: followed, for: current_user})
 510     end
 511   end
 512
 513   describe "POST /blocks/create.json" do
 514     setup [:valid_user]
 515
 516     test "without valid credentials", %{conn: conn} do
 517       conn = post(conn, "/api/blocks/create.json")
 518       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 519     end
 520
 521     test "with credentials", %{conn: conn, user: current_user} do
 522       blocked = insert(:user)
 523
 524       conn =
 525         conn
 526         |> with_credentials(current_user.nickname, "test")
 527         |> post("/api/blocks/create.json", %{user_id: blocked.id})
 528
 529       current_user = Repo.get(User, current_user.id)
 530       assert User.blocks?(current_user, blocked)
 531
 532       assert json_response(conn, 200) ==
 533                UserView.render("show.json", %{user: blocked, for: current_user})
 534     end
 535   end
 536
 537   describe "POST /blocks/destroy.json" do
 538     setup [:valid_user]
 539
 540     test "without valid credentials", %{conn: conn} do
 541       conn = post(conn, "/api/blocks/destroy.json")
 542       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 543     end
 544
 545     test "with credentials", %{conn: conn, user: current_user} do
 546       blocked = insert(:user)
 547
 548       {:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
 549       assert User.blocks?(current_user, blocked)
 550
 551       conn =
 552         conn
 553         |> with_credentials(current_user.nickname, "test")
 554         |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
 555
 556       current_user = Repo.get(User, current_user.id)
 557       assert current_user.info["blocks"] == []
 558
 559       assert json_response(conn, 200) ==
 560                UserView.render("show.json", %{user: blocked, for: current_user})
 561     end
 562   end
 563
 564   describe "GET /help/test.json" do
 565     test "returns \"ok\"", %{conn: conn} do
 566       conn = get(conn, "/api/help/test.json")
 567       assert json_response(conn, 200) == "ok"
 568     end
 569   end
 570
 571   describe "POST /api/qvitter/update_avatar.json" do
 572     setup [:valid_user]
 573
 574     test "without valid credentials", %{conn: conn} do
 575       conn = post(conn, "/api/qvitter/update_avatar.json")
 576       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 577     end
 578
 579     test "with credentials", %{conn: conn, user: current_user} do
 580       avatar_image = File.read!("test/fixtures/avatar_data_uri")
 581
 582       conn =
 583         conn
 584         |> with_credentials(current_user.nickname, "test")
 585         |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
 586
 587       current_user = Repo.get(User, current_user.id)
 588       assert is_map(current_user.avatar)
 589
 590       assert json_response(conn, 200) ==
 591                UserView.render("show.json", %{user: current_user, for: current_user})
 592     end
 593   end
 594
 595   describe "GET /api/qvitter/mutes.json" do
 596     setup [:valid_user]
 597
 598     test "unimplemented mutes without valid credentials", %{conn: conn} do
 599       conn = get(conn, "/api/qvitter/mutes.json")
 600       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 601     end
 602
 603     test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
 604       conn =
 605         conn
 606         |> with_credentials(current_user.nickname, "test")
 607         |> get("/api/qvitter/mutes.json")
 608
 609       current_user = Repo.get(User, current_user.id)
 610
 611       assert [] = json_response(conn, 200)
 612     end
 613   end
 614
 615   describe "POST /api/favorites/create/:id" do
 616     setup [:valid_user]
 617
 618     test "without valid credentials", %{conn: conn} do
 619       note_activity = insert(:note_activity)
 620       conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
 621       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 622     end
 623
 624     test "with credentials", %{conn: conn, user: current_user} do
 625       note_activity = insert(:note_activity)
 626
 627       conn =
 628         conn
 629         |> with_credentials(current_user.nickname, "test")
 630         |> post("/api/favorites/create/#{note_activity.id}.json")
 631
 632       assert json_response(conn, 200)
 633     end
 634
 635     test "with credentials, invalid param", %{conn: conn, user: current_user} do
 636       conn =
 637         conn
 638         |> with_credentials(current_user.nickname, "test")
 639         |> post("/api/favorites/create/wrong.json")
 640
 641       assert json_response(conn, 400)
 642     end
 643
 644     test "with credentials, invalid activity", %{conn: conn, user: current_user} do
 645       conn =
 646         conn
 647         |> with_credentials(current_user.nickname, "test")
 648         |> post("/api/favorites/create/1.json")
 649
 650       assert json_response(conn, 500)
 651     end
 652   end
 653
 654   describe "POST /api/favorites/destroy/:id" do
 655     setup [:valid_user]
 656
 657     test "without valid credentials", %{conn: conn} do
 658       note_activity = insert(:note_activity)
 659       conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
 660       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 661     end
 662
 663     test "with credentials", %{conn: conn, user: current_user} do
 664       note_activity = insert(:note_activity)
 665       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 666       ActivityPub.like(current_user, object)
 667
 668       conn =
 669         conn
 670         |> with_credentials(current_user.nickname, "test")
 671         |> post("/api/favorites/destroy/#{note_activity.id}.json")
 672
 673       assert json_response(conn, 200)
 674     end
 675   end
 676
 677   describe "POST /api/statuses/retweet/:id" do
 678     setup [:valid_user]
 679
 680     test "without valid credentials", %{conn: conn} do
 681       note_activity = insert(:note_activity)
 682       conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
 683       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 684     end
 685
 686     test "with credentials", %{conn: conn, user: current_user} do
 687       note_activity = insert(:note_activity)
 688
 689       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 690
 691       response =
 692         conn
 693         |> with_credentials(current_user.nickname, "test")
 694         |> post(request_path)
 695
 696       activity = Repo.get(Activity, note_activity.id)
 697       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 698
 699       assert json_response(response, 200) ==
 700                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 701     end
 702   end
 703
 704   describe "POST /api/statuses/unretweet/:id" do
 705     setup [:valid_user]
 706
 707     test "without valid credentials", %{conn: conn} do
 708       note_activity = insert(:note_activity)
 709       conn = post(conn, "/api/statuses/unretweet/#{note_activity.id}.json")
 710       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 711     end
 712
 713     test "with credentials", %{conn: conn, user: current_user} do
 714       note_activity = insert(:note_activity)
 715
 716       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 717
 718       _response =
 719         conn
 720         |> with_credentials(current_user.nickname, "test")
 721         |> post(request_path)
 722
 723       request_path = String.replace(request_path, "retweet", "unretweet")
 724
 725       response =
 726         conn
 727         |> with_credentials(current_user.nickname, "test")
 728         |> post(request_path)
 729
 730       activity = Repo.get(Activity, note_activity.id)
 731       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 732
 733       assert json_response(response, 200) ==
 734                ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 735     end
 736   end
 737
 738   describe "POST /api/account/register" do
 739     test "it creates a new user", %{conn: conn} do
 740       data = %{
 741         "nickname" => "lain",
 742         "email" => "lain@wired.jp",
 743         "fullname" => "lain iwakura",
 744         "bio" => "close the world.",
 745         "password" => "bear",
 746         "confirm" => "bear"
 747       }
 748
 749       conn =
 750         conn
 751         |> post("/api/account/register", data)
 752
 753       user = json_response(conn, 200)
 754
 755       fetched_user = Repo.get_by(User, nickname: "lain")
 756       assert user == UserView.render("show.json", %{user: fetched_user})
 757     end
 758
 759     test "it returns errors on a problem", %{conn: conn} do
 760       data = %{
 761         "email" => "lain@wired.jp",
 762         "fullname" => "lain iwakura",
 763         "bio" => "close the world.",
 764         "password" => "bear",
 765         "confirm" => "bear"
 766       }
 767
 768       conn =
 769         conn
 770         |> post("/api/account/register", data)
 771
 772       errors = json_response(conn, 400)
 773
 774       assert is_binary(errors["error"])
 775     end
 776   end
 777
 778   describe "GET /api/externalprofile/show" do
 779     test "it returns the user", %{conn: conn} do
 780       user = insert(:user)
 781       other_user = insert(:user)
 782
 783       conn =
 784         conn
 785         |> assign(:user, user)
 786         |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
 787
 788       assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
 789     end
 790   end
 791
 792   describe "GET /api/statuses/followers" do
 793     test "it returns a user's followers", %{conn: conn} do
 794       user = insert(:user)
 795       follower_one = insert(:user)
 796       follower_two = insert(:user)
 797       _not_follower = insert(:user)
 798
 799       {:ok, follower_one} = User.follow(follower_one, user)
 800       {:ok, follower_two} = User.follow(follower_two, user)
 801
 802       conn =
 803         conn
 804         |> assign(:user, user)
 805         |> get("/api/statuses/followers")
 806
 807       expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
 808       result = json_response(conn, 200)
 809       assert Enum.sort(expected) == Enum.sort(result)
 810     end
 811   end
 812
 813   describe "GET /api/statuses/friends" do
 814     test "it returns the logged in user's friends", %{conn: conn} do
 815       user = insert(:user)
 816       followed_one = insert(:user)
 817       followed_two = insert(:user)
 818       _not_followed = insert(:user)
 819
 820       {:ok, user} = User.follow(user, followed_one)
 821       {:ok, user} = User.follow(user, followed_two)
 822
 823       conn =
 824         conn
 825         |> assign(:user, user)
 826         |> get("/api/statuses/friends")
 827
 828       expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 829       result = json_response(conn, 200)
 830       assert Enum.sort(expected) == Enum.sort(result)
 831     end
 832
 833     test "it returns a given user's friends with user_id", %{conn: conn} do
 834       user = insert(:user)
 835       followed_one = insert(:user)
 836       followed_two = insert(:user)
 837       _not_followed = insert(:user)
 838
 839       {:ok, user} = User.follow(user, followed_one)
 840       {:ok, user} = User.follow(user, followed_two)
 841
 842       conn =
 843         conn
 844         |> assign(:user, user)
 845         |> get("/api/statuses/friends", %{"user_id" => user.id})
 846
 847       assert MapSet.equal?(
 848                MapSet.new(json_response(conn, 200)),
 849                MapSet.new(
 850                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 851                )
 852              )
 853     end
 854
 855     test "it returns a given user's friends with screen_name", %{conn: conn} do
 856       user = insert(:user)
 857       followed_one = insert(:user)
 858       followed_two = insert(:user)
 859       _not_followed = insert(:user)
 860
 861       {:ok, user} = User.follow(user, followed_one)
 862       {:ok, user} = User.follow(user, followed_two)
 863
 864       conn =
 865         conn
 866         |> assign(:user, user)
 867         |> get("/api/statuses/friends", %{"screen_name" => user.nickname})
 868
 869       assert MapSet.equal?(
 870                MapSet.new(json_response(conn, 200)),
 871                MapSet.new(
 872                  UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
 873                )
 874              )
 875     end
 876   end
 877
 878   describe "GET /friends/ids" do
 879     test "it returns a user's friends", %{conn: conn} do
 880       user = insert(:user)
 881       followed_one = insert(:user)
 882       followed_two = insert(:user)
 883       _not_followed = insert(:user)
 884
 885       {:ok, user} = User.follow(user, followed_one)
 886       {:ok, user} = User.follow(user, followed_two)
 887
 888       conn =
 889         conn
 890         |> assign(:user, user)
 891         |> get("/api/friends/ids")
 892
 893       expected = [followed_one.id, followed_two.id]
 894
 895       assert MapSet.equal?(
 896                MapSet.new(Poison.decode!(json_response(conn, 200))),
 897                MapSet.new(expected)
 898              )
 899     end
 900   end
 901
 902   describe "POST /api/account/update_profile.json" do
 903     test "it updates a user's profile", %{conn: conn} do
 904       user = insert(:user)
 905
 906       conn =
 907         conn
 908         |> assign(:user, user)
 909         |> post("/api/account/update_profile.json", %{
 910           "name" => "new name",
 911           "description" => "new description"
 912         })
 913
 914       user = Repo.get!(User, user.id)
 915       assert user.name == "new name"
 916       assert user.bio == "new description"
 917
 918       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 919     end
 920
 921     test "it locks an account", %{conn: conn} do
 922       user = insert(:user)
 923
 924       conn =
 925         conn
 926         |> assign(:user, user)
 927         |> post("/api/account/update_profile.json", %{
 928           "locked" => "true"
 929         })
 930
 931       user = Repo.get!(User, user.id)
 932       assert user.info["locked"] == true
 933
 934       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 935     end
 936
 937     test "it unlocks an account", %{conn: conn} do
 938       user = insert(:user)
 939
 940       conn =
 941         conn
 942         |> assign(:user, user)
 943         |> post("/api/account/update_profile.json", %{
 944           "locked" => "false"
 945         })
 946
 947       user = Repo.get!(User, user.id)
 948       assert user.info["locked"] == false
 949
 950       assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
 951     end
 952   end
 953
 954   defp valid_user(_context) do
 955     user = insert(:user)
 956     [user: user]
 957   end
 958
 959   defp with_credentials(conn, username, password) do
 960     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
 961     put_req_header(conn, "authorization", header_content)
 962   end
 963
 964   describe "GET /api/search.json" do
 965     test "it returns search results", %{conn: conn} do
 966       user = insert(:user)
 967       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 968
 969       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
 970       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 971
 972       conn =
 973         conn
 974         |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
 975
 976       assert [status] = json_response(conn, 200)
 977       assert status["id"] == activity.id
 978     end
 979   end
 980
 981   describe "GET /api/statusnet/tags/timeline/:tag.json" do
 982     test "it returns the tags timeline", %{conn: conn} do
 983       user = insert(:user)
 984       user_two = insert(:user, %{nickname: "shp@shitposter.club"})
 985
 986       {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
 987       {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
 988
 989       conn =
 990         conn
 991         |> get("/api/statusnet/tags/timeline/2hu.json")
 992
 993       assert [status] = json_response(conn, 200)
 994       assert status["id"] == activity.id
 995     end
 996   end
 997
 998   test "Convert newlines to <br> in bio", %{conn: conn} do
 999     user = insert(:user)
1000
1001     _conn =
1002       conn
1003       |> assign(:user, user)
1004       |> post("/api/account/update_profile.json", %{
1005         "description" => "Hello,\r\nWorld! I\n am a test."
1006       })
1007
1008     user = Repo.get!(User, user.id)
1009     assert user.bio == "Hello,<br>World! I<br> am a test."
1010   end
1011
1012   describe "POST /api/pleroma/change_password" do
1013     setup [:valid_user]
1014
1015     test "without credentials", %{conn: conn} do
1016       conn = post(conn, "/api/pleroma/change_password")
1017       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
1018     end
1019
1020     test "with credentials and invalid password", %{conn: conn, user: current_user} do
1021       conn =
1022         conn
1023         |> with_credentials(current_user.nickname, "test")
1024         |> post("/api/pleroma/change_password", %{
1025           "password" => "hi",
1026           "new_password" => "newpass",
1027           "new_password_confirmation" => "newpass"
1028         })
1029
1030       assert json_response(conn, 200) == %{"error" => "Invalid password."}
1031     end
1032
1033     test "with credentials, valid password and new password and confirmation not matching", %{
1034       conn: conn,
1035       user: current_user
1036     } do
1037       conn =
1038         conn
1039         |> with_credentials(current_user.nickname, "test")
1040         |> post("/api/pleroma/change_password", %{
1041           "password" => "test",
1042           "new_password" => "newpass",
1043           "new_password_confirmation" => "notnewpass"
1044         })
1045
1046       assert json_response(conn, 200) == %{
1047                "error" => "New password does not match confirmation."
1048              }
1049     end
1050
1051     test "with credentials, valid password and invalid new password", %{
1052       conn: conn,
1053       user: current_user
1054     } do
1055       conn =
1056         conn
1057         |> with_credentials(current_user.nickname, "test")
1058         |> post("/api/pleroma/change_password", %{
1059           "password" => "test",
1060           "new_password" => "",
1061           "new_password_confirmation" => ""
1062         })
1063
1064       assert json_response(conn, 200) == %{
1065                "error" => "New password can't be blank."
1066              }
1067     end
1068
1069     test "with credentials, valid password and matching new password and confirmation", %{
1070       conn: conn,
1071       user: current_user
1072     } do
1073       conn =
1074         conn
1075         |> with_credentials(current_user.nickname, "test")
1076         |> post("/api/pleroma/change_password", %{
1077           "password" => "test",
1078           "new_password" => "newpass",
1079           "new_password_confirmation" => "newpass"
1080         })
1081
1082       assert json_response(conn, 200) == %{"status" => "success"}
1083       fetched_user = Repo.get(User, current_user.id)
1084       assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
1085     end
1086   end
1087
1088   describe "POST /api/pleroma/delete_account" do
1089     setup [:valid_user]
1090
1091     test "without credentials", %{conn: conn} do
1092       conn = post(conn, "/api/pleroma/delete_account")
1093       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
1094     end
1095
1096     test "with credentials and invalid password", %{conn: conn, user: current_user} do
1097       conn =
1098         conn
1099         |> with_credentials(current_user.nickname, "test")
1100         |> post("/api/pleroma/delete_account", %{"password" => "hi"})
1101
1102       assert json_response(conn, 200) == %{"error" => "Invalid password."}
1103     end
1104
1105     test "with credentials and valid password", %{conn: conn, user: current_user} do
1106       conn =
1107         conn
1108         |> with_credentials(current_user.nickname, "test")
1109         |> post("/api/pleroma/delete_account", %{"password" => "test"})
1110
1111       assert json_response(conn, 200) == %{"status" => "success"}
1112       # Wait a second for the started task to end
1113       :timer.sleep(1000)
1114     end
1115   end
1116
1117   describe "GET /api/pleroma/friend_requests" do
1118     test "it lists friend requests" do
1119       user = insert(:user, %{info: %{"locked" => true}})
1120       other_user = insert(:user)
1121
1122       {:ok, activity} = ActivityPub.follow(other_user, user)
1123
1124       user = Repo.get(User, user.id)
1125       other_user = Repo.get(User, other_user.id)
1126
1127       assert User.following?(other_user, user) == false
1128
1129       conn =
1130         build_conn()
1131         |> assign(:user, user)
1132         |> get("/api/pleroma/friend_requests")
1133
1134       assert [relationship] = json_response(conn, 200)
1135       assert other_user.id == relationship["id"]
1136     end
1137   end
1138
1139   describe "POST /api/pleroma/friendships/approve" do
1140     test "it approves a friend request" do
1141       user = insert(:user, %{info: %{"locked" => true}})
1142       other_user = insert(:user)
1143
1144       {:ok, activity} = ActivityPub.follow(other_user, user)
1145
1146       user = Repo.get(User, user.id)
1147       other_user = Repo.get(User, other_user.id)
1148
1149       assert User.following?(other_user, user) == false
1150
1151       conn =
1152         build_conn()
1153         |> assign(:user, user)
1154         |> post("/api/pleroma/friendships/approve", %{"user_id" => to_string(other_user.id)})
1155
1156       assert relationship = json_response(conn, 200)
1157       assert other_user.id == relationship["id"]
1158       assert relationship["follows_you"] == true
1159     end
1160   end
1161
1162   describe "POST /api/pleroma/friendships/deny" do
1163     test "it denies a friend request" do
1164       user = insert(:user, %{info: %{"locked" => true}})
1165       other_user = insert(:user)
1166
1167       {:ok, activity} = ActivityPub.follow(other_user, user)
1168
1169       user = Repo.get(User, user.id)
1170       other_user = Repo.get(User, other_user.id)
1171
1172       assert User.following?(other_user, user) == false
1173
1174       conn =
1175         build_conn()
1176         |> assign(:user, user)
1177         |> post("/api/pleroma/friendships/deny", %{"user_id" => to_string(other_user.id)})
1178
1179       assert relationship = json_response(conn, 200)
1180       assert other_user.id == relationship["id"]
1181       assert relationship["follows_you"] == false
1182     end
1183   end
1184 end