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

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