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

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