← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_permissions.py

[patch] Aaron Bentley: make revert work in a subdirectory.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_permissions.py
1
1
# Copyright (C) 2005 by 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
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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?
26
31
"""
27
32
 
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
35
import stat
36
 
from StringIO import StringIO
37
36
 
38
37
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
 
38
from bzrlib.tests import TestCaseInTempDir, TestSkipped
42
39
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
43
40
from bzrlib.transport import get_transport
44
 
from bzrlib.workingtree import WorkingTree
45
41
 
46
42
 
47
43
def chmod_r(base, file_mode, dir_mode):
79
75
            test.assertTransportMode(t, p, file_mode)
80
76
 
81
77
 
82
 
class TestPermissions(TestCaseWithTransport):
 
78
def assertEqualMode(test, mode, mode_test):
 
79
    test.assertEqual(mode, mode_test,
 
80
                     'mode mismatch %o != %o' % (mode, mode_test))
 
81
 
 
82
 
 
83
class TestPermissions(TestCaseInTempDir):
83
84
 
84
85
    def test_new_files(self):
85
86
        if sys.platform == 'win32':
86
87
            raise TestSkipped('chmod has no effect on win32')
87
88
 
88
 
        t = self.make_branch_and_tree('.')
89
 
        b = t.branch
 
89
        b = Branch.initialize(u'.')
 
90
        t = b.working_tree()
90
91
        open('a', 'wb').write('foo\n')
91
92
        t.add('a')
92
93
        t.commit('foo')
93
94
 
 
95
        # Delete them because we are modifying the filesystem underneath them
 
96
        del b, t 
94
97
        chmod_r('.bzr', 0644, 0755)
95
98
        check_mode_r(self, '.bzr', 0644, 0755)
96
99
 
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)
 
100
        b = Branch.open('.')
 
101
        t = b.working_tree()
 
102
        assertEqualMode(self, 0755, b._dir_mode)
 
103
        assertEqualMode(self, 0644, b._file_mode)
106
104
 
107
105
        # Modifying a file shouldn't break the permissions
108
106
        open('a', 'wb').write('foo2\n')
116
114
        t.commit('new b')
117
115
        check_mode_r(self, '.bzr', 0644, 0755)
118
116
 
 
117
        del b, t
119
118
        # Recursively update the modes of all files
120
119
        chmod_r('.bzr', 0664, 0775)
121
120
        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)
 
121
        b = Branch.open('.')
 
122
        t = b.working_tree()
 
123
        assertEqualMode(self, 0775, b._dir_mode)
 
124
        assertEqualMode(self, 0664, b._file_mode)
126
125
 
127
126
        open('a', 'wb').write('foo3\n')
128
127
        t.commit('foo3')
134
133
        check_mode_r(self, '.bzr', 0664, 0775)
135
134
 
136
135
        # Test the group sticky bit
 
136
        del b, t
137
137
        # Recursively update the modes of all files
138
138
        chmod_r('.bzr', 0664, 02775)
139
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)
 
140
        b = Branch.open('.')
 
141
        t = b.working_tree()
 
142
        assertEqualMode(self, 02775, b._dir_mode)
 
143
        assertEqualMode(self, 0664, b._file_mode)
144
144
 
145
145
        open('a', 'wb').write('foo4\n')
146
146
        t.commit('foo4')
154
154
    def test_disable_set_mode(self):
155
155
        # TODO: jam 20051215 Ultimately, this test should probably test that
156
156
        #                    extra chmod calls aren't being made
 
157
        import bzrlib.branch
157
158
        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)
 
159
            b = Branch.initialize(u'.')
 
160
            self.assertNotEqual(None, b._dir_mode)
 
161
            self.assertNotEqual(None, b._file_mode)
 
162
 
 
163
            bzrlib.branch.BzrBranch._set_dir_mode = False
 
164
            b = Branch.open(u'.')
 
165
            self.assertEqual(None, b._dir_mode)
 
166
            self.assertNotEqual(None, b._file_mode)
 
167
 
 
168
            bzrlib.branch.BzrBranch._set_file_mode = False
 
169
            b = Branch.open(u'.')
 
170
            self.assertEqual(None, b._dir_mode)
 
171
            self.assertEqual(None, b._file_mode)
 
172
 
 
173
            bzrlib.branch.BzrBranch._set_dir_mode = True
 
174
            b = Branch.open(u'.')
 
175
            self.assertNotEqual(None, b._dir_mode)
 
176
            self.assertEqual(None, b._file_mode)
 
177
 
 
178
            bzrlib.branch.BzrBranch._set_file_mode = True
 
179
            b = Branch.open(u'.')
 
180
            self.assertNotEqual(None, b._dir_mode)
 
181
            self.assertNotEqual(None, b._file_mode)
187
182
        finally:
188
 
            LockableFiles._set_dir_mode = True
189
 
            LockableFiles._set_file_mode = True
 
183
            bzrlib.branch.BzrBranch._set_dir_mode = True
 
184
            bzrlib.branch.BzrBranch._set_file_mode = True
 
185
 
 
186
    def test_new_branch(self):
 
187
        if sys.platform == 'win32':
 
188
            raise TestSkipped('chmod has no effect on win32')
 
189
 
 
190
        os.mkdir('a')
 
191
        mode = stat.S_IMODE(os.stat('a').st_mode)
 
192
        b = Branch.initialize('a')
 
193
        assertEqualMode(self, mode, b._dir_mode)
 
194
        assertEqualMode(self, mode & ~07111, b._file_mode)
 
195
 
 
196
        os.mkdir('b')
 
197
        os.chmod('b', 02777)
 
198
        b = Branch.initialize('b')
 
199
        assertEqualMode(self, 02777, b._dir_mode)
 
200
        assertEqualMode(self, 00666, b._file_mode)
 
201
        check_mode_r(self, 'b/.bzr', 00666, 02777)
 
202
 
 
203
        os.mkdir('c')
 
204
        os.chmod('c', 02750)
 
205
        b = Branch.initialize('c')
 
206
        assertEqualMode(self, 02750, b._dir_mode)
 
207
        assertEqualMode(self, 00640, b._file_mode)
 
208
        check_mode_r(self, 'c/.bzr', 00640, 02750)
 
209
 
 
210
        os.mkdir('d')
 
211
        os.chmod('d', 0700)
 
212
        b = Branch.initialize('d')
 
213
        assertEqualMode(self, 0700, b._dir_mode)
 
214
        assertEqualMode(self, 0600, b._file_mode)
 
215
        check_mode_r(self, 'd/.bzr', 00600, 0700)
190
216
 
191
217
 
192
218
class TestSftpPermissions(TestCaseWithSFTPServer):
197
223
        # Though it would be nice to test that SFTP to a server
198
224
        # which does support chmod has the right effect
199
225
 
200
 
        # bodge around for stubsftpserver not letting use connect
201
 
        # more than once
202
 
        _t = get_transport(self.get_url())
 
226
        from bzrlib.transport.sftp import SFTPTransport
 
227
 
 
228
        # We don't actually use it directly, we just want to
 
229
        # keep the connection open, since StubSFTPServer only
 
230
        # allows 1 connection
 
231
        _transport = SFTPTransport(self._sftp_url)
203
232
 
204
233
        os.mkdir('local')
205
 
        t_local = self.make_branch_and_tree('local')
206
 
        b_local = t_local.branch
 
234
        b_local = Branch.initialize(u'local')
 
235
        t_local = b_local.working_tree()
207
236
        open('local/a', 'wb').write('foo\n')
208
237
        t_local.add('a')
209
238
        t_local.commit('foo')
210
239
 
211
240
        # Delete them because we are modifying the filesystem underneath them
 
241
        del b_local, t_local 
212
242
        chmod_r('local/.bzr', 0644, 0755)
213
243
        check_mode_r(self, 'local/.bzr', 0644, 0755)
214
244
 
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)
 
245
        b_local = Branch.open(u'local')
 
246
        t_local = b_local.working_tree()
 
247
        assertEqualMode(self, 0755, b_local._dir_mode)
 
248
        assertEqualMode(self, 0644, b_local._file_mode)
219
249
 
220
250
        os.mkdir('sftp')
221
 
        sftp_url = self.get_url('sftp')
222
 
        b_sftp = BzrDir.create_branch_and_repo(sftp_url)
 
251
        sftp_url = self.get_remote_url('sftp')
 
252
        b_sftp = Branch.initialize(sftp_url)
223
253
 
224
254
        b_sftp.pull(b_local)
225
255
        del b_sftp
227
257
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
228
258
 
229
259
        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)
 
260
        assertEqualMode(self, 0755, b_sftp._dir_mode)
 
261
        assertEqualMode(self, 0644, b_sftp._file_mode)
232
262
 
233
263
        open('local/a', 'wb').write('foo2\n')
234
264
        t_local.commit('foo2')
248
278
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
249
279
 
250
280
        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)
 
281
        assertEqualMode(self, 0775, b_sftp._dir_mode)
 
282
        assertEqualMode(self, 0664, b_sftp._file_mode)
253
283
 
254
284
        open('local/a', 'wb').write('foo3\n')
255
285
        t_local.commit('foo3')
270
300
        original_umask = os.umask(umask)
271
301
 
272
302
        try:
273
 
            t = get_transport(self.get_url())
 
303
            from bzrlib.transport.sftp import SFTPTransport
 
304
            t = SFTPTransport(self._sftp_url)
274
305
            # Direct access should be masked by umask
275
306
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
276
307
            self.assertTransportMode(t, 'a', 0666 &~umask)
286
317
            self.assertTransportMode(t, 'd', 0777)
287
318
        finally:
288
319
            os.umask(original_umask)
 
320
 
 
321