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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
   6   use Pleroma.DataCase
   7   alias Pleroma.Activity
   8   alias Pleroma.Object
   9   alias Pleroma.Repo
  10   alias Pleroma.User
  11   alias Pleroma.UserInviteToken
  12   alias Pleroma.Web.ActivityPub.ActivityPub
  13   alias Pleroma.Web.TwitterAPI.ActivityView
  14   alias Pleroma.Web.TwitterAPI.TwitterAPI
  15   alias Pleroma.Web.TwitterAPI.UserView
  16
  17   import Pleroma.Factory
  18
  19   setup_all do
  20     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  21     :ok
  22   end
  23
  24   test "create a status" do
  25     user = insert(:user)
  26     mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})
  27
  28     object_data = %{
  29       "type" => "Image",
  30       "url" => [
  31         %{
  32           "type" => "Link",
  33           "mediaType" => "image/jpg",
  34           "href" => "http://example.org/image.jpg"
  35         }
  36       ],
  37       "uuid" => 1
  38     }
  39
  40     object = Repo.insert!(%Object{data: object_data})
  41
  42     input = %{
  43       "status" =>
  44         "Hello again, @shp.<script></script>\nThis is on another :moominmamma: line. #2hu #epic #phantasmagoric",
  45       "media_ids" => [object.id]
  46     }
  47
  48     {:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
  49
  50     expected_text =
  51       "Hello again, <span class='h-card'><a data-user='#{mentioned_user.id}' class='u-url mention' href='shp'>@<span>shp</span></a></span>.&lt;script&gt;&lt;/script&gt;<br>This is on another :moominmamma: line. <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a class='hashtag' data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a class='hashtag' data-tag='phantasmagoric' href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"
  52
  53     assert get_in(activity.data, ["object", "content"]) == expected_text
  54     assert get_in(activity.data, ["object", "type"]) == "Note"
  55     assert get_in(activity.data, ["object", "actor"]) == user.ap_id
  56     assert get_in(activity.data, ["actor"]) == user.ap_id
  57     assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))
  58
  59     assert Enum.member?(
  60              get_in(activity.data, ["to"]),
  61              "https://www.w3.org/ns/activitystreams#Public"
  62            )
  63
  64     assert Enum.member?(get_in(activity.data, ["to"]), "shp")
  65     assert activity.local == true
  66
  67     assert %{"moominmamma" => "http://localhost:4001/finmoji/128px/moominmamma-128.png"} =
  68              activity.data["object"]["emoji"]
  69
  70     # hashtags
  71     assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]
  72
  73     # Add a context
  74     assert is_binary(get_in(activity.data, ["context"]))
  75     assert is_binary(get_in(activity.data, ["object", "context"]))
  76
  77     assert is_list(activity.data["object"]["attachment"])
  78
  79     assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data
  80
  81     user = User.get_by_ap_id(user.ap_id)
  82
  83     assert user.info.note_count == 1
  84   end
  85
  86   test "create a status that is a reply" do
  87     user = insert(:user)
  88
  89     input = %{
  90       "status" => "Hello again."
  91     }
  92
  93     {:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
  94
  95     input = %{
  96       "status" => "Here's your (you).",
  97       "in_reply_to_status_id" => activity.id
  98     }
  99
 100     {:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)
 101
 102     assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])
 103
 104     assert get_in(reply.data, ["object", "context"]) ==
 105              get_in(activity.data, ["object", "context"])
 106
 107     assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
 108     assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
 109   end
 110
 111   test "Follow another user using user_id" do
 112     user = insert(:user)
 113     followed = insert(:user)
 114
 115     {:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
 116     assert User.ap_followers(followed) in user.following
 117
 118     {:error, msg} = TwitterAPI.follow(user, %{"user_id" => followed.id})
 119     assert msg == "Could not follow user: #{followed.nickname} is already on your list."
 120   end
 121
 122   test "Follow another user using screen_name" do
 123     user = insert(:user)
 124     followed = insert(:user)
 125
 126     {:ok, user, followed, _activity} =
 127       TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
 128
 129     assert User.ap_followers(followed) in user.following
 130
 131     followed = User.get_by_ap_id(followed.ap_id)
 132     assert followed.info.follower_count == 1
 133
 134     {:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
 135     assert msg == "Could not follow user: #{followed.nickname} is already on your list."
 136   end
 137
 138   test "Unfollow another user using user_id" do
 139     unfollowed = insert(:user)
 140     user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
 141     ActivityPub.follow(user, unfollowed)
 142
 143     {:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
 144     assert user.following == []
 145
 146     {:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
 147     assert msg == "Not subscribed!"
 148   end
 149
 150   test "Unfollow another user using screen_name" do
 151     unfollowed = insert(:user)
 152     user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
 153
 154     ActivityPub.follow(user, unfollowed)
 155
 156     {:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
 157     assert user.following == []
 158
 159     {:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
 160     assert msg == "Not subscribed!"
 161   end
 162
 163   test "Block another user using user_id" do
 164     user = insert(:user)
 165     blocked = insert(:user)
 166
 167     {:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
 168     assert User.blocks?(user, blocked)
 169   end
 170
 171   test "Block another user using screen_name" do
 172     user = insert(:user)
 173     blocked = insert(:user)
 174
 175     {:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
 176     assert User.blocks?(user, blocked)
 177   end
 178
 179   test "Unblock another user using user_id" do
 180     unblocked = insert(:user)
 181     user = insert(:user)
 182     {:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})
 183
 184     {:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
 185     assert user.info.blocks == []
 186   end
 187
 188   test "Unblock another user using screen_name" do
 189     unblocked = insert(:user)
 190     user = insert(:user)
 191     {:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})
 192
 193     {:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
 194     assert user.info.blocks == []
 195   end
 196
 197   test "upload a file" do
 198     user = insert(:user)
 199
 200     file = %Plug.Upload{
 201       content_type: "image/jpg",
 202       path: Path.absname("test/fixtures/image.jpg"),
 203       filename: "an_image.jpg"
 204     }
 205
 206     response = TwitterAPI.upload(file, user)
 207
 208     assert is_binary(response)
 209   end
 210
 211   test "it favorites a status, returns the updated activity" do
 212     user = insert(:user)
 213     other_user = insert(:user)
 214     note_activity = insert(:note_activity)
 215
 216     {:ok, status} = TwitterAPI.fav(user, note_activity.id)
 217     updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
 218     assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 1
 219
 220     object = Object.normalize(note_activity.data["object"])
 221
 222     assert object.data["like_count"] == 1
 223
 224     assert status == updated_activity
 225
 226     {:ok, _status} = TwitterAPI.fav(other_user, note_activity.id)
 227
 228     object = Object.normalize(note_activity.data["object"])
 229
 230     assert object.data["like_count"] == 2
 231
 232     updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
 233     assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 2
 234   end
 235
 236   test "it unfavorites a status, returns the updated activity" do
 237     user = insert(:user)
 238     note_activity = insert(:note_activity)
 239     object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 240
 241     {:ok, _like_activity, _object} = ActivityPub.like(user, object)
 242     updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
 243
 244     assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1
 245
 246     {:ok, activity} = TwitterAPI.unfav(user, note_activity.id)
 247
 248     assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
 249   end
 250
 251   test "it retweets a status and returns the retweet" do
 252     user = insert(:user)
 253     note_activity = insert(:note_activity)
 254
 255     {:ok, status} = TwitterAPI.repeat(user, note_activity.id)
 256     updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
 257
 258     assert status == updated_activity
 259   end
 260
 261   test "it unretweets an already retweeted status" do
 262     user = insert(:user)
 263     note_activity = insert(:note_activity)
 264
 265     {:ok, _status} = TwitterAPI.repeat(user, note_activity.id)
 266     {:ok, status} = TwitterAPI.unrepeat(user, note_activity.id)
 267     updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
 268
 269     assert status == updated_activity
 270   end
 271
 272   test "it registers a new user and returns the user." do
 273     data = %{
 274       "nickname" => "lain",
 275       "email" => "lain@wired.jp",
 276       "fullname" => "lain iwakura",
 277       "password" => "bear",
 278       "confirm" => "bear"
 279     }
 280
 281     {:ok, user} = TwitterAPI.register_user(data)
 282
 283     fetched_user = User.get_by_nickname("lain")
 284
 285     assert UserView.render("show.json", %{user: user}) ==
 286              UserView.render("show.json", %{user: fetched_user})
 287   end
 288
 289   test "it registers a new user with empty string in bio and returns the user." do
 290     data = %{
 291       "nickname" => "lain",
 292       "email" => "lain@wired.jp",
 293       "fullname" => "lain iwakura",
 294       "bio" => "",
 295       "password" => "bear",
 296       "confirm" => "bear"
 297     }
 298
 299     {:ok, user} = TwitterAPI.register_user(data)
 300
 301     fetched_user = User.get_by_nickname("lain")
 302
 303     assert UserView.render("show.json", %{user: user}) ==
 304              UserView.render("show.json", %{user: fetched_user})
 305   end
 306
 307   test "it sends confirmation email if :account_activation_required is specified in instance config" do
 308     setting = Pleroma.Config.get([:instance, :account_activation_required])
 309
 310     unless setting do
 311       Pleroma.Config.put([:instance, :account_activation_required], true)
 312       on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
 313     end
 314
 315     data = %{
 316       "nickname" => "lain",
 317       "email" => "lain@wired.jp",
 318       "fullname" => "lain iwakura",
 319       "bio" => "",
 320       "password" => "bear",
 321       "confirm" => "bear"
 322     }
 323
 324     {:ok, user} = TwitterAPI.register_user(data)
 325
 326     assert user.info.confirmation_pending
 327
 328     Swoosh.TestAssertions.assert_email_sent(Pleroma.UserEmail.account_confirmation_email(user))
 329   end
 330
 331   test "it registers a new user and parses mentions in the bio" do
 332     data1 = %{
 333       "nickname" => "john",
 334       "email" => "john@gmail.com",
 335       "fullname" => "John Doe",
 336       "bio" => "test",
 337       "password" => "bear",
 338       "confirm" => "bear"
 339     }
 340
 341     {:ok, user1} = TwitterAPI.register_user(data1)
 342
 343     data2 = %{
 344       "nickname" => "lain",
 345       "email" => "lain@wired.jp",
 346       "fullname" => "lain iwakura",
 347       "bio" => "@john test",
 348       "password" => "bear",
 349       "confirm" => "bear"
 350     }
 351
 352     {:ok, user2} = TwitterAPI.register_user(data2)
 353
 354     expected_text =
 355       "<span class='h-card'><a data-user='#{user1.id}' class='u-url mention' href='#{user1.ap_id}'>@<span>john</span></a></span> test"
 356
 357     assert user2.bio == expected_text
 358   end
 359
 360   describe "register with one time token" do
 361     setup do
 362       setting = Pleroma.Config.get([:instance, :registrations_open])
 363
 364       if setting do
 365         Pleroma.Config.put([:instance, :registrations_open], false)
 366         on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
 367       end
 368
 369       :ok
 370     end
 371
 372     test "returns user on success" do
 373       {:ok, token} = UserInviteToken.create_token()
 374
 375       data = %{
 376         "nickname" => "vinny",
 377         "email" => "pasta@pizza.vs",
 378         "fullname" => "Vinny Vinesauce",
 379         "bio" => "streamer",
 380         "password" => "hiptofbees",
 381         "confirm" => "hiptofbees",
 382         "token" => token.token
 383       }
 384
 385       {:ok, user} = TwitterAPI.register_user(data)
 386
 387       fetched_user = User.get_by_nickname("vinny")
 388       token = Repo.get_by(UserInviteToken, token: token.token)
 389
 390       assert token.used == true
 391
 392       assert UserView.render("show.json", %{user: user}) ==
 393                UserView.render("show.json", %{user: fetched_user})
 394     end
 395
 396     test "returns error on invalid token" do
 397       data = %{
 398         "nickname" => "GrimReaper",
 399         "email" => "death@reapers.afterlife",
 400         "fullname" => "Reaper Grim",
 401         "bio" => "Your time has come",
 402         "password" => "scythe",
 403         "confirm" => "scythe",
 404         "token" => "DudeLetMeInImAFairy"
 405       }
 406
 407       {:error, msg} = TwitterAPI.register_user(data)
 408
 409       assert msg == "Invalid token"
 410       refute User.get_by_nickname("GrimReaper")
 411     end
 412
 413     test "returns error on expired token" do
 414       {:ok, token} = UserInviteToken.create_token()
 415       UserInviteToken.mark_as_used(token.token)
 416
 417       data = %{
 418         "nickname" => "GrimReaper",
 419         "email" => "death@reapers.afterlife",
 420         "fullname" => "Reaper Grim",
 421         "bio" => "Your time has come",
 422         "password" => "scythe",
 423         "confirm" => "scythe",
 424         "token" => token.token
 425       }
 426
 427       {:error, msg} = TwitterAPI.register_user(data)
 428
 429       assert msg == "Expired token"
 430       refute User.get_by_nickname("GrimReaper")
 431     end
 432   end
 433
 434   describe "registers with date limited token" do
 435     setup do
 436       setting = Pleroma.Config.get([:instance, :registrations_open])
 437
 438       if setting do
 439         Pleroma.Config.put([:instance, :registrations_open], false)
 440         on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
 441       end
 442
 443       data = %{
 444         "nickname" => "vinny",
 445         "email" => "pasta@pizza.vs",
 446         "fullname" => "Vinny Vinesauce",
 447         "bio" => "streamer",
 448         "password" => "hiptofbees",
 449         "confirm" => "hiptofbees"
 450       }
 451
 452       check_fn = fn token ->
 453         data = Map.put(data, "token", token.token)
 454         {:ok, user} = TwitterAPI.register_user(data)
 455         fetched_user = User.get_by_nickname("vinny")
 456
 457         assert UserView.render("show.json", %{user: user}) ==
 458                  UserView.render("show.json", %{user: fetched_user})
 459       end
 460
 461       {:ok, data: data, check_fn: check_fn}
 462     end
 463
 464     test "returns user on success", %{check_fn: check_fn} do
 465       {:ok, token} = UserInviteToken.create_token(expire_at: Date.utc_today())
 466
 467       check_fn.(token)
 468
 469       token = Repo.get_by(UserInviteToken, token: token.token)
 470
 471       refute token.used
 472     end
 473
 474     test "returns user on token which expired tomorrow", %{check_fn: check_fn} do
 475       {:ok, token} = UserInviteToken.create_token(expire_at: Date.add(Date.utc_today(), 1))
 476
 477       check_fn.(token)
 478
 479       token = Repo.get_by(UserInviteToken, token: token.token)
 480
 481       refute token.used
 482     end
 483
 484     test "returns an error on overdue date", %{data: data} do
 485       {:ok, token} = UserInviteToken.create_token(expire_at: Date.add(Date.utc_today(), -1))
 486
 487       data = Map.put(data, "token", token.token)
 488
 489       {:error, msg} = TwitterAPI.register_user(data)
 490
 491       assert msg == "Expired token"
 492       refute User.get_by_nickname("vinny")
 493       token = Repo.get_by(UserInviteToken, token: token.token)
 494
 495       assert token.used == true
 496     end
 497   end
 498
 499   describe "registers with reusable token" do
 500     setup do
 501       setting = Pleroma.Config.get([:instance, :registrations_open])
 502
 503       if setting do
 504         Pleroma.Config.put([:instance, :registrations_open], false)
 505         on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
 506       end
 507
 508       :ok
 509     end
 510
 511     test "returns user on success, after him registration fails" do
 512       {:ok, token} = UserInviteToken.create_token(max_use: 100)
 513
 514       Ecto.Changeset.change(token, uses: 99) |> Repo.update!()
 515
 516       data = %{
 517         "nickname" => "vinny",
 518         "email" => "pasta@pizza.vs",
 519         "fullname" => "Vinny Vinesauce",
 520         "bio" => "streamer",
 521         "password" => "hiptofbees",
 522         "confirm" => "hiptofbees",
 523         "token" => token.token
 524       }
 525
 526       {:ok, user} = TwitterAPI.register_user(data)
 527       fetched_user = User.get_by_nickname("vinny")
 528       token = Repo.get_by(UserInviteToken, token: token.token)
 529
 530       assert token.used == true
 531
 532       assert UserView.render("show.json", %{user: user}) ==
 533                UserView.render("show.json", %{user: fetched_user})
 534
 535       data = %{
 536         "nickname" => "GrimReaper",
 537         "email" => "death@reapers.afterlife",
 538         "fullname" => "Reaper Grim",
 539         "bio" => "Your time has come",
 540         "password" => "scythe",
 541         "confirm" => "scythe",
 542         "token" => token.token
 543       }
 544
 545       {:error, msg} = TwitterAPI.register_user(data)
 546
 547       assert msg == "Expired token"
 548       refute User.get_by_nickname("GrimReaper")
 549     end
 550   end
 551
 552   describe "registers with reusable date limited token" do
 553     setup do
 554       setting = Pleroma.Config.get([:instance, :registrations_open])
 555
 556       if setting do
 557         Pleroma.Config.put([:instance, :registrations_open], false)
 558         on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
 559       end
 560
 561       :ok
 562     end
 563
 564     test "returns user on success" do
 565       {:ok, token} =
 566         UserInviteToken.create_token(
 567           expire_at: Date.utc_today(),
 568           max_use: 100
 569         )
 570
 571       data = %{
 572         "nickname" => "vinny",
 573         "email" => "pasta@pizza.vs",
 574         "fullname" => "Vinny Vinesauce",
 575         "bio" => "streamer",
 576         "password" => "hiptofbees",
 577         "confirm" => "hiptofbees",
 578         "token" => token.token
 579       }
 580
 581       {:ok, user} = TwitterAPI.register_user(data)
 582       fetched_user = User.get_by_nickname("vinny")
 583       token = Repo.get_by(UserInviteToken, token: token.token)
 584
 585       refute token.used
 586
 587       assert UserView.render("show.json", %{user: user}) ==
 588                UserView.render("show.json", %{user: fetched_user})
 589     end
 590
 591     test "error after max uses" do
 592       {:ok, token} =
 593         UserInviteToken.create_token(
 594           expire_at: Date.utc_today(),
 595           max_use: 100
 596         )
 597
 598       Ecto.Changeset.change(token, uses: 99) |> Repo.update!()
 599
 600       data = %{
 601         "nickname" => "vinny",
 602         "email" => "pasta@pizza.vs",
 603         "fullname" => "Vinny Vinesauce",
 604         "bio" => "streamer",
 605         "password" => "hiptofbees",
 606         "confirm" => "hiptofbees",
 607         "token" => token.token
 608       }
 609
 610       {:ok, user} = TwitterAPI.register_user(data)
 611       fetched_user = User.get_by_nickname("vinny")
 612       token = Repo.get_by(UserInviteToken, token: token.token)
 613       assert token.used == true
 614
 615       assert UserView.render("show.json", %{user: user}) ==
 616                UserView.render("show.json", %{user: fetched_user})
 617
 618       data = %{
 619         "nickname" => "GrimReaper",
 620         "email" => "death@reapers.afterlife",
 621         "fullname" => "Reaper Grim",
 622         "bio" => "Your time has come",
 623         "password" => "scythe",
 624         "confirm" => "scythe",
 625         "token" => token.token
 626       }
 627
 628       {:error, msg} = TwitterAPI.register_user(data)
 629
 630       assert msg == "Expired token"
 631       refute User.get_by_nickname("GrimReaper")
 632     end
 633
 634     test "returns error on overdue date" do
 635       {:ok, token} =
 636         UserInviteToken.create_token(
 637           expire_at: Date.add(Date.utc_today(), -1),
 638           max_use: 100
 639         )
 640
 641       data = %{
 642         "nickname" => "GrimReaper",
 643         "email" => "death@reapers.afterlife",
 644         "fullname" => "Reaper Grim",
 645         "bio" => "Your time has come",
 646         "password" => "scythe",
 647         "confirm" => "scythe",
 648         "token" => token.token
 649       }
 650
 651       {:error, msg} = TwitterAPI.register_user(data)
 652
 653       assert msg == "Expired token"
 654       refute User.get_by_nickname("GrimReaper")
 655     end
 656
 657     test "returns error on with overdue date and after max" do
 658       {:ok, token} =
 659         UserInviteToken.create_token(
 660           expire_at: Date.add(Date.utc_today(), -1),
 661           max_use: 100
 662         )
 663
 664       Ecto.Changeset.change(token, uses: 100) |> Repo.update!()
 665
 666       data = %{
 667         "nickname" => "GrimReaper",
 668         "email" => "death@reapers.afterlife",
 669         "fullname" => "Reaper Grim",
 670         "bio" => "Your time has come",
 671         "password" => "scythe",
 672         "confirm" => "scythe",
 673         "token" => token.token
 674       }
 675
 676       {:error, msg} = TwitterAPI.register_user(data)
 677
 678       assert msg == "Expired token"
 679       refute User.get_by_nickname("GrimReaper")
 680     end
 681   end
 682
 683   test "it returns the error on registration problems" do
 684     data = %{
 685       "nickname" => "lain",
 686       "email" => "lain@wired.jp",
 687       "fullname" => "lain iwakura",
 688       "bio" => "close the world.",
 689       "password" => "bear"
 690     }
 691
 692     {:error, error_object} = TwitterAPI.register_user(data)
 693
 694     assert is_binary(error_object[:error])
 695     refute User.get_by_nickname("lain")
 696   end
 697
 698   test "it assigns an integer conversation_id" do
 699     note_activity = insert(:note_activity)
 700     status = ActivityView.render("activity.json", activity: note_activity)
 701
 702     assert is_number(status["statusnet_conversation_id"])
 703   end
 704
 705   setup do
 706     Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
 707     Supervisor.restart_child(Pleroma.Supervisor, Cachex)
 708     :ok
 709   end
 710
 711   describe "fetching a user by uri" do
 712     test "fetches a user by uri" do
 713       id = "https://mastodon.social/users/lambadalambda"
 714       user = insert(:user)
 715       {:ok, represented} = TwitterAPI.get_external_profile(user, id)
 716       remote = User.get_by_ap_id(id)
 717
 718       assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]
 719
 720       # Also fetches the feed.
 721       # assert Activity.get_create_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
 722       # credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
 723     end
 724   end
 725 end