← 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: Patch Queue Manager
  • Date: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

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.
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 StringIO import StringIO
 
35
import urllib
37
36
 
 
37
from bzrlib import transport
38
38
from bzrlib.branch import Branch
39
39
from bzrlib.bzrdir import BzrDir
40
 
from bzrlib.lockable_files import LockableFiles, TransportLock
41
40
from bzrlib.tests import TestCaseWithTransport, TestSkipped
42
41
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
43
 
from bzrlib.transport import get_transport
44
42
from bzrlib.workingtree import WorkingTree
45
43
 
46
44
 
47
45
def chmod_r(base, file_mode, dir_mode):
48
46
    """Recursively chmod from a base directory"""
49
 
    assert os.path.isdir(base)
50
47
    os.chmod(base, dir_mode)
51
48
    for root, dirs, files in os.walk(base):
52
49
        for d in dirs:
66
63
    :param dir_mode: The mode for all directories
67
64
    :param include_base: If false, only check the subdirectories
68
65
    """
69
 
    assert os.path.isdir(base)
70
 
    t = get_transport(".")
 
66
    t = test.get_transport()
71
67
    if include_base:
72
68
        test.assertTransportMode(t, base, dir_mode)
73
69
    for root, dirs, files in os.walk(base):
74
70
        for d in dirs:
75
 
            p = os.path.join(root, d)
 
71
            p = '/'.join([urllib.quote(x) for x in root.split('/\\') + [d]])
76
72
            test.assertTransportMode(t, p, dir_mode)
77
73
        for f in files:
78
74
            p = os.path.join(root, f)
 
75
            p = '/'.join([urllib.quote(x) for x in root.split('/\\') + [f]])
79
76
            test.assertTransportMode(t, p, file_mode)
80
77
 
81
78
 
88
85
        t = self.make_branch_and_tree('.')
89
86
        b = t.branch
90
87
        open('a', 'wb').write('foo\n')
91
 
        t.add('a')
 
88
        # ensure check_mode_r works with capital-letter file-ids like TREE_ROOT
 
89
        t.add('a', 'CAPS-ID')
92
90
        t.commit('foo')
93
91
 
94
92
        chmod_r('.bzr', 0644, 0755)
96
94
 
97
95
        # although we are modifying the filesystem
98
96
        # underneath the objects, they are not locked, and thus it must
99
 
        # 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
100
98
        # mode change in the control bits, which current do not refresh
101
99
        # when a new lock is taken out.
102
100
        t = WorkingTree.open('.')
103
101
        b = t.branch
104
102
        self.assertEqualMode(0755, b.control_files._dir_mode)
105
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())
106
106
 
107
107
        # Modifying a file shouldn't break the permissions
108
108
        open('a', 'wb').write('foo2\n')
123
123
        b = t.branch
124
124
        self.assertEqualMode(0775, b.control_files._dir_mode)
125
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())
126
128
 
127
129
        open('a', 'wb').write('foo3\n')
128
130
        t.commit('foo3')
133
135
        t.commit('new c')
134
136
        check_mode_r(self, '.bzr', 0664, 0775)
135
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
 
136
150
        # Test the group sticky bit
137
151
        # Recursively update the modes of all files
138
152
        chmod_r('.bzr', 0664, 02775)
141
155
        b = t.branch
142
156
        self.assertEqualMode(02775, b.control_files._dir_mode)
143
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())
144
160
 
145
161
        open('a', 'wb').write('foo4\n')
146
162
        t.commit('foo4')
151
167
        t.commit('new d')
152
168
        check_mode_r(self, '.bzr', 0664, 02775)
153
169
 
154
 
    def test_disable_set_mode(self):
155
 
        # TODO: jam 20051215 Ultimately, this test should probably test that
156
 
        #                    extra chmod calls aren't being made
157
 
        try:
158
 
            transport = get_transport(self.get_url())
159
 
            transport.put('my-lock', StringIO(''))
160
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
161
 
            self.assertNotEqual(None, lockable._dir_mode)
162
 
            self.assertNotEqual(None, lockable._file_mode)
163
 
 
164
 
            LockableFiles._set_dir_mode = False
165
 
            transport = get_transport('.')
166
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
167
 
            self.assertEqual(None, lockable._dir_mode)
168
 
            self.assertNotEqual(None, lockable._file_mode)
169
 
 
170
 
            LockableFiles._set_file_mode = False
171
 
            transport = get_transport('.')
172
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
173
 
            self.assertEqual(None, lockable._dir_mode)
174
 
            self.assertEqual(None, lockable._file_mode)
175
 
 
176
 
            LockableFiles._set_dir_mode = True
177
 
            transport = get_transport('.')
178
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
179
 
            self.assertNotEqual(None, lockable._dir_mode)
180
 
            self.assertEqual(None, lockable._file_mode)
181
 
 
182
 
            LockableFiles._set_file_mode = True
183
 
            transport = get_transport('.')
184
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
185
 
            self.assertNotEqual(None, lockable._dir_mode)
186
 
            self.assertNotEqual(None, lockable._file_mode)
187
 
        finally:
188
 
            LockableFiles._set_dir_mode = True
189
 
            LockableFiles._set_file_mode = True
190
 
 
191
170
 
192
171
class TestSftpPermissions(TestCaseWithSFTPServer):
193
172
 
199
178
 
200
179
        # bodge around for stubsftpserver not letting use connect
201
180
        # more than once
202
 
        _t = get_transport(self.get_url())
 
181
        _t = self.get_transport()
203
182
 
204
183
        os.mkdir('local')
205
184
        t_local = self.make_branch_and_tree('local')
216
195
        b_local = t.branch
217
196
        self.assertEqualMode(0755, b_local.control_files._dir_mode)
218
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())
219
200
 
220
201
        os.mkdir('sftp')
221
202
        sftp_url = self.get_url('sftp')
229
210
        b_sftp = Branch.open(sftp_url)
230
211
        self.assertEqualMode(0755, b_sftp.control_files._dir_mode)
231
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())
232
215
 
233
216
        open('local/a', 'wb').write('foo2\n')
234
217
        t_local.commit('foo2')
250
233
        b_sftp = Branch.open(sftp_url)
251
234
        self.assertEqualMode(0775, b_sftp.control_files._dir_mode)
252
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())
253
238
 
254
239
        open('local/a', 'wb').write('foo3\n')
255
240
        t_local.commit('foo3')
270
255
        original_umask = os.umask(umask)
271
256
 
272
257
        try:
273
 
            t = get_transport(self.get_url())
 
258
            t = self.get_transport()
274
259
            # Direct access should be masked by umask
275
260
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
276
261
            self.assertTransportMode(t, 'a', 0666 &~umask)
277
262
 
278
263
            # but Transport overrides umask
279
 
            t.put('b', 'txt', mode=0666)
 
264
            t.put_bytes('b', 'txt', mode=0666)
280
265
            self.assertTransportMode(t, 'b', 0666)
281
266
 
282
 
            t._sftp.mkdir('c', mode=0777)
 
267
            t._get_sftp().mkdir('c', mode=0777)
283
268
            self.assertTransportMode(t, 'c', 0777 &~umask)
284
269
 
285
270
            t.mkdir('d', mode=0777)