user_test.exs 25 KB
Newer Older
kaniini's avatar
kaniini committed
1 2 3 4
# Pleroma: A lightweight social networking server
# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only

lain's avatar
lain committed
5 6
defmodule Pleroma.UserTest do
  alias Pleroma.Builders.UserBuilder
lain's avatar
lain committed
7
  alias Pleroma.{User, Repo, Activity}
8
  alias Pleroma.Web.CommonAPI
lain's avatar
lain committed
9 10
  use Pleroma.DataCase

lain's avatar
lain committed
11 12
  import Pleroma.Factory

Maksim's avatar
Maksim committed
13 14 15 16 17
  setup_all do
    Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
    :ok
  end

18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
  describe "when tags are nil" do
    test "tagging a user" do
      user = insert(:user, %{tags: nil})
      user = User.tag(user, ["cool", "dude"])

      assert "cool" in user.tags
      assert "dude" in user.tags
    end

    test "untagging a user" do
      user = insert(:user, %{tags: nil})
      user = User.untag(user, ["cool", "dude"])

      assert user.tags == []
    end
  end

lain's avatar
lain committed
35
  test "ap_id returns the activity pub id for the user" do
lain's avatar
lain committed
36
    user = UserBuilder.build()
lain's avatar
lain committed
37

lain's avatar
lain committed
38
    expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
lain's avatar
lain committed
39 40 41 42 43

    assert expected_ap_id == User.ap_id(user)
  end

  test "ap_followers returns the followers collection for the user" do
lain's avatar
lain committed
44
    user = UserBuilder.build()
lain's avatar
lain committed
45 46 47 48 49

    expected_followers_collection = "#{User.ap_id(user)}/followers"

    assert expected_followers_collection == User.ap_followers(user)
  end
lain's avatar
lain committed
50

lain's avatar
lain committed
51 52 53 54 55 56 57 58 59 60 61
  test "follow_all follows mutliple users" do
    user = insert(:user)
    followed_one = insert(:user)
    followed_two = insert(:user)

    {:ok, user} = User.follow_all(user, [followed_one, followed_two])

    assert User.following?(user, followed_one)
    assert User.following?(user, followed_two)
  end

lain's avatar
lain committed
62
  test "follow takes a user and another user" do
lain's avatar
lain committed
63 64
    user = insert(:user)
    followed = insert(:user)
lain's avatar
lain committed
65

lain's avatar
lain committed
66
    {:ok, user} = User.follow(user, followed)
lain's avatar
lain committed
67 68 69

    user = Repo.get(User, user.id)

70
    followed = User.get_by_ap_id(followed.ap_id)
lain's avatar
lain committed
71
    assert followed.info.follower_count == 1
72

73
    assert User.ap_followers(followed) in user.following
lain's avatar
lain committed
74
  end
lain's avatar
lain committed
75

lain's avatar
lain committed
76 77
  test "can't follow a deactivated users" do
    user = insert(:user)
lain's avatar
lain committed
78
    followed = insert(:user, info: %{deactivated: true})
lain's avatar
lain committed
79 80 81 82

    {:error, _} = User.follow(user, followed)
  end

83 84 85 86 87 88 89 90 91
  test "can't follow a user who blocked us" do
    blocker = insert(:user)
    blockee = insert(:user)

    {:ok, blocker} = User.block(blocker, blockee)

    {:error, _} = User.follow(blockee, blocker)
  end

kaniini's avatar
kaniini committed
92
  test "local users do not automatically follow local locked accounts" do
lain's avatar
lain committed
93 94
    follower = insert(:user, info: %{locked: true})
    followed = insert(:user, info: %{locked: true})
kaniini's avatar
kaniini committed
95 96 97 98 99 100

    {:ok, follower} = User.maybe_direct_follow(follower, followed)

    refute User.following?(follower, followed)
  end

lain's avatar
lain committed
101 102 103 104
  # This is a somewhat useless test.
  # test "following a remote user will ensure a websub subscription is present" do
  #   user = insert(:user)
  #   {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")
lain's avatar
lain committed
105

lain's avatar
lain committed
106
  #   assert followed.local == false
lain's avatar
lain committed
107

lain's avatar
lain committed
108 109
  #   {:ok, user} = User.follow(user, followed)
  #   assert User.ap_followers(followed) in user.following
lain's avatar
lain committed
110

lain's avatar
lain committed
111 112 113
  #   query = from w in WebsubClientSubscription,
  #   where: w.topic == ^followed.info["topic"]
  #   websub = Repo.one(query)
lain's avatar
lain committed
114

lain's avatar
lain committed
115 116
  #   assert websub
  # end
lain's avatar
lain committed
117

lain's avatar
lain committed
118
  test "unfollow takes a user and another user" do
lain's avatar
lain committed
119 120
    followed = insert(:user)
    user = insert(:user, %{following: [User.ap_followers(followed)]})
lain's avatar
lain committed
121

lain's avatar
lain committed
122
    {:ok, user, _activity} = User.unfollow(user, followed)
lain's avatar
lain committed
123 124 125 126 127

    user = Repo.get(User, user.id)

    assert user.following == []
  end
128

129 130 131 132 133
  test "unfollow doesn't unfollow yourself" do
    user = insert(:user)

    {:error, _} = User.unfollow(user, user)

eal's avatar
eal committed
134
    user = Repo.get(User, user.id)
135 136 137
    assert user.following == [user.ap_id]
  end

138
  test "test if a user is following another user" do
lain's avatar
lain committed
139 140
    followed = insert(:user)
    user = insert(:user, %{following: [User.ap_followers(followed)]})
141 142 143 144

    assert User.following?(user, followed)
    refute User.following?(followed, user)
  end
lain's avatar
lain committed
145 146 147 148 149 150 151 152 153 154 155

  describe "user registration" do
    @full_user_data %{
      bio: "A guy",
      name: "my name",
      nickname: "nick",
      password: "test",
      password_confirmation: "test",
      email: "email@example.com"
    }

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
    test "it autofollows accounts that are set for it" do
      user = insert(:user)
      remote_user = insert(:user, %{local: false})

      Pleroma.Config.put([:instance, :autofollowed_nicknames], [
        user.nickname,
        remote_user.nickname
      ])

      cng = User.register_changeset(%User{}, @full_user_data)

      {:ok, registered_user} = User.register(cng)

      assert User.following?(registered_user, user)
      refute User.following?(registered_user, remote_user)
    end

vaartis's avatar
vaartis committed
173
    test "it requires an email, name, nickname and password, bio is optional" do
lain's avatar
lain committed
174
      @full_user_data
lain's avatar
lain committed
175 176
      |> Map.keys()
      |> Enum.each(fn key ->
lain's avatar
lain committed
177 178
        params = Map.delete(@full_user_data, key)
        changeset = User.register_changeset(%User{}, params)
vaartis's avatar
vaartis committed
179

lain's avatar
lain committed
180
        assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
lain's avatar
lain committed
181 182 183
      end)
    end

lain's avatar
lain committed
184 185 186 187 188 189 190 191 192 193 194 195 196 197
    test "it restricts certain nicknames" do
      [restricted_name | _] = Pleroma.Config.get([Pleroma.User, :restricted_nicknames])

      assert is_bitstring(restricted_name)

      params =
        @full_user_data
        |> Map.put(:nickname, restricted_name)

      changeset = User.register_changeset(%User{}, params)

      refute changeset.valid?
    end

lain's avatar
lain committed
198 199 200 201 202 203 204
    test "it sets the password_hash, ap_id and following fields" do
      changeset = User.register_changeset(%User{}, @full_user_data)

      assert changeset.valid?

      assert is_binary(changeset.changes[:password_hash])
      assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
lain's avatar
lain committed
205 206 207 208 209

      assert changeset.changes[:following] == [
               User.ap_followers(%User{nickname: @full_user_data.nickname})
             ]

210
      assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
lain's avatar
lain committed
211
    end
212 213 214 215 216 217 218 219 220 221 222 223

    test "it ensures info is not nil" do
      changeset = User.register_changeset(%User{}, @full_user_data)

      assert changeset.valid?

      {:ok, user} =
        changeset
        |> Repo.insert()

      refute is_nil(user.info)
    end
lain's avatar
lain committed
224
  end
lain's avatar
lain committed
225

226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
  describe "user registration, with :account_activation_required" do
    @full_user_data %{
      bio: "A guy",
      name: "my name",
      nickname: "nick",
      password: "test",
      password_confirmation: "test",
      email: "email@example.com"
    }

    setup do
      setting = Pleroma.Config.get([:instance, :account_activation_required])

      unless setting do
        Pleroma.Config.put([:instance, :account_activation_required], true)
        on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
      end

      :ok
    end

    test "it creates unconfirmed user" do
      changeset = User.register_changeset(%User{}, @full_user_data)
      assert changeset.valid?

      {:ok, user} = Repo.insert(changeset)

      assert user.info.confirmation_pending
      assert user.info.confirmation_token
    end

    test "it creates confirmed user if :confirmed option is given" do
      changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
      assert changeset.valid?

      {:ok, user} = Repo.insert(changeset)

      refute user.info.confirmation_pending
      refute user.info.confirmation_token
    end
  end

Maksim's avatar
Maksim committed
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
  describe "get_or_fetch/1" do
    test "gets an existing user by nickname" do
      user = insert(:user)
      fetched_user = User.get_or_fetch(user.nickname)

      assert user == fetched_user
    end

    test "gets an existing user by ap_id" do
      ap_id = "http://mastodon.example.org/users/admin"

      user =
        insert(
          :user,
          local: false,
          nickname: "admin@mastodon.example.org",
          ap_id: ap_id,
          info: %{}
        )

      fetched_user = User.get_or_fetch(ap_id)
      freshed_user = refresh_record(user)
      assert freshed_user == fetched_user
    end
  end

lain's avatar
lain committed
294 295 296 297 298 299 300 301
  describe "fetching a user from nickname or trying to build one" do
    test "gets an existing user" do
      user = insert(:user)
      fetched_user = User.get_or_fetch_by_nickname(user.nickname)

      assert user == fetched_user
    end

302 303 304 305 306 307 308
    test "gets an existing user, case insensitive" do
      user = insert(:user, nickname: "nick")
      fetched_user = User.get_or_fetch_by_nickname("NICK")

      assert user == fetched_user
    end

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
    test "gets an existing user by fully qualified nickname" do
      user = insert(:user)

      fetched_user =
        User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

      assert user == fetched_user
    end

    test "gets an existing user by fully qualified nickname, case insensitive" do
      user = insert(:user, nickname: "nick")
      casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

      fetched_user = User.get_or_fetch_by_nickname(casing_altered_fqn)

      assert user == fetched_user
    end

lain's avatar
lain committed
327 328 329 330 331 332 333 334 335
    test "fetches an external user via ostatus if no user exists" do
      fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
      assert fetched_user.nickname == "shp@social.heldscal.la"
    end

    test "returns nil if no user could be fetched" do
      fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
      assert fetched_user == nil
    end
lain's avatar
lain committed
336 337 338 339 340

    test "returns nil for nonexistant local user" do
      fetched_user = User.get_or_fetch_by_nickname("nonexistant")
      assert fetched_user == nil
    end
341 342 343 344 345 346 347 348 349 350

    test "updates an existing user, if stale" do
      a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

      orig_user =
        insert(
          :user,
          local: false,
          nickname: "admin@mastodon.example.org",
          ap_id: "http://mastodon.example.org/users/admin",
lain's avatar
lain committed
351 352
          last_refreshed_at: a_week_ago,
          info: %{}
353 354 355 356 357
        )

      assert orig_user.last_refreshed_at == a_week_ago

      user = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
lain's avatar
lain committed
358
      assert user.info.source_data["endpoints"]
359 360 361

      refute user.last_refreshed_at == orig_user.last_refreshed_at
    end
lain's avatar
lain committed
362
  end
363 364 365

  test "returns an ap_id for a user" do
    user = insert(:user)
lain's avatar
lain committed
366 367 368 369 370 371 372

    assert User.ap_id(user) ==
             Pleroma.Web.Router.Helpers.o_status_url(
               Pleroma.Web.Endpoint,
               :feed_redirect,
               user.nickname
             )
373 374 375 376
  end

  test "returns an ap_followers link for a user" do
    user = insert(:user)
lain's avatar
lain committed
377 378 379 380 381 382 383

    assert User.ap_followers(user) ==
             Pleroma.Web.Router.Helpers.o_status_url(
               Pleroma.Web.Endpoint,
               :feed_redirect,
               user.nickname
             ) <> "/followers"
384
  end
lain's avatar
lain committed
385 386 387 388 389 390 391

  describe "remote user creation changeset" do
    @valid_remote %{
      bio: "hello",
      name: "Someone",
      nickname: "a@b.de",
      ap_id: "http...",
lain's avatar
lain committed
392 393
      info: %{some: "info"},
      avatar: %{some: "avatar"}
lain's avatar
lain committed
394 395 396 397 398 399 400
    }

    test "it confirms validity" do
      cs = User.remote_user_creation(@valid_remote)
      assert cs.valid?
    end

401 402 403
    test "it sets the follower_adress" do
      cs = User.remote_user_creation(@valid_remote)
      # remote users get a fake local follower address
lain's avatar
lain committed
404 405
      assert cs.changes.follower_address ==
               User.ap_followers(%User{nickname: @valid_remote[:nickname]})
406 407
    end

lain's avatar
lain committed
408 409
    test "it enforces the fqn format for nicknames" do
      cs = User.remote_user_creation(%{@valid_remote | nickname: "bla"})
lain's avatar
lain committed
410 411
      assert cs.changes.local == false
      assert cs.changes.avatar
lain's avatar
lain committed
412 413 414 415
      refute cs.valid?
    end

    test "it has required fields" do
416
      [:name, :ap_id]
lain's avatar
lain committed
417
      |> Enum.each(fn field ->
lain's avatar
lain committed
418 419 420 421 422 423
        cs = User.remote_user_creation(Map.delete(@valid_remote, field))
        refute cs.valid?
      end)
    end

    test "it restricts some sizes" do
lain's avatar
lain committed
424
      [bio: 5000, name: 100]
lain's avatar
lain committed
425
      |> Enum.each(fn {field, size} ->
lain's avatar
lain committed
426 427 428 429 430 431 432 433 434 435
        string = String.pad_leading(".", size)
        cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
        assert cs.valid?

        string = String.pad_leading(".", size + 1)
        cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
        refute cs.valid?
      end)
    end
  end
lain's avatar
lain committed
436 437 438 439 440 441 442 443 444 445 446 447 448

  describe "followers and friends" do
    test "gets all followers for a given user" do
      user = insert(:user)
      follower_one = insert(:user)
      follower_two = insert(:user)
      not_follower = insert(:user)

      {:ok, follower_one} = User.follow(follower_one, user)
      {:ok, follower_two} = User.follow(follower_two, user)

      {:ok, res} = User.get_followers(user)

lain's avatar
lain committed
449 450 451
      assert Enum.member?(res, follower_one)
      assert Enum.member?(res, follower_two)
      refute Enum.member?(res, not_follower)
lain's avatar
lain committed
452 453 454 455 456 457 458 459 460 461 462 463 464
    end

    test "gets all friends (followed users) for a given user" do
      user = insert(:user)
      followed_one = insert(:user)
      followed_two = insert(:user)
      not_followed = insert(:user)

      {:ok, user} = User.follow(user, followed_one)
      {:ok, user} = User.follow(user, followed_two)

      {:ok, res} = User.get_friends(user)

465 466
      followed_one = User.get_by_ap_id(followed_one.ap_id)
      followed_two = User.get_by_ap_id(followed_two.ap_id)
lain's avatar
lain committed
467 468 469
      assert Enum.member?(res, followed_one)
      assert Enum.member?(res, followed_two)
      refute Enum.member?(res, not_followed)
lain's avatar
lain committed
470 471
    end
  end
472 473 474 475 476 477 478

  describe "updating note and follower count" do
    test "it sets the info->note_count property" do
      note = insert(:note)

      user = User.get_by_ap_id(note.data["actor"])

lain's avatar
lain committed
479
      assert user.info.note_count == 0
480 481 482

      {:ok, user} = User.update_note_count(user)

lain's avatar
lain committed
483
      assert user.info.note_count == 1
484 485
    end

486 487 488 489
    test "it increases the info->note_count property" do
      note = insert(:note)
      user = User.get_by_ap_id(note.data["actor"])

lain's avatar
lain committed
490
      assert user.info.note_count == 0
491 492 493

      {:ok, user} = User.increase_note_count(user)

lain's avatar
lain committed
494
      assert user.info.note_count == 1
495 496 497

      {:ok, user} = User.increase_note_count(user)

lain's avatar
lain committed
498
      assert user.info.note_count == 2
499 500
    end

501 502 503 504
    test "it decreases the info->note_count property" do
      note = insert(:note)
      user = User.get_by_ap_id(note.data["actor"])

lain's avatar
lain committed
505
      assert user.info.note_count == 0
506 507 508

      {:ok, user} = User.increase_note_count(user)

lain's avatar
lain committed
509
      assert user.info.note_count == 1
510 511 512

      {:ok, user} = User.decrease_note_count(user)

lain's avatar
lain committed
513
      assert user.info.note_count == 0
514 515 516

      {:ok, user} = User.decrease_note_count(user)

lain's avatar
lain committed
517
      assert user.info.note_count == 0
518 519
    end

520 521 522 523 524 525
    test "it sets the info->follower_count property" do
      user = insert(:user)
      follower = insert(:user)

      User.follow(follower, user)

lain's avatar
lain committed
526
      assert user.info.follower_count == 0
527 528 529

      {:ok, user} = User.update_follower_count(user)

lain's avatar
lain committed
530
      assert user.info.follower_count == 1
531 532
    end
  end
lain's avatar
lain committed
533

534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
  describe "follow_import" do
    test "it imports user followings from list" do
      [user1, user2, user3] = insert_list(3, :user)

      identifiers = [
        user2.ap_id,
        user3.nickname
      ]

      result = User.follow_import(user1, identifiers)
      assert is_list(result)
      assert result == [user2, user3]
    end
  end

lain's avatar
lain committed
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
  describe "blocks" do
    test "it blocks people" do
      user = insert(:user)
      blocked_user = insert(:user)

      refute User.blocks?(user, blocked_user)

      {:ok, user} = User.block(user, blocked_user)

      assert User.blocks?(user, blocked_user)
    end

    test "it unblocks users" do
      user = insert(:user)
      blocked_user = insert(:user)

      {:ok, user} = User.block(user, blocked_user)
      {:ok, user} = User.unblock(user, blocked_user)

      refute User.blocks?(user, blocked_user)
    end
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624

    test "blocks tear down cyclical follow relationships" do
      blocker = insert(:user)
      blocked = insert(:user)

      {:ok, blocker} = User.follow(blocker, blocked)
      {:ok, blocked} = User.follow(blocked, blocker)

      assert User.following?(blocker, blocked)
      assert User.following?(blocked, blocker)

      {:ok, blocker} = User.block(blocker, blocked)
      blocked = Repo.get(User, blocked.id)

      assert User.blocks?(blocker, blocked)

      refute User.following?(blocker, blocked)
      refute User.following?(blocked, blocker)
    end

    test "blocks tear down blocker->blocked follow relationships" do
      blocker = insert(:user)
      blocked = insert(:user)

      {:ok, blocker} = User.follow(blocker, blocked)

      assert User.following?(blocker, blocked)
      refute User.following?(blocked, blocker)

      {:ok, blocker} = User.block(blocker, blocked)
      blocked = Repo.get(User, blocked.id)

      assert User.blocks?(blocker, blocked)

      refute User.following?(blocker, blocked)
      refute User.following?(blocked, blocker)
    end

    test "blocks tear down blocked->blocker follow relationships" do
      blocker = insert(:user)
      blocked = insert(:user)

      {:ok, blocked} = User.follow(blocked, blocker)

      refute User.following?(blocker, blocked)
      assert User.following?(blocked, blocker)

      {:ok, blocker} = User.block(blocker, blocked)
      blocked = Repo.get(User, blocked.id)

      assert User.blocks?(blocker, blocked)

      refute User.following?(blocker, blocked)
      refute User.following?(blocked, blocker)
    end
lain's avatar
lain committed
625
  end
626

eal's avatar
eal committed
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
  describe "domain blocking" do
    test "blocks domains" do
      user = insert(:user)
      collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

      {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

      assert User.blocks?(user, collateral_user)
    end

    test "unblocks domains" do
      user = insert(:user)
      collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

      {:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
      {:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

      refute User.blocks?(user, collateral_user)
    end
  end

648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
  describe "blocks_import" do
    test "it imports user blocks from list" do
      [user1, user2, user3] = insert_list(3, :user)

      identifiers = [
        user2.ap_id,
        user3.nickname
      ]

      result = User.blocks_import(user1, identifiers)
      assert is_list(result)
      assert result == [user2, user3]
    end
  end

663 664 665 666 667 668
  test "get recipients from activity" do
    actor = insert(:user)
    user = insert(:user, local: true)
    user_two = insert(:user, local: false)
    addressed = insert(:user, local: true)
    addressed_remote = insert(:user, local: false)
lain's avatar
lain committed
669 670 671 672 673

    {:ok, activity} =
      CommonAPI.post(actor, %{
        "status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
      })
674 675 676 677

    assert [addressed] == User.get_recipients_from_activity(activity)

    {:ok, user} = User.follow(user, actor)
lain's avatar
lain committed
678
    {:ok, _user_two} = User.follow(user_two, actor)
679 680 681 682 683
    recipients = User.get_recipients_from_activity(activity)
    assert length(recipients) == 2
    assert user in recipients
    assert addressed in recipients
  end
lain's avatar
lain committed
684

scarlett's avatar
scarlett committed
685
  test ".deactivate can de-activate then re-activate a user" do
lain's avatar
lain committed
686
    user = insert(:user)
lain's avatar
lain committed
687
    assert false == user.info.deactivated
lain's avatar
lain committed
688
    {:ok, user} = User.deactivate(user)
lain's avatar
lain committed
689
    assert true == user.info.deactivated
scarlett's avatar
scarlett committed
690
    {:ok, user} = User.deactivate(user, false)
lain's avatar
lain committed
691
    assert false == user.info.deactivated
lain's avatar
lain committed
692
  end
lain's avatar
lain committed
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708

  test ".delete deactivates a user, all follow relationships and all create activities" do
    user = insert(:user)
    followed = insert(:user)
    follower = insert(:user)

    {:ok, user} = User.follow(user, followed)
    {:ok, follower} = User.follow(follower, user)

    {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
    {:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})

    {:ok, _, _} = CommonAPI.favorite(activity_two.id, user)
    {:ok, _, _} = CommonAPI.favorite(activity.id, follower)
    {:ok, _, _} = CommonAPI.repeat(activity.id, follower)

709
    {:ok, _} = User.delete(user)
lain's avatar
lain committed
710 711 712 713 714

    followed = Repo.get(User, followed.id)
    follower = Repo.get(User, follower.id)
    user = Repo.get(User, user.id)

lain's avatar
lain committed
715
    assert user.info.deactivated
lain's avatar
lain committed
716 717 718 719

    refute User.following?(user, followed)
    refute User.following?(followed, follower)

lain's avatar
lain committed
720 721 722
    # TODO: Remove favorites, repeats, delete activities.

    refute Repo.get(Activity, activity.id)
lain's avatar
lain committed
723
  end
724 725 726 727

  test "get_public_key_for_ap_id fetches a user that's not in the db" do
    assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
  end
lain's avatar
lain committed
728 729 730

  test "insert or update a user from given data" do
    user = insert(:user, %{nickname: "nick@name.de"})
lain's avatar
lain committed
731
    data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}
lain's avatar
lain committed
732 733 734

    assert {:ok, %User{}} = User.insert_or_update_user(data)
  end
735 736

  describe "per-user rich-text filtering" do
Rin Toshaka's avatar
Rin Toshaka committed
737
    test "html_filter_policy returns default policies, when rich-text is enabled" do
738 739
      user = insert(:user)

740
      assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
741 742 743
    end

    test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
lain's avatar
lain committed
744
      user = insert(:user, %{info: %{no_rich_text: true}})
745 746 747 748

      assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
    end
  end
749 750 751 752

  describe "caching" do
    test "invalidate_cache works" do
      user = insert(:user)
Maksim's avatar
Maksim committed
753
      _user_info = User.get_cached_user_info(user)
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775

      User.invalidate_cache(user)

      {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
      {:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
      {:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
    end

    test "User.delete() plugs any possible zombie objects" do
      user = insert(:user)

      {:ok, _} = User.delete(user)

      {:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

      assert cached_user != user

      {:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

      assert cached_user != user
    end
  end
776 777 778

  describe "User.search" do
    test "finds a user, ranking by similarity" do
Maksim's avatar
Maksim committed
779 780 781
      _user = insert(:user, %{name: "lain"})
      _user_two = insert(:user, %{name: "ean"})
      _user_three = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
782 783 784 785 786
      user_four = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})

      assert user_four ==
               User.search("lain@ple") |> List.first() |> Map.put(:search_distance, nil)
    end
cascode's avatar
cascode committed
787 788 789 790 791 792

    test "finds a user whose name is nil" do
      _user = insert(:user, %{name: "notamatch", nickname: "testuser@pleroma.amplifie.red"})
      user_two = insert(:user, %{name: nil, nickname: "lain@pleroma.soykaf.com"})

      assert user_two ==
cascode's avatar
cascode committed
793 794 795
               User.search("lain@pleroma.soykaf.com")
               |> List.first()
               |> Map.put(:search_distance, nil)
cascode's avatar
cascode committed
796
    end
797
  end
798

799
  test "auth_active?/1 works correctly" do
800 801 802 803 804 805
    Pleroma.Config.put([:instance, :account_activation_required], true)

    local_user = insert(:user, local: true, info: %{confirmation_pending: true})
    confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
    remote_user = insert(:user, local: false)

806 807 808
    refute User.auth_active?(local_user)
    assert User.auth_active?(confirmed_user)
    assert User.auth_active?(remote_user)
809 810 811

    Pleroma.Config.put([:instance, :account_activation_required], false)
  end
812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839

  describe "superuser?/1" do
    test "returns false for unprivileged users" do
      user = insert(:user, local: true)

      refute User.superuser?(user)
    end

    test "returns false for remote users" do
      user = insert(:user, local: false)
      remote_admin_user = insert(:user, local: false, info: %{is_admin: true})

      refute User.superuser?(user)
      refute User.superuser?(remote_admin_user)
    end

    test "returns true for local moderators" do
      user = insert(:user, local: true, info: %{is_moderator: true})

      assert User.superuser?(user)
    end

    test "returns true for local admins" do
      user = insert(:user, local: true, info: %{is_admin: true})

      assert User.superuser?(user)
    end
  end
840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876

  describe "visible_for?/2" do
    test "returns true when the account is itself" do
      user = insert(:user, local: true)

      assert User.visible_for?(user, user)
    end

    test "returns false when the account is unauthenticated and auth is required" do
      Pleroma.Config.put([:instance, :account_activation_required], true)

      user = insert(:user, local: true, info: %{confirmation_pending: true})
      other_user = insert(:user, local: true)

      refute User.visible_for?(user, other_user)

      Pleroma.Config.put([:instance, :account_activation_required], false)
    end

    test "returns true when the account is unauthenticated and auth is not required" do
      user = insert(:user, local: true, info: %{confirmation_pending: true})
      other_user = insert(:user, local: true)

      assert User.visible_for?(user, other_user)
    end

    test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
      Pleroma.Config.put([:instance, :account_activation_required], true)

      user = insert(:user, local: true, info: %{confirmation_pending: true})
      other_user = insert(:user, local: true, info: %{is_admin: true})

      assert User.visible_for?(user, other_user)

      Pleroma.Config.put([:instance, :account_activation_required], false)
    end
  end
lain's avatar
lain committed
877
end