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