git.squeep.com Git - akkoma/blob - test/web/feed/user_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 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
  15   clear_config_all([:instance, :federating]) do
  16     Config.put([:instance, :federating], true)
  17   end
  18
  19   describe "feed" do
  20     clear_config([:feed])
  21
  22     test "gets a feed", %{conn: conn} do
  23       Config.put(
  24         [:feed, :post_title],
  25         %{max_length: 10, omission: "..."}
  26       )
  27
  28       activity = insert(:note_activity)
  29
  30       note =
  31         insert(:note,
  32           data: %{
  33             "content" => "This is :moominmamma: note ",
  34             "attachment" => [
  35               %{
  36                 "url" => [
  37                   %{"mediaType" => "image/png", "href" => "https://pleroma.gov/image.png"}
  38                 ]
  39               }
  40             ],
  41             "inReplyTo" => activity.data["id"]
  42           }
  43         )
  44
  45       note_activity = insert(:note_activity, note: note)
  46       user = User.get_cached_by_ap_id(note_activity.data["actor"])
  47
  48       note2 =
  49         insert(:note,
  50           user: user,
  51           data: %{
  52             "content" => "42 This is :moominmamma: note ",
  53             "inReplyTo" => activity.data["id"]
  54           }
  55         )
  56
  57       _note_activity2 = insert(:note_activity, note: note2)
  58       object = Object.normalize(note_activity)
  59
  60       resp =
  61         conn
  62         |> put_req_header("content-type", "application/atom+xml")
  63         |> get(user_feed_path(conn, :feed, user.nickname))
  64         |> response(200)
  65
  66       activity_titles =
  67         resp
  68         |> SweetXml.parse()
  69         |> SweetXml.xpath(~x"//entry/title/text()"l)
  70
  71       assert activity_titles == ['42 This...', 'This is...']
  72       assert resp =~ object.data["content"]
  73     end
  74
  75     test "returns 404 for a missing feed", %{conn: conn} do
  76       conn =
  77         conn
  78         |> put_req_header("content-type", "application/atom+xml")
  79         |> get(user_feed_path(conn, :feed, "nonexisting"))
  80
  81       assert response(conn, 404)
  82     end
  83   end
  84
  85   describe "feed_redirect" do
  86     test "undefined format. it redirects to feed", %{conn: conn} do
  87       note_activity = insert(:note_activity)
  88       user = User.get_cached_by_ap_id(note_activity.data["actor"])
  89
  90       response =
  91         conn
  92         |> put_req_header("accept", "application/xml")
  93         |> get("/users/#{user.nickname}")
  94         |> response(302)
  95
  96       assert response ==
  97                "<html><body>You are being <a href=\"#{Pleroma.Web.base_url()}/users/#{
  98                  user.nickname
  99                }/feed.atom\">redirected</a>.</body></html>"
 100     end
 101
 102     test "undefined format. it returns error when user not found", %{conn: conn} do
 103       response =
 104         conn
 105         |> put_req_header("accept", "application/xml")
 106         |> get(user_feed_path(conn, :feed, "jimm"))
 107         |> response(404)
 108
 109       assert response == ~S({"error":"Not found"})
 110     end
 111
 112     test "activity+json format. it redirects on actual feed of user", %{conn: conn} do
 113       note_activity = insert(:note_activity)
 114       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 115
 116       response =
 117         conn
 118         |> put_req_header("accept", "application/activity+json")
 119         |> get("/users/#{user.nickname}")
 120         |> json_response(200)
 121
 122       assert response["endpoints"] == %{
 123                "oauthAuthorizationEndpoint" => "#{Pleroma.Web.base_url()}/oauth/authorize",
 124                "oauthRegistrationEndpoint" => "#{Pleroma.Web.base_url()}/api/v1/apps",
 125                "oauthTokenEndpoint" => "#{Pleroma.Web.base_url()}/oauth/token",
 126                "sharedInbox" => "#{Pleroma.Web.base_url()}/inbox",
 127                "uploadMedia" => "#{Pleroma.Web.base_url()}/api/ap/upload_media"
 128              }
 129
 130       assert response["@context"] == [
 131                "https://www.w3.org/ns/activitystreams",
 132                "http://localhost:4001/schemas/litepub-0.1.jsonld",
 133                %{"@language" => "und"}
 134              ]
 135
 136       assert Map.take(response, [
 137                "followers",
 138                "following",
 139                "id",
 140                "inbox",
 141                "manuallyApprovesFollowers",
 142                "name",
 143                "outbox",
 144                "preferredUsername",
 145                "summary",
 146                "tag",
 147                "type",
 148                "url"
 149              ]) == %{
 150                "followers" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/followers",
 151                "following" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/following",
 152                "id" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}",
 153                "inbox" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/inbox",
 154                "manuallyApprovesFollowers" => false,
 155                "name" => user.name,
 156                "outbox" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/outbox",
 157                "preferredUsername" => user.nickname,
 158                "summary" => user.bio,
 159                "tag" => [],
 160                "type" => "Person",
 161                "url" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
 162              }
 163     end
 164
 165     test "activity+json format. it returns error whe use not found", %{conn: conn} do
 166       response =
 167         conn
 168         |> put_req_header("accept", "application/activity+json")
 169         |> get("/users/jimm")
 170         |> json_response(404)
 171
 172       assert response == "Not found"
 173     end
 174
 175     test "json format. it redirects on actual feed of user", %{conn: conn} do
 176       note_activity = insert(:note_activity)
 177       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 178
 179       response =
 180         conn
 181         |> put_req_header("accept", "application/json")
 182         |> get("/users/#{user.nickname}")
 183         |> json_response(200)
 184
 185       assert response["endpoints"] == %{
 186                "oauthAuthorizationEndpoint" => "#{Pleroma.Web.base_url()}/oauth/authorize",
 187                "oauthRegistrationEndpoint" => "#{Pleroma.Web.base_url()}/api/v1/apps",
 188                "oauthTokenEndpoint" => "#{Pleroma.Web.base_url()}/oauth/token",
 189                "sharedInbox" => "#{Pleroma.Web.base_url()}/inbox",
 190                "uploadMedia" => "#{Pleroma.Web.base_url()}/api/ap/upload_media"
 191              }
 192
 193       assert response["@context"] == [
 194                "https://www.w3.org/ns/activitystreams",
 195                "http://localhost:4001/schemas/litepub-0.1.jsonld",
 196                %{"@language" => "und"}
 197              ]
 198
 199       assert Map.take(response, [
 200                "followers",
 201                "following",
 202                "id",
 203                "inbox",
 204                "manuallyApprovesFollowers",
 205                "name",
 206                "outbox",
 207                "preferredUsername",
 208                "summary",
 209                "tag",
 210                "type",
 211                "url"
 212              ]) == %{
 213                "followers" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/followers",
 214                "following" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/following",
 215                "id" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}",
 216                "inbox" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/inbox",
 217                "manuallyApprovesFollowers" => false,
 218                "name" => user.name,
 219                "outbox" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}/outbox",
 220                "preferredUsername" => user.nickname,
 221                "summary" => user.bio,
 222                "tag" => [],
 223                "type" => "Person",
 224                "url" => "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
 225              }
 226     end
 227
 228     test "json format. it returns error whe use not found", %{conn: conn} do
 229       response =
 230         conn
 231         |> put_req_header("accept", "application/json")
 232         |> get("/users/jimm")
 233         |> json_response(404)
 234
 235       assert response == "Not found"
 236     end
 237
 238     test "html format. it redirects on actual feed of user", %{conn: conn} do
 239       note_activity = insert(:note_activity)
 240       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 241
 242       response =
 243         conn
 244         |> get("/users/#{user.nickname}")
 245         |> response(200)
 246
 247       assert response ==
 248                Fallback.RedirectController.redirector_with_meta(
 249                  conn,
 250                  %{user: user}
 251                ).resp_body
 252     end
 253
 254     test "html format. it returns error when user not found", %{conn: conn} do
 255       response =
 256         conn
 257         |> get("/users/jimm")
 258         |> json_response(404)
 259
 260       assert response == %{"error" => "Not found"}
 261     end
 262   end
 263
 264   describe "feed_redirect (depending on federation enabled state)" do
 265     setup %{conn: conn} do
 266       user = insert(:user)
 267       conn = put_req_header(conn, "accept", "application/json")
 268
 269       %{conn: conn, user: user}
 270     end
 271
 272     clear_config([:instance, :federating])
 273
 274     test "renders if instance is federating", %{conn: conn, user: user} do
 275       Config.put([:instance, :federating], true)
 276
 277       conn = get(conn, "/users/#{user.nickname}")
 278       assert json_response(conn, 200)
 279     end
 280
 281     test "renders 404 if instance is NOT federating", %{conn: conn, user: user} do
 282       Config.put([:instance, :federating], false)
 283
 284       conn = get(conn, "/users/#{user.nickname}")
 285       assert json_response(conn, 404)
 286     end
 287   end
 288 end