← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_permissions.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-05-04 12:10:51 UTC
  • mfrom: (5819.1.4 777007-developer-doc)
  • Revision ID: pqm@pqm.ubuntu.com-20110504121051-aovlsmqiivjmc4fc
(jelmer) Small fixes to developer documentation. (Jonathan Riddell)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_permissions.py
1
 
# Copyright (C) 2005 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
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.
26
26
"""
27
27
 
28
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 
 
29
# TODO: jam 20051215 Currently the default behavior for 'bzr branch' is just
30
30
#                    defined by the local umask. This isn't terrible, is it
31
31
#                    the truly desired behavior?
32
 
 
 
32
 
33
33
import os
34
34
import sys
35
 
import stat
36
 
from cStringIO import StringIO
37
35
import urllib
38
36
 
 
37
from bzrlib import transport
39
38
from bzrlib.branch import Branch
40
39
from bzrlib.bzrdir import BzrDir
41
 
from bzrlib.lockable_files import LockableFiles, TransportLock
42
40
from bzrlib.tests import TestCaseWithTransport, TestSkipped
43
41
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
44
 
from bzrlib.transport import get_transport
45
42
from bzrlib.workingtree import WorkingTree
46
43
 
47
44
 
48
45
def chmod_r(base, file_mode, dir_mode):
49
46
    """Recursively chmod from a base directory"""
50
 
    assert os.path.isdir(base)
51
47
    os.chmod(base, dir_mode)
52
48
    for root, dirs, files in os.walk(base):
53
49
        for d in dirs:
67
63
    :param dir_mode: The mode for all directories
68
64
    :param include_base: If false, only check the subdirectories
69
65
    """
70
 
    assert os.path.isdir(base)
71
 
    t = get_transport(".")
 
66
    t = test.get_transport()
72
67
    if include_base:
73
68
        test.assertTransportMode(t, base, dir_mode)
74
69
    for root, dirs, files in os.walk(base):
99
94
 
100
95
        # although we are modifying the filesystem
101
96
        # underneath the objects, they are not locked, and thus it must
102
 
        # be safe for most operations. But here we want to observe a 
 
97
        # be safe for most operations. But here we want to observe a
103
98
        # mode change in the control bits, which current do not refresh
104
99
        # when a new lock is taken out.
105
100
        t = WorkingTree.open('.')
106
101
        b = t.branch
107
102
        self.assertEqualMode(0755, b.control_files._dir_mode)
108
103
        self.assertEqualMode(0644, b.control_files._file_mode)
 
104
        self.assertEqualMode(0755, b.bzrdir._get_dir_mode())
 
105
        self.assertEqualMode(0644, b.bzrdir._get_file_mode())
109
106
 
110
107
        # Modifying a file shouldn't break the permissions
111
108
        open('a', 'wb').write('foo2\n')
126
123
        b = t.branch
127
124
        self.assertEqualMode(0775, b.control_files._dir_mode)
128
125
        self.assertEqualMode(0664, b.control_files._file_mode)
 
126
        self.assertEqualMode(0775, b.bzrdir._get_dir_mode())
 
127
        self.assertEqualMode(0664, b.bzrdir._get_file_mode())
129
128
 
130
129
        open('a', 'wb').write('foo3\n')
131
130
        t.commit('foo3')
136
135
        t.commit('new c')
137
136
        check_mode_r(self, '.bzr', 0664, 0775)
138
137
 
 
138
    def test_new_files_group_sticky_bit(self):
 
139
        if sys.platform == 'win32':
 
140
            raise TestSkipped('chmod has no effect on win32')
 
141
        elif sys.platform == 'darwin' or 'freebsd' in sys.platform:
 
142
            # FreeBSD-based platforms create temp dirs with the 'wheel' group,
 
143
            # which users are not likely to be in, and this prevents us from
 
144
            # setting the sgid bit
 
145
            os.chown(self.test_dir, os.getuid(), os.getgid())
 
146
 
 
147
        t = self.make_branch_and_tree('.')
 
148
        b = t.branch
 
149
 
139
150
        # Test the group sticky bit
140
151
        # Recursively update the modes of all files
141
152
        chmod_r('.bzr', 0664, 02775)
144
155
        b = t.branch
145
156
        self.assertEqualMode(02775, b.control_files._dir_mode)
146
157
        self.assertEqualMode(0664, b.control_files._file_mode)
 
158
        self.assertEqualMode(02775, b.bzrdir._get_dir_mode())
 
159
        self.assertEqualMode(0664, b.bzrdir._get_file_mode())
147
160
 
148
161
        open('a', 'wb').write('foo4\n')
149
162
        t.commit('foo4')
154
167
        t.commit('new d')
155
168
        check_mode_r(self, '.bzr', 0664, 02775)
156
169
 
157
 
    def test_disable_set_mode(self):
158
 
        # TODO: jam 20051215 Ultimately, this test should probably test that
159
 
        #                    extra chmod calls aren't being made
160
 
        try:
161
 
            transport = get_transport(self.get_url())
162
 
            transport.put_bytes('my-lock', '')
163
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
164
 
            self.assertNotEqual(None, lockable._dir_mode)
165
 
            self.assertNotEqual(None, lockable._file_mode)
166
 
 
167
 
            LockableFiles._set_dir_mode = False
168
 
            transport = get_transport('.')
169
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
170
 
            self.assertEqual(None, lockable._dir_mode)
171
 
            self.assertNotEqual(None, lockable._file_mode)
172
 
 
173
 
            LockableFiles._set_file_mode = False
174
 
            transport = get_transport('.')
175
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
176
 
            self.assertEqual(None, lockable._dir_mode)
177
 
            self.assertEqual(None, lockable._file_mode)
178
 
 
179
 
            LockableFiles._set_dir_mode = True
180
 
            transport = get_transport('.')
181
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
182
 
            self.assertNotEqual(None, lockable._dir_mode)
183
 
            self.assertEqual(None, lockable._file_mode)
184
 
 
185
 
            LockableFiles._set_file_mode = True
186
 
            transport = get_transport('.')
187
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
188
 
            self.assertNotEqual(None, lockable._dir_mode)
189
 
            self.assertNotEqual(None, lockable._file_mode)
190
 
        finally:
191
 
            LockableFiles._set_dir_mode = True
192
 
            LockableFiles._set_file_mode = True
193
 
 
194
170
 
195
171
class TestSftpPermissions(TestCaseWithSFTPServer):
196
172
 
202
178
 
203
179
        # bodge around for stubsftpserver not letting use connect
204
180
        # more than once
205
 
        _t = get_transport(self.get_url())
 
181
        _t = self.get_transport()
206
182
 
207
183
        os.mkdir('local')
208
184
        t_local = self.make_branch_and_tree('local')
219
195
        b_local = t.branch
220
196
        self.assertEqualMode(0755, b_local.control_files._dir_mode)
221
197
        self.assertEqualMode(0644, b_local.control_files._file_mode)
 
198
        self.assertEqualMode(0755, b_local.bzrdir._get_dir_mode())
 
199
        self.assertEqualMode(0644, b_local.bzrdir._get_file_mode())
222
200
 
223
201
        os.mkdir('sftp')
224
202
        sftp_url = self.get_url('sftp')
232
210
        b_sftp = Branch.open(sftp_url)
233
211
        self.assertEqualMode(0755, b_sftp.control_files._dir_mode)
234
212
        self.assertEqualMode(0644, b_sftp.control_files._file_mode)
 
213
        self.assertEqualMode(0755, b_sftp.bzrdir._get_dir_mode())
 
214
        self.assertEqualMode(0644, b_sftp.bzrdir._get_file_mode())
235
215
 
236
216
        open('local/a', 'wb').write('foo2\n')
237
217
        t_local.commit('foo2')
253
233
        b_sftp = Branch.open(sftp_url)
254
234
        self.assertEqualMode(0775, b_sftp.control_files._dir_mode)
255
235
        self.assertEqualMode(0664, b_sftp.control_files._file_mode)
 
236
        self.assertEqualMode(0775, b_sftp.bzrdir._get_dir_mode())
 
237
        self.assertEqualMode(0664, b_sftp.bzrdir._get_file_mode())
256
238
 
257
239
        open('local/a', 'wb').write('foo3\n')
258
240
        t_local.commit('foo3')
273
255
        original_umask = os.umask(umask)
274
256
 
275
257
        try:
276
 
            t = get_transport(self.get_url())
 
258
            t = self.get_transport()
277
259
            # Direct access should be masked by umask
278
260
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
279
261
            self.assertTransportMode(t, 'a', 0666 &~umask)
282
264
            t.put_bytes('b', 'txt', mode=0666)
283
265
            self.assertTransportMode(t, 'b', 0666)
284
266
 
285
 
            t._sftp.mkdir('c', mode=0777)
 
267
            t._get_sftp().mkdir('c', mode=0777)
286
268
            self.assertTransportMode(t, 'c', 0777 &~umask)
287
269
 
288
270
            t.mkdir('d', mode=0777)