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       assert response["total"] == 0
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
1336       assert response["total"] == 1
1337     end
1338
1339     test "returns reports with specified state", %{conn: conn} do
1340       [reporter, target_user] = insert_pair(:user)
1341       activity = insert(:note_activity, user: target_user)
1342
1343       {:ok, %{id: first_report_id}} =
1344         CommonAPI.report(reporter, %{
1345           "account_id" => target_user.id,
1346           "comment" => "I feel offended",
1347           "status_ids" => [activity.id]
1348         })
1349
1350       {:ok, %{id: second_report_id}} =
1351         CommonAPI.report(reporter, %{
1352           "account_id" => target_user.id,
1353           "comment" => "I don't like this user"
1354         })
1355
1356       CommonAPI.update_report_state(second_report_id, "closed")
1357
1358       response =
1359         conn
1360         |> get("/api/pleroma/admin/reports", %{
1361           "state" => "open"
1362         })
1363         |> json_response(:ok)
1364
1365       [open_report] = response["reports"]
1366
1367       assert length(response["reports"]) == 1
1368       assert open_report["id"] == first_report_id
1369
1370       assert response["total"] == 1
1371
1372       response =
1373         conn
1374         |> get("/api/pleroma/admin/reports", %{
1375           "state" => "closed"
1376         })
1377         |> json_response(:ok)
1378
1379       [closed_report] = response["reports"]
1380
1381       assert length(response["reports"]) == 1
1382       assert closed_report["id"] == second_report_id
1383
1384       assert response["total"] == 1
1385
1386       response =
1387         conn
1388         |> get("/api/pleroma/admin/reports", %{
1389           "state" => "resolved"
1390         })
1391         |> json_response(:ok)
1392
1393       assert Enum.empty?(response["reports"])
1394       assert response["total"] == 0
1395     end
1396
1397     test "returns 403 when requested by a non-admin" do
1398       user = insert(:user)
1399
1400       conn =
1401         build_conn()
1402         |> assign(:user, user)
1403         |> get("/api/pleroma/admin/reports")
1404
1405       assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1406     end
1407
1408     test "returns 403 when requested by anonymous" do
1409       conn =
1410         build_conn()
1411         |> get("/api/pleroma/admin/reports")
1412
1413       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1414     end
1415   end
1416
1417   #
1418   describe "POST /api/pleroma/admin/reports/:id/respond" do
1419     setup %{conn: conn} do
1420       admin = insert(:user, info: %{is_admin: true})
1421
1422       %{conn: assign(conn, :user, admin), admin: admin}
1423     end
1424
1425     test "returns created dm", %{conn: conn, admin: admin} do
1426       [reporter, target_user] = insert_pair(:user)
1427       activity = insert(:note_activity, user: target_user)
1428
1429       {:ok, %{id: report_id}} =
1430         CommonAPI.report(reporter, %{
1431           "account_id" => target_user.id,
1432           "comment" => "I feel offended",
1433           "status_ids" => [activity.id]
1434         })
1435
1436       response =
1437         conn
1438         |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1439           "status" => "I will check it out"
1440         })
1441         |> json_response(:ok)
1442
1443       recipients = Enum.map(response["mentions"], & &1["username"])
1444
1445       assert reporter.nickname in recipients
1446       assert response["content"] == "I will check it out"
1447       assert response["visibility"] == "direct"
1448
1449       log_entry = Repo.one(ModerationLog)
1450
1451       assert ModerationLog.get_log_entry_message(log_entry) ==
1452                "@#{admin.nickname} responded with 'I will check it out' to report ##{
1453                  response["id"]
1454                }"
1455     end
1456
1457     test "returns 400 when status is missing", %{conn: conn} do
1458       conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1459
1460       assert json_response(conn, :bad_request) == "Invalid parameters"
1461     end
1462
1463     test "returns 404 when report id is invalid", %{conn: conn} do
1464       conn =
1465         post(conn, "/api/pleroma/admin/reports/test/respond", %{
1466           "status" => "foo"
1467         })
1468
1469       assert json_response(conn, :not_found) == "Not found"
1470     end
1471   end
1472
1473   describe "PUT /api/pleroma/admin/statuses/:id" do
1474     setup %{conn: conn} do
1475       admin = insert(:user, info: %{is_admin: true})
1476       activity = insert(:note_activity)
1477
1478       %{conn: assign(conn, :user, admin), id: activity.id, admin: admin}
1479     end
1480
1481     test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
1482       response =
1483         conn
1484         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1485         |> json_response(:ok)
1486
1487       assert response["sensitive"]
1488
1489       log_entry = Repo.one(ModerationLog)
1490
1491       assert ModerationLog.get_log_entry_message(log_entry) ==
1492                "@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"
1493
1494       response =
1495         conn
1496         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1497         |> json_response(:ok)
1498
1499       refute response["sensitive"]
1500     end
1501
1502     test "change visibility flag", %{conn: conn, id: id, admin: admin} do
1503       response =
1504         conn
1505         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1506         |> json_response(:ok)
1507
1508       assert response["visibility"] == "public"
1509
1510       log_entry = Repo.one(ModerationLog)
1511
1512       assert ModerationLog.get_log_entry_message(log_entry) ==
1513                "@#{admin.nickname} updated status ##{id}, set visibility: 'public'"
1514
1515       response =
1516         conn
1517         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1518         |> json_response(:ok)
1519
1520       assert response["visibility"] == "private"
1521
1522       response =
1523         conn
1524         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1525         |> json_response(:ok)
1526
1527       assert response["visibility"] == "unlisted"
1528     end
1529
1530     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1531       conn =
1532         conn
1533         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1534
1535       assert json_response(conn, :bad_request) == "Unsupported visibility"
1536     end
1537   end
1538
1539   describe "DELETE /api/pleroma/admin/statuses/:id" do
1540     setup %{conn: conn} do
1541       admin = insert(:user, info: %{is_admin: true})
1542       activity = insert(:note_activity)
1543
1544       %{conn: assign(conn, :user, admin), id: activity.id, admin: admin}
1545     end
1546
1547     test "deletes status", %{conn: conn, id: id, admin: admin} do
1548       conn
1549       |> delete("/api/pleroma/admin/statuses/#{id}")
1550       |> json_response(:ok)
1551
1552       refute Activity.get_by_id(id)
1553
1554       log_entry = Repo.one(ModerationLog)
1555
1556       assert ModerationLog.get_log_entry_message(log_entry) ==
1557                "@#{admin.nickname} deleted status ##{id}"
1558     end
1559
1560     test "returns error when status is not exist", %{conn: conn} do
1561       conn =
1562         conn
1563         |> delete("/api/pleroma/admin/statuses/test")
1564
1565       assert json_response(conn, :bad_request) == "Could not delete"
1566     end
1567   end
1568
1569   describe "GET /api/pleroma/admin/config" do
1570     setup %{conn: conn} do
1571       admin = insert(:user, info: %{is_admin: true})
1572
1573       %{conn: assign(conn, :user, admin)}
1574     end
1575
1576     test "without any settings in db", %{conn: conn} do
1577       conn = get(conn, "/api/pleroma/admin/config")
1578
1579       assert json_response(conn, 200) == %{"configs" => []}
1580     end
1581
1582     test "with settings in db", %{conn: conn} do
1583       config1 = insert(:config)
1584       config2 = insert(:config)
1585
1586       conn = get(conn, "/api/pleroma/admin/config")
1587
1588       %{
1589         "configs" => [
1590           %{
1591             "key" => key1,
1592             "value" => _
1593           },
1594           %{
1595             "key" => key2,
1596             "value" => _
1597           }
1598         ]
1599       } = json_response(conn, 200)
1600
1601       assert key1 == config1.key
1602       assert key2 == config2.key
1603     end
1604   end
1605
1606   describe "POST /api/pleroma/admin/config" do
1607     setup %{conn: conn} do
1608       admin = insert(:user, info: %{is_admin: true})
1609
1610       temp_file = "config/test.exported_from_db.secret.exs"
1611
1612       on_exit(fn ->
1613         Application.delete_env(:pleroma, :key1)
1614         Application.delete_env(:pleroma, :key2)
1615         Application.delete_env(:pleroma, :key3)
1616         Application.delete_env(:pleroma, :key4)
1617         Application.delete_env(:pleroma, :keyaa1)
1618         Application.delete_env(:pleroma, :keyaa2)
1619         Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1620         Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1621         :ok = File.rm(temp_file)
1622       end)
1623
1624       %{conn: assign(conn, :user, admin)}
1625     end
1626
1627     clear_config([:instance, :dynamic_configuration]) do
1628       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1629     end
1630
1631     test "create new config setting in db", %{conn: conn} do
1632       conn =
1633         post(conn, "/api/pleroma/admin/config", %{
1634           configs: [
1635             %{group: "pleroma", key: "key1", value: "value1"},
1636             %{
1637               group: "ueberauth",
1638               key: "Ueberauth.Strategy.Twitter.OAuth",
1639               value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
1640             },
1641             %{
1642               group: "pleroma",
1643               key: "key2",
1644               value: %{
1645                 ":nested_1" => "nested_value1",
1646                 ":nested_2" => [
1647                   %{":nested_22" => "nested_value222"},
1648                   %{":nested_33" => %{":nested_44" => "nested_444"}}
1649                 ]
1650               }
1651             },
1652             %{
1653               group: "pleroma",
1654               key: "key3",
1655               value: [
1656                 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1657                 %{"nested_4" => true}
1658               ]
1659             },
1660             %{
1661               group: "pleroma",
1662               key: "key4",
1663               value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
1664             },
1665             %{
1666               group: "idna",
1667               key: "key5",
1668               value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1669             }
1670           ]
1671         })
1672
1673       assert json_response(conn, 200) == %{
1674                "configs" => [
1675                  %{
1676                    "group" => "pleroma",
1677                    "key" => "key1",
1678                    "value" => "value1"
1679                  },
1680                  %{
1681                    "group" => "ueberauth",
1682                    "key" => "Ueberauth.Strategy.Twitter.OAuth",
1683                    "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
1684                  },
1685                  %{
1686                    "group" => "pleroma",
1687                    "key" => "key2",
1688                    "value" => %{
1689                      ":nested_1" => "nested_value1",
1690                      ":nested_2" => [
1691                        %{":nested_22" => "nested_value222"},
1692                        %{":nested_33" => %{":nested_44" => "nested_444"}}
1693                      ]
1694                    }
1695                  },
1696                  %{
1697                    "group" => "pleroma",
1698                    "key" => "key3",
1699                    "value" => [
1700                      %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1701                      %{"nested_4" => true}
1702                    ]
1703                  },
1704                  %{
1705                    "group" => "pleroma",
1706                    "key" => "key4",
1707                    "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
1708                  },
1709                  %{
1710                    "group" => "idna",
1711                    "key" => "key5",
1712                    "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1713                  }
1714                ]
1715              }
1716
1717       assert Application.get_env(:pleroma, :key1) == "value1"
1718
1719       assert Application.get_env(:pleroma, :key2) == %{
1720                nested_1: "nested_value1",
1721                nested_2: [
1722                  %{nested_22: "nested_value222"},
1723                  %{nested_33: %{nested_44: "nested_444"}}
1724                ]
1725              }
1726
1727       assert Application.get_env(:pleroma, :key3) == [
1728                %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
1729                %{"nested_4" => true}
1730              ]
1731
1732       assert Application.get_env(:pleroma, :key4) == %{
1733                "endpoint" => "https://example.com",
1734                nested_5: :upload
1735              }
1736
1737       assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
1738     end
1739
1740     test "update config setting & delete", %{conn: conn} do
1741       config1 = insert(:config, key: "keyaa1")
1742       config2 = insert(:config, key: "keyaa2")
1743
1744       insert(:config,
1745         group: "ueberauth",
1746         key: "Ueberauth.Strategy.Microsoft.OAuth",
1747         value: :erlang.term_to_binary([])
1748       )
1749
1750       conn =
1751         post(conn, "/api/pleroma/admin/config", %{
1752           configs: [
1753             %{group: config1.group, key: config1.key, value: "another_value"},
1754             %{group: config2.group, key: config2.key, delete: "true"},
1755             %{
1756               group: "ueberauth",
1757               key: "Ueberauth.Strategy.Microsoft.OAuth",
1758               delete: "true"
1759             }
1760           ]
1761         })
1762
1763       assert json_response(conn, 200) == %{
1764                "configs" => [
1765                  %{
1766                    "group" => "pleroma",
1767                    "key" => config1.key,
1768                    "value" => "another_value"
1769                  }
1770                ]
1771              }
1772
1773       assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1774       refute Application.get_env(:pleroma, :keyaa2)
1775     end
1776
1777     test "common config example", %{conn: conn} do
1778       conn =
1779         post(conn, "/api/pleroma/admin/config", %{
1780           configs: [
1781             %{
1782               "group" => "pleroma",
1783               "key" => "Pleroma.Captcha.NotReal",
1784               "value" => [
1785                 %{"tuple" => [":enabled", false]},
1786                 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1787                 %{"tuple" => [":seconds_valid", 60]},
1788                 %{"tuple" => [":path", ""]},
1789                 %{"tuple" => [":key1", nil]},
1790                 %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
1791                 %{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
1792                 %{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
1793                 %{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
1794                 %{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]}
1795               ]
1796             }
1797           ]
1798         })
1799
1800       assert json_response(conn, 200) == %{
1801                "configs" => [
1802                  %{
1803                    "group" => "pleroma",
1804                    "key" => "Pleroma.Captcha.NotReal",
1805                    "value" => [
1806                      %{"tuple" => [":enabled", false]},
1807                      %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1808                      %{"tuple" => [":seconds_valid", 60]},
1809                      %{"tuple" => [":path", ""]},
1810                      %{"tuple" => [":key1", nil]},
1811                      %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
1812                      %{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
1813                      %{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
1814                      %{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
1815                      %{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]}
1816                    ]
1817                  }
1818                ]
1819              }
1820     end
1821
1822     test "tuples with more than two values", %{conn: conn} do
1823       conn =
1824         post(conn, "/api/pleroma/admin/config", %{
1825           configs: [
1826             %{
1827               "group" => "pleroma",
1828               "key" => "Pleroma.Web.Endpoint.NotReal",
1829               "value" => [
1830                 %{
1831                   "tuple" => [
1832                     ":http",
1833                     [
1834                       %{
1835                         "tuple" => [
1836                           ":key2",
1837                           [
1838                             %{
1839                               "tuple" => [
1840                                 ":_",
1841                                 [
1842                                   %{
1843                                     "tuple" => [
1844                                       "/api/v1/streaming",
1845                                       "Pleroma.Web.MastodonAPI.WebsocketHandler",
1846                                       []
1847                                     ]
1848                                   },
1849                                   %{
1850                                     "tuple" => [
1851                                       "/websocket",
1852                                       "Phoenix.Endpoint.CowboyWebSocket",
1853                                       %{
1854                                         "tuple" => [
1855                                           "Phoenix.Transports.WebSocket",
1856                                           %{
1857                                             "tuple" => [
1858                                               "Pleroma.Web.Endpoint",
1859                                               "Pleroma.Web.UserSocket",
1860                                               []
1861                                             ]
1862                                           }
1863                                         ]
1864                                       }
1865                                     ]
1866                                   },
1867                                   %{
1868                                     "tuple" => [
1869                                       ":_",
1870                                       "Phoenix.Endpoint.Cowboy2Handler",
1871                                       %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1872                                     ]
1873                                   }
1874                                 ]
1875                               ]
1876                             }
1877                           ]
1878                         ]
1879                       }
1880                     ]
1881                   ]
1882                 }
1883               ]
1884             }
1885           ]
1886         })
1887
1888       assert json_response(conn, 200) == %{
1889                "configs" => [
1890                  %{
1891                    "group" => "pleroma",
1892                    "key" => "Pleroma.Web.Endpoint.NotReal",
1893                    "value" => [
1894                      %{
1895                        "tuple" => [
1896                          ":http",
1897                          [
1898                            %{
1899                              "tuple" => [
1900                                ":key2",
1901                                [
1902                                  %{
1903                                    "tuple" => [
1904                                      ":_",
1905                                      [
1906                                        %{
1907                                          "tuple" => [
1908                                            "/api/v1/streaming",
1909                                            "Pleroma.Web.MastodonAPI.WebsocketHandler",
1910                                            []
1911                                          ]
1912                                        },
1913                                        %{
1914                                          "tuple" => [
1915                                            "/websocket",
1916                                            "Phoenix.Endpoint.CowboyWebSocket",
1917                                            %{
1918                                              "tuple" => [
1919                                                "Phoenix.Transports.WebSocket",
1920                                                %{
1921                                                  "tuple" => [
1922                                                    "Pleroma.Web.Endpoint",
1923                                                    "Pleroma.Web.UserSocket",
1924                                                    []
1925                                                  ]
1926                                                }
1927                                              ]
1928                                            }
1929                                          ]
1930                                        },
1931                                        %{
1932                                          "tuple" => [
1933                                            ":_",
1934                                            "Phoenix.Endpoint.Cowboy2Handler",
1935                                            %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1936                                          ]
1937                                        }
1938                                      ]
1939                                    ]
1940                                  }
1941                                ]
1942                              ]
1943                            }
1944                          ]
1945                        ]
1946                      }
1947                    ]
1948                  }
1949                ]
1950              }
1951     end
1952
1953     test "settings with nesting map", %{conn: conn} do
1954       conn =
1955         post(conn, "/api/pleroma/admin/config", %{
1956           configs: [
1957             %{
1958               "group" => "pleroma",
1959               "key" => ":key1",
1960               "value" => [
1961                 %{"tuple" => [":key2", "some_val"]},
1962                 %{
1963                   "tuple" => [
1964                     ":key3",
1965                     %{
1966                       ":max_options" => 20,
1967                       ":max_option_chars" => 200,
1968                       ":min_expiration" => 0,
1969                       ":max_expiration" => 31_536_000,
1970                       "nested" => %{
1971                         ":max_options" => 20,
1972                         ":max_option_chars" => 200,
1973                         ":min_expiration" => 0,
1974                         ":max_expiration" => 31_536_000
1975                       }
1976                     }
1977                   ]
1978                 }
1979               ]
1980             }
1981           ]
1982         })
1983
1984       assert json_response(conn, 200) ==
1985                %{
1986                  "configs" => [
1987                    %{
1988                      "group" => "pleroma",
1989                      "key" => ":key1",
1990                      "value" => [
1991                        %{"tuple" => [":key2", "some_val"]},
1992                        %{
1993                          "tuple" => [
1994                            ":key3",
1995                            %{
1996                              ":max_expiration" => 31_536_000,
1997                              ":max_option_chars" => 200,
1998                              ":max_options" => 20,
1999                              ":min_expiration" => 0,
2000                              "nested" => %{
2001                                ":max_expiration" => 31_536_000,
2002                                ":max_option_chars" => 200,
2003                                ":max_options" => 20,
2004                                ":min_expiration" => 0
2005                              }
2006                            }
2007                          ]
2008                        }
2009                      ]
2010                    }
2011                  ]
2012                }
2013     end
2014
2015     test "value as map", %{conn: conn} do
2016       conn =
2017         post(conn, "/api/pleroma/admin/config", %{
2018           configs: [
2019             %{
2020               "group" => "pleroma",
2021               "key" => ":key1",
2022               "value" => %{"key" => "some_val"}
2023             }
2024           ]
2025         })
2026
2027       assert json_response(conn, 200) ==
2028                %{
2029                  "configs" => [
2030                    %{
2031                      "group" => "pleroma",
2032                      "key" => ":key1",
2033                      "value" => %{"key" => "some_val"}
2034                    }
2035                  ]
2036                }
2037     end
2038
2039     test "dispatch setting", %{conn: conn} do
2040       conn =
2041         post(conn, "/api/pleroma/admin/config", %{
2042           configs: [
2043             %{
2044               "group" => "pleroma",
2045               "key" => "Pleroma.Web.Endpoint.NotReal",
2046               "value" => [
2047                 %{
2048                   "tuple" => [
2049                     ":http",
2050                     [
2051                       %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2052                       %{"tuple" => [":dispatch", ["{:_,
2053        [
2054          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
2055          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
2056           {Phoenix.Transports.WebSocket,
2057            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
2058          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
2059        ]}"]]}
2060                     ]
2061                   ]
2062                 }
2063               ]
2064             }
2065           ]
2066         })
2067
2068       dispatch_string =
2069         "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
2070           "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
2071           "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
2072           "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
2073
2074       assert json_response(conn, 200) == %{
2075                "configs" => [
2076                  %{
2077                    "group" => "pleroma",
2078                    "key" => "Pleroma.Web.Endpoint.NotReal",
2079                    "value" => [
2080                      %{
2081                        "tuple" => [
2082                          ":http",
2083                          [
2084                            %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2085                            %{
2086                              "tuple" => [
2087                                ":dispatch",
2088                                [
2089                                  dispatch_string
2090                                ]
2091                              ]
2092                            }
2093                          ]
2094                        ]
2095                      }
2096                    ]
2097                  }
2098                ]
2099              }
2100     end
2101
2102     test "queues key as atom", %{conn: conn} do
2103       conn =
2104         post(conn, "/api/pleroma/admin/config", %{
2105           configs: [
2106             %{
2107               "group" => "oban",
2108               "key" => ":queues",
2109               "value" => [
2110                 %{"tuple" => [":federator_incoming", 50]},
2111                 %{"tuple" => [":federator_outgoing", 50]},
2112                 %{"tuple" => [":web_push", 50]},
2113                 %{"tuple" => [":mailer", 10]},
2114                 %{"tuple" => [":transmogrifier", 20]},
2115                 %{"tuple" => [":scheduled_activities", 10]},
2116                 %{"tuple" => [":background", 5]}
2117               ]
2118             }
2119           ]
2120         })
2121
2122       assert json_response(conn, 200) == %{
2123                "configs" => [
2124                  %{
2125                    "group" => "oban",
2126                    "key" => ":queues",
2127                    "value" => [
2128                      %{"tuple" => [":federator_incoming", 50]},
2129                      %{"tuple" => [":federator_outgoing", 50]},
2130                      %{"tuple" => [":web_push", 50]},
2131                      %{"tuple" => [":mailer", 10]},
2132                      %{"tuple" => [":transmogrifier", 20]},
2133                      %{"tuple" => [":scheduled_activities", 10]},
2134                      %{"tuple" => [":background", 5]}
2135                    ]
2136                  }
2137                ]
2138              }
2139     end
2140
2141     test "delete part of settings by atom subkeys", %{conn: conn} do
2142       config =
2143         insert(:config,
2144           key: "keyaa1",
2145           value: :erlang.term_to_binary(subkey1: "val1", subkey2: "val2", subkey3: "val3")
2146         )
2147
2148       conn =
2149         post(conn, "/api/pleroma/admin/config", %{
2150           configs: [
2151             %{
2152               group: config.group,
2153               key: config.key,
2154               subkeys: [":subkey1", ":subkey3"],
2155               delete: "true"
2156             }
2157           ]
2158         })
2159
2160       assert(
2161         json_response(conn, 200) == %{
2162           "configs" => [
2163             %{
2164               "group" => "pleroma",
2165               "key" => "keyaa1",
2166               "value" => [%{"tuple" => [":subkey2", "val2"]}]
2167             }
2168           ]
2169         }
2170       )
2171     end
2172   end
2173
2174   describe "config mix tasks run" do
2175     setup %{conn: conn} do
2176       admin = insert(:user, info: %{is_admin: true})
2177
2178       temp_file = "config/test.exported_from_db.secret.exs"
2179
2180       Mix.shell(Mix.Shell.Quiet)
2181
2182       on_exit(fn ->
2183         Mix.shell(Mix.Shell.IO)
2184         :ok = File.rm(temp_file)
2185       end)
2186
2187       %{conn: assign(conn, :user, admin), admin: admin}
2188     end
2189
2190     clear_config([:instance, :dynamic_configuration]) do
2191       Pleroma.Config.put([:instance, :dynamic_configuration], true)
2192     end
2193
2194     test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
2195       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2196       conn = get(conn, "/api/pleroma/admin/config/migrate_to_db")
2197       assert json_response(conn, 200) == %{}
2198       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) > 0
2199
2200       conn =
2201         build_conn()
2202         |> assign(:user, admin)
2203         |> get("/api/pleroma/admin/config/migrate_from_db")
2204
2205       assert json_response(conn, 200) == %{}
2206       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2207     end
2208   end
2209
2210   describe "GET /api/pleroma/admin/users/:nickname/statuses" do
2211     setup do
2212       admin = insert(:user, info: %{is_admin: true})
2213       user = insert(:user)
2214
2215       date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
2216       date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
2217       date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
2218
2219       insert(:note_activity, user: user, published: date1)
2220       insert(:note_activity, user: user, published: date2)
2221       insert(:note_activity, user: user, published: date3)
2222
2223       conn =
2224         build_conn()
2225         |> assign(:user, admin)
2226
2227       {:ok, conn: conn, user: user}
2228     end
2229
2230     test "renders user's statuses", %{conn: conn, user: user} do
2231       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2232
2233       assert json_response(conn, 200) |> length() == 3
2234     end
2235
2236     test "renders user's statuses with a limit", %{conn: conn, user: user} do
2237       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
2238
2239       assert json_response(conn, 200) |> length() == 2
2240     end
2241
2242     test "doesn't return private statuses by default", %{conn: conn, user: user} do
2243       {:ok, _private_status} =
2244         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2245
2246       {:ok, _public_status} =
2247         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2248
2249       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2250
2251       assert json_response(conn, 200) |> length() == 4
2252     end
2253
2254     test "returns private statuses with godmode on", %{conn: conn, user: user} do
2255       {:ok, _private_status} =
2256         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2257
2258       {:ok, _public_status} =
2259         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2260
2261       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
2262
2263       assert json_response(conn, 200) |> length() == 5
2264     end
2265   end
2266
2267   describe "GET /api/pleroma/admin/moderation_log" do
2268     setup %{conn: conn} do
2269       admin = insert(:user, info: %{is_admin: true})
2270
2271       %{conn: assign(conn, :user, admin), admin: admin}
2272     end
2273
2274     test "returns the log", %{conn: conn, admin: admin} do
2275       Repo.insert(%ModerationLog{
2276         data: %{
2277           actor: %{
2278             "id" => admin.id,
2279             "nickname" => admin.nickname,
2280             "type" => "user"
2281           },
2282           action: "relay_follow",
2283           target: "https://example.org/relay"
2284         },
2285         inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2286       })
2287
2288       Repo.insert(%ModerationLog{
2289         data: %{
2290           actor: %{
2291             "id" => admin.id,
2292             "nickname" => admin.nickname,
2293             "type" => "user"
2294           },
2295           action: "relay_unfollow",
2296           target: "https://example.org/relay"
2297         },
2298         inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2299       })
2300
2301       conn = get(conn, "/api/pleroma/admin/moderation_log")
2302
2303       response = json_response(conn, 200)
2304       [first_entry, second_entry] = response
2305
2306       assert response |> length() == 2
2307       assert first_entry["data"]["action"] == "relay_unfollow"
2308
2309       assert first_entry["message"] ==
2310                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2311
2312       assert second_entry["data"]["action"] == "relay_follow"
2313
2314       assert second_entry["message"] ==
2315                "@#{admin.nickname} followed relay: https://example.org/relay"
2316     end
2317
2318     test "returns the log with pagination", %{conn: conn, admin: admin} do
2319       Repo.insert(%ModerationLog{
2320         data: %{
2321           actor: %{
2322             "id" => admin.id,
2323             "nickname" => admin.nickname,
2324             "type" => "user"
2325           },
2326           action: "relay_follow",
2327           target: "https://example.org/relay"
2328         },
2329         inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2330       })
2331
2332       Repo.insert(%ModerationLog{
2333         data: %{
2334           actor: %{
2335             "id" => admin.id,
2336             "nickname" => admin.nickname,
2337             "type" => "user"
2338           },
2339           action: "relay_unfollow",
2340           target: "https://example.org/relay"
2341         },
2342         inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2343       })
2344
2345       conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
2346
2347       response1 = json_response(conn1, 200)
2348       [first_entry] = response1
2349
2350       assert response1 |> length() == 1
2351       assert first_entry["data"]["action"] == "relay_unfollow"
2352
2353       assert first_entry["message"] ==
2354                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2355
2356       conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
2357
2358       response2 = json_response(conn2, 200)
2359       [second_entry] = response2
2360
2361       assert response2 |> length() == 1
2362       assert second_entry["data"]["action"] == "relay_follow"
2363
2364       assert second_entry["message"] ==
2365                "@#{admin.nickname} followed relay: https://example.org/relay"
2366     end
2367   end
2368 end
2369
2370 # Needed for testing
2371 defmodule Pleroma.Web.Endpoint.NotReal do
2372 end
2373
2374 defmodule Pleroma.Captcha.NotReal do
2375 end