git.squeep.com Git - akkoma/blob - test/pleroma/user_relationship_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.UserRelationshipTest do
   6   alias Pleroma.UserRelationship
   7
   8   use Pleroma.DataCase, async: false
   9
  10   import Mock
  11   import Pleroma.Factory
  12
  13   describe "*_exists?/2" do
  14     setup do
  15       {:ok, users: insert_list(2, :user)}
  16     end
  17
  18     test "returns false if record doesn't exist", %{users: [user1, user2]} do
  19       refute UserRelationship.block_exists?(user1, user2)
  20       refute UserRelationship.mute_exists?(user1, user2)
  21       refute UserRelationship.notification_mute_exists?(user1, user2)
  22       refute UserRelationship.reblog_mute_exists?(user1, user2)
  23       refute UserRelationship.inverse_subscription_exists?(user1, user2)
  24     end
  25
  26     test "returns true if record exists", %{users: [user1, user2]} do
  27       for relationship_type <- [
  28             :block,
  29             :mute,
  30             :notification_mute,
  31             :reblog_mute,
  32             :inverse_subscription
  33           ] do
  34         insert(:user_relationship,
  35           source: user1,
  36           target: user2,
  37           relationship_type: relationship_type
  38         )
  39       end
  40
  41       assert UserRelationship.block_exists?(user1, user2)
  42       assert UserRelationship.mute_exists?(user1, user2)
  43       assert UserRelationship.notification_mute_exists?(user1, user2)
  44       assert UserRelationship.reblog_mute_exists?(user1, user2)
  45       assert UserRelationship.inverse_subscription_exists?(user1, user2)
  46     end
  47   end
  48
  49   describe "create_*/2" do
  50     setup do
  51       {:ok, users: insert_list(2, :user)}
  52     end
  53
  54     test "creates user relationship record if it doesn't exist", %{users: [user1, user2]} do
  55       for relationship_type <- [
  56             :block,
  57             :mute,
  58             :notification_mute,
  59             :reblog_mute,
  60             :inverse_subscription
  61           ] do
  62         insert(:user_relationship,
  63           source: user1,
  64           target: user2,
  65           relationship_type: relationship_type
  66         )
  67       end
  68
  69       UserRelationship.create_block(user1, user2)
  70       UserRelationship.create_mute(user1, user2)
  71       UserRelationship.create_notification_mute(user1, user2)
  72       UserRelationship.create_reblog_mute(user1, user2)
  73       UserRelationship.create_inverse_subscription(user1, user2)
  74
  75       assert UserRelationship.block_exists?(user1, user2)
  76       assert UserRelationship.mute_exists?(user1, user2)
  77       assert UserRelationship.notification_mute_exists?(user1, user2)
  78       assert UserRelationship.reblog_mute_exists?(user1, user2)
  79       assert UserRelationship.inverse_subscription_exists?(user1, user2)
  80     end
  81
  82     test "if record already exists, returns it", %{users: [user1, user2]} do
  83       user_block =
  84         with_mock NaiveDateTime, [:passthrough], utc_now: fn -> ~N[2017-03-17 17:09:58] end do
  85           {:ok, %{inserted_at: ~N[2017-03-17 17:09:58]}} =
  86             UserRelationship.create_block(user1, user2)
  87         end
  88
  89       assert user_block == UserRelationship.create_block(user1, user2)
  90     end
  91   end
  92
  93   describe "delete_*/2" do
  94     setup do
  95       {:ok, users: insert_list(2, :user)}
  96     end
  97
  98     test "deletes user relationship record if it exists", %{users: [user1, user2]} do
  99       for relationship_type <- [
 100             :block,
 101             :mute,
 102             :notification_mute,
 103             :reblog_mute,
 104             :inverse_subscription
 105           ] do
 106         insert(:user_relationship,
 107           source: user1,
 108           target: user2,
 109           relationship_type: relationship_type
 110         )
 111       end
 112
 113       assert {:ok, %UserRelationship{}} = UserRelationship.delete_block(user1, user2)
 114       assert {:ok, %UserRelationship{}} = UserRelationship.delete_mute(user1, user2)
 115       assert {:ok, %UserRelationship{}} = UserRelationship.delete_notification_mute(user1, user2)
 116       assert {:ok, %UserRelationship{}} = UserRelationship.delete_reblog_mute(user1, user2)
 117
 118       assert {:ok, %UserRelationship{}} =
 119                UserRelationship.delete_inverse_subscription(user1, user2)
 120
 121       refute UserRelationship.block_exists?(user1, user2)
 122       refute UserRelationship.mute_exists?(user1, user2)
 123       refute UserRelationship.notification_mute_exists?(user1, user2)
 124       refute UserRelationship.reblog_mute_exists?(user1, user2)
 125       refute UserRelationship.inverse_subscription_exists?(user1, user2)
 126     end
 127
 128     test "if record does not exist, returns {:ok, nil}", %{users: [user1, user2]} do
 129       assert {:ok, nil} = UserRelationship.delete_block(user1, user2)
 130       assert {:ok, nil} = UserRelationship.delete_mute(user1, user2)
 131       assert {:ok, nil} = UserRelationship.delete_notification_mute(user1, user2)
 132       assert {:ok, nil} = UserRelationship.delete_reblog_mute(user1, user2)
 133       assert {:ok, nil} = UserRelationship.delete_inverse_subscription(user1, user2)
 134     end
 135   end
 136 end