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