Git of dcc - anni/blob - test/pleroma/filter_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.FilterTest do
   6   use Pleroma.DataCase, async: true
   7
   8   import Pleroma.Factory
   9
  10   alias Oban.Job
  11   alias Pleroma.Filter
  12
  13   setup do
  14     [user: insert(:user)]
  15   end
  16
  17   describe "creating filters" do
  18     test "creation validation error", %{user: user} do
  19       attrs = %{
  20         user_id: user.id,
  21         expires_in: 60
  22       }
  23
  24       {:error, _} = Filter.create(attrs)
  25
  26       assert Repo.all(Job) == []
  27     end
  28
  29     test "use passed expires_at instead expires_in", %{user: user} do
  30       now = NaiveDateTime.utc_now()
  31
  32       attrs = %{
  33         user_id: user.id,
  34         expires_at: now,
  35         phrase: "knights",
  36         context: ["home"],
  37         expires_in: 600
  38       }
  39
  40       {:ok, %Filter{} = filter} = Filter.create(attrs)
  41
  42       result = Filter.get(filter.filter_id, user)
  43       assert result.expires_at == NaiveDateTime.truncate(now, :second)
  44
  45       [job] = Repo.all(Job)
  46
  47       assert DateTime.truncate(job.scheduled_at, :second) ==
  48                now |> NaiveDateTime.truncate(:second) |> DateTime.from_naive!("Etc/UTC")
  49     end
  50
  51     test "creating one filter", %{user: user} do
  52       attrs = %{
  53         user_id: user.id,
  54         filter_id: 42,
  55         phrase: "knights",
  56         context: ["home"]
  57       }
  58
  59       {:ok, %Filter{} = filter} = Filter.create(attrs)
  60       result = Filter.get(filter.filter_id, user)
  61       assert attrs.phrase == result.phrase
  62     end
  63
  64     test "creating with expired_at", %{user: user} do
  65       attrs = %{
  66         user_id: user.id,
  67         filter_id: 42,
  68         phrase: "knights",
  69         context: ["home"],
  70         expires_in: 60
  71       }
  72
  73       {:ok, %Filter{} = filter} = Filter.create(attrs)
  74       result = Filter.get(filter.filter_id, user)
  75       assert attrs.phrase == result.phrase
  76
  77       assert [_] = Repo.all(Job)
  78     end
  79
  80     test "creating one filter without a pre-defined filter_id", %{user: user} do
  81       attrs = %{
  82         user_id: user.id,
  83         phrase: "knights",
  84         context: ["home"]
  85       }
  86
  87       {:ok, %Filter{} = filter} = Filter.create(attrs)
  88       # Should start at 1
  89       assert filter.filter_id == 1
  90     end
  91
  92     test "creating additional filters uses previous highest filter_id + 1", %{user: user} do
  93       filter1 = insert(:filter, user: user)
  94
  95       attrs = %{
  96         user_id: user.id,
  97         # No filter_id
  98         phrase: "who",
  99         context: ["home"]
 100       }
 101
 102       {:ok, %Filter{} = filter2} = Filter.create(attrs)
 103       assert filter2.filter_id == filter1.filter_id + 1
 104     end
 105
 106     test "filter_id is unique per user", %{user: user_one} do
 107       user_two = insert(:user)
 108
 109       attrs1 = %{
 110         user_id: user_one.id,
 111         phrase: "knights",
 112         context: ["home"]
 113       }
 114
 115       {:ok, %Filter{} = filter_one} = Filter.create(attrs1)
 116
 117       attrs2 = %{
 118         user_id: user_two.id,
 119         phrase: "who",
 120         context: ["home"]
 121       }
 122
 123       {:ok, %Filter{} = filter_two} = Filter.create(attrs2)
 124
 125       assert filter_one.filter_id == 1
 126       assert filter_two.filter_id == 1
 127
 128       result_one = Filter.get(filter_one.filter_id, user_one)
 129       assert result_one.phrase == filter_one.phrase
 130
 131       result_two = Filter.get(filter_two.filter_id, user_two)
 132       assert result_two.phrase == filter_two.phrase
 133     end
 134   end
 135
 136   test "deleting a filter", %{user: user} do
 137     filter = insert(:filter, user: user)
 138
 139     assert Repo.get(Filter, filter.id)
 140     {:ok, filter} = Filter.delete(filter)
 141     refute Repo.get(Filter, filter.id)
 142   end
 143
 144   test "deleting a filter with expires_at is removing Oban job too", %{user: user} do
 145     attrs = %{
 146       user_id: user.id,
 147       phrase: "cofe",
 148       context: ["home"],
 149       expires_in: 600
 150     }
 151
 152     {:ok, filter} = Filter.create(attrs)
 153     assert %Job{id: job_id} = Pleroma.Workers.PurgeExpiredFilter.get_expiration(filter.id)
 154     {:ok, _} = Filter.delete(filter)
 155
 156     assert Repo.get(Job, job_id) == nil
 157   end
 158
 159   test "getting all filters by an user", %{user: user} do
 160     filter1 = insert(:filter, user: user)
 161     filter2 = insert(:filter, user: user)
 162
 163     filter_ids = user |> Filter.get_filters() |> collect_ids()
 164
 165     assert filter1.id in filter_ids
 166     assert filter2.id in filter_ids
 167   end
 168
 169   test "updating a filter", %{user: user} do
 170     filter = insert(:filter, user: user)
 171
 172     changes = %{
 173       phrase: "who",
 174       context: ["home", "timeline"]
 175     }
 176
 177     {:ok, updated_filter} = Filter.update(filter, changes)
 178
 179     assert filter != updated_filter
 180     assert updated_filter.phrase == changes.phrase
 181     assert updated_filter.context == changes.context
 182   end
 183
 184   test "updating with error", %{user: user} do
 185     filter = insert(:filter, user: user)
 186
 187     changes = %{
 188       phrase: nil
 189     }
 190
 191     {:error, _} = Filter.update(filter, changes)
 192   end
 193 end