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