<.video_embed_tab :for={tab <- @tabs} tab={tab} change_event={@change_event} />
diff --git a/lib/mave_core_web/controllers/api/image/image_controller.ex b/lib/mave_core_web/controllers/api/image/image_controller.ex
index 75365e6..027d898 100644
--- a/lib/mave_core_web/controllers/api/image/image_controller.ex
+++ b/lib/mave_core_web/controllers/api/image/image_controller.ex
@@ -49,14 +49,42 @@ defmodule MaveCoreWeb.Api.ImageController do
end
defp serve_image(conn, space_hash, embed_hash, format) do
- with {:ok, time} <- parse_time(conn.query_params["time"]),
+ with {:ok, conn} <- authorize_image(conn, space_hash, embed_hash),
+ {:ok, time} <- parse_time(conn.query_params["time"]),
{:ok, dimensions} <- parse_dimensions(conn.query_params) do
opts = [{:format, format} | dimensions]
ImageProcessor.process(space_hash, embed_hash, time, opts)
|> respond_to_image_result(conn, format)
else
- :error -> send_resp(conn, 400, "Invalid image parameters")
+ {:error, :unauthorized} ->
+ conn
+ |> put_resp_header("cache-control", "private, no-store")
+ |> send_resp(401, "Authorization required")
+
+ :error ->
+ send_resp(conn, 400, "Invalid image parameters")
+ end
+ end
+
+ defp authorize_image(conn, space_hash, embed_hash) do
+ case MaveCore.Embeds.get_embed_by_hashes(space_hash, embed_hash) do
+ %MaveCore.Embeds.Embed{} = embed ->
+ if MaveCore.Playback.protected?(embed) do
+ authorize_private_image(conn, embed)
+ else
+ {:ok, conn}
+ end
+
+ _ ->
+ {:ok, conn}
+ end
+ end
+
+ defp authorize_private_image(conn, embed) do
+ case MaveCore.Playback.authorize(conn.query_params["token"], embed) do
+ {:ok, _expires_at} -> {:ok, put_private(conn, :protected_playback, true)}
+ _ -> {:error, :unauthorized}
end
end
@@ -93,7 +121,13 @@ defmodule MaveCoreWeb.Api.ImageController do
defp respond_to_image_result({:ok, _path, image_data}, conn, format) do
conn
|> put_resp_header("x-content-type-options", "nosniff")
- |> put_resp_header("cache-control", "public, max-age=604800, immutable")
+ |> put_resp_header(
+ "cache-control",
+ if(conn.private[:protected_playback],
+ do: "private, no-store",
+ else: "public, max-age=604800, immutable"
+ )
+ )
|> send_download(
{:binary, image_data},
filename: "image.#{format}",
diff --git a/lib/mave_core_web/controllers/api/legacy_embed_controller.ex b/lib/mave_core_web/controllers/api/legacy_embed_controller.ex
index ea8eb25..f19a228 100644
--- a/lib/mave_core_web/controllers/api/legacy_embed_controller.ex
+++ b/lib/mave_core_web/controllers/api/legacy_embed_controller.ex
@@ -16,6 +16,7 @@ defmodule MaveCoreWeb.Api.LegacyEmbedController do
with {:ok, %{space_hash: space_hash, embed_hash: embed_hash}} <-
EmbedId.split(String.trim(embed_id || "")),
%Embed{type: :video} = embed <- Embeds.get_embed_by_hashes(space_hash, embed_hash),
+ false <- MaveCore.Playback.protected?(embed),
{:ok, manifest} <- ManifestPublisher.current(embed) do
json(conn, manifest)
else
diff --git a/lib/mave_core_web/controllers/api/playback_controller.ex b/lib/mave_core_web/controllers/api/playback_controller.ex
new file mode 100644
index 0000000..00869ad
--- /dev/null
+++ b/lib/mave_core_web/controllers/api/playback_controller.ex
@@ -0,0 +1,73 @@
+defmodule MaveCoreWeb.Api.PlaybackController do
+ use MaveCoreWeb, :controller
+
+ alias MaveCore.Embeds.Embed
+ alias MaveCore.Playback
+ alias MaveCore.Playback.Media
+ alias MaveCoreWeb.Api.ImageController
+
+ def show(conn, %{"id" => id, "path" => path} = params) do
+ conn = private_response(conn)
+ token = params["token"] || bearer(conn)
+
+ with %Embed{} = embed <- Playback.get_embed(id),
+ {:ok, expires_at} <- Playback.authorize(token, embed),
+ true <- not Playback.protected?(embed) or Playback.available?(embed.space) do
+ base = String.replace_suffix(conn.request_path, "/" <> Enum.join(path, "/"), "")
+
+ base =
+ URI.to_string(%URI{
+ scheme: Atom.to_string(conn.scheme),
+ host: conn.host,
+ port: conn.port,
+ path: base
+ })
+
+ if Enum.join(path, "/") in ["dynamic.jpg", "dynamic.jpeg", "dynamic.webp", "dynamic.avif"] do
+ ext = path |> List.first() |> Path.extname()
+
+ ImageController.show(
+ %{conn | query_params: Map.put(conn.query_params, "token", token)},
+ %{"mave_id" => embed.space.hash <> embed.hash <> ext}
+ )
+ else
+ respond_media(conn, Media.response(embed, Enum.join(path, "/"), base, token, expires_at))
+ end
+ else
+ _ -> send_resp(conn, 401, "Playback authorization required")
+ end
+ end
+
+ defp respond_media(conn, result) do
+ case result do
+ {:ok, "application/json", body} ->
+ conn |> put_resp_content_type("application/json") |> send_resp(200, body)
+
+ {:ok, "application/vnd.apple.mpegurl", body} ->
+ conn |> put_resp_content_type("application/vnd.apple.mpegurl") |> send_resp(200, body)
+
+ {:ok, "text/vtt", body} ->
+ conn |> put_resp_content_type("text/vtt") |> send_resp(200, body)
+
+ {:redirect, url} ->
+ redirect(conn, external: url)
+
+ {:error, _reason} ->
+ send_resp(conn, 404, "Media unavailable")
+ end
+ end
+
+ defp bearer(conn) do
+ case get_req_header(conn, "authorization") do
+ ["Bearer " <> token] -> token
+ _ -> ""
+ end
+ end
+
+ defp private_response(conn) do
+ conn
+ |> put_resp_header("cache-control", "private, no-store")
+ |> put_resp_header("referrer-policy", "no-referrer")
+ |> put_resp_header("x-content-type-options", "nosniff")
+ end
+end
diff --git a/lib/mave_core_web/controllers/api/videos_controller.ex b/lib/mave_core_web/controllers/api/videos_controller.ex
index f98dc8d..e06db8e 100644
--- a/lib/mave_core_web/controllers/api/videos_controller.ex
+++ b/lib/mave_core_web/controllers/api/videos_controller.ex
@@ -1,7 +1,7 @@
defmodule MaveCoreWeb.Api.VideosController do
use MaveCoreWeb, :controller
- plug MaveCoreWeb.Plugs.ApiKeyWriteAuth when action in [:create, :update, :delete]
+ plug(MaveCoreWeb.Plugs.ApiKeyWriteAuth when action in [:create, :update, :delete])
alias MaveCore.Embeds
alias MaveCore.PublicApi
@@ -41,7 +41,9 @@ defmodule MaveCoreWeb.Api.VideosController do
def show(%{assigns: %{current_space: %Space{} = space}} = conn, %{"hash" => hash}) do
case PublicApi.get_embed(space, hash) do
%Embeds.Embed{type: :video} = embed ->
- json(conn, PublicApi.video_response(space, embed))
+ conn
+ |> put_visibility_response_status(embed)
+ |> json(PublicApi.video_response(space, embed))
nil ->
conn |> put_status(:not_found) |> json(%{error: "This video embed does not exist."})
@@ -70,10 +72,13 @@ defmodule MaveCoreWeb.Api.VideosController do
def create(%{assigns: %{current_space: %Space{} = space}} = conn, params) do
with {:ok, parent_folder_id} <- resolve_parent_folder_id(space, params),
+ :ok <-
+ MaveCore.Playback.validate_visibility(space, Map.get(params, "visibility", "public")),
:ok <- maybe_validate_input_url(params),
{:ok, embed} <-
Embeds.create_video_embed(space, %{
name: blank_to_nil(params["name"]),
+ visibility: Map.get(params, "visibility", "public"),
parent_folder_id: parent_folder_id
}),
:ok <- maybe_start_input_url_upload(space, embed, params) do
@@ -91,10 +96,19 @@ defmodule MaveCoreWeb.Api.VideosController do
def update(%{assigns: %{current_space: %Space{} = space}} = conn, %{"hash" => hash} = params) do
case PublicApi.get_embed(space, hash) do
%Embeds.Embed{type: :video} = embed ->
- with {:ok, embed} <- maybe_rename(embed, params),
- {:ok, embed} <- maybe_move(space, embed, params) do
+ with :ok <-
+ MaveCore.Playback.validate_visibility(
+ space,
+ Map.get(params, "visibility", "public")
+ ),
+ {:ok, embed} <- maybe_rename(embed, params),
+ {:ok, embed} <- maybe_move(space, embed, params),
+ {:ok, embed} <- maybe_playback_visibility(embed, params) do
embed = PublicApi.get_embed(space, hash) || embed
- json(conn, PublicApi.video_response(space, embed))
+
+ conn
+ |> maybe_put_visibility_response_status(params, embed)
+ |> json(PublicApi.video_response(space, embed))
else
{:error, error} ->
conn |> put_status(:bad_request) |> json(%{error: format_error(error)})
@@ -132,6 +146,26 @@ defmodule MaveCoreWeb.Api.VideosController do
defp serialize_embed(space, %Embeds.Embed{} = embed), do: PublicApi.video_response(space, embed)
+ defp maybe_put_visibility_response_status(conn, %{"visibility" => _}, embed),
+ do: put_visibility_response_status(conn, embed)
+
+ defp maybe_put_visibility_response_status(conn, _params, _embed), do: conn
+
+ defp put_visibility_response_status(conn, %{playback_status: status})
+ when status in [:protecting, :publishing],
+ do: put_status(conn, :accepted)
+
+ defp put_visibility_response_status(conn, _embed), do: conn
+
+ defp maybe_playback_visibility(embed, %{"visibility" => "private"}),
+ do: MaveCore.Playback.request_visibility(embed, :private)
+
+ defp maybe_playback_visibility(embed, %{"visibility" => "public"}),
+ do: MaveCore.Playback.request_visibility(embed, :public)
+
+ defp maybe_playback_visibility(_embed, %{"visibility" => _}), do: {:error, :invalid_visibility}
+ defp maybe_playback_visibility(embed, _params), do: {:ok, embed}
+
defp resolve_collection(params, space),
do: PublicApi.resolve_collection_id(space, params["collection"])
@@ -203,6 +237,8 @@ defmodule MaveCoreWeb.Api.VideosController do
do: "This collection does not seem to be part of your space."
defp format_error(:not_found), do: "This video embed does not exist."
+ defp format_error(:invalid_visibility), do: "visibility must be public or private."
+ defp format_error(:playback_unavailable), do: "Private playback is unavailable for this space."
defp format_error(:embed_limit_reached), do: "This space has reached its video limit."
defp format_error(error) when is_binary(error), do: error
defp format_error(_error), do: "Could not update this video."
diff --git a/lib/mave_core_web/endpoint.ex b/lib/mave_core_web/endpoint.ex
index bc97ed8..fcb7f52 100644
--- a/lib/mave_core_web/endpoint.ex
+++ b/lib/mave_core_web/endpoint.ex
@@ -58,6 +58,7 @@ defmodule MaveCoreWeb.Endpoint do
plug Plug.MethodOverride
plug Plug.Head
+ plug MaveCoreWeb.Plugs.PlaybackHost
plug Plug.Session, @session_options
plug MaveCoreWeb.Router
diff --git a/lib/mave_core_web/live/dashboard/videos/show.ex b/lib/mave_core_web/live/dashboard/videos/show.ex
index 7d72005..1f9795f 100644
--- a/lib/mave_core_web/live/dashboard/videos/show.ex
+++ b/lib/mave_core_web/live/dashboard/videos/show.ex
@@ -9,6 +9,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
alias MaveCore.Embeds.Events, as: EmbedEvents
alias MaveCore.Embeds.SettingsSerializer
alias MaveCore.Flow.Diagnostics
+ alias MaveCore.Playback.EmbedCode
alias MaveCore.Spaces
alias MaveCore.Uploads.Token
alias MaveCore.UsageLimits
@@ -441,6 +442,38 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
end
@impl true
+ def handle_event(
+ "playback_session",
+ _params,
+ %{assigns: %{resource_embed: %Embed{} = embed}} = socket
+ ) do
+ session =
+ if MaveCore.Playback.protected?(embed),
+ do: MaveCore.Playback.dashboard_session(embed),
+ else: nil
+
+ {:reply, %{session: session, embed: socket.assigns.current_space.hash <> embed.hash}, socket}
+ end
+
+ def handle_event(
+ "toggle_playback_visibility",
+ _params,
+ %{assigns: %{resource_embed: %Embed{} = embed}} = socket
+ ) do
+ visibility = if embed.playback_visibility == :private, do: :public, else: :private
+
+ case MaveCore.Playback.request_visibility(embed, visibility) do
+ {:ok, updated} ->
+ {:noreply,
+ socket
+ |> assign(:resource_embed, updated)
+ |> put_flash(:info, gettext("Playback access is being updated."))}
+
+ {:error, _reason} ->
+ {:noreply, put_flash(socket, :error, gettext("Playback access could not be updated."))}
+ end
+ end
+
def handle_event("change_code_preview", %{"preview" => preview}, socket) do
{:noreply, assign(socket, :code_preview, String.to_existing_atom(preview))}
end
@@ -1527,9 +1560,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
}
end
- defp line_numbers(type, video) do
+ defp line_numbers(type, video, embed) do
type
- |> snippet_string(video)
+ |> snippet_string(video, embed)
|> String.split("\n")
|> Enum.with_index(1)
|> Enum.map(&elem(&1, 1))
@@ -1555,7 +1588,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
end)
end
- defp code_tabs(current, video) do
+ defp code_tabs(current, video, embed) do
+ current = effective_code_preview(current, embed)
+
[
%{name: :script, label: "Player", current: current == :script},
%{name: :clip, label: "Clip", current: current == :clip},
@@ -1563,7 +1598,36 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
%{name: :react, label: "React", current: current == :react},
%{name: :vue, label: "Vue", current: current == :vue}
]
- |> Enum.reject(&(dashboard_player_tag(video) == "mave-audio" and &1.name == :clip))
+ |> Enum.reject(fn tab ->
+ (dashboard_player_tag(video) == "mave-audio" and tab.name == :clip) or
+ (MaveCore.Playback.protected?(embed) and tab.name == :iframe)
+ end)
+ end
+
+ defp effective_code_preview(:iframe, embed) do
+ if MaveCore.Playback.protected?(embed), do: :script, else: :iframe
+ end
+
+ defp effective_code_preview(type, _embed), do: type
+
+ defp snippet_string(type, video, embed) do
+ type = effective_code_preview(type, embed)
+
+ if MaveCore.Playback.protected?(embed) do
+ # Public thumbnail URLs are not suitable as private embed backgrounds.
+ video = video |> Map.put(:snippet_player_poster, nil) |> Map.put(:snippet_clip_poster, nil)
+
+ tag =
+ case type do
+ :clip -> "mave-clip"
+ framework when framework in [:react, :vue] -> framework_player_name(video)
+ _ -> dashboard_player_tag(video)
+ end
+
+ EmbedCode.add_token(snippet_string(type, video), type, video.public_id, tag)
+ else
+ snippet_string(type, video)
+ end
end
defp snippet_string(:script, video) do
diff --git a/lib/mave_core_web/live/dashboard/videos/show.html.heex b/lib/mave_core_web/live/dashboard/videos/show.html.heex
index 4e991e4..b82a58f 100644
--- a/lib/mave_core_web/live/dashboard/videos/show.html.heex
+++ b/lib/mave_core_web/live/dashboard/videos/show.html.heex
@@ -207,6 +207,9 @@
<% else %>
{@video.public_id}
- <.dropdown_button id="video-actions">
+ <.dropdown_button id="video-actions" menu_class="w-40">
+ <:item
+ :if={MaveCore.Playback.available?(@current_space)}
+ id="video-playback-visibility"
+ icon={if @resource_embed.playback_visibility == :private, do: "hero-lock-open", else: "hero-lock-closed"}
+ phx-click="toggle_playback_visibility"
+ disabled={@resource_embed.playback_status in [:protecting, :publishing]}
+ >
+ {cond do
+ @resource_embed.playback_status in [:protecting, :publishing] -> gettext("updating access…")
+ @resource_embed.playback_visibility == :private -> gettext("public")
+ true -> gettext("private (token)")
+ end}
+
<:item :if={@video_ready or @replace_mode} icon="replace" phx-click={if @replace_mode, do: "cancel_replace", else: "replace"}>
{if @replace_mode, do: gettext("cancel replace"), else: gettext("replace")}
@@ -246,10 +262,13 @@
<.video_embed_panel
player_dom_id={@player_dom_id}
audio_only={match?(%{original: %{audio_only: true}}, @video) and !@replace_mode}
- tabs={code_tabs(@code_preview, @video)}
- snippet={snippet_string(@code_preview, @video)}
- line_numbers={line_numbers(@code_preview, @video)}
+ tabs={code_tabs(@code_preview, @video, @resource_embed)}
+ snippet={snippet_string(@code_preview, @video, @resource_embed)}
+ line_numbers={line_numbers(@code_preview, @video, @resource_embed)}
>
+ <:guidance>
+
+
<:player>
<%= if @replace_mode do %>
<.video_upload_panel token={@upload_token} dom_id="video-upload-bridge-detail" />
diff --git a/lib/mave_core_web/plugs/playback_host.ex b/lib/mave_core_web/plugs/playback_host.ex
new file mode 100644
index 0000000..0778481
--- /dev/null
+++ b/lib/mave_core_web/plugs/playback_host.ex
@@ -0,0 +1,41 @@
+defmodule MaveCoreWeb.Plugs.PlaybackHost do
+ @moduledoc "Routes a configured media hostname without exposing dashboard or management routes."
+ @behaviour Plug
+
+ import Plug.Conn
+
+ alias MaveCore.Playback.URLs
+ alias MaveCoreWeb.Api.PlaybackController
+ alias MaveCoreWeb.Plugs.CORS
+
+ def init(opts), do: opts
+
+ def call(conn, _opts) do
+ if URLs.playback_host?(conn.host), do: serve(conn), else: conn
+ end
+
+ defp serve(conn) do
+ conn = CORS.call(conn, [])
+
+ if conn.halted do
+ conn
+ else
+ dispatch(conn) |> halt()
+ end
+ end
+
+ defp dispatch(%{method: method, path_info: [hash | path]} = conn)
+ when method in ["GET", "HEAD"] and path != [] do
+ with {:ok, space_hash} <- URLs.space_hash(conn.host),
+ true <- Regex.match?(~r/\A[A-Za-z0-9]{10}\z/, hash) do
+ conn = fetch_query_params(conn)
+ # URL identity comes only from the configured host and path, never query parameters.
+ params = Map.merge(conn.query_params, %{"id" => space_hash <> hash, "path" => path})
+ PlaybackController.show(conn, params)
+ else
+ _ -> send_resp(conn, 404, "Not found")
+ end
+ end
+
+ defp dispatch(conn), do: send_resp(conn, 404, "Not found")
+end
diff --git a/lib/mave_core_web/router.ex b/lib/mave_core_web/router.ex
index 612cd63..0487296 100644
--- a/lib/mave_core_web/router.ex
+++ b/lib/mave_core_web/router.ex
@@ -81,6 +81,18 @@ defmodule MaveCoreWeb.Router do
plug MaveCoreWeb.Plugs.RequireHost, env_var: "MAVE_IMAGE_HOST"
end
+ scope "/api/v1", MaveCoreWeb do
+ pipe_through [:public_cors]
+ get "/playback/media/:id/*path", Api.PlaybackController, :show, log: false
+ options "/playback/media/:id/*path", Api.PlaybackController, :show, log: false
+ end
+
+ scope "/v1", MaveCoreWeb do
+ pipe_through [:api_host, :public_cors]
+ get "/playback/media/:id/*path", Api.PlaybackController, :show, log: false
+ options "/playback/media/:id/*path", Api.PlaybackController, :show, log: false
+ end
+
scope "/", MaveCoreWeb do
pipe_through :browser
diff --git a/mix.lock b/mix.lock
index 5dc44a4..779a6bb 100644
--- a/mix.lock
+++ b/mix.lock
@@ -8,7 +8,7 @@
"cors_plug": {:hex, :cors_plug, "3.0.3", "7c3ac52b39624bc616db2e937c282f3f623f25f8d550068b6710e58d04a0e330", [:mix], [{:plug, "~> 1.13", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "3f2d759e8c272ed3835fab2ef11b46bddab8c1ab9528167bd463b6452edf830d"},
"credo": {:hex, :credo, "1.7.18", "5c5596bf7aedf9c8c227f13272ac499fe8eae6237bd326f2f07dfc173786f042", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "a189d164685fd945809e862fe76a7420c4398fa288d76257662aecb909d6b3e5"},
"db_connection": {:hex, :db_connection, "2.10.2", "ae391e803a5adff104da913c2fc1c0c14a37f8b10001dcef568796e1fb7bf95c", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "510b14482330f1af6490a2fa0efd8d4f1435d1529b165647df22ac0f2df0fa93"},
- "decimal": {:hex, :decimal, "3.1.1", "430d87b04011ce6cbd4fd205be758311a81f87d552d40904abd00f015935b1d0", [:mix], [], "hexpm", "c5f25f2ced74a0587d03e6023f595db8e924c9d3922c8c8ffd9edfc4498cf1f6"},
+ "decimal": {:hex, :decimal, "3.1.2", "5111bb7f15ceb8412ad408f908025e7a5ec3080b9978612a647ac82430306726", [:mix], [], "hexpm", "6aaf9d352d1c80fd3983b82af666f7ea2f3fe225ae202c89055ca38f3582ba5b"},
"dns_cluster": {:hex, :dns_cluster, "0.2.0", "aa8eb46e3bd0326bd67b84790c561733b25c5ba2fe3c7e36f28e88f384ebcb33", [:mix], [], "hexpm", "ba6f1893411c69c01b9e8e8f772062535a4cf70f3f35bcc964a324078d8c8240"},
"ecto": {:hex, :ecto, "3.13.6", "352135b474f91d1ab99a1b502171d207e9db60421c9e3d0ecab4c7ab96b24d14", [:mix], [{:decimal, "~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "8afa059bc16cd2c94739ec0a11e3e5df69d828125119109bef35f20a21a76af2"},
"ecto_ch": {:hex, :ecto_ch, "0.10.0", "ccfad102d866eba426c71d202a73c6c138cfeefa6eb6964c7c186acdd6306aad", [:mix], [{:ch, "~> 0.8.2", [hex: :ch, repo: "hexpm", optional: false]}, {:ecto_sql, "~> 3.13.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}], "hexpm", "3d876ceb0d18808bee68d4fcd764faac0591de2987f6f8057a09eb869ee2cf17"},
diff --git a/priv/repo/migrations/20261009095534_add_embed_playback_visibility.exs b/priv/repo/migrations/20261009095534_add_embed_playback_visibility.exs
new file mode 100644
index 0000000..4733bc3
--- /dev/null
+++ b/priv/repo/migrations/20261009095534_add_embed_playback_visibility.exs
@@ -0,0 +1,22 @@
+defmodule MaveCore.Repo.Migrations.AddEmbedPlaybackVisibility do
+ use Ecto.Migration
+
+ def change do
+ alter table(:embeds) do
+ add(:playback_visibility, :string, null: false, default: "public")
+ add(:playback_status, :string, null: false, default: "public")
+ end
+
+ create(
+ constraint(:embeds, :embeds_playback_visibility_check,
+ check: "playback_visibility IN ('public', 'private')"
+ )
+ )
+
+ create(
+ constraint(:embeds, :embeds_playback_status_check,
+ check: "playback_status IN ('public', 'protecting', 'private', 'publishing')"
+ )
+ )
+ end
+end
diff --git a/storybook/dashboard/buttons/dropdown_button.story.exs b/storybook/dashboard/buttons/dropdown_button.story.exs
index 5695cd4..001d74d 100644
--- a/storybook/dashboard/buttons/dropdown_button.story.exs
+++ b/storybook/dashboard/buttons/dropdown_button.story.exs
@@ -6,15 +6,33 @@ defmodule Storybook.Dashboard.Buttons.DropdownButton do
def variations do
[
%Variation{
- id: :default,
- description: "Dropdown with render, replace, and delete actions",
+ id: :public_video,
+ description: "Public video actions",
attributes: %{
- id: "dropdown-default"
+ id: "dropdown-public-video",
+ menu_class: "w-40"
},
slots: [
"""
- <:item icon="render">(re)render
+ <:item icon="hero-lock-closed">private (token)
<:item icon="replace">replace
+ <:item icon="archive">archive
+ <:item icon="delete" danger>delete
+ """
+ ]
+ },
+ %Variation{
+ id: :private_video,
+ description: "Private video actions",
+ attributes: %{
+ id: "dropdown-private-video",
+ menu_class: "w-40"
+ },
+ slots: [
+ """
+ <:item icon="hero-lock-open">public
+ <:item icon="replace">replace
+ <:item icon="archive">archive
<:item icon="delete" danger>delete
"""
]
diff --git a/test/mave_core/embeds_test.exs b/test/mave_core/embeds_test.exs
index 5cee6e3..94d3144 100644
--- a/test/mave_core/embeds_test.exs
+++ b/test/mave_core/embeds_test.exs
@@ -1969,19 +1969,19 @@ defmodule MaveCore.EmbedsTest do
Application.delete_env(:mave_core, :components_src)
Application.delete_env(:mave_core, :components_base_url)
- Application.put_env(:mave_core, :domain, "https://dash.staging.mave.io/")
+ Application.put_env(:mave_core, :domain, "https://dashboard.example.test/")
Application.put_env(:mave_core, :upload,
- endpoint: "https://upload.staging.mave.io/files",
- source_base_url: "https://s3.fr-par.scw.cloud",
+ endpoint: "https://upload.example.test/files",
+ source_base_url: "https://storage.example.test",
source_region: "fr-par",
hook_secret: "secret",
default_template: "publish_default"
)
- Application.put_env(:mave_core, :public_cdn_host, "staging.video-dns.com")
+ Application.put_env(:mave_core, :public_cdn_host, "storage.example.test")
Application.put_env(:mave_core, :public_cdn_scheme, "https")
- System.put_env("MAVE_METRICS_HOST", "metrics.staging.video-dns.com")
+ System.put_env("MAVE_METRICS_HOST", "metrics.example.test")
assert SettingsSerializer.component_src() ==
"https://cdn.video-dns.com/npm/@maveio/components/+esm"
@@ -1990,20 +1990,25 @@ defmodule MaveCore.EmbedsTest do
"https://cdn.video-dns.com/npm/@maveio/components/dist/config.js"
assert Jason.decode!(SettingsSerializer.component_config_json()) == %{
- "api" => %{"endpoint" => "https://dash.staging.mave.io/api/v1"},
- "cdn" => %{"endpoint" => "https://space-${this.spaceId}.s3.fr-par.scw.cloud"},
- "metrics" => %{"endpoint" => "https://metrics.staging.video-dns.com/v1/events"},
+ "api" => %{"endpoint" => "https://dashboard.example.test/api/v1"},
+ "cdn" => %{
+ "endpoint" => "https://space-${this.spaceId}.storage.example.test",
+ "playback_endpoint" =>
+ "https://dashboard.example.test/api/v1/playback/media/${this.spaceId}${this.embedId}"
+ },
+ "metrics" => %{"endpoint" => "https://metrics.example.test/v1/events"},
"upload" => %{
- "endpoint" => "https://upload.staging.mave.io/files",
- "socket" => "wss://dash.staging.mave.io/api/v1/socket"
+ "endpoint" => "https://upload.example.test/files",
+ "socket" => "wss://dashboard.example.test/api/v1/socket"
}
}
assert SettingsSerializer.storage_object_url("space-ofyrn", "Vkmazex4WB/manifest.json") ==
- "https://space-ofyrn.s3.fr-par.scw.cloud/Vkmazex4WB/manifest.json"
+ "https://space-ofyrn.storage.example.test/Vkmazex4WB/manifest.json"
end
test "settings serializer does not require component config for production CDN aliases" do
+ original_playback_origin = Application.get_env(:mave_core, :playback_origin)
original_src = Application.get_env(:mave_core, :components_src)
original_base = Application.get_env(:mave_core, :components_base_url)
original_domain = Application.get_env(:mave_core, :domain)
@@ -2015,6 +2020,7 @@ defmodule MaveCore.EmbedsTest do
original_metrics_host = System.get_env("MAVE_METRICS_HOST")
on_exit(fn ->
+ restore_env(:playback_origin, original_playback_origin)
restore_env(:components_src, original_src)
restore_env(:components_base_url, original_base)
restore_env(:domain, original_domain)
@@ -2026,13 +2032,14 @@ defmodule MaveCore.EmbedsTest do
restore_system_env("MAVE_METRICS_HOST", original_metrics_host)
end)
+ Application.put_env(:mave_core, :playback_origin, "https://signed.video-dns.com")
Application.delete_env(:mave_core, :components_src)
Application.delete_env(:mave_core, :components_base_url)
Application.put_env(:mave_core, :domain, "https://dash.mave.io")
Application.put_env(:mave_core, :upload,
endpoint: "https://upload.mave.io/files",
- source_base_url: "https://s3.fr-par.scw.cloud",
+ source_base_url: "https://storage.example.test",
public_base_url: "https://storage.mave.io",
source_region: "fr-par",
hook_secret: "secret",
@@ -2046,17 +2053,15 @@ defmodule MaveCore.EmbedsTest do
Application.delete_env(:mave_core, :public_cdn_mode)
- assert Jason.decode!(SettingsSerializer.component_config_json())["cdn"] == %{
- "endpoint" => "https://space-${this.spaceId}.video-dns.com"
- }
+ assert Jason.decode!(SettingsSerializer.component_config_json())["cdn"]["endpoint"] ==
+ "https://space-${this.spaceId}.video-dns.com"
refute SettingsSerializer.component_config_required?()
Application.put_env(:mave_core, :public_cdn_mode, "path")
- assert Jason.decode!(SettingsSerializer.component_config_json())["cdn"] == %{
- "endpoint" => "https://cdn.video-dns.com/space-${this.spaceId}"
- }
+ assert Jason.decode!(SettingsSerializer.component_config_json())["cdn"]["endpoint"] ==
+ "https://cdn.video-dns.com/space-${this.spaceId}"
refute SettingsSerializer.component_config_required?()
end
@@ -2079,7 +2084,14 @@ defmodule MaveCore.EmbedsTest do
assert SettingsSerializer.storage_object_url("space-lt1ij", "yrATPMmNde/poster.jpg") ==
"https://cdn.saas.orb.local/space-lt1ij/yrATPMmNde/poster.jpg"
- assert Jason.decode!(SettingsSerializer.component_config_json()) == %{
+ config = Jason.decode!(SettingsSerializer.component_config_json())
+
+ assert config["cdn"]["playback_endpoint"] ==
+ "http://localhost:4000/api/v1/playback/media/${this.spaceId}${this.embedId}"
+
+ config = update_in(config, ["cdn"], &Map.delete(&1, "playback_endpoint"))
+
+ assert config == %{
"api" => %{"endpoint" => "http://localhost:4000/api/v1"},
"cdn" => %{"endpoint" => "https://cdn.saas.orb.local/space-${this.spaceId}"},
"metrics" => %{"endpoint" => "http://localhost:4000/v1/events"},
@@ -2103,9 +2115,8 @@ defmodule MaveCore.EmbedsTest do
assert SettingsSerializer.storage_object_url("space-lt1ij", "video/manifest.json") ==
"http://localhost:9000/space-lt1ij/video/manifest.json"
- assert Jason.decode!(SettingsSerializer.component_config_json())["cdn"] == %{
- "endpoint" => "http://localhost:9000/space-${this.spaceId}"
- }
+ assert Jason.decode!(SettingsSerializer.component_config_json())["cdn"]["endpoint"] ==
+ "http://localhost:9000/space-${this.spaceId}"
end
test "settings serializer honors explicit path-style public CDN mode" do
@@ -2126,9 +2137,8 @@ defmodule MaveCore.EmbedsTest do
assert SettingsSerializer.storage_object_url("space-ubg50", "XiyviR3oEq/thumbnail.jpg") ==
"https://cdn.video-dns.com/space-ubg50/XiyviR3oEq/thumbnail.jpg"
- assert Jason.decode!(SettingsSerializer.component_config_json())["cdn"] == %{
- "endpoint" => "https://cdn.video-dns.com/space-${this.spaceId}"
- }
+ assert Jason.decode!(SettingsSerializer.component_config_json())["cdn"]["endpoint"] ==
+ "https://cdn.video-dns.com/space-${this.spaceId}"
end
test "settings serializer uses public upload base for legacy uploaded poster keys" do
@@ -2222,6 +2232,32 @@ defmodule MaveCore.EmbedsTest do
"https://space-#{space.hash}.s3.fr-par.scw.cloud/#{video.hash}/thumbnail_4.jpg",
"https://space-#{space.hash}.s3.fr-par.scw.cloud/#{video.hash}/thumbnail_5.jpg"
]
+
+ private_video =
+ video
+ |> Ecto.Changeset.change(playback_visibility: :private, playback_status: :private)
+ |> Repo.update!()
+
+ preview = Embeds.get_video_dashboard_payload(space, private_video).thumbnail_preview
+ playlist = URI.parse(preview.preferred_src)
+ token = URI.decode_query(playlist.query)["token"]
+ assert is_binary(token)
+
+ assert String.ends_with?(playlist.path, "/#{video.hash}/h264_sd_hls/playlist.m3u8") or
+ String.ends_with?(
+ playlist.path,
+ "/#{space.hash}#{video.hash}/h264_sd_hls/playlist.m3u8"
+ )
+
+ assert {:ok, _expires_at} = MaveCore.Playback.authorize(token, private_video)
+
+ for src <- [preview.fallback_src | Enum.map(preview.frame_srcs, & &1.src)] do
+ uri = URI.parse(src)
+ query = URI.decode_query(uri.query)
+ assert query["X-Amz-Signature"]
+ assert query["X-Amz-Expires"] == "86400"
+ assert String.contains?(uri.path, "/#{video.hash}/")
+ end
end
test "settings serializer omits default controls from player attrs but keeps manifest default" do
diff --git a/test/mave_core/media/storage_test.exs b/test/mave_core/media/storage_test.exs
index acb1e45..4d438b2 100644
--- a/test/mave_core/media/storage_test.exs
+++ b/test/mave_core/media/storage_test.exs
@@ -9,6 +9,56 @@ defmodule MaveCore.Media.StorageTest do
setup {Req.Test, :verify_on_exit!}
+ test "signed reads support a full dashboard day while remaining bounded" do
+ profile = [
+ endpoint: "https://storage.example.test",
+ access_key_id: "test",
+ secret_access_key: "test"
+ ]
+
+ for requested <- [86_400, 172_800] do
+ assert {:ok, url} =
+ Storage.presigned_get_url("bucket", "video.mp4", profile, expires: requested)
+
+ query = url |> URI.parse() |> Map.fetch!(:query) |> URI.decode_query()
+ assert query["X-Amz-Expires"] == "86400"
+ end
+ end
+
+ test "presigned image URLs reuse a signing time and cover cache parameters" do
+ profile = [
+ endpoint: "https://storage.example.test",
+ region: "test-region",
+ access_key_id: "test-key",
+ secret_access_key: "test-secret"
+ ]
+
+ opts = [
+ datetime: ~U[2026-01-01 12:00:00Z],
+ expires: 600,
+ query_params: [{"response-cache-control", "private, max-age=300"}, {"e", 1}]
+ ]
+
+ assert {:ok, url} = Storage.presigned_get_url("bucket", "video/thumbnail.jpg", profile, opts)
+ assert {:ok, ^url} = Storage.presigned_get_url("bucket", "video/thumbnail.jpg", profile, opts)
+ query = url |> URI.parse() |> Map.fetch!(:query) |> URI.decode_query()
+ assert query["response-cache-control"] == "private, max-age=300"
+ assert query["X-Amz-Date"] == "20260101T120000Z"
+ assert query["X-Amz-Expires"] == "600"
+
+ changed_opts =
+ Keyword.put(opts, :query_params, [
+ {"response-cache-control", "private, max-age=300"},
+ {"e", 2}
+ ])
+
+ assert {:ok, changed_url} =
+ Storage.presigned_get_url("bucket", "video/thumbnail.jpg", profile, changed_opts)
+
+ changed_query = changed_url |> URI.parse() |> Map.fetch!(:query) |> URI.decode_query()
+ refute changed_query["X-Amz-Signature"] == query["X-Amz-Signature"]
+ end
+
test "bucket overrides sign requests and presigned URLs for the correct account" do
Req.default_options(plug: {Req.Test, __MODULE__})
diff --git a/test/mave_core/playback/embed_code_test.exs b/test/mave_core/playback/embed_code_test.exs
new file mode 100644
index 0000000..e8f2dcd
--- /dev/null
+++ b/test/mave_core/playback/embed_code_test.exs
@@ -0,0 +1,27 @@
+defmodule MaveCore.Playback.EmbedCodeTest do
+ use ExUnit.Case, async: true
+ alias MaveCore.Playback.EmbedCode
+
+ test "browser examples put the token directly in the HTML attribute" do
+ html =
+ EmbedCode.add_token(
+ ~s(
),
+ :script,
+ "spacevideo00001",
+ "mave-player"
+ )
+
+ assert html ==
+ ~s(
)
+
+ refute html =~ "
), :react, "video", "Player") =~
+ ~s(), :vue, "video", "Player") =~
+ ~s(
+ if previous,
+ do: Application.put_env(:mave_core, :playback_adapter, previous),
+ else: Application.delete_env(:mave_core, :playback_adapter)
+ end)
+
+ {:ok, user} =
+ Accounts.create_user("playback-#{System.unique_integer([:positive])}@example.com")
+
+ space = user.current_space_membership.space
+ {:ok, key} = Spaces.create_key(space, %{access_level: "read_only"})
+ {:ok, embed} = Embeds.create_video_embed(space, %{name: "Private video"})
+
+ embed =
+ embed
+ |> Ecto.Changeset.change(playback_visibility: :private, playback_status: :private)
+ |> Repo.update!()
+
+ %{space: space, key: key, embed: embed, identifier: space.hash <> embed.hash}
+ end
+
+ test "read-only keys sign a sub and exp token without aud or iat", context do
+ exp = System.system_time(:second) + 600
+ token = sign(context.key, %{"sub" => context.identifier, "exp" => exp})
+ assert context.key.access_level == :read_only
+ assert {:ok, expires_at} = Playback.authorize(token, context.embed)
+ assert expires_at == exp
+ end
+
+ test "expiration is optional and revoking the key rejects subsequent media requests", context do
+ token = sign(context.key, %{"sub" => context.space.id})
+ assert {:ok, expires_at} = Playback.authorize(token, context.embed)
+ assert expires_at <= System.system_time(:second) + 86_400
+ assert {:ok, _} = Spaces.delete_key(context.key)
+ assert {:error, :unauthorized} = Playback.authorize(token, context.embed)
+ end
+
+ test "tokens may last longer than a day while signed storage URLs remain bounded", context do
+ now = System.system_time(:second)
+
+ token =
+ sign(context.key, %{"sub" => context.identifier, "iat" => now, "exp" => now + 604_800})
+
+ assert {:ok, expires_at} = Playback.authorize(token, context.embed)
+ assert expires_at <= System.system_time(:second) + 86_400
+ end
+
+ test "expired or malformed time claims and incorrect signatures are rejected", context do
+ now = System.system_time(:second)
+
+ for claims <- [%{"exp" => now - 1}, %{"exp" => "tomorrow"}, %{"iat" => now + 3600}] do
+ token = sign(context.key, Map.put(claims, "sub", context.identifier))
+ assert {:error, :unauthorized} = Playback.authorize(token, context.embed)
+ end
+
+ token = sign(%{context.key | secret: "incorrect-secret"}, %{"sub" => context.identifier})
+ assert {:error, :unauthorized} = Playback.authorize(token, context.embed)
+ end
+
+ test "a token for one video does not authorize another video", context do
+ {:ok, other} = Embeds.create_video_embed(context.space, %{name: "Other video"})
+ token = sign(context.key, %{"sub" => context.identifier})
+
+ assert {:error, :unauthorized} =
+ Playback.authorize(token, other)
+ end
+
+ defp sign(key, claims) do
+ header = encode(%{"alg" => "HS256", "typ" => "JWT"})
+ payload = encode(claims)
+ input = header <> "." <> payload
+ signature = :crypto.mac(:hmac, :sha256, Spaces.display_api_key(key.key, key.secret), input)
+ input <> "." <> Base.url_encode64(signature, padding: false)
+ end
+
+ defp encode(value), do: value |> Jason.encode!() |> Base.url_encode64(padding: false)
+end
diff --git a/test/mave_core/playback/media_test.exs b/test/mave_core/playback/media_test.exs
new file mode 100644
index 0000000..ce7eaf9
--- /dev/null
+++ b/test/mave_core/playback/media_test.exs
@@ -0,0 +1,28 @@
+defmodule MaveCore.Playback.MediaTest do
+ use ExUnit.Case, async: true
+ alias MaveCore.Playback.Media
+
+ test "root playlists resolve rendition, audio and subtitle paths without a dot prefix" do
+ for path <- [
+ "h264_sd_hls/playlist.m3u8",
+ "audio_hls/playlist.m3u8",
+ "subtitle_en_hls/playlist.m3u8"
+ ] do
+ assert {:ok, ^path} = Media.resolve_path(path, "video", ".")
+ end
+
+ assert {:ok, "h264_sd_hls/segment0.ts"} =
+ Media.resolve_path("segment0.ts", "video", "h264_sd_hls")
+ end
+
+ test "media paths cannot escape the authorized video prefix" do
+ for path <- [
+ "../other/playlist.m3u8",
+ "/other/playlist.m3u8",
+ "https://example.com/other/playlist.m3u8",
+ "%2e%2e/other"
+ ] do
+ assert {:error, :invalid_path} = Media.resolve_path(path, "video", ".")
+ end
+ end
+end
diff --git a/test/mave_core/playback/minio_test.exs b/test/mave_core/playback/minio_test.exs
new file mode 100644
index 0000000..7f0dc7a
--- /dev/null
+++ b/test/mave_core/playback/minio_test.exs
@@ -0,0 +1,18 @@
+defmodule MaveCore.Playback.MinioTest do
+ use ExUnit.Case, async: true
+
+ alias MaveCore.Playback.Minio, as: Local
+
+ test "local policy permits only public prefixes without granting anonymous writes" do
+ {:ok, policy} = Local.bucket_policy("space-test", ["public-video", "public-video"])
+ assert policy["Version"] == "2012-10-17"
+ assert [statement] = policy["Statement"]
+ assert statement["Action"] == "s3:GetObject"
+
+ assert statement["Resource"] == [
+ "arn:aws:s3:::space-test/themes/*",
+ "arn:aws:s3:::space-test/*/player.html",
+ "arn:aws:s3:::space-test/public-video/*"
+ ]
+ end
+end
diff --git a/test/mave_core/playback/session_test.exs b/test/mave_core/playback/session_test.exs
new file mode 100644
index 0000000..db4cc69
--- /dev/null
+++ b/test/mave_core/playback/session_test.exs
@@ -0,0 +1,47 @@
+defmodule MaveCore.Playback.SessionTest do
+ use ExUnit.Case, async: false
+ alias MaveCore.Embeds.Embed
+ alias MaveCore.Playback
+
+ defmodule Endpoint do
+ def config(:secret_key_base), do: String.duplicate("playback-test", 8)
+ end
+
+ defmodule Adapter do
+ def token_endpoint, do: Endpoint
+ end
+
+ setup do
+ previous = Application.get_env(:mave_core, :playback_adapter)
+ Application.put_env(:mave_core, :playback_adapter, Adapter)
+
+ on_exit(fn ->
+ if previous,
+ do: Application.put_env(:mave_core, :playback_adapter, previous),
+ else: Application.delete_env(:mave_core, :playback_adapter)
+ end)
+ end
+
+ test "dashboard sessions use the active deployment endpoint and bind to one video" do
+ embed = %Embed{id: Ecto.UUID.generate(), space_id: Ecto.UUID.generate()}
+ session = Playback.dashboard_session(embed)
+ assert_in_delta session.expires_at - System.system_time(:second), 86_400, 1
+ assert {:ok, session.expires_at} == Playback.authorize(session.token, embed)
+
+ assert {:error, :unauthorized} ==
+ Playback.authorize(session.token, %{embed | id: Ecto.UUID.generate()})
+
+ assert {:error, :unauthorized} == Playback.authorize(nil, embed)
+ end
+
+ test "dashboard sessions remain valid after an hour but never past their expiry" do
+ embed = %Embed{id: Ecto.UUID.generate(), space_id: Ecto.UUID.generate()}
+ now = System.system_time(:second)
+ claims = %{embed_id: embed.id, space_id: embed.space_id, expires_at: now + 79_200}
+ token = Phoenix.Token.sign(Endpoint, "media-playback-v1", claims, signed_at: now - 7200)
+ assert {:ok, claims.expires_at} == Playback.authorize(token, embed)
+
+ expired = Phoenix.Token.sign(Endpoint, "media-playback-v1", %{claims | expires_at: now - 1})
+ assert {:error, :unauthorized} == Playback.authorize(expired, embed)
+ end
+end
diff --git a/test/mave_core/playback/storage_policy_test.exs b/test/mave_core/playback/storage_policy_test.exs
new file mode 100644
index 0000000..1459614
--- /dev/null
+++ b/test/mave_core/playback/storage_policy_test.exs
@@ -0,0 +1,62 @@
+defmodule MaveCore.Playback.StoragePolicyTest do
+ use MaveCore.DataCase, async: false
+
+ import Plug.Conn
+
+ alias MaveCore.{Accounts, Embeds}
+ alias MaveCore.Playback.Minio
+
+ setup {Req.Test, :verify_on_exit!}
+
+ setup do
+ previous = Application.get_env(:mave_core, :playback_adapter)
+ previous_req = Req.default_options()
+ Application.put_env(:mave_core, :playback_adapter, Minio)
+ Req.default_options(plug: {Req.Test, __MODULE__})
+
+ on_exit(fn ->
+ Req.default_options(previous_req)
+
+ if previous,
+ do: Application.put_env(:mave_core, :playback_adapter, previous),
+ else: Application.delete_env(:mave_core, :playback_adapter)
+ end)
+
+ {:ok, user} =
+ Accounts.create_user("storage-policy-#{System.unique_integer([:positive])}@example.com")
+
+ %{space: user.current_space_membership.space}
+ end
+
+ test "new private embeds protect their empty prefix before media exists", %{space: space} do
+ {:ok, public} = Embeds.create_video_embed(space)
+
+ Req.Test.expect(__MODULE__, fn conn ->
+ assert conn.method == "PUT"
+ assert conn.query_string == "policy"
+ {:ok, body, conn} = read_body(conn)
+ resources = Jason.decode!(body)["Statement"] |> hd() |> Map.fetch!("Resource")
+ assert Enum.any?(resources, &String.ends_with?(&1, "/#{public.hash}/*"))
+ send(self(), {:policy_resources, resources})
+ send_resp(conn, 200, "")
+ end)
+
+ Req.Test.expect(__MODULE__, fn conn ->
+ assert conn.method == "PUT"
+ assert conn.query_string == "cors"
+ send_resp(conn, 200, "")
+ end)
+
+ Req.Test.expect(__MODULE__, fn conn ->
+ assert conn.method == "HEAD"
+ assert String.ends_with?(conn.request_path, "/manifest.json")
+ send_resp(conn, 404, "")
+ end)
+
+ assert {:ok, private} = Embeds.create_video_embed(space, %{visibility: :private})
+ assert private.playback_status == :private
+ assert is_nil(private.asset.current_video_id)
+ assert_receive {:policy_resources, resources}
+ refute Enum.any?(resources, &String.ends_with?(&1, "/#{private.hash}/*"))
+ end
+end
diff --git a/test/mave_core_web/browser_security_test.exs b/test/mave_core_web/browser_security_test.exs
index d70b2f6..3fbd283 100644
--- a/test/mave_core_web/browser_security_test.exs
+++ b/test/mave_core_web/browser_security_test.exs
@@ -56,6 +56,38 @@ defmodule MaveCoreWeb.BrowserSecurityTest do
assert csp =~ "http://localhost:1080"
end
+ test "browser CSP allows private playback storage without allowing its scripts", %{conn: conn} do
+ original_endpoint = Application.get_env(:mave_core, :playback_public_storage_endpoint)
+ Application.put_env(:mave_core, :playback_public_storage_endpoint, "http://localhost:9010")
+ on_exit(fn -> restore_env(:playback_public_storage_endpoint, original_endpoint) end)
+
+ conn = get(conn, ~p"/health")
+ assert [csp] = get_resp_header(conn, "content-security-policy")
+ directives = String.split(csp, "; ")
+
+ for name <- ["img-src", "media-src", "connect-src"] do
+ directive = Enum.find(directives, &String.starts_with?(&1, name <> " "))
+ assert "http://localhost:9010" in String.split(directive)
+ end
+
+ script_src = Enum.find(directives, &String.starts_with?(&1, "script-src "))
+ refute "http://localhost:9010" in String.split(script_src)
+ end
+
+ test "browser CSP permits the configured local space media host" do
+ previous = Application.get_env(:mave_core, :playback_origin)
+ Application.put_env(:mave_core, :playback_origin, "http://signed.localhost:4001")
+ on_exit(fn -> restore_env(:playback_origin, previous) end)
+ directives = MaveCoreWeb.BrowserSecurity.content_security_policy() |> String.split("; ")
+
+ for name <- ["img-src", "media-src", "connect-src"] do
+ assert Enum.find(directives, &String.starts_with?(&1, name <> " ")) =~
+ "http://*.signed.localhost:4001"
+ end
+
+ refute Enum.find(directives, &String.starts_with?(&1, "script-src ")) =~ "signed.localhost"
+ end
+
defp restore_env(key, nil), do: Application.delete_env(:mave_core, key)
defp restore_env(key, value), do: Application.put_env(:mave_core, key, value)
end
diff --git a/test/mave_core_web/controllers/api/playback_controller_test.exs b/test/mave_core_web/controllers/api/playback_controller_test.exs
new file mode 100644
index 0000000..85ad5e3
--- /dev/null
+++ b/test/mave_core_web/controllers/api/playback_controller_test.exs
@@ -0,0 +1,458 @@
+defmodule MaveCoreWeb.Api.PlaybackControllerTest do
+ use MaveCoreWeb.ConnCase, async: false
+
+ alias MaveCore.{Accounts, Embeds, PublicApi, Repo, Spaces}
+ alias MaveCore.Assets.{AudioTrack, Subtitle}
+ alias MaveCore.Embeds.SettingsSerializer
+ alias MaveCore.Playback.Media
+ alias MaveCore.Workers.PlaybackVisibilityWorker
+
+ def available?(_space), do: Process.get(:playback_available, true)
+ def token_endpoint, do: MaveCoreWeb.Endpoint
+
+ def apply_visibility(embed, visibility) do
+ send(self(), {:storage_visibility, embed.id, visibility})
+ Process.get(:playback_storage_result, :ok)
+ end
+
+ def object_info(_bucket, _path, _region), do: {:ok, %{size_bytes: 100}}
+
+ def put_public(_bucket, _path, _body, _content_type, _region), do: {:ok, %{}}
+
+ def get(_bucket, path, _region) do
+ cond do
+ String.ends_with?(path, ".json") ->
+ {:error, :not_found}
+
+ String.ends_with?(path, "/storyboard.vtt") ->
+ {:ok,
+ Process.get(
+ :storyboard_body,
+ "WEBVTT\n\n00:00.000 --> 00:05.000\nstoryboard.jpg#xywh=0,0,320,180\n"
+ )}
+
+ String.ends_with?(path, "/h264_hd_hls/playlist.m3u8") ->
+ {:ok, "#EXTM3U\nsegment_000.ts\n#EXT-X-ENDLIST\n"}
+
+ true ->
+ {:ok, "#EXTM3U\nh264_hd_hls/playlist.m3u8\n"}
+ end
+ end
+
+ def presigned_get_url(bucket, path, _region, opts),
+ do: {:ok, "https://storage.example.test/#{bucket}/#{path}?expires=#{opts[:expires]}"}
+
+ setup do
+ previous_origin = Application.get_env(:mave_core, :playback_origin)
+ Application.delete_env(:mave_core, :playback_origin)
+
+ on_exit(fn ->
+ if previous_origin,
+ do: Application.put_env(:mave_core, :playback_origin, previous_origin),
+ else: Application.delete_env(:mave_core, :playback_origin)
+ end)
+
+ previous =
+ for key <- [:playback_adapter, :playback_storage_adapter, :flow_storage_adapter],
+ into: %{},
+ do: {key, Application.get_env(:mave_core, key)}
+
+ Enum.each(Map.keys(previous), &Application.put_env(:mave_core, &1, __MODULE__))
+
+ on_exit(fn ->
+ Enum.each(previous, fn {key, value} ->
+ if value,
+ do: Application.put_env(:mave_core, key, value),
+ else: Application.delete_env(:mave_core, key)
+ end)
+ end)
+
+ {:ok, user} =
+ Accounts.create_user("playback-api-#{System.unique_integer([:positive])}@example.com")
+
+ space = user.current_space_membership.space
+ {:ok, key} = Spaces.create_key(space)
+ {:ok, read_key} = Spaces.create_key(space, %{access_level: "read_only"})
+ %{space: space, key: key, read_key: read_key}
+ end
+
+ test "private creation protects storage before returning, and default creation stays public",
+ context do
+ conn = api(context.key) |> post("/api/v1/videos", %{name: "Private", visibility: "private"})
+
+ assert %{
+ "id" => id,
+ "visibility" => "private"
+ } = json_response(conn, 200)
+
+ embed = PublicApi.get_embed(context.space, id)
+ assert_receive {:storage_visibility, embed_id, :private}
+ assert embed_id == embed.id
+ assert is_nil(embed.asset.current_video_id)
+
+ conn = api(context.key) |> post("/api/v1/videos", %{name: "Default"})
+ assert %{"visibility" => "public"} = json_response(conn, 200)
+ end
+
+ test "failed or unavailable private protection and invalid visibility leave no video behind",
+ context do
+ Process.put(:playback_storage_result, {:error, :storage_unavailable})
+ conn = api(context.key) |> post("/api/v1/videos", %{visibility: "private"})
+ assert conn.status == 400
+ assert PublicApi.count_videos(context.space, []) == 0
+
+ Process.put(:playback_available, false)
+ conn = api(context.key) |> post("/api/v1/videos", %{visibility: "private"})
+ assert conn.status == 400
+ conn = api(context.key) |> post("/api/v1/videos", %{visibility: "unknown"})
+ assert conn.status == 400
+ assert PublicApi.count_videos(context.space, []) == 0
+ end
+
+ test "visibility updates require write access", context do
+ {:ok, embed} = Embeds.create_video_embed(context.space)
+ conn = api(context.read_key) |> put("/api/v1/videos/#{embed.hash}", %{visibility: "private"})
+ assert conn.status == 403
+ assert PublicApi.get_embed(context.space, embed.hash).playback_visibility == :public
+
+ conn = api(context.key) |> put("/api/v1/videos/#{embed.hash}", %{visibility: "private"})
+ assert %{"visibility" => "private"} = json_response(conn, 200)
+ conn = api(context.key) |> put("/api/v1/videos/#{embed.hash}", %{visibility: "public"})
+ assert %{"visibility" => "public"} = json_response(conn, 200)
+ end
+
+ test "visibility changes only after storage synchronization succeeds", context do
+ {:ok, embed} = Embeds.create_video_embed(context.space)
+ path = "/api/v1/videos/#{embed.hash}"
+ job = %Oban.Job{args: %{"embed_id" => embed.id}}
+
+ for {previous, target} <- [{"public", "private"}, {"private", "public"}] do
+ Oban.Testing.with_testing_mode(:manual, fn ->
+ conn = api(context.key) |> put(path, %{visibility: target})
+ response = json_response(conn, 202)
+ assert response["visibility"] == previous
+ refute Map.has_key?(response, "visibility_status")
+ end)
+
+ for reason <- [:cache_purge_timeout, :cache_purge_failed, :cache_pipeline_missing] do
+ Process.put(:playback_storage_result, {:error, reason})
+
+ assert {:error, :playback_storage_sync_failed} = PlaybackVisibilityWorker.perform(job)
+ conn = api(context.read_key) |> get(path)
+ assert json_response(conn, 202)["visibility"] == previous
+ assert MaveCore.Playback.protected?(PublicApi.get_embed(context.space, embed.hash))
+ end
+
+ Process.put(:playback_storage_result, :ok)
+ assert :ok = PlaybackVisibilityWorker.perform(job)
+ conn = api(context.read_key) |> get(path)
+ assert json_response(conn, 200)["visibility"] == target
+ end
+ end
+
+ test "reversing a pending change retains the last confirmed visibility", context do
+ {:ok, embed} = Embeds.create_video_embed(context.space)
+ path = "/api/v1/videos/#{embed.hash}"
+
+ Oban.Testing.with_testing_mode(:manual, fn ->
+ for target <- ["private", "public"] do
+ conn = api(context.key) |> put(path, %{visibility: target})
+ assert json_response(conn, 202)["visibility"] == "public"
+ end
+
+ conn = api(context.read_key) |> get(path)
+ assert json_response(conn, 202)["visibility"] == "public"
+ end)
+
+ assert :ok = PlaybackVisibilityWorker.perform(%Oban.Job{args: %{"embed_id" => embed.id}})
+ assert_receive {:storage_visibility, _, :public}
+ conn = api(context.read_key) |> get(path)
+ assert json_response(conn, 200)["visibility"] == "public"
+ end
+
+ test "ordinary updates and already confirmed visibility keep HTTP 200", context do
+ {:ok, embed} = Embeds.create_video_embed(context.space)
+ path = "/api/v1/videos/#{embed.hash}"
+
+ Oban.Testing.with_testing_mode(:manual, fn ->
+ conn = api(context.key) |> put(path, %{visibility: "public"})
+ assert json_response(conn, 200)["visibility"] == "public"
+
+ conn = api(context.key) |> put(path, %{visibility: "private"})
+ assert conn.status == 202
+ conn = api(context.key) |> put(path, %{name: "Renamed"})
+ assert json_response(conn, 200)["visibility"] == "public"
+ end)
+ end
+
+ test "media URLs play with the original JWT, including child playlists and files", context do
+ {:ok, embed} = Embeds.create_video_embed(context.space, %{visibility: :private})
+
+ {:ok, embed} =
+ Embeds.begin_video_upload(context.space.hash, embed.hash, %{"title" => "video.mp4"})
+
+ now = DateTime.utc_now() |> DateTime.truncate(:second)
+
+ for {container, key} <- [
+ {"hls", "#{embed.hash}/v1/h264_hd_hls/playlist.m3u8"},
+ {"mp4", "#{embed.hash}/v1/h264_hd.mp4"}
+ ] do
+ Repo.insert_all("renditions", [
+ %{
+ id: MaveCore.LegacyShortUUID.dump!(Ecto.UUID.generate()),
+ video_id: MaveCore.LegacyShortUUID.dump!(embed.asset.current_video_id),
+ rendition_key: key,
+ type: "video",
+ codec: "h264",
+ container: container,
+ size: "hd",
+ progress: 100.0,
+ inserted_at: now,
+ updated_at: now
+ }
+ ])
+ end
+
+ conn = api(context.read_key) |> get("/api/v1/videos/#{embed.hash}")
+ refute Map.has_key?(json_response(conn, 200), "sources")
+ base = "/api/v1/playback/media/#{context.space.hash}#{embed.hash}"
+ path = base <> "/playlist.m3u8"
+
+ token =
+ sign(context.read_key, %{
+ "sub" => context.space.hash <> embed.hash,
+ "exp" => System.system_time(:second) + 600
+ })
+
+ assert get(build_conn(), path).status == 401
+ conn = get(build_conn(), path <> "?" <> URI.encode_query(%{token: token}))
+ playlist = response(conn, 200)
+ child = playlist |> String.split("\n") |> Enum.find(&String.contains?(&1, "h264_hd_hls"))
+ assert URI.decode_query(URI.parse(child).query)["token"] == token
+ assert response(get(build_conn(), child), 200) =~ "https://storage.example.test/"
+
+ conn =
+ build_conn()
+ |> put_req_header("authorization", "Bearer " <> token)
+ |> get(base <> "/v1/h264_hd.mp4")
+
+ assert conn.status == 302
+ assert hd(get_resp_header(conn, "location")) =~ "v1/h264_hd.mp4"
+
+ {:ok, other} = Embeds.create_video_embed(context.space)
+ wrong = sign(context.read_key, %{"sub" => context.space.hash <> other.hash})
+ assert get(build_conn(), path <> "?" <> URI.encode_query(%{token: wrong})).status == 401
+ {:ok, _} = Spaces.delete_key(context.read_key)
+ assert get(build_conn(), path <> "?" <> URI.encode_query(%{token: token})).status == 401
+ end
+
+ test "video responses do not add a sources field to either format", context do
+ {:ok, embed} = Embeds.create_video_embed(context.space)
+
+ for version <- [1, 2], visibility <- [:public, :private] do
+ response =
+ PublicApi.video_response(context.space, %{
+ embed
+ | version: version,
+ playback_visibility: visibility,
+ playback_status: visibility
+ })
+
+ refute Map.has_key?(response, :sources)
+ refute Map.has_key?(response, :visibility_status)
+ assert response.visibility == visibility
+ assert Map.has_key?(response, :poster_image)
+ end
+ end
+
+ test "space, collection and video database IDs constrain JWT scope", context do
+ {:ok, folder} = Embeds.create_folder_embed(context.space, %{name: "Folder"})
+ {:ok, child} = Embeds.create_video_embed(context.space, %{parent_folder_id: folder.id})
+ {:ok, other} = Embeds.create_video_embed(context.space)
+
+ for sub <- [context.space.id, folder.id, child.id] do
+ token = sign(context.read_key, %{"sub" => sub})
+ assert {:ok, _} = MaveCore.Playback.authorize(token, child)
+
+ if sub != context.space.id,
+ do: assert({:error, :unauthorized} == MaveCore.Playback.authorize(token, other))
+ end
+ end
+
+ test "custom players can preflight bearer authorization" do
+ conn =
+ build_conn()
+ |> put_req_header("origin", "https://player.example.test")
+ |> put_req_header("access-control-request-method", "GET")
+ |> put_req_header("access-control-request-headers", "authorization")
+ |> options("/api/v1/playback/media/aaaaabbbbbccccc/playlist.m3u8")
+
+ assert conn.status == 204
+ assert get_resp_header(conn, "access-control-allow-origin") == ["*"]
+ assert hd(get_resp_header(conn, "access-control-allow-headers")) =~ "authorization"
+ end
+
+ test "space media host serves JWT playlists and keeps management routes closed", context do
+ Application.put_env(:mave_core, :playback_origin, "https://signed.example.test")
+ {:ok, embed} = Embeds.create_video_embed(context.space, %{visibility: :private})
+ token = sign(context.read_key, %{"sub" => context.space.hash <> embed.hash})
+ origin = "https://space-#{context.space.hash}.signed.example.test"
+ path = "/#{embed.hash}/playlist.m3u8"
+ query = URI.encode_query(%{token: token})
+
+ conn = get(build_conn(), origin <> path <> "?" <> query)
+ assert conn.status == 200
+ assert conn.resp_body =~ "/#{embed.hash}/h264_hd_hls/playlist.m3u8?token="
+ refute conn.resp_body =~ "/api/v1/"
+ assert get_resp_header(conn, "cache-control") == ["private, no-store"]
+ assert get_resp_header(conn, "access-control-allow-origin") == ["*"]
+ assert get(build_conn(), origin <> path).status == 401
+ assert get(build_conn(), origin <> "/api/v1/videos").status == 404
+ assert get(build_conn(), origin <> "/login").status == 404
+ assert post(build_conn(), origin <> path, %{}).status == 404
+ assert options(build_conn(), origin <> path).status == 204
+
+ {:ok, other_user} =
+ Accounts.create_user("other-host-#{System.unique_integer([:positive])}@example.com")
+
+ other = other_user.current_space_membership.space
+ other_origin = "https://space-#{other.hash}.signed.example.test"
+ assert get(build_conn(), other_origin <> path <> "?" <> query).status == 401
+ # A query-string id cannot override the tenant selected by the hostname.
+ assert get(
+ build_conn(),
+ other_origin <> path <> "?" <> query <> "&id=" <> context.space.hash <> embed.hash
+ ).status == 401
+
+ assert get(build_conn(), "https://bad.signed.example.test" <> path <> "?" <> query).status ==
+ 404
+
+ response = PublicApi.video_response(context.space, embed)
+ assert response.poster_image == origin <> "/#{embed.hash}/thumbnail.jpg"
+
+ endpoint =
+ SettingsSerializer.component_runtime_config()["cdn"]["playback_endpoint"]
+
+ assert endpoint == "https://space-${this.spaceId}.signed.example.test/${this.embedId}"
+
+ # Existing API links remain valid during rollout and for self-hosted installs.
+ assert get(
+ build_conn(),
+ "/api/v1/playback/media/#{context.space.hash}#{embed.hash}/playlist.m3u8?" <> query
+ ).status == 200
+ end
+
+ test "storyboards authorize their sprite images and keep crop coordinates", context do
+ {:ok, embed} = Embeds.create_video_embed(context.space, %{visibility: :private})
+
+ token =
+ sign(context.read_key, %{
+ sub: context.space.hash <> embed.hash,
+ exp: System.system_time(:second) + 3600
+ })
+
+ base = "/api/v1/playback/media/#{context.space.hash}#{embed.hash}"
+
+ for version <- ["", "v2/"] do
+ path = base <> "/" <> version <> "storyboard.vtt"
+ assert get(build_conn(), path).status == 401
+ conn = Phoenix.ConnTest.get(build_conn(), path, %{token: token})
+ assert [type] = get_resp_header(conn, "content-type")
+ assert type =~ "text/vtt"
+ assert conn.resp_body =~ "WEBVTT"
+ assert conn.resp_body =~ "00:00.000 --> 00:05.000"
+ assert conn.resp_body =~ "/#{embed.hash}/#{version}storyboard.jpg?expires="
+ assert conn.resp_body =~ "#xywh=0,0,320,180"
+ assert get_resp_header(conn, "cache-control") == ["private, no-store"]
+ end
+
+ Process.put(
+ :storyboard_body,
+ "WEBVTT\n\n00:00.000 --> 00:05.000\n../other/storyboard.jpg#xywh=0,0,320,180\n"
+ )
+
+ assert Phoenix.ConnTest.get(build_conn(), base <> "/storyboard.vtt", %{token: token}).status ==
+ 404
+ end
+
+ test "private manifests authorize path-style storage subtitles, audio and posters", context do
+ original = Application.get_env(:mave_core, :public_cdn_base_url)
+ Application.put_env(:mave_core, :public_cdn_base_url, "http://storage.example.test:9000")
+
+ on_exit(fn ->
+ if original,
+ do: Application.put_env(:mave_core, :public_cdn_base_url, original),
+ else: Application.delete_env(:mave_core, :public_cdn_base_url)
+ end)
+
+ {:ok, embed} = Embeds.create_video_embed(context.space, %{visibility: :private})
+
+ {:ok, embed} =
+ Embeds.begin_video_upload(context.space.hash, embed.hash, %{"title" => "video.mp4"})
+
+ video_id = embed.asset.current_video_id
+
+ %Subtitle{}
+ |> Subtitle.changeset(%{
+ video_id: video_id,
+ language: "en",
+ path: "#{embed.hash}/v1/subtitle_en.vtt"
+ })
+ |> Repo.insert!()
+
+ %AudioTrack{}
+ |> AudioTrack.changeset(%{
+ video_id: video_id,
+ filename: "audio.mp3",
+ default: true
+ })
+ |> Repo.insert!()
+
+ token = sign(context.read_key, %{sub: context.space.hash <> embed.hash})
+ base = "/api/v1/playback/media/#{context.space.hash}#{embed.hash}"
+ conn = Phoenix.ConnTest.get(build_conn(), base <> "/manifest.json", %{token: token})
+ manifest = json_response(conn, 200)
+ assert [%{"path" => subtitle}] = manifest["subtitles"]
+ assert [%{"path" => audio}] = manifest["audio_tracks"]
+
+ for {url, filename} <- [{subtitle, "v1/subtitle_en.vtt"}, {audio, "audio.mp3"}] do
+ uri = URI.parse(url)
+ assert uri.host == "www.example.com"
+ assert uri.path == base <> "/" <> filename
+ assert URI.decode_query(uri.query)["token"] == token
+ assert get(build_conn(), uri.path).status == 401
+ conn = get(build_conn(), url)
+ assert conn.status == 302
+ assert redirected_to(conn) =~ "/#{embed.hash}/#{filename}?expires="
+ end
+
+ for filename <- [
+ "poster.jpg",
+ "thumbnail.jpg",
+ "storyboard.jpg",
+ "subtitle.json",
+ "h264_hd.mp4"
+ ] do
+ assert get(build_conn(), base <> "/v1/" <> filename).status == 401
+
+ assert Phoenix.ConnTest.get(build_conn(), base <> "/v1/" <> filename, %{token: token}).status ==
+ 302
+ end
+
+ embed = Repo.preload(embed, :space)
+ foreign = "http://storage.example.test:9000/space-other/#{embed.hash}/v1/subtitle_en.vtt"
+ assert {:error, :invalid_path} = Media.resolve_path(foreign, embed, ".")
+ end
+
+ defp api(key),
+ do:
+ build_conn()
+ |> put_req_header("authorization", "Bearer " <> Spaces.display_api_key(key.key, key.secret))
+
+ defp sign(key, claims) do
+ encode = fn value -> value |> Jason.encode!() |> Base.url_encode64(padding: false) end
+ input = encode.(%{alg: "HS256", typ: "JWT"}) <> "." <> encode.(claims)
+ signature = :crypto.mac(:hmac, :sha256, Spaces.display_api_key(key.key, key.secret), input)
+ input <> "." <> Base.url_encode64(signature, padding: false)
+ end
+end
diff --git a/test/mave_core_web/live/dashboard/videos/index_test.exs b/test/mave_core_web/live/dashboard/videos/index_test.exs
index c3b8d2a..84a3404 100644
--- a/test/mave_core_web/live/dashboard/videos/index_test.exs
+++ b/test/mave_core_web/live/dashboard/videos/index_test.exs
@@ -45,6 +45,28 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.IndexTest do
assert has_element?(view, "#videos-empty-state.min-h-full")
end
+ test "/videos signs private thumbnails for the matching video", %{conn: conn} do
+ {conn, space} = authenticated_conn(conn)
+ video = video_embed_fixture(space, %{name: "Private overview thumbnail"})
+
+ video =
+ video
+ |> Ecto.Changeset.change(playback_visibility: :private, playback_status: :private)
+ |> Repo.update!()
+
+ %{videos: [row]} = MaveCore.Embeds.list_root_items(space)
+ uri = URI.parse(row.thumb)
+ assert uri.path == "/space-#{space.hash}/#{video.hash}/thumbnail.jpg"
+ query = URI.decode_query(uri.query)
+ assert query["X-Amz-Signature"]
+ assert query["X-Amz-Expires"] == "86400"
+ assert query["response-cache-control"] == "private, max-age=300"
+
+ {:ok, view, _html} = live(conn, "/videos")
+ assert has_element?(view, ~s([style*="#{uri.path}?"][style*="X-Amz-Signature="]))
+ refute has_element?(view, ~s([style*="/api/v1/playback/media/"]))
+ end
+
test "/videos renders cache-busted custom thumbnails in overview rows", %{conn: conn} do
{conn, space} = authenticated_conn(conn)
video = video_embed_fixture(space, %{name: "Custom Overview Poster"})
diff --git a/test/mave_core_web/live/dashboard/videos/show_test.exs b/test/mave_core_web/live/dashboard/videos/show_test.exs
index b11627f..c888986 100644
--- a/test/mave_core_web/live/dashboard/videos/show_test.exs
+++ b/test/mave_core_web/live/dashboard/videos/show_test.exs
@@ -24,6 +24,10 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
do: {:error, :visibility_failed}
end
+ defmodule AvailablePlayback do
+ def available?(_space), do: true
+ end
+
setup do
old_storage_adapter = Application.get_env(:mave_core, :flow_storage_adapter)
@@ -48,6 +52,102 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
{:ok, db_name: db_name}
end
+ @tag :private_playback_ui
+ test "playback visibility actions are only shown when available for the space", %{conn: conn} do
+ original_adapter = Application.get_env(:mave_core, :playback_adapter)
+ on_exit(fn -> restore_env(:playback_adapter, original_adapter) end)
+ {conn, space} = authenticated_conn(conn)
+ embed = video_embed_fixture(space, %{name: "Playback visibility"})
+
+ for visibility <- [:public, :private], available? <- [false, true] do
+ embed
+ |> Ecto.Changeset.change(playback_visibility: visibility, playback_status: visibility)
+ |> Repo.update!()
+
+ Application.put_env(:mave_core, :playback_adapter, if(available?, do: AvailablePlayback))
+ {:ok, view, _html} = live(conn, "/videos/#{embed.id}")
+
+ assert has_element?(view, "#video-playback-visibility") == available?
+ end
+ end
+
+ @tag :private_playback_ui
+ test "private videos explain token setup and display token-aware embed code", %{conn: conn} do
+ {conn, space} = authenticated_conn(conn)
+ embed = video_embed_fixture(space, %{name: "Private embed setup"})
+
+ embed
+ |> Ecto.Changeset.change(playback_visibility: :private, playback_status: :private)
+ |> Repo.update!()
+
+ {:ok, view, _html} = live(conn, "/videos/#{embed.id}")
+ refute has_element?(view, "#video-access-status")
+ assert has_element?(view, "#private-playback-guide", "Dashboard previews work automatically")
+ assert has_element?(view, "#snippet-code", "YOUR_PLAYBACK_TOKEN")
+ assert has_element?(view, "#snippet-code", ~s(token="YOUR_PLAYBACK_TOKEN"))
+ refute has_element?(view, "#private-playback-server-help")
+ refute has_element?(view, ~s([phx-value-preview="iframe"]))
+
+ view |> element(~s([phx-value-preview="react"])) |> render_click()
+ assert has_element?(view, "#snippet-code", "token={playbackToken}")
+ view |> element(~s([phx-value-preview="vue"])) |> render_click()
+ assert has_element?(view, "#snippet-code", ~s(:token="playbackToken"))
+ view |> element(~s([phx-value-preview="clip"])) |> render_click()
+
+ assert has_element?(
+ view,
+ "#snippet-code",
+ ~s( Ecto.Changeset.change(playback_visibility: :private, playback_status: :private)
+ |> Repo.update!()
+
+ {:ok, view, _html} = live(conn, "/videos/#{embed.id}")
+
+ player_id = fn ->
+ view
+ |> element("#video-components-loader")
+ |> render()
+ |> LazyHTML.from_fragment()
+ |> LazyHTML.filter("#video-components-loader")
+ |> LazyHTML.attribute("data-playback-player")
+ |> List.first()
+ end
+
+ original_id = player_id.()
+ assert is_binary(original_id)
+ assert has_element?(view, "##{original_id} mave-player")
+
+ view
+ |> element(~s([phx-value-title="controls"][phx-value-label="big"]))
+ |> render_click()
+
+ replacement_id = player_id.()
+ assert is_binary(replacement_id)
+ refute replacement_id == original_id
+ assert has_element?(view, ~s(##{replacement_id} mave-player[controls="big"]))
+ assert has_element?(view, ~s(#video-components-loader[data-playback-status="private"]))
+ end
+
+ @tag :private_playback_ui
+ test "public videos retain the ordinary embed code and iframe option", %{conn: conn} do
+ {conn, space} = authenticated_conn(conn)
+ embed = video_embed_fixture(space, %{name: "Public embed setup"})
+ {:ok, view, _html} = live(conn, "/videos/#{embed.id}")
+ refute has_element?(view, "#video-access-status")
+ assert has_element?(view, ~s([phx-value-preview="iframe"]))
+ refute has_element?(view, "#private-playback-guide")
+ refute has_element?(view, "#snippet-code", "YOUR_PLAYBACK_TOKEN")
+ end
+
test "/videos/:id renders folder mode when embed type is collection", %{conn: conn} do
{conn, space} = authenticated_conn(conn)
folder = folder_embed_fixture(space, %{name: "Folder Mode"})
@@ -2773,6 +2873,7 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
end
defp with_default_component_runtime(fun) do
+ original_playback_origin = Application.get_env(:mave_core, :playback_origin)
original_domain = Application.get_env(:mave_core, :domain)
original_upload = Application.get_env(:mave_core, :upload)
original_cdn_host = Application.get_env(:mave_core, :public_cdn_host)
@@ -2784,6 +2885,7 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
original_metrics_host = System.get_env("MAVE_METRICS_HOST")
try do
+ Application.put_env(:mave_core, :playback_origin, "https://signed.video-dns.com")
Application.put_env(:mave_core, :domain, "https://dash.mave.io")
Application.put_env(:mave_core, :upload,
@@ -2805,6 +2907,7 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
fun.()
after
+ restore_env(:playback_origin, original_playback_origin)
restore_env(:domain, original_domain)
restore_env(:upload, original_upload)
restore_env(:public_cdn_host, original_cdn_host)