summaryrefslogtreecommitdiff
path: root/test/user_relationship_test.exs
blob: f12406097f1e460ec732b163f49aa93d6708c8ae (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
# Pleroma: A lightweight social networking server
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only

defmodule Pleroma.UserRelationshipTest do
  alias Pleroma.UserRelationship

  use Pleroma.DataCase

  import Pleroma.Factory

  describe "*_exists?/2" do
    setup do
      {:ok, users: insert_list(2, :user)}
    end

    test "returns false if record doesn't exist", %{users: [user1, user2]} do
      refute UserRelationship.block_exists?(user1, user2)
      refute UserRelationship.mute_exists?(user1, user2)
      refute UserRelationship.notification_mute_exists?(user1, user2)
      refute UserRelationship.reblog_mute_exists?(user1, user2)
      refute UserRelationship.inverse_subscription_exists?(user1, user2)
    end

    test "returns true if record exists", %{users: [user1, user2]} do
      for relationship_type <- [
            :block,
            :mute,
            :notification_mute,
            :reblog_mute,
            :inverse_subscription
          ] do
        insert(:user_relationship,
          source: user1,
          target: user2,
          relationship_type: relationship_type
        )
      end

      assert UserRelationship.block_exists?(user1, user2)
      assert UserRelationship.mute_exists?(user1, user2)
      assert UserRelationship.notification_mute_exists?(user1, user2)
      assert UserRelationship.reblog_mute_exists?(user1, user2)
      assert UserRelationship.inverse_subscription_exists?(user1, user2)
    end
  end

  describe "create_*/2" do
    setup do
      {:ok, users: insert_list(2, :user)}
    end

    test "creates user relationship record if it doesn't exist", %{users: [user1, user2]} do
      for relationship_type <- [
            :block,
            :mute,
            :notification_mute,
            :reblog_mute,
            :inverse_subscription
          ] do
        insert(:user_relationship,
          source: user1,
          target: user2,
          relationship_type: relationship_type
        )
      end

      UserRelationship.create_block(user1, user2)
      UserRelationship.create_mute(user1, user2)
      UserRelationship.create_notification_mute(user1, user2)
      UserRelationship.create_reblog_mute(user1, user2)
      UserRelationship.create_inverse_subscription(user1, user2)

      assert UserRelationship.block_exists?(user1, user2)
      assert UserRelationship.mute_exists?(user1, user2)
      assert UserRelationship.notification_mute_exists?(user1, user2)
      assert UserRelationship.reblog_mute_exists?(user1, user2)
      assert UserRelationship.inverse_subscription_exists?(user1, user2)
    end

    test "if record already exists, returns it", %{users: [user1, user2]} do
      user_block = UserRelationship.create_block(user1, user2)
      assert user_block == UserRelationship.create_block(user1, user2)
    end
  end

  describe "delete_*/2" do
    setup do
      {:ok, users: insert_list(2, :user)}
    end

    test "deletes user relationship record if it exists", %{users: [user1, user2]} do
      for relationship_type <- [
            :block,
            :mute,
            :notification_mute,
            :reblog_mute,
            :inverse_subscription
          ] do
        insert(:user_relationship,
          source: user1,
          target: user2,
          relationship_type: relationship_type
        )
      end

      assert {:ok, %UserRelationship{}} = UserRelationship.delete_block(user1, user2)
      assert {:ok, %UserRelationship{}} = UserRelationship.delete_mute(user1, user2)
      assert {:ok, %UserRelationship{}} = UserRelationship.delete_notification_mute(user1, user2)
      assert {:ok, %UserRelationship{}} = UserRelationship.delete_reblog_mute(user1, user2)

      assert {:ok, %UserRelationship{}} =
               UserRelationship.delete_inverse_subscription(user1, user2)

      refute UserRelationship.block_exists?(user1, user2)
      refute UserRelationship.mute_exists?(user1, user2)
      refute UserRelationship.notification_mute_exists?(user1, user2)
      refute UserRelationship.reblog_mute_exists?(user1, user2)
      refute UserRelationship.inverse_subscription_exists?(user1, user2)
    end

    test "if record does not exist, returns {:ok, nil}", %{users: [user1, user2]} do
      assert {:ok, nil} = UserRelationship.delete_block(user1, user2)
      assert {:ok, nil} = UserRelationship.delete_mute(user1, user2)
      assert {:ok, nil} = UserRelationship.delete_notification_mute(user1, user2)
      assert {:ok, nil} = UserRelationship.delete_reblog_mute(user1, user2)
      assert {:ok, nil} = UserRelationship.delete_inverse_subscription(user1, user2)
    end
  end
end