Merge branch 'master' into 3634-tab-state
[arvados.git] / 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   %w(offset limit).each do |arg|
243     ['foo', '', '1234five', '0x10', '-8'].each do |val|
244       test "Raise error on bogus #{arg} parameter #{val.inspect}" do
245         authorize_with :active
246         get :contents, {
247           :id => groups(:aproject).uuid,
248           :format => :json,
249           arg => val,
250         }
251         assert_response 422
252       end
253     end
254   end
255
256   test 'get writable_by list for owned group' do
257     authorize_with :active
258     get :show, {
259       id: groups(:aproject).uuid,
260       format: :json
261     }
262     assert_response :success
263     assert_not_nil(json_response['writable_by'],
264                    "Should receive uuid list in 'writable_by' field")
265     assert_includes(json_response['writable_by'], users(:active).uuid,
266                     "owner should be included in writable_by list")
267   end
268
269   test 'no writable_by list for group with read-only access' do
270     authorize_with :rominiadmin
271     get :show, {
272       id: groups(:testusergroup_admins).uuid,
273       format: :json
274     }
275     assert_response :success
276     assert_equal([json_response['owner_uuid']],
277                  json_response['writable_by'],
278                  "Should only see owner_uuid in 'writable_by' field")
279   end
280
281   test 'get writable_by list by admin user' do
282     authorize_with :admin
283     get :show, {
284       id: groups(:testusergroup_admins).uuid,
285       format: :json
286     }
287     assert_response :success
288     assert_not_nil(json_response['writable_by'],
289                    "Should receive uuid list in 'writable_by' field")
290     assert_includes(json_response['writable_by'],
291                     users(:admin).uuid,
292                     "Current user should be included in 'writable_by' field")
293   end
294 end