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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.HTML
  10   alias Pleroma.User
  11   alias Pleroma.UserInviteToken
  12   alias Pleroma.Web.CommonAPI
  13   alias Pleroma.Web.MediaProxy
  14   import Pleroma.Factory
  15
  16   describe "/api/pleroma/admin/users" do
  17     test "Delete" do
  18       admin = insert(:user, info: %{is_admin: true})
  19       user = insert(:user)
  20
  21       conn =
  22         build_conn()
  23         |> assign(:user, admin)
  24         |> put_req_header("accept", "application/json")
  25         |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
  26
  27       assert json_response(conn, 200) == user.nickname
  28     end
  29
  30     test "Create" do
  31       admin = insert(:user, info: %{is_admin: true})
  32
  33       conn =
  34         build_conn()
  35         |> assign(:user, admin)
  36         |> put_req_header("accept", "application/json")
  37         |> post("/api/pleroma/admin/users", %{
  38           "nickname" => "lain",
  39           "email" => "lain@example.org",
  40           "password" => "test"
  41         })
  42
  43       assert json_response(conn, 200) == "lain"
  44     end
  45   end
  46
  47   describe "/api/pleroma/admin/users/:nickname" do
  48     test "Show", %{conn: conn} do
  49       admin = insert(:user, info: %{is_admin: true})
  50       user = insert(:user)
  51
  52       conn =
  53         conn
  54         |> assign(:user, admin)
  55         |> get("/api/pleroma/admin/users/#{user.nickname}")
  56
  57       expected = %{
  58         "deactivated" => false,
  59         "id" => to_string(user.id),
  60         "local" => true,
  61         "nickname" => user.nickname,
  62         "roles" => %{"admin" => false, "moderator" => false},
  63         "tags" => [],
  64         "avatar" => User.avatar_url(user) |> MediaProxy.url(),
  65         "display_name" => HTML.strip_tags(user.name || user.nickname)
  66       }
  67
  68       assert expected == json_response(conn, 200)
  69     end
  70
  71     test "when the user doesn't exist", %{conn: conn} do
  72       admin = insert(:user, info: %{is_admin: true})
  73       user = build(:user)
  74
  75       conn =
  76         conn
  77         |> assign(:user, admin)
  78         |> get("/api/pleroma/admin/users/#{user.nickname}")
  79
  80       assert "Not found" == json_response(conn, 404)
  81     end
  82   end
  83
  84   describe "/api/pleroma/admin/users/follow" do
  85     test "allows to force-follow another user" do
  86       admin = insert(:user, info: %{is_admin: true})
  87       user = insert(:user)
  88       follower = insert(:user)
  89
  90       build_conn()
  91       |> assign(:user, admin)
  92       |> put_req_header("accept", "application/json")
  93       |> post("/api/pleroma/admin/users/follow", %{
  94         "follower" => follower.nickname,
  95         "followed" => user.nickname
  96       })
  97
  98       user = User.get_cached_by_id(user.id)
  99       follower = User.get_cached_by_id(follower.id)
 100
 101       assert User.following?(follower, user)
 102     end
 103   end
 104
 105   describe "/api/pleroma/admin/users/unfollow" do
 106     test "allows to force-unfollow another user" do
 107       admin = insert(:user, info: %{is_admin: true})
 108       user = insert(:user)
 109       follower = insert(:user)
 110
 111       User.follow(follower, user)
 112
 113       build_conn()
 114       |> assign(:user, admin)
 115       |> put_req_header("accept", "application/json")
 116       |> post("/api/pleroma/admin/users/unfollow", %{
 117         "follower" => follower.nickname,
 118         "followed" => user.nickname
 119       })
 120
 121       user = User.get_cached_by_id(user.id)
 122       follower = User.get_cached_by_id(follower.id)
 123
 124       refute User.following?(follower, user)
 125     end
 126   end
 127
 128   describe "PUT /api/pleroma/admin/users/tag" do
 129     setup do
 130       admin = insert(:user, info: %{is_admin: true})
 131       user1 = insert(:user, %{tags: ["x"]})
 132       user2 = insert(:user, %{tags: ["y"]})
 133       user3 = insert(:user, %{tags: ["unchanged"]})
 134
 135       conn =
 136         build_conn()
 137         |> assign(:user, admin)
 138         |> put_req_header("accept", "application/json")
 139         |> put(
 140           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 141             user2.nickname
 142           }&tags[]=foo&tags[]=bar"
 143         )
 144
 145       %{conn: conn, user1: user1, user2: user2, user3: user3}
 146     end
 147
 148     test "it appends specified tags to users with specified nicknames", %{
 149       conn: conn,
 150       user1: user1,
 151       user2: user2
 152     } do
 153       assert json_response(conn, :no_content)
 154       assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
 155       assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
 156     end
 157
 158     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 159       assert json_response(conn, :no_content)
 160       assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
 161     end
 162   end
 163
 164   describe "DELETE /api/pleroma/admin/users/tag" do
 165     setup do
 166       admin = insert(:user, info: %{is_admin: true})
 167       user1 = insert(:user, %{tags: ["x"]})
 168       user2 = insert(:user, %{tags: ["y", "z"]})
 169       user3 = insert(:user, %{tags: ["unchanged"]})
 170
 171       conn =
 172         build_conn()
 173         |> assign(:user, admin)
 174         |> put_req_header("accept", "application/json")
 175         |> delete(
 176           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 177             user2.nickname
 178           }&tags[]=x&tags[]=z"
 179         )
 180
 181       %{conn: conn, user1: user1, user2: user2, user3: user3}
 182     end
 183
 184     test "it removes specified tags from users with specified nicknames", %{
 185       conn: conn,
 186       user1: user1,
 187       user2: user2
 188     } do
 189       assert json_response(conn, :no_content)
 190       assert User.get_cached_by_id(user1.id).tags == []
 191       assert User.get_cached_by_id(user2.id).tags == ["y"]
 192     end
 193
 194     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 195       assert json_response(conn, :no_content)
 196       assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
 197     end
 198   end
 199
 200   describe "/api/pleroma/admin/users/:nickname/permission_group" do
 201     test "GET is giving user_info" do
 202       admin = insert(:user, info: %{is_admin: true})
 203
 204       conn =
 205         build_conn()
 206         |> assign(:user, admin)
 207         |> put_req_header("accept", "application/json")
 208         |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
 209
 210       assert json_response(conn, 200) == %{
 211                "is_admin" => true,
 212                "is_moderator" => false
 213              }
 214     end
 215
 216     test "/:right POST, can add to a permission group" do
 217       admin = insert(:user, info: %{is_admin: true})
 218       user = insert(:user)
 219
 220       conn =
 221         build_conn()
 222         |> assign(:user, admin)
 223         |> put_req_header("accept", "application/json")
 224         |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 225
 226       assert json_response(conn, 200) == %{
 227                "is_admin" => true
 228              }
 229     end
 230
 231     test "/:right DELETE, can remove from a permission group" do
 232       admin = insert(:user, info: %{is_admin: true})
 233       user = insert(:user, info: %{is_admin: true})
 234
 235       conn =
 236         build_conn()
 237         |> assign(:user, admin)
 238         |> put_req_header("accept", "application/json")
 239         |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 240
 241       assert json_response(conn, 200) == %{
 242                "is_admin" => false
 243              }
 244     end
 245   end
 246
 247   describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
 248     setup %{conn: conn} do
 249       admin = insert(:user, info: %{is_admin: true})
 250
 251       conn =
 252         conn
 253         |> assign(:user, admin)
 254         |> put_req_header("accept", "application/json")
 255
 256       %{conn: conn}
 257     end
 258
 259     test "deactivates the user", %{conn: conn} do
 260       user = insert(:user)
 261
 262       conn =
 263         conn
 264         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
 265
 266       user = User.get_cached_by_id(user.id)
 267       assert user.info.deactivated == true
 268       assert json_response(conn, :no_content)
 269     end
 270
 271     test "activates the user", %{conn: conn} do
 272       user = insert(:user, info: %{deactivated: true})
 273
 274       conn =
 275         conn
 276         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})
 277
 278       user = User.get_cached_by_id(user.id)
 279       assert user.info.deactivated == false
 280       assert json_response(conn, :no_content)
 281     end
 282
 283     test "returns 403 when requested by a non-admin", %{conn: conn} do
 284       user = insert(:user)
 285
 286       conn =
 287         conn
 288         |> assign(:user, user)
 289         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
 290
 291       assert json_response(conn, :forbidden)
 292     end
 293   end
 294
 295   describe "POST /api/pleroma/admin/email_invite, with valid config" do
 296     setup do
 297       [user: insert(:user, info: %{is_admin: true})]
 298     end
 299
 300     clear_config([:instance, :registrations_open]) do
 301       Pleroma.Config.put([:instance, :registrations_open], false)
 302     end
 303
 304     clear_config([:instance, :invites_enabled]) do
 305       Pleroma.Config.put([:instance, :invites_enabled], true)
 306     end
 307
 308     test "sends invitation and returns 204", %{conn: conn, user: user} do
 309       recipient_email = "foo@bar.com"
 310       recipient_name = "J. D."
 311
 312       conn =
 313         conn
 314         |> assign(:user, user)
 315         |> post(
 316           "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
 317         )
 318
 319       assert json_response(conn, :no_content)
 320
 321       token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
 322       assert token_record
 323       refute token_record.used
 324
 325       notify_email = Pleroma.Config.get([:instance, :notify_email])
 326       instance_name = Pleroma.Config.get([:instance, :name])
 327
 328       email =
 329         Pleroma.Emails.UserEmail.user_invitation_email(
 330           user,
 331           token_record,
 332           recipient_email,
 333           recipient_name
 334         )
 335
 336       Swoosh.TestAssertions.assert_email_sent(
 337         from: {instance_name, notify_email},
 338         to: {recipient_name, recipient_email},
 339         html_body: email.html_body
 340       )
 341     end
 342
 343     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 344       non_admin_user = insert(:user)
 345
 346       conn =
 347         conn
 348         |> assign(:user, non_admin_user)
 349         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 350
 351       assert json_response(conn, :forbidden)
 352     end
 353   end
 354
 355   describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
 356     setup do
 357       [user: insert(:user, info: %{is_admin: true})]
 358     end
 359
 360     clear_config([:instance, :registrations_open])
 361     clear_config([:instance, :invites_enabled])
 362
 363     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 364       Pleroma.Config.put([:instance, :registrations_open], false)
 365       Pleroma.Config.put([:instance, :invites_enabled], false)
 366
 367       conn =
 368         conn
 369         |> assign(:user, user)
 370         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 371
 372       assert json_response(conn, :internal_server_error)
 373     end
 374
 375     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 376       Pleroma.Config.put([:instance, :registrations_open], true)
 377       Pleroma.Config.put([:instance, :invites_enabled], true)
 378
 379       conn =
 380         conn
 381         |> assign(:user, user)
 382         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 383
 384       assert json_response(conn, :internal_server_error)
 385     end
 386   end
 387
 388   test "/api/pleroma/admin/users/invite_token" do
 389     admin = insert(:user, info: %{is_admin: true})
 390
 391     conn =
 392       build_conn()
 393       |> assign(:user, admin)
 394       |> put_req_header("accept", "application/json")
 395       |> get("/api/pleroma/admin/users/invite_token")
 396
 397     assert conn.status == 200
 398   end
 399
 400   test "/api/pleroma/admin/users/:nickname/password_reset" do
 401     admin = insert(:user, info: %{is_admin: true})
 402     user = insert(:user)
 403
 404     conn =
 405       build_conn()
 406       |> assign(:user, admin)
 407       |> put_req_header("accept", "application/json")
 408       |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
 409
 410     assert conn.status == 200
 411   end
 412
 413   describe "GET /api/pleroma/admin/users" do
 414     setup do
 415       admin = insert(:user, info: %{is_admin: true})
 416
 417       conn =
 418         build_conn()
 419         |> assign(:user, admin)
 420
 421       {:ok, conn: conn, admin: admin}
 422     end
 423
 424     test "renders users array for the first page", %{conn: conn, admin: admin} do
 425       user = insert(:user, local: false, tags: ["foo", "bar"])
 426       conn = get(conn, "/api/pleroma/admin/users?page=1")
 427
 428       users =
 429         [
 430           %{
 431             "deactivated" => admin.info.deactivated,
 432             "id" => admin.id,
 433             "nickname" => admin.nickname,
 434             "roles" => %{"admin" => true, "moderator" => false},
 435             "local" => true,
 436             "tags" => [],
 437             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 438             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 439           },
 440           %{
 441             "deactivated" => user.info.deactivated,
 442             "id" => user.id,
 443             "nickname" => user.nickname,
 444             "roles" => %{"admin" => false, "moderator" => false},
 445             "local" => false,
 446             "tags" => ["foo", "bar"],
 447             "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 448             "display_name" => HTML.strip_tags(user.name || user.nickname)
 449           }
 450         ]
 451         |> Enum.sort_by(& &1["nickname"])
 452
 453       assert json_response(conn, 200) == %{
 454                "count" => 2,
 455                "page_size" => 50,
 456                "users" => users
 457              }
 458     end
 459
 460     test "renders empty array for the second page", %{conn: conn} do
 461       insert(:user)
 462
 463       conn = get(conn, "/api/pleroma/admin/users?page=2")
 464
 465       assert json_response(conn, 200) == %{
 466                "count" => 2,
 467                "page_size" => 50,
 468                "users" => []
 469              }
 470     end
 471
 472     test "regular search", %{conn: conn} do
 473       user = insert(:user, nickname: "bob")
 474
 475       conn = get(conn, "/api/pleroma/admin/users?query=bo")
 476
 477       assert json_response(conn, 200) == %{
 478                "count" => 1,
 479                "page_size" => 50,
 480                "users" => [
 481                  %{
 482                    "deactivated" => user.info.deactivated,
 483                    "id" => user.id,
 484                    "nickname" => user.nickname,
 485                    "roles" => %{"admin" => false, "moderator" => false},
 486                    "local" => true,
 487                    "tags" => [],
 488                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 489                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 490                  }
 491                ]
 492              }
 493     end
 494
 495     test "search by domain", %{conn: conn} do
 496       user = insert(:user, nickname: "nickname@domain.com")
 497       insert(:user)
 498
 499       conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
 500
 501       assert json_response(conn, 200) == %{
 502                "count" => 1,
 503                "page_size" => 50,
 504                "users" => [
 505                  %{
 506                    "deactivated" => user.info.deactivated,
 507                    "id" => user.id,
 508                    "nickname" => user.nickname,
 509                    "roles" => %{"admin" => false, "moderator" => false},
 510                    "local" => true,
 511                    "tags" => [],
 512                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 513                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 514                  }
 515                ]
 516              }
 517     end
 518
 519     test "search by full nickname", %{conn: conn} do
 520       user = insert(:user, nickname: "nickname@domain.com")
 521       insert(:user)
 522
 523       conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
 524
 525       assert json_response(conn, 200) == %{
 526                "count" => 1,
 527                "page_size" => 50,
 528                "users" => [
 529                  %{
 530                    "deactivated" => user.info.deactivated,
 531                    "id" => user.id,
 532                    "nickname" => user.nickname,
 533                    "roles" => %{"admin" => false, "moderator" => false},
 534                    "local" => true,
 535                    "tags" => [],
 536                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 537                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 538                  }
 539                ]
 540              }
 541     end
 542
 543     test "search by display name", %{conn: conn} do
 544       user = insert(:user, name: "Display name")
 545       insert(:user)
 546
 547       conn = get(conn, "/api/pleroma/admin/users?name=display")
 548
 549       assert json_response(conn, 200) == %{
 550                "count" => 1,
 551                "page_size" => 50,
 552                "users" => [
 553                  %{
 554                    "deactivated" => user.info.deactivated,
 555                    "id" => user.id,
 556                    "nickname" => user.nickname,
 557                    "roles" => %{"admin" => false, "moderator" => false},
 558                    "local" => true,
 559                    "tags" => [],
 560                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 561                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 562                  }
 563                ]
 564              }
 565     end
 566
 567     test "search by email", %{conn: conn} do
 568       user = insert(:user, email: "email@example.com")
 569       insert(:user)
 570
 571       conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
 572
 573       assert json_response(conn, 200) == %{
 574                "count" => 1,
 575                "page_size" => 50,
 576                "users" => [
 577                  %{
 578                    "deactivated" => user.info.deactivated,
 579                    "id" => user.id,
 580                    "nickname" => user.nickname,
 581                    "roles" => %{"admin" => false, "moderator" => false},
 582                    "local" => true,
 583                    "tags" => [],
 584                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 585                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 586                  }
 587                ]
 588              }
 589     end
 590
 591     test "regular search with page size", %{conn: conn} do
 592       user = insert(:user, nickname: "aalice")
 593       user2 = insert(:user, nickname: "alice")
 594
 595       conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 596
 597       assert json_response(conn1, 200) == %{
 598                "count" => 2,
 599                "page_size" => 1,
 600                "users" => [
 601                  %{
 602                    "deactivated" => user.info.deactivated,
 603                    "id" => user.id,
 604                    "nickname" => user.nickname,
 605                    "roles" => %{"admin" => false, "moderator" => false},
 606                    "local" => true,
 607                    "tags" => [],
 608                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 609                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 610                  }
 611                ]
 612              }
 613
 614       conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 615
 616       assert json_response(conn2, 200) == %{
 617                "count" => 2,
 618                "page_size" => 1,
 619                "users" => [
 620                  %{
 621                    "deactivated" => user2.info.deactivated,
 622                    "id" => user2.id,
 623                    "nickname" => user2.nickname,
 624                    "roles" => %{"admin" => false, "moderator" => false},
 625                    "local" => true,
 626                    "tags" => [],
 627                    "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
 628                    "display_name" => HTML.strip_tags(user2.name || user2.nickname)
 629                  }
 630                ]
 631              }
 632     end
 633
 634     test "only local users" do
 635       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 636       user = insert(:user, nickname: "bob")
 637
 638       insert(:user, nickname: "bobb", local: false)
 639
 640       conn =
 641         build_conn()
 642         |> assign(:user, admin)
 643         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 644
 645       assert json_response(conn, 200) == %{
 646                "count" => 1,
 647                "page_size" => 50,
 648                "users" => [
 649                  %{
 650                    "deactivated" => user.info.deactivated,
 651                    "id" => user.id,
 652                    "nickname" => user.nickname,
 653                    "roles" => %{"admin" => false, "moderator" => false},
 654                    "local" => true,
 655                    "tags" => [],
 656                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 657                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 658                  }
 659                ]
 660              }
 661     end
 662
 663     test "only local users with no query", %{admin: old_admin} do
 664       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 665       user = insert(:user, nickname: "bob")
 666
 667       insert(:user, nickname: "bobb", local: false)
 668
 669       conn =
 670         build_conn()
 671         |> assign(:user, admin)
 672         |> get("/api/pleroma/admin/users?filters=local")
 673
 674       users =
 675         [
 676           %{
 677             "deactivated" => user.info.deactivated,
 678             "id" => user.id,
 679             "nickname" => user.nickname,
 680             "roles" => %{"admin" => false, "moderator" => false},
 681             "local" => true,
 682             "tags" => [],
 683             "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 684             "display_name" => HTML.strip_tags(user.name || user.nickname)
 685           },
 686           %{
 687             "deactivated" => admin.info.deactivated,
 688             "id" => admin.id,
 689             "nickname" => admin.nickname,
 690             "roles" => %{"admin" => true, "moderator" => false},
 691             "local" => true,
 692             "tags" => [],
 693             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 694             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 695           },
 696           %{
 697             "deactivated" => false,
 698             "id" => old_admin.id,
 699             "local" => true,
 700             "nickname" => old_admin.nickname,
 701             "roles" => %{"admin" => true, "moderator" => false},
 702             "tags" => [],
 703             "avatar" => User.avatar_url(old_admin) |> MediaProxy.url(),
 704             "display_name" => HTML.strip_tags(old_admin.name || old_admin.nickname)
 705           }
 706         ]
 707         |> Enum.sort_by(& &1["nickname"])
 708
 709       assert json_response(conn, 200) == %{
 710                "count" => 3,
 711                "page_size" => 50,
 712                "users" => users
 713              }
 714     end
 715
 716     test "load only admins", %{conn: conn, admin: admin} do
 717       second_admin = insert(:user, info: %{is_admin: true})
 718       insert(:user)
 719       insert(:user)
 720
 721       conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
 722
 723       users =
 724         [
 725           %{
 726             "deactivated" => false,
 727             "id" => admin.id,
 728             "nickname" => admin.nickname,
 729             "roles" => %{"admin" => true, "moderator" => false},
 730             "local" => admin.local,
 731             "tags" => [],
 732             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 733             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 734           },
 735           %{
 736             "deactivated" => false,
 737             "id" => second_admin.id,
 738             "nickname" => second_admin.nickname,
 739             "roles" => %{"admin" => true, "moderator" => false},
 740             "local" => second_admin.local,
 741             "tags" => [],
 742             "avatar" => User.avatar_url(second_admin) |> MediaProxy.url(),
 743             "display_name" => HTML.strip_tags(second_admin.name || second_admin.nickname)
 744           }
 745         ]
 746         |> Enum.sort_by(& &1["nickname"])
 747
 748       assert json_response(conn, 200) == %{
 749                "count" => 2,
 750                "page_size" => 50,
 751                "users" => users
 752              }
 753     end
 754
 755     test "load only moderators", %{conn: conn} do
 756       moderator = insert(:user, info: %{is_moderator: true})
 757       insert(:user)
 758       insert(:user)
 759
 760       conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
 761
 762       assert json_response(conn, 200) == %{
 763                "count" => 1,
 764                "page_size" => 50,
 765                "users" => [
 766                  %{
 767                    "deactivated" => false,
 768                    "id" => moderator.id,
 769                    "nickname" => moderator.nickname,
 770                    "roles" => %{"admin" => false, "moderator" => true},
 771                    "local" => moderator.local,
 772                    "tags" => [],
 773                    "avatar" => User.avatar_url(moderator) |> MediaProxy.url(),
 774                    "display_name" => HTML.strip_tags(moderator.name || moderator.nickname)
 775                  }
 776                ]
 777              }
 778     end
 779
 780     test "load users with tags list", %{conn: conn} do
 781       user1 = insert(:user, tags: ["first"])
 782       user2 = insert(:user, tags: ["second"])
 783       insert(:user)
 784       insert(:user)
 785
 786       conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
 787
 788       users =
 789         [
 790           %{
 791             "deactivated" => false,
 792             "id" => user1.id,
 793             "nickname" => user1.nickname,
 794             "roles" => %{"admin" => false, "moderator" => false},
 795             "local" => user1.local,
 796             "tags" => ["first"],
 797             "avatar" => User.avatar_url(user1) |> MediaProxy.url(),
 798             "display_name" => HTML.strip_tags(user1.name || user1.nickname)
 799           },
 800           %{
 801             "deactivated" => false,
 802             "id" => user2.id,
 803             "nickname" => user2.nickname,
 804             "roles" => %{"admin" => false, "moderator" => false},
 805             "local" => user2.local,
 806             "tags" => ["second"],
 807             "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
 808             "display_name" => HTML.strip_tags(user2.name || user2.nickname)
 809           }
 810         ]
 811         |> Enum.sort_by(& &1["nickname"])
 812
 813       assert json_response(conn, 200) == %{
 814                "count" => 2,
 815                "page_size" => 50,
 816                "users" => users
 817              }
 818     end
 819
 820     test "it works with multiple filters" do
 821       admin = insert(:user, nickname: "john", info: %{is_admin: true})
 822       user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
 823
 824       insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
 825       insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
 826
 827       conn =
 828         build_conn()
 829         |> assign(:user, admin)
 830         |> get("/api/pleroma/admin/users?filters=deactivated,external")
 831
 832       assert json_response(conn, 200) == %{
 833                "count" => 1,
 834                "page_size" => 50,
 835                "users" => [
 836                  %{
 837                    "deactivated" => user.info.deactivated,
 838                    "id" => user.id,
 839                    "nickname" => user.nickname,
 840                    "roles" => %{"admin" => false, "moderator" => false},
 841                    "local" => user.local,
 842                    "tags" => [],
 843                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 844                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 845                  }
 846                ]
 847              }
 848     end
 849   end
 850
 851   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
 852     admin = insert(:user, info: %{is_admin: true})
 853     user = insert(:user)
 854
 855     conn =
 856       build_conn()
 857       |> assign(:user, admin)
 858       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
 859
 860     assert json_response(conn, 200) ==
 861              %{
 862                "deactivated" => !user.info.deactivated,
 863                "id" => user.id,
 864                "nickname" => user.nickname,
 865                "roles" => %{"admin" => false, "moderator" => false},
 866                "local" => true,
 867                "tags" => [],
 868                "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 869                "display_name" => HTML.strip_tags(user.name || user.nickname)
 870              }
 871   end
 872
 873   describe "GET /api/pleroma/admin/users/invite_token" do
 874     setup do
 875       admin = insert(:user, info: %{is_admin: true})
 876
 877       conn =
 878         build_conn()
 879         |> assign(:user, admin)
 880
 881       {:ok, conn: conn}
 882     end
 883
 884     test "without options", %{conn: conn} do
 885       conn = get(conn, "/api/pleroma/admin/users/invite_token")
 886
 887       token = json_response(conn, 200)
 888       invite = UserInviteToken.find_by_token!(token)
 889       refute invite.used
 890       refute invite.expires_at
 891       refute invite.max_use
 892       assert invite.invite_type == "one_time"
 893     end
 894
 895     test "with expires_at", %{conn: conn} do
 896       conn =
 897         get(conn, "/api/pleroma/admin/users/invite_token", %{
 898           "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
 899         })
 900
 901       token = json_response(conn, 200)
 902       invite = UserInviteToken.find_by_token!(token)
 903
 904       refute invite.used
 905       assert invite.expires_at == Date.utc_today()
 906       refute invite.max_use
 907       assert invite.invite_type == "date_limited"
 908     end
 909
 910     test "with max_use", %{conn: conn} do
 911       conn =
 912         get(conn, "/api/pleroma/admin/users/invite_token", %{
 913           "invite" => %{"max_use" => 150}
 914         })
 915
 916       token = json_response(conn, 200)
 917       invite = UserInviteToken.find_by_token!(token)
 918       refute invite.used
 919       refute invite.expires_at
 920       assert invite.max_use == 150
 921       assert invite.invite_type == "reusable"
 922     end
 923
 924     test "with max use and expires_at", %{conn: conn} do
 925       conn =
 926         get(conn, "/api/pleroma/admin/users/invite_token", %{
 927           "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
 928         })
 929
 930       token = json_response(conn, 200)
 931       invite = UserInviteToken.find_by_token!(token)
 932       refute invite.used
 933       assert invite.expires_at == Date.utc_today()
 934       assert invite.max_use == 150
 935       assert invite.invite_type == "reusable_date_limited"
 936     end
 937   end
 938
 939   describe "GET /api/pleroma/admin/users/invites" do
 940     setup do
 941       admin = insert(:user, info: %{is_admin: true})
 942
 943       conn =
 944         build_conn()
 945         |> assign(:user, admin)
 946
 947       {:ok, conn: conn}
 948     end
 949
 950     test "no invites", %{conn: conn} do
 951       conn = get(conn, "/api/pleroma/admin/users/invites")
 952
 953       assert json_response(conn, 200) == %{"invites" => []}
 954     end
 955
 956     test "with invite", %{conn: conn} do
 957       {:ok, invite} = UserInviteToken.create_invite()
 958
 959       conn = get(conn, "/api/pleroma/admin/users/invites")
 960
 961       assert json_response(conn, 200) == %{
 962                "invites" => [
 963                  %{
 964                    "expires_at" => nil,
 965                    "id" => invite.id,
 966                    "invite_type" => "one_time",
 967                    "max_use" => nil,
 968                    "token" => invite.token,
 969                    "used" => false,
 970                    "uses" => 0
 971                  }
 972                ]
 973              }
 974     end
 975   end
 976
 977   describe "POST /api/pleroma/admin/users/revoke_invite" do
 978     test "with token" do
 979       admin = insert(:user, info: %{is_admin: true})
 980       {:ok, invite} = UserInviteToken.create_invite()
 981
 982       conn =
 983         build_conn()
 984         |> assign(:user, admin)
 985         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
 986
 987       assert json_response(conn, 200) == %{
 988                "expires_at" => nil,
 989                "id" => invite.id,
 990                "invite_type" => "one_time",
 991                "max_use" => nil,
 992                "token" => invite.token,
 993                "used" => true,
 994                "uses" => 0
 995              }
 996     end
 997
 998     test "with invalid token" do
 999       admin = insert(:user, info: %{is_admin: true})
1000
1001       conn =
1002         build_conn()
1003         |> assign(:user, admin)
1004         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
1005
1006       assert json_response(conn, :not_found) == "Not found"
1007     end
1008   end
1009
1010   describe "GET /api/pleroma/admin/reports/:id" do
1011     setup %{conn: conn} do
1012       admin = insert(:user, info: %{is_admin: true})
1013
1014       %{conn: assign(conn, :user, admin)}
1015     end
1016
1017     test "returns report by its id", %{conn: conn} do
1018       [reporter, target_user] = insert_pair(:user)
1019       activity = insert(:note_activity, user: target_user)
1020
1021       {:ok, %{id: report_id}} =
1022         CommonAPI.report(reporter, %{
1023           "account_id" => target_user.id,
1024           "comment" => "I feel offended",
1025           "status_ids" => [activity.id]
1026         })
1027
1028       response =
1029         conn
1030         |> get("/api/pleroma/admin/reports/#{report_id}")
1031         |> json_response(:ok)
1032
1033       assert response["id"] == report_id
1034     end
1035
1036     test "returns 404 when report id is invalid", %{conn: conn} do
1037       conn = get(conn, "/api/pleroma/admin/reports/test")
1038
1039       assert json_response(conn, :not_found) == "Not found"
1040     end
1041   end
1042
1043   describe "PUT /api/pleroma/admin/reports/:id" do
1044     setup %{conn: conn} do
1045       admin = insert(:user, info: %{is_admin: true})
1046       [reporter, target_user] = insert_pair(:user)
1047       activity = insert(:note_activity, user: target_user)
1048
1049       {:ok, %{id: report_id}} =
1050         CommonAPI.report(reporter, %{
1051           "account_id" => target_user.id,
1052           "comment" => "I feel offended",
1053           "status_ids" => [activity.id]
1054         })
1055
1056       %{conn: assign(conn, :user, admin), id: report_id}
1057     end
1058
1059     test "mark report as resolved", %{conn: conn, id: id} do
1060       response =
1061         conn
1062         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1063         |> json_response(:ok)
1064
1065       assert response["state"] == "resolved"
1066     end
1067
1068     test "closes report", %{conn: conn, id: id} do
1069       response =
1070         conn
1071         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1072         |> json_response(:ok)
1073
1074       assert response["state"] == "closed"
1075     end
1076
1077     test "returns 400 when state is unknown", %{conn: conn, id: id} do
1078       conn =
1079         conn
1080         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1081
1082       assert json_response(conn, :bad_request) == "Unsupported state"
1083     end
1084
1085     test "returns 404 when report is not exist", %{conn: conn} do
1086       conn =
1087         conn
1088         |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1089
1090       assert json_response(conn, :not_found) == "Not found"
1091     end
1092   end
1093
1094   describe "GET /api/pleroma/admin/reports" do
1095     setup %{conn: conn} do
1096       admin = insert(:user, info: %{is_admin: true})
1097
1098       %{conn: assign(conn, :user, admin)}
1099     end
1100
1101     test "returns empty response when no reports created", %{conn: conn} do
1102       response =
1103         conn
1104         |> get("/api/pleroma/admin/reports")
1105         |> json_response(:ok)
1106
1107       assert Enum.empty?(response["reports"])
1108     end
1109
1110     test "returns reports", %{conn: conn} do
1111       [reporter, target_user] = insert_pair(:user)
1112       activity = insert(:note_activity, user: target_user)
1113
1114       {:ok, %{id: report_id}} =
1115         CommonAPI.report(reporter, %{
1116           "account_id" => target_user.id,
1117           "comment" => "I feel offended",
1118           "status_ids" => [activity.id]
1119         })
1120
1121       response =
1122         conn
1123         |> get("/api/pleroma/admin/reports")
1124         |> json_response(:ok)
1125
1126       [report] = response["reports"]
1127
1128       assert length(response["reports"]) == 1
1129       assert report["id"] == report_id
1130     end
1131
1132     test "returns reports with specified state", %{conn: conn} do
1133       [reporter, target_user] = insert_pair(:user)
1134       activity = insert(:note_activity, user: target_user)
1135
1136       {:ok, %{id: first_report_id}} =
1137         CommonAPI.report(reporter, %{
1138           "account_id" => target_user.id,
1139           "comment" => "I feel offended",
1140           "status_ids" => [activity.id]
1141         })
1142
1143       {:ok, %{id: second_report_id}} =
1144         CommonAPI.report(reporter, %{
1145           "account_id" => target_user.id,
1146           "comment" => "I don't like this user"
1147         })
1148
1149       CommonAPI.update_report_state(second_report_id, "closed")
1150
1151       response =
1152         conn
1153         |> get("/api/pleroma/admin/reports", %{
1154           "state" => "open"
1155         })
1156         |> json_response(:ok)
1157
1158       [open_report] = response["reports"]
1159
1160       assert length(response["reports"]) == 1
1161       assert open_report["id"] == first_report_id
1162
1163       response =
1164         conn
1165         |> get("/api/pleroma/admin/reports", %{
1166           "state" => "closed"
1167         })
1168         |> json_response(:ok)
1169
1170       [closed_report] = response["reports"]
1171
1172       assert length(response["reports"]) == 1
1173       assert closed_report["id"] == second_report_id
1174
1175       response =
1176         conn
1177         |> get("/api/pleroma/admin/reports", %{
1178           "state" => "resolved"
1179         })
1180         |> json_response(:ok)
1181
1182       assert Enum.empty?(response["reports"])
1183     end
1184
1185     test "returns 403 when requested by a non-admin" do
1186       user = insert(:user)
1187
1188       conn =
1189         build_conn()
1190         |> assign(:user, user)
1191         |> get("/api/pleroma/admin/reports")
1192
1193       assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1194     end
1195
1196     test "returns 403 when requested by anonymous" do
1197       conn =
1198         build_conn()
1199         |> get("/api/pleroma/admin/reports")
1200
1201       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1202     end
1203   end
1204
1205   describe "POST /api/pleroma/admin/reports/:id/respond" do
1206     setup %{conn: conn} do
1207       admin = insert(:user, info: %{is_admin: true})
1208
1209       %{conn: assign(conn, :user, admin)}
1210     end
1211
1212     test "returns created dm", %{conn: conn} do
1213       [reporter, target_user] = insert_pair(:user)
1214       activity = insert(:note_activity, user: target_user)
1215
1216       {:ok, %{id: report_id}} =
1217         CommonAPI.report(reporter, %{
1218           "account_id" => target_user.id,
1219           "comment" => "I feel offended",
1220           "status_ids" => [activity.id]
1221         })
1222
1223       response =
1224         conn
1225         |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1226           "status" => "I will check it out"
1227         })
1228         |> json_response(:ok)
1229
1230       recipients = Enum.map(response["mentions"], & &1["username"])
1231
1232       assert reporter.nickname in recipients
1233       assert response["content"] == "I will check it out"
1234       assert response["visibility"] == "direct"
1235     end
1236
1237     test "returns 400 when status is missing", %{conn: conn} do
1238       conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1239
1240       assert json_response(conn, :bad_request) == "Invalid parameters"
1241     end
1242
1243     test "returns 404 when report id is invalid", %{conn: conn} do
1244       conn =
1245         post(conn, "/api/pleroma/admin/reports/test/respond", %{
1246           "status" => "foo"
1247         })
1248
1249       assert json_response(conn, :not_found) == "Not found"
1250     end
1251   end
1252
1253   describe "PUT /api/pleroma/admin/statuses/:id" do
1254     setup %{conn: conn} do
1255       admin = insert(:user, info: %{is_admin: true})
1256       activity = insert(:note_activity)
1257
1258       %{conn: assign(conn, :user, admin), id: activity.id}
1259     end
1260
1261     test "toggle sensitive flag", %{conn: conn, id: id} do
1262       response =
1263         conn
1264         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1265         |> json_response(:ok)
1266
1267       assert response["sensitive"]
1268
1269       response =
1270         conn
1271         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1272         |> json_response(:ok)
1273
1274       refute response["sensitive"]
1275     end
1276
1277     test "change visibility flag", %{conn: conn, id: id} do
1278       response =
1279         conn
1280         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1281         |> json_response(:ok)
1282
1283       assert response["visibility"] == "public"
1284
1285       response =
1286         conn
1287         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1288         |> json_response(:ok)
1289
1290       assert response["visibility"] == "private"
1291
1292       response =
1293         conn
1294         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1295         |> json_response(:ok)
1296
1297       assert response["visibility"] == "unlisted"
1298     end
1299
1300     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1301       conn =
1302         conn
1303         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1304
1305       assert json_response(conn, :bad_request) == "Unsupported visibility"
1306     end
1307   end
1308
1309   describe "DELETE /api/pleroma/admin/statuses/:id" do
1310     setup %{conn: conn} do
1311       admin = insert(:user, info: %{is_admin: true})
1312       activity = insert(:note_activity)
1313
1314       %{conn: assign(conn, :user, admin), id: activity.id}
1315     end
1316
1317     test "deletes status", %{conn: conn, id: id} do
1318       conn
1319       |> delete("/api/pleroma/admin/statuses/#{id}")
1320       |> json_response(:ok)
1321
1322       refute Activity.get_by_id(id)
1323     end
1324
1325     test "returns error when status is not exist", %{conn: conn} do
1326       conn =
1327         conn
1328         |> delete("/api/pleroma/admin/statuses/test")
1329
1330       assert json_response(conn, :bad_request) == "Could not delete"
1331     end
1332   end
1333
1334   describe "GET /api/pleroma/admin/config" do
1335     setup %{conn: conn} do
1336       admin = insert(:user, info: %{is_admin: true})
1337
1338       %{conn: assign(conn, :user, admin)}
1339     end
1340
1341     test "without any settings in db", %{conn: conn} do
1342       conn = get(conn, "/api/pleroma/admin/config")
1343
1344       assert json_response(conn, 200) == %{"configs" => []}
1345     end
1346
1347     test "with settings in db", %{conn: conn} do
1348       config1 = insert(:config)
1349       config2 = insert(:config)
1350
1351       conn = get(conn, "/api/pleroma/admin/config")
1352
1353       %{
1354         "configs" => [
1355           %{
1356             "key" => key1,
1357             "value" => _
1358           },
1359           %{
1360             "key" => key2,
1361             "value" => _
1362           }
1363         ]
1364       } = json_response(conn, 200)
1365
1366       assert key1 == config1.key
1367       assert key2 == config2.key
1368     end
1369   end
1370
1371   describe "POST /api/pleroma/admin/config" do
1372     setup %{conn: conn} do
1373       admin = insert(:user, info: %{is_admin: true})
1374
1375       temp_file = "config/test.exported_from_db.secret.exs"
1376
1377       on_exit(fn ->
1378         Application.delete_env(:pleroma, :key1)
1379         Application.delete_env(:pleroma, :key2)
1380         Application.delete_env(:pleroma, :key3)
1381         Application.delete_env(:pleroma, :key4)
1382         Application.delete_env(:pleroma, :keyaa1)
1383         Application.delete_env(:pleroma, :keyaa2)
1384         Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1385         Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1386         :ok = File.rm(temp_file)
1387       end)
1388
1389       %{conn: assign(conn, :user, admin)}
1390     end
1391
1392     clear_config([:instance, :dynamic_configuration]) do
1393       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1394     end
1395
1396     test "create new config setting in db", %{conn: conn} do
1397       conn =
1398         post(conn, "/api/pleroma/admin/config", %{
1399           configs: [
1400             %{group: "pleroma", key: "key1", value: "value1"},
1401             %{
1402               group: "ueberauth",
1403               key: "Ueberauth.Strategy.Twitter.OAuth",
1404               value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
1405             },
1406             %{
1407               group: "pleroma",
1408               key: "key2",
1409               value: %{
1410                 ":nested_1" => "nested_value1",
1411                 ":nested_2" => [
1412                   %{":nested_22" => "nested_value222"},
1413                   %{":nested_33" => %{":nested_44" => "nested_444"}}
1414                 ]
1415               }
1416             },
1417             %{
1418               group: "pleroma",
1419               key: "key3",
1420               value: [
1421                 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1422                 %{"nested_4" => true}
1423               ]
1424             },
1425             %{
1426               group: "pleroma",
1427               key: "key4",
1428               value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
1429             },
1430             %{
1431               group: "idna",
1432               key: "key5",
1433               value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1434             }
1435           ]
1436         })
1437
1438       assert json_response(conn, 200) == %{
1439                "configs" => [
1440                  %{
1441                    "group" => "pleroma",
1442                    "key" => "key1",
1443                    "value" => "value1"
1444                  },
1445                  %{
1446                    "group" => "ueberauth",
1447                    "key" => "Ueberauth.Strategy.Twitter.OAuth",
1448                    "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
1449                  },
1450                  %{
1451                    "group" => "pleroma",
1452                    "key" => "key2",
1453                    "value" => %{
1454                      ":nested_1" => "nested_value1",
1455                      ":nested_2" => [
1456                        %{":nested_22" => "nested_value222"},
1457                        %{":nested_33" => %{":nested_44" => "nested_444"}}
1458                      ]
1459                    }
1460                  },
1461                  %{
1462                    "group" => "pleroma",
1463                    "key" => "key3",
1464                    "value" => [
1465                      %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1466                      %{"nested_4" => true}
1467                    ]
1468                  },
1469                  %{
1470                    "group" => "pleroma",
1471                    "key" => "key4",
1472                    "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
1473                  },
1474                  %{
1475                    "group" => "idna",
1476                    "key" => "key5",
1477                    "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1478                  }
1479                ]
1480              }
1481
1482       assert Application.get_env(:pleroma, :key1) == "value1"
1483
1484       assert Application.get_env(:pleroma, :key2) == %{
1485                nested_1: "nested_value1",
1486                nested_2: [
1487                  %{nested_22: "nested_value222"},
1488                  %{nested_33: %{nested_44: "nested_444"}}
1489                ]
1490              }
1491
1492       assert Application.get_env(:pleroma, :key3) == [
1493                %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
1494                %{"nested_4" => true}
1495              ]
1496
1497       assert Application.get_env(:pleroma, :key4) == %{
1498                "endpoint" => "https://example.com",
1499                nested_5: :upload
1500              }
1501
1502       assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
1503     end
1504
1505     test "update config setting & delete", %{conn: conn} do
1506       config1 = insert(:config, key: "keyaa1")
1507       config2 = insert(:config, key: "keyaa2")
1508
1509       insert(:config,
1510         group: "ueberauth",
1511         key: "Ueberauth.Strategy.Microsoft.OAuth",
1512         value: :erlang.term_to_binary([])
1513       )
1514
1515       conn =
1516         post(conn, "/api/pleroma/admin/config", %{
1517           configs: [
1518             %{group: config1.group, key: config1.key, value: "another_value"},
1519             %{group: config2.group, key: config2.key, delete: "true"},
1520             %{
1521               group: "ueberauth",
1522               key: "Ueberauth.Strategy.Microsoft.OAuth",
1523               delete: "true"
1524             }
1525           ]
1526         })
1527
1528       assert json_response(conn, 200) == %{
1529                "configs" => [
1530                  %{
1531                    "group" => "pleroma",
1532                    "key" => config1.key,
1533                    "value" => "another_value"
1534                  }
1535                ]
1536              }
1537
1538       assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1539       refute Application.get_env(:pleroma, :keyaa2)
1540     end
1541
1542     test "common config example", %{conn: conn} do
1543       conn =
1544         post(conn, "/api/pleroma/admin/config", %{
1545           configs: [
1546             %{
1547               "group" => "pleroma",
1548               "key" => "Pleroma.Captcha.NotReal",
1549               "value" => [
1550                 %{"tuple" => [":enabled", false]},
1551                 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1552                 %{"tuple" => [":seconds_valid", 60]},
1553                 %{"tuple" => [":path", ""]},
1554                 %{"tuple" => [":key1", nil]},
1555                 %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}
1556               ]
1557             }
1558           ]
1559         })
1560
1561       assert json_response(conn, 200) == %{
1562                "configs" => [
1563                  %{
1564                    "group" => "pleroma",
1565                    "key" => "Pleroma.Captcha.NotReal",
1566                    "value" => [
1567                      %{"tuple" => [":enabled", false]},
1568                      %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1569                      %{"tuple" => [":seconds_valid", 60]},
1570                      %{"tuple" => [":path", ""]},
1571                      %{"tuple" => [":key1", nil]},
1572                      %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}
1573                    ]
1574                  }
1575                ]
1576              }
1577     end
1578
1579     test "tuples with more than two values", %{conn: conn} do
1580       conn =
1581         post(conn, "/api/pleroma/admin/config", %{
1582           configs: [
1583             %{
1584               "group" => "pleroma",
1585               "key" => "Pleroma.Web.Endpoint.NotReal",
1586               "value" => [
1587                 %{
1588                   "tuple" => [
1589                     ":http",
1590                     [
1591                       %{
1592                         "tuple" => [
1593                           ":key2",
1594                           [
1595                             %{
1596                               "tuple" => [
1597                                 ":_",
1598                                 [
1599                                   %{
1600                                     "tuple" => [
1601                                       "/api/v1/streaming",
1602                                       "Pleroma.Web.MastodonAPI.WebsocketHandler",
1603                                       []
1604                                     ]
1605                                   },
1606                                   %{
1607                                     "tuple" => [
1608                                       "/websocket",
1609                                       "Phoenix.Endpoint.CowboyWebSocket",
1610                                       %{
1611                                         "tuple" => [
1612                                           "Phoenix.Transports.WebSocket",
1613                                           %{
1614                                             "tuple" => [
1615                                               "Pleroma.Web.Endpoint",
1616                                               "Pleroma.Web.UserSocket",
1617                                               []
1618                                             ]
1619                                           }
1620                                         ]
1621                                       }
1622                                     ]
1623                                   },
1624                                   %{
1625                                     "tuple" => [
1626                                       ":_",
1627                                       "Phoenix.Endpoint.Cowboy2Handler",
1628                                       %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1629                                     ]
1630                                   }
1631                                 ]
1632                               ]
1633                             }
1634                           ]
1635                         ]
1636                       }
1637                     ]
1638                   ]
1639                 }
1640               ]
1641             }
1642           ]
1643         })
1644
1645       assert json_response(conn, 200) == %{
1646                "configs" => [
1647                  %{
1648                    "group" => "pleroma",
1649                    "key" => "Pleroma.Web.Endpoint.NotReal",
1650                    "value" => [
1651                      %{
1652                        "tuple" => [
1653                          ":http",
1654                          [
1655                            %{
1656                              "tuple" => [
1657                                ":key2",
1658                                [
1659                                  %{
1660                                    "tuple" => [
1661                                      ":_",
1662                                      [
1663                                        %{
1664                                          "tuple" => [
1665                                            "/api/v1/streaming",
1666                                            "Pleroma.Web.MastodonAPI.WebsocketHandler",
1667                                            []
1668                                          ]
1669                                        },
1670                                        %{
1671                                          "tuple" => [
1672                                            "/websocket",
1673                                            "Phoenix.Endpoint.CowboyWebSocket",
1674                                            %{
1675                                              "tuple" => [
1676                                                "Phoenix.Transports.WebSocket",
1677                                                %{
1678                                                  "tuple" => [
1679                                                    "Pleroma.Web.Endpoint",
1680                                                    "Pleroma.Web.UserSocket",
1681                                                    []
1682                                                  ]
1683                                                }
1684                                              ]
1685                                            }
1686                                          ]
1687                                        },
1688                                        %{
1689                                          "tuple" => [
1690                                            ":_",
1691                                            "Phoenix.Endpoint.Cowboy2Handler",
1692                                            %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1693                                          ]
1694                                        }
1695                                      ]
1696                                    ]
1697                                  }
1698                                ]
1699                              ]
1700                            }
1701                          ]
1702                        ]
1703                      }
1704                    ]
1705                  }
1706                ]
1707              }
1708     end
1709
1710     test "settings with nesting map", %{conn: conn} do
1711       conn =
1712         post(conn, "/api/pleroma/admin/config", %{
1713           configs: [
1714             %{
1715               "group" => "pleroma",
1716               "key" => ":key1",
1717               "value" => [
1718                 %{"tuple" => [":key2", "some_val"]},
1719                 %{
1720                   "tuple" => [
1721                     ":key3",
1722                     %{
1723                       ":max_options" => 20,
1724                       ":max_option_chars" => 200,
1725                       ":min_expiration" => 0,
1726                       ":max_expiration" => 31_536_000,
1727                       "nested" => %{
1728                         ":max_options" => 20,
1729                         ":max_option_chars" => 200,
1730                         ":min_expiration" => 0,
1731                         ":max_expiration" => 31_536_000
1732                       }
1733                     }
1734                   ]
1735                 }
1736               ]
1737             }
1738           ]
1739         })
1740
1741       assert json_response(conn, 200) ==
1742                %{
1743                  "configs" => [
1744                    %{
1745                      "group" => "pleroma",
1746                      "key" => ":key1",
1747                      "value" => [
1748                        %{"tuple" => [":key2", "some_val"]},
1749                        %{
1750                          "tuple" => [
1751                            ":key3",
1752                            %{
1753                              ":max_expiration" => 31_536_000,
1754                              ":max_option_chars" => 200,
1755                              ":max_options" => 20,
1756                              ":min_expiration" => 0,
1757                              "nested" => %{
1758                                ":max_expiration" => 31_536_000,
1759                                ":max_option_chars" => 200,
1760                                ":max_options" => 20,
1761                                ":min_expiration" => 0
1762                              }
1763                            }
1764                          ]
1765                        }
1766                      ]
1767                    }
1768                  ]
1769                }
1770     end
1771
1772     test "value as map", %{conn: conn} do
1773       conn =
1774         post(conn, "/api/pleroma/admin/config", %{
1775           configs: [
1776             %{
1777               "group" => "pleroma",
1778               "key" => ":key1",
1779               "value" => %{"key" => "some_val"}
1780             }
1781           ]
1782         })
1783
1784       assert json_response(conn, 200) ==
1785                %{
1786                  "configs" => [
1787                    %{
1788                      "group" => "pleroma",
1789                      "key" => ":key1",
1790                      "value" => %{"key" => "some_val"}
1791                    }
1792                  ]
1793                }
1794     end
1795
1796     test "dispatch setting", %{conn: conn} do
1797       conn =
1798         post(conn, "/api/pleroma/admin/config", %{
1799           configs: [
1800             %{
1801               "group" => "pleroma",
1802               "key" => "Pleroma.Web.Endpoint.NotReal",
1803               "value" => [
1804                 %{
1805                   "tuple" => [
1806                     ":http",
1807                     [
1808                       %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
1809                       %{"tuple" => [":dispatch", ["{:_,
1810        [
1811          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
1812          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
1813           {Phoenix.Transports.WebSocket,
1814            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
1815          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
1816        ]}"]]}
1817                     ]
1818                   ]
1819                 }
1820               ]
1821             }
1822           ]
1823         })
1824
1825       dispatch_string =
1826         "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
1827           "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
1828           "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
1829           "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
1830
1831       assert json_response(conn, 200) == %{
1832                "configs" => [
1833                  %{
1834                    "group" => "pleroma",
1835                    "key" => "Pleroma.Web.Endpoint.NotReal",
1836                    "value" => [
1837                      %{
1838                        "tuple" => [
1839                          ":http",
1840                          [
1841                            %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
1842                            %{
1843                              "tuple" => [
1844                                ":dispatch",
1845                                [
1846                                  dispatch_string
1847                                ]
1848                              ]
1849                            }
1850                          ]
1851                        ]
1852                      }
1853                    ]
1854                  }
1855                ]
1856              }
1857     end
1858
1859     test "queues key as atom", %{conn: conn} do
1860       conn =
1861         post(conn, "/api/pleroma/admin/config", %{
1862           configs: [
1863             %{
1864               "group" => "pleroma_job_queue",
1865               "key" => ":queues",
1866               "value" => [
1867                 %{"tuple" => [":federator_incoming", 50]},
1868                 %{"tuple" => [":federator_outgoing", 50]},
1869                 %{"tuple" => [":web_push", 50]},
1870                 %{"tuple" => [":mailer", 10]},
1871                 %{"tuple" => [":transmogrifier", 20]},
1872                 %{"tuple" => [":scheduled_activities", 10]},
1873                 %{"tuple" => [":background", 5]}
1874               ]
1875             }
1876           ]
1877         })
1878
1879       assert json_response(conn, 200) == %{
1880                "configs" => [
1881                  %{
1882                    "group" => "pleroma_job_queue",
1883                    "key" => ":queues",
1884                    "value" => [
1885                      %{"tuple" => [":federator_incoming", 50]},
1886                      %{"tuple" => [":federator_outgoing", 50]},
1887                      %{"tuple" => [":web_push", 50]},
1888                      %{"tuple" => [":mailer", 10]},
1889                      %{"tuple" => [":transmogrifier", 20]},
1890                      %{"tuple" => [":scheduled_activities", 10]},
1891                      %{"tuple" => [":background", 5]}
1892                    ]
1893                  }
1894                ]
1895              }
1896     end
1897
1898     test "delete part of settings by atom subkeys", %{conn: conn} do
1899       config =
1900         insert(:config,
1901           key: "keyaa1",
1902           value: :erlang.term_to_binary(subkey1: "val1", subkey2: "val2", subkey3: "val3")
1903         )
1904
1905       conn =
1906         post(conn, "/api/pleroma/admin/config", %{
1907           configs: [
1908             %{
1909               group: config.group,
1910               key: config.key,
1911               subkeys: [":subkey1", ":subkey3"],
1912               delete: "true"
1913             }
1914           ]
1915         })
1916
1917       assert(
1918         json_response(conn, 200) == %{
1919           "configs" => [
1920             %{
1921               "group" => "pleroma",
1922               "key" => "keyaa1",
1923               "value" => [%{"tuple" => [":subkey2", "val2"]}]
1924             }
1925           ]
1926         }
1927       )
1928     end
1929   end
1930
1931   describe "config mix tasks run" do
1932     setup %{conn: conn} do
1933       admin = insert(:user, info: %{is_admin: true})
1934
1935       temp_file = "config/test.exported_from_db.secret.exs"
1936
1937       Mix.shell(Mix.Shell.Quiet)
1938
1939       on_exit(fn ->
1940         Mix.shell(Mix.Shell.IO)
1941         :ok = File.rm(temp_file)
1942       end)
1943
1944       %{conn: assign(conn, :user, admin), admin: admin}
1945     end
1946
1947     clear_config([:instance, :dynamic_configuration]) do
1948       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1949     end
1950
1951     test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
1952       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
1953       conn = get(conn, "/api/pleroma/admin/config/migrate_to_db")
1954       assert json_response(conn, 200) == %{}
1955       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) > 0
1956
1957       conn =
1958         build_conn()
1959         |> assign(:user, admin)
1960         |> get("/api/pleroma/admin/config/migrate_from_db")
1961
1962       assert json_response(conn, 200) == %{}
1963       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
1964     end
1965   end
1966
1967   describe "GET /api/pleroma/admin/users/:nickname/statuses" do
1968     setup do
1969       admin = insert(:user, info: %{is_admin: true})
1970       user = insert(:user)
1971
1972       date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
1973       date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
1974       date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
1975
1976       insert(:note_activity, user: user, published: date1)
1977       insert(:note_activity, user: user, published: date2)
1978       insert(:note_activity, user: user, published: date3)
1979
1980       conn =
1981         build_conn()
1982         |> assign(:user, admin)
1983
1984       {:ok, conn: conn, user: user}
1985     end
1986
1987     test "renders user's statuses", %{conn: conn, user: user} do
1988       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
1989
1990       assert json_response(conn, 200) |> length() == 3
1991     end
1992
1993     test "renders user's statuses with a limit", %{conn: conn, user: user} do
1994       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
1995
1996       assert json_response(conn, 200) |> length() == 2
1997     end
1998
1999     test "doesn't return private statuses by default", %{conn: conn, user: user} do
2000       {:ok, _private_status} =
2001         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2002
2003       {:ok, _public_status} =
2004         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2005
2006       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2007
2008       assert json_response(conn, 200) |> length() == 4
2009     end
2010
2011     test "returns private statuses with godmode on", %{conn: conn, user: user} do
2012       {:ok, _private_status} =
2013         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2014
2015       {:ok, _public_status} =
2016         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2017
2018       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
2019
2020       assert json_response(conn, 200) |> length() == 5
2021     end
2022   end
2023 end
2024
2025 # Needed for testing
2026 defmodule Pleroma.Web.Endpoint.NotReal do
2027 end
2028
2029 defmodule Pleroma.Captcha.NotReal do
2030 end