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