git.squeep.com Git - akkoma/blob - test/support/conn_case.ex

   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.ConnCase do
   6   @moduledoc """
   7   This module defines the test case to be used by
   8   tests that require setting up a connection.
   9
  10   Such tests rely on `Phoenix.ConnTest` and also
  11   import other functionality to make it easier
  12   to build common datastructures and query the data layer.
  13
  14   Finally, if the test case interacts with the database,
  15   it cannot be async. For this reason, every test runs
  16   inside a transaction which is reset at the beginning
  17   of the test unless the test case is marked as async.
  18   """
  19
  20   use ExUnit.CaseTemplate
  21
  22   using do
  23     quote do
  24       # Import conveniences for testing with connections
  25       use Phoenix.ConnTest
  26       use Pleroma.Tests.Helpers
  27       import Pleroma.Web.Router.Helpers
  28
  29       alias Pleroma.Config
  30
  31       # The default endpoint for testing
  32       @endpoint Pleroma.Web.Endpoint
  33
  34       # Sets up OAuth access with specified scopes
  35       defp oauth_access(scopes, opts \\ []) do
  36         user =
  37           Keyword.get_lazy(opts, :user, fn ->
  38             Pleroma.Factory.insert(:user)
  39           end)
  40
  41         token =
  42           Keyword.get_lazy(opts, :oauth_token, fn ->
  43             Pleroma.Factory.insert(:oauth_token, user: user, scopes: scopes)
  44           end)
  45
  46         conn =
  47           build_conn()
  48           |> assign(:user, user)
  49           |> assign(:token, token)
  50
  51         %{user: user, token: token, conn: conn}
  52       end
  53
  54       defp request_content_type(%{conn: conn}) do
  55         conn = put_req_header(conn, "content-type", "multipart/form-data")
  56         [conn: conn]
  57       end
  58
  59       defp json_response_and_validate_schema(
  60              %{
  61                private: %{
  62                  open_api_spex: %{operation_id: op_id, operation_lookup: lookup, spec: spec}
  63                }
  64              } = conn,
  65              status
  66            ) do
  67         content_type =
  68           conn
  69           |> Plug.Conn.get_resp_header("content-type")
  70           |> List.first()
  71           |> String.split(";")
  72           |> List.first()
  73
  74         status = Plug.Conn.Status.code(status)
  75
  76         unless lookup[op_id].responses[status] do
  77           err = "Response schema not found for #{status} #{conn.method} #{conn.request_path}"
  78           flunk(err)
  79         end
  80
  81         schema = lookup[op_id].responses[status].content[content_type].schema
  82         json = json_response(conn, status)
  83
  84         case OpenApiSpex.cast_value(json, schema, spec) do
  85           {:ok, _data} ->
  86             json
  87
  88           {:error, errors} ->
  89             errors =
  90               Enum.map(errors, fn error ->
  91                 message = OpenApiSpex.Cast.Error.message(error)
  92                 path = OpenApiSpex.Cast.Error.path_to_string(error)
  93                 "#{message} at #{path}"
  94               end)
  95
  96             flunk(
  97               "Response does not conform to schema of #{op_id} operation: #{
  98                 Enum.join(errors, "\n")
  99               }\n#{inspect(json)}"
 100             )
 101         end
 102       end
 103
 104       defp json_response_and_validate_schema(conn, _status) do
 105         flunk("Response schema not found for #{conn.method} #{conn.request_path} #{conn.status}")
 106       end
 107
 108       defp ensure_federating_or_authenticated(conn, url, user) do
 109         initial_setting = Config.get([:instance, :federating])
 110         on_exit(fn -> Config.put([:instance, :federating], initial_setting) end)
 111
 112         Config.put([:instance, :federating], false)
 113
 114         conn
 115         |> get(url)
 116         |> response(403)
 117
 118         conn
 119         |> assign(:user, user)
 120         |> get(url)
 121         |> response(200)
 122
 123         Config.put([:instance, :federating], true)
 124
 125         conn
 126         |> get(url)
 127         |> response(200)
 128       end
 129     end
 130   end
 131
 132   setup tags do
 133     Cachex.clear(:user_cache)
 134     Cachex.clear(:object_cache)
 135     :ok = Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)
 136
 137     unless tags[:async] do
 138       Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, {:shared, self()})
 139     end
 140
 141     if tags[:needs_streamer] do
 142       start_supervised(%{
 143         id: Pleroma.Web.Streamer.registry(),
 144         start:
 145           {Registry, :start_link, [[keys: :duplicate, name: Pleroma.Web.Streamer.registry()]]}
 146       })
 147     end
 148
 149     {:ok, conn: Phoenix.ConnTest.build_conn()}
 150   end
 151 end