/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_permissions.py

[merge] update from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_permissions.py
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
35
import stat
 
36
from StringIO import StringIO
36
37
 
37
38
from bzrlib.branch import Branch
38
 
from bzrlib.tests import TestCaseInTempDir, TestSkipped
 
39
from bzrlib.lockable_files import LockableFiles
 
40
from bzrlib.tests import TestCaseWithTransport, TestSkipped
39
41
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
40
 
from bzrlib.tests.test_transport import check_mode
 
42
from bzrlib.transport import get_transport
 
43
from bzrlib.workingtree import WorkingTree
41
44
 
42
45
 
43
46
def chmod_r(base, file_mode, dir_mode):
63
66
    :param include_base: If false, only check the subdirectories
64
67
    """
65
68
    assert os.path.isdir(base)
 
69
    t = get_transport(".")
66
70
    if include_base:
67
 
        check_mode(test, base, dir_mode)
 
71
        test.assertTransportMode(t, base, dir_mode)
68
72
    for root, dirs, files in os.walk(base):
69
73
        for d in dirs:
70
74
            p = os.path.join(root, d)
71
 
            check_mode(test, p, dir_mode)
 
75
            test.assertTransportMode(t, p, dir_mode)
72
76
        for f in files:
73
77
            p = os.path.join(root, f)
74
 
            check_mode(test, p, file_mode)
 
78
            test.assertTransportMode(t, p, file_mode)
75
79
 
76
80
 
77
81
def assertEqualMode(test, mode, mode_test):
79
83
                     'mode mismatch %o != %o' % (mode, mode_test))
80
84
 
81
85
 
82
 
class TestPermissions(TestCaseInTempDir):
 
86
class TestPermissions(TestCaseWithTransport):
83
87
 
84
88
    def test_new_files(self):
85
89
        if sys.platform == 'win32':
86
90
            raise TestSkipped('chmod has no effect on win32')
87
91
 
88
 
        b = Branch.initialize(u'.')
89
 
        t = b.working_tree()
 
92
        t = WorkingTree.create_standalone('.')
 
93
        b = t.branch
90
94
        open('a', 'wb').write('foo\n')
91
95
        t.add('a')
92
96
        t.commit('foo')
98
102
 
99
103
        b = Branch.open('.')
100
104
        t = b.working_tree()
101
 
        assertEqualMode(self, 0755, b._dir_mode)
102
 
        assertEqualMode(self, 0644, b._file_mode)
 
105
        assertEqualMode(self, 0755, b.control_files._dir_mode)
 
106
        assertEqualMode(self, 0644, b.control_files._file_mode)
103
107
 
104
108
        # Modifying a file shouldn't break the permissions
105
109
        open('a', 'wb').write('foo2\n')
119
123
        check_mode_r(self, '.bzr', 0664, 0775)
120
124
        b = Branch.open('.')
121
125
        t = b.working_tree()
122
 
        assertEqualMode(self, 0775, b._dir_mode)
123
 
        assertEqualMode(self, 0664, b._file_mode)
 
126
        assertEqualMode(self, 0775, b.control_files._dir_mode)
 
127
        assertEqualMode(self, 0664, b.control_files._file_mode)
124
128
 
125
129
        open('a', 'wb').write('foo3\n')
126
130
        t.commit('foo3')
138
142
        check_mode_r(self, '.bzr', 0664, 02775)
139
143
        b = Branch.open('.')
140
144
        t = b.working_tree()
141
 
        assertEqualMode(self, 02775, b._dir_mode)
142
 
        assertEqualMode(self, 0664, b._file_mode)
 
145
        assertEqualMode(self, 02775, b.control_files._dir_mode)
 
146
        assertEqualMode(self, 0664, b.control_files._file_mode)
143
147
 
144
148
        open('a', 'wb').write('foo4\n')
145
149
        t.commit('foo4')
153
157
    def test_disable_set_mode(self):
154
158
        # TODO: jam 20051215 Ultimately, this test should probably test that
155
159
        #                    extra chmod calls aren't being made
156
 
        import bzrlib.branch
157
160
        try:
158
 
            b = Branch.initialize(u'.')
159
 
            self.assertNotEqual(None, b._dir_mode)
160
 
            self.assertNotEqual(None, b._file_mode)
161
 
 
162
 
            bzrlib.branch.BzrBranch._set_dir_mode = False
163
 
            b = Branch.open(u'.')
164
 
            self.assertEqual(None, b._dir_mode)
165
 
            self.assertNotEqual(None, b._file_mode)
166
 
 
167
 
            bzrlib.branch.BzrBranch._set_file_mode = False
168
 
            b = Branch.open(u'.')
169
 
            self.assertEqual(None, b._dir_mode)
170
 
            self.assertEqual(None, b._file_mode)
171
 
 
172
 
            bzrlib.branch.BzrBranch._set_dir_mode = True
173
 
            b = Branch.open(u'.')
174
 
            self.assertNotEqual(None, b._dir_mode)
175
 
            self.assertEqual(None, b._file_mode)
176
 
 
177
 
            bzrlib.branch.BzrBranch._set_file_mode = True
178
 
            b = Branch.open(u'.')
179
 
            self.assertNotEqual(None, b._dir_mode)
180
 
            self.assertNotEqual(None, b._file_mode)
 
161
            transport = get_transport(self.get_url())
 
162
            transport.put('my-lock', StringIO(''))
 
163
            lockable = LockableFiles(transport, 'my-lock')
 
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')
 
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')
 
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')
 
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')
 
188
            self.assertNotEqual(None, lockable._dir_mode)
 
189
            self.assertNotEqual(None, lockable._file_mode)
181
190
        finally:
182
 
            bzrlib.branch.BzrBranch._set_dir_mode = True
183
 
            bzrlib.branch.BzrBranch._set_file_mode = True
 
191
            LockableFiles._set_dir_mode = True
 
192
            LockableFiles._set_file_mode = True
184
193
 
185
194
    def test_new_branch(self):
186
195
        if sys.platform == 'win32':
187
196
            raise TestSkipped('chmod has no effect on win32')
188
 
 
 
197
        #FIXME RBC 20060105 should test branch and repository 
 
198
        # permissions ? 
 
199
        # also, these are BzrBranch format specific things..
189
200
        os.mkdir('a')
190
201
        mode = stat.S_IMODE(os.stat('a').st_mode)
191
 
        b = Branch.initialize('a')
192
 
        assertEqualMode(self, mode, b._dir_mode)
193
 
        assertEqualMode(self, mode & ~07111, b._file_mode)
 
202
        t = WorkingTree.create_standalone('.')
 
203
        b = t.branch
 
204
        assertEqualMode(self, mode, b.control_files._dir_mode)
 
205
        assertEqualMode(self, mode & ~07111, b.control_files._file_mode)
194
206
 
195
207
        os.mkdir('b')
196
208
        os.chmod('b', 02777)
197
 
        b = Branch.initialize('b')
198
 
        assertEqualMode(self, 02777, b._dir_mode)
199
 
        assertEqualMode(self, 00666, b._file_mode)
 
209
        b = Branch.create('b')
 
210
        assertEqualMode(self, 02777, b.control_files._dir_mode)
 
211
        assertEqualMode(self, 00666, b.control_files._file_mode)
200
212
        check_mode_r(self, 'b/.bzr', 00666, 02777)
201
213
 
202
214
        os.mkdir('c')
203
215
        os.chmod('c', 02750)
204
 
        b = Branch.initialize('c')
205
 
        assertEqualMode(self, 02750, b._dir_mode)
206
 
        assertEqualMode(self, 00640, b._file_mode)
 
216
        b = Branch.create('c')
 
217
        assertEqualMode(self, 02750, b.control_files._dir_mode)
 
218
        assertEqualMode(self, 00640, b.control_files._file_mode)
207
219
        check_mode_r(self, 'c/.bzr', 00640, 02750)
208
220
 
209
221
        os.mkdir('d')
210
222
        os.chmod('d', 0700)
211
 
        b = Branch.initialize('d')
212
 
        assertEqualMode(self, 0700, b._dir_mode)
213
 
        assertEqualMode(self, 0600, b._file_mode)
 
223
        b = Branch.create('d')
 
224
        assertEqualMode(self, 0700, b.control_files._dir_mode)
 
225
        assertEqualMode(self, 0600, b.control_files._file_mode)
214
226
        check_mode_r(self, 'd/.bzr', 00600, 0700)
215
227
 
216
228
 
227
239
        # We don't actually use it directly, we just want to
228
240
        # keep the connection open, since StubSFTPServer only
229
241
        # allows 1 connection
230
 
        self.delayed_setup()
231
242
        _transport = SFTPTransport(self._sftp_url)
232
243
 
233
244
        os.mkdir('local')
234
 
        b_local = Branch.initialize(u'local')
235
 
        t_local = b_local.working_tree()
 
245
        t_local = WorkingTree.create_standalone('local')
 
246
        b_local = t_local.branch
236
247
        open('local/a', 'wb').write('foo\n')
237
248
        t_local.add('a')
238
249
        t_local.commit('foo')
244
255
 
245
256
        b_local = Branch.open(u'local')
246
257
        t_local = b_local.working_tree()
247
 
        assertEqualMode(self, 0755, b_local._dir_mode)
248
 
        assertEqualMode(self, 0644, b_local._file_mode)
 
258
        assertEqualMode(self, 0755, b_local.control_files._dir_mode)
 
259
        assertEqualMode(self, 0644, b_local.control_files._file_mode)
249
260
 
250
261
        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)
 
262
        sftp_url = self.get_remote_url('sftp')
 
263
        b_sftp = Branch.create(sftp_url)
254
264
 
255
265
        b_sftp.pull(b_local)
256
266
        del b_sftp
258
268
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
259
269
 
260
270
        b_sftp = Branch.open(sftp_url)
261
 
        assertEqualMode(self, 0755, b_sftp._dir_mode)
262
 
        assertEqualMode(self, 0644, b_sftp._file_mode)
 
271
        assertEqualMode(self, 0755, b_sftp.control_files._dir_mode)
 
272
        assertEqualMode(self, 0644, b_sftp.control_files._file_mode)
263
273
 
264
274
        open('local/a', 'wb').write('foo2\n')
265
275
        t_local.commit('foo2')
279
289
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
280
290
 
281
291
        b_sftp = Branch.open(sftp_url)
282
 
        assertEqualMode(self, 0775, b_sftp._dir_mode)
283
 
        assertEqualMode(self, 0664, b_sftp._file_mode)
 
292
        assertEqualMode(self, 0775, b_sftp.control_files._dir_mode)
 
293
        assertEqualMode(self, 0664, b_sftp.control_files._file_mode)
284
294
 
285
295
        open('local/a', 'wb').write('foo3\n')
286
296
        t_local.commit('foo3')
302
312
 
303
313
        try:
304
314
            from bzrlib.transport.sftp import SFTPTransport
305
 
            self.delayed_setup()
306
315
            t = SFTPTransport(self._sftp_url)
307
316
            # Direct access should be masked by umask
308
317
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
309
 
            check_mode(self, 'a', 0666 &~umask)
 
318
            self.assertTransportMode(t, 'a', 0666 &~umask)
310
319
 
311
320
            # but Transport overrides umask
312
321
            t.put('b', 'txt', mode=0666)
313
 
            check_mode(self, 'b', 0666)
 
322
            self.assertTransportMode(t, 'b', 0666)
314
323
 
315
324
            t._sftp.mkdir('c', mode=0777)
316
 
            check_mode(self, 'c', 0777 &~umask)
 
325
            self.assertTransportMode(t, 'c', 0777 &~umask)
317
326
 
318
327
            t.mkdir('d', mode=0777)
319
 
            check_mode(self, 'd', 0777)
 
328
            self.assertTransportMode(t, 'd', 0777)
320
329
        finally:
321
330
            os.umask(original_umask)
322
 
 
323