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 cannot modify administered user" do
 216     put "/arvados/v1/users/#{users(:active).uuid}", {
 217       :user => {
 218         first_name: 'KilroyWasHere'
 219       },
 220       :format => :json
 221     }, auth(:rominiadmin)
 222     assert_response 403
 223   end
 224
 225   test "read-only group-admin cannot read or update non-administered user" do
 226     get "/arvados/v1/users/#{users(:spectator).uuid}", {
 227       :format => :json
 228     }, auth(:rominiadmin)
 229     assert_response 404
 230
 231     put "/arvados/v1/users/#{users(:spectator).uuid}", {
 232       :user => {
 233         first_name: 'KilroyWasHere'
 234       },
 235       :format => :json
 236     }, auth(:rominiadmin)
 237     assert_response 404
 238   end
 239
 240   test "RO group-admin finds user's specimens, RW group-admin can update" do
 241     [[:rominiadmin, false],
 242      [:miniadmin, true]].each do |which_user, update_should_succeed|
 243       get "/arvados/v1/specimens", {:format => :json}, auth(which_user)
 244       assert_response :success
 245       resp_uuids = json_response['items'].collect { |i| i['uuid'] }
 246       [[true, specimens(:owned_by_active_user).uuid],
 247        [true, specimens(:owned_by_private_group).uuid],
 248        [false, specimens(:owned_by_spectator).uuid],
 249       ].each do |should_find, uuid|
 250         assert_equal(should_find, !resp_uuids.index(uuid).nil?,
 251                      "%s should%s see %s in specimen list" %
 252                      [which_user.to_s,
 253                       should_find ? '' : 'not ',
 254                       uuid])
 255         put "/arvados/v1/specimens/#{uuid}", {
 256           :specimen => {
 257             properties: {
 258               miniadmin_was_here: true
 259             }
 260           },
 261           :format => :json
 262         }, auth(which_user)
 263         if !should_find
 264           assert_response 404
 265         elsif !update_should_succeed
 266           assert_response 403
 267         else
 268           assert_response :success
 269         end
 270       end
 271     end
 272   end
 273
 274   test "get_permissions returns list" do
 275     # First confirm that user :active cannot get permissions on group :public
 276     get "/arvados/v1/permissions/#{groups(:public).uuid}", nil, auth(:active)
 277     assert_response 404
 278
 279     # add some permissions, including can_manage
 280     # permission for user :active
 281     post "/arvados/v1/links", {
 282       :format => :json,
 283       :link => {
 284         tail_uuid: users(:spectator).uuid,
 285         link_class: 'permission',
 286         name: 'can_read',
 287         head_uuid: groups(:public).uuid,
 288         properties: {}
 289       }
 290     }, auth(:admin)
 291     assert_response :success
 292     can_read_uuid = json_response['uuid']
 293
 294     post "/arvados/v1/links", {
 295       :format => :json,
 296       :link => {
 297         tail_uuid: users(:inactive).uuid,
 298         link_class: 'permission',
 299         name: 'can_write',
 300         head_uuid: groups(:public).uuid,
 301         properties: {}
 302       }
 303     }, auth(:admin)
 304     assert_response :success
 305     can_write_uuid = json_response['uuid']
 306
 307     post "/arvados/v1/links", {
 308       :format => :json,
 309       :link => {
 310         tail_uuid: users(:active).uuid,
 311         link_class: 'permission',
 312         name: 'can_manage',
 313         head_uuid: groups(:public).uuid,
 314         properties: {}
 315       }
 316     }, auth(:admin)
 317     assert_response :success
 318     can_manage_uuid = json_response['uuid']
 319
 320     # Now user :active should be able to retrieve permissions
 321     # on group :public.
 322     get("/arvados/v1/permissions/#{groups(:public).uuid}",
 323         { :format => :json },
 324         auth(:active))
 325     assert_response :success
 326
 327     perm_uuids = json_response['items'].map { |item| item['uuid'] }
 328     assert_includes perm_uuids, can_read_uuid, "can_read_uuid not found"
 329     assert_includes perm_uuids, can_write_uuid, "can_write_uuid not found"
 330     assert_includes perm_uuids, can_manage_uuid, "can_manage_uuid not found"
 331   end
 332
 333   test "get_permissions returns 404 for nonexistent uuid" do
 334     nonexistent = Group.generate_uuid
 335     # make sure it really doesn't exist
 336     get "/arvados/v1/groups/#{nonexistent}", nil, auth(:admin)
 337     assert_response 404
 338
 339     get "/arvados/v1/permissions/#{nonexistent}", nil, auth(:active)
 340     assert_response 404
 341   end
 342
 343   test "get_permissions returns 404 for unreadable uuid" do
 344     get "/arvados/v1/permissions/#{groups(:public).uuid}", nil, auth(:active)
 345     assert_response 404
 346   end
 347
 348   test "get_permissions returns 403 if user can read but not manage" do
 349     post "/arvados/v1/links", {
 350       :link => {
 351         tail_uuid: users(:active).uuid,
 352         link_class: 'permission',
 353         name: 'can_read',
 354         head_uuid: groups(:public).uuid,
 355         properties: {}
 356       }
 357     }, auth(:admin)
 358     assert_response :success
 359
 360     get "/arvados/v1/permissions/#{groups(:public).uuid}", nil, auth(:active)
 361     assert_response 403
 362   end
 363 end