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