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