← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_permissions.py

first cut at merge from integration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_permissions.py
36
36
from StringIO import StringIO
37
37
 
38
38
from bzrlib.branch import Branch
39
 
from bzrlib.bzrdir import BzrDir
40
 
from bzrlib.lockable_files import LockableFiles, TransportLock
 
39
from bzrlib.lockable_files import LockableFiles
41
40
from bzrlib.tests import TestCaseWithTransport, TestSkipped
42
41
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
43
42
from bzrlib.transport import get_transport
79
78
            test.assertTransportMode(t, p, file_mode)
80
79
 
81
80
 
 
81
def assertEqualMode(test, mode, mode_test):
 
82
    test.assertEqual(mode, mode_test,
 
83
                     'mode mismatch %o != %o' % (mode, mode_test))
 
84
 
 
85
 
82
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
 
        t = self.make_branch_and_tree('.')
 
92
        t = WorkingTree.create_standalone('.')
89
93
        b = t.branch
90
94
        open('a', 'wb').write('foo\n')
91
95
        t.add('a')
92
96
        t.commit('foo')
93
97
 
 
98
        # Delete them because we are modifying the filesystem underneath them
 
99
        del b, t 
94
100
        chmod_r('.bzr', 0644, 0755)
95
101
        check_mode_r(self, '.bzr', 0644, 0755)
96
102
 
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)
 
103
        b = Branch.open('.')
 
104
        t = b.working_tree()
 
105
        assertEqualMode(self, 0755, b.control_files._dir_mode)
 
106
        assertEqualMode(self, 0644, b.control_files._file_mode)
106
107
 
107
108
        # Modifying a file shouldn't break the permissions
108
109
        open('a', 'wb').write('foo2\n')
116
117
        t.commit('new b')
117
118
        check_mode_r(self, '.bzr', 0644, 0755)
118
119
 
 
120
        del b, t
119
121
        # Recursively update the modes of all files
120
122
        chmod_r('.bzr', 0664, 0775)
121
123
        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)
 
124
        b = Branch.open('.')
 
125
        t = b.working_tree()
 
126
        assertEqualMode(self, 0775, b.control_files._dir_mode)
 
127
        assertEqualMode(self, 0664, b.control_files._file_mode)
126
128
 
127
129
        open('a', 'wb').write('foo3\n')
128
130
        t.commit('foo3')
134
136
        check_mode_r(self, '.bzr', 0664, 0775)
135
137
 
136
138
        # Test the group sticky bit
 
139
        del b, t
137
140
        # Recursively update the modes of all files
138
141
        chmod_r('.bzr', 0664, 02775)
139
142
        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)
 
143
        b = Branch.open('.')
 
144
        t = b.working_tree()
 
145
        assertEqualMode(self, 02775, b.control_files._dir_mode)
 
146
        assertEqualMode(self, 0664, b.control_files._file_mode)
144
147
 
145
148
        open('a', 'wb').write('foo4\n')
146
149
        t.commit('foo4')
157
160
        try:
158
161
            transport = get_transport(self.get_url())
159
162
            transport.put('my-lock', StringIO(''))
160
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
 
163
            lockable = LockableFiles(transport, 'my-lock')
161
164
            self.assertNotEqual(None, lockable._dir_mode)
162
165
            self.assertNotEqual(None, lockable._file_mode)
163
166
 
164
167
            LockableFiles._set_dir_mode = False
165
168
            transport = get_transport('.')
166
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
 
169
            lockable = LockableFiles(transport, 'my-lock')
167
170
            self.assertEqual(None, lockable._dir_mode)
168
171
            self.assertNotEqual(None, lockable._file_mode)
169
172
 
170
173
            LockableFiles._set_file_mode = False
171
174
            transport = get_transport('.')
172
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
 
175
            lockable = LockableFiles(transport, 'my-lock')
173
176
            self.assertEqual(None, lockable._dir_mode)
174
177
            self.assertEqual(None, lockable._file_mode)
175
178
 
176
179
            LockableFiles._set_dir_mode = True
177
180
            transport = get_transport('.')
178
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
 
181
            lockable = LockableFiles(transport, 'my-lock')
179
182
            self.assertNotEqual(None, lockable._dir_mode)
180
183
            self.assertEqual(None, lockable._file_mode)
181
184
 
182
185
            LockableFiles._set_file_mode = True
183
186
            transport = get_transport('.')
184
 
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
 
187
            lockable = LockableFiles(transport, 'my-lock')
185
188
            self.assertNotEqual(None, lockable._dir_mode)
186
189
            self.assertNotEqual(None, lockable._file_mode)
187
190
        finally:
188
191
            LockableFiles._set_dir_mode = True
189
192
            LockableFiles._set_file_mode = True
190
193
 
 
194
    def test_new_branch(self):
 
195
        if sys.platform == 'win32':
 
196
            raise TestSkipped('chmod has no effect on win32')
 
197
        #FIXME RBC 20060105 should test branch and repository 
 
198
        # permissions ? 
 
199
        # also, these are BzrBranch format specific things..
 
200
        os.mkdir('a')
 
201
        mode = stat.S_IMODE(os.stat('a').st_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)
 
206
 
 
207
        os.mkdir('b')
 
208
        os.chmod('b', 02777)
 
209
        b = Branch.create('b')
 
210
        assertEqualMode(self, 02777, b.control_files._dir_mode)
 
211
        assertEqualMode(self, 00666, b.control_files._file_mode)
 
212
        check_mode_r(self, 'b/.bzr', 00666, 02777)
 
213
 
 
214
        os.mkdir('c')
 
215
        os.chmod('c', 02750)
 
216
        b = Branch.create('c')
 
217
        assertEqualMode(self, 02750, b.control_files._dir_mode)
 
218
        assertEqualMode(self, 00640, b.control_files._file_mode)
 
219
        check_mode_r(self, 'c/.bzr', 00640, 02750)
 
220
 
 
221
        os.mkdir('d')
 
222
        os.chmod('d', 0700)
 
223
        b = Branch.create('d')
 
224
        assertEqualMode(self, 0700, b.control_files._dir_mode)
 
225
        assertEqualMode(self, 0600, b.control_files._file_mode)
 
226
        check_mode_r(self, 'd/.bzr', 00600, 0700)
 
227
 
191
228
 
192
229
class TestSftpPermissions(TestCaseWithSFTPServer):
193
230
 
197
234
        # Though it would be nice to test that SFTP to a server
198
235
        # which does support chmod has the right effect
199
236
 
200
 
        # bodge around for stubsftpserver not letting use connect
201
 
        # more than once
202
 
        _t = get_transport(self.get_url())
 
237
        from bzrlib.transport.sftp import SFTPTransport
 
238
 
 
239
        # We don't actually use it directly, we just want to
 
240
        # keep the connection open, since StubSFTPServer only
 
241
        # allows 1 connection
 
242
        _transport = SFTPTransport(self._sftp_url)
203
243
 
204
244
        os.mkdir('local')
205
 
        t_local = self.make_branch_and_tree('local')
 
245
        t_local = WorkingTree.create_standalone('local')
206
246
        b_local = t_local.branch
207
247
        open('local/a', 'wb').write('foo\n')
208
248
        t_local.add('a')
209
249
        t_local.commit('foo')
210
250
 
211
251
        # Delete them because we are modifying the filesystem underneath them
 
252
        del b_local, t_local 
212
253
        chmod_r('local/.bzr', 0644, 0755)
213
254
        check_mode_r(self, 'local/.bzr', 0644, 0755)
214
255
 
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)
 
256
        b_local = Branch.open(u'local')
 
257
        t_local = b_local.working_tree()
 
258
        assertEqualMode(self, 0755, b_local.control_files._dir_mode)
 
259
        assertEqualMode(self, 0644, b_local.control_files._file_mode)
219
260
 
220
261
        os.mkdir('sftp')
221
 
        sftp_url = self.get_url('sftp')
222
 
        b_sftp = BzrDir.create_branch_and_repo(sftp_url)
 
262
        sftp_url = self.get_remote_url('sftp')
 
263
        b_sftp = Branch.create(sftp_url)
223
264
 
224
265
        b_sftp.pull(b_local)
225
266
        del b_sftp
227
268
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
228
269
 
229
270
        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)
 
271
        assertEqualMode(self, 0755, b_sftp.control_files._dir_mode)
 
272
        assertEqualMode(self, 0644, b_sftp.control_files._file_mode)
232
273
 
233
274
        open('local/a', 'wb').write('foo2\n')
234
275
        t_local.commit('foo2')
248
289
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
249
290
 
250
291
        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)
 
292
        assertEqualMode(self, 0775, b_sftp.control_files._dir_mode)
 
293
        assertEqualMode(self, 0664, b_sftp.control_files._file_mode)
253
294
 
254
295
        open('local/a', 'wb').write('foo3\n')
255
296
        t_local.commit('foo3')
270
311
        original_umask = os.umask(umask)
271
312
 
272
313
        try:
273
 
            t = get_transport(self.get_url())
 
314
            from bzrlib.transport.sftp import SFTPTransport
 
315
            t = SFTPTransport(self._sftp_url)
274
316
            # Direct access should be masked by umask
275
317
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
276
318
            self.assertTransportMode(t, 'a', 0666 &~umask)