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.{UserRepresenter, ActivityRepresenter}
   4   alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
   5   alias Pleroma.{Repo, Activity, User, Object}
   6   alias Pleroma.Web.ActivityPub.ActivityPub
   7
   8   import Pleroma.Factory
   9
  10   describe "POST /api/account/verify_credentials" do
  11     setup [:valid_user]
  12     test "without valid credentials", %{conn: conn} do
  13       conn = post conn, "/api/account/verify_credentials.json"
  14       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  15     end
  16
  17     test "with credentials", %{conn: conn, user: user} do
  18       conn = conn
  19         |> with_credentials(user.nickname, "test")
  20         |> post("/api/account/verify_credentials.json")
  21
  22       assert json_response(conn, 200) == UserRepresenter.to_map(user)
  23     end
  24   end
  25
  26   describe "POST /statuses/update.json" do
  27     setup [:valid_user]
  28     test "without valid credentials", %{conn: conn} do
  29       conn = post conn, "/api/statuses/update.json"
  30       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
  31     end
  32
  33     test "with credentials", %{conn: conn, user: user} do
  34       conn_with_creds = conn |> with_credentials(user.nickname, "test")
  35       request_path = "/api/statuses/update.json"
  36
  37       error_response = %{"request" => request_path,
  38                          "error" => "Client must provide a 'status' parameter with a value."}
  39       conn = conn_with_creds |> post(request_path)
  40       assert json_response(conn, 400) == error_response
  41
  42       conn = conn_with_creds |> post(request_path, %{ status: "" })
  43       assert json_response(conn, 400) == error_response
  44
  45       conn = conn_with_creds |> post(request_path, %{ status: " " })
  46       assert json_response(conn, 400) == error_response
  47
  48       conn =  conn_with_creds |> post(request_path, %{ status: "Nice meme." })
  49       assert json_response(conn, 200) == ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
  50     end
  51   end
  52
  53   describe "GET /statuses/public_timeline.json" do
  54     test "returns statuses", %{conn: conn} do
  55       {:ok, user} = UserBuilder.insert
  56       activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
  57       ActivityBuilder.insert_list(10, %{}, %{user: user})
  58       since_id = List.last(activities).id
  59
  60       conn = conn
  61         |> get("/api/statuses/public_timeline.json", %{since_id: since_id})
  62
  63       response = json_response(conn, 200)
  64
  65       assert length(response) == 10
  66     end
  67   end
  68
  69   describe "GET /statuses/show/:id.json" do
  70     test "returns one status", %{conn: conn} do
  71       {:ok, user} = UserBuilder.insert
  72       {:ok, activity} = ActivityBuilder.insert(%{}, %{user: user})
  73       actor = Repo.get_by!(User, ap_id: activity.data["actor"])
  74
  75       conn = conn
  76       |> get("/api/statuses/show/#{activity.id}.json")
  77
  78       response = json_response(conn, 200)
  79
  80       assert response == ActivityRepresenter.to_map(activity, %{user: actor})
  81     end
  82   end
  83
  84   describe "GET /statusnet/conversation/:id.json" do
  85     test "returns the statuses in the conversation", %{conn: conn} do
  86       {:ok, _user} = UserBuilder.insert
  87       {:ok, _activity} = ActivityBuilder.insert(%{"statusnetConversationId" => 1, "context" => "2hu"})
  88       {:ok, _activity_two} = ActivityBuilder.insert(%{"statusnetConversationId" => 1,"context" => "2hu"})
  89       {:ok, _activity_three} = ActivityBuilder.insert(%{"context" => "3hu"})
  90
  91       conn = conn
  92       |> get("/api/statusnet/conversation/1.json")
  93
  94       response = json_response(conn, 200)
  95
  96       assert length(response) == 2
  97     end
  98   end
  99
 100   describe "GET /statuses/friends_timeline.json" do
 101     setup [:valid_user]
 102     test "without valid credentials", %{conn: conn} do
 103       conn = get conn, "/api/statuses/friends_timeline.json"
 104       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 105     end
 106
 107     test "with credentials", %{conn: conn, user: current_user} do
 108       user = insert(:user)
 109       activities = ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
 110       returned_activities = ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
 111       other_user = insert(:user)
 112       ActivityBuilder.insert_list(10, %{}, %{user: other_user})
 113       since_id = List.last(activities).id
 114
 115       current_user = Ecto.Changeset.change(current_user, following: [User.ap_followers(user)]) |> Repo.update!
 116
 117       conn = conn
 118         |> with_credentials(current_user.nickname, "test")
 119         |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
 120
 121       response = json_response(conn, 200)
 122
 123       assert length(response) == 10
 124       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)
 125     end
 126   end
 127
 128   describe "GET /statuses/mentions.json" do
 129     setup [:valid_user]
 130     test "without valid credentials", %{conn: conn} do
 131       conn = get conn, "/api/statuses/mentions.json"
 132       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 133     end
 134
 135     test "with credentials", %{conn: conn, user: current_user} do
 136       {:ok, activity} = ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})
 137
 138       conn = conn
 139         |> with_credentials(current_user.nickname, "test")
 140         |> get("/api/statuses/mentions.json")
 141
 142       response = json_response(conn, 200)
 143
 144       assert length(response) == 1
 145       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user, mentioned: [current_user]})
 146     end
 147   end
 148
 149   describe "GET /statuses/user_timeline.json" do
 150     setup [:valid_user]
 151     test "without any params", %{conn: conn} do
 152       conn = get(conn, "/api/statuses/user_timeline.json")
 153       assert json_response(conn, 400) == %{"error" => "You need to specify screen_name or user_id", "request" => "/api/statuses/user_timeline.json"}
 154     end
 155
 156     test "with user_id", %{conn: conn} do
 157       user = insert(:user)
 158       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 159
 160       conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
 161       response = json_response(conn, 200)
 162       assert length(response) == 1
 163       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 164     end
 165
 166     test "with screen_name", %{conn: conn} do
 167       user = insert(:user)
 168       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 169
 170       conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 171       response = json_response(conn, 200)
 172       assert length(response) == 1
 173       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 174     end
 175
 176     test "with credentials", %{conn: conn, user: current_user} do
 177       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
 178       conn = conn
 179       |> with_credentials(current_user.nickname, "test")
 180       |> get("/api/statuses/user_timeline.json")
 181
 182       response = json_response(conn, 200)
 183
 184       assert length(response) == 1
 185       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
 186     end
 187
 188     test "with credentials with user_id", %{conn: conn, user: current_user} do
 189       user = insert(:user)
 190       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 191       conn = conn
 192       |> with_credentials(current_user.nickname, "test")
 193       |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
 194
 195       response = json_response(conn, 200)
 196
 197       assert length(response) == 1
 198       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 199     end
 200
 201     test "with credentials screen_name", %{conn: conn, user: current_user} do
 202       user = insert(:user)
 203       {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
 204       conn = conn
 205       |> with_credentials(current_user.nickname, "test")
 206       |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
 207
 208       response = json_response(conn, 200)
 209
 210       assert length(response) == 1
 211       assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
 212     end
 213   end
 214
 215   describe "POST /friendships/create.json" do
 216     setup [:valid_user]
 217     test "without valid credentials", %{conn: conn} do
 218       conn = post conn, "/api/friendships/create.json"
 219       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 220     end
 221
 222     test "with credentials", %{conn: conn, user: current_user} do
 223       followed = insert(:user)
 224
 225       conn = conn
 226       |> with_credentials(current_user.nickname, "test")
 227       |> post("/api/friendships/create.json", %{user_id: followed.id})
 228
 229       current_user = Repo.get(User, current_user.id)
 230       assert current_user.following == [User.ap_followers(followed)]
 231       assert json_response(conn, 200) == UserRepresenter.to_map(followed, %{for: current_user})
 232     end
 233   end
 234
 235   describe "POST /friendships/destroy.json" do
 236     setup [:valid_user]
 237     test "without valid credentials", %{conn: conn} do
 238       conn = post conn, "/api/friendships/destroy.json"
 239       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 240     end
 241
 242     test "with credentials", %{conn: conn, user: current_user} do
 243       followed = insert(:user)
 244
 245       {:ok, current_user} = User.follow(current_user, followed)
 246       assert current_user.following == [User.ap_followers(followed)]
 247
 248       conn = conn
 249       |> with_credentials(current_user.nickname, "test")
 250       |> post("/api/friendships/destroy.json", %{user_id: followed.id})
 251
 252       current_user = Repo.get(User, current_user.id)
 253       assert current_user.following == []
 254       assert json_response(conn, 200) == UserRepresenter.to_map(followed, %{for: current_user})
 255     end
 256   end
 257
 258   describe "GET /help/test.json" do
 259     test "returns \"ok\"", %{conn: conn} do
 260       conn = get conn, "/api/help/test.json"
 261       assert json_response(conn, 200) == "ok"
 262     end
 263   end
 264
 265   describe "POST /api/qvitter/update_avatar.json" do
 266     setup [:valid_user]
 267     test "without valid credentials", %{conn: conn} do
 268       conn = post conn, "/api/qvitter/update_avatar.json"
 269       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 270     end
 271
 272     test "with credentials", %{conn: conn, user: current_user} do
 273       conn = conn
 274       |> with_credentials(current_user.nickname, "test")
 275       |> post("/api/qvitter/update_avatar.json", %{img: Pleroma.Web.ActivityPub.ActivityPubTest.data_uri})
 276
 277       current_user = Repo.get(User, current_user.id)
 278       assert is_map(current_user.avatar)
 279       assert json_response(conn, 200) == UserRepresenter.to_map(current_user, %{for: current_user})
 280     end
 281   end
 282
 283   describe "POST /api/favorites/create/:id" do
 284     setup [:valid_user]
 285     test "without valid credentials", %{conn: conn} do
 286       note_activity = insert(:note_activity)
 287       conn = post conn, "/api/favorites/create/#{note_activity.id}.json"
 288       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 289     end
 290
 291     test "with credentials", %{conn: conn, user: current_user} do
 292       note_activity = insert(:note_activity)
 293
 294       conn = conn
 295       |> with_credentials(current_user.nickname, "test")
 296       |> post("/api/favorites/create/#{note_activity.id}.json")
 297
 298       assert json_response(conn, 200)
 299     end
 300   end
 301
 302   describe "POST /api/favorites/destroy/:id" do
 303     setup [:valid_user]
 304     test "without valid credentials", %{conn: conn} do
 305       note_activity = insert(:note_activity)
 306       conn = post conn, "/api/favorites/destroy/#{note_activity.id}.json"
 307       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 308     end
 309
 310     test "with credentials", %{conn: conn, user: current_user} do
 311       note_activity = insert(:note_activity)
 312       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 313       ActivityPub.like(current_user, object)
 314
 315       conn = conn
 316       |> with_credentials(current_user.nickname, "test")
 317       |> post("/api/favorites/destroy/#{note_activity.id}.json")
 318
 319       assert json_response(conn, 200)
 320     end
 321   end
 322
 323   describe "POST /api/statuses/retweet/:id" do
 324     setup [:valid_user]
 325     test "without valid credentials", %{conn: conn} do
 326       note_activity = insert(:note_activity)
 327       conn = post conn, "/api/statuses/retweet/#{note_activity.id}.json"
 328       assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
 329     end
 330
 331     test "with credentials", %{conn: conn, user: current_user} do
 332       note_activity = insert(:note_activity)
 333
 334       request_path = "/api/statuses/retweet/#{note_activity.id}.json"
 335
 336       user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 337       response = conn
 338       |> with_credentials(user.nickname, "test")
 339       |> post(request_path)
 340       assert json_response(response, 400) == %{"error" => "You cannot repeat your own notice.",
 341                                                "request" => request_path}
 342
 343       response = conn
 344       |> with_credentials(current_user.nickname, "test")
 345       |> post(request_path)
 346       activity = Repo.get(Activity, note_activity.id)
 347       activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
 348       assert json_response(response, 200) == ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
 349     end
 350   end
 351
 352   describe "POST /api/account/register" do
 353     test "it creates a new user", %{conn: conn} do
 354       data = %{
 355         "nickname" => "lain",
 356         "email" => "lain@wired.jp",
 357         "fullname" => "lain iwakura",
 358         "bio" => "close the world.",
 359         "password" => "bear",
 360         "confirm" => "bear"
 361       }
 362
 363       conn = conn
 364       |> post("/api/account/register", data)
 365
 366       user = json_response(conn, 200)
 367
 368       fetched_user = Repo.get_by(User, nickname: "lain")
 369       assert user == UserRepresenter.to_map(fetched_user)
 370     end
 371
 372     test "it returns errors on a problem", %{conn: conn} do
 373       data = %{
 374         "email" => "lain@wired.jp",
 375         "fullname" => "lain iwakura",
 376         "bio" => "close the world.",
 377         "password" => "bear",
 378         "confirm" => "bear"
 379       }
 380
 381       conn = conn
 382       |> post("/api/account/register", data)
 383
 384       errors = json_response(conn, 400)
 385
 386       assert is_binary(errors["error"])
 387     end
 388   end
 389
 390   defp valid_user(_context) do
 391     user = insert(:user)
 392     [user: user]
 393   end
 394
 395   defp with_credentials(conn, username, password) do
 396     header_content = "Basic " <> Base.encode64("#{username}:#{password}")
 397     put_req_header(conn, "authorization", header_content)
 398   end
 399
 400   setup do
 401     Supervisor.terminate_child(Pleroma.Supervisor, ConCache)
 402     Supervisor.restart_child(Pleroma.Supervisor, ConCache)
 403     :ok
 404   end
 405 end