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             "key" => key1,
1954             "value" => _
1955           },
1956           %{
1957             "key" => key2,
1958             "value" => _
1959           }
1960         ]
1961       } = json_response(conn, 200)
1962
1963       assert key1 == config1.key
1964       assert key2 == config2.key
1965     end
1966   end
1967
1968   describe "POST /api/pleroma/admin/config" do
1969     setup %{conn: conn} do
1970       admin = insert(:user, is_admin: true)
1971
1972       temp_file = "config/test.exported_from_db.secret.exs"
1973
1974       on_exit(fn ->
1975         Application.delete_env(:pleroma, :key1)
1976         Application.delete_env(:pleroma, :key2)
1977         Application.delete_env(:pleroma, :key3)
1978         Application.delete_env(:pleroma, :key4)
1979         Application.delete_env(:pleroma, :keyaa1)
1980         Application.delete_env(:pleroma, :keyaa2)
1981         Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1982         Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1983         :ok = File.rm(temp_file)
1984       end)
1985
1986       %{conn: assign(conn, :user, admin)}
1987     end
1988
1989     clear_config([:instance, :dynamic_configuration]) do
1990       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1991     end
1992
1993     @tag capture_log: true
1994     test "create new config setting in db", %{conn: conn} do
1995       conn =
1996         post(conn, "/api/pleroma/admin/config", %{
1997           configs: [
1998             %{group: "pleroma", key: "key1", value: "value1"},
1999             %{
2000               group: "ueberauth",
2001               key: "Ueberauth.Strategy.Twitter.OAuth",
2002               value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
2003             },
2004             %{
2005               group: "pleroma",
2006               key: "key2",
2007               value: %{
2008                 ":nested_1" => "nested_value1",
2009                 ":nested_2" => [
2010                   %{":nested_22" => "nested_value222"},
2011                   %{":nested_33" => %{":nested_44" => "nested_444"}}
2012                 ]
2013               }
2014             },
2015             %{
2016               group: "pleroma",
2017               key: "key3",
2018               value: [
2019                 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
2020                 %{"nested_4" => true}
2021               ]
2022             },
2023             %{
2024               group: "pleroma",
2025               key: "key4",
2026               value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
2027             },
2028             %{
2029               group: "idna",
2030               key: "key5",
2031               value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
2032             }
2033           ]
2034         })
2035
2036       assert json_response(conn, 200) == %{
2037                "configs" => [
2038                  %{
2039                    "group" => "pleroma",
2040                    "key" => "key1",
2041                    "value" => "value1"
2042                  },
2043                  %{
2044                    "group" => "ueberauth",
2045                    "key" => "Ueberauth.Strategy.Twitter.OAuth",
2046                    "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
2047                  },
2048                  %{
2049                    "group" => "pleroma",
2050                    "key" => "key2",
2051                    "value" => %{
2052                      ":nested_1" => "nested_value1",
2053                      ":nested_2" => [
2054                        %{":nested_22" => "nested_value222"},
2055                        %{":nested_33" => %{":nested_44" => "nested_444"}}
2056                      ]
2057                    }
2058                  },
2059                  %{
2060                    "group" => "pleroma",
2061                    "key" => "key3",
2062                    "value" => [
2063                      %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
2064                      %{"nested_4" => true}
2065                    ]
2066                  },
2067                  %{
2068                    "group" => "pleroma",
2069                    "key" => "key4",
2070                    "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
2071                  },
2072                  %{
2073                    "group" => "idna",
2074                    "key" => "key5",
2075                    "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
2076                  }
2077                ]
2078              }
2079
2080       assert Application.get_env(:pleroma, :key1) == "value1"
2081
2082       assert Application.get_env(:pleroma, :key2) == %{
2083                nested_1: "nested_value1",
2084                nested_2: [
2085                  %{nested_22: "nested_value222"},
2086                  %{nested_33: %{nested_44: "nested_444"}}
2087                ]
2088              }
2089
2090       assert Application.get_env(:pleroma, :key3) == [
2091                %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
2092                %{"nested_4" => true}
2093              ]
2094
2095       assert Application.get_env(:pleroma, :key4) == %{
2096                "endpoint" => "https://example.com",
2097                nested_5: :upload
2098              }
2099
2100       assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
2101     end
2102
2103     test "update config setting & delete", %{conn: conn} do
2104       config1 = insert(:config, key: "keyaa1")
2105       config2 = insert(:config, key: "keyaa2")
2106
2107       insert(:config,
2108         group: "ueberauth",
2109         key: "Ueberauth.Strategy.Microsoft.OAuth",
2110         value: :erlang.term_to_binary([])
2111       )
2112
2113       conn =
2114         post(conn, "/api/pleroma/admin/config", %{
2115           configs: [
2116             %{group: config1.group, key: config1.key, value: "another_value"},
2117             %{group: config2.group, key: config2.key, delete: "true"},
2118             %{
2119               group: "ueberauth",
2120               key: "Ueberauth.Strategy.Microsoft.OAuth",
2121               delete: "true"
2122             }
2123           ]
2124         })
2125
2126       assert json_response(conn, 200) == %{
2127                "configs" => [
2128                  %{
2129                    "group" => "pleroma",
2130                    "key" => config1.key,
2131                    "value" => "another_value"
2132                  }
2133                ]
2134              }
2135
2136       assert Application.get_env(:pleroma, :keyaa1) == "another_value"
2137       refute Application.get_env(:pleroma, :keyaa2)
2138     end
2139
2140     test "common config example", %{conn: conn} do
2141       conn =
2142         post(conn, "/api/pleroma/admin/config", %{
2143           configs: [
2144             %{
2145               "group" => "pleroma",
2146               "key" => "Pleroma.Captcha.NotReal",
2147               "value" => [
2148                 %{"tuple" => [":enabled", false]},
2149                 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
2150                 %{"tuple" => [":seconds_valid", 60]},
2151                 %{"tuple" => [":path", ""]},
2152                 %{"tuple" => [":key1", nil]},
2153                 %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
2154                 %{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
2155                 %{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
2156                 %{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
2157                 %{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]}
2158               ]
2159             }
2160           ]
2161         })
2162
2163       assert json_response(conn, 200) == %{
2164                "configs" => [
2165                  %{
2166                    "group" => "pleroma",
2167                    "key" => "Pleroma.Captcha.NotReal",
2168                    "value" => [
2169                      %{"tuple" => [":enabled", false]},
2170                      %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
2171                      %{"tuple" => [":seconds_valid", 60]},
2172                      %{"tuple" => [":path", ""]},
2173                      %{"tuple" => [":key1", nil]},
2174                      %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
2175                      %{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
2176                      %{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
2177                      %{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
2178                      %{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]}
2179                    ]
2180                  }
2181                ]
2182              }
2183     end
2184
2185     test "tuples with more than two values", %{conn: conn} do
2186       conn =
2187         post(conn, "/api/pleroma/admin/config", %{
2188           configs: [
2189             %{
2190               "group" => "pleroma",
2191               "key" => "Pleroma.Web.Endpoint.NotReal",
2192               "value" => [
2193                 %{
2194                   "tuple" => [
2195                     ":http",
2196                     [
2197                       %{
2198                         "tuple" => [
2199                           ":key2",
2200                           [
2201                             %{
2202                               "tuple" => [
2203                                 ":_",
2204                                 [
2205                                   %{
2206                                     "tuple" => [
2207                                       "/api/v1/streaming",
2208                                       "Pleroma.Web.MastodonAPI.WebsocketHandler",
2209                                       []
2210                                     ]
2211                                   },
2212                                   %{
2213                                     "tuple" => [
2214                                       "/websocket",
2215                                       "Phoenix.Endpoint.CowboyWebSocket",
2216                                       %{
2217                                         "tuple" => [
2218                                           "Phoenix.Transports.WebSocket",
2219                                           %{
2220                                             "tuple" => [
2221                                               "Pleroma.Web.Endpoint",
2222                                               "Pleroma.Web.UserSocket",
2223                                               []
2224                                             ]
2225                                           }
2226                                         ]
2227                                       }
2228                                     ]
2229                                   },
2230                                   %{
2231                                     "tuple" => [
2232                                       ":_",
2233                                       "Phoenix.Endpoint.Cowboy2Handler",
2234                                       %{"tuple" => ["Pleroma.Web.Endpoint", []]}
2235                                     ]
2236                                   }
2237                                 ]
2238                               ]
2239                             }
2240                           ]
2241                         ]
2242                       }
2243                     ]
2244                   ]
2245                 }
2246               ]
2247             }
2248           ]
2249         })
2250
2251       assert json_response(conn, 200) == %{
2252                "configs" => [
2253                  %{
2254                    "group" => "pleroma",
2255                    "key" => "Pleroma.Web.Endpoint.NotReal",
2256                    "value" => [
2257                      %{
2258                        "tuple" => [
2259                          ":http",
2260                          [
2261                            %{
2262                              "tuple" => [
2263                                ":key2",
2264                                [
2265                                  %{
2266                                    "tuple" => [
2267                                      ":_",
2268                                      [
2269                                        %{
2270                                          "tuple" => [
2271                                            "/api/v1/streaming",
2272                                            "Pleroma.Web.MastodonAPI.WebsocketHandler",
2273                                            []
2274                                          ]
2275                                        },
2276                                        %{
2277                                          "tuple" => [
2278                                            "/websocket",
2279                                            "Phoenix.Endpoint.CowboyWebSocket",
2280                                            %{
2281                                              "tuple" => [
2282                                                "Phoenix.Transports.WebSocket",
2283                                                %{
2284                                                  "tuple" => [
2285                                                    "Pleroma.Web.Endpoint",
2286                                                    "Pleroma.Web.UserSocket",
2287                                                    []
2288                                                  ]
2289                                                }
2290                                              ]
2291                                            }
2292                                          ]
2293                                        },
2294                                        %{
2295                                          "tuple" => [
2296                                            ":_",
2297                                            "Phoenix.Endpoint.Cowboy2Handler",
2298                                            %{"tuple" => ["Pleroma.Web.Endpoint", []]}
2299                                          ]
2300                                        }
2301                                      ]
2302                                    ]
2303                                  }
2304                                ]
2305                              ]
2306                            }
2307                          ]
2308                        ]
2309                      }
2310                    ]
2311                  }
2312                ]
2313              }
2314     end
2315
2316     test "settings with nesting map", %{conn: conn} do
2317       conn =
2318         post(conn, "/api/pleroma/admin/config", %{
2319           configs: [
2320             %{
2321               "group" => "pleroma",
2322               "key" => ":key1",
2323               "value" => [
2324                 %{"tuple" => [":key2", "some_val"]},
2325                 %{
2326                   "tuple" => [
2327                     ":key3",
2328                     %{
2329                       ":max_options" => 20,
2330                       ":max_option_chars" => 200,
2331                       ":min_expiration" => 0,
2332                       ":max_expiration" => 31_536_000,
2333                       "nested" => %{
2334                         ":max_options" => 20,
2335                         ":max_option_chars" => 200,
2336                         ":min_expiration" => 0,
2337                         ":max_expiration" => 31_536_000
2338                       }
2339                     }
2340                   ]
2341                 }
2342               ]
2343             }
2344           ]
2345         })
2346
2347       assert json_response(conn, 200) ==
2348                %{
2349                  "configs" => [
2350                    %{
2351                      "group" => "pleroma",
2352                      "key" => ":key1",
2353                      "value" => [
2354                        %{"tuple" => [":key2", "some_val"]},
2355                        %{
2356                          "tuple" => [
2357                            ":key3",
2358                            %{
2359                              ":max_expiration" => 31_536_000,
2360                              ":max_option_chars" => 200,
2361                              ":max_options" => 20,
2362                              ":min_expiration" => 0,
2363                              "nested" => %{
2364                                ":max_expiration" => 31_536_000,
2365                                ":max_option_chars" => 200,
2366                                ":max_options" => 20,
2367                                ":min_expiration" => 0
2368                              }
2369                            }
2370                          ]
2371                        }
2372                      ]
2373                    }
2374                  ]
2375                }
2376     end
2377
2378     test "value as map", %{conn: conn} do
2379       conn =
2380         post(conn, "/api/pleroma/admin/config", %{
2381           configs: [
2382             %{
2383               "group" => "pleroma",
2384               "key" => ":key1",
2385               "value" => %{"key" => "some_val"}
2386             }
2387           ]
2388         })
2389
2390       assert json_response(conn, 200) ==
2391                %{
2392                  "configs" => [
2393                    %{
2394                      "group" => "pleroma",
2395                      "key" => ":key1",
2396                      "value" => %{"key" => "some_val"}
2397                    }
2398                  ]
2399                }
2400     end
2401
2402     test "dispatch setting", %{conn: conn} do
2403       conn =
2404         post(conn, "/api/pleroma/admin/config", %{
2405           configs: [
2406             %{
2407               "group" => "pleroma",
2408               "key" => "Pleroma.Web.Endpoint.NotReal",
2409               "value" => [
2410                 %{
2411                   "tuple" => [
2412                     ":http",
2413                     [
2414                       %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2415                       %{"tuple" => [":dispatch", ["{:_,
2416        [
2417          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
2418          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
2419           {Phoenix.Transports.WebSocket,
2420            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
2421          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
2422        ]}"]]}
2423                     ]
2424                   ]
2425                 }
2426               ]
2427             }
2428           ]
2429         })
2430
2431       dispatch_string =
2432         "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
2433           "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
2434           "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
2435           "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
2436
2437       assert json_response(conn, 200) == %{
2438                "configs" => [
2439                  %{
2440                    "group" => "pleroma",
2441                    "key" => "Pleroma.Web.Endpoint.NotReal",
2442                    "value" => [
2443                      %{
2444                        "tuple" => [
2445                          ":http",
2446                          [
2447                            %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2448                            %{
2449                              "tuple" => [
2450                                ":dispatch",
2451                                [
2452                                  dispatch_string
2453                                ]
2454                              ]
2455                            }
2456                          ]
2457                        ]
2458                      }
2459                    ]
2460                  }
2461                ]
2462              }
2463     end
2464
2465     test "queues key as atom", %{conn: conn} do
2466       conn =
2467         post(conn, "/api/pleroma/admin/config", %{
2468           configs: [
2469             %{
2470               "group" => "oban",
2471               "key" => ":queues",
2472               "value" => [
2473                 %{"tuple" => [":federator_incoming", 50]},
2474                 %{"tuple" => [":federator_outgoing", 50]},
2475                 %{"tuple" => [":web_push", 50]},
2476                 %{"tuple" => [":mailer", 10]},
2477                 %{"tuple" => [":transmogrifier", 20]},
2478                 %{"tuple" => [":scheduled_activities", 10]},
2479                 %{"tuple" => [":background", 5]}
2480               ]
2481             }
2482           ]
2483         })
2484
2485       assert json_response(conn, 200) == %{
2486                "configs" => [
2487                  %{
2488                    "group" => "oban",
2489                    "key" => ":queues",
2490                    "value" => [
2491                      %{"tuple" => [":federator_incoming", 50]},
2492                      %{"tuple" => [":federator_outgoing", 50]},
2493                      %{"tuple" => [":web_push", 50]},
2494                      %{"tuple" => [":mailer", 10]},
2495                      %{"tuple" => [":transmogrifier", 20]},
2496                      %{"tuple" => [":scheduled_activities", 10]},
2497                      %{"tuple" => [":background", 5]}
2498                    ]
2499                  }
2500                ]
2501              }
2502     end
2503
2504     test "delete part of settings by atom subkeys", %{conn: conn} do
2505       config =
2506         insert(:config,
2507           key: "keyaa1",
2508           value: :erlang.term_to_binary(subkey1: "val1", subkey2: "val2", subkey3: "val3")
2509         )
2510
2511       conn =
2512         post(conn, "/api/pleroma/admin/config", %{
2513           configs: [
2514             %{
2515               group: config.group,
2516               key: config.key,
2517               subkeys: [":subkey1", ":subkey3"],
2518               delete: "true"
2519             }
2520           ]
2521         })
2522
2523       assert(
2524         json_response(conn, 200) == %{
2525           "configs" => [
2526             %{
2527               "group" => "pleroma",
2528               "key" => "keyaa1",
2529               "value" => [%{"tuple" => [":subkey2", "val2"]}]
2530             }
2531           ]
2532         }
2533       )
2534     end
2535   end
2536
2537   describe "config mix tasks run" do
2538     setup %{conn: conn} do
2539       admin = insert(:user, is_admin: true)
2540
2541       temp_file = "config/test.exported_from_db.secret.exs"
2542
2543       Mix.shell(Mix.Shell.Quiet)
2544
2545       on_exit(fn ->
2546         Mix.shell(Mix.Shell.IO)
2547         :ok = File.rm(temp_file)
2548       end)
2549
2550       %{conn: assign(conn, :user, admin), admin: admin}
2551     end
2552
2553     clear_config([:instance, :dynamic_configuration]) do
2554       Pleroma.Config.put([:instance, :dynamic_configuration], true)
2555     end
2556
2557     clear_config([:feed, :post_title]) do
2558       Pleroma.Config.put([:feed, :post_title], %{max_length: 100, omission: "…"})
2559     end
2560
2561     test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
2562       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2563       conn = get(conn, "/api/pleroma/admin/config/migrate_to_db")
2564       assert json_response(conn, 200) == %{}
2565       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) > 0
2566
2567       conn =
2568         build_conn()
2569         |> assign(:user, admin)
2570         |> get("/api/pleroma/admin/config/migrate_from_db")
2571
2572       assert json_response(conn, 200) == %{}
2573       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2574     end
2575   end
2576
2577   describe "GET /api/pleroma/admin/users/:nickname/statuses" do
2578     setup do
2579       admin = insert(:user, is_admin: true)
2580       user = insert(:user)
2581
2582       date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
2583       date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
2584       date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
2585
2586       insert(:note_activity, user: user, published: date1)
2587       insert(:note_activity, user: user, published: date2)
2588       insert(:note_activity, user: user, published: date3)
2589
2590       conn =
2591         build_conn()
2592         |> assign(:user, admin)
2593
2594       {:ok, conn: conn, user: user}
2595     end
2596
2597     test "renders user's statuses", %{conn: conn, user: user} do
2598       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2599
2600       assert json_response(conn, 200) |> length() == 3
2601     end
2602
2603     test "renders user's statuses with a limit", %{conn: conn, user: user} do
2604       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
2605
2606       assert json_response(conn, 200) |> length() == 2
2607     end
2608
2609     test "doesn't return private statuses by default", %{conn: conn, user: user} do
2610       {:ok, _private_status} =
2611         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2612
2613       {:ok, _public_status} =
2614         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2615
2616       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2617
2618       assert json_response(conn, 200) |> length() == 4
2619     end
2620
2621     test "returns private statuses with godmode on", %{conn: conn, user: user} do
2622       {:ok, _private_status} =
2623         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2624
2625       {:ok, _public_status} =
2626         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2627
2628       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
2629
2630       assert json_response(conn, 200) |> length() == 5
2631     end
2632   end
2633
2634   describe "GET /api/pleroma/admin/moderation_log" do
2635     setup %{conn: conn} do
2636       admin = insert(:user, is_admin: true)
2637       moderator = insert(:user, is_moderator: true)
2638
2639       %{conn: assign(conn, :user, admin), admin: admin, moderator: moderator}
2640     end
2641
2642     test "returns the log", %{conn: conn, admin: admin} do
2643       Repo.insert(%ModerationLog{
2644         data: %{
2645           actor: %{
2646             "id" => admin.id,
2647             "nickname" => admin.nickname,
2648             "type" => "user"
2649           },
2650           action: "relay_follow",
2651           target: "https://example.org/relay"
2652         },
2653         inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2654       })
2655
2656       Repo.insert(%ModerationLog{
2657         data: %{
2658           actor: %{
2659             "id" => admin.id,
2660             "nickname" => admin.nickname,
2661             "type" => "user"
2662           },
2663           action: "relay_unfollow",
2664           target: "https://example.org/relay"
2665         },
2666         inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2667       })
2668
2669       conn = get(conn, "/api/pleroma/admin/moderation_log")
2670
2671       response = json_response(conn, 200)
2672       [first_entry, second_entry] = response["items"]
2673
2674       assert response["total"] == 2
2675       assert first_entry["data"]["action"] == "relay_unfollow"
2676
2677       assert first_entry["message"] ==
2678                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2679
2680       assert second_entry["data"]["action"] == "relay_follow"
2681
2682       assert second_entry["message"] ==
2683                "@#{admin.nickname} followed relay: https://example.org/relay"
2684     end
2685
2686     test "returns the log with pagination", %{conn: conn, admin: admin} do
2687       Repo.insert(%ModerationLog{
2688         data: %{
2689           actor: %{
2690             "id" => admin.id,
2691             "nickname" => admin.nickname,
2692             "type" => "user"
2693           },
2694           action: "relay_follow",
2695           target: "https://example.org/relay"
2696         },
2697         inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2698       })
2699
2700       Repo.insert(%ModerationLog{
2701         data: %{
2702           actor: %{
2703             "id" => admin.id,
2704             "nickname" => admin.nickname,
2705             "type" => "user"
2706           },
2707           action: "relay_unfollow",
2708           target: "https://example.org/relay"
2709         },
2710         inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2711       })
2712
2713       conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
2714
2715       response1 = json_response(conn1, 200)
2716       [first_entry] = response1["items"]
2717
2718       assert response1["total"] == 2
2719       assert response1["items"] |> length() == 1
2720       assert first_entry["data"]["action"] == "relay_unfollow"
2721
2722       assert first_entry["message"] ==
2723                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2724
2725       conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
2726
2727       response2 = json_response(conn2, 200)
2728       [second_entry] = response2["items"]
2729
2730       assert response2["total"] == 2
2731       assert response2["items"] |> length() == 1
2732       assert second_entry["data"]["action"] == "relay_follow"
2733
2734       assert second_entry["message"] ==
2735                "@#{admin.nickname} followed relay: https://example.org/relay"
2736     end
2737
2738     test "filters log by date", %{conn: conn, admin: admin} do
2739       first_date = "2017-08-15T15:47:06Z"
2740       second_date = "2017-08-20T15:47:06Z"
2741
2742       Repo.insert(%ModerationLog{
2743         data: %{
2744           actor: %{
2745             "id" => admin.id,
2746             "nickname" => admin.nickname,
2747             "type" => "user"
2748           },
2749           action: "relay_follow",
2750           target: "https://example.org/relay"
2751         },
2752         inserted_at: NaiveDateTime.from_iso8601!(first_date)
2753       })
2754
2755       Repo.insert(%ModerationLog{
2756         data: %{
2757           actor: %{
2758             "id" => admin.id,
2759             "nickname" => admin.nickname,
2760             "type" => "user"
2761           },
2762           action: "relay_unfollow",
2763           target: "https://example.org/relay"
2764         },
2765         inserted_at: NaiveDateTime.from_iso8601!(second_date)
2766       })
2767
2768       conn1 =
2769         get(
2770           conn,
2771           "/api/pleroma/admin/moderation_log?start_date=#{second_date}"
2772         )
2773
2774       response1 = json_response(conn1, 200)
2775       [first_entry] = response1["items"]
2776
2777       assert response1["total"] == 1
2778       assert first_entry["data"]["action"] == "relay_unfollow"
2779
2780       assert first_entry["message"] ==
2781                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2782     end
2783
2784     test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
2785       Repo.insert(%ModerationLog{
2786         data: %{
2787           actor: %{
2788             "id" => admin.id,
2789             "nickname" => admin.nickname,
2790             "type" => "user"
2791           },
2792           action: "relay_follow",
2793           target: "https://example.org/relay"
2794         }
2795       })
2796
2797       Repo.insert(%ModerationLog{
2798         data: %{
2799           actor: %{
2800             "id" => moderator.id,
2801             "nickname" => moderator.nickname,
2802             "type" => "user"
2803           },
2804           action: "relay_unfollow",
2805           target: "https://example.org/relay"
2806         }
2807       })
2808
2809       conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")
2810
2811       response1 = json_response(conn1, 200)
2812       [first_entry] = response1["items"]
2813
2814       assert response1["total"] == 1
2815       assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
2816     end
2817
2818     test "returns log filtered by search", %{conn: conn, moderator: moderator} do
2819       ModerationLog.insert_log(%{
2820         actor: moderator,
2821         action: "relay_follow",
2822         target: "https://example.org/relay"
2823       })
2824
2825       ModerationLog.insert_log(%{
2826         actor: moderator,
2827         action: "relay_unfollow",
2828         target: "https://example.org/relay"
2829       })
2830
2831       conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")
2832
2833       response1 = json_response(conn1, 200)
2834       [first_entry] = response1["items"]
2835
2836       assert response1["total"] == 1
2837
2838       assert get_in(first_entry, ["data", "message"]) ==
2839                "@#{moderator.nickname} unfollowed relay: https://example.org/relay"
2840     end
2841   end
2842
2843   describe "PATCH /users/:nickname/force_password_reset" do
2844     setup %{conn: conn} do
2845       admin = insert(:user, is_admin: true)
2846       user = insert(:user)
2847
2848       %{conn: assign(conn, :user, admin), admin: admin, user: user}
2849     end
2850
2851     test "sets password_reset_pending to true", %{admin: admin, user: user} do
2852       assert user.password_reset_pending == false
2853
2854       conn =
2855         build_conn()
2856         |> assign(:user, admin)
2857         |> patch("/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})
2858
2859       assert json_response(conn, 204) == ""
2860
2861       ObanHelpers.perform_all()
2862
2863       assert User.get_by_id(user.id).password_reset_pending == true
2864     end
2865   end
2866
2867   describe "relays" do
2868     setup %{conn: conn} do
2869       admin = insert(:user, is_admin: true)
2870
2871       %{conn: assign(conn, :user, admin), admin: admin}
2872     end
2873
2874     test "POST /relay", %{admin: admin} do
2875       conn =
2876         build_conn()
2877         |> assign(:user, admin)
2878         |> post("/api/pleroma/admin/relay", %{
2879           relay_url: "http://mastodon.example.org/users/admin"
2880         })
2881
2882       assert json_response(conn, 200) == "http://mastodon.example.org/users/admin"
2883
2884       log_entry = Repo.one(ModerationLog)
2885
2886       assert ModerationLog.get_log_entry_message(log_entry) ==
2887                "@#{admin.nickname} followed relay: http://mastodon.example.org/users/admin"
2888     end
2889
2890     test "GET /relay", %{admin: admin} do
2891       relay_user = Pleroma.Web.ActivityPub.Relay.get_actor()
2892
2893       ["http://mastodon.example.org/users/admin", "https://mstdn.io/users/mayuutann"]
2894       |> Enum.each(fn ap_id ->
2895         {:ok, user} = User.get_or_fetch_by_ap_id(ap_id)
2896         User.follow(relay_user, user)
2897       end)
2898
2899       conn =
2900         build_conn()
2901         |> assign(:user, admin)
2902         |> get("/api/pleroma/admin/relay")
2903
2904       assert json_response(conn, 200)["relays"] -- ["mastodon.example.org", "mstdn.io"] == []
2905     end
2906
2907     test "DELETE /relay", %{admin: admin} do
2908       build_conn()
2909       |> assign(:user, admin)
2910       |> post("/api/pleroma/admin/relay", %{
2911         relay_url: "http://mastodon.example.org/users/admin"
2912       })
2913
2914       conn =
2915         build_conn()
2916         |> assign(:user, admin)
2917         |> delete("/api/pleroma/admin/relay", %{
2918           relay_url: "http://mastodon.example.org/users/admin"
2919         })
2920
2921       assert json_response(conn, 200) == "http://mastodon.example.org/users/admin"
2922
2923       [log_entry_one, log_entry_two] = Repo.all(ModerationLog)
2924
2925       assert ModerationLog.get_log_entry_message(log_entry_one) ==
2926                "@#{admin.nickname} followed relay: http://mastodon.example.org/users/admin"
2927
2928       assert ModerationLog.get_log_entry_message(log_entry_two) ==
2929                "@#{admin.nickname} unfollowed relay: http://mastodon.example.org/users/admin"
2930     end
2931   end
2932
2933   describe "instances" do
2934     test "GET /instances/:instance/statuses" do
2935       admin = insert(:user, is_admin: true)
2936       user = insert(:user, local: false, nickname: "archaeme@archae.me")
2937       user2 = insert(:user, local: false, nickname: "test@test.com")
2938       insert_pair(:note_activity, user: user)
2939       insert(:note_activity, user: user2)
2940
2941       conn =
2942         build_conn()
2943         |> assign(:user, admin)
2944         |> get("/api/pleroma/admin/instances/archae.me/statuses")
2945
2946       response = json_response(conn, 200)
2947
2948       assert length(response) == 2
2949
2950       conn =
2951         build_conn()
2952         |> assign(:user, admin)
2953         |> get("/api/pleroma/admin/instances/test.com/statuses")
2954
2955       response = json_response(conn, 200)
2956
2957       assert length(response) == 1
2958
2959       conn =
2960         build_conn()
2961         |> assign(:user, admin)
2962         |> get("/api/pleroma/admin/instances/nonexistent.com/statuses")
2963
2964       response = json_response(conn, 200)
2965
2966       assert length(response) == 0
2967     end
2968   end
2969
2970   describe "PATCH /confirm_email" do
2971     setup %{conn: conn} do
2972       admin = insert(:user, is_admin: true)
2973
2974       %{conn: assign(conn, :user, admin), admin: admin}
2975     end
2976
2977     test "it confirms emails of two users", %{admin: admin} do
2978       [first_user, second_user] = insert_pair(:user, confirmation_pending: true)
2979
2980       assert first_user.confirmation_pending == true
2981       assert second_user.confirmation_pending == true
2982
2983       build_conn()
2984       |> assign(:user, admin)
2985       |> patch("/api/pleroma/admin/users/confirm_email", %{
2986         nicknames: [
2987           first_user.nickname,
2988           second_user.nickname
2989         ]
2990       })
2991
2992       assert first_user.confirmation_pending == true
2993       assert second_user.confirmation_pending == true
2994
2995       log_entry = Repo.one(ModerationLog)
2996
2997       assert ModerationLog.get_log_entry_message(log_entry) ==
2998                "@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{
2999                  second_user.nickname
3000                }"
3001     end
3002   end
3003
3004   describe "PATCH /resend_confirmation_email" do
3005     setup %{conn: conn} do
3006       admin = insert(:user, is_admin: true)
3007
3008       %{conn: assign(conn, :user, admin), admin: admin}
3009     end
3010
3011     test "it resend emails for two users", %{admin: admin} do
3012       [first_user, second_user] = insert_pair(:user, confirmation_pending: true)
3013
3014       build_conn()
3015       |> assign(:user, admin)
3016       |> patch("/api/pleroma/admin/users/resend_confirmation_email", %{
3017         nicknames: [
3018           first_user.nickname,
3019           second_user.nickname
3020         ]
3021       })
3022
3023       log_entry = Repo.one(ModerationLog)
3024
3025       assert ModerationLog.get_log_entry_message(log_entry) ==
3026                "@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{
3027                  second_user.nickname
3028                }"
3029     end
3030   end
3031
3032   describe "POST /reports/:id/notes" do
3033     setup do
3034       admin = insert(:user, is_admin: true)
3035       [reporter, target_user] = insert_pair(:user)
3036       activity = insert(:note_activity, user: target_user)
3037
3038       {:ok, %{id: report_id}} =
3039         CommonAPI.report(reporter, %{
3040           "account_id" => target_user.id,
3041           "comment" => "I feel offended",
3042           "status_ids" => [activity.id]
3043         })
3044
3045       build_conn()
3046       |> assign(:user, admin)
3047       |> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
3048         content: "this is disgusting!"
3049       })
3050
3051       build_conn()
3052       |> assign(:user, admin)
3053       |> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
3054         content: "this is disgusting2!"
3055       })
3056
3057       %{
3058         admin_id: admin.id,
3059         report_id: report_id,
3060         admin: admin
3061       }
3062     end
3063
3064     test "it creates report note", %{admin_id: admin_id, report_id: report_id} do
3065       [note, _] = Repo.all(ReportNote)
3066
3067       assert %{
3068                activity_id: ^report_id,
3069                content: "this is disgusting!",
3070                user_id: ^admin_id
3071              } = note
3072     end
3073
3074     test "it returns reports with notes", %{admin: admin} do
3075       conn =
3076         build_conn()
3077         |> assign(:user, admin)
3078         |> get("/api/pleroma/admin/reports")
3079
3080       response = json_response(conn, 200)
3081       notes = hd(response["reports"])["notes"]
3082       [note, _] = notes
3083
3084       assert note["user"]["nickname"] == admin.nickname
3085       assert note["content"] == "this is disgusting!"
3086       assert note["created_at"]
3087       assert response["total"] == 1
3088     end
3089
3090     test "it deletes the note", %{admin: admin, report_id: report_id} do
3091       assert ReportNote |> Repo.all() |> length() == 2
3092
3093       [note, _] = Repo.all(ReportNote)
3094
3095       build_conn()
3096       |> assign(:user, admin)
3097       |> delete("/api/pleroma/admin/reports/#{report_id}/notes/#{note.id}")
3098
3099       assert ReportNote |> Repo.all() |> length() == 1
3100     end
3101   end
3102 end
3103
3104 # Needed for testing
3105 defmodule Pleroma.Web.Endpoint.NotReal do
3106 end
3107
3108 defmodule Pleroma.Captcha.NotReal do
3109 end