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     resp = json_response(conn, 200)
 600
 601     assert Regex.match?(~r/(http:\/\/|https:\/\/)/, resp["link"])
 602   end
 603
 604   describe "GET /api/pleroma/admin/users" do
 605     setup do
 606       admin = insert(:user, info: %{is_admin: true})
 607
 608       conn =
 609         build_conn()
 610         |> assign(:user, admin)
 611
 612       {:ok, conn: conn, admin: admin}
 613     end
 614
 615     test "renders users array for the first page", %{conn: conn, admin: admin} do
 616       user = insert(:user, local: false, tags: ["foo", "bar"])
 617       conn = get(conn, "/api/pleroma/admin/users?page=1")
 618
 619       users =
 620         [
 621           %{
 622             "deactivated" => admin.info.deactivated,
 623             "id" => admin.id,
 624             "nickname" => admin.nickname,
 625             "roles" => %{"admin" => true, "moderator" => false},
 626             "local" => true,
 627             "tags" => [],
 628             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 629             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 630           },
 631           %{
 632             "deactivated" => user.info.deactivated,
 633             "id" => user.id,
 634             "nickname" => user.nickname,
 635             "roles" => %{"admin" => false, "moderator" => false},
 636             "local" => false,
 637             "tags" => ["foo", "bar"],
 638             "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 639             "display_name" => HTML.strip_tags(user.name || user.nickname)
 640           }
 641         ]
 642         |> Enum.sort_by(& &1["nickname"])
 643
 644       assert json_response(conn, 200) == %{
 645                "count" => 2,
 646                "page_size" => 50,
 647                "users" => users
 648              }
 649     end
 650
 651     test "renders empty array for the second page", %{conn: conn} do
 652       insert(:user)
 653
 654       conn = get(conn, "/api/pleroma/admin/users?page=2")
 655
 656       assert json_response(conn, 200) == %{
 657                "count" => 2,
 658                "page_size" => 50,
 659                "users" => []
 660              }
 661     end
 662
 663     test "regular search", %{conn: conn} do
 664       user = insert(:user, nickname: "bob")
 665
 666       conn = get(conn, "/api/pleroma/admin/users?query=bo")
 667
 668       assert json_response(conn, 200) == %{
 669                "count" => 1,
 670                "page_size" => 50,
 671                "users" => [
 672                  %{
 673                    "deactivated" => user.info.deactivated,
 674                    "id" => user.id,
 675                    "nickname" => user.nickname,
 676                    "roles" => %{"admin" => false, "moderator" => false},
 677                    "local" => true,
 678                    "tags" => [],
 679                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 680                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 681                  }
 682                ]
 683              }
 684     end
 685
 686     test "search by domain", %{conn: conn} do
 687       user = insert(:user, nickname: "nickname@domain.com")
 688       insert(:user)
 689
 690       conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
 691
 692       assert json_response(conn, 200) == %{
 693                "count" => 1,
 694                "page_size" => 50,
 695                "users" => [
 696                  %{
 697                    "deactivated" => user.info.deactivated,
 698                    "id" => user.id,
 699                    "nickname" => user.nickname,
 700                    "roles" => %{"admin" => false, "moderator" => false},
 701                    "local" => true,
 702                    "tags" => [],
 703                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 704                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 705                  }
 706                ]
 707              }
 708     end
 709
 710     test "search by full nickname", %{conn: conn} do
 711       user = insert(:user, nickname: "nickname@domain.com")
 712       insert(:user)
 713
 714       conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
 715
 716       assert json_response(conn, 200) == %{
 717                "count" => 1,
 718                "page_size" => 50,
 719                "users" => [
 720                  %{
 721                    "deactivated" => user.info.deactivated,
 722                    "id" => user.id,
 723                    "nickname" => user.nickname,
 724                    "roles" => %{"admin" => false, "moderator" => false},
 725                    "local" => true,
 726                    "tags" => [],
 727                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 728                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 729                  }
 730                ]
 731              }
 732     end
 733
 734     test "search by display name", %{conn: conn} do
 735       user = insert(:user, name: "Display name")
 736       insert(:user)
 737
 738       conn = get(conn, "/api/pleroma/admin/users?name=display")
 739
 740       assert json_response(conn, 200) == %{
 741                "count" => 1,
 742                "page_size" => 50,
 743                "users" => [
 744                  %{
 745                    "deactivated" => user.info.deactivated,
 746                    "id" => user.id,
 747                    "nickname" => user.nickname,
 748                    "roles" => %{"admin" => false, "moderator" => false},
 749                    "local" => true,
 750                    "tags" => [],
 751                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 752                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 753                  }
 754                ]
 755              }
 756     end
 757
 758     test "search by email", %{conn: conn} do
 759       user = insert(:user, email: "email@example.com")
 760       insert(:user)
 761
 762       conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
 763
 764       assert json_response(conn, 200) == %{
 765                "count" => 1,
 766                "page_size" => 50,
 767                "users" => [
 768                  %{
 769                    "deactivated" => user.info.deactivated,
 770                    "id" => user.id,
 771                    "nickname" => user.nickname,
 772                    "roles" => %{"admin" => false, "moderator" => false},
 773                    "local" => true,
 774                    "tags" => [],
 775                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 776                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 777                  }
 778                ]
 779              }
 780     end
 781
 782     test "regular search with page size", %{conn: conn} do
 783       user = insert(:user, nickname: "aalice")
 784       user2 = insert(:user, nickname: "alice")
 785
 786       conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 787
 788       assert json_response(conn1, 200) == %{
 789                "count" => 2,
 790                "page_size" => 1,
 791                "users" => [
 792                  %{
 793                    "deactivated" => user.info.deactivated,
 794                    "id" => user.id,
 795                    "nickname" => user.nickname,
 796                    "roles" => %{"admin" => false, "moderator" => false},
 797                    "local" => true,
 798                    "tags" => [],
 799                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 800                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 801                  }
 802                ]
 803              }
 804
 805       conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 806
 807       assert json_response(conn2, 200) == %{
 808                "count" => 2,
 809                "page_size" => 1,
 810                "users" => [
 811                  %{
 812                    "deactivated" => user2.info.deactivated,
 813                    "id" => user2.id,
 814                    "nickname" => user2.nickname,
 815                    "roles" => %{"admin" => false, "moderator" => false},
 816                    "local" => true,
 817                    "tags" => [],
 818                    "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
 819                    "display_name" => HTML.strip_tags(user2.name || user2.nickname)
 820                  }
 821                ]
 822              }
 823     end
 824
 825     test "only local users" do
 826       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 827       user = insert(:user, nickname: "bob")
 828
 829       insert(:user, nickname: "bobb", local: false)
 830
 831       conn =
 832         build_conn()
 833         |> assign(:user, admin)
 834         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 835
 836       assert json_response(conn, 200) == %{
 837                "count" => 1,
 838                "page_size" => 50,
 839                "users" => [
 840                  %{
 841                    "deactivated" => user.info.deactivated,
 842                    "id" => user.id,
 843                    "nickname" => user.nickname,
 844                    "roles" => %{"admin" => false, "moderator" => false},
 845                    "local" => true,
 846                    "tags" => [],
 847                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 848                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 849                  }
 850                ]
 851              }
 852     end
 853
 854     test "only local users with no query", %{admin: old_admin} do
 855       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 856       user = insert(:user, nickname: "bob")
 857
 858       insert(:user, nickname: "bobb", local: false)
 859
 860       conn =
 861         build_conn()
 862         |> assign(:user, admin)
 863         |> get("/api/pleroma/admin/users?filters=local")
 864
 865       users =
 866         [
 867           %{
 868             "deactivated" => user.info.deactivated,
 869             "id" => user.id,
 870             "nickname" => user.nickname,
 871             "roles" => %{"admin" => false, "moderator" => false},
 872             "local" => true,
 873             "tags" => [],
 874             "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 875             "display_name" => HTML.strip_tags(user.name || user.nickname)
 876           },
 877           %{
 878             "deactivated" => admin.info.deactivated,
 879             "id" => admin.id,
 880             "nickname" => admin.nickname,
 881             "roles" => %{"admin" => true, "moderator" => false},
 882             "local" => true,
 883             "tags" => [],
 884             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 885             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 886           },
 887           %{
 888             "deactivated" => false,
 889             "id" => old_admin.id,
 890             "local" => true,
 891             "nickname" => old_admin.nickname,
 892             "roles" => %{"admin" => true, "moderator" => false},
 893             "tags" => [],
 894             "avatar" => User.avatar_url(old_admin) |> MediaProxy.url(),
 895             "display_name" => HTML.strip_tags(old_admin.name || old_admin.nickname)
 896           }
 897         ]
 898         |> Enum.sort_by(& &1["nickname"])
 899
 900       assert json_response(conn, 200) == %{
 901                "count" => 3,
 902                "page_size" => 50,
 903                "users" => users
 904              }
 905     end
 906
 907     test "load only admins", %{conn: conn, admin: admin} do
 908       second_admin = insert(:user, info: %{is_admin: true})
 909       insert(:user)
 910       insert(:user)
 911
 912       conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
 913
 914       users =
 915         [
 916           %{
 917             "deactivated" => false,
 918             "id" => admin.id,
 919             "nickname" => admin.nickname,
 920             "roles" => %{"admin" => true, "moderator" => false},
 921             "local" => admin.local,
 922             "tags" => [],
 923             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 924             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 925           },
 926           %{
 927             "deactivated" => false,
 928             "id" => second_admin.id,
 929             "nickname" => second_admin.nickname,
 930             "roles" => %{"admin" => true, "moderator" => false},
 931             "local" => second_admin.local,
 932             "tags" => [],
 933             "avatar" => User.avatar_url(second_admin) |> MediaProxy.url(),
 934             "display_name" => HTML.strip_tags(second_admin.name || second_admin.nickname)
 935           }
 936         ]
 937         |> Enum.sort_by(& &1["nickname"])
 938
 939       assert json_response(conn, 200) == %{
 940                "count" => 2,
 941                "page_size" => 50,
 942                "users" => users
 943              }
 944     end
 945
 946     test "load only moderators", %{conn: conn} do
 947       moderator = insert(:user, info: %{is_moderator: true})
 948       insert(:user)
 949       insert(:user)
 950
 951       conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
 952
 953       assert json_response(conn, 200) == %{
 954                "count" => 1,
 955                "page_size" => 50,
 956                "users" => [
 957                  %{
 958                    "deactivated" => false,
 959                    "id" => moderator.id,
 960                    "nickname" => moderator.nickname,
 961                    "roles" => %{"admin" => false, "moderator" => true},
 962                    "local" => moderator.local,
 963                    "tags" => [],
 964                    "avatar" => User.avatar_url(moderator) |> MediaProxy.url(),
 965                    "display_name" => HTML.strip_tags(moderator.name || moderator.nickname)
 966                  }
 967                ]
 968              }
 969     end
 970
 971     test "load users with tags list", %{conn: conn} do
 972       user1 = insert(:user, tags: ["first"])
 973       user2 = insert(:user, tags: ["second"])
 974       insert(:user)
 975       insert(:user)
 976
 977       conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
 978
 979       users =
 980         [
 981           %{
 982             "deactivated" => false,
 983             "id" => user1.id,
 984             "nickname" => user1.nickname,
 985             "roles" => %{"admin" => false, "moderator" => false},
 986             "local" => user1.local,
 987             "tags" => ["first"],
 988             "avatar" => User.avatar_url(user1) |> MediaProxy.url(),
 989             "display_name" => HTML.strip_tags(user1.name || user1.nickname)
 990           },
 991           %{
 992             "deactivated" => false,
 993             "id" => user2.id,
 994             "nickname" => user2.nickname,
 995             "roles" => %{"admin" => false, "moderator" => false},
 996             "local" => user2.local,
 997             "tags" => ["second"],
 998             "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
 999             "display_name" => HTML.strip_tags(user2.name || user2.nickname)
1000           }
1001         ]
1002         |> Enum.sort_by(& &1["nickname"])
1003
1004       assert json_response(conn, 200) == %{
1005                "count" => 2,
1006                "page_size" => 50,
1007                "users" => users
1008              }
1009     end
1010
1011     test "it works with multiple filters" do
1012       admin = insert(:user, nickname: "john", info: %{is_admin: true})
1013       user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
1014
1015       insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
1016       insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
1017
1018       conn =
1019         build_conn()
1020         |> assign(:user, admin)
1021         |> get("/api/pleroma/admin/users?filters=deactivated,external")
1022
1023       assert json_response(conn, 200) == %{
1024                "count" => 1,
1025                "page_size" => 50,
1026                "users" => [
1027                  %{
1028                    "deactivated" => user.info.deactivated,
1029                    "id" => user.id,
1030                    "nickname" => user.nickname,
1031                    "roles" => %{"admin" => false, "moderator" => false},
1032                    "local" => user.local,
1033                    "tags" => [],
1034                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1035                    "display_name" => HTML.strip_tags(user.name || user.nickname)
1036                  }
1037                ]
1038              }
1039     end
1040   end
1041
1042   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
1043     admin = insert(:user, info: %{is_admin: true})
1044     user = insert(:user)
1045
1046     conn =
1047       build_conn()
1048       |> assign(:user, admin)
1049       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
1050
1051     assert json_response(conn, 200) ==
1052              %{
1053                "deactivated" => !user.info.deactivated,
1054                "id" => user.id,
1055                "nickname" => user.nickname,
1056                "roles" => %{"admin" => false, "moderator" => false},
1057                "local" => true,
1058                "tags" => [],
1059                "avatar" => User.avatar_url(user) |> MediaProxy.url(),
1060                "display_name" => HTML.strip_tags(user.name || user.nickname)
1061              }
1062
1063     log_entry = Repo.one(ModerationLog)
1064
1065     assert ModerationLog.get_log_entry_message(log_entry) ==
1066              "@#{admin.nickname} deactivated user @#{user.nickname}"
1067   end
1068
1069   describe "GET /api/pleroma/admin/users/invite_token" do
1070     setup do
1071       admin = insert(:user, info: %{is_admin: true})
1072
1073       conn =
1074         build_conn()
1075         |> assign(:user, admin)
1076
1077       {:ok, conn: conn}
1078     end
1079
1080     test "without options", %{conn: conn} do
1081       conn = get(conn, "/api/pleroma/admin/users/invite_token")
1082
1083       token = json_response(conn, 200)
1084       invite = UserInviteToken.find_by_token!(token)
1085       refute invite.used
1086       refute invite.expires_at
1087       refute invite.max_use
1088       assert invite.invite_type == "one_time"
1089     end
1090
1091     test "with expires_at", %{conn: conn} do
1092       conn =
1093         get(conn, "/api/pleroma/admin/users/invite_token", %{
1094           "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
1095         })
1096
1097       token = json_response(conn, 200)
1098       invite = UserInviteToken.find_by_token!(token)
1099
1100       refute invite.used
1101       assert invite.expires_at == Date.utc_today()
1102       refute invite.max_use
1103       assert invite.invite_type == "date_limited"
1104     end
1105
1106     test "with max_use", %{conn: conn} do
1107       conn =
1108         get(conn, "/api/pleroma/admin/users/invite_token", %{
1109           "invite" => %{"max_use" => 150}
1110         })
1111
1112       token = json_response(conn, 200)
1113       invite = UserInviteToken.find_by_token!(token)
1114       refute invite.used
1115       refute invite.expires_at
1116       assert invite.max_use == 150
1117       assert invite.invite_type == "reusable"
1118     end
1119
1120     test "with max use and expires_at", %{conn: conn} do
1121       conn =
1122         get(conn, "/api/pleroma/admin/users/invite_token", %{
1123           "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
1124         })
1125
1126       token = json_response(conn, 200)
1127       invite = UserInviteToken.find_by_token!(token)
1128       refute invite.used
1129       assert invite.expires_at == Date.utc_today()
1130       assert invite.max_use == 150
1131       assert invite.invite_type == "reusable_date_limited"
1132     end
1133   end
1134
1135   describe "GET /api/pleroma/admin/users/invites" do
1136     setup do
1137       admin = insert(:user, info: %{is_admin: true})
1138
1139       conn =
1140         build_conn()
1141         |> assign(:user, admin)
1142
1143       {:ok, conn: conn}
1144     end
1145
1146     test "no invites", %{conn: conn} do
1147       conn = get(conn, "/api/pleroma/admin/users/invites")
1148
1149       assert json_response(conn, 200) == %{"invites" => []}
1150     end
1151
1152     test "with invite", %{conn: conn} do
1153       {:ok, invite} = UserInviteToken.create_invite()
1154
1155       conn = get(conn, "/api/pleroma/admin/users/invites")
1156
1157       assert json_response(conn, 200) == %{
1158                "invites" => [
1159                  %{
1160                    "expires_at" => nil,
1161                    "id" => invite.id,
1162                    "invite_type" => "one_time",
1163                    "max_use" => nil,
1164                    "token" => invite.token,
1165                    "used" => false,
1166                    "uses" => 0
1167                  }
1168                ]
1169              }
1170     end
1171   end
1172
1173   describe "POST /api/pleroma/admin/users/revoke_invite" do
1174     test "with token" do
1175       admin = insert(:user, info: %{is_admin: true})
1176       {:ok, invite} = UserInviteToken.create_invite()
1177
1178       conn =
1179         build_conn()
1180         |> assign(:user, admin)
1181         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
1182
1183       assert json_response(conn, 200) == %{
1184                "expires_at" => nil,
1185                "id" => invite.id,
1186                "invite_type" => "one_time",
1187                "max_use" => nil,
1188                "token" => invite.token,
1189                "used" => true,
1190                "uses" => 0
1191              }
1192     end
1193
1194     test "with invalid token" do
1195       admin = insert(:user, info: %{is_admin: true})
1196
1197       conn =
1198         build_conn()
1199         |> assign(:user, admin)
1200         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
1201
1202       assert json_response(conn, :not_found) == "Not found"
1203     end
1204   end
1205
1206   describe "GET /api/pleroma/admin/reports/:id" do
1207     setup %{conn: conn} do
1208       admin = insert(:user, info: %{is_admin: true})
1209
1210       %{conn: assign(conn, :user, admin)}
1211     end
1212
1213     test "returns report by its id", %{conn: conn} do
1214       [reporter, target_user] = insert_pair(:user)
1215       activity = insert(:note_activity, user: target_user)
1216
1217       {:ok, %{id: report_id}} =
1218         CommonAPI.report(reporter, %{
1219           "account_id" => target_user.id,
1220           "comment" => "I feel offended",
1221           "status_ids" => [activity.id]
1222         })
1223
1224       response =
1225         conn
1226         |> get("/api/pleroma/admin/reports/#{report_id}")
1227         |> json_response(:ok)
1228
1229       assert response["id"] == report_id
1230     end
1231
1232     test "returns 404 when report id is invalid", %{conn: conn} do
1233       conn = get(conn, "/api/pleroma/admin/reports/test")
1234
1235       assert json_response(conn, :not_found) == "Not found"
1236     end
1237   end
1238
1239   describe "PUT /api/pleroma/admin/reports/:id" do
1240     setup %{conn: conn} do
1241       admin = insert(:user, info: %{is_admin: true})
1242       [reporter, target_user] = insert_pair(:user)
1243       activity = insert(:note_activity, user: target_user)
1244
1245       {:ok, %{id: report_id}} =
1246         CommonAPI.report(reporter, %{
1247           "account_id" => target_user.id,
1248           "comment" => "I feel offended",
1249           "status_ids" => [activity.id]
1250         })
1251
1252       %{conn: assign(conn, :user, admin), id: report_id, admin: admin}
1253     end
1254
1255     test "mark report as resolved", %{conn: conn, id: id, admin: admin} do
1256       response =
1257         conn
1258         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1259         |> json_response(:ok)
1260
1261       assert response["state"] == "resolved"
1262
1263       log_entry = Repo.one(ModerationLog)
1264
1265       assert ModerationLog.get_log_entry_message(log_entry) ==
1266                "@#{admin.nickname} updated report ##{id} with 'resolved' state"
1267     end
1268
1269     test "closes report", %{conn: conn, id: id, admin: admin} do
1270       response =
1271         conn
1272         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1273         |> json_response(:ok)
1274
1275       assert response["state"] == "closed"
1276
1277       log_entry = Repo.one(ModerationLog)
1278
1279       assert ModerationLog.get_log_entry_message(log_entry) ==
1280                "@#{admin.nickname} updated report ##{id} with 'closed' state"
1281     end
1282
1283     test "returns 400 when state is unknown", %{conn: conn, id: id} do
1284       conn =
1285         conn
1286         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1287
1288       assert json_response(conn, :bad_request) == "Unsupported state"
1289     end
1290
1291     test "returns 404 when report is not exist", %{conn: conn} do
1292       conn =
1293         conn
1294         |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1295
1296       assert json_response(conn, :not_found) == "Not found"
1297     end
1298   end
1299
1300   describe "GET /api/pleroma/admin/reports" do
1301     setup %{conn: conn} do
1302       admin = insert(:user, info: %{is_admin: true})
1303
1304       %{conn: assign(conn, :user, admin)}
1305     end
1306
1307     test "returns empty response when no reports created", %{conn: conn} do
1308       response =
1309         conn
1310         |> get("/api/pleroma/admin/reports")
1311         |> json_response(:ok)
1312
1313       assert Enum.empty?(response["reports"])
1314       assert response["total"] == 0
1315     end
1316
1317     test "returns reports", %{conn: conn} do
1318       [reporter, target_user] = insert_pair(:user)
1319       activity = insert(:note_activity, user: target_user)
1320
1321       {:ok, %{id: report_id}} =
1322         CommonAPI.report(reporter, %{
1323           "account_id" => target_user.id,
1324           "comment" => "I feel offended",
1325           "status_ids" => [activity.id]
1326         })
1327
1328       response =
1329         conn
1330         |> get("/api/pleroma/admin/reports")
1331         |> json_response(:ok)
1332
1333       [report] = response["reports"]
1334
1335       assert length(response["reports"]) == 1
1336       assert report["id"] == report_id
1337
1338       assert response["total"] == 1
1339     end
1340
1341     test "returns reports with specified state", %{conn: conn} do
1342       [reporter, target_user] = insert_pair(:user)
1343       activity = insert(:note_activity, user: target_user)
1344
1345       {:ok, %{id: first_report_id}} =
1346         CommonAPI.report(reporter, %{
1347           "account_id" => target_user.id,
1348           "comment" => "I feel offended",
1349           "status_ids" => [activity.id]
1350         })
1351
1352       {:ok, %{id: second_report_id}} =
1353         CommonAPI.report(reporter, %{
1354           "account_id" => target_user.id,
1355           "comment" => "I don't like this user"
1356         })
1357
1358       CommonAPI.update_report_state(second_report_id, "closed")
1359
1360       response =
1361         conn
1362         |> get("/api/pleroma/admin/reports", %{
1363           "state" => "open"
1364         })
1365         |> json_response(:ok)
1366
1367       [open_report] = response["reports"]
1368
1369       assert length(response["reports"]) == 1
1370       assert open_report["id"] == first_report_id
1371
1372       assert response["total"] == 1
1373
1374       response =
1375         conn
1376         |> get("/api/pleroma/admin/reports", %{
1377           "state" => "closed"
1378         })
1379         |> json_response(:ok)
1380
1381       [closed_report] = response["reports"]
1382
1383       assert length(response["reports"]) == 1
1384       assert closed_report["id"] == second_report_id
1385
1386       assert response["total"] == 1
1387
1388       response =
1389         conn
1390         |> get("/api/pleroma/admin/reports", %{
1391           "state" => "resolved"
1392         })
1393         |> json_response(:ok)
1394
1395       assert Enum.empty?(response["reports"])
1396       assert response["total"] == 0
1397     end
1398
1399     test "returns 403 when requested by a non-admin" do
1400       user = insert(:user)
1401
1402       conn =
1403         build_conn()
1404         |> assign(:user, user)
1405         |> get("/api/pleroma/admin/reports")
1406
1407       assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1408     end
1409
1410     test "returns 403 when requested by anonymous" do
1411       conn =
1412         build_conn()
1413         |> get("/api/pleroma/admin/reports")
1414
1415       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1416     end
1417   end
1418
1419   #
1420   describe "POST /api/pleroma/admin/reports/:id/respond" do
1421     setup %{conn: conn} do
1422       admin = insert(:user, info: %{is_admin: true})
1423
1424       %{conn: assign(conn, :user, admin), admin: admin}
1425     end
1426
1427     test "returns created dm", %{conn: conn, admin: admin} do
1428       [reporter, target_user] = insert_pair(:user)
1429       activity = insert(:note_activity, user: target_user)
1430
1431       {:ok, %{id: report_id}} =
1432         CommonAPI.report(reporter, %{
1433           "account_id" => target_user.id,
1434           "comment" => "I feel offended",
1435           "status_ids" => [activity.id]
1436         })
1437
1438       response =
1439         conn
1440         |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1441           "status" => "I will check it out"
1442         })
1443         |> json_response(:ok)
1444
1445       recipients = Enum.map(response["mentions"], & &1["username"])
1446
1447       assert reporter.nickname in recipients
1448       assert response["content"] == "I will check it out"
1449       assert response["visibility"] == "direct"
1450
1451       log_entry = Repo.one(ModerationLog)
1452
1453       assert ModerationLog.get_log_entry_message(log_entry) ==
1454                "@#{admin.nickname} responded with 'I will check it out' to report ##{
1455                  response["id"]
1456                }"
1457     end
1458
1459     test "returns 400 when status is missing", %{conn: conn} do
1460       conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1461
1462       assert json_response(conn, :bad_request) == "Invalid parameters"
1463     end
1464
1465     test "returns 404 when report id is invalid", %{conn: conn} do
1466       conn =
1467         post(conn, "/api/pleroma/admin/reports/test/respond", %{
1468           "status" => "foo"
1469         })
1470
1471       assert json_response(conn, :not_found) == "Not found"
1472     end
1473   end
1474
1475   describe "PUT /api/pleroma/admin/statuses/:id" do
1476     setup %{conn: conn} do
1477       admin = insert(:user, info: %{is_admin: true})
1478       activity = insert(:note_activity)
1479
1480       %{conn: assign(conn, :user, admin), id: activity.id, admin: admin}
1481     end
1482
1483     test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
1484       response =
1485         conn
1486         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1487         |> json_response(:ok)
1488
1489       assert response["sensitive"]
1490
1491       log_entry = Repo.one(ModerationLog)
1492
1493       assert ModerationLog.get_log_entry_message(log_entry) ==
1494                "@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"
1495
1496       response =
1497         conn
1498         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1499         |> json_response(:ok)
1500
1501       refute response["sensitive"]
1502     end
1503
1504     test "change visibility flag", %{conn: conn, id: id, admin: admin} do
1505       response =
1506         conn
1507         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1508         |> json_response(:ok)
1509
1510       assert response["visibility"] == "public"
1511
1512       log_entry = Repo.one(ModerationLog)
1513
1514       assert ModerationLog.get_log_entry_message(log_entry) ==
1515                "@#{admin.nickname} updated status ##{id}, set visibility: 'public'"
1516
1517       response =
1518         conn
1519         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1520         |> json_response(:ok)
1521
1522       assert response["visibility"] == "private"
1523
1524       response =
1525         conn
1526         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1527         |> json_response(:ok)
1528
1529       assert response["visibility"] == "unlisted"
1530     end
1531
1532     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1533       conn =
1534         conn
1535         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1536
1537       assert json_response(conn, :bad_request) == "Unsupported visibility"
1538     end
1539   end
1540
1541   describe "DELETE /api/pleroma/admin/statuses/:id" do
1542     setup %{conn: conn} do
1543       admin = insert(:user, info: %{is_admin: true})
1544       activity = insert(:note_activity)
1545
1546       %{conn: assign(conn, :user, admin), id: activity.id, admin: admin}
1547     end
1548
1549     test "deletes status", %{conn: conn, id: id, admin: admin} do
1550       conn
1551       |> delete("/api/pleroma/admin/statuses/#{id}")
1552       |> json_response(:ok)
1553
1554       refute Activity.get_by_id(id)
1555
1556       log_entry = Repo.one(ModerationLog)
1557
1558       assert ModerationLog.get_log_entry_message(log_entry) ==
1559                "@#{admin.nickname} deleted status ##{id}"
1560     end
1561
1562     test "returns error when status is not exist", %{conn: conn} do
1563       conn =
1564         conn
1565         |> delete("/api/pleroma/admin/statuses/test")
1566
1567       assert json_response(conn, :bad_request) == "Could not delete"
1568     end
1569   end
1570
1571   describe "GET /api/pleroma/admin/config" do
1572     setup %{conn: conn} do
1573       admin = insert(:user, info: %{is_admin: true})
1574
1575       %{conn: assign(conn, :user, admin)}
1576     end
1577
1578     test "without any settings in db", %{conn: conn} do
1579       conn = get(conn, "/api/pleroma/admin/config")
1580
1581       assert json_response(conn, 200) == %{"configs" => []}
1582     end
1583
1584     test "with settings in db", %{conn: conn} do
1585       config1 = insert(:config)
1586       config2 = insert(:config)
1587
1588       conn = get(conn, "/api/pleroma/admin/config")
1589
1590       %{
1591         "configs" => [
1592           %{
1593             "key" => key1,
1594             "value" => _
1595           },
1596           %{
1597             "key" => key2,
1598             "value" => _
1599           }
1600         ]
1601       } = json_response(conn, 200)
1602
1603       assert key1 == config1.key
1604       assert key2 == config2.key
1605     end
1606   end
1607
1608   describe "POST /api/pleroma/admin/config" do
1609     setup %{conn: conn} do
1610       admin = insert(:user, info: %{is_admin: true})
1611
1612       temp_file = "config/test.exported_from_db.secret.exs"
1613
1614       on_exit(fn ->
1615         Application.delete_env(:pleroma, :key1)
1616         Application.delete_env(:pleroma, :key2)
1617         Application.delete_env(:pleroma, :key3)
1618         Application.delete_env(:pleroma, :key4)
1619         Application.delete_env(:pleroma, :keyaa1)
1620         Application.delete_env(:pleroma, :keyaa2)
1621         Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1622         Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1623         :ok = File.rm(temp_file)
1624       end)
1625
1626       %{conn: assign(conn, :user, admin)}
1627     end
1628
1629     clear_config([:instance, :dynamic_configuration]) do
1630       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1631     end
1632
1633     test "create new config setting in db", %{conn: conn} do
1634       conn =
1635         post(conn, "/api/pleroma/admin/config", %{
1636           configs: [
1637             %{group: "pleroma", key: "key1", value: "value1"},
1638             %{
1639               group: "ueberauth",
1640               key: "Ueberauth.Strategy.Twitter.OAuth",
1641               value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
1642             },
1643             %{
1644               group: "pleroma",
1645               key: "key2",
1646               value: %{
1647                 ":nested_1" => "nested_value1",
1648                 ":nested_2" => [
1649                   %{":nested_22" => "nested_value222"},
1650                   %{":nested_33" => %{":nested_44" => "nested_444"}}
1651                 ]
1652               }
1653             },
1654             %{
1655               group: "pleroma",
1656               key: "key3",
1657               value: [
1658                 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1659                 %{"nested_4" => true}
1660               ]
1661             },
1662             %{
1663               group: "pleroma",
1664               key: "key4",
1665               value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
1666             },
1667             %{
1668               group: "idna",
1669               key: "key5",
1670               value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1671             }
1672           ]
1673         })
1674
1675       assert json_response(conn, 200) == %{
1676                "configs" => [
1677                  %{
1678                    "group" => "pleroma",
1679                    "key" => "key1",
1680                    "value" => "value1"
1681                  },
1682                  %{
1683                    "group" => "ueberauth",
1684                    "key" => "Ueberauth.Strategy.Twitter.OAuth",
1685                    "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
1686                  },
1687                  %{
1688                    "group" => "pleroma",
1689                    "key" => "key2",
1690                    "value" => %{
1691                      ":nested_1" => "nested_value1",
1692                      ":nested_2" => [
1693                        %{":nested_22" => "nested_value222"},
1694                        %{":nested_33" => %{":nested_44" => "nested_444"}}
1695                      ]
1696                    }
1697                  },
1698                  %{
1699                    "group" => "pleroma",
1700                    "key" => "key3",
1701                    "value" => [
1702                      %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1703                      %{"nested_4" => true}
1704                    ]
1705                  },
1706                  %{
1707                    "group" => "pleroma",
1708                    "key" => "key4",
1709                    "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
1710                  },
1711                  %{
1712                    "group" => "idna",
1713                    "key" => "key5",
1714                    "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1715                  }
1716                ]
1717              }
1718
1719       assert Application.get_env(:pleroma, :key1) == "value1"
1720
1721       assert Application.get_env(:pleroma, :key2) == %{
1722                nested_1: "nested_value1",
1723                nested_2: [
1724                  %{nested_22: "nested_value222"},
1725                  %{nested_33: %{nested_44: "nested_444"}}
1726                ]
1727              }
1728
1729       assert Application.get_env(:pleroma, :key3) == [
1730                %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
1731                %{"nested_4" => true}
1732              ]
1733
1734       assert Application.get_env(:pleroma, :key4) == %{
1735                "endpoint" => "https://example.com",
1736                nested_5: :upload
1737              }
1738
1739       assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
1740     end
1741
1742     test "update config setting & delete", %{conn: conn} do
1743       config1 = insert(:config, key: "keyaa1")
1744       config2 = insert(:config, key: "keyaa2")
1745
1746       insert(:config,
1747         group: "ueberauth",
1748         key: "Ueberauth.Strategy.Microsoft.OAuth",
1749         value: :erlang.term_to_binary([])
1750       )
1751
1752       conn =
1753         post(conn, "/api/pleroma/admin/config", %{
1754           configs: [
1755             %{group: config1.group, key: config1.key, value: "another_value"},
1756             %{group: config2.group, key: config2.key, delete: "true"},
1757             %{
1758               group: "ueberauth",
1759               key: "Ueberauth.Strategy.Microsoft.OAuth",
1760               delete: "true"
1761             }
1762           ]
1763         })
1764
1765       assert json_response(conn, 200) == %{
1766                "configs" => [
1767                  %{
1768                    "group" => "pleroma",
1769                    "key" => config1.key,
1770                    "value" => "another_value"
1771                  }
1772                ]
1773              }
1774
1775       assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1776       refute Application.get_env(:pleroma, :keyaa2)
1777     end
1778
1779     test "common config example", %{conn: conn} do
1780       conn =
1781         post(conn, "/api/pleroma/admin/config", %{
1782           configs: [
1783             %{
1784               "group" => "pleroma",
1785               "key" => "Pleroma.Captcha.NotReal",
1786               "value" => [
1787                 %{"tuple" => [":enabled", false]},
1788                 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1789                 %{"tuple" => [":seconds_valid", 60]},
1790                 %{"tuple" => [":path", ""]},
1791                 %{"tuple" => [":key1", nil]},
1792                 %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
1793                 %{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
1794                 %{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
1795                 %{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
1796                 %{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]}
1797               ]
1798             }
1799           ]
1800         })
1801
1802       assert json_response(conn, 200) == %{
1803                "configs" => [
1804                  %{
1805                    "group" => "pleroma",
1806                    "key" => "Pleroma.Captcha.NotReal",
1807                    "value" => [
1808                      %{"tuple" => [":enabled", false]},
1809                      %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1810                      %{"tuple" => [":seconds_valid", 60]},
1811                      %{"tuple" => [":path", ""]},
1812                      %{"tuple" => [":key1", nil]},
1813                      %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
1814                      %{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
1815                      %{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
1816                      %{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
1817                      %{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]}
1818                    ]
1819                  }
1820                ]
1821              }
1822     end
1823
1824     test "tuples with more than two values", %{conn: conn} do
1825       conn =
1826         post(conn, "/api/pleroma/admin/config", %{
1827           configs: [
1828             %{
1829               "group" => "pleroma",
1830               "key" => "Pleroma.Web.Endpoint.NotReal",
1831               "value" => [
1832                 %{
1833                   "tuple" => [
1834                     ":http",
1835                     [
1836                       %{
1837                         "tuple" => [
1838                           ":key2",
1839                           [
1840                             %{
1841                               "tuple" => [
1842                                 ":_",
1843                                 [
1844                                   %{
1845                                     "tuple" => [
1846                                       "/api/v1/streaming",
1847                                       "Pleroma.Web.MastodonAPI.WebsocketHandler",
1848                                       []
1849                                     ]
1850                                   },
1851                                   %{
1852                                     "tuple" => [
1853                                       "/websocket",
1854                                       "Phoenix.Endpoint.CowboyWebSocket",
1855                                       %{
1856                                         "tuple" => [
1857                                           "Phoenix.Transports.WebSocket",
1858                                           %{
1859                                             "tuple" => [
1860                                               "Pleroma.Web.Endpoint",
1861                                               "Pleroma.Web.UserSocket",
1862                                               []
1863                                             ]
1864                                           }
1865                                         ]
1866                                       }
1867                                     ]
1868                                   },
1869                                   %{
1870                                     "tuple" => [
1871                                       ":_",
1872                                       "Phoenix.Endpoint.Cowboy2Handler",
1873                                       %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1874                                     ]
1875                                   }
1876                                 ]
1877                               ]
1878                             }
1879                           ]
1880                         ]
1881                       }
1882                     ]
1883                   ]
1884                 }
1885               ]
1886             }
1887           ]
1888         })
1889
1890       assert json_response(conn, 200) == %{
1891                "configs" => [
1892                  %{
1893                    "group" => "pleroma",
1894                    "key" => "Pleroma.Web.Endpoint.NotReal",
1895                    "value" => [
1896                      %{
1897                        "tuple" => [
1898                          ":http",
1899                          [
1900                            %{
1901                              "tuple" => [
1902                                ":key2",
1903                                [
1904                                  %{
1905                                    "tuple" => [
1906                                      ":_",
1907                                      [
1908                                        %{
1909                                          "tuple" => [
1910                                            "/api/v1/streaming",
1911                                            "Pleroma.Web.MastodonAPI.WebsocketHandler",
1912                                            []
1913                                          ]
1914                                        },
1915                                        %{
1916                                          "tuple" => [
1917                                            "/websocket",
1918                                            "Phoenix.Endpoint.CowboyWebSocket",
1919                                            %{
1920                                              "tuple" => [
1921                                                "Phoenix.Transports.WebSocket",
1922                                                %{
1923                                                  "tuple" => [
1924                                                    "Pleroma.Web.Endpoint",
1925                                                    "Pleroma.Web.UserSocket",
1926                                                    []
1927                                                  ]
1928                                                }
1929                                              ]
1930                                            }
1931                                          ]
1932                                        },
1933                                        %{
1934                                          "tuple" => [
1935                                            ":_",
1936                                            "Phoenix.Endpoint.Cowboy2Handler",
1937                                            %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1938                                          ]
1939                                        }
1940                                      ]
1941                                    ]
1942                                  }
1943                                ]
1944                              ]
1945                            }
1946                          ]
1947                        ]
1948                      }
1949                    ]
1950                  }
1951                ]
1952              }
1953     end
1954
1955     test "settings with nesting map", %{conn: conn} do
1956       conn =
1957         post(conn, "/api/pleroma/admin/config", %{
1958           configs: [
1959             %{
1960               "group" => "pleroma",
1961               "key" => ":key1",
1962               "value" => [
1963                 %{"tuple" => [":key2", "some_val"]},
1964                 %{
1965                   "tuple" => [
1966                     ":key3",
1967                     %{
1968                       ":max_options" => 20,
1969                       ":max_option_chars" => 200,
1970                       ":min_expiration" => 0,
1971                       ":max_expiration" => 31_536_000,
1972                       "nested" => %{
1973                         ":max_options" => 20,
1974                         ":max_option_chars" => 200,
1975                         ":min_expiration" => 0,
1976                         ":max_expiration" => 31_536_000
1977                       }
1978                     }
1979                   ]
1980                 }
1981               ]
1982             }
1983           ]
1984         })
1985
1986       assert json_response(conn, 200) ==
1987                %{
1988                  "configs" => [
1989                    %{
1990                      "group" => "pleroma",
1991                      "key" => ":key1",
1992                      "value" => [
1993                        %{"tuple" => [":key2", "some_val"]},
1994                        %{
1995                          "tuple" => [
1996                            ":key3",
1997                            %{
1998                              ":max_expiration" => 31_536_000,
1999                              ":max_option_chars" => 200,
2000                              ":max_options" => 20,
2001                              ":min_expiration" => 0,
2002                              "nested" => %{
2003                                ":max_expiration" => 31_536_000,
2004                                ":max_option_chars" => 200,
2005                                ":max_options" => 20,
2006                                ":min_expiration" => 0
2007                              }
2008                            }
2009                          ]
2010                        }
2011                      ]
2012                    }
2013                  ]
2014                }
2015     end
2016
2017     test "value as map", %{conn: conn} do
2018       conn =
2019         post(conn, "/api/pleroma/admin/config", %{
2020           configs: [
2021             %{
2022               "group" => "pleroma",
2023               "key" => ":key1",
2024               "value" => %{"key" => "some_val"}
2025             }
2026           ]
2027         })
2028
2029       assert json_response(conn, 200) ==
2030                %{
2031                  "configs" => [
2032                    %{
2033                      "group" => "pleroma",
2034                      "key" => ":key1",
2035                      "value" => %{"key" => "some_val"}
2036                    }
2037                  ]
2038                }
2039     end
2040
2041     test "dispatch setting", %{conn: conn} do
2042       conn =
2043         post(conn, "/api/pleroma/admin/config", %{
2044           configs: [
2045             %{
2046               "group" => "pleroma",
2047               "key" => "Pleroma.Web.Endpoint.NotReal",
2048               "value" => [
2049                 %{
2050                   "tuple" => [
2051                     ":http",
2052                     [
2053                       %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2054                       %{"tuple" => [":dispatch", ["{:_,
2055        [
2056          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
2057          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
2058           {Phoenix.Transports.WebSocket,
2059            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
2060          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
2061        ]}"]]}
2062                     ]
2063                   ]
2064                 }
2065               ]
2066             }
2067           ]
2068         })
2069
2070       dispatch_string =
2071         "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
2072           "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
2073           "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
2074           "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
2075
2076       assert json_response(conn, 200) == %{
2077                "configs" => [
2078                  %{
2079                    "group" => "pleroma",
2080                    "key" => "Pleroma.Web.Endpoint.NotReal",
2081                    "value" => [
2082                      %{
2083                        "tuple" => [
2084                          ":http",
2085                          [
2086                            %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
2087                            %{
2088                              "tuple" => [
2089                                ":dispatch",
2090                                [
2091                                  dispatch_string
2092                                ]
2093                              ]
2094                            }
2095                          ]
2096                        ]
2097                      }
2098                    ]
2099                  }
2100                ]
2101              }
2102     end
2103
2104     test "queues key as atom", %{conn: conn} do
2105       conn =
2106         post(conn, "/api/pleroma/admin/config", %{
2107           configs: [
2108             %{
2109               "group" => "oban",
2110               "key" => ":queues",
2111               "value" => [
2112                 %{"tuple" => [":federator_incoming", 50]},
2113                 %{"tuple" => [":federator_outgoing", 50]},
2114                 %{"tuple" => [":web_push", 50]},
2115                 %{"tuple" => [":mailer", 10]},
2116                 %{"tuple" => [":transmogrifier", 20]},
2117                 %{"tuple" => [":scheduled_activities", 10]},
2118                 %{"tuple" => [":background", 5]}
2119               ]
2120             }
2121           ]
2122         })
2123
2124       assert json_response(conn, 200) == %{
2125                "configs" => [
2126                  %{
2127                    "group" => "oban",
2128                    "key" => ":queues",
2129                    "value" => [
2130                      %{"tuple" => [":federator_incoming", 50]},
2131                      %{"tuple" => [":federator_outgoing", 50]},
2132                      %{"tuple" => [":web_push", 50]},
2133                      %{"tuple" => [":mailer", 10]},
2134                      %{"tuple" => [":transmogrifier", 20]},
2135                      %{"tuple" => [":scheduled_activities", 10]},
2136                      %{"tuple" => [":background", 5]}
2137                    ]
2138                  }
2139                ]
2140              }
2141     end
2142
2143     test "delete part of settings by atom subkeys", %{conn: conn} do
2144       config =
2145         insert(:config,
2146           key: "keyaa1",
2147           value: :erlang.term_to_binary(subkey1: "val1", subkey2: "val2", subkey3: "val3")
2148         )
2149
2150       conn =
2151         post(conn, "/api/pleroma/admin/config", %{
2152           configs: [
2153             %{
2154               group: config.group,
2155               key: config.key,
2156               subkeys: [":subkey1", ":subkey3"],
2157               delete: "true"
2158             }
2159           ]
2160         })
2161
2162       assert(
2163         json_response(conn, 200) == %{
2164           "configs" => [
2165             %{
2166               "group" => "pleroma",
2167               "key" => "keyaa1",
2168               "value" => [%{"tuple" => [":subkey2", "val2"]}]
2169             }
2170           ]
2171         }
2172       )
2173     end
2174   end
2175
2176   describe "config mix tasks run" do
2177     setup %{conn: conn} do
2178       admin = insert(:user, info: %{is_admin: true})
2179
2180       temp_file = "config/test.exported_from_db.secret.exs"
2181
2182       Mix.shell(Mix.Shell.Quiet)
2183
2184       on_exit(fn ->
2185         Mix.shell(Mix.Shell.IO)
2186         :ok = File.rm(temp_file)
2187       end)
2188
2189       %{conn: assign(conn, :user, admin), admin: admin}
2190     end
2191
2192     clear_config([:instance, :dynamic_configuration]) do
2193       Pleroma.Config.put([:instance, :dynamic_configuration], true)
2194     end
2195
2196     test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
2197       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2198       conn = get(conn, "/api/pleroma/admin/config/migrate_to_db")
2199       assert json_response(conn, 200) == %{}
2200       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) > 0
2201
2202       conn =
2203         build_conn()
2204         |> assign(:user, admin)
2205         |> get("/api/pleroma/admin/config/migrate_from_db")
2206
2207       assert json_response(conn, 200) == %{}
2208       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
2209     end
2210   end
2211
2212   describe "GET /api/pleroma/admin/users/:nickname/statuses" do
2213     setup do
2214       admin = insert(:user, info: %{is_admin: true})
2215       user = insert(:user)
2216
2217       date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
2218       date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
2219       date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
2220
2221       insert(:note_activity, user: user, published: date1)
2222       insert(:note_activity, user: user, published: date2)
2223       insert(:note_activity, user: user, published: date3)
2224
2225       conn =
2226         build_conn()
2227         |> assign(:user, admin)
2228
2229       {:ok, conn: conn, user: user}
2230     end
2231
2232     test "renders user's statuses", %{conn: conn, user: user} do
2233       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2234
2235       assert json_response(conn, 200) |> length() == 3
2236     end
2237
2238     test "renders user's statuses with a limit", %{conn: conn, user: user} do
2239       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
2240
2241       assert json_response(conn, 200) |> length() == 2
2242     end
2243
2244     test "doesn't return private statuses by default", %{conn: conn, user: user} do
2245       {:ok, _private_status} =
2246         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2247
2248       {:ok, _public_status} =
2249         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2250
2251       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
2252
2253       assert json_response(conn, 200) |> length() == 4
2254     end
2255
2256     test "returns private statuses with godmode on", %{conn: conn, user: user} do
2257       {:ok, _private_status} =
2258         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2259
2260       {:ok, _public_status} =
2261         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2262
2263       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
2264
2265       assert json_response(conn, 200) |> length() == 5
2266     end
2267   end
2268
2269   describe "GET /api/pleroma/admin/moderation_log" do
2270     setup %{conn: conn} do
2271       admin = insert(:user, info: %{is_admin: true})
2272
2273       %{conn: assign(conn, :user, admin), admin: admin}
2274     end
2275
2276     test "returns the log", %{conn: conn, admin: admin} do
2277       Repo.insert(%ModerationLog{
2278         data: %{
2279           actor: %{
2280             "id" => admin.id,
2281             "nickname" => admin.nickname,
2282             "type" => "user"
2283           },
2284           action: "relay_follow",
2285           target: "https://example.org/relay"
2286         },
2287         inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2288       })
2289
2290       Repo.insert(%ModerationLog{
2291         data: %{
2292           actor: %{
2293             "id" => admin.id,
2294             "nickname" => admin.nickname,
2295             "type" => "user"
2296           },
2297           action: "relay_unfollow",
2298           target: "https://example.org/relay"
2299         },
2300         inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2301       })
2302
2303       conn = get(conn, "/api/pleroma/admin/moderation_log")
2304
2305       response = json_response(conn, 200)
2306       [first_entry, second_entry] = response
2307
2308       assert response |> length() == 2
2309       assert first_entry["data"]["action"] == "relay_unfollow"
2310
2311       assert first_entry["message"] ==
2312                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2313
2314       assert second_entry["data"]["action"] == "relay_follow"
2315
2316       assert second_entry["message"] ==
2317                "@#{admin.nickname} followed relay: https://example.org/relay"
2318     end
2319
2320     test "returns the log with pagination", %{conn: conn, admin: admin} do
2321       Repo.insert(%ModerationLog{
2322         data: %{
2323           actor: %{
2324             "id" => admin.id,
2325             "nickname" => admin.nickname,
2326             "type" => "user"
2327           },
2328           action: "relay_follow",
2329           target: "https://example.org/relay"
2330         },
2331         inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
2332       })
2333
2334       Repo.insert(%ModerationLog{
2335         data: %{
2336           actor: %{
2337             "id" => admin.id,
2338             "nickname" => admin.nickname,
2339             "type" => "user"
2340           },
2341           action: "relay_unfollow",
2342           target: "https://example.org/relay"
2343         },
2344         inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
2345       })
2346
2347       conn1 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=1")
2348
2349       response1 = json_response(conn1, 200)
2350       [first_entry] = response1
2351
2352       assert response1 |> length() == 1
2353       assert first_entry["data"]["action"] == "relay_unfollow"
2354
2355       assert first_entry["message"] ==
2356                "@#{admin.nickname} unfollowed relay: https://example.org/relay"
2357
2358       conn2 = get(conn, "/api/pleroma/admin/moderation_log?page_size=1&page=2")
2359
2360       response2 = json_response(conn2, 200)
2361       [second_entry] = response2
2362
2363       assert response2 |> length() == 1
2364       assert second_entry["data"]["action"] == "relay_follow"
2365
2366       assert second_entry["message"] ==
2367                "@#{admin.nickname} followed relay: https://example.org/relay"
2368     end
2369   end
2370 end
2371
2372 # Needed for testing
2373 defmodule Pleroma.Web.Endpoint.NotReal do
2374 end
2375
2376 defmodule Pleroma.Captcha.NotReal do
2377 end