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