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