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-2019 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   use Oban.Testing, repo: Pleroma.Repo
   8
   9   alias Pleroma.Activity
  10   alias Pleroma.HTML
  11   alias Pleroma.ModerationLog
  12   alias Pleroma.Repo
  13   alias Pleroma.ReportNote
  14   alias Pleroma.Tests.ObanHelpers
  15   alias Pleroma.User
  16   alias Pleroma.UserInviteToken
  17   alias Pleroma.Web.ActivityPub.Relay
  18   alias Pleroma.Web.CommonAPI
  19   alias Pleroma.Web.MastodonAPI.StatusView
  20   alias Pleroma.Web.MediaProxy
  21   import Pleroma.Factory
  22
  23   setup_all do
  24     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  25
  26     :ok
  27   end
  28
  29   clear_config([:auth, :enforce_oauth_admin_scope_usage]) do
  30     Pleroma.Config.put([:auth, :enforce_oauth_admin_scope_usage], false)
  31   end
  32
  33   describe "with [:auth, :enforce_oauth_admin_scope_usage]," do
  34     clear_config([:auth, :enforce_oauth_admin_scope_usage]) do
  35       Pleroma.Config.put([:auth, :enforce_oauth_admin_scope_usage], true)
  36     end
  37
  38     test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope" do
  39       user = insert(:user)
  40       admin = insert(:user, is_admin: true)
  41       url = "/api/pleroma/admin/users/#{user.nickname}"
  42
  43       good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
  44       good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
  45       good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])
  46
  47       bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
  48       bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
  49       bad_token3 = nil
  50
  51       for good_token <- [good_token1, good_token2, good_token3] do
  52         conn =
  53           build_conn()
  54           |> assign(:user, admin)
  55           |> assign(:token, good_token)
  56           |> get(url)
  57
  58         assert json_response(conn, 200)
  59       end
  60
  61       for good_token <- [good_token1, good_token2, good_token3] do
  62         conn =
  63           build_conn()
  64           |> assign(:user, nil)
  65           |> assign(:token, good_token)
  66           |> get(url)
  67
  68         assert json_response(conn, :forbidden)
  69       end
  70
  71       for bad_token <- [bad_token1, bad_token2, bad_token3] do
  72         conn =
  73           build_conn()
  74           |> assign(:user, admin)
  75           |> assign(:token, bad_token)
  76           |> get(url)
  77
  78         assert json_response(conn, :forbidden)
  79       end
  80     end
  81   end
  82
  83   describe "DELETE /api/pleroma/admin/users" do
  84     test "single user" do
  85       admin = insert(:user, is_admin: true)
  86       user = insert(:user)
  87
  88       conn =
  89         build_conn()
  90         |> assign(:user, admin)
  91         |> put_req_header("accept", "application/json")
  92         |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
  93
  94       log_entry = Repo.one(ModerationLog)
  95
  96       assert ModerationLog.get_log_entry_message(log_entry) ==
  97                "@#{admin.nickname} deleted users: @#{user.nickname}"
  98
  99       assert json_response(conn, 200) == user.nickname
 100     end
 101
 102     test "multiple users" do
 103       admin = insert(:user, is_admin: true)
 104       user_one = insert(:user)
 105       user_two = insert(:user)
 106
 107       conn =
 108         build_conn()
 109         |> assign(:user, admin)
 110         |> put_req_header("accept", "application/json")
 111         |> delete("/api/pleroma/admin/users", %{
 112           nicknames: [user_one.nickname, user_two.nickname]
 113         })
 114
 115       log_entry = Repo.one(ModerationLog)
 116
 117       assert ModerationLog.get_log_entry_message(log_entry) ==
 118                "@#{admin.nickname} deleted users: @#{user_one.nickname}, @#{user_two.nickname}"
 119
 120       response = json_response(conn, 200)
 121       assert response -- [user_one.nickname, user_two.nickname] == []
 122     end
 123   end
 124
 125   describe "/api/pleroma/admin/users" do
 126     test "Create" do
 127       admin = insert(:user, is_admin: true)
 128
 129       conn =
 130         build_conn()
 131         |> assign(:user, admin)
 132         |> put_req_header("accept", "application/json")
 133         |> post("/api/pleroma/admin/users", %{
 134           "users" => [
 135             %{
 136               "nickname" => "lain",
 137               "email" => "lain@example.org",
 138               "password" => "test"
 139             },
 140             %{
 141               "nickname" => "lain2",
 142               "email" => "lain2@example.org",
 143               "password" => "test"
 144             }
 145           ]
 146         })
 147
 148       response = json_response(conn, 200) |> Enum.map(&Map.get(&1, "type"))
 149       assert response == ["success", "success"]
 150
 151       log_entry = Repo.one(ModerationLog)
 152
 153       assert ["lain", "lain2"] -- Enum.map(log_entry.data["subjects"], & &1["nickname"]) == []
 154     end
 155
 156     test "Cannot create user with existing email" do
 157       admin = insert(:user, is_admin: true)
 158       user = insert(:user)
 159
 160       conn =
 161         build_conn()
 162         |> assign(:user, admin)
 163         |> put_req_header("accept", "application/json")
 164         |> post("/api/pleroma/admin/users", %{
 165           "users" => [
 166             %{
 167               "nickname" => "lain",
 168               "email" => user.email,
 169               "password" => "test"
 170             }
 171           ]
 172         })
 173
 174       assert json_response(conn, 409) == [
 175                %{
 176                  "code" => 409,
 177                  "data" => %{
 178                    "email" => user.email,
 179                    "nickname" => "lain"
 180                  },
 181                  "error" => "email has already been taken",
 182                  "type" => "error"
 183                }
 184              ]
 185     end
 186
 187     test "Cannot create user with existing nickname" do
 188       admin = insert(:user, is_admin: true)
 189       user = insert(:user)
 190
 191       conn =
 192         build_conn()
 193         |> assign(:user, admin)
 194         |> put_req_header("accept", "application/json")
 195         |> post("/api/pleroma/admin/users", %{
 196           "users" => [
 197             %{
 198               "nickname" => user.nickname,
 199               "email" => "someuser@plerama.social",
 200               "password" => "test"
 201             }
 202           ]
 203         })
 204
 205       assert json_response(conn, 409) == [
 206                %{
 207                  "code" => 409,
 208                  "data" => %{
 209                    "email" => "someuser@plerama.social",
 210                    "nickname" => user.nickname
 211                  },
 212                  "error" => "nickname has already been taken",
 213                  "type" => "error"
 214                }
 215              ]
 216     end
 217
 218     test "Multiple user creation works in transaction" do
 219       admin = insert(:user, is_admin: true)
 220       user = insert(:user)
 221
 222       conn =
 223         build_conn()
 224         |> assign(:user, admin)
 225         |> put_req_header("accept", "application/json")
 226         |> post("/api/pleroma/admin/users", %{
 227           "users" => [
 228             %{
 229               "nickname" => "newuser",
 230               "email" => "newuser@pleroma.social",
 231               "password" => "test"
 232             },
 233             %{
 234               "nickname" => "lain",
 235               "email" => user.email,
 236               "password" => "test"
 237             }
 238           ]
 239         })
 240
 241       assert json_response(conn, 409) == [
 242                %{
 243                  "code" => 409,
 244                  "data" => %{
 245                    "email" => user.email,
 246                    "nickname" => "lain"
 247                  },
 248                  "error" => "email has already been taken",
 249                  "type" => "error"
 250                },
 251                %{
 252                  "code" => 409,
 253                  "data" => %{
 254                    "email" => "newuser@pleroma.social",
 255                    "nickname" => "newuser"
 256                  },
 257                  "error" => "",
 258                  "type" => "error"
 259                }
 260              ]
 261
 262       assert User.get_by_nickname("newuser") === nil
 263     end
 264   end
 265
 266   describe "/api/pleroma/admin/users/:nickname" do
 267     test "Show", %{conn: conn} do
 268       admin = insert(:user, is_admin: true)
 269       user = insert(:user)
 270
 271       conn =
 272         conn
 273         |> assign(:user, admin)
 274         |> get("/api/pleroma/admin/users/#{user.nickname}")
 275
 276       expected = %{
 277         "deactivated" => false,
 278         "id" => to_string(user.id),
 279         "local" => true,
 280         "nickname" => user.nickname,
 281         "roles" => %{"admin" => false, "moderator" => false},
 282         "tags" => [],
 283         "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 284         "display_name" => HTML.strip_tags(user.name || user.nickname),
 285         "confirmation_pending" => false
 286       }
 287
 288       assert expected == json_response(conn, 200)
 289     end
 290
 291     test "when the user doesn't exist", %{conn: conn} do
 292       admin = insert(:user, is_admin: true)
 293       user = build(:user)
 294
 295       conn =
 296         conn
 297         |> assign(:user, admin)
 298         |> get("/api/pleroma/admin/users/#{user.nickname}")
 299
 300       assert "Not found" == json_response(conn, 404)
 301     end
 302   end
 303
 304   describe "/api/pleroma/admin/users/follow" do
 305     test "allows to force-follow another user" do
 306       admin = insert(:user, is_admin: true)
 307       user = insert(:user)
 308       follower = insert(:user)
 309
 310       build_conn()
 311       |> assign(:user, admin)
 312       |> put_req_header("accept", "application/json")
 313       |> post("/api/pleroma/admin/users/follow", %{
 314         "follower" => follower.nickname,
 315         "followed" => user.nickname
 316       })
 317
 318       user = User.get_cached_by_id(user.id)
 319       follower = User.get_cached_by_id(follower.id)
 320
 321       assert User.following?(follower, user)
 322
 323       log_entry = Repo.one(ModerationLog)
 324
 325       assert ModerationLog.get_log_entry_message(log_entry) ==
 326                "@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
 327     end
 328   end
 329
 330   describe "/api/pleroma/admin/users/unfollow" do
 331     test "allows to force-unfollow another user" do
 332       admin = insert(:user, is_admin: true)
 333       user = insert(:user)
 334       follower = insert(:user)
 335
 336       User.follow(follower, user)
 337
 338       build_conn()
 339       |> assign(:user, admin)
 340       |> put_req_header("accept", "application/json")
 341       |> post("/api/pleroma/admin/users/unfollow", %{
 342         "follower" => follower.nickname,
 343         "followed" => user.nickname
 344       })
 345
 346       user = User.get_cached_by_id(user.id)
 347       follower = User.get_cached_by_id(follower.id)
 348
 349       refute User.following?(follower, user)
 350
 351       log_entry = Repo.one(ModerationLog)
 352
 353       assert ModerationLog.get_log_entry_message(log_entry) ==
 354                "@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
 355     end
 356   end
 357
 358   describe "PUT /api/pleroma/admin/users/tag" do
 359     setup do
 360       admin = insert(:user, is_admin: true)
 361       user1 = insert(:user, %{tags: ["x"]})
 362       user2 = insert(:user, %{tags: ["y"]})
 363       user3 = insert(:user, %{tags: ["unchanged"]})
 364
 365       conn =
 366         build_conn()
 367         |> assign(:user, admin)
 368         |> put_req_header("accept", "application/json")
 369         |> put(
 370           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 371             user2.nickname
 372           }&tags[]=foo&tags[]=bar"
 373         )
 374
 375       %{conn: conn, admin: admin, user1: user1, user2: user2, user3: user3}
 376     end
 377
 378     test "it appends specified tags to users with specified nicknames", %{
 379       conn: conn,
 380       admin: admin,
 381       user1: user1,
 382       user2: user2
 383     } do
 384       assert json_response(conn, :no_content)
 385       assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
 386       assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
 387
 388       log_entry = Repo.one(ModerationLog)
 389
 390       users =
 391         [user1.nickname, user2.nickname]
 392         |> Enum.map(&"@#{&1}")
 393         |> Enum.join(", ")
 394
 395       tags = ["foo", "bar"] |> Enum.join(", ")
 396
 397       assert ModerationLog.get_log_entry_message(log_entry) ==
 398                "@#{admin.nickname} added tags: #{tags} to users: #{users}"
 399     end
 400
 401     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 402       assert json_response(conn, :no_content)
 403       assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
 404     end
 405   end
 406
 407   describe "DELETE /api/pleroma/admin/users/tag" do
 408     setup do
 409       admin = insert(:user, is_admin: true)
 410       user1 = insert(:user, %{tags: ["x"]})
 411       user2 = insert(:user, %{tags: ["y", "z"]})
 412       user3 = insert(:user, %{tags: ["unchanged"]})
 413
 414       conn =
 415         build_conn()
 416         |> assign(:user, admin)
 417         |> put_req_header("accept", "application/json")
 418         |> delete(
 419           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 420             user2.nickname
 421           }&tags[]=x&tags[]=z"
 422         )
 423
 424       %{conn: conn, admin: admin, user1: user1, user2: user2, user3: user3}
 425     end
 426
 427     test "it removes specified tags from users with specified nicknames", %{
 428       conn: conn,
 429       admin: admin,
 430       user1: user1,
 431       user2: user2
 432     } do
 433       assert json_response(conn, :no_content)
 434       assert User.get_cached_by_id(user1.id).tags == []
 435       assert User.get_cached_by_id(user2.id).tags == ["y"]
 436
 437       log_entry = Repo.one(ModerationLog)
 438
 439       users =
 440         [user1.nickname, user2.nickname]
 441         |> Enum.map(&"@#{&1}")
 442         |> Enum.join(", ")
 443
 444       tags = ["x", "z"] |> Enum.join(", ")
 445
 446       assert ModerationLog.get_log_entry_message(log_entry) ==
 447                "@#{admin.nickname} removed tags: #{tags} from users: #{users}"
 448     end
 449
 450     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 451       assert json_response(conn, :no_content)
 452       assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
 453     end
 454   end
 455
 456   describe "/api/pleroma/admin/users/:nickname/permission_group" do
 457     test "GET is giving user_info" do
 458       admin = insert(:user, is_admin: true)
 459
 460       conn =
 461         build_conn()
 462         |> assign(:user, admin)
 463         |> put_req_header("accept", "application/json")
 464         |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
 465
 466       assert json_response(conn, 200) == %{
 467                "is_admin" => true,
 468                "is_moderator" => false
 469              }
 470     end
 471
 472     test "/:right POST, can add to a permission group" do
 473       admin = insert(:user, is_admin: true)
 474       user = insert(:user)
 475
 476       conn =
 477         build_conn()
 478         |> assign(:user, admin)
 479         |> put_req_header("accept", "application/json")
 480         |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 481
 482       assert json_response(conn, 200) == %{
 483                "is_admin" => true
 484              }
 485
 486       log_entry = Repo.one(ModerationLog)
 487
 488       assert ModerationLog.get_log_entry_message(log_entry) ==
 489                "@#{admin.nickname} made @#{user.nickname} admin"
 490     end
 491
 492     test "/:right POST, can add to a permission group (multiple)" do
 493       admin = insert(:user, is_admin: true)
 494       user_one = insert(:user)
 495       user_two = insert(:user)
 496
 497       conn =
 498         build_conn()
 499         |> assign(:user, admin)
 500         |> put_req_header("accept", "application/json")
 501         |> post("/api/pleroma/admin/users/permission_group/admin", %{
 502           nicknames: [user_one.nickname, user_two.nickname]
 503         })
 504
 505       assert json_response(conn, 200) == %{
 506                "is_admin" => true
 507              }
 508
 509       log_entry = Repo.one(ModerationLog)
 510
 511       assert ModerationLog.get_log_entry_message(log_entry) ==
 512                "@#{admin.nickname} made @#{user_one.nickname}, @#{user_two.nickname} admin"
 513     end
 514
 515     test "/:right DELETE, can remove from a permission group" do
 516       admin = insert(:user, is_admin: true)
 517       user = insert(:user, is_admin: true)
 518
 519       conn =
 520         build_conn()
 521         |> assign(:user, admin)
 522         |> put_req_header("accept", "application/json")
 523         |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 524
 525       assert json_response(conn, 200) == %{
 526                "is_admin" => false
 527              }
 528
 529       log_entry = Repo.one(ModerationLog)
 530
 531       assert ModerationLog.get_log_entry_message(log_entry) ==
 532                "@#{admin.nickname} revoked admin role from @#{user.nickname}"
 533     end
 534
 535     test "/:right DELETE, can remove from a permission group (multiple)" do
 536       admin = insert(:user, is_admin: true)
 537       user_one = insert(:user, is_admin: true)
 538       user_two = insert(:user, is_admin: true)
 539
 540       conn =
 541         build_conn()
 542         |> assign(:user, admin)
 543         |> put_req_header("accept", "application/json")
 544         |> delete("/api/pleroma/admin/users/permission_group/admin", %{
 545           nicknames: [user_one.nickname, user_two.nickname]
 546         })
 547
 548       assert json_response(conn, 200) == %{
 549                "is_admin" => false
 550              }
 551
 552       log_entry = Repo.one(ModerationLog)
 553
 554       assert ModerationLog.get_log_entry_message(log_entry) ==
 555                "@#{admin.nickname} revoked admin role from @#{user_one.nickname}, @#{
 556                  user_two.nickname
 557                }"
 558     end
 559   end
 560
 561   describe "POST /api/pleroma/admin/email_invite, with valid config" do
 562     setup do
 563       [user: insert(:user, is_admin: true)]
 564     end
 565
 566     clear_config([:instance, :registrations_open]) do
 567       Pleroma.Config.put([:instance, :registrations_open], false)
 568     end
 569
 570     clear_config([:instance, :invites_enabled]) do
 571       Pleroma.Config.put([:instance, :invites_enabled], true)
 572     end
 573
 574     test "sends invitation and returns 204", %{conn: conn, user: user} do
 575       recipient_email = "foo@bar.com"
 576       recipient_name = "J. D."
 577
 578       conn =
 579         conn
 580         |> assign(:user, user)
 581         |> post(
 582           "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
 583         )
 584
 585       assert json_response(conn, :no_content)
 586
 587       token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
 588       assert token_record
 589       refute token_record.used
 590
 591       notify_email = Pleroma.Config.get([:instance, :notify_email])
 592       instance_name = Pleroma.Config.get([:instance, :name])
 593
 594       email =
 595         Pleroma.Emails.UserEmail.user_invitation_email(
 596           user,
 597           token_record,
 598           recipient_email,
 599           recipient_name
 600         )
 601
 602       Swoosh.TestAssertions.assert_email_sent(
 603         from: {instance_name, notify_email},
 604         to: {recipient_name, recipient_email},
 605         html_body: email.html_body
 606       )
 607     end
 608
 609     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 610       non_admin_user = insert(:user)
 611
 612       conn =
 613         conn
 614         |> assign(:user, non_admin_user)
 615         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 616
 617       assert json_response(conn, :forbidden)
 618     end
 619   end
 620
 621   describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
 622     setup do
 623       [user: insert(:user, is_admin: true)]
 624     end
 625
 626     clear_config([:instance, :registrations_open])
 627     clear_config([:instance, :invites_enabled])
 628
 629     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 630       Pleroma.Config.put([:instance, :registrations_open], false)
 631       Pleroma.Config.put([:instance, :invites_enabled], false)
 632
 633       conn =
 634         conn
 635         |> assign(:user, user)
 636         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 637
 638       assert json_response(conn, :internal_server_error)
 639     end
 640
 641     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 642       Pleroma.Config.put([:instance, :registrations_open], true)
 643       Pleroma.Config.put([:instance, :invites_enabled], true)
 644
 645       conn =
 646         conn
 647         |> assign(:user, user)
 648         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 649
 650       assert json_response(conn, :internal_server_error)
 651     end
 652   end
 653
 654   test "/api/pleroma/admin/users/:nickname/password_reset" do
 655     admin = insert(:user, is_admin: true)
 656     user = insert(:user)
 657
 658     conn =
 659       build_conn()
 660       |> assign(:user, admin)
 661       |> put_req_header("accept", "application/json")
 662       |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
 663
 664     resp = json_response(conn, 200)
 665
 666     assert Regex.match?(~r/(http:\/\/|https:\/\/)/, resp["link"])
 667   end
 668
 669   describe "GET /api/pleroma/admin/users" do
 670     setup do
 671       admin = insert(:user, is_admin: true)
 672
 673       conn =
 674         build_conn()
 675         |> assign(:user, admin)
 676
 677       {:ok, conn: conn, admin: admin}
 678     end
 679
 680     test "renders users array for the first page", %{conn: conn, admin: admin} do
 681       user = insert(:user, local: false, tags: ["foo", "bar"])
 682       conn = get(conn, "/api/pleroma/admin/users?page=1")
 683
 684       users =
 685         [
 686           %{
 687             "deactivated" => admin.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             "confirmation_pending" => false
 696           },
 697           %{
 698             "deactivated" => user.deactivated,
 699             "id" => user.id,
 700             "nickname" => user.nickname,
 701             "roles" => %{"admin" => false, "moderator" => false},
 702             "local" => false,
 703             "tags" => ["foo", "bar"],
 704             "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 705             "display_name" => HTML.strip_tags(user.name || user.nickname),
 706             "confirmation_pending" => false
 707           }
 708         ]
 709         |> Enum.sort_by(& &1["nickname"])
 710
 711       assert json_response(conn, 200) == %{
 712                "count" => 2,
 713                "page_size" => 50,
 714                "users" => users
 715              }
 716     end
 717
 718     test "renders empty array for the second page", %{conn: conn} do
 719       insert(:user)
 720
 721       conn = get(conn, "/api/pleroma/admin/users?page=2")
 722
 723       assert json_response(conn, 200) == %{
 724                "count" => 2,
 725                "page_size" => 50,
 726                "users" => []
 727              }
 728     end
 729
 730     test "regular search", %{conn: conn} do
 731       user = insert(:user, nickname: "bob")
 732
 733       conn = get(conn, "/api/pleroma/admin/users?query=bo")
 734
 735       assert json_response(conn, 200) == %{
 736                "count" => 1,
 737                "page_size" => 50,
 738                "users" => [
 739                  %{
 740                    "deactivated" => user.deactivated,
 741                    "id" => user.id,
 742                    "nickname" => user.nickname,
 743                    "roles" => %{"admin" => false, "moderator" => false},
 744                    "local" => true,
 745                    "tags" => [],
 746                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 747                    "display_name" => HTML.strip_tags(user.name || user.nickname),
 748                    "confirmation_pending" => false
 749                  }
 750                ]
 751              }
 752     end
 753
 754     test "search by domain", %{conn: conn} do
 755       user = insert(:user, nickname: "nickname@domain.com")
 756       insert(:user)
 757
 758       conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
 759
 760       assert json_response(conn, 200) == %{
 761                "count" => 1,
 762                "page_size" => 50,
 763                "users" => [
 764                  %{
 765                    "deactivated" => user.deactivated,
 766                    "id" => user.id,
 767                    "nickname" => user.nickname,
 768                    "roles" => %{"admin" => false, "moderator" => false},
 769                    "local" => true,
 770                    "tags" => [],
 771                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 772                    "display_name" => HTML.strip_tags(user.name || user.nickname),
 773                    "confirmation_pending" => false
 774                  }
 775                ]
 776              }
 777     end
 778
 779     test "search by full nickname", %{conn: conn} do
 780       user = insert(:user, nickname: "nickname@domain.com")
 781       insert(:user)
 782
 783       conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
 784
 785       assert json_response(conn, 200) == %{
 786                "count" => 1,
 787                "page_size" => 50,
 788                "users" => [
 789                  %{
 790                    "deactivated" => user.deactivated,
 791                    "id" => user.id,
 792                    "nickname" => user.nickname,
 793                    "roles" => %{"admin" => false, "moderator" => false},
 794                    "local" => true,
 795                    "tags" => [],
 796                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 797                    "display_name" => HTML.strip_tags(user.name || user.nickname),
 798                    "confirmation_pending" => false
 799                  }
 800                ]
 801              }
 802     end
 803
 804     test "search by display name", %{conn: conn} do
 805       user = insert(:user, name: "Display name")
 806       insert(:user)
 807
 808       conn = get(conn, "/api/pleroma/admin/users?name=display")
 809
 810       assert json_response(conn, 200) == %{
 811                "count" => 1,
 812                "page_size" => 50,
 813                "users" => [
 814                  %{
 815                    "deactivated" => user.deactivated,
 816                    "id" => user.id,
 817                    "nickname" => user.nickname,
 818                    "roles" => %{"admin" => false, "moderator" => false},
 819                    "local" => true,
 820                    "tags" => [],
 821                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 822                    "display_name" => HTML.strip_tags(user.name || user.nickname),
 823                    "confirmation_pending" => false
 824                  }
 825                ]
 826              }
 827     end
 828
 829     test "search by email", %{conn: conn} do
 830       user = insert(:user, email: "email@example.com")
 831       insert(:user)
 832
 833       conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
 834
 835       assert json_response(conn, 200) == %{
 836                "count" => 1,
 837                "page_size" => 50,
 838                "users" => [
 839                  %{
 840                    "deactivated" => user.deactivated,
 841                    "id" => user.id,
 842                    "nickname" => user.nickname,
 843                    "roles" => %{"admin" => false, "moderator" => false},
 844                    "local" => true,
 845                    "tags" => [],
 846                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 847                    "display_name" => HTML.strip_tags(user.name || user.nickname),
 848                    "confirmation_pending" => false
 849                  }
 850                ]
 851              }
 852     end
 853
 854     test "regular search with page size", %{conn: conn} do
 855       user = insert(:user, nickname: "aalice")
 856       user2 = insert(:user, nickname: "alice")
 857
 858       conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 859
 860       assert json_response(conn1, 200) == %{
 861                "count" => 2,
 862                "page_size" => 1,
 863                "users" => [
 864                  %{
 865                    "deactivated" => user.deactivated,
 866                    "id" => user.id,
 867                    "nickname" => user.nickname,
 868                    "roles" => %{"admin" => false, "moderator" => false},
 869                    "local" => true,
 870                    "tags" => [],
 871                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 872                    "display_name" => HTML.strip_tags(user.name || user.nickname),
 873                    "confirmation_pending" => false
 874                  }
 875                ]
 876              }
 877
 878       conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 879
 880       assert json_response(conn2, 200) == %{
 881                "count" => 2,
 882                "page_size" => 1,
 883                "users" => [
 884                  %{
 885                    "deactivated" => user2.deactivated,
 886                    "id" => user2.id,
 887                    "nickname" => user2.nickname,
 888                    "roles" => %{"admin" => false, "moderator" => false},
 889                    "local" => true,
 890                    "tags" => [],
 891                    "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
 892                    "display_name" => HTML.strip_tags(user2.name || user2.nickname),
 893                    "confirmation_pending" => false
 894                  }
 895                ]
 896              }
 897     end
 898
 899     test "only local users" do
 900       admin = insert(:user, is_admin: true, nickname: "john")
 901       user = insert(:user, nickname: "bob")
 902
 903       insert(:user, nickname: "bobb", local: false)
 904
 905       conn =
 906         build_conn()
 907         |> assign(:user, admin)
 908         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 909
 910       assert json_response(conn, 200) == %{
 911                "count" => 1,
 912                "page_size" => 50,
 913                "users" => [
 914                  %{
 915                    "deactivated" => user.deactivated,
 916                    "id" => user.id,
 917                    "nickname" => user.nickname,
 918                    "roles" => %{"admin" => false, "moderator" => false},
 919                    "local" => true,
 920                    "tags" => [],
 921                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 922                    "display_name" => HTML.strip_tags(user.name || user.nickname),
 923                    "confirmation_pending" => false
 924                  }
 925                ]
 926              }
 927     end
 928
 929     test "only local users with no query", %{admin: old_admin} do
 930       admin = insert(:user, is_admin: true, nickname: "john")
 931       user = insert(:user, nickname: "bob")
 932
 933       insert(:user, nickname: "bobb", local: false)
 934
 935       conn =
 936         build_conn()
 937         |> assign(:user, admin)
 938         |> get("/api/pleroma/admin/users?filters=local")
 939
 940       users =
 941         [
 942           %{
 943             "deactivated" => user.deactivated,
 944             "id" => user.id,
 945             "nickname" => user.nickname,
 946             "roles" => %{"admin" => false, "moderator" => false},
 947             "local" => true,
 948             "tags" => [],
 949             "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 950             "display_name" => HTML.strip_tags(user.name || user.nickname),
 951             "confirmation_pending" => false
 952           },
 953           %{
 954             "deactivated" => admin.deactivated,
 955             "id" => admin.id,
 956             "nickname" => admin.nickname,
 957             "roles" => %{"admin" => true, "moderator" => false},
 958             "local" => true,
 959             "tags" => [],
 960             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 961             "display_name" => HTML.strip_tags(admin.name || admin.nickname),
 962             "confirmation_pending" => false
 963           },
 964           %{
 965             "deactivated" => false,
 966             "id" => old_admin.id,
 967             "local" => true,
 968             "nickname" => old_admin.nickname,
 969             "roles" => %{"admin" => true, "moderator" => false},
 970             "tags" => [],
 971             "avatar" => User.avatar_url(old_admin) |> MediaProxy.url(),
 972             "display_name" => HTML.strip_tags(old_admin.name || old_admin.nickname),
 973             "confirmation_pending" => false
 974           }
 975         ]
 976         |> Enum.sort_by(& &1["nickname"])
 977
 978       assert json_response(conn, 200) == %{
 979                "count" => 3,
 980                "page_size" => 50,
 981                "users" => users
 982              }
 983     end
 984
 985     test "load only admins", %{conn: conn, admin: admin} do
 986       second_admin = insert(:user, is_admin: true)
 987       insert(:user)
 988       insert(:user)
 989
 990       conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
 991
 992       users =
 993         [
 994           %{
 995             "deactivated" => false,
 996             "id" => admin.id,
 997             "nickname" => admin.nickname,
 998             "roles" => %{"admin" => true, "moderator" => false},
 999             "local" => admin.local,
1000             "tags" => [],
1001             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
1002             "display_name" => HTML.strip_tags(admin.name || admin.nickname),
1003             "confirmation_pending" => false
1004           },
1005           %{
1006             "deactivated" => false,
1007             "id" => second_admin.id,
1008             "nickname" => second_admin.nickname,
1009             "roles" => %{"admin" => true, "moderator" => false},
1010             "local" => second_admin.local,
1011             "tags" => [],
1012             "avatar" => User.avatar_url(second_admin) |> MediaProxy.url(),
1013             "display_name" => HTML.strip_tags(second_admin.name || second_admin.nickname),
1014             "confirmation_pending" => false
1015           }
1016         ]
1017         |> Enum.sort_by(& &1["nickname"])
1018
1019       assert json_response(conn, 200) == %{
1020                "count" => 2,
1021                "page_size" => 50,
1022                "users" => users
1023              }
1024     end
1025
1026     test "load only moderators", %{conn: conn} do
1027       moderator = insert(:user, is_moderator: true)
1028       insert(:user)
1029       insert(:user)
1030
1031       conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
1032
1033       assert json_response(conn, 200) == %{
1034                "count" => 1,
1035                "page_size" => 50,
1036                "users" => [
1037                  %{
1038                    "deactivated" => false,
1039                    "id" => moderator.id,
1040                    "nickname" => moderator.nickname,
1041                    "roles" => %{"admin" => false, "moderator" => true},
1042                    "local" => moderator.local,
1043                    "tags" => [],
1044                    "avatar" => User.avatar_url(moderator) |> MediaProxy.url(),
1045                    "display_name" => HTML.strip_tags(moderator.name || moderator.nickname),
1046                    "confirmation_pending" => false
1047                  }
1048                ]
1049              }
1050     end
1051
1052     test "load users with tags list", %{conn: conn} do
1053       user1 = insert(:user, tags: ["first"])
1054       user2 = insert(:user, tags: ["second"])
1055       insert(:user)
1056       insert(:user)
1057
1058       conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
1059
1060       users =
1061         [
1062           %{
1063             "deactivated" => false,
1064             "id" => user1.id,
1065             "nickname" => user1.nickname,
1066             "roles" => %{"admin" => false, "moderator" => false},
1067             "local" => user1.local,
1068             "tags" => ["first"],
1069             "avatar" => User.avatar_url(user1) |> MediaProxy.url(),
1070             "display_name" => HTML.strip_tags(user1.name || user1.nickname),
1071             "confirmation_pending" => false
1072           },
1073           %{
1074             "deactivated" => false,
1075             "id" => user2.id,
1076             "nickname" => user2.nickname,
1077             "roles" => %{"admin" => false, "moderator" => false},
1078             "local" => user2.local,
1079             "tags" => ["second"],
1080             "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
1081             "display_name" => HTML.strip_tags(user2.name || user2.nickname),
1082             "confirmation_pending" => false
1083           }
1084         ]
1085         |> Enum.sort_by(& &1["nickname"])
1086
1087       assert json_response(conn, 200) == %{
1088                "count" => 2,
1089                "page_size" => 50,
1090                "users" => users
1091              }
1092     end
1093
1094     test "it works with multiple filters" do
1095       admin = insert(:user, nickname: "john", is_admin: true)
1096       user = insert(:user, nickname: "bob", local: false, deactivated: true)
1097
1098       insert(:user, nickname: "ken", local: true, deactivated: true)
1099       insert(:user, nickname: "bobb", local: false, deactivated: false)
1100
1101       conn =
1102         build_conn()
1103         |> assign(:user, admin)
1104         |> get("/api/pleroma/admin/users?filters=deactivated,external")
1105
1106       assert json_response(conn, 200) == %{
1107                "count" => 1,
1108                "page_size" => 50,
1109                "users" => [
1110                  %{
1111                    "deactivated" => user.deactivated,
1112                    "id" => user.id,
1113                    "nickname" => user.nickname,
1114                    "roles" => %{"admin" => false, "moderator" => false},
1115                    "local" => user.local,
1116                    "tags" => [],
1117                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1118                    "display_name" => HTML.strip_tags(user.name || user.nickname),
1119                    "confirmation_pending" => false
1120                  }
1121                ]
1122              }
1123     end
1124
1125     test "it omits relay user", %{admin: admin} do
1126       assert %User{} = Relay.get_actor()
1127
1128       conn =
1129         build_conn()
1130         |> assign(:user, admin)
1131         |> get("/api/pleroma/admin/users")
1132
1133       assert json_response(conn, 200) == %{
1134                "count" => 1,
1135                "page_size" => 50,
1136                "users" => [
1137                  %{
1138                    "deactivated" => admin.deactivated,
1139                    "id" => admin.id,
1140                    "nickname" => admin.nickname,
1141                    "roles" => %{"admin" => true, "moderator" => false},
1142                    "local" => true,
1143                    "tags" => [],
1144                    "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
1145                    "display_name" => HTML.strip_tags(admin.name || admin.nickname),
1146                    "confirmation_pending" => false
1147                  }
1148                ]
1149              }
1150     end
1151   end
1152
1153   test "PATCH /api/pleroma/admin/users/activate" do
1154     admin = insert(:user, is_admin: true)
1155     user_one = insert(:user, deactivated: true)
1156     user_two = insert(:user, deactivated: true)
1157
1158     conn =
1159       build_conn()
1160       |> assign(:user, admin)
1161       |> patch(
1162         "/api/pleroma/admin/users/activate",
1163         %{nicknames: [user_one.nickname, user_two.nickname]}
1164       )
1165
1166     response = json_response(conn, 200)
1167     assert Enum.map(response["users"], & &1["deactivated"]) == [false, false]
1168
1169     log_entry = Repo.one(ModerationLog)
1170
1171     assert ModerationLog.get_log_entry_message(log_entry) ==
1172              "@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
1173   end
1174
1175   test "PATCH /api/pleroma/admin/users/deactivate" do
1176     admin = insert(:user, is_admin: true)
1177     user_one = insert(:user, deactivated: false)
1178     user_two = insert(:user, deactivated: false)
1179
1180     conn =
1181       build_conn()
1182       |> assign(:user, admin)
1183       |> patch(
1184         "/api/pleroma/admin/users/deactivate",
1185         %{nicknames: [user_one.nickname, user_two.nickname]}
1186       )
1187
1188     response = json_response(conn, 200)
1189     assert Enum.map(response["users"], & &1["deactivated"]) == [true, true]
1190
1191     log_entry = Repo.one(ModerationLog)
1192
1193     assert ModerationLog.get_log_entry_message(log_entry) ==
1194              "@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
1195   end
1196
1197   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
1198     admin = insert(:user, is_admin: true)
1199     user = insert(:user)
1200
1201     conn =
1202       build_conn()
1203       |> assign(:user, admin)
1204       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
1205
1206     assert json_response(conn, 200) ==
1207              %{
1208                "deactivated" => !user.deactivated,
1209                "id" => user.id,
1210                "nickname" => user.nickname,
1211                "roles" => %{"admin" => false, "moderator" => false},
1212                "local" => true,
1213                "tags" => [],
1214                "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1215                "display_name" => HTML.strip_tags(user.name || user.nickname),
1216                "confirmation_pending" => false
1217              }
1218
1219     log_entry = Repo.one(ModerationLog)
1220
1221     assert ModerationLog.get_log_entry_message(log_entry) ==
1222              "@#{admin.nickname} deactivated users: @#{user.nickname}"
1223   end
1224
1225   describe "POST /api/pleroma/admin/users/invite_token" do
1226     setup do
1227       admin = insert(:user, is_admin: true)
1228
1229       conn =
1230         build_conn()
1231         |> assign(:user, admin)
1232
1233       {:ok, conn: conn}
1234     end
1235
1236     test "without options", %{conn: conn} do
1237       conn = post(conn, "/api/pleroma/admin/users/invite_token")
1238
1239       invite_json = json_response(conn, 200)
1240       invite = UserInviteToken.find_by_token!(invite_json["token"])
1241       refute invite.used
1242       refute invite.expires_at
1243       refute invite.max_use
1244       assert invite.invite_type == "one_time"
1245     end
1246
1247     test "with expires_at", %{conn: conn} do
1248       conn =
1249         post(conn, "/api/pleroma/admin/users/invite_token", %{
1250           "expires_at" => Date.to_string(Date.utc_today())
1251         })
1252
1253       invite_json = json_response(conn, 200)
1254       invite = UserInviteToken.find_by_token!(invite_json["token"])
1255
1256       refute invite.used
1257       assert invite.expires_at == Date.utc_today()
1258       refute invite.max_use
1259       assert invite.invite_type == "date_limited"
1260     end
1261
1262     test "with max_use", %{conn: conn} do
1263       conn = post(conn, "/api/pleroma/admin/users/invite_token", %{"max_use" => 150})
1264
1265       invite_json = json_response(conn, 200)
1266       invite = UserInviteToken.find_by_token!(invite_json["token"])
1267       refute invite.used
1268       refute invite.expires_at
1269       assert invite.max_use == 150
1270       assert invite.invite_type == "reusable"
1271     end
1272
1273     test "with max use and expires_at", %{conn: conn} do
1274       conn =
1275         post(conn, "/api/pleroma/admin/users/invite_token", %{
1276           "max_use" => 150,
1277           "expires_at" => Date.to_string(Date.utc_today())
1278         })
1279
1280       invite_json = json_response(conn, 200)
1281       invite = UserInviteToken.find_by_token!(invite_json["token"])
1282       refute invite.used
1283       assert invite.expires_at == Date.utc_today()
1284       assert invite.max_use == 150
1285       assert invite.invite_type == "reusable_date_limited"
1286     end
1287   end
1288
1289   describe "GET /api/pleroma/admin/users/invites" do
1290     setup do
1291       admin = insert(:user, is_admin: true)
1292
1293       conn =
1294         build_conn()
1295         |> assign(:user, admin)
1296
1297       {:ok, conn: conn}
1298     end
1299
1300     test "no invites", %{conn: conn} do
1301       conn = get(conn, "/api/pleroma/admin/users/invites")
1302
1303       assert json_response(conn, 200) == %{"invites" => []}
1304     end
1305
1306     test "with invite", %{conn: conn} do
1307       {:ok, invite} = UserInviteToken.create_invite()
1308
1309       conn = get(conn, "/api/pleroma/admin/users/invites")
1310
1311       assert json_response(conn, 200) == %{
1312                "invites" => [
1313                  %{
1314                    "expires_at" => nil,
1315                    "id" => invite.id,
1316                    "invite_type" => "one_time",
1317                    "max_use" => nil,
1318                    "token" => invite.token,
1319                    "used" => false,
1320                    "uses" => 0
1321                  }
1322                ]
1323              }
1324     end
1325   end
1326
1327   describe "POST /api/pleroma/admin/users/revoke_invite" do
1328     test "with token" do
1329       admin = insert(:user, is_admin: true)
1330       {:ok, invite} = UserInviteToken.create_invite()
1331
1332       conn =
1333         build_conn()
1334         |> assign(:user, admin)
1335         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
1336
1337       assert json_response(conn, 200) == %{
1338                "expires_at" => nil,
1339                "id" => invite.id,
1340                "invite_type" => "one_time",
1341                "max_use" => nil,
1342                "token" => invite.token,
1343                "used" => true,
1344                "uses" => 0
1345              }
1346     end
1347
1348     test "with invalid token" do
1349       admin = insert(:user, is_admin: true)
1350
1351       conn =
1352         build_conn()
1353         |> assign(:user, admin)
1354         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
1355
1356       assert json_response(conn, :not_found) == "Not found"
1357     end
1358   end
1359
1360   describe "GET /api/pleroma/admin/reports/:id" do
1361     setup %{conn: conn} do
1362       admin = insert(:user, is_admin: true)
1363
1364       %{conn: assign(conn, :user, admin)}
1365     end
1366
1367     test "returns report by its id", %{conn: conn} do
1368       [reporter, target_user] = insert_pair(:user)
1369       activity = insert(:note_activity, user: target_user)
1370
1371       {:ok, %{id: report_id}} =
1372         CommonAPI.report(reporter, %{
1373           "account_id" => target_user.id,
1374           "comment" => "I feel offended",
1375           "status_ids" => [activity.id]
1376         })
1377
1378       response =
1379         conn
1380         |> get("/api/pleroma/admin/reports/#{report_id}")
1381         |> json_response(:ok)
1382
1383       assert response["id"] == report_id
1384     end
1385
1386     test "returns 404 when report id is invalid", %{conn: conn} do
1387       conn = get(conn, "/api/pleroma/admin/reports/test")
1388
1389       assert json_response(conn, :not_found) == "Not found"
1390     end
1391   end
1392
1393   describe "PATCH /api/pleroma/admin/reports" do
1394     setup %{conn: conn} do
1395       admin = insert(:user, is_admin: true)
1396       [reporter, target_user] = insert_pair(:user)
1397       activity = insert(:note_activity, user: target_user)
1398
1399       {:ok, %{id: report_id}} =
1400         CommonAPI.report(reporter, %{
1401           "account_id" => target_user.id,
1402           "comment" => "I feel offended",
1403           "status_ids" => [activity.id]
1404         })
1405
1406       {:ok, %{id: second_report_id}} =
1407         CommonAPI.report(reporter, %{
1408           "account_id" => target_user.id,
1409           "comment" => "I feel very offended",
1410           "status_ids" => [activity.id]
1411         })
1412
1413       %{
1414         conn: assign(conn, :user, admin),
1415         id: report_id,
1416         admin: admin,
1417         second_report_id: second_report_id
1418       }
1419     end
1420
1421     test "mark report as resolved", %{conn: conn, id: id, admin: admin} do
1422       conn
1423       |> patch("/api/pleroma/admin/reports", %{
1424         "reports" => [
1425           %{"state" => "resolved", "id" => id}
1426         ]
1427       })
1428       |> json_response(:no_content)
1429
1430       activity = Activity.get_by_id(id)
1431       assert activity.data["state"] == "resolved"
1432
1433       log_entry = Repo.one(ModerationLog)
1434
1435       assert ModerationLog.get_log_entry_message(log_entry) ==
1436                "@#{admin.nickname} updated report ##{id} with 'resolved' state"
1437     end
1438
1439     test "closes report", %{conn: conn, id: id, admin: admin} do
1440       conn
1441       |> patch("/api/pleroma/admin/reports", %{
1442         "reports" => [
1443           %{"state" => "closed", "id" => id}
1444         ]
1445       })
1446       |> json_response(:no_content)
1447
1448       activity = Activity.get_by_id(id)
1449       assert activity.data["state"] == "closed"
1450
1451       log_entry = Repo.one(ModerationLog)
1452
1453       assert ModerationLog.get_log_entry_message(log_entry) ==
1454                "@#{admin.nickname} updated report ##{id} with 'closed' state"
1455     end
1456
1457     test "returns 400 when state is unknown", %{conn: conn, id: id} do
1458       conn =
1459         conn
1460         |> patch("/api/pleroma/admin/reports", %{
1461           "reports" => [
1462             %{"state" => "test", "id" => id}
1463           ]
1464         })
1465
1466       assert hd(json_response(conn, :bad_request))["error"] == "Unsupported state"
1467     end
1468
1469     test "returns 404 when report is not exist", %{conn: conn} do
1470       conn =
1471         conn
1472         |> patch("/api/pleroma/admin/reports", %{
1473           "reports" => [
1474             %{"state" => "closed", "id" => "test"}
1475           ]
1476         })
1477
1478       assert hd(json_response(conn, :bad_request))["error"] == "not_found"
1479     end
1480
1481     test "updates state of multiple reports", %{
1482       conn: conn,
1483       id: id,
1484       admin: admin,
1485       second_report_id: second_report_id
1486     } do
1487       conn
1488       |> patch("/api/pleroma/admin/reports", %{
1489         "reports" => [
1490           %{"state" => "resolved", "id" => id},
1491           %{"state" => "closed", "id" => second_report_id}
1492         ]
1493       })
1494       |> json_response(:no_content)
1495
1496       activity = Activity.get_by_id(id)
1497       second_activity = Activity.get_by_id(second_report_id)
1498       assert activity.data["state"] == "resolved"
1499       assert second_activity.data["state"] == "closed"
1500
1501       [first_log_entry, second_log_entry] = Repo.all(ModerationLog)
1502
1503       assert ModerationLog.get_log_entry_message(first_log_entry) ==
1504                "@#{admin.nickname} updated report ##{id} with 'resolved' state"
1505
1506       assert ModerationLog.get_log_entry_message(second_log_entry) ==
1507                "@#{admin.nickname} updated report ##{second_report_id} with 'closed' state"
1508     end
1509   end
1510
1511   describe "GET /api/pleroma/admin/reports" do
1512     setup %{conn: conn} do
1513       admin = insert(:user, is_admin: true)
1514
1515       %{conn: assign(conn, :user, admin)}
1516     end
1517
1518     test "returns empty response when no reports created", %{conn: conn} do
1519       response =
1520         conn
1521         |> get("/api/pleroma/admin/reports")
1522         |> json_response(:ok)
1523
1524       assert Enum.empty?(response["reports"])
1525       assert response["total"] == 0
1526     end
1527
1528     test "returns reports", %{conn: conn} do
1529       [reporter, target_user] = insert_pair(:user)
1530       activity = insert(:note_activity, user: target_user)
1531
1532       {:ok, %{id: report_id}} =
1533         CommonAPI.report(reporter, %{
1534           "account_id" => target_user.id,
1535           "comment" => "I feel offended",
1536           "status_ids" => [activity.id]
1537         })
1538
1539       response =
1540         conn
1541         |> get("/api/pleroma/admin/reports")
1542         |> json_response(:ok)
1543
1544       [report] = response["reports"]
1545
1546       assert length(response["reports"]) == 1
1547       assert report["id"] == report_id
1548
1549       assert response["total"] == 1
1550     end
1551
1552     test "returns reports with specified state", %{conn: conn} do
1553       [reporter, target_user] = insert_pair(:user)
1554       activity = insert(:note_activity, user: target_user)
1555
1556       {:ok, %{id: first_report_id}} =
1557         CommonAPI.report(reporter, %{
1558           "account_id" => target_user.id,
1559           "comment" => "I feel offended",
1560           "status_ids" => [activity.id]
1561         })
1562
1563       {:ok, %{id: second_report_id}} =
1564         CommonAPI.report(reporter, %{
1565           "account_id" => target_user.id,
1566           "comment" => "I don't like this user"
1567         })
1568
1569       CommonAPI.update_report_state(second_report_id, "closed")
1570
1571       response =
1572         conn
1573         |> get("/api/pleroma/admin/reports", %{
1574           "state" => "open"
1575         })
1576         |> json_response(:ok)
1577
1578       [open_report] = response["reports"]
1579
1580       assert length(response["reports"]) == 1
1581       assert open_report["id"] == first_report_id
1582
1583       assert response["total"] == 1
1584
1585       response =
1586         conn
1587         |> get("/api/pleroma/admin/reports", %{
1588           "state" => "closed"
1589         })
1590         |> json_response(:ok)
1591
1592       [closed_report] = response["reports"]
1593
1594       assert length(response["reports"]) == 1
1595       assert closed_report["id"] == second_report_id
1596
1597       assert response["total"] == 1
1598
1599       response =
1600         conn
1601         |> get("/api/pleroma/admin/reports", %{
1602           "state" => "resolved"
1603         })
1604         |> json_response(:ok)
1605
1606       assert Enum.empty?(response["reports"])
1607       assert response["total"] == 0
1608     end
1609
1610     test "returns 403 when requested by a non-admin" do
1611       user = insert(:user)
1612
1613       conn =
1614         build_conn()
1615         |> assign(:user, user)
1616         |> get("/api/pleroma/admin/reports")
1617
1618       assert json_response(conn, :forbidden) ==
1619                %{"error" => "User is not an admin or OAuth admin scope is not granted."}
1620     end
1621
1622     test "returns 403 when requested by anonymous" do
1623       conn =
1624         build_conn()
1625         |> get("/api/pleroma/admin/reports")
1626
1627       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1628     end
1629   end
1630
1631   describe "GET /api/pleroma/admin/grouped_reports" do
1632     setup %{conn: conn} do
1633       admin = insert(:user, is_admin: true)
1634       [reporter, target_user] = insert_pair(:user)
1635
1636       date1 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
1637       date2 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
1638       date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
1639
1640       first_status =
1641         insert(:note_activity, user: target_user, data_attrs: %{"published" => date1})
1642
1643       second_status =
1644         insert(:note_activity, user: target_user, data_attrs: %{"published" => date2})
1645
1646       third_status =
1647         insert(:note_activity, user: target_user, data_attrs: %{"published" => date3})
1648
1649       {:ok, first_report} =
1650         CommonAPI.report(reporter, %{
1651           "account_id" => target_user.id,
1652           "status_ids" => [first_status.id, second_status.id, third_status.id]
1653         })
1654
1655       {:ok, second_report} =
1656         CommonAPI.report(reporter, %{
1657           "account_id" => target_user.id,
1658           "status_ids" => [first_status.id, second_status.id]
1659         })
1660
1661       {:ok, third_report} =
1662         CommonAPI.report(reporter, %{
1663           "account_id" => target_user.id,
1664           "status_ids" => [first_status.id]
1665         })
1666
1667       %{
1668         conn: assign(conn, :user, admin),
1669         first_status: Activity.get_by_ap_id_with_object(first_status.data["id"]),
1670         second_status: Activity.get_by_ap_id_with_object(second_status.data["id"]),
1671         third_status: Activity.get_by_ap_id_with_object(third_status.data["id"]),
1672         first_report: first_report,
1673         first_status_reports: [first_report, second_report, third_report],
1674         second_status_reports: [first_report, second_report],
1675         third_status_reports: [first_report],
1676         target_user: target_user,
1677         reporter: reporter
1678       }
1679     end
1680
1681     test "returns reports grouped by status", %{
1682       conn: conn,
1683       first_status: first_status,
1684       second_status: second_status,
1685       third_status: third_status,
1686       first_status_reports: first_status_reports,
1687       second_status_reports: second_status_reports,
1688       third_status_reports: third_status_reports,
1689       target_user: target_user,
1690       reporter: reporter
1691     } do
1692       response =
1693         conn
1694         |> get("/api/pleroma/admin/grouped_reports")
1695         |> json_response(:ok)
1696
1697       assert length(response["reports"]) == 3
1698
1699       first_group = Enum.find(response["reports"], &(&1["status"]["id"] == first_status.id))
1700
1701       second_group = Enum.find(response["reports"], &(&1["status"]["id"] == second_status.id))
1702
1703       third_group = Enum.find(response["reports"], &(&1["status"]["id"] == third_status.id))
1704
1705       assert length(first_group["reports"]) == 3
1706       assert length(second_group["reports"]) == 2
1707       assert length(third_group["reports"]) == 1
1708
1709       assert first_group["date"] ==
1710                Enum.max_by(first_status_reports, fn act ->
1711                  NaiveDateTime.from_iso8601!(act.data["published"])
1712                end).data["published"]
1713
1714       assert first_group["status"] ==
1715                Map.put(
1716                  stringify_keys(StatusView.render("show.json", %{activity: first_status})),
1717                  "deleted",
1718                  false
1719                )
1720
1721       assert(first_group["account"]["id"] == target_user.id)
1722
1723       assert length(first_group["actors"]) == 1
1724       assert hd(first_group["actors"])["id"] == reporter.id
1725
1726       assert Enum.map(first_group["reports"], & &1["id"]) --
1727                Enum.map(first_status_reports, & &1.id) == []
1728
1729       assert second_group["date"] ==
1730                Enum.max_by(second_status_reports, fn act ->
1731                  NaiveDateTime.from_iso8601!(act.data["published"])
1732                end).data["published"]
1733
1734       assert second_group["status"] ==
1735                Map.put(
1736                  stringify_keys(StatusView.render("show.json", %{activity: second_status})),
1737                  "deleted",
1738                  false
1739                )
1740
1741       assert second_group["account"]["id"] == target_user.id
1742
1743       assert length(second_group["actors"]) == 1
1744       assert hd(second_group["actors"])["id"] == reporter.id
1745
1746       assert Enum.map(second_group["reports"], & &1["id"]) --
1747                Enum.map(second_status_reports, & &1.id) == []
1748
1749       assert third_group["date"] ==
1750                Enum.max_by(third_status_reports, fn act ->
1751                  NaiveDateTime.from_iso8601!(act.data["published"])
1752                end).data["published"]
1753
1754       assert third_group["status"] ==
1755                Map.put(
1756                  stringify_keys(StatusView.render("show.json", %{activity: third_status})),
1757                  "deleted",
1758                  false
1759                )
1760
1761       assert third_group["account"]["id"] == target_user.id
1762
1763       assert length(third_group["actors"]) == 1
1764       assert hd(third_group["actors"])["id"] == reporter.id
1765
1766       assert Enum.map(third_group["reports"], & &1["id"]) --
1767                Enum.map(third_status_reports, & &1.id) == []
1768     end
1769
1770     test "reopened report renders status data", %{
1771       conn: conn,
1772       first_report: first_report,
1773       first_status: first_status
1774     } do
1775       {:ok, _} = CommonAPI.update_report_state(first_report.id, "resolved")
1776
1777       response =
1778         conn
1779         |> get("/api/pleroma/admin/grouped_reports")
1780         |> json_response(:ok)
1781
1782       first_group = Enum.find(response["reports"], &(&1["status"]["id"] == first_status.id))
1783
1784       assert first_group["status"] ==
1785                Map.put(
1786                  stringify_keys(StatusView.render("show.json", %{activity: first_status})),
1787                  "deleted",
1788                  false
1789                )
1790     end
1791
1792     test "reopened report does not render status data if status has been deleted", %{
1793       conn: conn,
1794       first_report: first_report,
1795       first_status: first_status,
1796       target_user: target_user
1797     } do
1798       {:ok, _} = CommonAPI.update_report_state(first_report.id, "resolved")
1799       {:ok, _} = CommonAPI.delete(first_status.id, target_user)
1800
1801       refute Activity.get_by_ap_id(first_status.id)
1802
1803       response =
1804         conn
1805         |> get("/api/pleroma/admin/grouped_reports")
1806         |> json_response(:ok)
1807
1808       assert Enum.find(response["reports"], &(&1["status"]["deleted"] == true))["status"][
1809                "deleted"
1810              ] == true
1811
1812       assert length(Enum.filter(response["reports"], &(&1["status"]["deleted"] == false))) == 2
1813     end
1814
1815     test "account not empty if status was deleted", %{
1816       conn: conn,
1817       first_report: first_report,
1818       first_status: first_status,
1819       target_user: target_user
1820     } do
1821       {:ok, _} = CommonAPI.update_report_state(first_report.id, "resolved")
1822       {:ok, _} = CommonAPI.delete(first_status.id, target_user)
1823
1824       refute Activity.get_by_ap_id(first_status.id)
1825
1826       response =
1827         conn
1828         |> get("/api/pleroma/admin/grouped_reports")
1829         |> json_response(:ok)
1830
1831       assert Enum.find(response["reports"], &(&1["status"]["deleted"] == true))["account"]
1832     end
1833   end
1834
1835   describe "PUT /api/pleroma/admin/statuses/:id" do
1836     setup %{conn: conn} do
1837       admin = insert(:user, is_admin: true)
1838       activity = insert(:note_activity)
1839
1840       %{conn: assign(conn, :user, admin), id: activity.id, admin: admin}
1841     end
1842
1843     test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
1844       response =
1845         conn
1846         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1847         |> json_response(:ok)
1848
1849       assert response["sensitive"]
1850
1851       log_entry = Repo.one(ModerationLog)
1852
1853       assert ModerationLog.get_log_entry_message(log_entry) ==
1854                "@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"
1855
1856       response =
1857         conn
1858         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1859         |> json_response(:ok)
1860
1861       refute response["sensitive"]
1862     end
1863
1864     test "change visibility flag", %{conn: conn, id: id, admin: admin} do
1865       response =
1866         conn
1867         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1868         |> json_response(:ok)
1869
1870       assert response["visibility"] == "public"
1871
1872       log_entry = Repo.one(ModerationLog)
1873
1874       assert ModerationLog.get_log_entry_message(log_entry) ==
1875                "@#{admin.nickname} updated status ##{id}, set visibility: 'public'"
1876
1877       response =
1878         conn
1879         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1880         |> json_response(:ok)
1881
1882       assert response["visibility"] == "private"
1883
1884       response =
1885         conn
1886         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1887         |> json_response(:ok)
1888
1889       assert response["visibility"] == "unlisted"
1890     end
1891
1892     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1893       conn =
1894         conn
1895         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1896
1897       assert json_response(conn, :bad_request) == "Unsupported visibility"
1898     end
1899   end
1900
1901   describe "DELETE /api/pleroma/admin/statuses/:id" do
1902     setup %{conn: conn} do
1903       admin = insert(:user, is_admin: true)
1904       activity = insert(:note_activity)
1905
1906       %{conn: assign(conn, :user, admin), id: activity.id, admin: admin}
1907     end
1908
1909     test "deletes status", %{conn: conn, id: id, admin: admin} do
1910       conn
1911       |> delete("/api/pleroma/admin/statuses/#{id}")
1912       |> json_response(:ok)
1913
1914       refute Activity.get_by_id(id)
1915
1916       log_entry = Repo.one(ModerationLog)
1917
1918       assert ModerationLog.get_log_entry_message(log_entry) ==
1919                "@#{admin.nickname} deleted status ##{id}"
1920     end
1921
1922     test "returns error when status is not exist", %{conn: conn} do
1923       conn =
1924         conn
1925         |> delete("/api/pleroma/admin/statuses/test")
1926
1927       assert json_response(conn, :bad_request) == "Could not delete"
1928     end
1929   end
1930
1931   describe "GET /api/pleroma/admin/config" do
1932     setup %{conn: conn} do
1933       admin = insert(:user, is_admin: true)
1934
1935       %{conn: assign(conn, :user, admin)}
1936     end
1937
1938     test "without any settings in db", %{conn: conn} do
1939       conn = get(conn, "/api/pleroma/admin/config")
1940
1941       assert json_response(conn, 200) == %{"configs" => []}
1942     end
1943
1944     test "with settings in db", %{conn: conn} do
1945       config1 = insert(:config)
1946       config2 = insert(:config)
1947
1948       conn = get(conn, "/api/pleroma/admin/config")
1949
1950       %{
1951         "configs" => [
1952           %{
1953             "group" => ":pleroma",
1954             "key" => key1,
1955             "value" => _
1956           },
1957           %{
1958             "key" => key2,
1959             "value" => _
1960           }
1961         ]
1962       } = json_response(conn, 200)
1963
1964       assert key1 == config1.key
1965       assert key2 == config2.key
1966     end
1967   end
1968
1969   describe "POST /api/pleroma/admin/config" do
1970     setup %{conn: conn} do
1971       admin = insert(:user, is_admin: true)
1972
1973       temp_file = "config/test.exported_from_db.secret.exs"
1974
1975       on_exit(fn ->
1976         Application.delete_env(:pleroma, :key1)
1977         Application.delete_env(:pleroma, :key2)
1978         Application.delete_env(:pleroma, :key3)
1979         Application.delete_env(:pleroma, :key4)
1980         Application.delete_env(:pleroma, :keyaa1)
1981         Application.delete_env(:pleroma, :keyaa2)
1982         Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1983         Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1984         :ok = File.rm(temp_file)
1985       end)
1986
1987       %{conn: assign(conn, :user, admin)}
1988     end
1989
1990     clear_config([:instance, :dynamic_configuration]) do
1991       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1992     end
1993
1994     @tag capture_log: true
1995     test "create new config setting in db", %{conn: conn} do
1996       conn =
1997         post(conn, "/api/pleroma/admin/config", %{
1998           configs: [
1999             %{group: ":pleroma", key: ":key1", value: "value1"},
2000             %{
2001               group: ":ueberauth",
2002               key: "Ueberauth.Strategy.Twitter.OAuth",
2003               value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
2004             },
2005             %{
2006               group: ":pleroma",
2007               key: ":key2",
2008               value: %{
2009                 ":nested_1" => "nested_value1",
2010                 ":nested_2" => [
2011                   %{":nested_22" => "nested_value222"},
2012                   %{":nested_33" => %{":nested_44" => "nested_444"}}
2013                 ]
2014               }
2015             },
2016             %{
2017               group: ":pleroma",
2018               key: ":key3",
2019               value: [
2020                 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
2021                 %{"nested_4" => true}
2022               ]
2023             },
2024             %{
2025               group: ":pleroma",
2026               key: ":key4",
2027               value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
2028             },
2029             %{
2030               group: ":idna",
2031               key: ":key5",
2032               value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
2033             }
2034           ]
2035         })
2036
2037       assert json_response(conn, 200) == %{
2038                "configs" => [
2039                  %{
2040                    "group" => ":pleroma",
2041                    "key" => ":key1",
2042                    "value" => "value1"
2043                  },
2044                  %{
2045                    "group" => ":ueberauth",
2046                    "key" => "Ueberauth.Strategy.Twitter.OAuth",
2047                    "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
2048                  },
2049                  %{
2050                    "group" => ":pleroma",
2051                    "key" => ":key2",
2052                    "value" => %{
2053                      ":nested_1" => "nested_value1",
2054                      ":nested_2" => [
2055                        %{":nested_22" => "nested_value222"},
2056                        %{":nested_33" => %{":nested_44" => "nested_444"}}
2057                      ]
2058                    }
2059                  },
2060                  %{
2061                    "group" => ":pleroma",
2062                    "key" => ":key3",
2063                    "value" => [
2064                      %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
2065                      %{"nested_4" => true}
2066                    ]
2067                  },
2068                  %{
2069                    "group" => ":pleroma",
2070                    "key" => ":key4",
2071                    "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
2072                  },
2073                  %{
2074                    "group" => ":idna",
2075                    "key" => ":key5",
2076                    "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
2077                  }
2078                ]
2079              }
2080
2081       assert Application.get_env(:pleroma, :key1) == "value1"
2082
2083       assert Application.get_env(:pleroma, :key2) == %{
2084                nested_1: "nested_value1",
2085                nested_2: [
2086                  %{nested_22: "nested_value222"},
2087                  %{nested_33: %{nested_44: "nested_444"}}
2088                ]
2089              }
2090
2091       assert Application.get_env(:pleroma, :key3) == [
2092                %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
2093                %{"nested_4" => true}
2094              ]
2095
2096       assert Application.get_env(:pleroma, :key4) == %{
2097                "endpoint" => "https://example.com",
2098                nested_5: :upload
2099              }
2100
2101       assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
2102     end
2103
2104     test "update config setting & delete", %{conn: conn} do
2105       config1 = insert(:config, key: ":keyaa1")
2106       config2 = insert(:config, key: ":keyaa2")
2107
2108       insert(:config,
2109         group: "ueberauth",
2110         key: "Ueberauth.Strategy.Microsoft.OAuth",
2111         value: :erlang.term_to_binary([])
2112       )
2113
2114       conn =
2115         post(conn, "/api/pleroma/admin/config", %{
2116           configs: [
2117             %{group: config1.group, key: config1.key, value: "another_value"},
2118             %{group: config2.group, key: config2.key, delete: "true"},
2119             %{
2120               group: "ueberauth",
2121               key: "Ueberauth.Strategy.Microsoft.OAuth",
2122               delete: "true"
2123             }
2124           ]
2125         })
2126
2127       assert json_response(conn, 200) == %{
2128                "configs" => [
2129                  %{
2130                    "group" => ":pleroma",
2131                    "key" => config1.key,
2132                    "value" => "another_value"
2133                  }
2134                ]
2135              }
2136
2137       assert Application.get_env(:pleroma, :keyaa1) == "another_value"
2138       refute Application.get_env(:pleroma, :keyaa2)
2139     end
2140
2141     test "common config example", %{conn: conn} do
2142       adapter = Application.get_env(:tesla, :adapter)
2143       on_exit(fn -> Application.put_env(:tesla, :adapter, adapter) end)
2144
2145       conn =
2146         post(conn, "/api/pleroma/admin/config", %{
2147           configs: [
2148             %{
2149               "group" => ":pleroma",
2150               "key" => "Pleroma.Captcha.NotReal",
2151               "value" => [
2152                 %{"tuple" => [":enabled", false]},
2153                 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
2154                 %{"tuple" => [":seconds_valid", 60]},
2155                 %{"tuple" => [":path", ""]},
2156                 %{"tuple" => [":key1", nil]},
2157                 %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
2158                 %{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
2159                 %{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
2160                 %{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
2161                 %{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]},
2162                 %{"tuple" => [":name", "Pleroma"]}
2163               ]
2164             },
2165             %{"group" => ":tesla", "key" => ":adapter", "value" => "Tesla.Adapter.Httpc"}
2166           ]
2167         })
2168
2169       assert Application.get_env(:tesla, :adapter) == Tesla.Adapter.Httpc
2170       assert Pleroma.Config.get([Pleroma.Captcha.NotReal, :name]) == "Pleroma"
2171
2172       assert json_response(conn, 200) == %{
2173                "configs" => [
2174                  %{
2175                    "group" => ":pleroma",
2176                    "key" => "Pleroma.Captcha.NotReal",
2177                    "value" => [
2178                      %{"tuple" => [":enabled", false]},
2179                      %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
2180                      %{"tuple" => [":seconds_valid", 60]},
2181                      %{"tuple" => [":path", ""]},
2182                      %{"tuple" => [":key1", nil]},
2183                      %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
2184                      %{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
2185                      %{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
2186                      %{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
2187                      %{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]},
2188                      %{"tuple" => [":name", "Pleroma"]}
2189                    ]
2190                  },
2191                  %{"group" => ":tesla", "key" => ":adapter", "value" => "Tesla.Adapter.Httpc"}
2192                ]
2193              }
2194     end
2195
2196     test "tuples with more than two values", %{conn: conn} do
2197       conn =
2198         post(conn, "/api/pleroma/admin/config", %{
2199           configs: [
2200             %{
2201               "group" => ":pleroma",
2202               "key" => "Pleroma.Web.Endpoint.NotReal",
2203               "value" => [
2204                 %{
2205                   "tuple" => [
2206                     ":http",
2207                     [
2208                       %{
2209                         "tuple" => [
2210                           ":key2",
2211                           [
2212                             %{
2213                               "tuple" => [
2214                                 ":_",
2215                                 [
2216                                   %{
2217                                     "tuple" => [
2218                                       "/api/v1/streaming",
2219                                       "Pleroma.Web.MastodonAPI.WebsocketHandler",
2220                                       []
2221                                     ]
2222                                   },
2223                                   %{
2224                                     "tuple" => [
2225                                       "/websocket",
2226                                       "Phoenix.Endpoint.CowboyWebSocket",
2227                                       %{
2228                                         "tuple" => [
2229                                           "Phoenix.Transports.WebSocket",
2230                                           %{
2231                                             "tuple" => [
2232                                               "Pleroma.Web.Endpoint",
2233                                               "Pleroma.Web.UserSocket",
2234                                               []
2235                                             ]
2236                                           }
2237                                         ]
2238                                       }
2239                                     ]
2240                                   },
2241                                   %{
2242                                     "tuple" => [
2243                                       ":_",
2244                                       "Phoenix.Endpoint.Cowboy2Handler",
2245                                       %{"tuple" => ["Pleroma.Web.Endpoint", []]}
2246                                     ]
2247                                   }
2248                                 ]
2249                               ]
2250                             }
2251                           ]
2252                         ]
2253                       }
2254                     ]
2255                   ]
2256                 }
2257               ]
2258             }
2259           ]
2260         })
2261
2262       assert json_response(conn, 200) == %{
2263                "configs" => [
2264                  %{
2265                    "group" => ":pleroma",
2266                    "key" => "Pleroma.Web.Endpoint.NotReal",
2267                    "value" => [
2268                      %{
2269                        "tuple" => [
2270                          ":http",
2271                          [
2272                            %{
2273                              "tuple" => [
2274                                ":key2",
2275                                [
2276                                  %{
2277                                    "tuple" => [
2278                                      ":_",
2279                                      [
2280                                        %{
2281                                          "tuple" => [
2282                                            "/api/v1/streaming",
2283                                            "Pleroma.Web.MastodonAPI.WebsocketHandler",
2284                                            []
2285                                          ]
2286                                        },
2287                                        %{
2288                                          "tuple" => [
2289                                            "/websocket",
2290                                            "Phoenix.Endpoint.CowboyWebSocket",
2291                                            %{
2292                                              "tuple" => [
2293                                                "Phoenix.Transports.WebSocket",
2294                                                %{
2295                                                  "tuple" => [
2296                                                    "Pleroma.Web.Endpoint",
2297                                                    "Pleroma.Web.UserSocket",
2298                                                    []
2299                                                  ]
2300                                                }
2301                                              ]
2302                                            }
2303                                          ]
2304                                        },
2305                                        %{
2306                                          "tuple" => [
2307                                            ":_",
2308                                            "Phoenix.Endpoint.Cowboy2Handler",
2309                                            %{"tuple" => ["Pleroma.Web.Endpoint", []]}
2310                                          ]
2311                                        }
2312                                      ]
2313                                    ]
2314                                  }
2315                                ]
2316                              ]
2317                            }
2318                          ]
2319                        ]
2320                      }
2321                    ]
2322                  }
2323                ]
2324              }
2325     end
2326
2327     test "settings with nesting map", %{conn: conn} do
2328       conn =
2329         post(conn, "/api/pleroma/admin/config", %{
2330           configs: [
2331             %{
2332               "group" => ":pleroma",
2333               "key" => ":key1",
2334               "value" => [
2335                 %{"tuple" => [":key2", "some_val"]},
2336                 %{
2337                   "tuple" => [
2338                     ":key3",
2339                     %{
2340                       ":max_options" => 20,
2341                       ":max_option_chars" => 200,
2342                       ":min_expiration" => 0,
2343                       ":max_expiration" => 31_536_000,
2344                       "nested" => %{
2345                         ":max_options" => 20,
2346                         ":max_option_chars" => 200,
2347                         ":min_expiration" => 0,
2348                         ":max_expiration" => 31_536_000
2349                       }
2350                     }
2351                   ]
2352                 }
2353               ]
2354             }
2355           ]
2356         })
2357
2358       assert json_response(conn, 200) ==
2359                %{
2360                  "configs" => [
2361                    %{
2362                      "group" => ":pleroma",
2363                      "key" => ":key1",
2364                      "value" => [
2365                        %{"tuple" => [":key2", "some_val"]},
2366                        %{
2367                          "tuple" => [
2368                            ":key3",
2369                            %{
2370                              ":max_expiration" => 31_536_000,
2371                              ":max_option_chars" => 200,
2372                              ":max_options" => 20,
2373                              ":min_expiration" => 0,
2374                              "nested" => %{
2375                                ":max_expiration" => 31_536_000,
2376                                ":max_option_chars" => 200,
2377                                ":max_options" => 20,
2378                                ":min_expiration" => 0
2379                              }
2380                            }
2381                          ]
2382                        }
2383                      ]
2384                    }
2385                  ]
2386                }
2387     end
2388
2389     test "value as map", %{conn: conn} do
2390       conn =
2391         post(conn, "/api/pleroma/admin/config", %{
2392           configs: [
2393             %{
2394               "group" => ":pleroma",
2395               "key" => ":key1",
2396               "value" => %{"key" => "some_val"}
2397             }
2398           ]
2399         })
2400
2401       assert json_response(conn, 200) ==
2402                %{
2403                  "configs" => [
2404                    %{
2405                      "group" => ":pleroma",
2406                      "key" => ":key1",
2407                      "value" => %{"key" => "some_val"}
2408                    }
2409                  ]
2410                }
2411     end
2412
2413     test "dispatch setting", %{conn: conn} do
2414       conn =
2415         post(conn, "/api/pleroma/admin/config", %{
2416           configs: [
2417             %{
2418               "group" => ":pleroma",
2419               "key" => "Pleroma.Web.Endpoint.NotReal",
2420               "value" => [
2421                 %{
2422                   "tuple" => [
2423                     ":http",
2424                     [
2425                       %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2426                       %{"tuple" => [":dispatch", ["{:_,
2427        [
2428          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
2429          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
2430           {Phoenix.Transports.WebSocket,
2431            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
2432          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
2433        ]}"]]}
2434                     ]
2435                   ]
2436                 }
2437               ]
2438             }
2439           ]
2440         })
2441
2442       dispatch_string =
2443         "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
2444           "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
2445           "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
2446           "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
2447
2448       assert json_response(conn, 200) == %{
2449                "configs" => [
2450                  %{
2451                    "group" => ":pleroma",
2452                    "key" => "Pleroma.Web.Endpoint.NotReal",
2453                    "value" => [
2454                      %{
2455                        "tuple" => [
2456                          ":http",
2457                          [
2458                            %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2459                            %{
2460                              "tuple" => [
2461                                ":dispatch",
2462                                [
2463                                  dispatch_string
2464                                ]
2465                              ]
2466                            }
2467                          ]
2468                        ]
2469                      }
2470                    ]
2471                  }
2472                ]
2473              }
2474     end
2475
2476     test "queues key as atom", %{conn: conn} do
2477       conn =
2478         post(conn, "/api/pleroma/admin/config", %{
2479           configs: [
2480             %{
2481               "group" => ":oban",
2482               "key" => ":queues",
2483               "value" => [
2484                 %{"tuple" => [":federator_incoming", 50]},
2485                 %{"tuple" => [":federator_outgoing", 50]},
2486                 %{"tuple" => [":web_push", 50]},
2487                 %{"tuple" => [":mailer", 10]},
2488                 %{"tuple" => [":transmogrifier", 20]},
2489                 %{"tuple" => [":scheduled_activities", 10]},
2490                 %{"tuple" => [":background", 5]}
2491               ]
2492             }
2493           ]
2494         })
2495
2496       assert json_response(conn, 200) == %{
2497                "configs" => [
2498                  %{
2499                    "group" => ":oban",
2500                    "key" => ":queues",
2501                    "value" => [
2502                      %{"tuple" => [":federator_incoming", 50]},
2503                      %{"tuple" => [":federator_outgoing", 50]},
2504                      %{"tuple" => [":web_push", 50]},
2505                      %{"tuple" => [":mailer", 10]},
2506                      %{"tuple" => [":transmogrifier", 20]},
2507                      %{"tuple" => [":scheduled_activities", 10]},
2508                      %{"tuple" => [":background", 5]}
2509                    ]
2510                  }
2511                ]
2512              }
2513     end
2514
2515     test "delete part of settings by atom subkeys", %{conn: conn} do
2516       config =
2517         insert(:config,
2518           key: ":keyaa1",
2519           value: :erlang.term_to_binary(subkey1: "val1", subkey2: "val2", subkey3: "val3")
2520         )
2521
2522       conn =
2523         post(conn, "/api/pleroma/admin/config", %{
2524           configs: [
2525             %{
2526               group: config.group,
2527               key: config.key,
2528               subkeys: [":subkey1", ":subkey3"],
2529               delete: "true"
2530             }
2531           ]
2532         })
2533
2534       assert(
2535         json_response(conn, 200) == %{
2536           "configs" => [
2537             %{
2538               "group" => ":pleroma",
2539               "key" => ":keyaa1",
2540               "value" => [%{"tuple" => [":subkey2", "val2"]}]
2541             }
2542           ]
2543         }
2544       )
2545     end
2546   end
2547
2548   describe "config mix tasks run" do
2549     setup %{conn: conn} do
2550       admin = insert(:user, is_admin: true)
2551
2552       temp_file = "config/test.exported_from_db.secret.exs"
2553
2554       Mix.shell(Mix.Shell.Quiet)
2555
2556       on_exit(fn ->
2557         Mix.shell(Mix.Shell.IO)
2558         :ok = File.rm(temp_file)
2559       end)
2560
2561       %{conn: assign(conn, :user, admin), admin: admin}
2562     end
2563
2564     clear_config([:instance, :dynamic_configuration]) do
2565       Pleroma.Config.put([:instance, :dynamic_configuration], true)
2566     end
2567
2568     clear_config([:feed, :post_title]) do
2569       Pleroma.Config.put([:feed, :post_title], %{max_length: 100, omission: "…"})
2570     end
2571
2572     test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
2573       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2574       conn = get(conn, "/api/pleroma/admin/config/migrate_to_db")
2575       assert json_response(conn, 200) == %{}
2576       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) > 0
2577
2578       conn =
2579         build_conn()
2580         |> assign(:user, admin)
2581         |> get("/api/pleroma/admin/config/migrate_from_db")
2582
2583       assert json_response(conn, 200) == %{}
2584       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2585     end
2586   end
2587
2588   describe "GET /api/pleroma/admin/users/:nickname/statuses" do
2589     setup do
2590       admin = insert(:user, is_admin: true)
2591       user = insert(:user)
2592
2593       date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
2594       date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
2595       date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
2596
2597       insert(:note_activity, user: user, published: date1)
2598       insert(:note_activity, user: user, published: date2)
2599       insert(:note_activity, user: user, published: date3)
2600
2601       conn =
2602         build_conn()
2603         |> assign(:user, admin)
2604
2605       {:ok, conn: conn, user: user}
2606     end
2607
2608     test "renders user's statuses", %{conn: conn, user: user} do
2609       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2610
2611       assert json_response(conn, 200) |> length() == 3
2612     end
2613
2614     test "renders user's statuses with a limit", %{conn: conn, user: user} do
2615       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
2616
2617       assert json_response(conn, 200) |> length() == 2
2618     end
2619
2620     test "doesn't return private statuses by default", %{conn: conn, user: user} do
2621       {:ok, _private_status} =
2622         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2623
2624       {:ok, _public_status} =
2625         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2626
2627       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2628
2629       assert json_response(conn, 200) |> length() == 4
2630     end
2631
2632     test "returns private statuses with godmode on", %{conn: conn, user: user} do
2633       {:ok, _private_status} =
2634         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2635
2636       {:ok, _public_status} =
2637         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2638
2639       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
2640
2641       assert json_response(conn, 200) |> length() == 5
2642     end
2643   end
2644
2645   describe "GET /api/pleroma/admin/moderation_log" do
2646     setup %{conn: conn} do
2647       admin = insert(:user, is_admin: true)
2648       moderator = insert(:user, is_moderator: true)
2649
2650       %{conn: assign(conn, :user, admin), admin: admin, moderator: moderator}
2651     end
2652
2653     test "returns the log", %{conn: conn, admin: admin} do
2654       Repo.insert(%ModerationLog{
2655         data: %{
2656           actor: %{
2657             "id" => admin.id,
2658             "nickname" => admin.nickname,
2659             "type" => "user"
2660           },
2661           action: "relay_follow",
2662           target: "https://example.org/relay"
2663         },
2664         inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2665       })
2666
2667       Repo.insert(%ModerationLog{
2668         data: %{
2669           actor: %{
2670             "id" => admin.id,
2671             "nickname" => admin.nickname,
2672             "type" => "user"
2673           },
2674           action: "relay_unfollow",
2675           target: "https://example.org/relay"
2676         },
2677         inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2678       })
2679
2680       conn = get(conn, "/api/pleroma/admin/moderation_log")
2681
2682       response = json_response(conn, 200)
2683       [first_entry, second_entry] = response["items"]
2684
2685       assert response["total"] == 2
2686       assert first_entry["data"]["action"] == "relay_unfollow"
2687
2688       assert first_entry["message"] ==
2689                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2690
2691       assert second_entry["data"]["action"] == "relay_follow"
2692
2693       assert second_entry["message"] ==
2694                "@#{admin.nickname} followed relay: https://example.org/relay"
2695     end
2696
2697     test "returns the log with pagination", %{conn: conn, admin: admin} do
2698       Repo.insert(%ModerationLog{
2699         data: %{
2700           actor: %{
2701             "id" => admin.id,
2702             "nickname" => admin.nickname,
2703             "type" => "user"
2704           },
2705           action: "relay_follow",
2706           target: "https://example.org/relay"
2707         },
2708         inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2709       })
2710
2711       Repo.insert(%ModerationLog{
2712         data: %{
2713           actor: %{
2714             "id" => admin.id,
2715             "nickname" => admin.nickname,
2716             "type" => "user"
2717           },
2718           action: "relay_unfollow",
2719           target: "https://example.org/relay"
2720         },
2721         inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2722       })
2723
2724       conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
2725
2726       response1 = json_response(conn1, 200)
2727       [first_entry] = response1["items"]
2728
2729       assert response1["total"] == 2
2730       assert response1["items"] |> length() == 1
2731       assert first_entry["data"]["action"] == "relay_unfollow"
2732
2733       assert first_entry["message"] ==
2734                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2735
2736       conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
2737
2738       response2 = json_response(conn2, 200)
2739       [second_entry] = response2["items"]
2740
2741       assert response2["total"] == 2
2742       assert response2["items"] |> length() == 1
2743       assert second_entry["data"]["action"] == "relay_follow"
2744
2745       assert second_entry["message"] ==
2746                "@#{admin.nickname} followed relay: https://example.org/relay"
2747     end
2748
2749     test "filters log by date", %{conn: conn, admin: admin} do
2750       first_date = "2017-08-15T15:47:06Z"
2751       second_date = "2017-08-20T15:47:06Z"
2752
2753       Repo.insert(%ModerationLog{
2754         data: %{
2755           actor: %{
2756             "id" => admin.id,
2757             "nickname" => admin.nickname,
2758             "type" => "user"
2759           },
2760           action: "relay_follow",
2761           target: "https://example.org/relay"
2762         },
2763         inserted_at: NaiveDateTime.from_iso8601!(first_date)
2764       })
2765
2766       Repo.insert(%ModerationLog{
2767         data: %{
2768           actor: %{
2769             "id" => admin.id,
2770             "nickname" => admin.nickname,
2771             "type" => "user"
2772           },
2773           action: "relay_unfollow",
2774           target: "https://example.org/relay"
2775         },
2776         inserted_at: NaiveDateTime.from_iso8601!(second_date)
2777       })
2778
2779       conn1 =
2780         get(
2781           conn,
2782           "/api/pleroma/admin/moderation_log?start_date=#{second_date}"
2783         )
2784
2785       response1 = json_response(conn1, 200)
2786       [first_entry] = response1["items"]
2787
2788       assert response1["total"] == 1
2789       assert first_entry["data"]["action"] == "relay_unfollow"
2790
2791       assert first_entry["message"] ==
2792                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2793     end
2794
2795     test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
2796       Repo.insert(%ModerationLog{
2797         data: %{
2798           actor: %{
2799             "id" => admin.id,
2800             "nickname" => admin.nickname,
2801             "type" => "user"
2802           },
2803           action: "relay_follow",
2804           target: "https://example.org/relay"
2805         }
2806       })
2807
2808       Repo.insert(%ModerationLog{
2809         data: %{
2810           actor: %{
2811             "id" => moderator.id,
2812             "nickname" => moderator.nickname,
2813             "type" => "user"
2814           },
2815           action: "relay_unfollow",
2816           target: "https://example.org/relay"
2817         }
2818       })
2819
2820       conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")
2821
2822       response1 = json_response(conn1, 200)
2823       [first_entry] = response1["items"]
2824
2825       assert response1["total"] == 1
2826       assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
2827     end
2828
2829     test "returns log filtered by search", %{conn: conn, moderator: moderator} do
2830       ModerationLog.insert_log(%{
2831         actor: moderator,
2832         action: "relay_follow",
2833         target: "https://example.org/relay"
2834       })
2835
2836       ModerationLog.insert_log(%{
2837         actor: moderator,
2838         action: "relay_unfollow",
2839         target: "https://example.org/relay"
2840       })
2841
2842       conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")
2843
2844       response1 = json_response(conn1, 200)
2845       [first_entry] = response1["items"]
2846
2847       assert response1["total"] == 1
2848
2849       assert get_in(first_entry, ["data", "message"]) ==
2850                "@#{moderator.nickname} unfollowed relay: https://example.org/relay"
2851     end
2852   end
2853
2854   describe "PATCH /users/:nickname/force_password_reset" do
2855     setup %{conn: conn} do
2856       admin = insert(:user, is_admin: true)
2857       user = insert(:user)
2858
2859       %{conn: assign(conn, :user, admin), admin: admin, user: user}
2860     end
2861
2862     test "sets password_reset_pending to true", %{admin: admin, user: user} do
2863       assert user.password_reset_pending == false
2864
2865       conn =
2866         build_conn()
2867         |> assign(:user, admin)
2868         |> patch("/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})
2869
2870       assert json_response(conn, 204) == ""
2871
2872       ObanHelpers.perform_all()
2873
2874       assert User.get_by_id(user.id).password_reset_pending == true
2875     end
2876   end
2877
2878   describe "relays" do
2879     setup %{conn: conn} do
2880       admin = insert(:user, is_admin: true)
2881
2882       %{conn: assign(conn, :user, admin), admin: admin}
2883     end
2884
2885     test "POST /relay", %{admin: admin} do
2886       conn =
2887         build_conn()
2888         |> assign(:user, admin)
2889         |> post("/api/pleroma/admin/relay", %{
2890           relay_url: "http://mastodon.example.org/users/admin"
2891         })
2892
2893       assert json_response(conn, 200) == "http://mastodon.example.org/users/admin"
2894
2895       log_entry = Repo.one(ModerationLog)
2896
2897       assert ModerationLog.get_log_entry_message(log_entry) ==
2898                "@#{admin.nickname} followed relay: http://mastodon.example.org/users/admin"
2899     end
2900
2901     test "GET /relay", %{admin: admin} do
2902       relay_user = Pleroma.Web.ActivityPub.Relay.get_actor()
2903
2904       ["http://mastodon.example.org/users/admin", "https://mstdn.io/users/mayuutann"]
2905       |> Enum.each(fn ap_id ->
2906         {:ok, user} = User.get_or_fetch_by_ap_id(ap_id)
2907         User.follow(relay_user, user)
2908       end)
2909
2910       conn =
2911         build_conn()
2912         |> assign(:user, admin)
2913         |> get("/api/pleroma/admin/relay")
2914
2915       assert json_response(conn, 200)["relays"] -- ["mastodon.example.org", "mstdn.io"] == []
2916     end
2917
2918     test "DELETE /relay", %{admin: admin} do
2919       build_conn()
2920       |> assign(:user, admin)
2921       |> post("/api/pleroma/admin/relay", %{
2922         relay_url: "http://mastodon.example.org/users/admin"
2923       })
2924
2925       conn =
2926         build_conn()
2927         |> assign(:user, admin)
2928         |> delete("/api/pleroma/admin/relay", %{
2929           relay_url: "http://mastodon.example.org/users/admin"
2930         })
2931
2932       assert json_response(conn, 200) == "http://mastodon.example.org/users/admin"
2933
2934       [log_entry_one, log_entry_two] = Repo.all(ModerationLog)
2935
2936       assert ModerationLog.get_log_entry_message(log_entry_one) ==
2937                "@#{admin.nickname} followed relay: http://mastodon.example.org/users/admin"
2938
2939       assert ModerationLog.get_log_entry_message(log_entry_two) ==
2940                "@#{admin.nickname} unfollowed relay: http://mastodon.example.org/users/admin"
2941     end
2942   end
2943
2944   describe "instances" do
2945     test "GET /instances/:instance/statuses" do
2946       admin = insert(:user, is_admin: true)
2947       user = insert(:user, local: false, nickname: "archaeme@archae.me")
2948       user2 = insert(:user, local: false, nickname: "test@test.com")
2949       insert_pair(:note_activity, user: user)
2950       insert(:note_activity, user: user2)
2951
2952       conn =
2953         build_conn()
2954         |> assign(:user, admin)
2955         |> get("/api/pleroma/admin/instances/archae.me/statuses")
2956
2957       response = json_response(conn, 200)
2958
2959       assert length(response) == 2
2960
2961       conn =
2962         build_conn()
2963         |> assign(:user, admin)
2964         |> get("/api/pleroma/admin/instances/test.com/statuses")
2965
2966       response = json_response(conn, 200)
2967
2968       assert length(response) == 1
2969
2970       conn =
2971         build_conn()
2972         |> assign(:user, admin)
2973         |> get("/api/pleroma/admin/instances/nonexistent.com/statuses")
2974
2975       response = json_response(conn, 200)
2976
2977       assert length(response) == 0
2978     end
2979   end
2980
2981   describe "PATCH /confirm_email" do
2982     setup %{conn: conn} do
2983       admin = insert(:user, is_admin: true)
2984
2985       %{conn: assign(conn, :user, admin), admin: admin}
2986     end
2987
2988     test "it confirms emails of two users", %{admin: admin} do
2989       [first_user, second_user] = insert_pair(:user, confirmation_pending: true)
2990
2991       assert first_user.confirmation_pending == true
2992       assert second_user.confirmation_pending == true
2993
2994       build_conn()
2995       |> assign(:user, admin)
2996       |> patch("/api/pleroma/admin/users/confirm_email", %{
2997         nicknames: [
2998           first_user.nickname,
2999           second_user.nickname
3000         ]
3001       })
3002
3003       assert first_user.confirmation_pending == true
3004       assert second_user.confirmation_pending == true
3005
3006       log_entry = Repo.one(ModerationLog)
3007
3008       assert ModerationLog.get_log_entry_message(log_entry) ==
3009                "@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{
3010                  second_user.nickname
3011                }"
3012     end
3013   end
3014
3015   describe "PATCH /resend_confirmation_email" do
3016     setup %{conn: conn} do
3017       admin = insert(:user, is_admin: true)
3018
3019       %{conn: assign(conn, :user, admin), admin: admin}
3020     end
3021
3022     test "it resend emails for two users", %{admin: admin} do
3023       [first_user, second_user] = insert_pair(:user, confirmation_pending: true)
3024
3025       build_conn()
3026       |> assign(:user, admin)
3027       |> patch("/api/pleroma/admin/users/resend_confirmation_email", %{
3028         nicknames: [
3029           first_user.nickname,
3030           second_user.nickname
3031         ]
3032       })
3033
3034       log_entry = Repo.one(ModerationLog)
3035
3036       assert ModerationLog.get_log_entry_message(log_entry) ==
3037                "@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{
3038                  second_user.nickname
3039                }"
3040     end
3041   end
3042
3043   describe "POST /reports/:id/notes" do
3044     setup do
3045       admin = insert(:user, is_admin: true)
3046       [reporter, target_user] = insert_pair(:user)
3047       activity = insert(:note_activity, user: target_user)
3048
3049       {:ok, %{id: report_id}} =
3050         CommonAPI.report(reporter, %{
3051           "account_id" => target_user.id,
3052           "comment" => "I feel offended",
3053           "status_ids" => [activity.id]
3054         })
3055
3056       build_conn()
3057       |> assign(:user, admin)
3058       |> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
3059         content: "this is disgusting!"
3060       })
3061
3062       build_conn()
3063       |> assign(:user, admin)
3064       |> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
3065         content: "this is disgusting2!"
3066       })
3067
3068       %{
3069         admin_id: admin.id,
3070         report_id: report_id,
3071         admin: admin
3072       }
3073     end
3074
3075     test "it creates report note", %{admin_id: admin_id, report_id: report_id} do
3076       [note, _] = Repo.all(ReportNote)
3077
3078       assert %{
3079                activity_id: ^report_id,
3080                content: "this is disgusting!",
3081                user_id: ^admin_id
3082              } = note
3083     end
3084
3085     test "it returns reports with notes", %{admin: admin} do
3086       conn =
3087         build_conn()
3088         |> assign(:user, admin)
3089         |> get("/api/pleroma/admin/reports")
3090
3091       response = json_response(conn, 200)
3092       notes = hd(response["reports"])["notes"]
3093       [note, _] = notes
3094
3095       assert note["user"]["nickname"] == admin.nickname
3096       assert note["content"] == "this is disgusting!"
3097       assert note["created_at"]
3098       assert response["total"] == 1
3099     end
3100
3101     test "it deletes the note", %{admin: admin, report_id: report_id} do
3102       assert ReportNote |> Repo.all() |> length() == 2
3103
3104       [note, _] = Repo.all(ReportNote)
3105
3106       build_conn()
3107       |> assign(:user, admin)
3108       |> delete("/api/pleroma/admin/reports/#{report_id}/notes/#{note.id}")
3109
3110       assert ReportNote |> Repo.all() |> length() == 1
3111     end
3112   end
3113
3114   test "GET /api/pleroma/admin/config/descriptions", %{conn: conn} do
3115     admin = insert(:user, is_admin: true)
3116
3117     conn =
3118       assign(conn, :user, admin)
3119       |> get("/api/pleroma/admin/config/descriptions")
3120
3121     assert [child | _others] = json_response(conn, 200)
3122
3123     assert child["children"]
3124     assert child["key"]
3125     assert String.starts_with?(child["group"], ":")
3126     assert child["description"]
3127   end
3128 end
3129
3130 # Needed for testing
3131 defmodule Pleroma.Web.Endpoint.NotReal do
3132 end
3133
3134 defmodule Pleroma.Captcha.NotReal do
3135 end