git.squeep.com Git - akkoma/blob - test/web/emoji_api_controller_test.exs

   1 defmodule Pleroma.Web.PleromaAPI.EmojiAPIControllerTest do
   2   use Pleroma.Web.ConnCase
   3
   4   import Tesla.Mock
   5
   6   import Pleroma.Factory
   7
   8   @emoji_dir_path Path.join(
   9                     Pleroma.Config.get!([:instance, :static_dir]),
  10                     "emoji"
  11                   )
  12
  13   test "shared & non-shared pack information in list_packs is ok" do
  14     conn = build_conn()
  15     resp = conn |> get(emoji_api_path(conn, :list_packs)) |> json_response(200)
  16
  17     assert Map.has_key?(resp, "test_pack")
  18
  19     pack = resp["test_pack"]
  20
  21     assert Map.has_key?(pack["pack"], "download-sha256")
  22     assert pack["pack"]["can-download"]
  23
  24     assert pack["files"] == %{"blank" => "blank.png"}
  25
  26     # Non-shared pack
  27
  28     assert Map.has_key?(resp, "test_pack_nonshared")
  29
  30     pack = resp["test_pack_nonshared"]
  31
  32     refute pack["pack"]["shared"]
  33     refute pack["pack"]["can-download"]
  34   end
  35
  36   test "downloading a shared pack from download_shared" do
  37     conn = build_conn()
  38
  39     resp =
  40       conn
  41       |> get(emoji_api_path(conn, :download_shared, "test_pack"))
  42       |> response(200)
  43
  44     {:ok, arch} = :zip.unzip(resp, [:memory])
  45
  46     assert Enum.find(arch, fn {n, _} -> n == 'pack.json' end)
  47     assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end)
  48   end
  49
  50   test "downloading shared & unshared packs from another instance via download_from, deleting them" do
  51     on_exit(fn ->
  52       File.rm_rf!("#{@emoji_dir_path}/test_pack2")
  53       File.rm_rf!("#{@emoji_dir_path}/test_pack_nonshared2")
  54     end)
  55
  56     mock(fn
  57       %{method: :get, url: "https://old-instance/.well-known/nodeinfo"} ->
  58         json([%{href: "https://old-instance/nodeinfo/2.1.json"}])
  59
  60       %{method: :get, url: "https://old-instance/nodeinfo/2.1.json"} ->
  61         json(%{metadata: %{features: []}})
  62
  63       %{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
  64         json([%{href: "https://example.com/nodeinfo/2.1.json"}])
  65
  66       %{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
  67         json(%{metadata: %{features: ["shareable_emoji_packs"]}})
  68
  69       %{
  70         method: :get,
  71         url: "https://example.com/api/pleroma/emoji/packs/list"
  72       } ->
  73         conn = build_conn()
  74
  75         conn
  76         |> get(emoji_api_path(conn, :list_packs))
  77         |> json_response(200)
  78         |> json()
  79
  80       %{
  81         method: :get,
  82         url: "https://example.com/api/pleroma/emoji/packs/download_shared/test_pack"
  83       } ->
  84         conn = build_conn()
  85
  86         conn
  87         |> get(emoji_api_path(conn, :download_shared, "test_pack"))
  88         |> response(200)
  89         |> text()
  90
  91       %{
  92         method: :get,
  93         url: "https://nonshared-pack"
  94       } ->
  95         text(File.read!("#{@emoji_dir_path}/test_pack_nonshared/nonshared.zip"))
  96     end)
  97
  98     admin = insert(:user, info: %{is_admin: true})
  99
 100     conn = build_conn() |> assign(:user, admin)
 101
 102     assert (conn
 103             |> put_req_header("content-type", "application/json")
 104             |> post(
 105               emoji_api_path(
 106                 conn,
 107                 :download_from
 108               ),
 109               %{
 110                 instance_address: "https://old-instance",
 111                 pack_name: "test_pack",
 112                 as: "test_pack2"
 113               }
 114               |> Jason.encode!()
 115             )
 116             |> json_response(500))["error"] =~ "does not support"
 117
 118     assert conn
 119            |> put_req_header("content-type", "application/json")
 120            |> post(
 121              emoji_api_path(
 122                conn,
 123                :download_from
 124              ),
 125              %{
 126                instance_address: "https://example.com",
 127                pack_name: "test_pack",
 128                as: "test_pack2"
 129              }
 130              |> Jason.encode!()
 131            )
 132            |> json_response(200) == "ok"
 133
 134     assert File.exists?("#{@emoji_dir_path}/test_pack2/pack.json")
 135     assert File.exists?("#{@emoji_dir_path}/test_pack2/blank.png")
 136
 137     assert conn
 138            |> delete(emoji_api_path(conn, :delete, "test_pack2"))
 139            |> json_response(200) == "ok"
 140
 141     refute File.exists?("#{@emoji_dir_path}/test_pack2")
 142
 143     # non-shared, downloaded from the fallback URL
 144
 145     conn = build_conn() |> assign(:user, admin)
 146
 147     assert conn
 148            |> put_req_header("content-type", "application/json")
 149            |> post(
 150              emoji_api_path(
 151                conn,
 152                :download_from
 153              ),
 154              %{
 155                instance_address: "https://example.com",
 156                pack_name: "test_pack_nonshared",
 157                as: "test_pack_nonshared2"
 158              }
 159              |> Jason.encode!()
 160            )
 161            |> json_response(200) == "ok"
 162
 163     assert File.exists?("#{@emoji_dir_path}/test_pack_nonshared2/pack.json")
 164     assert File.exists?("#{@emoji_dir_path}/test_pack_nonshared2/blank.png")
 165
 166     assert conn
 167            |> delete(emoji_api_path(conn, :delete, "test_pack_nonshared2"))
 168            |> json_response(200) == "ok"
 169
 170     refute File.exists?("#{@emoji_dir_path}/test_pack_nonshared2")
 171   end
 172
 173   describe "updating pack metadata" do
 174     setup do
 175       pack_file = "#{@emoji_dir_path}/test_pack/pack.json"
 176       original_content = File.read!(pack_file)
 177
 178       on_exit(fn ->
 179         File.write!(pack_file, original_content)
 180       end)
 181
 182       {:ok,
 183        admin: insert(:user, info: %{is_admin: true}),
 184        pack_file: pack_file,
 185        new_data: %{
 186          "license" => "Test license changed",
 187          "homepage" => "https://pleroma.social",
 188          "description" => "Test description",
 189          "share-files" => false
 190        }}
 191     end
 192
 193     test "for a pack without a fallback source", ctx do
 194       conn = build_conn()
 195
 196       assert conn
 197              |> assign(:user, ctx[:admin])
 198              |> post(
 199                emoji_api_path(conn, :update_metadata, "test_pack"),
 200                %{
 201                  "new_data" => ctx[:new_data]
 202                }
 203              )
 204              |> json_response(200) == ctx[:new_data]
 205
 206       assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == ctx[:new_data]
 207     end
 208
 209     test "for a pack with a fallback source", ctx do
 210       mock(fn
 211         %{
 212           method: :get,
 213           url: "https://nonshared-pack"
 214         } ->
 215           text(File.read!("#{@emoji_dir_path}/test_pack_nonshared/nonshared.zip"))
 216       end)
 217
 218       new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")
 219
 220       new_data_with_sha =
 221         Map.put(
 222           new_data,
 223           "fallback-src-sha256",
 224           "74409E2674DAA06C072729C6C8426C4CB3B7E0B85ED77792DB7A436E11D76DAF"
 225         )
 226
 227       conn = build_conn()
 228
 229       assert conn
 230              |> assign(:user, ctx[:admin])
 231              |> post(
 232                emoji_api_path(conn, :update_metadata, "test_pack"),
 233                %{
 234                  "new_data" => new_data
 235                }
 236              )
 237              |> json_response(200) == new_data_with_sha
 238
 239       assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == new_data_with_sha
 240     end
 241
 242     test "when the fallback source doesn't have all the files", ctx do
 243       mock(fn
 244         %{
 245           method: :get,
 246           url: "https://nonshared-pack"
 247         } ->
 248           {:ok, {'empty.zip', empty_arch}} = :zip.zip('empty.zip', [], [:memory])
 249           text(empty_arch)
 250       end)
 251
 252       new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")
 253
 254       conn = build_conn()
 255
 256       assert (conn
 257               |> assign(:user, ctx[:admin])
 258               |> post(
 259                 emoji_api_path(conn, :update_metadata, "test_pack"),
 260                 %{
 261                   "new_data" => new_data
 262                 }
 263               )
 264               |> json_response(:bad_request))["error"] =~ "does not have all"
 265     end
 266   end
 267
 268   test "updating pack files" do
 269     pack_file = "#{@emoji_dir_path}/test_pack/pack.json"
 270     original_content = File.read!(pack_file)
 271
 272     on_exit(fn ->
 273       File.write!(pack_file, original_content)
 274
 275       File.rm_rf!("#{@emoji_dir_path}/test_pack/blank_url.png")
 276       File.rm_rf!("#{@emoji_dir_path}/test_pack/dir")
 277       File.rm_rf!("#{@emoji_dir_path}/test_pack/dir_2")
 278     end)
 279
 280     admin = insert(:user, info: %{is_admin: true})
 281
 282     conn = build_conn()
 283
 284     same_name = %{
 285       "action" => "add",
 286       "shortcode" => "blank",
 287       "filename" => "dir/blank.png",
 288       "file" => %Plug.Upload{
 289         filename: "blank.png",
 290         path: "#{@emoji_dir_path}/test_pack/blank.png"
 291       }
 292     }
 293
 294     different_name = %{same_name | "shortcode" => "blank_2"}
 295
 296     conn = conn |> assign(:user, admin)
 297
 298     assert (conn
 299             |> post(emoji_api_path(conn, :update_file, "test_pack"), same_name)
 300             |> json_response(:conflict))["error"] =~ "already exists"
 301
 302     assert conn
 303            |> post(emoji_api_path(conn, :update_file, "test_pack"), different_name)
 304            |> json_response(200) == %{"blank" => "blank.png", "blank_2" => "dir/blank.png"}
 305
 306     assert File.exists?("#{@emoji_dir_path}/test_pack/dir/blank.png")
 307
 308     assert conn
 309            |> post(emoji_api_path(conn, :update_file, "test_pack"), %{
 310              "action" => "update",
 311              "shortcode" => "blank_2",
 312              "new_shortcode" => "blank_3",
 313              "new_filename" => "dir_2/blank_3.png"
 314            })
 315            |> json_response(200) == %{"blank" => "blank.png", "blank_3" => "dir_2/blank_3.png"}
 316
 317     refute File.exists?("#{@emoji_dir_path}/test_pack/dir/")
 318     assert File.exists?("#{@emoji_dir_path}/test_pack/dir_2/blank_3.png")
 319
 320     assert conn
 321            |> post(emoji_api_path(conn, :update_file, "test_pack"), %{
 322              "action" => "remove",
 323              "shortcode" => "blank_3"
 324            })
 325            |> json_response(200) == %{"blank" => "blank.png"}
 326
 327     refute File.exists?("#{@emoji_dir_path}/test_pack/dir_2/")
 328
 329     mock(fn
 330       %{
 331         method: :get,
 332         url: "https://test-blank/blank_url.png"
 333       } ->
 334         text(File.read!("#{@emoji_dir_path}/test_pack/blank.png"))
 335     end)
 336
 337     # The name should be inferred from the URL ending
 338     from_url = %{
 339       "action" => "add",
 340       "shortcode" => "blank_url",
 341       "file" => "https://test-blank/blank_url.png"
 342     }
 343
 344     assert conn
 345            |> post(emoji_api_path(conn, :update_file, "test_pack"), from_url)
 346            |> json_response(200) == %{
 347              "blank" => "blank.png",
 348              "blank_url" => "blank_url.png"
 349            }
 350
 351     assert File.exists?("#{@emoji_dir_path}/test_pack/blank_url.png")
 352
 353     assert conn
 354            |> post(emoji_api_path(conn, :update_file, "test_pack"), %{
 355              "action" => "remove",
 356              "shortcode" => "blank_url"
 357            })
 358            |> json_response(200) == %{"blank" => "blank.png"}
 359
 360     refute File.exists?("#{@emoji_dir_path}/test_pack/blank_url.png")
 361   end
 362
 363   test "creating and deleting a pack" do
 364     on_exit(fn ->
 365       File.rm_rf!("#{@emoji_dir_path}/test_created")
 366     end)
 367
 368     admin = insert(:user, info: %{is_admin: true})
 369
 370     conn = build_conn() |> assign(:user, admin)
 371
 372     assert conn
 373            |> put_req_header("content-type", "application/json")
 374            |> put(
 375              emoji_api_path(
 376                conn,
 377                :create,
 378                "test_created"
 379              )
 380            )
 381            |> json_response(200) == "ok"
 382
 383     assert File.exists?("#{@emoji_dir_path}/test_created/pack.json")
 384
 385     assert Jason.decode!(File.read!("#{@emoji_dir_path}/test_created/pack.json")) == %{
 386              "pack" => %{},
 387              "files" => %{}
 388            }
 389
 390     assert conn
 391            |> delete(emoji_api_path(conn, :delete, "test_created"))
 392            |> json_response(200) == "ok"
 393
 394     refute File.exists?("#{@emoji_dir_path}/test_created/pack.json")
 395   end
 396
 397   test "filesystem import" do
 398     on_exit(fn ->
 399       File.rm!("#{@emoji_dir_path}/test_pack_for_import/emoji.txt")
 400       File.rm!("#{@emoji_dir_path}/test_pack_for_import/pack.json")
 401     end)
 402
 403     conn = build_conn()
 404     resp = conn |> get(emoji_api_path(conn, :list_packs)) |> json_response(200)
 405
 406     refute Map.has_key?(resp, "test_pack_for_import")
 407
 408     admin = insert(:user, info: %{is_admin: true})
 409
 410     assert conn
 411            |> assign(:user, admin)
 412            |> post(emoji_api_path(conn, :import_from_fs))
 413            |> json_response(200) == ["test_pack_for_import"]
 414
 415     resp = conn |> get(emoji_api_path(conn, :list_packs)) |> json_response(200)
 416     assert resp["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}
 417
 418     File.rm!("#{@emoji_dir_path}/test_pack_for_import/pack.json")
 419     refute File.exists?("#{@emoji_dir_path}/test_pack_for_import/pack.json")
 420
 421     emoji_txt_content = "blank, blank.png, Fun\n\nblank2, blank.png"
 422
 423     File.write!("#{@emoji_dir_path}/test_pack_for_import/emoji.txt", emoji_txt_content)
 424
 425     assert conn
 426            |> assign(:user, admin)
 427            |> post(emoji_api_path(conn, :import_from_fs))
 428            |> json_response(200) == ["test_pack_for_import"]
 429
 430     resp = conn |> get(emoji_api_path(conn, :list_packs)) |> json_response(200)
 431
 432     assert resp["test_pack_for_import"]["files"] == %{
 433              "blank" => "blank.png",
 434              "blank2" => "blank.png"
 435            }
 436   end
 437 end