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