← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_permissions.py

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_permissions.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
# -*- coding: utf-8 -*-
3
 
 
 
3
#
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
6
6
# the Free Software Foundation; either version 2 of the License, or
7
7
# (at your option) any later version.
8
 
 
 
8
#
9
9
# This program is distributed in the hope that it will be useful,
10
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
12
# GNU General Public License for more details.
13
 
 
 
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
 
18
18
 
19
19
"""Tests for bzr setting permissions.
23
23
 
24
24
In the future, when we have Repository/Branch/Checkout information, the
25
25
permissions should be inherited individually, rather than all be the same.
26
 
 
27
 
TODO: jam 20051215 There are no tests for ftp yet, because we have no ftp server
28
 
TODO: jam 20051215 Currently the default behavior for 'bzr branch' is just 
29
 
                   defined by the local umask. This isn't terrible, is it
30
 
                   the truly desired behavior?
31
26
"""
32
27
 
 
28
# TODO: jam 20051215 There are no tests for ftp yet, because we have no ftp server
 
29
# TODO: jam 20051215 Currently the default behavior for 'bzr branch' is just
 
30
#                    defined by the local umask. This isn't terrible, is it
 
31
#                    the truly desired behavior?
 
32
 
33
33
import os
34
34
import sys
35
 
import stat
36
35
 
 
36
from bzrlib import urlutils
37
37
from bzrlib.branch import Branch
38
 
from bzrlib.tests import TestCaseInTempDir, TestSkipped
 
38
from bzrlib.controldir import ControlDir
 
39
from bzrlib.tests import TestCaseWithTransport, TestSkipped
39
40
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
40
 
from bzrlib.tests.test_transport import check_mode
 
41
from bzrlib.workingtree import WorkingTree
41
42
 
42
43
 
43
44
def chmod_r(base, file_mode, dir_mode):
44
45
    """Recursively chmod from a base directory"""
45
 
    assert os.path.isdir(base)
46
46
    os.chmod(base, dir_mode)
47
47
    for root, dirs, files in os.walk(base):
48
48
        for d in dirs:
62
62
    :param dir_mode: The mode for all directories
63
63
    :param include_base: If false, only check the subdirectories
64
64
    """
65
 
    assert os.path.isdir(base)
 
65
    t = test.get_transport()
66
66
    if include_base:
67
 
        check_mode(test, base, dir_mode)
 
67
        test.assertTransportMode(t, base, dir_mode)
68
68
    for root, dirs, files in os.walk(base):
69
69
        for d in dirs:
70
 
            p = os.path.join(root, d)
71
 
            check_mode(test, p, dir_mode)
 
70
            p = '/'.join([urlutils.quote(x) for x in root.split('/\\') + [d]])
 
71
            test.assertTransportMode(t, p, dir_mode)
72
72
        for f in files:
73
73
            p = os.path.join(root, f)
74
 
            check_mode(test, p, file_mode)
75
 
 
76
 
 
77
 
def assertEqualMode(test, mode, mode_test):
78
 
    test.assertEqual(mode, mode_test,
79
 
                     'mode mismatch %o != %o' % (mode, mode_test))
80
 
 
81
 
 
82
 
class TestPermissions(TestCaseInTempDir):
 
74
            p = '/'.join([urlutils.quote(x) for x in root.split('/\\') + [f]])
 
75
            test.assertTransportMode(t, p, file_mode)
 
76
 
 
77
 
 
78
class TestPermissions(TestCaseWithTransport):
83
79
 
84
80
    def test_new_files(self):
85
81
        if sys.platform == 'win32':
86
82
            raise TestSkipped('chmod has no effect on win32')
87
83
 
88
 
        b = Branch.initialize(u'.')
89
 
        t = b.working_tree()
90
 
        open('a', 'wb').write('foo\n')
91
 
        t.add('a')
 
84
        t = self.make_branch_and_tree('.')
 
85
        b = t.branch
 
86
        with open('a', 'wb') as f: f.write('foo\n')
 
87
        # ensure check_mode_r works with capital-letter file-ids like TREE_ROOT
 
88
        t.add('a', 'CAPS-ID')
92
89
        t.commit('foo')
93
90
 
94
 
        # Delete them because we are modifying the filesystem underneath them
95
 
        del b, t 
96
91
        chmod_r('.bzr', 0644, 0755)
97
92
        check_mode_r(self, '.bzr', 0644, 0755)
98
93
 
99
 
        b = Branch.open('.')
100
 
        t = b.working_tree()
101
 
        assertEqualMode(self, 0755, b.control_files._dir_mode)
102
 
        assertEqualMode(self, 0644, b.control_files._file_mode)
 
94
        # although we are modifying the filesystem
 
95
        # underneath the objects, they are not locked, and thus it must
 
96
        # be safe for most operations. But here we want to observe a
 
97
        # mode change in the control bits, which current do not refresh
 
98
        # when a new lock is taken out.
 
99
        t = WorkingTree.open('.')
 
100
        b = t.branch
 
101
        self.assertEqualMode(0755, b.control_files._dir_mode)
 
102
        self.assertEqualMode(0644, b.control_files._file_mode)
 
103
        self.assertEqualMode(0755, b.bzrdir._get_dir_mode())
 
104
        self.assertEqualMode(0644, b.bzrdir._get_file_mode())
103
105
 
104
106
        # Modifying a file shouldn't break the permissions
105
 
        open('a', 'wb').write('foo2\n')
 
107
        with open('a', 'wb') as f: f.write('foo2\n')
106
108
        t.commit('foo2')
107
109
        # The mode should be maintained after commit
108
110
        check_mode_r(self, '.bzr', 0644, 0755)
109
111
 
110
112
        # Adding a new file should maintain the permissions
111
 
        open('b', 'wb').write('new b\n')
 
113
        with open('b', 'wb') as f: f.write('new b\n')
112
114
        t.add('b')
113
115
        t.commit('new b')
114
116
        check_mode_r(self, '.bzr', 0644, 0755)
115
117
 
116
 
        del b, t
117
118
        # Recursively update the modes of all files
118
119
        chmod_r('.bzr', 0664, 0775)
119
120
        check_mode_r(self, '.bzr', 0664, 0775)
120
 
        b = Branch.open('.')
121
 
        t = b.working_tree()
122
 
        assertEqualMode(self, 0775, b.control_files._dir_mode)
123
 
        assertEqualMode(self, 0664, b.control_files._file_mode)
 
121
        t = WorkingTree.open('.')
 
122
        b = t.branch
 
123
        self.assertEqualMode(0775, b.control_files._dir_mode)
 
124
        self.assertEqualMode(0664, b.control_files._file_mode)
 
125
        self.assertEqualMode(0775, b.bzrdir._get_dir_mode())
 
126
        self.assertEqualMode(0664, b.bzrdir._get_file_mode())
124
127
 
125
 
        open('a', 'wb').write('foo3\n')
 
128
        with open('a', 'wb') as f: f.write('foo3\n')
126
129
        t.commit('foo3')
127
130
        check_mode_r(self, '.bzr', 0664, 0775)
128
131
 
129
 
        open('c', 'wb').write('new c\n')
 
132
        with open('c', 'wb') as f: f.write('new c\n')
130
133
        t.add('c')
131
134
        t.commit('new c')
132
135
        check_mode_r(self, '.bzr', 0664, 0775)
133
136
 
 
137
    def test_new_files_group_sticky_bit(self):
 
138
        if sys.platform == 'win32':
 
139
            raise TestSkipped('chmod has no effect on win32')
 
140
        elif sys.platform == 'darwin' or 'freebsd' in sys.platform:
 
141
            # FreeBSD-based platforms create temp dirs with the 'wheel' group,
 
142
            # which users are not likely to be in, and this prevents us from
 
143
            # setting the sgid bit
 
144
            os.chown(self.test_dir, os.getuid(), os.getgid())
 
145
 
 
146
        t = self.make_branch_and_tree('.')
 
147
        b = t.branch
 
148
 
134
149
        # Test the group sticky bit
135
 
        del b, t
136
150
        # Recursively update the modes of all files
137
151
        chmod_r('.bzr', 0664, 02775)
138
152
        check_mode_r(self, '.bzr', 0664, 02775)
139
 
        b = Branch.open('.')
140
 
        t = b.working_tree()
141
 
        assertEqualMode(self, 02775, b.control_files._dir_mode)
142
 
        assertEqualMode(self, 0664, b.control_files._file_mode)
 
153
        t = WorkingTree.open('.')
 
154
        b = t.branch
 
155
        self.assertEqualMode(02775, b.control_files._dir_mode)
 
156
        self.assertEqualMode(0664, b.control_files._file_mode)
 
157
        self.assertEqualMode(02775, b.bzrdir._get_dir_mode())
 
158
        self.assertEqualMode(0664, b.bzrdir._get_file_mode())
143
159
 
144
 
        open('a', 'wb').write('foo4\n')
 
160
        with open('a', 'wb') as f: f.write('foo4\n')
145
161
        t.commit('foo4')
146
162
        check_mode_r(self, '.bzr', 0664, 02775)
147
163
 
148
 
        open('d', 'wb').write('new d\n')
 
164
        with open('d', 'wb') as f: f.write('new d\n')
149
165
        t.add('d')
150
166
        t.commit('new d')
151
167
        check_mode_r(self, '.bzr', 0664, 02775)
152
168
 
153
 
    def test_disable_set_mode(self):
154
 
        # TODO: jam 20051215 Ultimately, this test should probably test that
155
 
        #                    extra chmod calls aren't being made
156
 
        import bzrlib.lockable_files
157
 
        try:
158
 
            b = Branch.initialize(u'.')
159
 
            self.assertNotEqual(None, b.control_files._dir_mode)
160
 
            self.assertNotEqual(None, b.control_files._file_mode)
161
 
 
162
 
            bzrlib.lockable_files.LockableFiles._set_dir_mode = False
163
 
            b = Branch.open(u'.')
164
 
            self.assertEqual(None, b.control_files._dir_mode)
165
 
            self.assertNotEqual(None, b.control_files._file_mode)
166
 
 
167
 
            bzrlib.lockable_files.LockableFiles._set_file_mode = False
168
 
            b = Branch.open(u'.')
169
 
            self.assertEqual(None, b.control_files._dir_mode)
170
 
            self.assertEqual(None, b.control_files._file_mode)
171
 
 
172
 
            bzrlib.lockable_files.LockableFiles._set_dir_mode = True
173
 
            b = Branch.open(u'.')
174
 
            self.assertNotEqual(None, b.control_files._dir_mode)
175
 
            self.assertEqual(None, b.control_files._file_mode)
176
 
 
177
 
            bzrlib.lockable_files.LockableFiles._set_file_mode = True
178
 
            b = Branch.open(u'.')
179
 
            self.assertNotEqual(None, b.control_files._dir_mode)
180
 
            self.assertNotEqual(None, b.control_files._file_mode)
181
 
        finally:
182
 
            bzrlib.lockable_files.LockableFiles._set_dir_mode = True
183
 
            bzrlib.lockable_files.LockableFiles._set_file_mode = True
184
 
 
185
 
    def test_new_branch(self):
186
 
        if sys.platform == 'win32':
187
 
            raise TestSkipped('chmod has no effect on win32')
188
 
 
189
 
        os.mkdir('a')
190
 
        mode = stat.S_IMODE(os.stat('a').st_mode)
191
 
        b = Branch.initialize('a')
192
 
        assertEqualMode(self, mode, b.control_files._dir_mode)
193
 
        assertEqualMode(self, mode & ~07111, b.control_files._file_mode)
194
 
 
195
 
        os.mkdir('b')
196
 
        os.chmod('b', 02777)
197
 
        b = Branch.initialize('b')
198
 
        assertEqualMode(self, 02777, b.control_files._dir_mode)
199
 
        assertEqualMode(self, 00666, b.control_files._file_mode)
200
 
        check_mode_r(self, 'b/.bzr', 00666, 02777)
201
 
 
202
 
        os.mkdir('c')
203
 
        os.chmod('c', 02750)
204
 
        b = Branch.initialize('c')
205
 
        assertEqualMode(self, 02750, b.control_files._dir_mode)
206
 
        assertEqualMode(self, 00640, b.control_files._file_mode)
207
 
        check_mode_r(self, 'c/.bzr', 00640, 02750)
208
 
 
209
 
        os.mkdir('d')
210
 
        os.chmod('d', 0700)
211
 
        b = Branch.initialize('d')
212
 
        assertEqualMode(self, 0700, b.control_files._dir_mode)
213
 
        assertEqualMode(self, 0600, b.control_files._file_mode)
214
 
        check_mode_r(self, 'd/.bzr', 00600, 0700)
215
 
 
216
169
 
217
170
class TestSftpPermissions(TestCaseWithSFTPServer):
218
171
 
222
175
        # Though it would be nice to test that SFTP to a server
223
176
        # which does support chmod has the right effect
224
177
 
225
 
        from bzrlib.transport.sftp import SFTPTransport
226
 
 
227
 
        # We don't actually use it directly, we just want to
228
 
        # keep the connection open, since StubSFTPServer only
229
 
        # allows 1 connection
230
 
        self.delayed_setup()
231
 
        _transport = SFTPTransport(self._sftp_url)
 
178
        # bodge around for stubsftpserver not letting use connect
 
179
        # more than once
 
180
        _t = self.get_transport()
232
181
 
233
182
        os.mkdir('local')
234
 
        b_local = Branch.initialize(u'local')
235
 
        t_local = b_local.working_tree()
236
 
        open('local/a', 'wb').write('foo\n')
 
183
        t_local = self.make_branch_and_tree('local')
 
184
        b_local = t_local.branch
 
185
        with open('local/a', 'wb') as f: f.write('foo\n')
237
186
        t_local.add('a')
238
187
        t_local.commit('foo')
239
188
 
240
189
        # Delete them because we are modifying the filesystem underneath them
241
 
        del b_local, t_local 
242
190
        chmod_r('local/.bzr', 0644, 0755)
243
191
        check_mode_r(self, 'local/.bzr', 0644, 0755)
244
192
 
245
 
        b_local = Branch.open(u'local')
246
 
        t_local = b_local.working_tree()
247
 
        assertEqualMode(self, 0755, b_local.control_files._dir_mode)
248
 
        assertEqualMode(self, 0644, b_local.control_files._file_mode)
 
193
        t = WorkingTree.open('local')
 
194
        b_local = t.branch
 
195
        self.assertEqualMode(0755, b_local.control_files._dir_mode)
 
196
        self.assertEqualMode(0644, b_local.control_files._file_mode)
 
197
        self.assertEqualMode(0755, b_local.bzrdir._get_dir_mode())
 
198
        self.assertEqualMode(0644, b_local.bzrdir._get_file_mode())
249
199
 
250
200
        os.mkdir('sftp')
251
 
        # Why does self._sftp_url end with a slash????
252
 
        sftp_url = self._sftp_url + 'sftp'
253
 
        b_sftp = Branch.initialize(sftp_url)
 
201
        sftp_url = self.get_url('sftp')
 
202
        b_sftp = ControlDir.create_branch_and_repo(sftp_url)
254
203
 
255
204
        b_sftp.pull(b_local)
256
205
        del b_sftp
258
207
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
259
208
 
260
209
        b_sftp = Branch.open(sftp_url)
261
 
        assertEqualMode(self, 0755, b_sftp.control_files._dir_mode)
262
 
        assertEqualMode(self, 0644, b_sftp.control_files._file_mode)
 
210
        self.assertEqualMode(0755, b_sftp.control_files._dir_mode)
 
211
        self.assertEqualMode(0644, b_sftp.control_files._file_mode)
 
212
        self.assertEqualMode(0755, b_sftp.bzrdir._get_dir_mode())
 
213
        self.assertEqualMode(0644, b_sftp.bzrdir._get_file_mode())
263
214
 
264
 
        open('local/a', 'wb').write('foo2\n')
 
215
        with open('local/a', 'wb') as f: f.write('foo2\n')
265
216
        t_local.commit('foo2')
266
217
        b_sftp.pull(b_local)
267
218
        # The mode should be maintained after commit
268
219
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
269
220
 
270
 
        open('local/b', 'wb').write('new b\n')
 
221
        with open('local/b', 'wb') as f: f.write('new b\n')
271
222
        t_local.add('b')
272
223
        t_local.commit('new b')
273
224
        b_sftp.pull(b_local)
279
230
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
280
231
 
281
232
        b_sftp = Branch.open(sftp_url)
282
 
        assertEqualMode(self, 0775, b_sftp.control_files._dir_mode)
283
 
        assertEqualMode(self, 0664, b_sftp.control_files._file_mode)
 
233
        self.assertEqualMode(0775, b_sftp.control_files._dir_mode)
 
234
        self.assertEqualMode(0664, b_sftp.control_files._file_mode)
 
235
        self.assertEqualMode(0775, b_sftp.bzrdir._get_dir_mode())
 
236
        self.assertEqualMode(0664, b_sftp.bzrdir._get_file_mode())
284
237
 
285
 
        open('local/a', 'wb').write('foo3\n')
 
238
        with open('local/a', 'wb') as f: f.write('foo3\n')
286
239
        t_local.commit('foo3')
287
240
        b_sftp.pull(b_local)
288
241
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
289
242
 
290
 
        open('local/c', 'wb').write('new c\n')
 
243
        with open('local/c', 'wb') as f: f.write('new c\n')
291
244
        t_local.add('c')
292
245
        t_local.commit('new c')
293
246
        b_sftp.pull(b_local)
301
254
        original_umask = os.umask(umask)
302
255
 
303
256
        try:
304
 
            from bzrlib.transport.sftp import SFTPTransport
305
 
            self.delayed_setup()
306
 
            t = SFTPTransport(self._sftp_url)
 
257
            t = self.get_transport()
307
258
            # Direct access should be masked by umask
308
259
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
309
 
            check_mode(self, 'a', 0666 &~umask)
 
260
            self.assertTransportMode(t, 'a', 0666 &~umask)
310
261
 
311
262
            # but Transport overrides umask
312
 
            t.put('b', 'txt', mode=0666)
313
 
            check_mode(self, 'b', 0666)
 
263
            t.put_bytes('b', 'txt', mode=0666)
 
264
            self.assertTransportMode(t, 'b', 0666)
314
265
 
315
 
            t._sftp.mkdir('c', mode=0777)
316
 
            check_mode(self, 'c', 0777 &~umask)
 
266
            t._get_sftp().mkdir('c', mode=0777)
 
267
            self.assertTransportMode(t, 'c', 0777 &~umask)
317
268
 
318
269
            t.mkdir('d', mode=0777)
319
 
            check_mode(self, 'd', 0777)
 
270
            self.assertTransportMode(t, 'd', 0777)
320
271
        finally:
321
272
            os.umask(original_umask)
322
 
 
323