No OneTemporary
Actions

Authored By

Unknown

Size

23 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/filter.ex b/lib/pleroma/filter.ex
	index 7cb49360f..4d61b3650 100644
	--- a/lib/pleroma/filter.ex
	+++ b/lib/pleroma/filter.ex
	@@ -1,99 +1,98 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Filter do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

	alias Pleroma.Repo
	alias Pleroma.User

	schema "filters" do
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	field(:filter_id, :integer)
	field(:hide, :boolean, default: false)
	field(:whole_word, :boolean, default: true)
	field(:phrase, :string)
	field(:context, {:array, :string})
	field(:expires_at, :utc_datetime)

	timestamps()
	end

	def get(id, %{id: user_id} = _user) do
	query =
	from(
	f in Pleroma.Filter,
	where: f.filter_id == ^id,
	where: f.user_id == ^user_id
	)

	Repo.one(query)
	end

	def get_filters(%User{id: user_id} = _user) do
	query =
	from(
	f in Pleroma.Filter,
	where: f.user_id == ^user_id,
	order_by: [desc: :id]
	)

	Repo.all(query)
	end

	def create(%Pleroma.Filter{user_id: user_id, filter_id: nil} = filter) do
	# If filter_id wasn't given, use the max filter_id for this user plus 1.
	# XXX This could result in a race condition if a user tries to add two
	# different filters for their account from two different clients at the
	# same time, but that should be unlikely.

	max_id_query =
	from(
	f in Pleroma.Filter,
	where: f.user_id == ^user_id,
	select: max(f.filter_id)
	)

	filter_id =
	case Repo.one(max_id_query) do
	# Start allocating from 1
	nil ->
	1

	max_id ->
	max_id + 1
	end

	filter
	\|> Map.put(:filter_id, filter_id)
	\|> Repo.insert()
	end

	def create(%Pleroma.Filter{} = filter) do
	Repo.insert(filter)
	end

	def delete(%Pleroma.Filter{id: filter_key} = filter) when is_number(filter_key) do
	Repo.delete(filter)
	end

	def delete(%Pleroma.Filter{id: filter_key} = filter) when is_nil(filter_key) do
	%Pleroma.Filter{id: id} = get(filter.filter_id, %{id: filter.user_id})

	filter
	\|> Map.put(:id, id)
	\|> Repo.delete()
	end

	- def update(%Pleroma.Filter{} = filter) do
	- destination = Map.from_struct(filter)
	-
	- Pleroma.Filter.get(filter.filter_id, %{id: filter.user_id})
	- \|> cast(destination, [:phrase, :context, :hide, :expires_at, :whole_word])
	+ def update(%Pleroma.Filter{} = filter, params) do
	+ filter
	+ \|> cast(params, [:phrase, :context, :hide, :expires_at, :whole_word])
	+ \|> validate_required([:phrase, :context])
	\|> Repo.update()
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/filter_operation.ex b/lib/pleroma/web/api_spec/operations/filter_operation.ex
	new file mode 100644
	index 000000000..53e57b46b
	--- /dev/null
	+++ b/lib/pleroma/web/api_spec/operations/filter_operation.ex
	@@ -0,0 +1,227 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ApiSpec.FilterOperation do
	+ alias OpenApiSpex.Operation
	+ alias OpenApiSpex.Schema
	+ alias Pleroma.Web.ApiSpec.Helpers
	+
	+ def open_api_operation(action) do
	+ operation = String.to_existing_atom("#{action}_operation")
	+ apply(__MODULE__, operation, [])
	+ end
	+
	+ def index_operation do
	+ %Operation{
	+ tags: ["apps"],
	+ summary: "View all filters",
	+ operationId: "FilterController.index",
	+ security: [%{"oAuth" => ["read:filters"]}],
	+ responses: %{
	+ 200 => Operation.response("Filters", "application/json", array_of_filters())
	+ }
	+ }
	+ end
	+
	+ def create_operation do
	+ %Operation{
	+ tags: ["apps"],
	+ summary: "Create a filter",
	+ operationId: "FilterController.create",
	+ requestBody: Helpers.request_body("Parameters", create_request(), required: true),
	+ security: [%{"oAuth" => ["write:filters"]}],
	+ responses: %{200 => Operation.response("Filter", "application/json", filter())}
	+ }
	+ end
	+
	+ def show_operation do
	+ %Operation{
	+ tags: ["apps"],
	+ summary: "View all filters",
	+ parameters: [id_param()],
	+ operationId: "FilterController.show",
	+ security: [%{"oAuth" => ["read:filters"]}],
	+ responses: %{
	+ 200 => Operation.response("Filter", "application/json", filter())
	+ }
	+ }
	+ end
	+
	+ def update_operation do
	+ %Operation{
	+ tags: ["apps"],
	+ summary: "Update a filter",
	+ parameters: [id_param()],
	+ operationId: "FilterController.update",
	+ requestBody: Helpers.request_body("Parameters", update_request(), required: true),
	+ security: [%{"oAuth" => ["write:filters"]}],
	+ responses: %{
	+ 200 => Operation.response("Filter", "application/json", filter())
	+ }
	+ }
	+ end
	+
	+ def delete_operation do
	+ %Operation{
	+ tags: ["apps"],
	+ summary: "Remove a filter",
	+ parameters: [id_param()],
	+ operationId: "FilterController.delete",
	+ security: [%{"oAuth" => ["write:filters"]}],
	+ responses: %{
	+ 200 =>
	+ Operation.response("Filter", "application/json", %Schema{
	+ type: :object,
	+ description: "Empty object"
	+ })
	+ }
	+ }
	+ end
	+
	+ defp id_param do
	+ Operation.parameter(:id, :path, :string, "Filter ID", example: "123", required: true)
	+ end
	+
	+ defp filter do
	+ %Schema{
	+ title: "Filter",
	+ type: :object,
	+ properties: %{
	+ id: %Schema{type: :string},
	+ phrase: %Schema{type: :string, description: "The text to be filtered"},
	+ context: %Schema{
	+ type: :array,
	+ items: %Schema{type: :string, enum: ["home", "notifications", "public", "thread"]},
	+ description: "The contexts in which the filter should be applied."
	+ },
	+ expires_at: %Schema{
	+ type: :string,
	+ format: :"date-time",
	+ description:
	+ "When the filter should no longer be applied. String (ISO 8601 Datetime), or null if the filter does not expire.",
	+ nullable: true
	+ },
	+ irreversible: %Schema{
	+ type: :boolean,
	+ description:
	+ "Should matching entities in home and notifications be dropped by the server?"
	+ },
	+ whole_word: %Schema{
	+ type: :boolean,
	+ description: "Should the filter consider word boundaries?"
	+ }
	+ },
	+ example: %{
	+ "id" => "5580",
	+ "phrase" => "@twitter.com",
	+ "context" => [
	+ "home",
	+ "notifications",
	+ "public",
	+ "thread"
	+ ],
	+ "whole_word" => false,
	+ "expires_at" => nil,
	+ "irreversible" => true
	+ }
	+ }
	+ end
	+
	+ defp array_of_filters do
	+ %Schema{
	+ title: "ArrayOfFilters",
	+ description: "Array of Filters",
	+ type: :array,
	+ items: filter(),
	+ example: [
	+ %{
	+ "id" => "5580",
	+ "phrase" => "@twitter.com",
	+ "context" => [
	+ "home",
	+ "notifications",
	+ "public",
	+ "thread"
	+ ],
	+ "whole_word" => false,
	+ "expires_at" => nil,
	+ "irreversible" => true
	+ },
	+ %{
	+ "id" => "6191",
	+ "phrase" => ":eurovision2019:",
	+ "context" => [
	+ "home"
	+ ],
	+ "whole_word" => true,
	+ "expires_at" => "2019-05-21T13:47:31.333Z",
	+ "irreversible" => false
	+ }
	+ ]
	+ }
	+ end
	+
	+ defp create_request do
	+ %Schema{
	+ title: "FilterCreateRequest",
	+ allOf: [
	+ update_request(),
	+ %Schema{
	+ type: :object,
	+ properties: %{
	+ irreversible: %Schema{
	+ type: :bolean,
	+ description:
	+ "Should the server irreversibly drop matching entities from home and notifications?",
	+ default: false
	+ }
	+ }
	+ }
	+ ],
	+ example: %{
	+ "phrase" => "knights",
	+ "context" => ["home"]
	+ }
	+ }
	+ end
	+
	+ defp update_request do
	+ %Schema{
	+ title: "FilterUpdateRequest",
	+ type: :object,
	+ properties: %{
	+ phrase: %Schema{type: :string, description: "The text to be filtered"},
	+ context: %Schema{
	+ type: :array,
	+ items: %Schema{type: :string, enum: ["home", "notifications", "public", "thread"]},
	+ description:
	+ "Array of enumerable strings `home`, `notifications`, `public`, `thread`. At least one context must be specified."
	+ },
	+ irreversible: %Schema{
	+ type: :bolean,
	+ description:
	+ "Should the server irreversibly drop matching entities from home and notifications?"
	+ },
	+ whole_word: %Schema{
	+ type: :bolean,
	+ description: "Consider word boundaries?",
	+ default: true
	+ }
	+ # TODO: probably should implement filter expiration
	+ # expires_in: %Schema{
	+ # type: :string,
	+ # format: :"date-time",
	+ # description:
	+ # "ISO 8601 Datetime for when the filter expires. Otherwise,
	+ # null for a filter that doesn't expire."
	+ # }
	+ },
	+ required: [:phrase, :context],
	+ example: %{
	+ "phrase" => "knights",
	+ "context" => ["home"]
	+ }
	+ }
	+ end
	+end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/filter_controller.ex b/lib/pleroma/web/mastodon_api/controllers/filter_controller.ex
	index 7fd0562c9..abbf0ce02 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/filter_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/filter_controller.ex
	@@ -1,82 +1,83 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.FilterController do
	use Pleroma.Web, :controller

	alias Pleroma.Filter
	alias Pleroma.Plugs.OAuthScopesPlug

	@oauth_read_actions [:show, :index]

	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(OAuthScopesPlug, %{scopes: ["read:filters"]} when action in @oauth_read_actions)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:filters"]} when action not in @oauth_read_actions
	)

	+ defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.FilterOperation
	+
	@doc "GET /api/v1/filters"
	def index(%{assigns: %{user: user}} = conn, _) do
	filters = Filter.get_filters(user)

	- render(conn, "filters.json", filters: filters)
	+ render(conn, "index.json", filters: filters)
	end

	@doc "POST /api/v1/filters"
	- def create(
	- %{assigns: %{user: user}} = conn,
	- %{"phrase" => phrase, "context" => context} = params
	- ) do
	+ def create(%{assigns: %{user: user}, body_params: params} = conn, _) do
	query = %Filter{
	user_id: user.id,
	- phrase: phrase,
	- context: context,
	- hide: Map.get(params, "irreversible", false),
	- whole_word: Map.get(params, "boolean", true)
	- # expires_at
	+ phrase: params.phrase,
	+ context: params.context,
	+ hide: params.irreversible,
	+ whole_word: params.whole_word
	+ # TODO: support `expires_in` parameter (as in Mastodon API)
	}

	{:ok, response} = Filter.create(query)

	- render(conn, "filter.json", filter: response)
	+ render(conn, "show.json", filter: response)
	end

	@doc "GET /api/v1/filters/:id"
	- def show(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
	+ def show(%{assigns: %{user: user}} = conn, %{id: filter_id}) do
	filter = Filter.get(filter_id, user)

	- render(conn, "filter.json", filter: filter)
	+ render(conn, "show.json", filter: filter)
	end

	@doc "PUT /api/v1/filters/:id"
	def update(
	- %{assigns: %{user: user}} = conn,
	- %{"phrase" => phrase, "context" => context, "id" => filter_id} = params
	+ %{assigns: %{user: user}, body_params: params} = conn,
	+ %{id: filter_id}
	) do
	- query = %Filter{
	- user_id: user.id,
	- filter_id: filter_id,
	- phrase: phrase,
	- context: context,
	- hide: Map.get(params, "irreversible", nil),
	- whole_word: Map.get(params, "boolean", true)
	- # expires_at
	- }
	-
	- {:ok, response} = Filter.update(query)
	- render(conn, "filter.json", filter: response)
	+ params =
	+ params
	+ \|> Map.delete(:irreversible)
	+ \|> Map.put(:hide, params[:irreversible])
	+ \|> Enum.reject(fn {_key, value} -> is_nil(value) end)
	+ \|> Map.new()
	+
	+ # TODO: support `expires_in` parameter (as in Mastodon API)
	+
	+ with %Filter{} = filter <- Filter.get(filter_id, user),
	+ {:ok, %Filter{} = filter} <- Filter.update(filter, params) do
	+ render(conn, "show.json", filter: filter)
	+ end
	end

	@doc "DELETE /api/v1/filters/:id"
	- def delete(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
	+ def delete(%{assigns: %{user: user}} = conn, %{id: filter_id}) do
	query = %Filter{
	user_id: user.id,
	filter_id: filter_id
	}

	{:ok, _} = Filter.delete(query)
	json(conn, %{})
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/filter_view.ex b/lib/pleroma/web/mastodon_api/views/filter_view.ex
	index 97fd1e83f..aeff646f5 100644
	--- a/lib/pleroma/web/mastodon_api/views/filter_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/filter_view.ex
	@@ -1,31 +1,31 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.FilterView do
	use Pleroma.Web, :view
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.FilterView

	- def render("filters.json", %{filters: filters} = opts) do
	- render_many(filters, FilterView, "filter.json", opts)
	+ def render("index.json", %{filters: filters}) do
	+ render_many(filters, FilterView, "show.json")
	end

	- def render("filter.json", %{filter: filter}) do
	+ def render("show.json", %{filter: filter}) do
	expires_at =
	if filter.expires_at do
	Utils.to_masto_date(filter.expires_at)
	else
	nil
	end

	%{
	id: to_string(filter.filter_id),
	phrase: filter.phrase,
	context: filter.context,
	expires_at: expires_at,
	irreversible: filter.hide,
	whole_word: false
	}
	end
	end
	diff --git a/test/filter_test.exs b/test/filter_test.exs
	index b2a8330ee..63a30c736 100644
	--- a/test/filter_test.exs
	+++ b/test/filter_test.exs
	@@ -1,157 +1,155 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.FilterTest do
	alias Pleroma.Repo
	use Pleroma.DataCase

	import Pleroma.Factory

	describe "creating filters" do
	test "creating one filter" do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 42,
	phrase: "knights",
	context: ["home"]
	}

	{:ok, %Pleroma.Filter{} = filter} = Pleroma.Filter.create(query)
	result = Pleroma.Filter.get(filter.filter_id, user)
	assert query.phrase == result.phrase
	end

	test "creating one filter without a pre-defined filter_id" do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	phrase: "knights",
	context: ["home"]
	}

	{:ok, %Pleroma.Filter{} = filter} = Pleroma.Filter.create(query)
	# Should start at 1
	assert filter.filter_id == 1
	end

	test "creating additional filters uses previous highest filter_id + 1" do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 42,
	phrase: "knights",
	context: ["home"]
	}

	{:ok, %Pleroma.Filter{} = filter_one} = Pleroma.Filter.create(query_one)

	query_two = %Pleroma.Filter{
	user_id: user.id,
	# No filter_id
	phrase: "who",
	context: ["home"]
	}

	{:ok, %Pleroma.Filter{} = filter_two} = Pleroma.Filter.create(query_two)
	assert filter_two.filter_id == filter_one.filter_id + 1
	end

	test "filter_id is unique per user" do
	user_one = insert(:user)
	user_two = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user_one.id,
	phrase: "knights",
	context: ["home"]
	}

	{:ok, %Pleroma.Filter{} = filter_one} = Pleroma.Filter.create(query_one)

	query_two = %Pleroma.Filter{
	user_id: user_two.id,
	phrase: "who",
	context: ["home"]
	}

	{:ok, %Pleroma.Filter{} = filter_two} = Pleroma.Filter.create(query_two)

	assert filter_one.filter_id == 1
	assert filter_two.filter_id == 1

	result_one = Pleroma.Filter.get(filter_one.filter_id, user_one)
	assert result_one.phrase == filter_one.phrase

	result_two = Pleroma.Filter.get(filter_two.filter_id, user_two)
	assert result_two.phrase == filter_two.phrase
	end
	end

	test "deleting a filter" do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 0,
	phrase: "knights",
	context: ["home"]
	}

	{:ok, _filter} = Pleroma.Filter.create(query)
	{:ok, filter} = Pleroma.Filter.delete(query)
	assert is_nil(Repo.get(Pleroma.Filter, filter.filter_id))
	end

	test "getting all filters by an user" do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	query_two = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "who",
	context: ["home"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.create(query_two)
	filters = Pleroma.Filter.get_filters(user)
	assert filter_one in filters
	assert filter_two in filters
	end

	test "updating a filter" do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	- query_two = %Pleroma.Filter{
	- user_id: user.id,
	- filter_id: 1,
	+ changes = %{
	phrase: "who",
	context: ["home", "timeline"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	- {:ok, filter_two} = Pleroma.Filter.update(query_two)
	+ {:ok, filter_two} = Pleroma.Filter.update(filter_one, changes)
	assert filter_one != filter_two
	- assert filter_two.phrase == query_two.phrase
	- assert filter_two.context == query_two.context
	+ assert filter_two.phrase == changes.phrase
	+ assert filter_two.context == changes.context
	end
	end
	diff --git a/test/web/mastodon_api/controllers/filter_controller_test.exs b/test/web/mastodon_api/controllers/filter_controller_test.exs
	index 97ab005e0..f29547d13 100644
	--- a/test/web/mastodon_api/controllers/filter_controller_test.exs
	+++ b/test/web/mastodon_api/controllers/filter_controller_test.exs
	@@ -1,123 +1,129 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Web.MastodonAPI.FilterView

	test "creating a filter" do
	%{conn: conn} = oauth_access(["write:filters"])

	filter = %Pleroma.Filter{
	phrase: "knights",
	context: ["home"]
	}

	- conn = post(conn, "/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

	- assert response = json_response(conn, 200)
	+ assert response = json_response_and_validate_schema(conn, 200)
	assert response["phrase"] == filter.phrase
	assert response["context"] == filter.context
	assert response["irreversible"] == false
	assert response["id"] != nil
	assert response["id"] != ""
	end

	test "fetching a list of filters" do
	%{user: user, conn: conn} = oauth_access(["read:filters"])

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	query_two = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "who",
	context: ["home"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.create(query_two)

	response =
	conn
	\|> get("/api/v1/filters")
	- \|> json_response(200)
	+ \|> json_response_and_validate_schema(200)

	assert response ==
	render_json(
	FilterView,
	- "filters.json",
	+ "index.json",
	filters: [filter_two, filter_one]
	)
	end

	test "get a filter" do
	%{user: user, conn: conn} = oauth_access(["read:filters"])

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn = get(conn, "/api/v1/filters/#{filter.filter_id}")

	- assert _response = json_response(conn, 200)
	+ assert response = json_response_and_validate_schema(conn, 200)
	end

	test "update a filter" do
	%{user: user, conn: conn} = oauth_access(["write:filters"])

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	- context: ["home"]
	+ context: ["home"],
	+ hide: true
	}

	{:ok, _filter} = Pleroma.Filter.create(query)

	new = %Pleroma.Filter{
	phrase: "nii",
	context: ["home"]
	}

	conn =
	- put(conn, "/api/v1/filters/#{query.filter_id}", %{
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> put("/api/v1/filters/#{query.filter_id}", %{
	phrase: new.phrase,
	context: new.context
	})

	- assert response = json_response(conn, 200)
	+ assert response = json_response_and_validate_schema(conn, 200)
	assert response["phrase"] == new.phrase
	assert response["context"] == new.context
	+ assert response["irreversible"] == true
	end

	test "delete a filter" do
	%{user: user, conn: conn} = oauth_access(["write:filters"])

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn = delete(conn, "/api/v1/filters/#{filter.filter_id}")

	- assert response = json_response(conn, 200)
	- assert response == %{}
	+ assert json_response_and_validate_schema(conn, 200) == %{}
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 2:27 PM (17 h, 8 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1801504
Default Alt Text: (23 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions