14807: Merge branch 'master'
[arvados.git] / services / api / test / functional / arvados / v1 / repositories_controller_test.rb
1 # Copyright (C) The Arvados Authors. All rights reserved.
2 #
3 # SPDX-License-Identifier: AGPL-3.0
4
5 require 'test_helper'
6
7 class Arvados::V1::RepositoriesControllerTest < ActionController::TestCase
8   test "should get_all_logins with admin token" do
9     authorize_with :admin
10     get :get_all_permissions
11     assert_response :success
12   end
13
14   test "should get_all_logins with non-admin token" do
15     authorize_with :active
16     get :get_all_permissions
17     assert_response 403
18   end
19
20   test "get_all_permissions gives RW to repository owner" do
21     authorize_with :admin
22     get :get_all_permissions
23     assert_response :success
24     ok = false
25     json_response['repositories'].each do |repo|
26       if repo['uuid'] == repositories(:repository2).uuid
27         if repo['user_permissions'][users(:active).uuid]['can_write']
28           ok = true
29         end
30       end
31     end
32     assert_equal(true, ok,
33                  "No permission on own repo '@{repositories(:repository2).uuid}'")
34   end
35
36   test "get_all_permissions takes into account is_admin flag" do
37     authorize_with :admin
38     get :get_all_permissions
39     assert_response :success
40     json_response['repositories'].each do |repo|
41       assert_not_nil(repo['user_permissions'][users(:admin).uuid],
42                      "Admin user is not listed in perms for #{repo['uuid']}")
43       assert_equal(true,
44                    repo['user_permissions'][users(:admin).uuid]['can_write'],
45                    "Admin has no perms for #{repo['uuid']}")
46     end
47   end
48
49   test "get_all_permissions takes into account is_active flag" do
50     act_as_user users(:active) do
51       Repository.create! name: 'active/testrepo'
52     end
53     act_as_system_user do
54       u = users(:active)
55       u.is_active = false
56       u.save!
57     end
58     authorize_with :admin
59     get :get_all_permissions
60     assert_response :success
61     json_response['repositories'].each do |r|
62       r['user_permissions'].each do |user_uuid, perms|
63         refute_equal user_uuid, users(:active).uuid
64       end
65     end
66   end
67
68   test "get_all_permissions does not give any access to user without permission" do
69     viewer_uuid = users(:project_viewer).uuid
70     assert_equal(authorized_keys(:project_viewer).authorized_user_uuid,
71                  viewer_uuid,
72                  "project_viewer must have an authorized_key for this test to work")
73     authorize_with :admin
74     get :get_all_permissions
75     assert_response :success
76     readable_repos = json_response["repositories"].select do |repo|
77       repo["user_permissions"].has_key?(viewer_uuid)
78     end
79     assert_equal(["arvados"], readable_repos.map { |r| r["name"] },
80                  "project_viewer should only have permissions on public repos")
81   end
82
83   test "get_all_permissions gives gitolite R to user with read-only access" do
84     authorize_with :admin
85     get :get_all_permissions
86     assert_response :success
87     found_it = false
88     assert_equal(authorized_keys(:spectator).authorized_user_uuid,
89                  users(:spectator).uuid,
90                  "spectator must have an authorized_key for this test to work")
91     json_response['repositories'].each do |repo|
92       next unless repo['uuid'] == repositories(:foo).uuid
93       assert_equal('R',
94                    repo['user_permissions'][users(:spectator).uuid]['gitolite_permissions'],
95                    "spectator user should have just R access to #{repo['uuid']}")
96       found_it = true
97     end
98     assert_equal true, found_it, "spectator user does not have R on foo repo"
99   end
100
101   test "get_all_permissions provides admin and active user keys" do
102     authorize_with :admin
103     get :get_all_permissions
104     assert_response :success
105     [:active, :admin].each do |u|
106       assert_equal(1, json_response['user_keys'][users(u).uuid].andand.count,
107                    "expected 1 key for #{u} (#{users(u).uuid})")
108       assert_equal(json_response['user_keys'][users(u).uuid][0]['public_key'],
109                    authorized_keys(u).public_key,
110                    "response public_key does not match fixture #{u}.")
111     end
112   end
113
114   test "get_all_permissions lists all repos regardless of permissions" do
115     act_as_system_user do
116       # Create repos that could potentially be left out of the
117       # permission list by accident.
118
119       # No authorized_key, no username (this can't even be done
120       # without skipping validations)
121       r = Repository.create name: 'root/testrepo'
122       assert r.save validate: false
123
124       r = Repository.create name: 'invalid username / repo name', owner_uuid: users(:inactive).uuid
125       assert r.save validate: false
126     end
127     authorize_with :admin
128     get :get_all_permissions
129     assert_response :success
130     assert_equal(Repository.count, json_response["repositories"].size)
131   end
132
133   test "get_all_permissions lists user permissions for users with no authorized keys" do
134     authorize_with :admin
135     AuthorizedKey.destroy_all
136     get :get_all_permissions
137     assert_response :success
138     assert_equal(Repository.count, json_response["repositories"].size)
139     repos_with_perms = []
140     json_response['repositories'].each do |repo|
141       if repo['user_permissions'].any?
142         repos_with_perms << repo['uuid']
143       end
144     end
145     assert_not_empty repos_with_perms, 'permissions are missing'
146   end
147
148   # Ensure get_all_permissions correctly describes what the normal
149   # permission system would do.
150   test "get_all_permissions obeys group permissions" do
151     act_as_user system_user do
152       r = Repository.create!(name: 'admin/groupcanwrite', owner_uuid: users(:admin).uuid)
153       g = Group.create!(group_class: 'group', name: 'repo-writers')
154       u1 = users(:active)
155       u2 = users(:spectator)
156       Link.create!(tail_uuid: g.uuid, head_uuid: r.uuid, link_class: 'permission', name: 'can_manage')
157       Link.create!(tail_uuid: u1.uuid, head_uuid: g.uuid, link_class: 'permission', name: 'can_write')
158       Link.create!(tail_uuid: u2.uuid, head_uuid: g.uuid, link_class: 'permission', name: 'can_read')
159
160       r = Repository.create!(name: 'admin/groupreadonly', owner_uuid: users(:admin).uuid)
161       g = Group.create!(group_class: 'group', name: 'repo-readers')
162       u1 = users(:active)
163       u2 = users(:spectator)
164       Link.create!(tail_uuid: g.uuid, head_uuid: r.uuid, link_class: 'permission', name: 'can_read')
165       Link.create!(tail_uuid: u1.uuid, head_uuid: g.uuid, link_class: 'permission', name: 'can_write')
166       Link.create!(tail_uuid: u2.uuid, head_uuid: g.uuid, link_class: 'permission', name: 'can_read')
167     end
168     authorize_with :admin
169     get :get_all_permissions
170     assert_response :success
171     json_response['repositories'].each do |repo|
172       repo['user_permissions'].each do |user_uuid, perms|
173         u = User.find_by_uuid(user_uuid)
174         if perms['can_read']
175           assert u.can? read: repo['uuid']
176           assert_match(/R/, perms['gitolite_permissions'])
177         else
178           refute_match(/R/, perms['gitolite_permissions'])
179         end
180         if perms['can_write']
181           assert u.can? write: repo['uuid']
182           assert_match(/RW\+/, perms['gitolite_permissions'])
183         else
184           refute_match(/W/, perms['gitolite_permissions'])
185         end
186         if perms['can_manage']
187           assert u.can? manage: repo['uuid']
188           assert_match(/RW\+/, perms['gitolite_permissions'])
189         end
190       end
191     end
192   end
193
194   test "default index includes fetch_url" do
195     authorize_with :active
196     get(:index)
197     assert_response :success
198     assert_includes(json_response["items"].map { |r| r["fetch_url"] },
199                     "git@git.zzzzz.arvadosapi.com:active/foo.git")
200   end
201
202   [
203     {cfg: :git_repo_ssh_base, cfgval: "git@example.com:", match: %r"^git@example.com:"},
204     {cfg: :git_repo_ssh_base, cfgval: true, match: %r"^git@git.zzzzz.arvadosapi.com:"},
205     {cfg: :git_repo_ssh_base, cfgval: false, refute: /^git@/ },
206     {cfg: :git_repo_https_base, cfgval: "https://example.com/", match: %r"^https://example.com/"},
207     {cfg: :git_repo_https_base, cfgval: true, match: %r"^https://git.zzzzz.arvadosapi.com/"},
208     {cfg: :git_repo_https_base, cfgval: false, refute: /^http/ },
209   ].each do |expect|
210     test "set #{expect[:cfg]} to #{expect[:cfgval]}" do
211       Rails.configuration.send expect[:cfg].to_s+"=", expect[:cfgval]
212       authorize_with :active
213       get :index
214       assert_response :success
215       assert_not_empty json_response['items']
216       json_response['items'].each do |r|
217         if expect[:refute]
218           r['clone_urls'].each do |u|
219             refute_match expect[:refute], u
220           end
221         else
222           assert((r['clone_urls'].any? do |u|
223                     expect[:match].match u
224                   end),
225                  "no match for #{expect[:match]} in #{r['clone_urls'].inspect}")
226         end
227       end
228     end
229   end
230
231   test "select push_url in index" do
232     authorize_with :active
233     get(:index, {select: ["uuid", "push_url"]})
234     assert_response :success
235     assert_includes(json_response["items"].map { |r| r["push_url"] },
236                     "git@git.zzzzz.arvadosapi.com:active/foo.git")
237   end
238
239   test "select clone_urls in index" do
240     authorize_with :active
241     get(:index, {select: ["uuid", "clone_urls"]})
242     assert_response :success
243     assert_includes(json_response["items"].map { |r| r["clone_urls"] }.flatten,
244                     "git@git.zzzzz.arvadosapi.com:active/foo.git")
245   end
246 end