services/api/test/integration/permissions_test.rb

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: AGPL-3.0
   4
   5 require 'test_helper'
   6
   7 class PermissionsTest < ActionDispatch::IntegrationTest
   8   include DbCurrentTime
   9   fixtures :users, :groups, :api_client_authorizations, :collections
  10
  11   test "adding and removing direct can_read links" do
  12     # try to read collection as spectator
  13     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
  14       params: {:format => :json},
  15       headers: auth(:spectator)
  16     assert_response 404
  17
  18     # try to add permission as spectator
  19     post "/arvados/v1/links",
  20       params: {
  21         :format => :json,
  22         :link => {
  23           tail_uuid: users(:spectator).uuid,
  24           link_class: 'permission',
  25           name: 'can_read',
  26           head_uuid: collections(:foo_file).uuid,
  27           properties: {}
  28         }
  29       },
  30       headers: auth(:spectator)
  31     assert_response 422
  32
  33     # add permission as admin
  34     post "/arvados/v1/links",
  35       params: {
  36         :format => :json,
  37         :link => {
  38           tail_uuid: users(:spectator).uuid,
  39           link_class: 'permission',
  40           name: 'can_read',
  41           head_uuid: collections(:foo_file).uuid,
  42           properties: {}
  43         }
  44       },
  45       headers: auth(:admin)
  46     u = json_response['uuid']
  47     assert_response :success
  48
  49     # read collection as spectator
  50     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
  51       params: {:format => :json},
  52       headers: auth(:spectator)
  53     assert_response :success
  54
  55     # try to delete permission as spectator
  56     delete "/arvados/v1/links/#{u}",
  57       params: {:format => :json},
  58       headers: auth(:spectator)
  59     assert_response 403
  60
  61     # delete permission as admin
  62     delete "/arvados/v1/links/#{u}",
  63       params: {:format => :json},
  64       headers: auth(:admin)
  65     assert_response :success
  66
  67     # try to read collection as spectator
  68     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
  69       params: {:format => :json},
  70       headers: auth(:spectator)
  71     assert_response 404
  72   end
  73
  74
  75   test "adding can_read links from user to group, group to collection" do
  76     # try to read collection as spectator
  77     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
  78       params: {:format => :json},
  79       headers: auth(:spectator)
  80     assert_response 404
  81
  82     # add permission for spectator to read group
  83     post "/arvados/v1/links",
  84       params: {
  85         :format => :json,
  86         :link => {
  87           tail_uuid: users(:spectator).uuid,
  88           link_class: 'permission',
  89           name: 'can_read',
  90           head_uuid: groups(:private_role).uuid,
  91           properties: {}
  92         }
  93       },
  94       headers: auth(:admin)
  95     assert_response :success
  96
  97     # try to read collection as spectator
  98     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
  99       params: {:format => :json},
 100       headers: auth(:spectator)
 101     assert_response 404
 102
 103     # add permission for group to read collection
 104     post "/arvados/v1/links",
 105       params: {
 106         :format => :json,
 107         :link => {
 108           tail_uuid: groups(:private_role).uuid,
 109           link_class: 'permission',
 110           name: 'can_read',
 111           head_uuid: collections(:foo_file).uuid,
 112           properties: {}
 113         }
 114       },
 115       headers: auth(:admin)
 116     u = json_response['uuid']
 117     assert_response :success
 118
 119     # try to read collection as spectator
 120     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 121       params: {:format => :json},
 122       headers: auth(:spectator)
 123     assert_response :success
 124
 125     # delete permission for group to read collection
 126     delete "/arvados/v1/links/#{u}",
 127       params: {:format => :json},
 128       headers: auth(:admin)
 129     assert_response :success
 130
 131     # try to read collection as spectator
 132     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 133       params: {:format => :json},
 134       headers: auth(:spectator)
 135     assert_response 404
 136
 137   end
 138
 139
 140   test "adding can_read links from group to collection, user to group" do
 141     # try to read collection as spectator
 142     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 143       params: {:format => :json},
 144       headers: auth(:spectator)
 145     assert_response 404
 146
 147     # add permission for group to read collection
 148     post "/arvados/v1/links",
 149       params: {
 150         :format => :json,
 151         :link => {
 152           tail_uuid: groups(:private_role).uuid,
 153           link_class: 'permission',
 154           name: 'can_read',
 155           head_uuid: collections(:foo_file).uuid,
 156           properties: {}
 157         }
 158       },
 159       headers: auth(:admin)
 160     assert_response :success
 161
 162     # try to read collection as spectator
 163     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 164       params: {:format => :json},
 165       headers: auth(:spectator)
 166     assert_response 404
 167
 168     # add permission for spectator to read group
 169     post "/arvados/v1/links",
 170       params: {
 171         :format => :json,
 172         :link => {
 173           tail_uuid: users(:spectator).uuid,
 174           link_class: 'permission',
 175           name: 'can_read',
 176           head_uuid: groups(:private_role).uuid,
 177           properties: {}
 178         }
 179       },
 180       headers: auth(:admin)
 181     u = json_response['uuid']
 182     assert_response :success
 183
 184     # try to read collection as spectator
 185     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 186       params: {:format => :json},
 187       headers: auth(:spectator)
 188     assert_response :success
 189
 190     # delete permission for spectator to read group
 191     delete "/arvados/v1/links/#{u}",
 192       params: {:format => :json},
 193       headers: auth(:admin)
 194     assert_response :success
 195
 196     # try to read collection as spectator
 197     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 198       params: {:format => :json},
 199       headers: auth(:spectator)
 200     assert_response 404
 201
 202   end
 203
 204   test "adding can_read links from user to group, group to group, group to collection" do
 205     # try to read collection as spectator
 206     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 207       params: {:format => :json},
 208       headers: auth(:spectator)
 209     assert_response 404
 210
 211     # add permission for user to read group
 212     post "/arvados/v1/links",
 213       params: {
 214         :format => :json,
 215         :link => {
 216           tail_uuid: users(:spectator).uuid,
 217           link_class: 'permission',
 218           name: 'can_read',
 219           head_uuid: groups(:private_role).uuid,
 220           properties: {}
 221         }
 222       },
 223       headers: auth(:admin)
 224     assert_response :success
 225
 226     # add permission for group to read group
 227     post "/arvados/v1/links",
 228       params: {
 229         :format => :json,
 230         :link => {
 231           tail_uuid: groups(:private_role).uuid,
 232           link_class: 'permission',
 233           name: 'can_read',
 234           head_uuid: groups(:empty_lonely_group).uuid,
 235           properties: {}
 236         }
 237       },
 238       headers: auth(:admin)
 239     assert_response :success
 240
 241     # add permission for group to read collection
 242     post "/arvados/v1/links",
 243       params: {
 244         :format => :json,
 245         :link => {
 246           tail_uuid: groups(:empty_lonely_group).uuid,
 247           link_class: 'permission',
 248           name: 'can_read',
 249           head_uuid: collections(:foo_file).uuid,
 250           properties: {}
 251         }
 252       },
 253       headers: auth(:admin)
 254     u = json_response['uuid']
 255     assert_response :success
 256
 257     # try to read collection as spectator
 258     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 259       params: {:format => :json},
 260       headers: auth(:spectator)
 261     assert_response :success
 262
 263     # delete permission for group to read collection
 264     delete "/arvados/v1/links/#{u}",
 265       params: {:format => :json},
 266       headers: auth(:admin)
 267     assert_response :success
 268
 269     # try to read collection as spectator
 270     get "/arvados/v1/collections/#{collections(:foo_file).uuid}",
 271       params: {:format => :json},
 272       headers: auth(:spectator)
 273     assert_response 404
 274   end
 275
 276   test "read-only group-admin cannot modify administered user" do
 277     put "/arvados/v1/users/#{users(:active).uuid}",
 278       params: {
 279         :user => {
 280           first_name: 'KilroyWasHere'
 281         },
 282         :format => :json
 283       },
 284       headers: auth(:rominiadmin)
 285     assert_response 403
 286   end
 287
 288   test "read-only group-admin cannot read or update non-administered user" do
 289     get "/arvados/v1/users/#{users(:spectator).uuid}",
 290       params: {:format => :json},
 291       headers: auth(:rominiadmin)
 292     assert_response 404
 293
 294     put "/arvados/v1/users/#{users(:spectator).uuid}",
 295       params: {
 296         :user => {
 297           first_name: 'KilroyWasHere'
 298         },
 299         :format => :json
 300       },
 301       headers: auth(:rominiadmin)
 302     assert_response 404
 303   end
 304
 305   test "RO group-admin finds user's specimens, RW group-admin can update" do
 306     [[:rominiadmin, false],
 307      [:miniadmin, true]].each do |which_user, update_should_succeed|
 308       get "/arvados/v1/specimens",
 309         params: {:format => :json},
 310         headers: auth(which_user)
 311       assert_response :success
 312       resp_uuids = json_response['items'].collect { |i| i['uuid'] }
 313       [[true, specimens(:owned_by_active_user).uuid],
 314        [true, specimens(:owned_by_private_group).uuid],
 315        [false, specimens(:owned_by_spectator).uuid],
 316       ].each do |should_find, uuid|
 317         assert_equal(should_find, !resp_uuids.index(uuid).nil?,
 318                      "%s should%s see %s in specimen list" %
 319                      [which_user.to_s,
 320                       should_find ? '' : 'not ',
 321                       uuid])
 322         put "/arvados/v1/specimens/#{uuid}",
 323           params: {
 324             :specimen => {
 325               properties: {
 326                 miniadmin_was_here: true
 327               }
 328             },
 329             :format => :json
 330           },
 331           headers: auth(which_user)
 332         if !should_find
 333           assert_response 404
 334         elsif !update_should_succeed
 335           assert_response 403
 336         else
 337           assert_response :success
 338         end
 339       end
 340     end
 341   end
 342
 343   test "get_permissions returns list" do
 344     # First confirm that user :active cannot get permissions on group :public
 345     get "/arvados/v1/permissions/#{groups(:public).uuid}",
 346       params: nil,
 347       headers: auth(:active)
 348     assert_response 404
 349
 350     get "/arvados/v1/links",
 351         params: {
 352           :filters => [["link_class", "=", "permission"], ["head_uuid", "=", groups(:public).uuid]].to_json
 353         },
 354       headers: auth(:active)
 355     assert_response :success
 356     assert_equal [], json_response['items']
 357
 358     ### add some permissions, including can_manage
 359     ### permission for user :active
 360     post "/arvados/v1/links",
 361       params: {
 362         :format => :json,
 363         :link => {
 364           tail_uuid: users(:spectator).uuid,
 365           link_class: 'permission',
 366           name: 'can_read',
 367           head_uuid: groups(:public).uuid,
 368           properties: {}
 369         }
 370       },
 371       headers: auth(:admin)
 372     assert_response :success
 373     can_read_uuid = json_response['uuid']
 374
 375     post "/arvados/v1/links",
 376       params: {
 377         :format => :json,
 378         :link => {
 379           tail_uuid: users(:inactive).uuid,
 380           link_class: 'permission',
 381           name: 'can_write',
 382           head_uuid: groups(:public).uuid,
 383           properties: {}
 384         }
 385       },
 386       headers: auth(:admin)
 387     assert_response :success
 388     can_write_uuid = json_response['uuid']
 389
 390     # Still should not be able read these permission links
 391     get "/arvados/v1/permissions/#{groups(:public).uuid}",
 392       params: nil,
 393       headers: auth(:active)
 394     assert_response 404
 395
 396     get "/arvados/v1/links",
 397         params: {
 398           :filters => [["link_class", "=", "permission"], ["head_uuid", "=", groups(:public).uuid]].to_json
 399         },
 400       headers: auth(:active)
 401     assert_response :success
 402     assert_equal [], json_response['items']
 403
 404     # Shouldn't be able to read links directly either
 405     get "/arvados/v1/links/#{can_read_uuid}",
 406         params: {},
 407       headers: auth(:active)
 408     assert_response 404
 409
 410     ### Now add a can_manage link
 411     post "/arvados/v1/links",
 412       params: {
 413         :format => :json,
 414         :link => {
 415           tail_uuid: users(:active).uuid,
 416           link_class: 'permission',
 417           name: 'can_manage',
 418           head_uuid: groups(:public).uuid,
 419           properties: {}
 420         }
 421       },
 422       headers: auth(:admin)
 423     assert_response :success
 424     can_manage_uuid = json_response['uuid']
 425
 426     # user :active should be able to retrieve permissions
 427     # on group :public using get_permissions
 428     get("/arvados/v1/permissions/#{groups(:public).uuid}",
 429       params: { :format => :json },
 430       headers: auth(:active))
 431     assert_response :success
 432
 433     perm_uuids = json_response['items'].map { |item| item['uuid'] }
 434     assert_includes perm_uuids, can_read_uuid, "can_read_uuid not found"
 435     assert_includes perm_uuids, can_write_uuid, "can_write_uuid not found"
 436     assert_includes perm_uuids, can_manage_uuid, "can_manage_uuid not found"
 437
 438     # user :active should be able to retrieve permissions
 439     # on group :public using link list
 440     get "/arvados/v1/links",
 441         params: {
 442           :filters => [["link_class", "=", "permission"], ["head_uuid", "=", groups(:public).uuid]].to_json
 443         },
 444       headers: auth(:active)
 445     assert_response :success
 446
 447     perm_uuids = json_response['items'].map { |item| item['uuid'] }
 448     assert_includes perm_uuids, can_read_uuid, "can_read_uuid not found"
 449     assert_includes perm_uuids, can_write_uuid, "can_write_uuid not found"
 450     assert_includes perm_uuids, can_manage_uuid, "can_manage_uuid not found"
 451
 452     # Should be able to read links directly too
 453     get "/arvados/v1/links/#{can_read_uuid}",
 454       headers: auth(:active)
 455     assert_response :success
 456
 457     ### Create a collection inside a subproject inside the shared
 458     ### project, and share the collection with a 3rd user
 459     ### ("spectator").
 460     post '/arvados/v1/groups',
 461          params: {
 462            group: {
 463              owner_uuid: groups(:public).uuid,
 464              name: 'permission test subproject',
 465              group_class: 'project',
 466            },
 467          },
 468          headers: auth(:admin)
 469     assert_response :success
 470     subproject_uuid = json_response['uuid']
 471
 472     post '/arvados/v1/collections',
 473          params: {
 474            collection: {
 475              owner_uuid: subproject_uuid,
 476              name: 'permission test collection in subproject',
 477            },
 478          },
 479          headers: auth(:admin)
 480     assert_response :success
 481     collection_uuid = json_response['uuid']
 482
 483     post '/arvados/v1/links',
 484          params: {
 485            link: {
 486              tail_uuid: users(:spectator).uuid,
 487              link_class: 'permission',
 488              name: 'can_read',
 489              head_uuid: collection_uuid,
 490            }
 491          },
 492          headers: auth(:admin)
 493     assert_response :success
 494     can_read_collection_uuid = json_response['uuid']
 495
 496     # The "active-can_manage-project" permission should cause the
 497     # "spectator-can_read-collection" link to be visible to the
 498     # "active" user.
 499     get "/arvados/v1/permissions/#{collection_uuid}",
 500       headers: auth(:active)
 501     assert_response :success
 502     perm_uuids = json_response['items'].map { |item| item['uuid'] }
 503     assert_includes perm_uuids, can_read_collection_uuid, "can_read_uuid not found"
 504
 505     get "/arvados/v1/links/#{can_read_collection_uuid}",
 506       headers: auth(:active)
 507     assert_response :success
 508
 509     [
 510       ['head_uuid', '=', collection_uuid],
 511       ['head_uuid', 'in', [collection_uuid]],
 512       ['head_uuid', 'in', [users(:admin).uuid, collection_uuid]],
 513     ].each do |filter|
 514       get "/arvados/v1/links",
 515           params: {
 516             filters: ([['link_class', '=', 'permission'], filter]).to_json,
 517           },
 518           headers: auth(:active)
 519       assert_response :success
 520       assert_not_empty json_response['items'], "could not find can_read link using index with filter #{filter}"
 521       assert_equal can_read_collection_uuid, json_response['items'][0]['uuid']
 522     end
 523
 524     # The "spectator-can_read-collection" link should be visible to
 525     # the subject user ("spectator") in a filter query, even without
 526     # can_manage permission on the target object.
 527     [
 528       ['tail_uuid', '=', users(:spectator).uuid],
 529     ].each do |filter|
 530       get "/arvados/v1/links",
 531           params: {
 532             filters: ([['link_class', '=', 'permission'], filter]).to_json,
 533           },
 534           headers: auth(:spectator)
 535       assert_response :success
 536       perm_uuids = json_response['items'].map { |item| item['uuid'] }
 537       assert_includes perm_uuids, can_read_collection_uuid, "could not find can_read link using index with filter #{filter}"
 538     end
 539
 540     ### Now delete the can_manage link
 541     delete "/arvados/v1/links/#{can_manage_uuid}",
 542       headers: auth(:active)
 543     assert_response :success
 544
 545     # Should not be able read these permission links again
 546     get "/arvados/v1/permissions/#{groups(:public).uuid}",
 547       headers: auth(:active)
 548     assert_response 404
 549
 550     get "/arvados/v1/permissions/#{collection_uuid}",
 551       headers: auth(:active)
 552     assert_response 404
 553
 554     get "/arvados/v1/links",
 555       params: {
 556         filters: [["link_class", "=", "permission"], ["head_uuid", "=", groups(:public).uuid]].to_json
 557       },
 558       headers: auth(:active)
 559     assert_response :success
 560     assert_equal [], json_response['items']
 561
 562     [
 563       ['head_uuid', '=', collection_uuid],
 564       ['head_uuid', 'in', [users(:admin).uuid, collection_uuid]],
 565       ['head_uuid', 'in', []],
 566     ].each do |filter|
 567       get "/arvados/v1/links",
 568           params: {
 569             :filters => [["link_class", "=", "permission"], filter].to_json
 570           },
 571           headers: auth(:active)
 572       assert_response :success
 573       assert_equal [], json_response['items']
 574     end
 575
 576     # Should not be able to read links directly either
 577     get "/arvados/v1/links/#{can_read_uuid}",
 578       params: {},
 579       headers: auth(:active)
 580     assert_response 404
 581
 582     get "/arvados/v1/links/#{can_read_collection_uuid}",
 583         headers: auth(:active)
 584     assert_response 404
 585
 586     ### Create a collection, and share it with a direct permission
 587     ### link (as opposed to sharing its parent project)
 588     post "/arvados/v1/collections",
 589       params: {
 590         collection: {
 591           name: 'permission test',
 592         }
 593       },
 594       headers: auth(:admin)
 595     assert_response :success
 596     collection_uuid = json_response['uuid']
 597     post "/arvados/v1/links",
 598       params: {
 599         link: {
 600           tail_uuid: users(:spectator).uuid,
 601           link_class: 'permission',
 602           name: 'can_read',
 603           head_uuid: collection_uuid,
 604           properties: {}
 605         }
 606       },
 607       headers: auth(:admin)
 608     assert_response :success
 609     can_read_collection_uuid = json_response['uuid']
 610
 611     # Should not be able read the permission link via permissions API,
 612     # because permission is only can_read, not can_manage
 613     get "/arvados/v1/permissions/#{collection_uuid}",
 614       headers: auth(:active)
 615     assert_response 404
 616
 617     # Should not be able to read the permission link directly, for
 618     # same reason
 619     get "/arvados/v1/links/#{can_read_collection_uuid}",
 620       headers: auth(:active)
 621     assert_response 404
 622
 623     ### Now add a can_manage link
 624     post "/arvados/v1/links",
 625       params: {
 626         link: {
 627           tail_uuid: users(:active).uuid,
 628           link_class: 'permission',
 629           name: 'can_manage',
 630           head_uuid: collection_uuid,
 631           properties: {}
 632         }
 633       },
 634       headers: auth(:admin)
 635     assert_response :success
 636     can_manage_collection_uuid = json_response['uuid']
 637
 638     # Should be able read both permission links via permissions API
 639     get "/arvados/v1/permissions/#{collection_uuid}",
 640       headers: auth(:active)
 641     assert_response :success
 642     perm_uuids = json_response['items'].map { |item| item['uuid'] }
 643     assert_includes perm_uuids, can_read_collection_uuid, "can_read_uuid not found"
 644     assert_includes perm_uuids, can_manage_collection_uuid, "can_manage_uuid not found"
 645
 646     # Should be able to read both permission links directly
 647     [can_read_collection_uuid, can_manage_collection_uuid].each do |uuid|
 648       get "/arvados/v1/links/#{uuid}",
 649         headers: auth(:active)
 650       assert_response :success
 651     end
 652   end
 653
 654   test "get_permissions returns 404 for nonexistent uuid" do
 655     nonexistent = Group.generate_uuid
 656     # make sure it really doesn't exist
 657     get "/arvados/v1/groups/#{nonexistent}", params: nil, headers: auth(:admin)
 658     assert_response 404
 659
 660     get "/arvados/v1/permissions/#{nonexistent}", params: nil, headers: auth(:active)
 661     assert_response 404
 662   end
 663
 664   test "get_permissions returns 403 if user can read but not manage" do
 665     post "/arvados/v1/links",
 666       params: {
 667         :link => {
 668           tail_uuid: users(:active).uuid,
 669           link_class: 'permission',
 670           name: 'can_read',
 671           head_uuid: groups(:public).uuid,
 672           properties: {}
 673         }
 674       },
 675       headers: auth(:admin)
 676     assert_response :success
 677
 678     get "/arvados/v1/permissions/#{groups(:public).uuid}",
 679       params: nil,
 680       headers: auth(:active)
 681     assert_response 403
 682   end
 683
 684   test "active user can read the empty collection" do
 685     # The active user should be able to read the empty collection.
 686
 687     get("/arvados/v1/collections/#{empty_collection_pdh}",
 688       params: {:format => :json},
 689       headers: auth(:active))
 690     assert_response :success
 691     assert_empty json_response['manifest_text'], "empty collection manifest_text is not empty"
 692   end
 693 end