services/api/test/integration/permissions_test.rb

   1 require 'test_helper'
   2
   3 class PermissionsTest < ActionDispatch::IntegrationTest
   4   fixtures :users, :groups, :api_client_authorizations, :collections
   5
   6   test "adding and removing direct can_read links" do
   7     # try to read collection as spectator
   8     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
   9     assert_response 404
  10
  11     # try to add permission as spectator
  12     post "/arvados/v1/links", {
  13       :format => :json,
  14       :link => {
  15         tail_uuid: users(:spectator).uuid,
  16         link_class: 'permission',
  17         name: 'can_read',
  18         head_uuid: collections(:foo_file).uuid,
  19         properties: {}
  20       }
  21     }, auth(:spectator)
  22     assert_response 422
  23
  24     # add permission as admin
  25     post "/arvados/v1/links", {
  26       :format => :json,
  27       :link => {
  28         tail_uuid: users(:spectator).uuid,
  29         link_class: 'permission',
  30         name: 'can_read',
  31         head_uuid: collections(:foo_file).uuid,
  32         properties: {}
  33       }
  34     }, auth(:admin)
  35     u = json_response['uuid']
  36     assert_response :success
  37
  38     # read collection as spectator
  39     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
  40     assert_response :success
  41
  42     # try to delete permission as spectator
  43     delete "/arvados/v1/links/#{u}", {:format => :json}, auth(:spectator)
  44     assert_response 403
  45
  46     # delete permission as admin
  47     delete "/arvados/v1/links/#{u}", {:format => :json}, auth(:admin)
  48     assert_response :success
  49
  50     # try to read collection as spectator
  51     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
  52     assert_response 404
  53   end
  54
  55
  56   test "adding can_read links from user to group, group to collection" do
  57     # try to read collection as spectator
  58     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
  59     assert_response 404
  60
  61     # add permission for spectator to read group
  62     post "/arvados/v1/links", {
  63       :format => :json,
  64       :link => {
  65         tail_uuid: users(:spectator).uuid,
  66         link_class: 'permission',
  67         name: 'can_read',
  68         head_uuid: groups(:private).uuid,
  69         properties: {}
  70       }
  71     }, auth(:admin)
  72     assert_response :success
  73
  74     # try to read collection as spectator
  75     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
  76     assert_response 404
  77
  78     # add permission for group to read collection
  79     post "/arvados/v1/links", {
  80       :format => :json,
  81       :link => {
  82         tail_uuid: groups(:private).uuid,
  83         link_class: 'permission',
  84         name: 'can_read',
  85         head_uuid: collections(:foo_file).uuid,
  86         properties: {}
  87       }
  88     }, auth(:admin)
  89     u = json_response['uuid']
  90     assert_response :success
  91
  92     # try to read collection as spectator
  93     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
  94     assert_response :success
  95
  96     # delete permission for group to read collection
  97     delete "/arvados/v1/links/#{u}", {:format => :json}, auth(:admin)
  98     assert_response :success
  99
 100     # try to read collection as spectator
 101     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
 102     assert_response 404
 103
 104   end
 105
 106
 107   test "adding can_read links from group to collection, user to group" do
 108     # try to read collection as spectator
 109     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
 110     assert_response 404
 111
 112     # add permission for group to read collection
 113     post "/arvados/v1/links", {
 114       :format => :json,
 115       :link => {
 116         tail_uuid: groups(:private).uuid,
 117         link_class: 'permission',
 118         name: 'can_read',
 119         head_uuid: collections(:foo_file).uuid,
 120         properties: {}
 121       }
 122     }, auth(:admin)
 123     assert_response :success
 124
 125     # try to read collection as spectator
 126     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
 127     assert_response 404
 128
 129     # add permission for spectator to read group
 130     post "/arvados/v1/links", {
 131       :format => :json,
 132       :link => {
 133         tail_uuid: users(:spectator).uuid,
 134         link_class: 'permission',
 135         name: 'can_read',
 136         head_uuid: groups(:private).uuid,
 137         properties: {}
 138       }
 139     }, auth(:admin)
 140     u = json_response['uuid']
 141     assert_response :success
 142
 143     # try to read collection as spectator
 144     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
 145     assert_response :success
 146
 147     # delete permission for spectator to read group
 148     delete "/arvados/v1/links/#{u}", {:format => :json}, auth(:admin)
 149     assert_response :success
 150
 151     # try to read collection as spectator
 152     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
 153     assert_response 404
 154
 155   end
 156
 157   test "adding can_read links from user to group, group to group, group to collection" do
 158     # try to read collection as spectator
 159     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
 160     assert_response 404
 161
 162     # add permission for user to read group
 163     post "/arvados/v1/links", {
 164       :format => :json,
 165       :link => {
 166         tail_uuid: users(:spectator).uuid,
 167         link_class: 'permission',
 168         name: 'can_read',
 169         head_uuid: groups(:private).uuid,
 170         properties: {}
 171       }
 172     }, auth(:admin)
 173     assert_response :success
 174
 175     # add permission for group to read group
 176     post "/arvados/v1/links", {
 177       :format => :json,
 178       :link => {
 179         tail_uuid: groups(:private).uuid,
 180         link_class: 'permission',
 181         name: 'can_read',
 182         head_uuid: groups(:empty_lonely_group).uuid,
 183         properties: {}
 184       }
 185     }, auth(:admin)
 186     assert_response :success
 187
 188     # add permission for group to read collection
 189     post "/arvados/v1/links", {
 190       :format => :json,
 191       :link => {
 192         tail_uuid: groups(:empty_lonely_group).uuid,
 193         link_class: 'permission',
 194         name: 'can_read',
 195         head_uuid: collections(:foo_file).uuid,
 196         properties: {}
 197       }
 198     }, auth(:admin)
 199     u = json_response['uuid']
 200     assert_response :success
 201
 202     # try to read collection as spectator
 203     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
 204     assert_response :success
 205
 206     # delete permission for group to read collection
 207     delete "/arvados/v1/links/#{u}", {:format => :json}, auth(:admin)
 208     assert_response :success
 209
 210     # try to read collection as spectator
 211     get "/arvados/v1/collections/#{collections(:foo_file).uuid}", {:format => :json}, auth(:spectator)
 212     assert_response 404
 213   end
 214
 215   test "read-only group-admin sees correct subset of user list" do
 216     get "/arvados/v1/users", {:format => :json}, auth(:rominiadmin)
 217     assert_response :success
 218     resp_uuids = json_response['items'].collect { |i| i['uuid'] }
 219     [[true, users(:rominiadmin).uuid],
 220      [true, users(:active).uuid],
 221      [false, users(:miniadmin).uuid],
 222      [false, users(:spectator).uuid]].each do |should_find, uuid|
 223       assert_equal should_find, !resp_uuids.index(uuid).nil?, "rominiadmin should #{'not ' if !should_find}see #{uuid} in user list"
 224     end
 225   end
 226
 227   test "read-only group-admin cannot modify administered user" do
 228     put "/arvados/v1/users/#{users(:active).uuid}", {
 229       :user => {
 230         first_name: 'KilroyWasHere'
 231       },
 232       :format => :json
 233     }, auth(:rominiadmin)
 234     assert_response 403
 235   end
 236
 237   test "read-only group-admin cannot read or update non-administered user" do
 238     get "/arvados/v1/users/#{users(:spectator).uuid}", {
 239       :format => :json
 240     }, auth(:rominiadmin)
 241     assert_response 404
 242
 243     put "/arvados/v1/users/#{users(:spectator).uuid}", {
 244       :user => {
 245         first_name: 'KilroyWasHere'
 246       },
 247       :format => :json
 248     }, auth(:rominiadmin)
 249     assert_response 404
 250   end
 251
 252   test "RO group-admin finds user's specimens, RW group-admin can update" do
 253     [[:rominiadmin, false],
 254      [:miniadmin, true]].each do |which_user, update_should_succeed|
 255       get "/arvados/v1/specimens", {:format => :json}, auth(which_user)
 256       assert_response :success
 257       resp_uuids = json_response['items'].collect { |i| i['uuid'] }
 258       [[true, specimens(:owned_by_active_user).uuid],
 259        [true, specimens(:owned_by_private_group).uuid],
 260        [false, specimens(:owned_by_spectator).uuid],
 261       ].each do |should_find, uuid|
 262         assert_equal(should_find, !resp_uuids.index(uuid).nil?,
 263                      "%s should%s see %s in specimen list" %
 264                      [which_user.to_s,
 265                       should_find ? '' : 'not ',
 266                       uuid])
 267         put "/arvados/v1/specimens/#{uuid}", {
 268           :specimen => {
 269             properties: {
 270               miniadmin_was_here: true
 271             }
 272           },
 273           :format => :json
 274         }, auth(which_user)
 275         if !should_find
 276           assert_response 404
 277         elsif !update_should_succeed
 278           assert_response 403
 279         else
 280           assert_response :success
 281         end
 282       end
 283     end
 284   end
 285
 286   test "get_permissions returns list" do
 287     # First confirm that user :active cannot get permissions on group :public
 288     get "/arvados/v1/permissions/#{groups(:public).uuid}", nil, auth(:active)
 289     assert_response 404
 290
 291     # add some permissions, including can_manage
 292     # permission for user :active
 293     post "/arvados/v1/links", {
 294       :format => :json,
 295       :link => {
 296         tail_uuid: users(:spectator).uuid,
 297         link_class: 'permission',
 298         name: 'can_read',
 299         head_uuid: groups(:public).uuid,
 300         properties: {}
 301       }
 302     }, auth(:admin)
 303     assert_response :success
 304     can_read_uuid = json_response['uuid']
 305
 306     post "/arvados/v1/links", {
 307       :format => :json,
 308       :link => {
 309         tail_uuid: users(:inactive).uuid,
 310         link_class: 'permission',
 311         name: 'can_write',
 312         head_uuid: groups(:public).uuid,
 313         properties: {}
 314       }
 315     }, auth(:admin)
 316     assert_response :success
 317     can_write_uuid = json_response['uuid']
 318
 319     post "/arvados/v1/links", {
 320       :format => :json,
 321       :link => {
 322         tail_uuid: users(:active).uuid,
 323         link_class: 'permission',
 324         name: 'can_manage',
 325         head_uuid: groups(:public).uuid,
 326         properties: {}
 327       }
 328     }, auth(:admin)
 329     assert_response :success
 330     can_manage_uuid = json_response['uuid']
 331
 332     # Now user :active should be able to retrieve permissions
 333     # on group :public.
 334     get("/arvados/v1/permissions/#{groups(:public).uuid}",
 335         { :format => :json },
 336         auth(:active))
 337     assert_response :success
 338
 339     perm_uuids = json_response['items'].map { |item| item['uuid'] }
 340     assert_includes perm_uuids, can_read_uuid, "can_read_uuid not found"
 341     assert_includes perm_uuids, can_write_uuid, "can_write_uuid not found"
 342     assert_includes perm_uuids, can_manage_uuid, "can_manage_uuid not found"
 343   end
 344
 345   test "get_permissions returns 404 for nonexistent uuid" do
 346     nonexistent = Group.generate_uuid
 347     # make sure it really doesn't exist
 348     get "/arvados/v1/groups/#{nonexistent}", nil, auth(:admin)
 349     assert_response 404
 350
 351     get "/arvados/v1/permissions/#{nonexistent}", nil, auth(:active)
 352     assert_response 404
 353   end
 354
 355   test "get_permissions returns 404 for unreadable uuid" do
 356     get "/arvados/v1/permissions/#{groups(:public).uuid}", nil, auth(:active)
 357     assert_response 404
 358   end
 359
 360   test "get_permissions returns 403 if user can read but not manage" do
 361     post "/arvados/v1/links", {
 362       :link => {
 363         tail_uuid: users(:active).uuid,
 364         link_class: 'permission',
 365         name: 'can_read',
 366         head_uuid: groups(:public).uuid,
 367         properties: {}
 368       }
 369     }, auth(:admin)
 370     assert_response :success
 371
 372     get "/arvados/v1/permissions/#{groups(:public).uuid}", nil, auth(:active)
 373     assert_response 403
 374   end
 375 end