git.squeep.com Git - akkoma/blob - test/media_proxy_test.exs

   1 defmodule Pleroma.MediaProxyTest do
   2   use ExUnit.Case
   3   import Pleroma.Web.MediaProxy
   4
   5   describe "when enabled" do
   6     setup do
   7       enabled = Pleroma.Config.get([:media_proxy, :enabled])
   8
   9       unless enabled do
  10         Pleroma.Config.put([:media_proxy, :enabled], true)
  11         on_exit(fn -> Pleroma.Config.put([:media_proxy, :enabled], enabled) end)
  12       end
  13
  14       :ok
  15     end
  16
  17     test "ignores invalid url" do
  18       assert url(nil) == nil
  19       assert url("") == nil
  20     end
  21
  22     test "ignores relative url" do
  23       assert url("/local") == "/local"
  24       assert url("/") == "/"
  25     end
  26
  27     test "ignores local url" do
  28       local_url = Pleroma.Web.Endpoint.url() <> "/hello"
  29       local_root = Pleroma.Web.Endpoint.url()
  30       assert url(local_url) == local_url
  31       assert url(local_root) == local_root
  32     end
  33
  34     test "encodes and decodes URL" do
  35       url = "https://pleroma.soykaf.com/static/logo.png"
  36       encoded = url(url)
  37
  38       assert String.starts_with?(
  39                encoded,
  40                Pleroma.Config.get([:media_proxy, :base_url], Pleroma.Web.base_url())
  41              )
  42
  43       assert String.ends_with?(encoded, "/logo.png")
  44
  45       assert decode_result(encoded) == url
  46     end
  47
  48     test "encodes and decodes URL without a path" do
  49       url = "https://pleroma.soykaf.com"
  50       encoded = url(url)
  51       assert decode_result(encoded) == url
  52     end
  53
  54     test "encodes and decodes URL without an extension" do
  55       url = "https://pleroma.soykaf.com/path/"
  56       encoded = url(url)
  57       assert String.ends_with?(encoded, "/path")
  58       assert decode_result(encoded) == url
  59     end
  60
  61     test "encodes and decodes URL and ignores query params for the path" do
  62       url = "https://pleroma.soykaf.com/static/logo.png?93939393939&bunny=true"
  63       encoded = url(url)
  64       assert String.ends_with?(encoded, "/logo.png")
  65       assert decode_result(encoded) == url
  66     end
  67
  68     test "validates signature" do
  69       secret_key_base = Pleroma.Config.get([Pleroma.Web.Endpoint, :secret_key_base])
  70
  71       on_exit(fn ->
  72         Pleroma.Config.put([Pleroma.Web.Endpoint, :secret_key_base], secret_key_base)
  73       end)
  74
  75       encoded = url("https://pleroma.social")
  76
  77       Pleroma.Config.put(
  78         [Pleroma.Web.Endpoint, :secret_key_base],
  79         "00000000000000000000000000000000000000000000000"
  80       )
  81
  82       [_, "proxy", sig, base64 | _] = URI.parse(encoded).path |> String.split("/")
  83       assert decode_url(sig, base64) == {:error, :invalid_signature}
  84     end
  85
  86     test "uses the configured base_url" do
  87       base_url = Pleroma.Config.get([:media_proxy, :base_url])
  88
  89       if base_url do
  90         on_exit(fn ->
  91           Pleroma.Config.put([:media_proxy, :base_url], base_url)
  92         end)
  93       end
  94
  95       Pleroma.Config.put([:media_proxy, :base_url], "https://cache.pleroma.social")
  96
  97       url = "https://pleroma.soykaf.com/static/logo.png"
  98       encoded = url(url)
  99
 100       assert String.starts_with?(encoded, Pleroma.Config.get([:media_proxy, :base_url]))
 101     end
 102   end
 103
 104   describe "when disabled" do
 105     setup do
 106       enabled = Pleroma.Config.get([:media_proxy, :enabled])
 107
 108       if enabled do
 109         Pleroma.Config.put([:media_proxy, :enabled], false)
 110
 111         on_exit(fn ->
 112           Pleroma.Config.put([:media_proxy, :enabled], enabled)
 113           :ok
 114         end)
 115       end
 116
 117       :ok
 118     end
 119
 120     test "does not encode remote urls" do
 121       assert url("https://google.fr") == "https://google.fr"
 122     end
 123   end
 124
 125   defp decode_result(encoded) do
 126     [_, "proxy", sig, base64 | _] = URI.parse(encoded).path |> String.split("/")
 127     {:ok, decoded} = decode_url(sig, base64)
 128     decoded
 129   end
 130 end