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