← 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: Martin Pool
  • Date: 2006-06-15 05:36:34 UTC
  • mto: This revision was merged to the branch mainline in revision 1797.
  • Revision ID: mbp@sourcefrog.net-20060615053634-4fd52ba691855659
Clean up many exception classes.

Errors indicating a user error are now shown with is_user_error on the
exception; use this rather than hardcoding a list of exceptions that should be
handled this way.

Exceptions now inherit from BzrNewException where possible to use consistent
formatting method.

Remove rather obsolete docstring test on Branch.missing_revisions.

Remove dead code from find_merge_base.


Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_permissions.py
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
# -*- coding: utf-8 -*-
 
3
 
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
 
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
 
 
14
# You should have received a copy of the GNU General Public License
 
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
 
17
 
 
18
 
 
19
"""Tests for bzr setting permissions.
 
20
 
 
21
Files which are created underneath .bzr/ should inherit its permissions.
 
22
So if the directory is group writable, the files and subdirs should be as well.
 
23
 
 
24
In the future, when we have Repository/Branch/Checkout information, the
 
25
permissions should be inherited individually, rather than all be the same.
 
26
"""
 
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
import os
 
34
import sys
 
35
import stat
 
36
from StringIO import StringIO
 
37
 
 
38
from bzrlib.branch import Branch
 
39
from bzrlib.bzrdir import BzrDir
 
40
from bzrlib.lockable_files import LockableFiles, TransportLock
 
41
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
42
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
 
43
from bzrlib.transport import get_transport
 
44
from bzrlib.workingtree import WorkingTree
 
45
 
 
46
 
 
47
def chmod_r(base, file_mode, dir_mode):
 
48
    """Recursively chmod from a base directory"""
 
49
    assert os.path.isdir(base)
 
50
    os.chmod(base, dir_mode)
 
51
    for root, dirs, files in os.walk(base):
 
52
        for d in dirs:
 
53
            p = os.path.join(root, d)
 
54
            os.chmod(p, dir_mode)
 
55
        for f in files:
 
56
            p = os.path.join(root, f)
 
57
            os.chmod(p, file_mode)
 
58
 
 
59
 
 
60
def check_mode_r(test, base, file_mode, dir_mode, include_base=True):
 
61
    """Check that all permissions match
 
62
 
 
63
    :param test: The TestCase being run
 
64
    :param base: The path to the root directory to check
 
65
    :param file_mode: The mode for all files
 
66
    :param dir_mode: The mode for all directories
 
67
    :param include_base: If false, only check the subdirectories
 
68
    """
 
69
    assert os.path.isdir(base)
 
70
    t = get_transport(".")
 
71
    if include_base:
 
72
        test.assertTransportMode(t, base, dir_mode)
 
73
    for root, dirs, files in os.walk(base):
 
74
        for d in dirs:
 
75
            p = os.path.join(root, d)
 
76
            test.assertTransportMode(t, p, dir_mode)
 
77
        for f in files:
 
78
            p = os.path.join(root, f)
 
79
            test.assertTransportMode(t, p, file_mode)
 
80
 
 
81
 
 
82
class TestPermissions(TestCaseWithTransport):
 
83
 
 
84
    def test_new_files(self):
 
85
        if sys.platform == 'win32':
 
86
            raise TestSkipped('chmod has no effect on win32')
 
87
 
 
88
        t = self.make_branch_and_tree('.')
 
89
        b = t.branch
 
90
        open('a', 'wb').write('foo\n')
 
91
        t.add('a')
 
92
        t.commit('foo')
 
93
 
 
94
        chmod_r('.bzr', 0644, 0755)
 
95
        check_mode_r(self, '.bzr', 0644, 0755)
 
96
 
 
97
        # although we are modifying the filesystem
 
98
        # underneath the objects, they are not locked, and thus it must
 
99
        # be safe for most operations. But here we want to observe a 
 
100
        # mode change in the control bits, which current do not refresh
 
101
        # when a new lock is taken out.
 
102
        t = WorkingTree.open('.')
 
103
        b = t.branch
 
104
        self.assertEqualMode(0755, b.control_files._dir_mode)
 
105
        self.assertEqualMode(0644, b.control_files._file_mode)
 
106
 
 
107
        # Modifying a file shouldn't break the permissions
 
108
        open('a', 'wb').write('foo2\n')
 
109
        t.commit('foo2')
 
110
        # The mode should be maintained after commit
 
111
        check_mode_r(self, '.bzr', 0644, 0755)
 
112
 
 
113
        # Adding a new file should maintain the permissions
 
114
        open('b', 'wb').write('new b\n')
 
115
        t.add('b')
 
116
        t.commit('new b')
 
117
        check_mode_r(self, '.bzr', 0644, 0755)
 
118
 
 
119
        # Recursively update the modes of all files
 
120
        chmod_r('.bzr', 0664, 0775)
 
121
        check_mode_r(self, '.bzr', 0664, 0775)
 
122
        t = WorkingTree.open('.')
 
123
        b = t.branch
 
124
        self.assertEqualMode(0775, b.control_files._dir_mode)
 
125
        self.assertEqualMode(0664, b.control_files._file_mode)
 
126
 
 
127
        open('a', 'wb').write('foo3\n')
 
128
        t.commit('foo3')
 
129
        check_mode_r(self, '.bzr', 0664, 0775)
 
130
 
 
131
        open('c', 'wb').write('new c\n')
 
132
        t.add('c')
 
133
        t.commit('new c')
 
134
        check_mode_r(self, '.bzr', 0664, 0775)
 
135
 
 
136
        # Test the group sticky bit
 
137
        # Recursively update the modes of all files
 
138
        chmod_r('.bzr', 0664, 02775)
 
139
        check_mode_r(self, '.bzr', 0664, 02775)
 
140
        t = WorkingTree.open('.')
 
141
        b = t.branch
 
142
        self.assertEqualMode(02775, b.control_files._dir_mode)
 
143
        self.assertEqualMode(0664, b.control_files._file_mode)
 
144
 
 
145
        open('a', 'wb').write('foo4\n')
 
146
        t.commit('foo4')
 
147
        check_mode_r(self, '.bzr', 0664, 02775)
 
148
 
 
149
        open('d', 'wb').write('new d\n')
 
150
        t.add('d')
 
151
        t.commit('new d')
 
152
        check_mode_r(self, '.bzr', 0664, 02775)
 
153
 
 
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
 
 
192
class TestSftpPermissions(TestCaseWithSFTPServer):
 
193
 
 
194
    def test_new_files(self):
 
195
        if sys.platform == 'win32':
 
196
            raise TestSkipped('chmod has no effect on win32')
 
197
        # Though it would be nice to test that SFTP to a server
 
198
        # which does support chmod has the right effect
 
199
 
 
200
        # bodge around for stubsftpserver not letting use connect
 
201
        # more than once
 
202
        _t = get_transport(self.get_url())
 
203
 
 
204
        os.mkdir('local')
 
205
        t_local = self.make_branch_and_tree('local')
 
206
        b_local = t_local.branch
 
207
        open('local/a', 'wb').write('foo\n')
 
208
        t_local.add('a')
 
209
        t_local.commit('foo')
 
210
 
 
211
        # Delete them because we are modifying the filesystem underneath them
 
212
        chmod_r('local/.bzr', 0644, 0755)
 
213
        check_mode_r(self, 'local/.bzr', 0644, 0755)
 
214
 
 
215
        t = WorkingTree.open('local')
 
216
        b_local = t.branch
 
217
        self.assertEqualMode(0755, b_local.control_files._dir_mode)
 
218
        self.assertEqualMode(0644, b_local.control_files._file_mode)
 
219
 
 
220
        os.mkdir('sftp')
 
221
        sftp_url = self.get_url('sftp')
 
222
        b_sftp = BzrDir.create_branch_and_repo(sftp_url)
 
223
 
 
224
        b_sftp.pull(b_local)
 
225
        del b_sftp
 
226
        chmod_r('sftp/.bzr', 0644, 0755)
 
227
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
 
228
 
 
229
        b_sftp = Branch.open(sftp_url)
 
230
        self.assertEqualMode(0755, b_sftp.control_files._dir_mode)
 
231
        self.assertEqualMode(0644, b_sftp.control_files._file_mode)
 
232
 
 
233
        open('local/a', 'wb').write('foo2\n')
 
234
        t_local.commit('foo2')
 
235
        b_sftp.pull(b_local)
 
236
        # The mode should be maintained after commit
 
237
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
 
238
 
 
239
        open('local/b', 'wb').write('new b\n')
 
240
        t_local.add('b')
 
241
        t_local.commit('new b')
 
242
        b_sftp.pull(b_local)
 
243
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
 
244
 
 
245
        del b_sftp
 
246
        # Recursively update the modes of all files
 
247
        chmod_r('sftp/.bzr', 0664, 0775)
 
248
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
 
249
 
 
250
        b_sftp = Branch.open(sftp_url)
 
251
        self.assertEqualMode(0775, b_sftp.control_files._dir_mode)
 
252
        self.assertEqualMode(0664, b_sftp.control_files._file_mode)
 
253
 
 
254
        open('local/a', 'wb').write('foo3\n')
 
255
        t_local.commit('foo3')
 
256
        b_sftp.pull(b_local)
 
257
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
 
258
 
 
259
        open('local/c', 'wb').write('new c\n')
 
260
        t_local.add('c')
 
261
        t_local.commit('new c')
 
262
        b_sftp.pull(b_local)
 
263
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
 
264
 
 
265
    def test_sftp_server_modes(self):
 
266
        if sys.platform == 'win32':
 
267
            raise TestSkipped('chmod has no effect on win32')
 
268
 
 
269
        umask = 0022
 
270
        original_umask = os.umask(umask)
 
271
 
 
272
        try:
 
273
            t = get_transport(self.get_url())
 
274
            # Direct access should be masked by umask
 
275
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
 
276
            self.assertTransportMode(t, 'a', 0666 &~umask)
 
277
 
 
278
            # but Transport overrides umask
 
279
            t.put('b', 'txt', mode=0666)
 
280
            self.assertTransportMode(t, 'b', 0666)
 
281
 
 
282
            t._sftp.mkdir('c', mode=0777)
 
283
            self.assertTransportMode(t, 'c', 0777 &~umask)
 
284
 
 
285
            t.mkdir('d', mode=0777)
 
286
            self.assertTransportMode(t, 'd', 0777)
 
287
        finally:
 
288
            os.umask(original_umask)