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

   1 require 'test_helper'
   2
   3 class Arvados::V1::UsersControllerTest < ActionController::TestCase
   4   include CurrentApiClient
   5
   6   setup do
   7     @all_links_at_start = Link.all
   8     @vm_uuid = virtual_machines(:testvm).uuid
   9   end
  10
  11   test "activate a user after signing UA" do
  12     authorize_with :inactive_but_signed_user_agreement
  13     get :current
  14     assert_response :success
  15     me = JSON.parse(@response.body)
  16     post :activate, id: me['uuid']
  17     assert_response :success
  18     assert_not_nil assigns(:object)
  19     me = JSON.parse(@response.body)
  20     assert_equal true, me['is_active']
  21   end
  22
  23   test "refuse to activate a user before signing UA" do
  24     act_as_system_user do
  25     required_uuids = Link.where("owner_uuid = ? and link_class = ? and name = ? and tail_uuid = ? and head_uuid like ?",
  26                                 system_user_uuid,
  27                                 'signature',
  28                                 'require',
  29                                 system_user_uuid,
  30                                 Collection.uuid_like_pattern).
  31       collect(&:head_uuid)
  32
  33       assert required_uuids.length > 0
  34
  35       signed_uuids = Link.where(owner_uuid: system_user_uuid,
  36                                 link_class: 'signature',
  37                                 name: 'click',
  38                                 tail_uuid: users(:inactive).uuid,
  39                                 head_uuid: required_uuids).
  40         collect(&:head_uuid)
  41
  42       assert_equal 0, signed_uuids.length
  43     end
  44
  45     authorize_with :inactive
  46
  47     get :current
  48     assert_response :success
  49     me = JSON.parse(@response.body)
  50     assert_equal false, me['is_active']
  51
  52     post :activate, id: me['uuid']
  53     assert_response 403
  54
  55     get :current
  56     assert_response :success
  57     me = JSON.parse(@response.body)
  58     assert_equal false, me['is_active']
  59   end
  60
  61   test "activate an already-active user" do
  62     authorize_with :active
  63     get :current
  64     assert_response :success
  65     me = JSON.parse(@response.body)
  66     post :activate, id: me['uuid']
  67     assert_response :success
  68     me = JSON.parse(@response.body)
  69     assert_equal true, me['is_active']
  70   end
  71
  72   test "respond 401 if given token exists but user record is missing" do
  73     authorize_with :valid_token_deleted_user
  74     get :current, {format: :json}
  75     assert_response 401
  76   end
  77
  78   test "create new user with user as input" do
  79     authorize_with :admin
  80     post :create, user: {
  81       first_name: "test_first_name",
  82       last_name: "test_last_name",
  83       email: "foo@example.com"
  84     }
  85     assert_response :success
  86     created = JSON.parse(@response.body)
  87     assert_equal 'test_first_name', created['first_name']
  88     assert_not_nil created['uuid'], 'expected uuid for the newly created user'
  89     assert_not_nil created['email'], 'expected non-nil email'
  90     assert_nil created['identity_url'], 'expected no identity_url'
  91   end
  92
  93   test "create user with user, vm and repo as input" do
  94     authorize_with :admin
  95     repo_name = 'test_repo'
  96
  97     post :setup, {
  98       repo_name: repo_name,
  99       openid_prefix: 'https://www.google.com/accounts/o8/id',
 100       user: {
 101         uuid: 'zzzzz-tpzed-abcdefghijklmno',
 102         first_name: "in_create_test_first_name",
 103         last_name: "test_last_name",
 104         email: "foo@example.com"
 105       }
 106     }
 107     assert_response :success
 108     response_items = JSON.parse(@response.body)['items']
 109
 110     created = find_obj_in_resp response_items, 'User', nil
 111
 112     assert_equal 'in_create_test_first_name', created['first_name']
 113     assert_not_nil created['uuid'], 'expected non-null uuid for the new user'
 114     assert_equal 'zzzzz-tpzed-abcdefghijklmno', created['uuid']
 115     assert_not_nil created['email'], 'expected non-nil email'
 116     assert_nil created['identity_url'], 'expected no identity_url'
 117
 118     # arvados#user, repo link and link add user to 'All users' group
 119     verify_num_links @all_links_at_start, 4
 120
 121     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 122         created['uuid'], created['email'], 'arvados#user', false, 'User'
 123
 124     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 125         repo_name, created['uuid'], 'arvados#repository', true, 'Repository'
 126
 127     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 128         'All users', created['uuid'], 'arvados#group', true, 'Group'
 129
 130     verify_link response_items, 'arvados#virtualMachine', false, 'permission', 'can_login',
 131         nil, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 132
 133     verify_system_group_permission_link_for created['uuid']
 134
 135     # invoke setup again with the same data
 136     post :setup, {
 137       repo_name: repo_name,
 138       vm_uuid: @vm_uuid,
 139       openid_prefix: 'https://www.google.com/accounts/o8/id',
 140       user: {
 141         uuid: 'zzzzz-tpzed-abcdefghijklmno',
 142         first_name: "in_create_test_first_name",
 143         last_name: "test_last_name",
 144         email: "foo@example.com"
 145       }
 146     }
 147     assert_response :success
 148
 149     response_items = JSON.parse(@response.body)['items']
 150
 151     created = find_obj_in_resp response_items, 'User', nil
 152     assert_equal 'in_create_test_first_name', created['first_name']
 153     assert_not_nil created['uuid'], 'expected non-null uuid for the new user'
 154     assert_equal 'zzzzz-tpzed-abcdefghijklmno', created['uuid']
 155     assert_not_nil created['email'], 'expected non-nil email'
 156     assert_nil created['identity_url'], 'expected no identity_url'
 157
 158     # arvados#user, repo link and link add user to 'All users' group
 159     verify_num_links @all_links_at_start, 5
 160
 161     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 162         repo_name, created['uuid'], 'arvados#repository', true, 'Repository'
 163
 164     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 165         'All users', created['uuid'], 'arvados#group', true, 'Group'
 166
 167     verify_link response_items, 'arvados#virtualMachine', true, 'permission', 'can_login',
 168         @vm_uuid, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 169
 170     verify_system_group_permission_link_for created['uuid']
 171   end
 172
 173   test "setup user with bogus uuid and expect error" do
 174     authorize_with :admin
 175
 176     post :setup, {
 177       uuid: 'bogus_uuid',
 178       repo_name: 'test_repo',
 179       vm_uuid: @vm_uuid
 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? 'Path not found'), 'Expected 404'
 185   end
 186
 187   test "setup user with bogus uuid in user and expect error" do
 188     authorize_with :admin
 189
 190     post :setup, {
 191       user: {uuid: 'bogus_uuid'},
 192       repo_name: 'test_repo',
 193       vm_uuid: @vm_uuid,
 194       openid_prefix: 'https://www.google.com/accounts/o8/id'
 195     }
 196     response_body = JSON.parse(@response.body)
 197     response_errors = response_body['errors']
 198     assert_not_nil response_errors, 'Expected error in response'
 199     assert (response_errors.first.include? 'ArgumentError: Require user email'),
 200       'Expected RuntimeError'
 201   end
 202
 203   test "setup user with no uuid and user, expect error" do
 204     authorize_with :admin
 205
 206     post :setup, {
 207       repo_name: 'test_repo',
 208       vm_uuid: @vm_uuid,
 209       openid_prefix: 'https://www.google.com/accounts/o8/id'
 210     }
 211     response_body = JSON.parse(@response.body)
 212     response_errors = response_body['errors']
 213     assert_not_nil response_errors, 'Expected error in response'
 214     assert (response_errors.first.include? 'Required uuid or user'),
 215         'Expected ArgumentError'
 216   end
 217
 218   test "setup user with no uuid and email, expect error" do
 219     authorize_with :admin
 220
 221     post :setup, {
 222       user: {},
 223       repo_name: 'test_repo',
 224       vm_uuid: @vm_uuid,
 225       openid_prefix: 'https://www.google.com/accounts/o8/id'
 226     }
 227     response_body = JSON.parse(@response.body)
 228     response_errors = response_body['errors']
 229     assert_not_nil response_errors, 'Expected error in response'
 230     assert (response_errors.first.include? '<ArgumentError: Require user email'),
 231         'Expected ArgumentError'
 232   end
 233
 234   test "invoke setup with existing uuid, vm and repo and verify links" do
 235     authorize_with :inactive
 236     get :current
 237     assert_response :success
 238     inactive_user = JSON.parse(@response.body)
 239
 240     authorize_with :admin
 241
 242     post :setup, {
 243       uuid: inactive_user['uuid'],
 244       repo_name: 'test_repo',
 245       vm_uuid: @vm_uuid
 246     }
 247
 248     assert_response :success
 249
 250     response_items = JSON.parse(@response.body)['items']
 251     resp_obj = find_obj_in_resp response_items, 'User', nil
 252
 253     assert_not_nil resp_obj['uuid'], 'expected uuid for the new user'
 254     assert_equal inactive_user['uuid'], resp_obj['uuid']
 255     assert_equal inactive_user['email'], resp_obj['email'],
 256         'expecting inactive user email'
 257
 258     # expect repo and vm links
 259     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 260         'test_repo', resp_obj['uuid'], 'arvados#repository', true, 'Repository'
 261
 262     verify_link response_items, 'arvados#virtualMachine', true, 'permission', 'can_login',
 263         @vm_uuid, resp_obj['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 264   end
 265
 266   test "invoke setup with existing uuid in user, verify response" do
 267     authorize_with :inactive
 268     get :current
 269     assert_response :success
 270     inactive_user = JSON.parse(@response.body)
 271
 272     authorize_with :admin
 273
 274     post :setup, {
 275       user: {uuid: inactive_user['uuid']},
 276       openid_prefix: 'https://www.google.com/accounts/o8/id'
 277     }
 278
 279     assert_response :success
 280
 281     response_items = JSON.parse(@response.body)['items']
 282     resp_obj = find_obj_in_resp response_items, 'User', nil
 283
 284     assert_not_nil resp_obj['uuid'], 'expected uuid for the new user'
 285     assert_equal inactive_user['uuid'], resp_obj['uuid']
 286     assert_equal inactive_user['email'], resp_obj['email'],
 287         'expecting inactive user email'
 288   end
 289
 290   test "invoke setup with existing uuid but different email, expect original email" do
 291     authorize_with :inactive
 292     get :current
 293     assert_response :success
 294     inactive_user = JSON.parse(@response.body)
 295
 296     authorize_with :admin
 297
 298     post :setup, {
 299       uuid: inactive_user['uuid'],
 300       user: {email: 'junk_email'}
 301     }
 302
 303     assert_response :success
 304
 305     response_items = JSON.parse(@response.body)['items']
 306     resp_obj = find_obj_in_resp response_items, 'User', nil
 307
 308     assert_not_nil resp_obj['uuid'], 'expected uuid for the new user'
 309     assert_equal inactive_user['uuid'], resp_obj['uuid']
 310     assert_equal inactive_user['email'], resp_obj['email'],
 311         'expecting inactive user email'
 312   end
 313
 314   test "setup user with valid email and repo as input" do
 315     authorize_with :admin
 316
 317     post :setup, {
 318       repo_name: 'test_repo',
 319       user: {email: 'foo@example.com'},
 320       openid_prefix: 'https://www.google.com/accounts/o8/id'
 321     }
 322
 323     assert_response :success
 324     response_items = JSON.parse(@response.body)['items']
 325     response_object = find_obj_in_resp response_items, 'User', nil
 326     assert_not_nil response_object['uuid'], 'expected uuid for the new user'
 327     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 328
 329     # four extra links; system_group, login, group and repo perms
 330     verify_num_links @all_links_at_start, 4
 331   end
 332
 333   test "setup user with fake vm and expect error" do
 334     authorize_with :admin
 335
 336     post :setup, {
 337       repo_name: 'test_repo',
 338       vm_uuid: 'no_such_vm',
 339       user: {email: 'foo@example.com'},
 340       openid_prefix: 'https://www.google.com/accounts/o8/id'
 341     }
 342
 343     response_body = JSON.parse(@response.body)
 344     response_errors = response_body['errors']
 345     assert_not_nil response_errors, 'Expected error in response'
 346     assert (response_errors.first.include? "No vm found for no_such_vm"),
 347           'Expected RuntimeError: No vm found for no_such_vm'
 348   end
 349
 350   test "setup user with valid email, repo and real vm as input" do
 351     authorize_with :admin
 352
 353     post :setup, {
 354       repo_name: 'test_repo',
 355       openid_prefix: 'https://www.google.com/accounts/o8/id',
 356       vm_uuid: @vm_uuid,
 357       user: {email: 'foo@example.com'}
 358     }
 359
 360     assert_response :success
 361     response_items = JSON.parse(@response.body)['items']
 362     response_object = find_obj_in_resp response_items, 'User', nil
 363     assert_not_nil response_object['uuid'], 'expected uuid for the new user'
 364     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 365
 366     # five extra links; system_group, login, group, vm, repo
 367     verify_num_links @all_links_at_start, 5
 368   end
 369
 370   test "setup user with valid email, no vm and repo as input" do
 371     authorize_with :admin
 372
 373     post :setup, {
 374       user: {email: 'foo@example.com'},
 375       openid_prefix: 'https://www.google.com/accounts/o8/id'
 376     }
 377
 378     assert_response :success
 379     response_items = JSON.parse(@response.body)['items']
 380     response_object = find_obj_in_resp response_items, 'User', nil
 381     assert_not_nil response_object['uuid'], 'expected uuid for new user'
 382     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 383
 384     # three extra links; system_group, login, and group
 385     verify_num_links @all_links_at_start, 3
 386   end
 387
 388   test "setup user with email, first name, repo name and vm uuid" do
 389     authorize_with :admin
 390
 391     post :setup, {
 392       openid_prefix: 'https://www.google.com/accounts/o8/id',
 393       repo_name: 'test_repo',
 394       vm_uuid: @vm_uuid,
 395       user: {
 396         first_name: 'test_first_name',
 397         email: 'foo@example.com'
 398       }
 399     }
 400
 401     assert_response :success
 402     response_items = JSON.parse(@response.body)['items']
 403     response_object = find_obj_in_resp response_items, 'User', nil
 404     assert_not_nil response_object['uuid'], 'expected uuid for new user'
 405     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 406     assert_equal 'test_first_name', response_object['first_name'],
 407         'expecting first name'
 408
 409     # five extra links; system_group, login, group, repo and vm
 410     verify_num_links @all_links_at_start, 5
 411   end
 412
 413   test "setup user twice with email and check two different objects created" do
 414     authorize_with :admin
 415
 416     post :setup, {
 417       openid_prefix: 'https://www.google.com/accounts/o8/id',
 418       repo_name: 'test_repo',
 419       user: {
 420         email: 'foo@example.com'
 421       }
 422     }
 423
 424     assert_response :success
 425     response_items = JSON.parse(@response.body)['items']
 426     response_object = find_obj_in_resp response_items, 'User', nil
 427     assert_not_nil response_object['uuid'], 'expected uuid for new user'
 428     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 429     # system_group, openid, group, and repo. No vm link.
 430     verify_num_links @all_links_at_start, 4
 431
 432     # create again
 433     post :setup, {
 434       user: {email: 'foo@example.com'},
 435       openid_prefix: 'https://www.google.com/accounts/o8/id'
 436     }
 437
 438     assert_response :success
 439     response_items = JSON.parse(@response.body)['items']
 440     response_object2 = find_obj_in_resp response_items, 'User', nil
 441     assert_not_equal response_object['uuid'], response_object2['uuid'],
 442         'expected same uuid as first create operation'
 443     assert_equal response_object['email'], 'foo@example.com', 'expected given email'
 444
 445     # +1 extra can_read 'all users' group link
 446     # +1 extra system_group can_manage link pointing to the new User
 447     # +1 extra can_login permission link
 448     # no repo link, no vm link
 449     verify_num_links @all_links_at_start, 7
 450   end
 451
 452   test "setup user with openid prefix" do
 453     authorize_with :admin
 454
 455     post :setup, {
 456       repo_name: 'test_repo',
 457       openid_prefix: 'http://www.example.com/account',
 458       user: {
 459         first_name: "in_create_test_first_name",
 460         last_name: "test_last_name",
 461         email: "foo@example.com"
 462       }
 463     }
 464
 465     assert_response :success
 466
 467     response_items = JSON.parse(@response.body)['items']
 468     created = find_obj_in_resp response_items, 'User', nil
 469
 470     assert_equal 'in_create_test_first_name', created['first_name']
 471     assert_not_nil created['uuid'], 'expected uuid for new user'
 472     assert_not_nil created['email'], 'expected non-nil email'
 473     assert_nil created['identity_url'], 'expected no identity_url'
 474
 475     # verify links
 476     # four new links: system_group, arvados#user, repo, and 'All users' group.
 477     verify_num_links @all_links_at_start, 4
 478
 479     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 480         created['uuid'], created['email'], 'arvados#user', false, 'User'
 481
 482     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 483         'test_repo', created['uuid'], 'arvados#repository', true, 'Repository'
 484
 485     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 486         'All users', created['uuid'], 'arvados#group', true, 'Group'
 487
 488     verify_link response_items, 'arvados#virtualMachine', false, 'permission', 'can_login',
 489         nil, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 490   end
 491
 492   test "invoke setup with no openid prefix, expect error" do
 493     authorize_with :admin
 494
 495     post :setup, {
 496       repo_name: 'test_repo',
 497       user: {
 498         first_name: "in_create_test_first_name",
 499         last_name: "test_last_name",
 500         email: "foo@example.com"
 501       }
 502     }
 503
 504     response_body = JSON.parse(@response.body)
 505     response_errors = response_body['errors']
 506     assert_not_nil response_errors, 'Expected error in response'
 507     assert (response_errors.first.include? 'openid_prefix parameter is missing'),
 508         'Expected ArgumentError'
 509   end
 510
 511   test "setup user with user, vm and repo and verify links" do
 512     authorize_with :admin
 513
 514     post :setup, {
 515       user: {
 516         first_name: "in_create_test_first_name",
 517         last_name: "test_last_name",
 518         email: "foo@example.com"
 519       },
 520       vm_uuid: @vm_uuid,
 521       repo_name: 'test_repo',
 522       openid_prefix: 'https://www.google.com/accounts/o8/id'
 523     }
 524
 525     assert_response :success
 526
 527     response_items = JSON.parse(@response.body)['items']
 528     created = find_obj_in_resp response_items, 'User', nil
 529
 530     assert_equal 'in_create_test_first_name', created['first_name']
 531     assert_not_nil created['uuid'], 'expected uuid for new user'
 532     assert_not_nil created['email'], 'expected non-nil email'
 533     assert_nil created['identity_url'], 'expected no identity_url'
 534
 535     # five new links: system_group, arvados#user, repo, vm and 'All
 536     # users' group link
 537     verify_num_links @all_links_at_start, 5
 538
 539     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 540         created['uuid'], created['email'], 'arvados#user', false, 'User'
 541
 542     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 543         'test_repo', created['uuid'], 'arvados#repository', true, 'Repository'
 544
 545     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 546         'All users', created['uuid'], 'arvados#group', true, 'Group'
 547
 548     verify_link response_items, 'arvados#virtualMachine', true, 'permission', 'can_login',
 549         @vm_uuid, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 550   end
 551
 552   test "create user as non admin user and expect error" do
 553     authorize_with :active
 554
 555     post :create, {
 556       user: {email: 'foo@example.com'}
 557     }
 558
 559     response_body = JSON.parse(@response.body)
 560     response_errors = response_body['errors']
 561     assert_not_nil response_errors, 'Expected error in response'
 562     assert (response_errors.first.include? 'PermissionDenied'),
 563           'Expected PermissionDeniedError'
 564   end
 565
 566   test "setup user as non admin user and expect error" do
 567     authorize_with :active
 568
 569     post :setup, {
 570       openid_prefix: 'https://www.google.com/accounts/o8/id',
 571       user: {email: 'foo@example.com'}
 572     }
 573
 574     response_body = JSON.parse(@response.body)
 575     response_errors = response_body['errors']
 576     assert_not_nil response_errors, 'Expected error in response'
 577     assert (response_errors.first.include? 'Forbidden'),
 578           'Expected Forbidden error'
 579   end
 580
 581   test "setup user in multiple steps and verify response" do
 582     authorize_with :admin
 583
 584     post :setup, {
 585       openid_prefix: 'http://www.example.com/account',
 586       user: {
 587         email: "foo@example.com"
 588       }
 589     }
 590
 591     assert_response :success
 592     response_items = JSON.parse(@response.body)['items']
 593     created = find_obj_in_resp response_items, 'User', nil
 594
 595     assert_not_nil created['uuid'], 'expected uuid for new user'
 596     assert_not_nil created['email'], 'expected non-nil email'
 597     assert_equal created['email'], 'foo@example.com', 'expected input email'
 598
 599     # three new links: system_group, arvados#user, and 'All users' group.
 600     verify_num_links @all_links_at_start, 3
 601
 602     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 603         created['uuid'], created['email'], 'arvados#user', false, 'User'
 604
 605     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 606         'All users', created['uuid'], 'arvados#group', true, 'Group'
 607
 608     verify_link response_items, 'arvados#repository', false, 'permission', 'can_manage',
 609         'test_repo', created['uuid'], 'arvados#repository', true, 'Repository'
 610
 611     verify_link response_items, 'arvados#virtualMachine', false, 'permission', 'can_login',
 612         nil, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 613
 614    # invoke setup with a repository
 615     post :setup, {
 616       openid_prefix: 'http://www.example.com/account',
 617       repo_name: 'new_repo',
 618       uuid: created['uuid']
 619     }
 620
 621     assert_response :success
 622
 623     response_items = JSON.parse(@response.body)['items']
 624     created = find_obj_in_resp response_items, 'User', nil
 625
 626     assert_equal 'foo@example.com', created['email'], 'expected input email'
 627
 628      # verify links
 629     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 630         'All users', created['uuid'], 'arvados#group', true, 'Group'
 631
 632     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 633         'new_repo', created['uuid'], 'arvados#repository', true, 'Repository'
 634
 635     verify_link response_items, 'arvados#virtualMachine', false, 'permission', 'can_login',
 636         nil, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 637
 638     # invoke setup with a vm_uuid
 639     post :setup, {
 640       vm_uuid: @vm_uuid,
 641       openid_prefix: 'http://www.example.com/account',
 642       user: {
 643         email: 'junk_email'
 644       },
 645       uuid: created['uuid']
 646     }
 647
 648     assert_response :success
 649
 650     response_items = JSON.parse(@response.body)['items']
 651     created = find_obj_in_resp response_items, 'User', nil
 652
 653     assert_equal created['email'], 'foo@example.com', 'expected original email'
 654
 655     # verify links
 656     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 657         'All users', created['uuid'], 'arvados#group', true, 'Group'
 658
 659     # since no repo name in input, we won't get any; even though user has one
 660     verify_link response_items, 'arvados#repository', false, 'permission', 'can_manage',
 661         'new_repo', created['uuid'], 'arvados#repository', true, 'Repository'
 662
 663     verify_link response_items, 'arvados#virtualMachine', true, 'permission', 'can_login',
 664         @vm_uuid, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 665   end
 666
 667   test "setup and unsetup user" do
 668     authorize_with :admin
 669
 670     post :setup, {
 671       repo_name: 'test_repo',
 672       vm_uuid: @vm_uuid,
 673       user: {email: 'foo@example.com'},
 674       openid_prefix: 'https://www.google.com/accounts/o8/id'
 675     }
 676
 677     assert_response :success
 678     response_items = JSON.parse(@response.body)['items']
 679     created = find_obj_in_resp response_items, 'User', nil
 680     assert_not_nil created['uuid'], 'expected uuid for the new user'
 681     assert_equal created['email'], 'foo@example.com', 'expected given email'
 682
 683     # five extra links: system_group, login, group, repo and vm
 684     verify_num_links @all_links_at_start, 5
 685
 686     verify_link response_items, 'arvados#user', true, 'permission', 'can_login',
 687         created['uuid'], created['email'], 'arvados#user', false, 'User'
 688
 689     verify_link response_items, 'arvados#group', true, 'permission', 'can_read',
 690         'All users', created['uuid'], 'arvados#group', true, 'Group'
 691
 692     verify_link response_items, 'arvados#repository', true, 'permission', 'can_manage',
 693         'test_repo', created['uuid'], 'arvados#repository', true, 'Repository'
 694
 695     verify_link response_items, 'arvados#virtualMachine', true, 'permission', 'can_login',
 696         @vm_uuid, created['uuid'], 'arvados#virtualMachine', false, 'VirtualMachine'
 697
 698     verify_link_existence created['uuid'], created['email'], true, true, true, true, false
 699
 700     # now unsetup this user
 701     post :unsetup, id: created['uuid']
 702     assert_response :success
 703
 704     created2 = JSON.parse(@response.body)
 705     assert_not_nil created2['uuid'], 'expected uuid for the newly created user'
 706     assert_equal created['uuid'], created2['uuid'], 'expected uuid not found'
 707
 708     verify_link_existence created['uuid'], created['email'], false, false, false, false, false
 709   end
 710
 711   test "unsetup active user" do
 712     authorize_with :active
 713     get :current
 714     assert_response :success
 715     active_user = JSON.parse(@response.body)
 716     assert_not_nil active_user['uuid'], 'expected uuid for the active user'
 717     assert active_user['is_active'], 'expected is_active for active user'
 718     assert active_user['is_invited'], 'expected is_invited for active user'
 719
 720     verify_link_existence active_user['uuid'], active_user['email'],
 721           false, true, false, true, true
 722
 723     authorize_with :admin
 724
 725     # now unsetup this user
 726     post :unsetup, id: active_user['uuid']
 727     assert_response :success
 728
 729     response_user = JSON.parse(@response.body)
 730     assert_not_nil response_user['uuid'], 'expected uuid for the upsetup user'
 731     assert_equal active_user['uuid'], response_user['uuid'], 'expected uuid not found'
 732     assert !response_user['is_active'], 'expected user to be inactive'
 733     assert !response_user['is_invited'], 'expected user to be uninvited'
 734
 735     verify_link_existence response_user['uuid'], response_user['email'],
 736           false, false, false, false, false
 737
 738     active_user = User.find_by_uuid(users(:active).uuid)
 739     readable_groups = active_user.groups_i_can(:read)
 740     all_users_group = Group.all.collect(&:uuid).select { |g| g.match /-f+$/ }
 741     refute_includes(readable_groups, all_users_group,
 742                     "active user can read All Users group after being deactivated")
 743     assert_equal(false, active_user.is_invited,
 744                  "active user is_invited after being deactivated & reloaded")
 745   end
 746
 747   test "setup user with send notification param false and verify no email" do
 748     authorize_with :admin
 749
 750     post :setup, {
 751       openid_prefix: 'http://www.example.com/account',
 752       send_notification_email: 'false',
 753       user: {
 754         email: "foo@example.com"
 755       }
 756     }
 757
 758     assert_response :success
 759     response_items = JSON.parse(@response.body)['items']
 760     created = find_obj_in_resp response_items, 'User', nil
 761     assert_not_nil created['uuid'], 'expected uuid for the new user'
 762     assert_equal created['email'], 'foo@example.com', 'expected given email'
 763
 764     setup_email = ActionMailer::Base.deliveries.last
 765     assert_nil setup_email, 'expected no setup email'
 766   end
 767
 768   test "setup user with send notification param true and verify email" do
 769     authorize_with :admin
 770
 771     post :setup, {
 772       openid_prefix: 'http://www.example.com/account',
 773       send_notification_email: 'true',
 774       user: {
 775         email: "foo@example.com"
 776       }
 777     }
 778
 779     assert_response :success
 780     response_items = JSON.parse(@response.body)['items']
 781     created = find_obj_in_resp response_items, 'User', nil
 782     assert_not_nil created['uuid'], 'expected uuid for the new user'
 783     assert_equal created['email'], 'foo@example.com', 'expected given email'
 784
 785     setup_email = ActionMailer::Base.deliveries.last
 786     assert_not_nil setup_email, 'Expected email after setup'
 787
 788     assert_equal Rails.configuration.user_notifier_email_from, setup_email.from[0]
 789     assert_equal 'foo@example.com', setup_email.to[0]
 790     assert_equal 'Welcome to Curoverse', setup_email.subject
 791     assert (setup_email.body.to_s.include? 'Your Arvados account has been set up'),
 792         'Expected Your Arvados account has been set up in email body'
 793     assert (setup_email.body.to_s.include? 'foo@example.com'),
 794         'Expected user email in email body'
 795     assert (setup_email.body.to_s.include? Rails.configuration.workbench_address),
 796         'Expected workbench url in email body'
 797   end
 798
 799   test "non-admin user can get basic information about readable users" do
 800     authorize_with :spectator
 801     get(:index)
 802     check_non_admin_index
 803     check_readable_users_index [:spectator], [:inactive, :active]
 804   end
 805
 806   test "non-admin user gets only safe attributes from users#show" do
 807     g = act_as_system_user do
 808       create :group
 809     end
 810     users = create_list :active_user, 2, join_groups: [g]
 811     token = create :token, user: users[0]
 812     authorize_with_token token
 813     get :show, id: users[1].uuid
 814     check_non_admin_show
 815   end
 816
 817   test "non-admin user can limit index" do
 818     g = act_as_system_user do
 819       create :group
 820     end
 821     users = create_list :active_user, 4, join_groups: [g]
 822     token = create :token, user: users[0]
 823
 824     [2, 4].each do |limit|
 825       authorize_with_token token
 826       get(:index, limit: limit)
 827       check_non_admin_index
 828       assert_equal(limit, json_response["items"].size,
 829                    "non-admin index limit was ineffective")
 830     end
 831   end
 832
 833   test "admin has full index powers" do
 834     authorize_with :admin
 835     check_inactive_user_findable
 836   end
 837
 838   test "reader token can grant admin index powers" do
 839     authorize_with :spectator
 840     check_inactive_user_findable(reader_tokens: [api_token(:admin)])
 841   end
 842
 843   test "admin can filter on user.is_active" do
 844     authorize_with :admin
 845     get(:index, filters: [["is_active", "=", "true"]])
 846     assert_response :success
 847     check_readable_users_index [:active, :spectator], [:inactive]
 848   end
 849
 850   test "admin can search where user.is_active" do
 851     authorize_with :admin
 852     get(:index, where: {is_active: true})
 853     assert_response :success
 854     check_readable_users_index [:active, :spectator], [:inactive]
 855   end
 856
 857   test "update active_no_prefs user profile and expect notification email" do
 858     authorize_with :admin
 859
 860     put :update, {
 861       id: users(:active_no_prefs).uuid,
 862       user: {
 863         prefs: {:profile => {'organization' => 'example.com'}}
 864       }
 865     }
 866     assert_response :success
 867
 868     found_email = false
 869     ActionMailer::Base.deliveries.andand.each do |email|
 870       if email.subject == "Profile created by #{users(:active_no_prefs).email}"
 871         found_email = true
 872         break
 873       end
 874     end
 875     assert_equal true, found_email, 'Expected email after creating profile'
 876   end
 877
 878   test "update active_no_prefs_profile user profile and expect notification email" do
 879     authorize_with :admin
 880
 881     user = {}
 882     user[:prefs] = users(:active_no_prefs_profile).prefs
 883     user[:prefs][:profile] = {:profile => {'organization' => 'example.com'}}
 884     put :update, {
 885       id: users(:active_no_prefs_profile).uuid,
 886       user: user
 887     }
 888     assert_response :success
 889
 890     found_email = false
 891     ActionMailer::Base.deliveries.andand.each do |email|
 892       if email.subject == "Profile created by #{users(:active_no_prefs_profile).email}"
 893         found_email = true
 894         break
 895       end
 896     end
 897     assert_equal true, found_email, 'Expected email after creating profile'
 898   end
 899
 900   test "update active user profile and expect no notification email" do
 901     authorize_with :admin
 902
 903     put :update, {
 904       id: users(:active).uuid,
 905       user: {
 906         prefs: {:profile => {'organization' => 'anotherexample.com'}}
 907       }
 908     }
 909     assert_response :success
 910
 911     found_email = false
 912     ActionMailer::Base.deliveries.andand.each do |email|
 913       if email.subject == "Profile created by #{users(:active).email}"
 914         found_email = true
 915         break
 916       end
 917     end
 918     assert_equal false, found_email, 'Expected no email after updating profile'
 919   end
 920
 921
 922   NON_ADMIN_USER_DATA = ["uuid", "kind", "is_active", "email", "first_name",
 923                          "last_name"].sort
 924
 925   def check_non_admin_index
 926     assert_response :success
 927     response_items = json_response["items"]
 928     assert_not_nil response_items
 929     response_items.each do |user_data|
 930       check_non_admin_item user_data
 931       assert(user_data["is_active"], "non-admin index returned inactive user")
 932     end
 933   end
 934
 935   def check_non_admin_show
 936     assert_response :success
 937     check_non_admin_item json_response
 938   end
 939
 940   def check_non_admin_item user_data
 941     assert_equal(NON_ADMIN_USER_DATA, user_data.keys.sort,
 942                  "data in response had missing or extra attributes")
 943     assert_equal("arvados#user", user_data["kind"])
 944   end
 945
 946
 947   def check_readable_users_index expect_present, expect_missing
 948     response_uuids = json_response["items"].map { |u| u["uuid"] }
 949     expect_present.each do |user_key|
 950       assert_includes(response_uuids, users(user_key).uuid,
 951                       "#{user_key} missing from index")
 952     end
 953     expect_missing.each do |user_key|
 954       refute_includes(response_uuids, users(user_key).uuid,
 955                       "#{user_key} included in index")
 956     end
 957   end
 958
 959   def check_inactive_user_findable(params={})
 960     inactive_user = users(:inactive)
 961     get(:index, params.merge(filters: [["email", "=", inactive_user.email]]))
 962     assert_response :success
 963     user_list = json_response["items"]
 964     assert_equal(1, user_list.andand.count)
 965     # This test needs to check a column non-admins have no access to,
 966     # to ensure that admins see all user information.
 967     assert_equal(inactive_user.identity_url, user_list.first["identity_url"],
 968                  "admin's filtered index did not return inactive user")
 969   end
 970
 971   def verify_num_links (original_links, expected_additional_links)
 972     links_now = Link.all
 973     assert_equal expected_additional_links, Link.all.size-original_links.size,
 974         "Expected #{expected_additional_links.inspect} more links"
 975   end
 976
 977   def find_obj_in_resp (response_items, object_type, head_kind=nil)
 978     return_obj = nil
 979     response_items
 980     response_items.each { |x|
 981       if !x
 982         next
 983       end
 984
 985       if object_type == 'User'
 986         if ArvadosModel::resource_class_for_uuid(x['uuid']) == User
 987           return_obj = x
 988           break
 989         end
 990       else  # looking for a link
 991         if x['head_uuid'] and ArvadosModel::resource_class_for_uuid(x['head_uuid']).kind == head_kind
 992           return_obj = x
 993           break
 994         end
 995       end
 996     }
 997     return return_obj
 998   end
 999
1000   def verify_link(response_items, link_object_name, expect_link, link_class,
1001         link_name, head_uuid, tail_uuid, head_kind, fetch_object, class_name)
1002
1003     link = find_obj_in_resp response_items, 'Link', link_object_name
1004
1005     if !expect_link
1006       assert_nil link, "Expected no link for #{link_object_name}"
1007       return
1008     end
1009
1010     assert_not_nil link, "Expected link for #{link_object_name}"
1011
1012     if fetch_object
1013       object = Object.const_get(class_name).where(name: head_uuid)
1014       assert [] != object, "expected #{class_name} with name #{head_uuid}"
1015       head_uuid = object.first[:uuid]
1016     end
1017     assert_equal link_class, link['link_class'],
1018         "did not find expected link_class for #{link_object_name}"
1019
1020     assert_equal link_name, link['name'],
1021         "did not find expected link_name for #{link_object_name}"
1022
1023     assert_equal tail_uuid, link['tail_uuid'],
1024         "did not find expected tail_uuid for #{link_object_name}"
1025
1026     assert_equal head_kind, link['head_kind'],
1027         "did not find expected head_kind for #{link_object_name}"
1028
1029     assert_equal head_uuid, link['head_uuid'],
1030         "did not find expected head_uuid for #{link_object_name}"
1031   end
1032
1033   def verify_link_existence uuid, email, expect_oid_login_perms,
1034       expect_repo_perms, expect_vm_perms, expect_group_perms, expect_signatures
1035     # verify that all links are deleted for the user
1036     oid_login_perms = Link.where(tail_uuid: email,
1037                                  link_class: 'permission',
1038                                  name: 'can_login').where("head_uuid like ?", User.uuid_like_pattern)
1039     if expect_oid_login_perms
1040       assert oid_login_perms.any?, "expected oid_login_perms"
1041     else
1042       assert !oid_login_perms.any?, "expected all oid_login_perms deleted"
1043     end
1044
1045     repo_perms = Link.where(tail_uuid: uuid,
1046                             link_class: 'permission',
1047                             name: 'can_manage').where("head_uuid like ?", Repository.uuid_like_pattern)
1048     if expect_repo_perms
1049       assert repo_perms.any?, "expected repo_perms"
1050     else
1051       assert !repo_perms.any?, "expected all repo_perms deleted"
1052     end
1053
1054     vm_login_perms = Link.
1055       where(tail_uuid: uuid,
1056             link_class: 'permission',
1057             name: 'can_login').
1058       where("head_uuid like ?",
1059             VirtualMachine.uuid_like_pattern).
1060       where('uuid <> ?',
1061             links(:auto_setup_vm_login_username_can_login_to_test_vm).uuid)
1062     if expect_vm_perms
1063       assert vm_login_perms.any?, "expected vm_login_perms"
1064     else
1065       assert !vm_login_perms.any?, "expected all vm_login_perms deleted"
1066     end
1067
1068     group = Group.where(name: 'All users').select do |g|
1069       g[:uuid].match /-f+$/
1070     end.first
1071     group_read_perms = Link.where(tail_uuid: uuid,
1072                                   head_uuid: group[:uuid],
1073                                   link_class: 'permission',
1074                                   name: 'can_read')
1075     if expect_group_perms
1076       assert group_read_perms.any?, "expected all users group read perms"
1077     else
1078       assert !group_read_perms.any?, "expected all users group perm deleted"
1079     end
1080
1081     signed_uuids = Link.where(link_class: 'signature',
1082                               tail_uuid: uuid)
1083
1084     if expect_signatures
1085       assert signed_uuids.any?, "expected signatures"
1086     else
1087       assert !signed_uuids.any?, "expected all signatures deleted"
1088     end
1089
1090   end
1091
1092   def verify_system_group_permission_link_for user_uuid
1093     assert_equal 1, Link.where(link_class: 'permission',
1094                                name: 'can_manage',
1095                                tail_uuid: system_group_uuid,
1096                                head_uuid: user_uuid).count
1097   end
1098 end