git.squeep.com Git - akkoma/blob - test/pleroma/web/feed/user_controller_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.Web.Feed.UserControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   import Pleroma.Factory
   9   import SweetXml
  10
  11   alias Pleroma.Config
  12   alias Pleroma.Object
  13   alias Pleroma.User
  14   alias Pleroma.Web.CommonAPI
  15   alias Pleroma.Web.Feed.FeedView
  16
  17   setup do: clear_config([:static_fe, :enabled], false)
  18
  19   describe "feed" do
  20     setup do: clear_config([:feed])
  21
  22     setup do
  23       Config.put(
  24         [:feed, :post_title],
  25         %{max_length: 15, omission: "..."}
  26       )
  27
  28       activity = insert(:note_activity)
  29
  30       note =
  31         insert(:note,
  32           data: %{
  33             "content" => "This & this is :moominmamma: note ",
  34             "source" => "This & this is :moominmamma: note ",
  35             "attachment" => [
  36               %{
  37                 "url" => [
  38                   %{"mediaType" => "image/png", "href" => "https://pleroma.gov/image.png"}
  39                 ]
  40               }
  41             ],
  42             "inReplyTo" => activity.data["id"],
  43             "context" => "2hu & as",
  44             "summary" => "2hu & as"
  45           }
  46         )
  47
  48       note_activity = insert(:note_activity, note: note)
  49       user = User.get_cached_by_ap_id(note_activity.data["actor"])
  50
  51       note2 =
  52         insert(:note,
  53           user: user,
  54           data: %{
  55             "content" => "42 & This is :moominmamma: note ",
  56             "inReplyTo" => activity.data["id"]
  57           }
  58         )
  59
  60       note_activity2 = insert(:note_activity, note: note2)
  61       object = Object.normalize(note_activity, fetch: false)
  62
  63       [user: user, object: object, max_id: note_activity2.id]
  64     end
  65
  66     test "gets an atom feed", %{conn: conn, user: user, object: object, max_id: max_id} do
  67       resp =
  68         conn
  69         |> put_req_header("accept", "application/atom+xml")
  70         |> get(user_feed_path(conn, :feed, user.nickname))
  71         |> response(200)
  72
  73       activity_titles =
  74         resp
  75         |> SweetXml.parse()
  76         |> SweetXml.xpath(~x"//entry/title/text()"l)
  77
  78       assert activity_titles == ['42 &amp; Thi...', 'This &amp; t...']
  79       assert resp =~ FeedView.escape(object.data["content"])
  80       assert resp =~ FeedView.escape(object.data["summary"])
  81       assert resp =~ FeedView.escape(object.data["context"])
  82
  83       resp =
  84         conn
  85         |> put_req_header("accept", "application/atom+xml")
  86         |> get("/users/#{user.nickname}/feed", %{"max_id" => max_id})
  87         |> response(200)
  88
  89       activity_titles =
  90         resp
  91         |> SweetXml.parse()
  92         |> SweetXml.xpath(~x"//entry/title/text()"l)
  93
  94       assert activity_titles == ['This &amp; t...']
  95     end
  96
  97     test "gets a rss feed", %{conn: conn, user: user, object: object, max_id: max_id} do
  98       resp =
  99         conn
 100         |> put_req_header("accept", "application/rss+xml")
 101         |> get("/users/#{user.nickname}/feed.rss")
 102         |> response(200)
 103
 104       activity_titles =
 105         resp
 106         |> SweetXml.parse()
 107         |> SweetXml.xpath(~x"//item/title/text()"l)
 108
 109       assert activity_titles == ['42 &amp; Thi...', 'This &amp; t...']
 110       assert resp =~ FeedView.escape(object.data["content"])
 111       assert resp =~ FeedView.escape(object.data["summary"])
 112       assert resp =~ FeedView.escape(object.data["context"])
 113
 114       resp =
 115         conn
 116         |> put_req_header("accept", "application/rss+xml")
 117         |> get("/users/#{user.nickname}/feed.rss", %{"max_id" => max_id})
 118         |> response(200)
 119
 120       activity_titles =
 121         resp
 122         |> SweetXml.parse()
 123         |> SweetXml.xpath(~x"//item/title/text()"l)
 124
 125       assert activity_titles == ['This &amp; t...']
 126     end
 127
 128     test "returns 404 for a missing feed", %{conn: conn} do
 129       conn =
 130         conn
 131         |> put_req_header("accept", "application/atom+xml")
 132         |> get(user_feed_path(conn, :feed, "nonexisting"))
 133
 134       assert response(conn, 404)
 135     end
 136
 137     test "returns feed with public and unlisted activities", %{conn: conn} do
 138       user = insert(:user)
 139
 140       {:ok, _} = CommonAPI.post(user, %{status: "public", visibility: "public"})
 141       {:ok, _} = CommonAPI.post(user, %{status: "direct", visibility: "direct"})
 142       {:ok, _} = CommonAPI.post(user, %{status: "unlisted", visibility: "unlisted"})
 143       {:ok, _} = CommonAPI.post(user, %{status: "private", visibility: "private"})
 144
 145       resp =
 146         conn
 147         |> put_req_header("accept", "application/atom+xml")
 148         |> get(user_feed_path(conn, :feed, user.nickname))
 149         |> response(200)
 150
 151       activity_titles =
 152         resp
 153         |> SweetXml.parse()
 154         |> SweetXml.xpath(~x"//entry/title/text()"l)
 155         |> Enum.sort()
 156
 157       assert activity_titles == ['public', 'unlisted']
 158     end
 159
 160     test "returns 404 when the user is remote", %{conn: conn} do
 161       user = insert(:user, local: false)
 162
 163       {:ok, _} = CommonAPI.post(user, %{status: "test"})
 164
 165       assert conn
 166              |> put_req_header("accept", "application/atom+xml")
 167              |> get(user_feed_path(conn, :feed, user.nickname))
 168              |> response(404)
 169     end
 170
 171     test "does not require authentication on non-federating instances", %{conn: conn} do
 172       clear_config([:instance, :federating], false)
 173       user = insert(:user)
 174
 175       conn
 176       |> put_req_header("accept", "application/rss+xml")
 177       |> get("/users/#{user.nickname}/feed.rss")
 178       |> response(200)
 179     end
 180   end
 181
 182   # Note: see ActivityPubControllerTest for JSON format tests
 183   describe "feed_redirect" do
 184     test "with html format, it redirects to user feed", %{conn: conn} do
 185       note_activity = insert(:note_activity)
 186       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 187
 188       response =
 189         conn
 190         |> get("/users/#{user.nickname}")
 191         |> response(200)
 192
 193       assert response ==
 194                Pleroma.Web.Fallback.RedirectController.redirector_with_meta(
 195                  conn,
 196                  %{user: user}
 197                ).resp_body
 198     end
 199
 200     test "with html format, it returns error when user is not found", %{conn: conn} do
 201       response =
 202         conn
 203         |> get("/users/jimm")
 204         |> json_response(404)
 205
 206       assert response == %{"error" => "Not found"}
 207     end
 208
 209     test "with non-html / non-json format, it redirects to user feed in atom format", %{
 210       conn: conn
 211     } do
 212       note_activity = insert(:note_activity)
 213       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 214
 215       conn =
 216         conn
 217         |> put_req_header("accept", "application/xml")
 218         |> get("/users/#{user.nickname}")
 219
 220       assert conn.status == 302
 221       assert redirected_to(conn) == "#{Pleroma.Web.base_url()}/users/#{user.nickname}/feed.atom"
 222     end
 223
 224     test "with non-html / non-json format, it returns error when user is not found", %{conn: conn} do
 225       response =
 226         conn
 227         |> put_req_header("accept", "application/xml")
 228         |> get(user_feed_path(conn, :feed, "jimm"))
 229         |> response(404)
 230
 231       assert response == ~S({"error":"Not found"})
 232     end
 233   end
 234
 235   describe "private instance" do
 236     setup do: clear_config([:instance, :public])
 237
 238     test "returns 404 for user feed", %{conn: conn} do
 239       Config.put([:instance, :public], false)
 240       user = insert(:user)
 241
 242       {:ok, _} = CommonAPI.post(user, %{status: "test"})
 243
 244       assert conn
 245              |> put_req_header("accept", "application/atom+xml")
 246              |> get(user_feed_path(conn, :feed, user.nickname))
 247              |> response(404)
 248     end
 249   end
 250 end