git.squeep.com Git - akkoma/blob - test/user_test.exs

   1 defmodule Pleroma.UserTest do
   2   alias Pleroma.Builders.UserBuilder
   3   alias Pleroma.{User, Repo}
   4   alias Pleroma.Web.OStatus
   5   alias Pleroma.Web.Websub.WebsubClientSubscription
   6   use Pleroma.DataCase
   7
   8   import Pleroma.Factory
   9   import Ecto.Query
  10
  11   test "ap_id returns the activity pub id for the user" do
  12     host =
  13       Application.get_env(:pleroma, Pleroma.Web.Endpoint)
  14       |> Keyword.fetch!(:url)
  15       |> Keyword.fetch!(:host)
  16
  17     user = UserBuilder.build
  18
  19     expected_ap_id = "#{Pleroma.Web.base_url}/users/#{user.nickname}"
  20
  21     assert expected_ap_id == User.ap_id(user)
  22   end
  23
  24   test "ap_followers returns the followers collection for the user" do
  25     user = UserBuilder.build
  26
  27     expected_followers_collection = "#{User.ap_id(user)}/followers"
  28
  29     assert expected_followers_collection == User.ap_followers(user)
  30   end
  31
  32   test "follow takes a user and another user" do
  33     user = insert(:user)
  34     followed = insert(:user)
  35
  36     {:ok, user} = User.follow(user, followed)
  37
  38     user = Repo.get(User, user.id)
  39
  40     assert user.following == [User.ap_followers(followed)]
  41   end
  42
  43   test "following a remote user will ensure a websub subscription is present" do
  44     user = insert(:user)
  45     {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")
  46
  47     assert followed.local == false
  48
  49     {:ok, user} = User.follow(user, followed)
  50     assert user.following == [User.ap_followers(followed)]
  51
  52     query = from w in WebsubClientSubscription,
  53     where: w.topic == ^followed.info["topic"]
  54     websub = Repo.one(query)
  55
  56     assert websub
  57   end
  58
  59   test "unfollow takes a user and another user" do
  60     followed = insert(:user)
  61     user = insert(:user, %{following: [User.ap_followers(followed)]})
  62
  63     {:ok, user, _activity } = User.unfollow(user, followed)
  64
  65     user = Repo.get(User, user.id)
  66
  67     assert user.following == []
  68   end
  69
  70   test "test if a user is following another user" do
  71     followed = insert(:user)
  72     user = insert(:user, %{following: [User.ap_followers(followed)]})
  73
  74     assert User.following?(user, followed)
  75     refute User.following?(followed, user)
  76   end
  77
  78   describe "user registration" do
  79     @full_user_data %{
  80       bio: "A guy",
  81       name: "my name",
  82       nickname: "nick",
  83       password: "test",
  84       password_confirmation: "test",
  85       email: "email@example.com"
  86     }
  87
  88     test "it requires a bio, email, name, nickname and password" do
  89       @full_user_data
  90       |> Map.keys
  91       |> Enum.each(fn (key) ->
  92         params = Map.delete(@full_user_data, key)
  93         changeset = User.register_changeset(%User{}, params)
  94         assert changeset.valid? == false
  95       end)
  96     end
  97
  98     test "it sets the password_hash, ap_id and following fields" do
  99       changeset = User.register_changeset(%User{}, @full_user_data)
 100
 101       assert changeset.valid?
 102
 103       assert is_binary(changeset.changes[:password_hash])
 104       assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
 105       assert changeset.changes[:following] == [User.ap_followers(%User{nickname: @full_user_data.nickname})]
 106     end
 107   end
 108
 109   describe "fetching a user from nickname or trying to build one" do
 110     test "gets an existing user" do
 111       user = insert(:user)
 112       fetched_user = User.get_or_fetch_by_nickname(user.nickname)
 113
 114       assert user == fetched_user
 115     end
 116
 117     test "gets an existing user, case insensitive" do
 118       user = insert(:user, nickname: "nick")
 119       fetched_user = User.get_or_fetch_by_nickname("NICK")
 120
 121       assert user == fetched_user
 122     end
 123
 124     test "fetches an external user via ostatus if no user exists" do
 125       fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
 126       assert fetched_user.nickname == "shp@social.heldscal.la"
 127     end
 128
 129     test "returns nil if no user could be fetched" do
 130       fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
 131       assert fetched_user == nil
 132     end
 133
 134     test "returns nil for nonexistant local user" do
 135       fetched_user = User.get_or_fetch_by_nickname("nonexistant")
 136       assert fetched_user == nil
 137     end
 138   end
 139
 140   test "returns an ap_id for a user" do
 141     user = insert(:user)
 142     assert User.ap_id(user) == Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :feed_redirect, user.nickname)
 143   end
 144
 145   test "returns an ap_followers link for a user" do
 146     user = insert(:user)
 147     assert User.ap_followers(user) == Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :feed_redirect, user.nickname) <> "/followers"
 148   end
 149
 150   describe "remote user creation changeset" do
 151     @valid_remote %{
 152       bio: "hello",
 153       name: "Someone",
 154       nickname: "a@b.de",
 155       ap_id: "http...",
 156       info: %{some: "info"},
 157       avatar: %{some: "avatar"}
 158     }
 159
 160     test "it confirms validity" do
 161       cs = User.remote_user_creation(@valid_remote)
 162       assert cs.valid?
 163     end
 164
 165     test "it enforces the fqn format for nicknames" do
 166       cs = User.remote_user_creation(%{@valid_remote | nickname: "bla"})
 167       assert cs.changes.local == false
 168       assert cs.changes.avatar
 169       refute cs.valid?
 170     end
 171
 172     test "it has required fields" do
 173       [:name, :nickname, :ap_id]
 174       |> Enum.each(fn (field) ->
 175         cs = User.remote_user_creation(Map.delete(@valid_remote, field))
 176         refute cs.valid?
 177       end)
 178     end
 179
 180     test "it restricts some sizes" do
 181       [bio: 5000, name: 100]
 182       |> Enum.each(fn ({field, size}) ->
 183         string = String.pad_leading(".", size)
 184         cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
 185         assert cs.valid?
 186
 187         string = String.pad_leading(".", size + 1)
 188         cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
 189         refute cs.valid?
 190       end)
 191     end
 192   end
 193 end
 194