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

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