Fork of Pleroma with site-specific changes and feature branches https://git.pleroma.social/pleroma/pleroma
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1818 lines
55KB

  1. # Pleroma: A lightweight social networking server
  2. # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
  3. # SPDX-License-Identifier: AGPL-3.0-only
  4. defmodule Pleroma.UserTest do
  5. alias Pleroma.Activity
  6. alias Pleroma.Builders.UserBuilder
  7. alias Pleroma.Object
  8. alias Pleroma.Repo
  9. alias Pleroma.Tests.ObanHelpers
  10. alias Pleroma.User
  11. alias Pleroma.Web.ActivityPub.ActivityPub
  12. alias Pleroma.Web.CommonAPI
  13. use Pleroma.DataCase
  14. use Oban.Testing, repo: Pleroma.Repo
  15. import Pleroma.Factory
  16. import ExUnit.CaptureLog
  17. setup_all do
  18. Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  19. :ok
  20. end
  21. setup do: clear_config([:instance, :account_activation_required])
  22. describe "service actors" do
  23. test "returns updated invisible actor" do
  24. uri = "#{Pleroma.Web.Endpoint.url()}/relay"
  25. followers_uri = "#{uri}/followers"
  26. insert(
  27. :user,
  28. %{
  29. nickname: "relay",
  30. invisible: false,
  31. local: true,
  32. ap_id: uri,
  33. follower_address: followers_uri
  34. }
  35. )
  36. actor = User.get_or_create_service_actor_by_ap_id(uri, "relay")
  37. assert actor.invisible
  38. end
  39. test "returns relay user" do
  40. uri = "#{Pleroma.Web.Endpoint.url()}/relay"
  41. followers_uri = "#{uri}/followers"
  42. assert %User{
  43. nickname: "relay",
  44. invisible: true,
  45. local: true,
  46. ap_id: ^uri,
  47. follower_address: ^followers_uri
  48. } = User.get_or_create_service_actor_by_ap_id(uri, "relay")
  49. assert capture_log(fn ->
  50. refute User.get_or_create_service_actor_by_ap_id("/relay", "relay")
  51. end) =~ "Cannot create service actor:"
  52. end
  53. test "returns invisible actor" do
  54. uri = "#{Pleroma.Web.Endpoint.url()}/internal/fetch-test"
  55. followers_uri = "#{uri}/followers"
  56. user = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")
  57. assert %User{
  58. nickname: "internal.fetch-test",
  59. invisible: true,
  60. local: true,
  61. ap_id: ^uri,
  62. follower_address: ^followers_uri
  63. } = user
  64. user2 = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")
  65. assert user.id == user2.id
  66. end
  67. end
  68. describe "AP ID user relationships" do
  69. setup do
  70. {:ok, user: insert(:user)}
  71. end
  72. test "outgoing_relationships_ap_ids/1", %{user: user} do
  73. rel_types = [:block, :mute, :notification_mute, :reblog_mute, :inverse_subscription]
  74. ap_ids_by_rel =
  75. Enum.into(
  76. rel_types,
  77. %{},
  78. fn rel_type ->
  79. rel_records =
  80. insert_list(2, :user_relationship, %{source: user, relationship_type: rel_type})
  81. ap_ids = Enum.map(rel_records, fn rr -> Repo.preload(rr, :target).target.ap_id end)
  82. {rel_type, Enum.sort(ap_ids)}
  83. end
  84. )
  85. assert ap_ids_by_rel[:block] == Enum.sort(User.blocked_users_ap_ids(user))
  86. assert ap_ids_by_rel[:block] == Enum.sort(Enum.map(User.blocked_users(user), & &1.ap_id))
  87. assert ap_ids_by_rel[:mute] == Enum.sort(User.muted_users_ap_ids(user))
  88. assert ap_ids_by_rel[:mute] == Enum.sort(Enum.map(User.muted_users(user), & &1.ap_id))
  89. assert ap_ids_by_rel[:notification_mute] ==
  90. Enum.sort(User.notification_muted_users_ap_ids(user))
  91. assert ap_ids_by_rel[:notification_mute] ==
  92. Enum.sort(Enum.map(User.notification_muted_users(user), & &1.ap_id))
  93. assert ap_ids_by_rel[:reblog_mute] == Enum.sort(User.reblog_muted_users_ap_ids(user))
  94. assert ap_ids_by_rel[:reblog_mute] ==
  95. Enum.sort(Enum.map(User.reblog_muted_users(user), & &1.ap_id))
  96. assert ap_ids_by_rel[:inverse_subscription] == Enum.sort(User.subscriber_users_ap_ids(user))
  97. assert ap_ids_by_rel[:inverse_subscription] ==
  98. Enum.sort(Enum.map(User.subscriber_users(user), & &1.ap_id))
  99. outgoing_relationships_ap_ids = User.outgoing_relationships_ap_ids(user, rel_types)
  100. assert ap_ids_by_rel ==
  101. Enum.into(outgoing_relationships_ap_ids, %{}, fn {k, v} -> {k, Enum.sort(v)} end)
  102. end
  103. end
  104. describe "when tags are nil" do
  105. test "tagging a user" do
  106. user = insert(:user, %{tags: nil})
  107. user = User.tag(user, ["cool", "dude"])
  108. assert "cool" in user.tags
  109. assert "dude" in user.tags
  110. end
  111. test "untagging a user" do
  112. user = insert(:user, %{tags: nil})
  113. user = User.untag(user, ["cool", "dude"])
  114. assert user.tags == []
  115. end
  116. end
  117. test "ap_id returns the activity pub id for the user" do
  118. user = UserBuilder.build()
  119. expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
  120. assert expected_ap_id == User.ap_id(user)
  121. end
  122. test "ap_followers returns the followers collection for the user" do
  123. user = UserBuilder.build()
  124. expected_followers_collection = "#{User.ap_id(user)}/followers"
  125. assert expected_followers_collection == User.ap_followers(user)
  126. end
  127. test "ap_following returns the following collection for the user" do
  128. user = UserBuilder.build()
  129. expected_followers_collection = "#{User.ap_id(user)}/following"
  130. assert expected_followers_collection == User.ap_following(user)
  131. end
  132. test "returns all pending follow requests" do
  133. unlocked = insert(:user)
  134. locked = insert(:user, locked: true)
  135. follower = insert(:user)
  136. CommonAPI.follow(follower, unlocked)
  137. CommonAPI.follow(follower, locked)
  138. assert [] = User.get_follow_requests(unlocked)
  139. assert [activity] = User.get_follow_requests(locked)
  140. assert activity
  141. end
  142. test "doesn't return already accepted or duplicate follow requests" do
  143. locked = insert(:user, locked: true)
  144. pending_follower = insert(:user)
  145. accepted_follower = insert(:user)
  146. CommonAPI.follow(pending_follower, locked)
  147. CommonAPI.follow(pending_follower, locked)
  148. CommonAPI.follow(accepted_follower, locked)
  149. Pleroma.FollowingRelationship.update(accepted_follower, locked, :follow_accept)
  150. assert [^pending_follower] = User.get_follow_requests(locked)
  151. end
  152. test "clears follow requests when requester is blocked" do
  153. followed = insert(:user, locked: true)
  154. follower = insert(:user)
  155. CommonAPI.follow(follower, followed)
  156. assert [_activity] = User.get_follow_requests(followed)
  157. {:ok, _user_relationship} = User.block(followed, follower)
  158. assert [] = User.get_follow_requests(followed)
  159. end
  160. test "follow_all follows mutliple users" do
  161. user = insert(:user)
  162. followed_zero = insert(:user)
  163. followed_one = insert(:user)
  164. followed_two = insert(:user)
  165. blocked = insert(:user)
  166. not_followed = insert(:user)
  167. reverse_blocked = insert(:user)
  168. {:ok, _user_relationship} = User.block(user, blocked)
  169. {:ok, _user_relationship} = User.block(reverse_blocked, user)
  170. {:ok, user} = User.follow(user, followed_zero)
  171. {:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])
  172. assert User.following?(user, followed_one)
  173. assert User.following?(user, followed_two)
  174. assert User.following?(user, followed_zero)
  175. refute User.following?(user, not_followed)
  176. refute User.following?(user, blocked)
  177. refute User.following?(user, reverse_blocked)
  178. end
  179. test "follow_all follows mutliple users without duplicating" do
  180. user = insert(:user)
  181. followed_zero = insert(:user)
  182. followed_one = insert(:user)
  183. followed_two = insert(:user)
  184. {:ok, user} = User.follow_all(user, [followed_zero, followed_one])
  185. assert length(User.following(user)) == 3
  186. {:ok, user} = User.follow_all(user, [followed_one, followed_two])
  187. assert length(User.following(user)) == 4
  188. end
  189. test "follow takes a user and another user" do
  190. user = insert(:user)
  191. followed = insert(:user)
  192. {:ok, user} = User.follow(user, followed)
  193. user = User.get_cached_by_id(user.id)
  194. followed = User.get_cached_by_ap_id(followed.ap_id)
  195. assert followed.follower_count == 1
  196. assert user.following_count == 1
  197. assert User.ap_followers(followed) in User.following(user)
  198. end
  199. test "can't follow a deactivated users" do
  200. user = insert(:user)
  201. followed = insert(:user, %{deactivated: true})
  202. {:error, _} = User.follow(user, followed)
  203. end
  204. test "can't follow a user who blocked us" do
  205. blocker = insert(:user)
  206. blockee = insert(:user)
  207. {:ok, _user_relationship} = User.block(blocker, blockee)
  208. {:error, _} = User.follow(blockee, blocker)
  209. end
  210. test "can't subscribe to a user who blocked us" do
  211. blocker = insert(:user)
  212. blocked = insert(:user)
  213. {:ok, _user_relationship} = User.block(blocker, blocked)
  214. {:error, _} = User.subscribe(blocked, blocker)
  215. end
  216. test "local users do not automatically follow local locked accounts" do
  217. follower = insert(:user, locked: true)
  218. followed = insert(:user, locked: true)
  219. {:ok, follower} = User.maybe_direct_follow(follower, followed)
  220. refute User.following?(follower, followed)
  221. end
  222. describe "unfollow/2" do
  223. setup do: clear_config([:instance, :external_user_synchronization])
  224. test "unfollow with syncronizes external user" do
  225. Pleroma.Config.put([:instance, :external_user_synchronization], true)
  226. followed =
  227. insert(:user,
  228. nickname: "fuser1",
  229. follower_address: "http://localhost:4001/users/fuser1/followers",
  230. following_address: "http://localhost:4001/users/fuser1/following",
  231. ap_id: "http://localhost:4001/users/fuser1"
  232. )
  233. user =
  234. insert(:user, %{
  235. local: false,
  236. nickname: "fuser2",
  237. ap_id: "http://localhost:4001/users/fuser2",
  238. follower_address: "http://localhost:4001/users/fuser2/followers",
  239. following_address: "http://localhost:4001/users/fuser2/following"
  240. })
  241. {:ok, user} = User.follow(user, followed, :follow_accept)
  242. {:ok, user, _activity} = User.unfollow(user, followed)
  243. user = User.get_cached_by_id(user.id)
  244. assert User.following(user) == []
  245. end
  246. test "unfollow takes a user and another user" do
  247. followed = insert(:user)
  248. user = insert(:user)
  249. {:ok, user} = User.follow(user, followed, :follow_accept)
  250. assert User.following(user) == [user.follower_address, followed.follower_address]
  251. {:ok, user, _activity} = User.unfollow(user, followed)
  252. assert User.following(user) == [user.follower_address]
  253. end
  254. test "unfollow doesn't unfollow yourself" do
  255. user = insert(:user)
  256. {:error, _} = User.unfollow(user, user)
  257. assert User.following(user) == [user.follower_address]
  258. end
  259. end
  260. test "test if a user is following another user" do
  261. followed = insert(:user)
  262. user = insert(:user)
  263. User.follow(user, followed, :follow_accept)
  264. assert User.following?(user, followed)
  265. refute User.following?(followed, user)
  266. end
  267. test "fetches correct profile for nickname beginning with number" do
  268. # Use old-style integer ID to try to reproduce the problem
  269. user = insert(:user, %{id: 1080})
  270. user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
  271. assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
  272. end
  273. describe "user registration" do
  274. @full_user_data %{
  275. bio: "A guy",
  276. name: "my name",
  277. nickname: "nick",
  278. password: "test",
  279. password_confirmation: "test",
  280. email: "email@example.com"
  281. }
  282. setup do: clear_config([:instance, :autofollowed_nicknames])
  283. setup do: clear_config([:instance, :welcome_message])
  284. setup do: clear_config([:instance, :welcome_user_nickname])
  285. test "it autofollows accounts that are set for it" do
  286. user = insert(:user)
  287. remote_user = insert(:user, %{local: false})
  288. Pleroma.Config.put([:instance, :autofollowed_nicknames], [
  289. user.nickname,
  290. remote_user.nickname
  291. ])
  292. cng = User.register_changeset(%User{}, @full_user_data)
  293. {:ok, registered_user} = User.register(cng)
  294. assert User.following?(registered_user, user)
  295. refute User.following?(registered_user, remote_user)
  296. end
  297. test "it sends a welcome message if it is set" do
  298. welcome_user = insert(:user)
  299. Pleroma.Config.put([:instance, :welcome_user_nickname], welcome_user.nickname)
  300. Pleroma.Config.put([:instance, :welcome_message], "Hello, this is a cool site")
  301. cng = User.register_changeset(%User{}, @full_user_data)
  302. {:ok, registered_user} = User.register(cng)
  303. activity = Repo.one(Pleroma.Activity)
  304. assert registered_user.ap_id in activity.recipients
  305. assert Object.normalize(activity).data["content"] =~ "cool site"
  306. assert activity.actor == welcome_user.ap_id
  307. end
  308. setup do: clear_config([:instance, :account_activation_required])
  309. test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
  310. Pleroma.Config.put([:instance, :account_activation_required], true)
  311. @full_user_data
  312. |> Map.keys()
  313. |> Enum.each(fn key ->
  314. params = Map.delete(@full_user_data, key)
  315. changeset = User.register_changeset(%User{}, params)
  316. assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
  317. end)
  318. end
  319. test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do
  320. Pleroma.Config.put([:instance, :account_activation_required], false)
  321. @full_user_data
  322. |> Map.keys()
  323. |> Enum.each(fn key ->
  324. params = Map.delete(@full_user_data, key)
  325. changeset = User.register_changeset(%User{}, params)
  326. assert if key in [:bio, :email], do: changeset.valid?, else: not changeset.valid?
  327. end)
  328. end
  329. test "it restricts certain nicknames" do
  330. [restricted_name | _] = Pleroma.Config.get([User, :restricted_nicknames])
  331. assert is_bitstring(restricted_name)
  332. params =
  333. @full_user_data
  334. |> Map.put(:nickname, restricted_name)
  335. changeset = User.register_changeset(%User{}, params)
  336. refute changeset.valid?
  337. end
  338. test "it sets the password_hash and ap_id" do
  339. changeset = User.register_changeset(%User{}, @full_user_data)
  340. assert changeset.valid?
  341. assert is_binary(changeset.changes[:password_hash])
  342. assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
  343. assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
  344. end
  345. end
  346. describe "user registration, with :account_activation_required" do
  347. @full_user_data %{
  348. bio: "A guy",
  349. name: "my name",
  350. nickname: "nick",
  351. password: "test",
  352. password_confirmation: "test",
  353. email: "email@example.com"
  354. }
  355. setup do: clear_config([:instance, :account_activation_required], true)
  356. test "it creates unconfirmed user" do
  357. changeset = User.register_changeset(%User{}, @full_user_data)
  358. assert changeset.valid?
  359. {:ok, user} = Repo.insert(changeset)
  360. assert user.confirmation_pending
  361. assert user.confirmation_token
  362. end
  363. test "it creates confirmed user if :confirmed option is given" do
  364. changeset = User.register_changeset(%User{}, @full_user_data, need_confirmation: false)
  365. assert changeset.valid?
  366. {:ok, user} = Repo.insert(changeset)
  367. refute user.confirmation_pending
  368. refute user.confirmation_token
  369. end
  370. end
  371. describe "get_or_fetch/1" do
  372. test "gets an existing user by nickname" do
  373. user = insert(:user)
  374. {:ok, fetched_user} = User.get_or_fetch(user.nickname)
  375. assert user == fetched_user
  376. end
  377. test "gets an existing user by ap_id" do
  378. ap_id = "http://mastodon.example.org/users/admin"
  379. user =
  380. insert(
  381. :user,
  382. local: false,
  383. nickname: "admin@mastodon.example.org",
  384. ap_id: ap_id
  385. )
  386. {:ok, fetched_user} = User.get_or_fetch(ap_id)
  387. freshed_user = refresh_record(user)
  388. assert freshed_user == fetched_user
  389. end
  390. end
  391. describe "fetching a user from nickname or trying to build one" do
  392. test "gets an existing user" do
  393. user = insert(:user)
  394. {:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)
  395. assert user == fetched_user
  396. end
  397. test "gets an existing user, case insensitive" do
  398. user = insert(:user, nickname: "nick")
  399. {:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")
  400. assert user == fetched_user
  401. end
  402. test "gets an existing user by fully qualified nickname" do
  403. user = insert(:user)
  404. {:ok, fetched_user} =
  405. User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
  406. assert user == fetched_user
  407. end
  408. test "gets an existing user by fully qualified nickname, case insensitive" do
  409. user = insert(:user, nickname: "nick")
  410. casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())
  411. {:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)
  412. assert user == fetched_user
  413. end
  414. @tag capture_log: true
  415. test "returns nil if no user could be fetched" do
  416. {:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
  417. assert fetched_user == "not found nonexistant@social.heldscal.la"
  418. end
  419. test "returns nil for nonexistant local user" do
  420. {:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant")
  421. assert fetched_user == "not found nonexistant"
  422. end
  423. test "updates an existing user, if stale" do
  424. a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
  425. orig_user =
  426. insert(
  427. :user,
  428. local: false,
  429. nickname: "admin@mastodon.example.org",
  430. ap_id: "http://mastodon.example.org/users/admin",
  431. last_refreshed_at: a_week_ago
  432. )
  433. assert orig_user.last_refreshed_at == a_week_ago
  434. {:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
  435. assert user.inbox
  436. refute user.last_refreshed_at == orig_user.last_refreshed_at
  437. end
  438. @tag capture_log: true
  439. test "it returns the old user if stale, but unfetchable" do
  440. a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)
  441. orig_user =
  442. insert(
  443. :user,
  444. local: false,
  445. nickname: "admin@mastodon.example.org",
  446. ap_id: "http://mastodon.example.org/users/raymoo",
  447. last_refreshed_at: a_week_ago
  448. )
  449. assert orig_user.last_refreshed_at == a_week_ago
  450. {:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/raymoo")
  451. assert user.last_refreshed_at == orig_user.last_refreshed_at
  452. end
  453. end
  454. test "returns an ap_id for a user" do
  455. user = insert(:user)
  456. assert User.ap_id(user) ==
  457. Pleroma.Web.Router.Helpers.user_feed_url(
  458. Pleroma.Web.Endpoint,
  459. :feed_redirect,
  460. user.nickname
  461. )
  462. end
  463. test "returns an ap_followers link for a user" do
  464. user = insert(:user)
  465. assert User.ap_followers(user) ==
  466. Pleroma.Web.Router.Helpers.user_feed_url(
  467. Pleroma.Web.Endpoint,
  468. :feed_redirect,
  469. user.nickname
  470. ) <> "/followers"
  471. end
  472. describe "remote user changeset" do
  473. @valid_remote %{
  474. bio: "hello",
  475. name: "Someone",
  476. nickname: "a@b.de",
  477. ap_id: "http...",
  478. avatar: %{some: "avatar"}
  479. }
  480. setup do: clear_config([:instance, :user_bio_length])
  481. setup do: clear_config([:instance, :user_name_length])
  482. test "it confirms validity" do
  483. cs = User.remote_user_changeset(@valid_remote)
  484. assert cs.valid?
  485. end
  486. test "it sets the follower_adress" do
  487. cs = User.remote_user_changeset(@valid_remote)
  488. # remote users get a fake local follower address
  489. assert cs.changes.follower_address ==
  490. User.ap_followers(%User{nickname: @valid_remote[:nickname]})
  491. end
  492. test "it enforces the fqn format for nicknames" do
  493. cs = User.remote_user_changeset(%{@valid_remote | nickname: "bla"})
  494. assert Ecto.Changeset.get_field(cs, :local) == false
  495. assert cs.changes.avatar
  496. refute cs.valid?
  497. end
  498. test "it has required fields" do
  499. [:ap_id]
  500. |> Enum.each(fn field ->
  501. cs = User.remote_user_changeset(Map.delete(@valid_remote, field))
  502. refute cs.valid?
  503. end)
  504. end
  505. end
  506. describe "followers and friends" do
  507. test "gets all followers for a given user" do
  508. user = insert(:user)
  509. follower_one = insert(:user)
  510. follower_two = insert(:user)
  511. not_follower = insert(:user)
  512. {:ok, follower_one} = User.follow(follower_one, user)
  513. {:ok, follower_two} = User.follow(follower_two, user)
  514. res = User.get_followers(user)
  515. assert Enum.member?(res, follower_one)
  516. assert Enum.member?(res, follower_two)
  517. refute Enum.member?(res, not_follower)
  518. end
  519. test "gets all friends (followed users) for a given user" do
  520. user = insert(:user)
  521. followed_one = insert(:user)
  522. followed_two = insert(:user)
  523. not_followed = insert(:user)
  524. {:ok, user} = User.follow(user, followed_one)
  525. {:ok, user} = User.follow(user, followed_two)
  526. res = User.get_friends(user)
  527. followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
  528. followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
  529. assert Enum.member?(res, followed_one)
  530. assert Enum.member?(res, followed_two)
  531. refute Enum.member?(res, not_followed)
  532. end
  533. end
  534. describe "updating note and follower count" do
  535. test "it sets the note_count property" do
  536. note = insert(:note)
  537. user = User.get_cached_by_ap_id(note.data["actor"])
  538. assert user.note_count == 0
  539. {:ok, user} = User.update_note_count(user)
  540. assert user.note_count == 1
  541. end
  542. test "it increases the note_count property" do
  543. note = insert(:note)
  544. user = User.get_cached_by_ap_id(note.data["actor"])
  545. assert user.note_count == 0
  546. {:ok, user} = User.increase_note_count(user)
  547. assert user.note_count == 1
  548. {:ok, user} = User.increase_note_count(user)
  549. assert user.note_count == 2
  550. end
  551. test "it decreases the note_count property" do
  552. note = insert(:note)
  553. user = User.get_cached_by_ap_id(note.data["actor"])
  554. assert user.note_count == 0
  555. {:ok, user} = User.increase_note_count(user)
  556. assert user.note_count == 1
  557. {:ok, user} = User.decrease_note_count(user)
  558. assert user.note_count == 0
  559. {:ok, user} = User.decrease_note_count(user)
  560. assert user.note_count == 0
  561. end
  562. test "it sets the follower_count property" do
  563. user = insert(:user)
  564. follower = insert(:user)
  565. User.follow(follower, user)
  566. assert user.follower_count == 0
  567. {:ok, user} = User.update_follower_count(user)
  568. assert user.follower_count == 1
  569. end
  570. end
  571. describe "follow_import" do
  572. test "it imports user followings from list" do
  573. [user1, user2, user3] = insert_list(3, :user)
  574. identifiers = [
  575. user2.ap_id,
  576. user3.nickname
  577. ]
  578. {:ok, job} = User.follow_import(user1, identifiers)
  579. assert {:ok, result} = ObanHelpers.perform(job)
  580. assert is_list(result)
  581. assert result == [user2, user3]
  582. end
  583. end
  584. describe "mutes" do
  585. test "it mutes people" do
  586. user = insert(:user)
  587. muted_user = insert(:user)
  588. refute User.mutes?(user, muted_user)
  589. refute User.muted_notifications?(user, muted_user)
  590. {:ok, _user_relationships} = User.mute(user, muted_user)
  591. assert User.mutes?(user, muted_user)
  592. assert User.muted_notifications?(user, muted_user)
  593. end
  594. test "it unmutes users" do
  595. user = insert(:user)
  596. muted_user = insert(:user)
  597. {:ok, _user_relationships} = User.mute(user, muted_user)
  598. {:ok, _user_mute} = User.unmute(user, muted_user)
  599. refute User.mutes?(user, muted_user)
  600. refute User.muted_notifications?(user, muted_user)
  601. end
  602. test "it mutes user without notifications" do
  603. user = insert(:user)
  604. muted_user = insert(:user)
  605. refute User.mutes?(user, muted_user)
  606. refute User.muted_notifications?(user, muted_user)
  607. {:ok, _user_relationships} = User.mute(user, muted_user, false)
  608. assert User.mutes?(user, muted_user)
  609. refute User.muted_notifications?(user, muted_user)
  610. end
  611. end
  612. describe "blocks" do
  613. test "it blocks people" do
  614. user = insert(:user)
  615. blocked_user = insert(:user)
  616. refute User.blocks?(user, blocked_user)
  617. {:ok, _user_relationship} = User.block(user, blocked_user)
  618. assert User.blocks?(user, blocked_user)
  619. end
  620. test "it unblocks users" do
  621. user = insert(:user)
  622. blocked_user = insert(:user)
  623. {:ok, _user_relationship} = User.block(user, blocked_user)
  624. {:ok, _user_block} = User.unblock(user, blocked_user)
  625. refute User.blocks?(user, blocked_user)
  626. end
  627. test "blocks tear down cyclical follow relationships" do
  628. blocker = insert(:user)
  629. blocked = insert(:user)
  630. {:ok, blocker} = User.follow(blocker, blocked)
  631. {:ok, blocked} = User.follow(blocked, blocker)
  632. assert User.following?(blocker, blocked)
  633. assert User.following?(blocked, blocker)
  634. {:ok, _user_relationship} = User.block(blocker, blocked)
  635. blocked = User.get_cached_by_id(blocked.id)
  636. assert User.blocks?(blocker, blocked)
  637. refute User.following?(blocker, blocked)
  638. refute User.following?(blocked, blocker)
  639. end
  640. test "blocks tear down blocker->blocked follow relationships" do
  641. blocker = insert(:user)
  642. blocked = insert(:user)
  643. {:ok, blocker} = User.follow(blocker, blocked)
  644. assert User.following?(blocker, blocked)
  645. refute User.following?(blocked, blocker)
  646. {:ok, _user_relationship} = User.block(blocker, blocked)
  647. blocked = User.get_cached_by_id(blocked.id)
  648. assert User.blocks?(blocker, blocked)
  649. refute User.following?(blocker, blocked)
  650. refute User.following?(blocked, blocker)
  651. end
  652. test "blocks tear down blocked->blocker follow relationships" do
  653. blocker = insert(:user)
  654. blocked = insert(:user)
  655. {:ok, blocked} = User.follow(blocked, blocker)
  656. refute User.following?(blocker, blocked)
  657. assert User.following?(blocked, blocker)
  658. {:ok, _user_relationship} = User.block(blocker, blocked)
  659. blocked = User.get_cached_by_id(blocked.id)
  660. assert User.blocks?(blocker, blocked)
  661. refute User.following?(blocker, blocked)
  662. refute User.following?(blocked, blocker)
  663. end
  664. test "blocks tear down blocked->blocker subscription relationships" do
  665. blocker = insert(:user)
  666. blocked = insert(:user)
  667. {:ok, _subscription} = User.subscribe(blocked, blocker)
  668. assert User.subscribed_to?(blocked, blocker)
  669. refute User.subscribed_to?(blocker, blocked)
  670. {:ok, _user_relationship} = User.block(blocker, blocked)
  671. assert User.blocks?(blocker, blocked)
  672. refute User.subscribed_to?(blocker, blocked)
  673. refute User.subscribed_to?(blocked, blocker)
  674. end
  675. end
  676. describe "domain blocking" do
  677. test "blocks domains" do
  678. user = insert(:user)
  679. collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
  680. {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
  681. assert User.blocks?(user, collateral_user)
  682. end
  683. test "does not block domain with same end" do
  684. user = insert(:user)
  685. collateral_user =
  686. insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})
  687. {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
  688. refute User.blocks?(user, collateral_user)
  689. end
  690. test "does not block domain with same end if wildcard added" do
  691. user = insert(:user)
  692. collateral_user =
  693. insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})
  694. {:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")
  695. refute User.blocks?(user, collateral_user)
  696. end
  697. test "blocks domain with wildcard for subdomain" do
  698. user = insert(:user)
  699. user_from_subdomain =
  700. insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})
  701. user_with_two_subdomains =
  702. insert(:user, %{
  703. ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
  704. })
  705. user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
  706. {:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")
  707. assert User.blocks?(user, user_from_subdomain)
  708. assert User.blocks?(user, user_with_two_subdomains)
  709. assert User.blocks?(user, user_domain)
  710. end
  711. test "unblocks domains" do
  712. user = insert(:user)
  713. collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})
  714. {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
  715. {:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")
  716. refute User.blocks?(user, collateral_user)
  717. end
  718. test "follows take precedence over domain blocks" do
  719. user = insert(:user)
  720. good_eggo = insert(:user, %{ap_id: "https://meanies.social/user/cuteposter"})
  721. {:ok, user} = User.block_domain(user, "meanies.social")
  722. {:ok, user} = User.follow(user, good_eggo)
  723. refute User.blocks?(user, good_eggo)
  724. end
  725. end
  726. describe "blocks_import" do
  727. test "it imports user blocks from list" do
  728. [user1, user2, user3] = insert_list(3, :user)
  729. identifiers = [
  730. user2.ap_id,
  731. user3.nickname
  732. ]
  733. {:ok, job} = User.blocks_import(user1, identifiers)
  734. assert {:ok, result} = ObanHelpers.perform(job)
  735. assert is_list(result)
  736. assert result == [user2, user3]
  737. end
  738. end
  739. describe "get_recipients_from_activity" do
  740. test "works for announces" do
  741. actor = insert(:user)
  742. user = insert(:user, local: true)
  743. {:ok, activity} = CommonAPI.post(actor, %{status: "hello"})
  744. {:ok, announce} = CommonAPI.repeat(activity.id, user)
  745. recipients = User.get_recipients_from_activity(announce)
  746. assert user in recipients
  747. end
  748. test "get recipients" do
  749. actor = insert(:user)
  750. user = insert(:user, local: true)
  751. user_two = insert(:user, local: false)
  752. addressed = insert(:user, local: true)
  753. addressed_remote = insert(:user, local: false)
  754. {:ok, activity} =
  755. CommonAPI.post(actor, %{
  756. status: "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
  757. })
  758. assert Enum.map([actor, addressed], & &1.ap_id) --
  759. Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []
  760. {:ok, user} = User.follow(user, actor)
  761. {:ok, _user_two} = User.follow(user_two, actor)
  762. recipients = User.get_recipients_from_activity(activity)
  763. assert length(recipients) == 3
  764. assert user in recipients
  765. assert addressed in recipients
  766. end
  767. test "has following" do
  768. actor = insert(:user)
  769. user = insert(:user)
  770. user_two = insert(:user)
  771. addressed = insert(:user, local: true)
  772. {:ok, activity} =
  773. CommonAPI.post(actor, %{
  774. status: "hey @#{addressed.nickname}"
  775. })
  776. assert Enum.map([actor, addressed], & &1.ap_id) --
  777. Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []
  778. {:ok, _actor} = User.follow(actor, user)
  779. {:ok, _actor} = User.follow(actor, user_two)
  780. recipients = User.get_recipients_from_activity(activity)
  781. assert length(recipients) == 2
  782. assert addressed in recipients
  783. end
  784. end
  785. describe ".deactivate" do
  786. test "can de-activate then re-activate a user" do
  787. user = insert(:user)
  788. assert false == user.deactivated
  789. {:ok, user} = User.deactivate(user)
  790. assert true == user.deactivated
  791. {:ok, user} = User.deactivate(user, false)
  792. assert false == user.deactivated
  793. end
  794. test "hide a user from followers" do
  795. user = insert(:user)
  796. user2 = insert(:user)
  797. {:ok, user} = User.follow(user, user2)
  798. {:ok, _user} = User.deactivate(user)
  799. user2 = User.get_cached_by_id(user2.id)
  800. assert user2.follower_count == 0
  801. assert [] = User.get_followers(user2)
  802. end
  803. test "hide a user from friends" do
  804. user = insert(:user)
  805. user2 = insert(:user)
  806. {:ok, user2} = User.follow(user2, user)
  807. assert user2.following_count == 1
  808. assert User.following_count(user2) == 1
  809. {:ok, _user} = User.deactivate(user)
  810. user2 = User.get_cached_by_id(user2.id)
  811. assert refresh_record(user2).following_count == 0
  812. assert user2.following_count == 0
  813. assert User.following_count(user2) == 0
  814. assert [] = User.get_friends(user2)
  815. end
  816. test "hide a user's statuses from timelines and notifications" do
  817. user = insert(:user)
  818. user2 = insert(:user)
  819. {:ok, user2} = User.follow(user2, user)
  820. {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{user2.nickname}"})
  821. activity = Repo.preload(activity, :bookmark)
  822. [notification] = Pleroma.Notification.for_user(user2)
  823. assert notification.activity.id == activity.id
  824. assert [activity] == ActivityPub.fetch_public_activities(%{}) |> Repo.preload(:bookmark)
  825. assert [%{activity | thread_muted?: CommonAPI.thread_muted?(user2, activity)}] ==
  826. ActivityPub.fetch_activities([user2.ap_id | User.following(user2)], %{
  827. user: user2
  828. })
  829. {:ok, _user} = User.deactivate(user)
  830. assert [] == ActivityPub.fetch_public_activities(%{})
  831. assert [] == Pleroma.Notification.for_user(user2)
  832. assert [] ==
  833. ActivityPub.fetch_activities([user2.ap_id | User.following(user2)], %{
  834. user: user2
  835. })
  836. end
  837. end
  838. describe "delete" do
  839. setup do
  840. {:ok, user} = insert(:user) |> User.set_cache()
  841. [user: user]
  842. end
  843. setup do: clear_config([:instance, :federating])
  844. test ".delete_user_activities deletes all create activities", %{user: user} do
  845. {:ok, activity} = CommonAPI.post(user, %{status: "2hu"})
  846. User.delete_user_activities(user)
  847. # TODO: Test removal favorites, repeats, delete activities.
  848. refute Activity.get_by_id(activity.id)
  849. end
  850. test "it deactivates a user, all follow relationships and all activities", %{user: user} do
  851. follower = insert(:user)
  852. {:ok, follower} = User.follow(follower, user)
  853. locked_user = insert(:user, name: "locked", locked: true)
  854. {:ok, _} = User.follow(user, locked_user, :follow_pending)
  855. object = insert(:note, user: user)
  856. activity = insert(:note_activity, user: user, note: object)
  857. object_two = insert(:note, user: follower)
  858. activity_two = insert(:note_activity, user: follower, note: object_two)
  859. {:ok, like} = CommonAPI.favorite(user, activity_two.id)
  860. {:ok, like_two} = CommonAPI.favorite(follower, activity.id)
  861. {:ok, repeat} = CommonAPI.repeat(activity_two.id, user)
  862. {:ok, job} = User.delete(user)
  863. {:ok, _user} = ObanHelpers.perform(job)
  864. follower = User.get_cached_by_id(follower.id)
  865. refute User.following?(follower, user)
  866. assert %{deactivated: true} = User.get_by_id(user.id)
  867. assert [] == User.get_follow_requests(locked_user)
  868. user_activities =
  869. user.ap_id
  870. |> Activity.Queries.by_actor()
  871. |> Repo.all()
  872. |> Enum.map(fn act -> act.data["type"] end)
  873. assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)
  874. refute Activity.get_by_id(activity.id)
  875. refute Activity.get_by_id(like.id)
  876. refute Activity.get_by_id(like_two.id)
  877. refute Activity.get_by_id(repeat.id)
  878. end
  879. end
  880. describe "delete/1 when confirmation is pending" do
  881. setup do
  882. user = insert(:user, confirmation_pending: true)
  883. {:ok, user: user}
  884. end
  885. test "deletes user from database when activation required", %{user: user} do
  886. clear_config([:instance, :account_activation_required], true)
  887. {:ok, job} = User.delete(user)
  888. {:ok, _} = ObanHelpers.perform(job)
  889. refute User.get_cached_by_id(user.id)
  890. refute User.get_by_id(user.id)
  891. end
  892. test "deactivates user when activation is not required", %{user: user} do
  893. clear_config([:instance, :account_activation_required], false)
  894. {:ok, job} = User.delete(user)
  895. {:ok, _} = ObanHelpers.perform(job)
  896. assert %{deactivated: true} = User.get_cached_by_id(user.id)
  897. assert %{deactivated: true} = User.get_by_id(user.id)
  898. end
  899. end
  900. test "get_public_key_for_ap_id fetches a user that's not in the db" do
  901. assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
  902. end
  903. describe "per-user rich-text filtering" do
  904. test "html_filter_policy returns default policies, when rich-text is enabled" do
  905. user = insert(:user)
  906. assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
  907. end
  908. test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
  909. user = insert(:user, no_rich_text: true)
  910. assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
  911. end
  912. end
  913. describe "caching" do
  914. test "invalidate_cache works" do
  915. user = insert(:user)
  916. User.set_cache(user)
  917. User.invalidate_cache(user)
  918. {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
  919. {:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
  920. end
  921. test "User.delete() plugs any possible zombie objects" do
  922. user = insert(:user)
  923. {:ok, job} = User.delete(user)
  924. {:ok, _} = ObanHelpers.perform(job)
  925. {:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
  926. assert cached_user != user
  927. {:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")
  928. assert cached_user != user
  929. end
  930. end
  931. describe "account_status/1" do
  932. setup do: clear_config([:instance, :account_activation_required])
  933. test "return confirmation_pending for unconfirm user" do
  934. Pleroma.Config.put([:instance, :account_activation_required], true)
  935. user = insert(:user, confirmation_pending: true)
  936. assert User.account_status(user) == :confirmation_pending
  937. end
  938. test "return active for confirmed user" do
  939. Pleroma.Config.put([:instance, :account_activation_required], true)
  940. user = insert(:user, confirmation_pending: false)
  941. assert User.account_status(user) == :active
  942. end
  943. test "return active for remote user" do
  944. user = insert(:user, local: false)
  945. assert User.account_status(user) == :active
  946. end
  947. test "returns :password_reset_pending for user with reset password" do
  948. user = insert(:user, password_reset_pending: true)
  949. assert User.account_status(user) == :password_reset_pending
  950. end
  951. test "returns :deactivated for deactivated user" do
  952. user = insert(:user, local: true, confirmation_pending: false, deactivated: true)
  953. assert User.account_status(user) == :deactivated
  954. end
  955. end
  956. describe "superuser?/1" do
  957. test "returns false for unprivileged users" do
  958. user = insert(:user, local: true)
  959. refute User.superuser?(user)
  960. end
  961. test "returns false for remote users" do
  962. user = insert(:user, local: false)
  963. remote_admin_user = insert(:user, local: false, is_admin: true)
  964. refute User.superuser?(user)
  965. refute User.superuser?(remote_admin_user)
  966. end
  967. test "returns true for local moderators" do
  968. user = insert(:user, local: true, is_moderator: true)
  969. assert User.superuser?(user)
  970. end
  971. test "returns true for local admins" do
  972. user = insert(:user, local: true, is_admin: true)
  973. assert User.superuser?(user)
  974. end
  975. end
  976. describe "invisible?/1" do
  977. test "returns true for an invisible user" do
  978. user = insert(:user, local: true, invisible: true)
  979. assert User.invisible?(user)
  980. end
  981. test "returns false for a non-invisible user" do
  982. user = insert(:user, local: true)
  983. refute User.invisible?(user)
  984. end
  985. end
  986. describe "visible_for?/2" do
  987. test "returns true when the account is itself" do
  988. user = insert(:user, local: true)
  989. assert User.visible_for?(user, user)
  990. end
  991. test "returns false when the account is unauthenticated and auth is required" do
  992. Pleroma.Config.put([:instance, :account_activation_required], true)
  993. user = insert(:user, local: true, confirmation_pending: true)
  994. other_user = insert(:user, local: true)
  995. refute User.visible_for?(user, other_user)
  996. end
  997. test "returns true when the account is unauthenticated and auth is not required" do
  998. user = insert(:user, local: true, confirmation_pending: true)
  999. other_user = insert(:user, local: true)
  1000. assert User.visible_for?(user, other_user)
  1001. end
  1002. test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
  1003. Pleroma.Config.put([:instance, :account_activation_required], true)
  1004. user = insert(:user, local: true, confirmation_pending: true)
  1005. other_user = insert(:user, local: true, is_admin: true)
  1006. assert User.visible_for?(user, other_user)
  1007. end
  1008. end
  1009. describe "parse_bio/2" do
  1010. test "preserves hosts in user links text" do
  1011. remote_user = insert(:user, local: false, nickname: "nick@domain.com")
  1012. user = insert(:user)
  1013. bio = "A.k.a. @nick@domain.com"
  1014. expected_text =
  1015. ~s(A.k.a. <span class="h-card"><a class="u-url mention" data-user="#{remote_user.id}" href="#{
  1016. remote_user.ap_id
  1017. }" rel="ugc">@<span>nick@domain.com</span></a></span>)
  1018. assert expected_text == User.parse_bio(bio, user)
  1019. end
  1020. test "Adds rel=me on linkbacked urls" do
  1021. user = insert(:user, ap_id: "https://social.example.org/users/lain")
  1022. bio = "http://example.com/rel_me/null"
  1023. expected_text = "<a href=\"#{bio}\">#{bio}</a>"
  1024. assert expected_text == User.parse_bio(bio, user)
  1025. bio = "http://example.com/rel_me/link"
  1026. expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
  1027. assert expected_text == User.parse_bio(bio, user)
  1028. bio = "http://example.com/rel_me/anchor"
  1029. expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
  1030. assert expected_text == User.parse_bio(bio, user)
  1031. end
  1032. end
  1033. test "follower count is updated when a follower is blocked" do
  1034. user = insert(:user)
  1035. follower = insert(:user)
  1036. follower2 = insert(:user)
  1037. follower3 = insert(:user)
  1038. {:ok, follower} = User.follow(follower, user)
  1039. {:ok, _follower2} = User.follow(follower2, user)
  1040. {:ok, _follower3} = User.follow(follower3, user)
  1041. {:ok, _user_relationship} = User.block(user, follower)
  1042. user = refresh_record(user)
  1043. assert user.follower_count == 2
  1044. end
  1045. describe "list_inactive_users_query/1" do
  1046. defp days_ago(days) do
  1047. NaiveDateTime.add(
  1048. NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
  1049. -days * 60 * 60 * 24,
  1050. :second
  1051. )
  1052. end
  1053. test "Users are inactive by default" do
  1054. total = 10
  1055. users =
  1056. Enum.map(1..total, fn _ ->
  1057. insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
  1058. end)
  1059. inactive_users_ids =
  1060. Pleroma.User.list_inactive_users_query()
  1061. |> Pleroma.Repo.all()
  1062. |> Enum.map(& &1.id)
  1063. Enum.each(users, fn user ->
  1064. assert user.id in inactive_users_ids
  1065. end)
  1066. end
  1067. test "Only includes users who has no recent activity" do
  1068. total = 10
  1069. users =
  1070. Enum.map(1..total, fn _ ->
  1071. insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
  1072. end)
  1073. {inactive, active} = Enum.split(users, trunc(total / 2))
  1074. Enum.map(active, fn user ->
  1075. to = Enum.random(users -- [user])
  1076. {:ok, _} =
  1077. CommonAPI.post(user, %{
  1078. status: "hey @#{to.nickname}"
  1079. })
  1080. end)
  1081. inactive_users_ids =
  1082. Pleroma.User.list_inactive_users_query()
  1083. |> Pleroma.Repo.all()
  1084. |> Enum.map(& &1.id)
  1085. Enum.each(active, fn user ->
  1086. refute user.id in inactive_users_ids
  1087. end)
  1088. Enum.each(inactive, fn user ->
  1089. assert user.id in inactive_users_ids
  1090. end)
  1091. end
  1092. test "Only includes users with no read notifications" do
  1093. total = 10
  1094. users =
  1095. Enum.map(1..total, fn _ ->
  1096. insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
  1097. end)
  1098. [sender | recipients] = users
  1099. {inactive, active} = Enum.split(recipients, trunc(total / 2))
  1100. Enum.each(recipients, fn to ->
  1101. {:ok, _} =
  1102. CommonAPI.post(sender, %{
  1103. status: "hey @#{to.nickname}"
  1104. })
  1105. {:ok, _} =
  1106. CommonAPI.post(sender, %{
  1107. status: "hey again @#{to.nickname}"
  1108. })
  1109. end)
  1110. Enum.each(active, fn user ->
  1111. [n1, _n2] = Pleroma.Notification.for_user(user)
  1112. {:ok, _} = Pleroma.Notification.read_one(user, n1.id)
  1113. end)
  1114. inactive_users_ids =
  1115. Pleroma.User.list_inactive_users_query()
  1116. |> Pleroma.Repo.all()
  1117. |> Enum.map(& &1.id)
  1118. Enum.each(active, fn user ->
  1119. refute user.id in inactive_users_ids
  1120. end)
  1121. Enum.each(inactive, fn user ->
  1122. assert user.id in inactive_users_ids
  1123. end)
  1124. end
  1125. end
  1126. describe "toggle_confirmation/1" do
  1127. test "if user is confirmed" do
  1128. user = insert(:user, confirmation_pending: false)
  1129. {:ok, user} = User.toggle_confirmation(user)
  1130. assert user.confirmation_pending
  1131. assert user.confirmation_token
  1132. end
  1133. test "if user is unconfirmed" do
  1134. user = insert(:user, confirmation_pending: true, confirmation_token: "some token")
  1135. {:ok, user} = User.toggle_confirmation(user)
  1136. refute user.confirmation_pending
  1137. refute user.confirmation_token
  1138. end
  1139. end
  1140. describe "ensure_keys_present" do
  1141. test "it creates keys for a user and stores them in info" do
  1142. user = insert(:user)
  1143. refute is_binary(user.keys)
  1144. {:ok, user} = User.ensure_keys_present(user)
  1145. assert is_binary(user.keys)
  1146. end
  1147. test "it doesn't create keys if there already are some" do
  1148. user = insert(:user, keys: "xxx")
  1149. {:ok, user} = User.ensure_keys_present(user)
  1150. assert user.keys == "xxx"
  1151. end
  1152. end
  1153. describe "get_ap_ids_by_nicknames" do
  1154. test "it returns a list of AP ids for a given set of nicknames" do
  1155. user = insert(:user)
  1156. user_two = insert(:user)
  1157. ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
  1158. assert length(ap_ids) == 2
  1159. assert user.ap_id in ap_ids
  1160. assert user_two.ap_id in ap_ids
  1161. end
  1162. end
  1163. describe "sync followers count" do
  1164. setup do
  1165. user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
  1166. user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
  1167. insert(:user, local: true)
  1168. insert(:user, local: false, deactivated: true)
  1169. {:ok, user1: user1, user2: user2}
  1170. end
  1171. test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
  1172. [fdb_user1] = User.external_users(limit: 1)
  1173. assert fdb_user1.ap_id
  1174. assert fdb_user1.ap_id == user1.ap_id
  1175. assert fdb_user1.id == user1.id
  1176. [fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)
  1177. assert fdb_user2.ap_id
  1178. assert fdb_user2.ap_id == user2.ap_id
  1179. assert fdb_user2.id == user2.id
  1180. assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
  1181. end
  1182. end
  1183. describe "is_internal_user?/1" do
  1184. test "non-internal user returns false" do
  1185. user = insert(:user)
  1186. refute User.is_internal_user?(user)
  1187. end
  1188. test "user with no nickname returns true" do
  1189. user = insert(:user, %{nickname: nil})
  1190. assert User.is_internal_user?(user)
  1191. end
  1192. test "user with internal-prefixed nickname returns true" do
  1193. user = insert(:user, %{nickname: "internal.test"})
  1194. assert User.is_internal_user?(user)
  1195. end
  1196. end
  1197. describe "update_and_set_cache/1" do
  1198. test "returns error when user is stale instead Ecto.StaleEntryError" do
  1199. user = insert(:user)
  1200. changeset = Ecto.Changeset.change(user, bio: "test")
  1201. Repo.delete(user)
  1202. assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
  1203. User.update_and_set_cache(changeset)
  1204. end
  1205. test "performs update cache if user updated" do
  1206. user = insert(:user)
  1207. assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
  1208. changeset = Ecto.Changeset.change(user, bio: "test-bio")
  1209. assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
  1210. assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
  1211. assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
  1212. end
  1213. end
  1214. describe "following/followers synchronization" do
  1215. setup do: clear_config([:instance, :external_user_synchronization])
  1216. test "updates the counters normally on following/getting a follow when disabled" do
  1217. Pleroma.Config.put([:instance, :external_user_synchronization], false)
  1218. user = insert(:user)
  1219. other_user =
  1220. insert(:user,
  1221. local: false,
  1222. follower_address: "http://localhost:4001/users/masto_closed/followers",
  1223. following_address: "http://localhost:4001/users/masto_closed/following",
  1224. ap_enabled: true
  1225. )
  1226. assert other_user.following_count == 0
  1227. assert other_user.follower_count == 0
  1228. {:ok, user} = Pleroma.User.follow(user, other_user)
  1229. other_user = Pleroma.User.get_by_id(other_user.id)
  1230. assert user.following_count == 1
  1231. assert other_user.follower_count == 1
  1232. end
  1233. test "syncronizes the counters with the remote instance for the followed when enabled" do
  1234. Pleroma.Config.put([:instance, :external_user_synchronization], false)
  1235. user = insert(:user)
  1236. other_user =
  1237. insert(:user,
  1238. local: false,
  1239. follower_address: "http://localhost:4001/users/masto_closed/followers",
  1240. following_address: "http://localhost:4001/users/masto_closed/following",
  1241. ap_enabled: true
  1242. )
  1243. assert other_user.following_count == 0
  1244. assert other_user.follower_count == 0
  1245. Pleroma.Config.put([:instance, :external_user_synchronization], true)
  1246. {:ok, _user} = User.follow(user, other_user)
  1247. other_user = User.get_by_id(other_user.id)
  1248. assert other_user.follower_count == 437
  1249. end
  1250. test "syncronizes the counters with the remote instance for the follower when enabled" do
  1251. Pleroma.Config.put([:instance, :external_user_synchronization], false)
  1252. user = insert(:user)
  1253. other_user =
  1254. insert(:user,
  1255. local: false,
  1256. follower_address: "http://localhost:4001/users/masto_closed/followers",
  1257. following_address: "http://localhost:4001/users/masto_closed/following",
  1258. ap_enabled: true
  1259. )
  1260. assert other_user.following_count == 0
  1261. assert other_user.follower_count == 0
  1262. Pleroma.Config.put([:instance, :external_user_synchronization], true)
  1263. {:ok, other_user} = User.follow(other_user, user)
  1264. assert other_user.following_count == 152
  1265. end
  1266. end
  1267. describe "change_email/2" do
  1268. setup do
  1269. [user: insert(:user)]
  1270. end
  1271. test "blank email returns error", %{user: user} do
  1272. assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
  1273. assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
  1274. end
  1275. test "non unique email returns error", %{user: user} do
  1276. %{email: email} = insert(:user)
  1277. assert {:error, %{errors: [email: {"has already been taken", _}]}} =
  1278. User.change_email(user, email)
  1279. end
  1280. test "invalid email returns error", %{user: user} do
  1281. assert {:error, %{errors: [email: {"has invalid format", _}]}} =
  1282. User.change_email(user, "cofe")
  1283. end
  1284. test "changes email", %{user: user} do
  1285. assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
  1286. end
  1287. end
  1288. describe "get_cached_by_nickname_or_id" do
  1289. setup do
  1290. local_user = insert(:user)
  1291. remote_user = insert(:user, nickname: "nickname@example.com", local: false)
  1292. [local_user: local_user, remote_user: remote_user]
  1293. end
  1294. setup do: clear_config([:instance, :limit_to_local_content])
  1295. test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
  1296. remote_user: remote_user
  1297. } do
  1298. Pleroma.Config.put([:instance, :limit_to_local_content], false)
  1299. assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
  1300. Pleroma.Config.put([:instance, :limit_to_local_content], true)
  1301. assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
  1302. Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
  1303. assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
  1304. end
  1305. test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
  1306. %{remote_user: remote_user} do
  1307. Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
  1308. assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
  1309. end
  1310. test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
  1311. %{remote_user: remote_user, local_user: local_user} do
  1312. Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
  1313. assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
  1314. end
  1315. test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
  1316. %{remote_user: remote_user} do
  1317. Pleroma.Config.put([:instance, :limit_to_local_content], true)
  1318. assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
  1319. end
  1320. test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
  1321. %{local_user: local_user} do
  1322. Pleroma.Config.put([:instance, :limit_to_local_content], false)
  1323. assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
  1324. Pleroma.Config.put([:instance, :limit_to_local_content], true)
  1325. assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
  1326. Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
  1327. assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
  1328. end
  1329. end
  1330. describe "update_email_notifications/2" do
  1331. setup do
  1332. user = insert(:user, email_notifications: %{"digest" => true})
  1333. {:ok, user: user}
  1334. end
  1335. test "Notifications are updated", %{user: user} do
  1336. true = user.email_notifications["digest"]
  1337. assert {:ok, result} = User.update_email_notifications(user, %{"digest" => false})
  1338. assert result.email_notifications["digest"] == false
  1339. end
  1340. end
  1341. test "avatar fallback" do
  1342. user = insert(:user)
  1343. assert User.avatar_url(user) =~ "/images/avi.png"
  1344. clear_config([:assets, :default_user_avatar], "avatar.png")
  1345. user = User.get_cached_by_nickname_or_id(user.nickname)
  1346. assert User.avatar_url(user) =~ "avatar.png"
  1347. assert User.avatar_url(user, no_default: true) == nil
  1348. end
  1349. end