Use `json_response_and_validate_schema/2` in tests to validate OpenAPI schema
[akkoma] / 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 #{conn.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(Pleroma.Web.Streamer.supervisor())
143 end
144
145 {:ok, conn: Phoenix.ConnTest.build_conn()}
146 end
147 end