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