Merge branch 'develop' into feature/788-separate-email-addresses

test/web/twitter_api/twitter_api_test.exs

@@ -16,6 +16,11 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
 
   import Pleroma.Factory
 
+  setup_all do
+    Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
+    :ok
+  end
+
   test "create a status" do
     user = insert(:user)
     mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})
@@ -299,7 +304,6 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
              UserView.render("show.json", %{user: fetched_user})
   end
 
-  @moduletag skip: "needs 'account_activation_required: true' in config"
   test "it sends confirmation email if :account_activation_required is specified in instance config" do
     setting = Pleroma.Config.get([:instance, :account_activation_required])
 
@@ -362,68 +366,313 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
     assert user2.bio == expected_text
   end
 
-  @moduletag skip: "needs 'registrations_open: false' in config"
-  test "it registers a new user via invite token and returns the user." do
-    {:ok, token} = UserInviteToken.create_token()
+  describe "register with one time token" do
+    setup do
+      setting = Pleroma.Config.get([:instance, :registrations_open])
 
-    data = %{
-      "nickname" => "vinny",
-      "email" => "pasta@pizza.vs",
-      "fullname" => "Vinny Vinesauce",
-      "bio" => "streamer",
-      "password" => "hiptofbees",
-      "confirm" => "hiptofbees",
-      "token" => token.token
-    }
+      if setting do
+        Pleroma.Config.put([:instance, :registrations_open], false)
+        on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
+      end
 
-    {:ok, user} = TwitterAPI.register_user(data)
+      :ok
+    end
 
-    fetched_user = User.get_by_nickname("vinny")
-    token = Repo.get_by(UserInviteToken, token: token.token)
+    test "returns user on success" do
+      {:ok, invite} = UserInviteToken.create_invite()
 
-    assert token.used == true
+      data = %{
+        "nickname" => "vinny",
+        "email" => "pasta@pizza.vs",
+        "fullname" => "Vinny Vinesauce",
+        "bio" => "streamer",
+        "password" => "hiptofbees",
+        "confirm" => "hiptofbees",
+        "token" => invite.token
+      }
 
-    assert UserView.render("show.json", %{user: user}) ==
-             UserView.render("show.json", %{user: fetched_user})
+      {:ok, user} = TwitterAPI.register_user(data)
+
+      fetched_user = User.get_by_nickname("vinny")
+      invite = Repo.get_by(UserInviteToken, token: invite.token)
+
+      assert invite.used == true
+
+      assert UserView.render("show.json", %{user: user}) ==
+               UserView.render("show.json", %{user: fetched_user})
+    end
+
+    test "returns error on invalid token" do
+      data = %{
+        "nickname" => "GrimReaper",
+        "email" => "death@reapers.afterlife",
+        "fullname" => "Reaper Grim",
+        "bio" => "Your time has come",
+        "password" => "scythe",
+        "confirm" => "scythe",
+        "token" => "DudeLetMeInImAFairy"
+      }
+
+      {:error, msg} = TwitterAPI.register_user(data)
+
+      assert msg == "Invalid token"
+      refute User.get_by_nickname("GrimReaper")
+    end
+
+    test "returns error on expired token" do
+      {:ok, invite} = UserInviteToken.create_invite()
+      UserInviteToken.update_invite!(invite, used: true)
+
+      data = %{
+        "nickname" => "GrimReaper",
+        "email" => "death@reapers.afterlife",
+        "fullname" => "Reaper Grim",
+        "bio" => "Your time has come",
+        "password" => "scythe",
+        "confirm" => "scythe",
+        "token" => invite.token
+      }
+
+      {:error, msg} = TwitterAPI.register_user(data)
+
+      assert msg == "Expired token"
+      refute User.get_by_nickname("GrimReaper")
+    end
   end
 
-  @moduletag skip: "needs 'registrations_open: false' in config"
-  test "it returns an error if invalid token submitted" do
-    data = %{
-      "nickname" => "GrimReaper",
-      "email" => "death@reapers.afterlife",
-      "fullname" => "Reaper Grim",
-      "bio" => "Your time has come",
-      "password" => "scythe",
-      "confirm" => "scythe",
-      "token" => "DudeLetMeInImAFairy"
-    }
+  describe "registers with date limited token" do
+    setup do
+      setting = Pleroma.Config.get([:instance, :registrations_open])
 
-    {:error, msg} = TwitterAPI.register_user(data)
+      if setting do
+        Pleroma.Config.put([:instance, :registrations_open], false)
+        on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
+      end
 
-    assert msg == "Invalid token"
-    refute User.get_by_nickname("GrimReaper")
+      data = %{
+        "nickname" => "vinny",
+        "email" => "pasta@pizza.vs",
+        "fullname" => "Vinny Vinesauce",
+        "bio" => "streamer",
+        "password" => "hiptofbees",
+        "confirm" => "hiptofbees"
+      }
+
+      check_fn = fn invite ->
+        data = Map.put(data, "token", invite.token)
+        {:ok, user} = TwitterAPI.register_user(data)
+        fetched_user = User.get_by_nickname("vinny")
+
+        assert UserView.render("show.json", %{user: user}) ==
+                 UserView.render("show.json", %{user: fetched_user})
+      end
+
+      {:ok, data: data, check_fn: check_fn}
+    end
+
+    test "returns user on success", %{check_fn: check_fn} do
+      {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
+
+      check_fn.(invite)
+
+      invite = Repo.get_by(UserInviteToken, token: invite.token)
+
+      refute invite.used
+    end
+
+    test "returns user on token which expired tomorrow", %{check_fn: check_fn} do
+      {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), 1)})
+
+      check_fn.(invite)
+
+      invite = Repo.get_by(UserInviteToken, token: invite.token)
+
+      refute invite.used
+    end
+
+    test "returns an error on overdue date", %{data: data} do
+      {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1)})
+
+      data = Map.put(data, "token", invite.token)
+
+      {:error, msg} = TwitterAPI.register_user(data)
+
+      assert msg == "Expired token"
+      refute User.get_by_nickname("vinny")
+      invite = Repo.get_by(UserInviteToken, token: invite.token)
+
+      refute invite.used
+    end
   end
 
-  @moduletag skip: "needs 'registrations_open: false' in config"
-  test "it returns an error if expired token submitted" do
-    {:ok, token} = UserInviteToken.create_token()
-    UserInviteToken.mark_as_used(token.token)
+  describe "registers with reusable token" do
+    setup do
+      setting = Pleroma.Config.get([:instance, :registrations_open])
 
-    data = %{
-      "nickname" => "GrimReaper",
-      "email" => "death@reapers.afterlife",
-      "fullname" => "Reaper Grim",
-      "bio" => "Your time has come",
-      "password" => "scythe",
-      "confirm" => "scythe",
-      "token" => token.token
-    }
+      if setting do
+        Pleroma.Config.put([:instance, :registrations_open], false)
+        on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
+      end
 
-    {:error, msg} = TwitterAPI.register_user(data)
+      :ok
+    end
 
-    assert msg == "Expired token"
-    refute User.get_by_nickname("GrimReaper")
+    test "returns user on success, after him registration fails" do
+      {:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})
+
+      UserInviteToken.update_invite!(invite, uses: 99)
+
+      data = %{
+        "nickname" => "vinny",
+        "email" => "pasta@pizza.vs",
+        "fullname" => "Vinny Vinesauce",
+        "bio" => "streamer",
+        "password" => "hiptofbees",
+        "confirm" => "hiptofbees",
+        "token" => invite.token
+      }
+
+      {:ok, user} = TwitterAPI.register_user(data)
+      fetched_user = User.get_by_nickname("vinny")
+      invite = Repo.get_by(UserInviteToken, token: invite.token)
+
+      assert invite.used == true
+
+      assert UserView.render("show.json", %{user: user}) ==
+               UserView.render("show.json", %{user: fetched_user})
+
+      data = %{
+        "nickname" => "GrimReaper",
+        "email" => "death@reapers.afterlife",
+        "fullname" => "Reaper Grim",
+        "bio" => "Your time has come",
+        "password" => "scythe",
+        "confirm" => "scythe",
+        "token" => invite.token
+      }
+
+      {:error, msg} = TwitterAPI.register_user(data)
+
+      assert msg == "Expired token"
+      refute User.get_by_nickname("GrimReaper")
+    end
+  end
+
+  describe "registers with reusable date limited token" do
+    setup do
+      setting = Pleroma.Config.get([:instance, :registrations_open])
+
+      if setting do
+        Pleroma.Config.put([:instance, :registrations_open], false)
+        on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
+      end
+
+      :ok
+    end
+
+    test "returns user on success" do
+      {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
+
+      data = %{
+        "nickname" => "vinny",
+        "email" => "pasta@pizza.vs",
+        "fullname" => "Vinny Vinesauce",
+        "bio" => "streamer",
+        "password" => "hiptofbees",
+        "confirm" => "hiptofbees",
+        "token" => invite.token
+      }
+
+      {:ok, user} = TwitterAPI.register_user(data)
+      fetched_user = User.get_by_nickname("vinny")
+      invite = Repo.get_by(UserInviteToken, token: invite.token)
+
+      refute invite.used
+
+      assert UserView.render("show.json", %{user: user}) ==
+               UserView.render("show.json", %{user: fetched_user})
+    end
+
+    test "error after max uses" do
+      {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
+
+      UserInviteToken.update_invite!(invite, uses: 99)
+
+      data = %{
+        "nickname" => "vinny",
+        "email" => "pasta@pizza.vs",
+        "fullname" => "Vinny Vinesauce",
+        "bio" => "streamer",
+        "password" => "hiptofbees",
+        "confirm" => "hiptofbees",
+        "token" => invite.token
+      }
+
+      {:ok, user} = TwitterAPI.register_user(data)
+      fetched_user = User.get_by_nickname("vinny")
+      invite = Repo.get_by(UserInviteToken, token: invite.token)
+      assert invite.used == true
+
+      assert UserView.render("show.json", %{user: user}) ==
+               UserView.render("show.json", %{user: fetched_user})
+
+      data = %{
+        "nickname" => "GrimReaper",
+        "email" => "death@reapers.afterlife",
+        "fullname" => "Reaper Grim",
+        "bio" => "Your time has come",
+        "password" => "scythe",
+        "confirm" => "scythe",
+        "token" => invite.token
+      }
+
+      {:error, msg} = TwitterAPI.register_user(data)
+
+      assert msg == "Expired token"
+      refute User.get_by_nickname("GrimReaper")
+    end
+
+    test "returns error on overdue date" do
+      {:ok, invite} =
+        UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
+
+      data = %{
+        "nickname" => "GrimReaper",
+        "email" => "death@reapers.afterlife",
+        "fullname" => "Reaper Grim",
+        "bio" => "Your time has come",
+        "password" => "scythe",
+        "confirm" => "scythe",
+        "token" => invite.token
+      }
+
+      {:error, msg} = TwitterAPI.register_user(data)
+
+      assert msg == "Expired token"
+      refute User.get_by_nickname("GrimReaper")
+    end
+
+    test "returns error on with overdue date and after max" do
+      {:ok, invite} =
+        UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})
+
+      UserInviteToken.update_invite!(invite, uses: 100)
+
+      data = %{
+        "nickname" => "GrimReaper",
+        "email" => "death@reapers.afterlife",
+        "fullname" => "Reaper Grim",
+        "bio" => "Your time has come",
+        "password" => "scythe",
+        "confirm" => "scythe",
+        "token" => invite.token
+      }
+
+      {:error, msg} = TwitterAPI.register_user(data)
+
+      assert msg == "Expired token"
+      refute User.get_by_nickname("GrimReaper")
+    end
   end
 
   test "it returns the error on registration problems" do

test/web/twitter_api/util_controller_test.exs

@@ -3,6 +3,7 @@ defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
 
   alias Pleroma.Notification
   alias Pleroma.Repo
+  alias Pleroma.User
   alias Pleroma.Web.CommonAPI
   import Pleroma.Factory
 
@@ -79,6 +80,26 @@ defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
     end
   end
 
+  describe "PUT /api/pleroma/notification_settings" do
+    test "it updates notification settings", %{conn: conn} do
+      user = insert(:user)
+
+      conn
+      |> assign(:user, user)
+      |> put("/api/pleroma/notification_settings", %{
+        "remote" => false,
+        "followers" => false,
+        "bar" => 1
+      })
+      |> json_response(:ok)
+
+      user = Repo.get(User, user.id)
+
+      assert %{"remote" => false, "local" => true, "followers" => false, "follows" => true} ==
+               user.info.notification_settings
+    end
+  end
+
   describe "GET /api/statusnet/config.json" do
     test "returns the state of safe_dm_mentions flag", %{conn: conn} do
       option = Pleroma.Config.get([:instance, :safe_dm_mentions])
@@ -172,22 +193,19 @@ defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
 
   describe "/api/pleroma/emoji" do
     test "returns json with custom emoji with tags", %{conn: conn} do
-      [emoji | _body] =
+      emoji =
         conn
         |> get("/api/pleroma/emoji")
         |> json_response(200)
 
-      [key] = Map.keys(emoji)
-
-      %{
-        ^key => %{
-          "image_url" => url,
-          "tags" => tags
-        }
-      } = emoji
-
-      assert is_binary(url)
-      assert is_list(tags)
+      assert Enum.all?(emoji, fn
+               {_key,
+                %{
+                  "image_url" => url,
+                  "tags" => tags
+                }} ->
+                 is_binary(url) and is_list(tags)
+             end)
     end
   end