services/api/test/functional/arvados/v1/groups_controller_test.rb

   1 require 'test_helper'
   2
   3 class Arvados::V1::GroupsControllerTest < ActionController::TestCase
   4
   5   test "attempt to delete group without read or write access" do
   6     authorize_with :active
   7     post :destroy, id: groups(:empty_lonely_group).uuid
   8     assert_response 404
   9   end
  10
  11   test "attempt to delete group without write access" do
  12     authorize_with :active
  13     post :destroy, id: groups(:all_users).uuid
  14     assert_response 403
  15   end
  16
  17   test "get list of projects" do
  18     authorize_with :active
  19     get :index, filters: [['group_class', '=', 'project']], format: :json
  20     assert_response :success
  21     group_uuids = []
  22     json_response['items'].each do |group|
  23       assert_equal 'project', group['group_class']
  24       group_uuids << group['uuid']
  25     end
  26     assert_includes group_uuids, groups(:aproject).uuid
  27     assert_includes group_uuids, groups(:asubproject).uuid
  28     assert_not_includes group_uuids, groups(:system_group).uuid
  29     assert_not_includes group_uuids, groups(:private).uuid
  30   end
  31
  32   test "get list of groups that are not projects" do
  33     authorize_with :active
  34     get :index, filters: [['group_class', '!=', 'project']], format: :json
  35     assert_response :success
  36     group_uuids = []
  37     json_response['items'].each do |group|
  38       assert_not_equal 'project', group['group_class']
  39       group_uuids << group['uuid']
  40     end
  41     assert_not_includes group_uuids, groups(:aproject).uuid
  42     assert_not_includes group_uuids, groups(:asubproject).uuid
  43     assert_includes group_uuids, groups(:private).uuid
  44   end
  45
  46   test "get list of groups with bogus group_class" do
  47     authorize_with :active
  48     get :index, {
  49       filters: [['group_class', '=', 'nogrouphasthislittleclass']],
  50       format: :json,
  51     }
  52     assert_response :success
  53     assert_equal [], json_response['items']
  54     assert_equal 0, json_response['items_available']
  55   end
  56
  57   def check_project_contents_response
  58     assert_response :success
  59     assert_operator 2, :<=, json_response['items_available']
  60     assert_operator 2, :<=, json_response['items'].count
  61     kinds = json_response['items'].collect { |i| i['kind'] }.uniq
  62     expect_kinds = %w'arvados#group arvados#specimen arvados#pipelineTemplate arvados#job'
  63     assert_equal expect_kinds, (expect_kinds & kinds)
  64
  65     json_response['items'].each do |i|
  66       if i['kind'] == 'arvados#group'
  67         assert(i['group_class'] == 'project',
  68                "group#contents returned a non-project group")
  69       end
  70     end
  71   end
  72
  73   test 'get group-owned objects' do
  74     authorize_with :active
  75     get :contents, {
  76       id: groups(:aproject).uuid,
  77       format: :json,
  78       include_linked: true,
  79     }
  80     check_project_contents_response
  81   end
  82
  83   test "user with project read permission can see project objects" do
  84     authorize_with :project_viewer
  85     get :contents, {
  86       id: groups(:aproject).uuid,
  87       format: :json,
  88       include_linked: true,
  89     }
  90     check_project_contents_response
  91   end
  92
  93   test "list objects across projects" do
  94     authorize_with :project_viewer
  95     get :contents, {
  96       format: :json,
  97       filters: [['uuid', 'is_a', 'arvados#specimen']]
  98     }
  99     assert_response :success
 100     found_uuids = json_response['items'].collect { |i| i['uuid'] }
 101     [[:in_aproject, true],
 102      [:in_asubproject, true],
 103      [:owned_by_private_group, false]].each do |specimen_fixture, should_find|
 104       if should_find
 105         assert_includes found_uuids, specimens(specimen_fixture).uuid, "did not find specimen fixture '#{specimen_fixture}'"
 106       else
 107         refute_includes found_uuids, specimens(specimen_fixture).uuid, "found specimen fixture '#{specimen_fixture}'"
 108       end
 109     end
 110   end
 111
 112   test "list objects in home project" do
 113     authorize_with :active
 114     get :contents, {
 115       format: :json,
 116       id: users(:active).uuid
 117     }
 118     assert_response :success
 119     found_uuids = json_response['items'].collect { |i| i['uuid'] }
 120     assert_includes found_uuids, specimens(:owned_by_active_user).uuid, "specimen did not appear in home project"
 121     refute_includes found_uuids, specimens(:in_asubproject).uuid, "specimen appeared unexpectedly in home project"
 122   end
 123
 124   test "user with project read permission can see project collections" do
 125     authorize_with :project_viewer
 126     get :contents, {
 127       id: groups(:asubproject).uuid,
 128       format: :json,
 129     }
 130     ids = json_response['items'].map { |item| item["uuid"] }
 131     assert_includes ids, collections(:baz_file_in_asubproject).uuid
 132   end
 133
 134   test 'list objects across multiple projects' do
 135     authorize_with :project_viewer
 136     get :contents, {
 137       format: :json,
 138       include_linked: false,
 139       filters: [['uuid', 'is_a', 'arvados#specimen']]
 140     }
 141     assert_response :success
 142     found_uuids = json_response['items'].collect { |i| i['uuid'] }
 143     [[:in_aproject, true],
 144      [:in_asubproject, true],
 145      [:owned_by_private_group, false]].each do |specimen_fixture, should_find|
 146       if should_find
 147         assert_includes found_uuids, specimens(specimen_fixture).uuid, "did not find specimen fixture '#{specimen_fixture}'"
 148       else
 149         refute_includes found_uuids, specimens(specimen_fixture).uuid, "found specimen fixture '#{specimen_fixture}'"
 150       end
 151     end
 152   end
 153
 154   # Even though the project_viewer tests go through other controllers,
 155   # I'm putting them here so they're easy to find alongside the other
 156   # project tests.
 157   def check_new_project_link_fails(link_attrs)
 158     @controller = Arvados::V1::LinksController.new
 159     post :create, link: {
 160       link_class: "permission",
 161       name: "can_read",
 162       head_uuid: groups(:aproject).uuid,
 163     }.merge(link_attrs)
 164     assert_includes(403..422, response.status)
 165   end
 166
 167   test "user with project read permission can't add users to it" do
 168     authorize_with :project_viewer
 169     check_new_project_link_fails(tail_uuid: users(:spectator).uuid)
 170   end
 171
 172   test "user with project read permission can't add items to it" do
 173     authorize_with :project_viewer
 174     check_new_project_link_fails(tail_uuid: collections(:baz_file).uuid)
 175   end
 176
 177   test "user with project read permission can't rename items in it" do
 178     authorize_with :project_viewer
 179     @controller = Arvados::V1::LinksController.new
 180     post :update, {
 181       id: jobs(:running).uuid,
 182       name: "Denied test name",
 183     }
 184     assert_includes(403..404, response.status)
 185   end
 186
 187   test "user with project read permission can't remove items from it" do
 188     @controller = Arvados::V1::PipelineTemplatesController.new
 189     authorize_with :project_viewer
 190     post :update, {
 191       id: pipeline_templates(:two_part).uuid,
 192       pipeline_template: {
 193         owner_uuid: users(:project_viewer).uuid,
 194       }
 195     }
 196     assert_response 403
 197   end
 198
 199   test "user with project read permission can't delete it" do
 200     authorize_with :project_viewer
 201     post :destroy, {id: groups(:aproject).uuid}
 202     assert_response 403
 203   end
 204
 205   test 'get group-owned objects with limit' do
 206     authorize_with :active
 207     get :contents, {
 208       id: groups(:aproject).uuid,
 209       limit: 1,
 210       format: :json,
 211     }
 212     assert_response :success
 213     assert_operator 1, :<, json_response['items_available']
 214     assert_equal 1, json_response['items'].count
 215   end
 216
 217   test 'get group-owned objects with limit and offset' do
 218     authorize_with :active
 219     get :contents, {
 220       id: groups(:aproject).uuid,
 221       limit: 1,
 222       offset: 12345,
 223       format: :json,
 224     }
 225     assert_response :success
 226     assert_operator 1, :<, json_response['items_available']
 227     assert_equal 0, json_response['items'].count
 228   end
 229
 230   test 'get group-owned objects with additional filter matching nothing' do
 231     authorize_with :active
 232     get :contents, {
 233       id: groups(:aproject).uuid,
 234       filters: [['uuid', 'in', ['foo_not_a_uuid','bar_not_a_uuid']]],
 235       format: :json,
 236     }
 237     assert_response :success
 238     assert_equal [], json_response['items']
 239     assert_equal 0, json_response['items_available']
 240   end
 241
 242   test "get all pages of group-owned objects" do
 243     authorize_with :active
 244     limit = 5
 245     offset = 0
 246     items_available = nil
 247     uuid_received = {}
 248     owner_received = {}
 249     while true
 250       # Behaving badly here, using the same controller multiple
 251       # times within a test.
 252       @json_response = nil
 253       get :contents, {
 254         id: groups(:aproject).uuid,
 255         limit: limit,
 256         offset: offset,
 257         format: :json,
 258       }
 259       assert_response :success
 260       assert_operator(0, :<, json_response['items'].count,
 261                       "items_available=#{items_available} but received 0 "\
 262                       "items with offset=#{offset}")
 263       items_available ||= json_response['items_available']
 264       assert_equal(items_available, json_response['items_available'],
 265                    "items_available changed between page #{offset/limit} "\
 266                    "and page #{1+offset/limit}")
 267       json_response['items'].each do |item|
 268         uuid = item['uuid']
 269         assert_equal(nil, uuid_received[uuid],
 270                      "Received '#{uuid}' again on page #{1+offset/limit}")
 271         uuid_received[uuid] = true
 272         owner_received[item['owner_uuid']] = true
 273         offset += 1
 274         assert_equal groups(:aproject).uuid, item['owner_uuid']
 275       end
 276       break if offset >= items_available
 277     end
 278   end
 279
 280   %w(offset limit).each do |arg|
 281     ['foo', '', '1234five', '0x10', '-8'].each do |val|
 282       test "Raise error on bogus #{arg} parameter #{val.inspect}" do
 283         authorize_with :active
 284         get :contents, {
 285           :id => groups(:aproject).uuid,
 286           :format => :json,
 287           arg => val,
 288         }
 289         assert_response 422
 290       end
 291     end
 292   end
 293
 294   test 'get writable_by list for owned group' do
 295     authorize_with :active
 296     get :show, {
 297       id: groups(:aproject).uuid,
 298       format: :json
 299     }
 300     assert_response :success
 301     assert_not_nil(json_response['writable_by'],
 302                    "Should receive uuid list in 'writable_by' field")
 303     assert_includes(json_response['writable_by'], users(:active).uuid,
 304                     "owner should be included in writable_by list")
 305   end
 306
 307   test 'no writable_by list for group with read-only access' do
 308     authorize_with :rominiadmin
 309     get :show, {
 310       id: groups(:testusergroup_admins).uuid,
 311       format: :json
 312     }
 313     assert_response :success
 314     assert_equal([json_response['owner_uuid']],
 315                  json_response['writable_by'],
 316                  "Should only see owner_uuid in 'writable_by' field")
 317   end
 318
 319   test 'get writable_by list by admin user' do
 320     authorize_with :admin
 321     get :show, {
 322       id: groups(:testusergroup_admins).uuid,
 323       format: :json
 324     }
 325     assert_response :success
 326     assert_not_nil(json_response['writable_by'],
 327                    "Should receive uuid list in 'writable_by' field")
 328     assert_includes(json_response['writable_by'],
 329                     users(:admin).uuid,
 330                     "Current user should be included in 'writable_by' field")
 331   end
 332 end