services/api/test/functional/arvados/v1/users_controller_test.rb

   1 require 'test_helper'
   2 require 'helpers/users_test_helper'
   3
   4 class Arvados::V1::UsersControllerTest < ActionController::TestCase
   5   include CurrentApiClient
   6   include UsersTestHelper
   7
   8   setup do
   9     @initial_link_count = Link.count
  10     @vm_uuid = virtual_machines(:testvm).uuid
  11   end
  12
  13   test "activate a user after signing UA" do
  14     authorize_with :inactive_but_signed_user_agreement
  15     post :activate, id: users(:inactive_but_signed_user_agreement).uuid
  16     assert_response :success
  17     assert_not_nil assigns(:object)
  18     me = JSON.parse(@response.body)
  19     assert_equal true, me['is_active']
  20   end
  21
  22   test "refuse to activate a user before signing UA" do
  23     act_as_system_user do
  24     required_uuids = Link.where("owner_uuid = ? and link_class = ? and name = ? and tail_uuid = ? and head_uuid like ?",
  25                                 system_user_uuid,
  26                                 'signature',
  27                                 'require',
  28                                 system_user_uuid,
  29                                 Collection.uuid_like_pattern).
  30       collect(&:head_uuid)
  31
  32       assert required_uuids.length > 0
  33
  34       signed_uuids = Link.where(owner_uuid: system_user_uuid,
  35                                 link_class: 'signature',
  36                                 name: 'click',
  37                                 tail_uuid: users(:inactive).uuid,
  38                                 head_uuid: required_uuids).
  39                           collect(&:head_uuid)
  40
  41       assert_equal 0, signed_uuids.length
  42     end
  43
  44     authorize_with :inactive
  45     assert_equal false, users(:inactive).is_active
  46
  47     post :activate, id: users(:inactive).uuid
  48     assert_response 403
  49
  50     resp = json_response
  51     assert resp['errors'].first.include? 'Cannot activate without user agreements'
  52     assert_nil resp['is_active']
  53   end
  54
  55   test "activate an already-active user" do
  56     authorize_with :active
  57     post :activate, id: users(:active).uuid
  58     assert_response :success
  59     me = JSON.parse(@response.body)
  60     assert_equal true, me['is_active']
  61   end
  62
  63   test "respond 401 if given token exists but user record is missing" do
  64     authorize_with :valid_token_deleted_user
  65     get :current, {format: :json}
  66     assert_response 401
  67   end
  68
  69   test "create new user with user as input" do
  70     authorize_with :admin
  71     post :create, user: {
  72       first_name: "test_first_name",
  73       last_name: "test_last_name",
  74       email: "foo@example.com"
  75     }
  76     assert_response :success
  77     created = JSON.parse(@response.body)
  78     assert_equal 'test_first_name', created['first_name']
  79     assert_not_nil created['uuid'], 'expected uuid for the newly created user'
  80     assert_not_nil created['email'], 'expected non-nil email'
  81     assert_nil created['identity_url'], 'expected no identity_url'
  82   end
  83
  84   test "create user with user, vm and repo as input" do
  85     authorize_with :admin
  86     repo_name = 'usertestrepo'
  87
  88     post :setup, {
  89       repo_name: repo_name,
  90       openid_prefix: 'https://www.google.com/accounts/o8/id',
  91       user: {
  92         uuid: 'zzzzz-tpzed-abcdefghijklmno',
  93         first_name: "in_create_test_first_name",
  94         last_name: "test_last_name",
  95         email: "foo@example.com"
  96       }
  97     }
  98     assert_response :success
  99     response_items = JSON.parse(@response.body)['items']
 100
 101     created = find_obj_in_resp response_items, 'User', nil
 102
 103     assert_equal 'in_create_test_first_name', created['first_name']
 104     assert_not_nil created['uuid'], 'expected non-null uuid for the new user'
 105     assert_equal 'zzzzz-tpzed-abcdefghijklmno', created['uuid']
 106     assert_not_nil created['email'], 'expected non-nil email'
 107     assert_nil created['identity_url'], 'expected no identity_url'
 108
 109     # arvados#user, repo link and link add user to 'All users' group
 110     verify_links_added 4
 111
 112     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 113         created['uuid'], created['email'], 'arvados#user', false, 'User'
 114
 115     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 116         "foo/#{repo_name}", created['uuid'], 'arvados#repository', true, 'Repository'
 117
 118     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 119         'All users', created['uuid'], 'arvados#group', true, 'Group'
 120
 121     verify_link response_items, 'arvados#virtualMachine', false, 'permission', 'can_login',
 122         nil, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 123
 124     verify_system_group_permission_link_for created['uuid']
 125   end
 126
 127   test "setup user with bogus uuid and expect error" do
 128     authorize_with :admin
 129
 130     post :setup, {
 131       uuid: 'bogus_uuid',
 132       repo_name: 'usertestrepo',
 133       vm_uuid: @vm_uuid
 134     }
 135     response_body = JSON.parse(@response.body)
 136     response_errors = response_body['errors']
 137     assert_not_nil response_errors, 'Expected error in response'
 138     assert (response_errors.first.include? 'Path not found'), 'Expected 404'
 139   end
 140
 141   test "setup user with bogus uuid in user and expect error" do
 142     authorize_with :admin
 143
 144     post :setup, {
 145       user: {uuid: 'bogus_uuid'},
 146       repo_name: 'usertestrepo',
 147       vm_uuid: @vm_uuid,
 148       openid_prefix: 'https://www.google.com/accounts/o8/id'
 149     }
 150     response_body = JSON.parse(@response.body)
 151     response_errors = response_body['errors']
 152     assert_not_nil response_errors, 'Expected error in response'
 153     assert (response_errors.first.include? 'ArgumentError: Require user email'),
 154       'Expected RuntimeError'
 155   end
 156
 157   test "setup user with no uuid and user, expect error" do
 158     authorize_with :admin
 159
 160     post :setup, {
 161       repo_name: 'usertestrepo',
 162       vm_uuid: @vm_uuid,
 163       openid_prefix: 'https://www.google.com/accounts/o8/id'
 164     }
 165     response_body = JSON.parse(@response.body)
 166     response_errors = response_body['errors']
 167     assert_not_nil response_errors, 'Expected error in response'
 168     assert (response_errors.first.include? 'Required uuid or user'),
 169         'Expected ArgumentError'
 170   end
 171
 172   test "setup user with no uuid and email, expect error" do
 173     authorize_with :admin
 174
 175     post :setup, {
 176       user: {},
 177       repo_name: 'usertestrepo',
 178       vm_uuid: @vm_uuid,
 179       openid_prefix: 'https://www.google.com/accounts/o8/id'
 180     }
 181     response_body = JSON.parse(@response.body)
 182     response_errors = response_body['errors']
 183     assert_not_nil response_errors, 'Expected error in response'
 184     assert (response_errors.first.include? '<ArgumentError: Require user email'),
 185         'Expected ArgumentError'
 186   end
 187
 188   test "invoke setup with existing uuid, vm and repo and verify links" do
 189     authorize_with :admin
 190     inactive_user = users(:inactive)
 191
 192     post :setup, {
 193       uuid: users(:inactive).uuid,
 194       repo_name: 'usertestrepo',
 195       vm_uuid: @vm_uuid
 196     }
 197
 198     assert_response :success
 199
 200     response_items = JSON.parse(@response.body)['items']
 201     resp_obj = find_obj_in_resp response_items, 'User', nil
 202
 203     assert_not_nil resp_obj['uuid'], 'expected uuid for the new user'
 204     assert_equal inactive_user['uuid'], resp_obj['uuid']
 205     assert_equal inactive_user['email'], resp_obj['email'],
 206         'expecting inactive user email'
 207
 208     # expect repo and vm links
 209     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 210         'inactiveuser/usertestrepo', resp_obj['uuid'], 'arvados#repository', true, 'Repository'
 211
 212     verify_link response_items, 'arvados#virtualMachine', true, 'permission', 'can_login',
 213         @vm_uuid, resp_obj['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 214   end
 215
 216   test "invoke setup with existing uuid in user, verify response" do
 217     authorize_with :admin
 218     inactive_user = users(:inactive)
 219
 220     post :setup, {
 221       user: {uuid: inactive_user['uuid']},
 222       openid_prefix: 'https://www.google.com/accounts/o8/id'
 223     }
 224
 225     assert_response :success
 226
 227     response_items = JSON.parse(@response.body)['items']
 228     resp_obj = find_obj_in_resp response_items, 'User', nil
 229
 230     assert_not_nil resp_obj['uuid'], 'expected uuid for the new user'
 231     assert_equal inactive_user['uuid'], resp_obj['uuid']
 232     assert_equal inactive_user['email'], resp_obj['email'],
 233         'expecting inactive user email'
 234   end
 235
 236   test "invoke setup with existing uuid but different email, expect original email" do
 237     authorize_with :admin
 238     inactive_user = users(:inactive)
 239
 240     post :setup, {
 241       uuid: inactive_user['uuid'],
 242       user: {email: 'junk_email'}
 243     }
 244
 245     assert_response :success
 246
 247     response_items = JSON.parse(@response.body)['items']
 248     resp_obj = find_obj_in_resp response_items, 'User', nil
 249
 250     assert_not_nil resp_obj['uuid'], 'expected uuid for the new user'
 251     assert_equal inactive_user['uuid'], resp_obj['uuid']
 252     assert_equal inactive_user['email'], resp_obj['email'],
 253         'expecting inactive user email'
 254   end
 255
 256   test "setup user with valid email and repo as input" do
 257     authorize_with :admin
 258
 259     post :setup, {
 260       repo_name: 'usertestrepo',
 261       user: {email: 'foo@example.com'},
 262       openid_prefix: 'https://www.google.com/accounts/o8/id'
 263     }
 264
 265     assert_response :success
 266     response_items = JSON.parse(@response.body)['items']
 267     response_object = find_obj_in_resp response_items, 'User', nil
 268     assert_not_nil response_object['uuid'], 'expected uuid for the new user'
 269     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 270
 271     # four extra links; system_group, login, group and repo perms
 272     verify_links_added 4
 273   end
 274
 275   test "setup user with fake vm and expect error" do
 276     authorize_with :admin
 277
 278     post :setup, {
 279       repo_name: 'usertestrepo',
 280       vm_uuid: 'no_such_vm',
 281       user: {email: 'foo@example.com'},
 282       openid_prefix: 'https://www.google.com/accounts/o8/id'
 283     }
 284
 285     response_body = JSON.parse(@response.body)
 286     response_errors = response_body['errors']
 287     assert_not_nil response_errors, 'Expected error in response'
 288     assert (response_errors.first.include? "No vm found for no_such_vm"),
 289           'Expected RuntimeError: No vm found for no_such_vm'
 290   end
 291
 292   test "setup user with valid email, repo and real vm as input" do
 293     authorize_with :admin
 294
 295     post :setup, {
 296       repo_name: 'usertestrepo',
 297       openid_prefix: 'https://www.google.com/accounts/o8/id',
 298       vm_uuid: @vm_uuid,
 299       user: {email: 'foo@example.com'}
 300     }
 301
 302     assert_response :success
 303     response_items = JSON.parse(@response.body)['items']
 304     response_object = find_obj_in_resp response_items, 'User', nil
 305     assert_not_nil response_object['uuid'], 'expected uuid for the new user'
 306     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 307
 308     # five extra links; system_group, login, group, vm, repo
 309     verify_links_added 5
 310   end
 311
 312   test "setup user with valid email, no vm and no repo as input" do
 313     authorize_with :admin
 314
 315     post :setup, {
 316       user: {email: 'foo@example.com'},
 317       openid_prefix: 'https://www.google.com/accounts/o8/id'
 318     }
 319
 320     assert_response :success
 321     response_items = JSON.parse(@response.body)['items']
 322     response_object = find_obj_in_resp response_items, 'User', nil
 323     assert_not_nil response_object['uuid'], 'expected uuid for new user'
 324     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 325
 326     # three extra links; system_group, login, and group
 327     verify_links_added 3
 328
 329     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 330         response_object['uuid'], response_object['email'], 'arvados#user', false, 'User'
 331
 332     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 333         'All users', response_object['uuid'], 'arvados#group', true, 'Group'
 334
 335     verify_link response_items, 'arvados#repository', false, 'permission', 'can_manage',
 336         'foo/usertestrepo', response_object['uuid'], 'arvados#repository', true, 'Repository'
 337
 338     verify_link response_items, 'arvados#virtualMachine', false, 'permission', 'can_login',
 339         nil, response_object['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 340   end
 341
 342   test "setup user with email, first name, repo name and vm uuid" do
 343     authorize_with :admin
 344
 345     post :setup, {
 346       openid_prefix: 'https://www.google.com/accounts/o8/id',
 347       repo_name: 'usertestrepo',
 348       vm_uuid: @vm_uuid,
 349       user: {
 350         first_name: 'test_first_name',
 351         email: 'foo@example.com'
 352       }
 353     }
 354
 355     assert_response :success
 356     response_items = JSON.parse(@response.body)['items']
 357     response_object = find_obj_in_resp response_items, 'User', nil
 358     assert_not_nil response_object['uuid'], 'expected uuid for new user'
 359     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 360     assert_equal 'test_first_name', response_object['first_name'],
 361         'expecting first name'
 362
 363     # five extra links; system_group, login, group, repo and vm
 364     verify_links_added 5
 365   end
 366
 367   test "setup user with an existing user email and check different object is created" do
 368     authorize_with :admin
 369     inactive_user = users(:inactive)
 370
 371     post :setup, {
 372       openid_prefix: 'https://www.google.com/accounts/o8/id',
 373       repo_name: 'usertestrepo',
 374       user: {
 375         email: inactive_user['email']
 376       }
 377     }
 378
 379     assert_response :success
 380     response_items = JSON.parse(@response.body)['items']
 381     response_object = find_obj_in_resp response_items, 'User', nil
 382     assert_not_nil response_object['uuid'], 'expected uuid for new user'
 383     assert_not_equal response_object['uuid'], inactive_user['uuid'],
 384         'expected different uuid after create operation'
 385     assert_equal inactive_user['email'], response_object['email'], 'expected given email'
 386     # system_group, openid, group, and repo. No vm link.
 387     verify_links_added 4
 388   end
 389
 390   test "setup user with openid prefix" do
 391     authorize_with :admin
 392
 393     post :setup, {
 394       repo_name: 'usertestrepo',
 395       openid_prefix: 'http://www.example.com/account',
 396       user: {
 397         first_name: "in_create_test_first_name",
 398         last_name: "test_last_name",
 399         email: "foo@example.com"
 400       }
 401     }
 402
 403     assert_response :success
 404
 405     response_items = JSON.parse(@response.body)['items']
 406     created = find_obj_in_resp response_items, 'User', nil
 407
 408     assert_equal 'in_create_test_first_name', created['first_name']
 409     assert_not_nil created['uuid'], 'expected uuid for new user'
 410     assert_not_nil created['email'], 'expected non-nil email'
 411     assert_nil created['identity_url'], 'expected no identity_url'
 412
 413     # verify links
 414     # four new links: system_group, arvados#user, repo, and 'All users' group.
 415     verify_links_added 4
 416
 417     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 418         created['uuid'], created['email'], 'arvados#user', false, 'User'
 419
 420     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 421         'foo/usertestrepo', created['uuid'], 'arvados#repository', true, 'Repository'
 422
 423     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 424         'All users', created['uuid'], 'arvados#group', true, 'Group'
 425
 426     verify_link response_items, 'arvados#virtualMachine', false, 'permission', 'can_login',
 427         nil, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 428   end
 429
 430   test "invoke setup with no openid prefix, expect error" do
 431     authorize_with :admin
 432
 433     post :setup, {
 434       repo_name: 'usertestrepo',
 435       user: {
 436         first_name: "in_create_test_first_name",
 437         last_name: "test_last_name",
 438         email: "foo@example.com"
 439       }
 440     }
 441
 442     response_body = JSON.parse(@response.body)
 443     response_errors = response_body['errors']
 444     assert_not_nil response_errors, 'Expected error in response'
 445     assert (response_errors.first.include? 'openid_prefix parameter is missing'),
 446         'Expected ArgumentError'
 447   end
 448
 449   test "setup user with user, vm and repo and verify links" do
 450     authorize_with :admin
 451
 452     post :setup, {
 453       user: {
 454         first_name: "in_create_test_first_name",
 455         last_name: "test_last_name",
 456         email: "foo@example.com"
 457       },
 458       vm_uuid: @vm_uuid,
 459       repo_name: 'usertestrepo',
 460       openid_prefix: 'https://www.google.com/accounts/o8/id'
 461     }
 462
 463     assert_response :success
 464
 465     response_items = JSON.parse(@response.body)['items']
 466     created = find_obj_in_resp response_items, 'User', nil
 467
 468     assert_equal 'in_create_test_first_name', created['first_name']
 469     assert_not_nil created['uuid'], 'expected uuid for new user'
 470     assert_not_nil created['email'], 'expected non-nil email'
 471     assert_nil created['identity_url'], 'expected no identity_url'
 472
 473     # five new links: system_group, arvados#user, repo, vm and 'All
 474     # users' group link
 475     verify_links_added 5
 476
 477     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 478         created['uuid'], created['email'], 'arvados#user', false, 'User'
 479
 480     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 481         'foo/usertestrepo', created['uuid'], 'arvados#repository', true, 'Repository'
 482
 483     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 484         'All users', created['uuid'], 'arvados#group', true, 'Group'
 485
 486     verify_link response_items, 'arvados#virtualMachine', true, 'permission', 'can_login',
 487         @vm_uuid, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 488   end
 489
 490   test "create user as non admin user and expect error" do
 491     authorize_with :active
 492
 493     post :create, {
 494       user: {email: 'foo@example.com'}
 495     }
 496
 497     response_body = JSON.parse(@response.body)
 498     response_errors = response_body['errors']
 499     assert_not_nil response_errors, 'Expected error in response'
 500     assert (response_errors.first.include? 'PermissionDenied'),
 501           'Expected PermissionDeniedError'
 502   end
 503
 504   test "setup user as non admin user and expect error" do
 505     authorize_with :active
 506
 507     post :setup, {
 508       openid_prefix: 'https://www.google.com/accounts/o8/id',
 509       user: {email: 'foo@example.com'}
 510     }
 511
 512     response_body = JSON.parse(@response.body)
 513     response_errors = response_body['errors']
 514     assert_not_nil response_errors, 'Expected error in response'
 515     assert (response_errors.first.include? 'Forbidden'),
 516           'Expected Forbidden error'
 517   end
 518
 519   test "setup active user with repo and no vm" do
 520     authorize_with :admin
 521     active_user = users(:active)
 522
 523     # invoke setup with a repository
 524     post :setup, {
 525       repo_name: 'usertestrepo',
 526       uuid: active_user['uuid']
 527     }
 528
 529     assert_response :success
 530
 531     response_items = JSON.parse(@response.body)['items']
 532     created = find_obj_in_resp response_items, 'User', nil
 533
 534     assert_equal active_user[:email], created['email'], 'expected input email'
 535
 536      # verify links
 537     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 538         'All users', created['uuid'], 'arvados#group', true, 'Group'
 539
 540     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 541         'active/usertestrepo', created['uuid'], 'arvados#repository', true, 'Repository'
 542
 543     verify_link response_items, 'arvados#virtualMachine', false, 'permission', 'can_login',
 544         nil, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 545   end
 546
 547   test "setup active user with vm and no repo" do
 548     authorize_with :admin
 549     active_user = users(:active)
 550     repos_query = Repository.where(owner_uuid: active_user.uuid)
 551     repo_link_query = Link.where(tail_uuid: active_user.uuid,
 552                                  link_class: "permission", name: "can_manage")
 553     repos_count = repos_query.count
 554     repo_link_count = repo_link_query.count
 555
 556     # invoke setup with a repository
 557     post :setup, {
 558       vm_uuid: @vm_uuid,
 559       uuid: active_user['uuid'],
 560       email: 'junk_email'
 561     }
 562
 563     assert_response :success
 564
 565     response_items = JSON.parse(@response.body)['items']
 566     created = find_obj_in_resp response_items, 'User', nil
 567
 568     assert_equal active_user['email'], created['email'], 'expected original email'
 569
 570     # verify links
 571     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 572         'All users', created['uuid'], 'arvados#group', true, 'Group'
 573
 574     assert_equal(repos_count, repos_query.count)
 575     assert_equal(repo_link_count, repo_link_query.count)
 576
 577     verify_link response_items, 'arvados#virtualMachine', true, 'permission', 'can_login',
 578         @vm_uuid, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 579   end
 580
 581   test "unsetup active user" do
 582     active_user = users(:active)
 583     assert_not_nil active_user['uuid'], 'expected uuid for the active user'
 584     assert active_user['is_active'], 'expected is_active for active user'
 585
 586     verify_link_existence active_user['uuid'], active_user['email'],
 587           false, true, true, true, true
 588
 589     authorize_with :admin
 590
 591     # now unsetup this user
 592     post :unsetup, id: active_user['uuid']
 593     assert_response :success
 594
 595     response_user = JSON.parse(@response.body)
 596     assert_not_nil response_user['uuid'], 'expected uuid for the upsetup user'
 597     assert_equal active_user['uuid'], response_user['uuid'], 'expected uuid not found'
 598     assert !response_user['is_active'], 'expected user to be inactive'
 599     assert !response_user['is_invited'], 'expected user to be uninvited'
 600
 601     verify_link_existence response_user['uuid'], response_user['email'],
 602           false, false, false, false, false
 603
 604     active_user = User.find_by_uuid(users(:active).uuid)
 605     readable_groups = active_user.groups_i_can(:read)
 606     all_users_group = Group.all.collect(&:uuid).select { |g| g.match(/-f+$/) }
 607     refute_includes(readable_groups, all_users_group,
 608                     "active user can read All Users group after being deactivated")
 609     assert_equal(false, active_user.is_invited,
 610                  "active user is_invited after being deactivated & reloaded")
 611   end
 612
 613   test "setup user with send notification param false and verify no email" do
 614     authorize_with :admin
 615
 616     post :setup, {
 617       openid_prefix: 'http://www.example.com/account',
 618       send_notification_email: 'false',
 619       user: {
 620         email: "foo@example.com"
 621       }
 622     }
 623
 624     assert_response :success
 625     response_items = JSON.parse(@response.body)['items']
 626     created = find_obj_in_resp response_items, 'User', nil
 627     assert_not_nil created['uuid'], 'expected uuid for the new user'
 628     assert_equal created['email'], 'foo@example.com', 'expected given email'
 629
 630     setup_email = ActionMailer::Base.deliveries.last
 631     assert_nil setup_email, 'expected no setup email'
 632   end
 633
 634   test "setup user with send notification param true and verify email" do
 635     authorize_with :admin
 636
 637     post :setup, {
 638       openid_prefix: 'http://www.example.com/account',
 639       send_notification_email: 'true',
 640       user: {
 641         email: "foo@example.com"
 642       }
 643     }
 644
 645     assert_response :success
 646     response_items = JSON.parse(@response.body)['items']
 647     created = find_obj_in_resp response_items, 'User', nil
 648     assert_not_nil created['uuid'], 'expected uuid for the new user'
 649     assert_equal created['email'], 'foo@example.com', 'expected given email'
 650
 651     setup_email = ActionMailer::Base.deliveries.last
 652     assert_not_nil setup_email, 'Expected email after setup'
 653
 654     assert_equal Rails.configuration.user_notifier_email_from, setup_email.from[0]
 655     assert_equal 'foo@example.com', setup_email.to[0]
 656     assert_equal 'Welcome to Curoverse - shell account enabled', setup_email.subject
 657     assert (setup_email.body.to_s.include? 'Your Arvados shell account has been set up'),
 658         'Expected Your Arvados shell account has been set up in email body'
 659     assert (setup_email.body.to_s.include? "#{Rails.configuration.workbench_address}users/#{created['uuid']}/virtual_machines"), 'Expected virtual machines url in email body'
 660   end
 661
 662   test "non-admin user can get basic information about readable users" do
 663     authorize_with :spectator
 664     get(:index)
 665     check_non_admin_index
 666     check_readable_users_index [:spectator], [:inactive, :active]
 667   end
 668
 669   test "non-admin user gets only safe attributes from users#show" do
 670     g = act_as_system_user do
 671       create :group
 672     end
 673     users = create_list :active_user, 2, join_groups: [g]
 674     token = create :token, user: users[0]
 675     authorize_with_token token
 676     get :show, id: users[1].uuid
 677     check_non_admin_show
 678   end
 679
 680   [2, 4].each do |limit|
 681     test "non-admin user can limit index to #{limit}" do
 682       g = act_as_system_user do
 683         create :group
 684       end
 685       users = create_list :active_user, 4, join_groups: [g]
 686       token = create :token, user: users[0]
 687
 688       authorize_with_token token
 689       get(:index, limit: limit)
 690       check_non_admin_index
 691       assert_equal(limit, json_response["items"].size,
 692                    "non-admin index limit was ineffective")
 693     end
 694   end
 695
 696   test "admin has full index powers" do
 697     authorize_with :admin
 698     check_inactive_user_findable
 699   end
 700
 701   test "reader token can grant admin index powers" do
 702     authorize_with :spectator
 703     check_inactive_user_findable(reader_tokens: [api_token(:admin)])
 704   end
 705
 706   test "admin can filter on user.is_active" do
 707     authorize_with :admin
 708     get(:index, filters: [["is_active", "=", "true"]])
 709     assert_response :success
 710     check_readable_users_index [:active, :spectator], [:inactive]
 711   end
 712
 713   test "admin can search where user.is_active" do
 714     authorize_with :admin
 715     get(:index, where: {is_active: true})
 716     assert_response :success
 717     check_readable_users_index [:active, :spectator], [:inactive]
 718   end
 719
 720   test "update active_no_prefs user profile and expect notification email" do
 721     authorize_with :admin
 722
 723     put :update, {
 724       id: users(:active_no_prefs).uuid,
 725       user: {
 726         prefs: {:profile => {'organization' => 'example.com'}}
 727       }
 728     }
 729     assert_response :success
 730
 731     found_email = false
 732     ActionMailer::Base.deliveries.andand.each do |email|
 733       if email.subject == "Profile created by #{users(:active_no_prefs).email}"
 734         found_email = true
 735         break
 736       end
 737     end
 738     assert_equal true, found_email, 'Expected email after creating profile'
 739   end
 740
 741   test "update active_no_prefs_profile user profile and expect notification email" do
 742     authorize_with :admin
 743
 744     user = {}
 745     user[:prefs] = users(:active_no_prefs_profile_no_getting_started_shown).prefs
 746     user[:prefs][:profile] = {:profile => {'organization' => 'example.com'}}
 747     put :update, {
 748       id: users(:active_no_prefs_profile_no_getting_started_shown).uuid,
 749       user: user
 750     }
 751     assert_response :success
 752
 753     found_email = false
 754     ActionMailer::Base.deliveries.andand.each do |email|
 755       if email.subject == "Profile created by #{users(:active_no_prefs_profile_no_getting_started_shown).email}"
 756         found_email = true
 757         break
 758       end
 759     end
 760     assert_equal true, found_email, 'Expected email after creating profile'
 761   end
 762
 763   test "update active user profile and expect no notification email" do
 764     authorize_with :admin
 765
 766     put :update, {
 767       id: users(:active).uuid,
 768       user: {
 769         prefs: {:profile => {'organization' => 'anotherexample.com'}}
 770       }
 771     }
 772     assert_response :success
 773
 774     found_email = false
 775     ActionMailer::Base.deliveries.andand.each do |email|
 776       if email.subject == "Profile created by #{users(:active).email}"
 777         found_email = true
 778         break
 779       end
 780     end
 781     assert_equal false, found_email, 'Expected no email after updating profile'
 782   end
 783
 784   test "user API response includes writable_by" do
 785     authorize_with :active
 786     get :current
 787     assert_response :success
 788     assert_includes(json_response["writable_by"], users(:active).uuid,
 789                     "user's writable_by should include self")
 790     assert_includes(json_response["writable_by"], users(:active).owner_uuid,
 791                     "user's writable_by should include its owner_uuid")
 792   end
 793
 794
 795   NON_ADMIN_USER_DATA = ["uuid", "kind", "is_active", "email", "first_name",
 796                          "last_name"].sort
 797
 798   def check_non_admin_index
 799     assert_response :success
 800     response_items = json_response["items"]
 801     assert_not_nil response_items
 802     response_items.each do |user_data|
 803       check_non_admin_item user_data
 804       assert(user_data["is_active"], "non-admin index returned inactive user")
 805     end
 806   end
 807
 808   def check_non_admin_show
 809     assert_response :success
 810     check_non_admin_item json_response
 811   end
 812
 813   def check_non_admin_item user_data
 814     assert_equal(NON_ADMIN_USER_DATA, user_data.keys.sort,
 815                  "data in response had missing or extra attributes")
 816     assert_equal("arvados#user", user_data["kind"])
 817   end
 818
 819
 820   def check_readable_users_index expect_present, expect_missing
 821     response_uuids = json_response["items"].map { |u| u["uuid"] }
 822     expect_present.each do |user_key|
 823       assert_includes(response_uuids, users(user_key).uuid,
 824                       "#{user_key} missing from index")
 825     end
 826     expect_missing.each do |user_key|
 827       refute_includes(response_uuids, users(user_key).uuid,
 828                       "#{user_key} included in index")
 829     end
 830   end
 831
 832   def check_inactive_user_findable(params={})
 833     inactive_user = users(:inactive)
 834     get(:index, params.merge(filters: [["email", "=", inactive_user.email]]))
 835     assert_response :success
 836     user_list = json_response["items"]
 837     assert_equal(1, user_list.andand.count)
 838     # This test needs to check a column non-admins have no access to,
 839     # to ensure that admins see all user information.
 840     assert_equal(inactive_user.identity_url, user_list.first["identity_url"],
 841                  "admin's filtered index did not return inactive user")
 842   end
 843
 844   def verify_links_added more
 845     assert_equal @initial_link_count+more, Link.count,
 846         "Started with #{@initial_link_count} links, expected #{more} more"
 847   end
 848
 849   def find_obj_in_resp (response_items, object_type, head_kind=nil)
 850     return_obj = nil
 851     response_items.each { |x|
 852       if !x
 853         next
 854       end
 855
 856       if object_type == 'User'
 857         if ArvadosModel::resource_class_for_uuid(x['uuid']) == User
 858           return_obj = x
 859           break
 860         end
 861       else  # looking for a link
 862         if x['head_uuid'] and ArvadosModel::resource_class_for_uuid(x['head_uuid']).kind == head_kind
 863           return_obj = x
 864           break
 865         end
 866       end
 867     }
 868     return return_obj
 869   end
 870 end