/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

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_permissions.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
2
2
# -*- coding: utf-8 -*-
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
32
32
 
33
33
import os
34
34
import sys
 
35
import stat
 
36
from cStringIO import StringIO
 
37
import urllib
35
38
 
36
 
from breezy import urlutils
37
 
from breezy.branch import Branch
38
 
from breezy.controldir import ControlDir
39
 
from breezy.tests import TestCaseWithTransport, TestSkipped
40
 
from breezy.tests.test_sftp_transport import TestCaseWithSFTPServer
41
 
from breezy.workingtree import WorkingTree
 
39
from bzrlib.branch import Branch
 
40
from bzrlib.bzrdir import BzrDir
 
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
42
45
 
43
46
 
44
47
def chmod_r(base, file_mode, dir_mode):
62
65
    :param dir_mode: The mode for all directories
63
66
    :param include_base: If false, only check the subdirectories
64
67
    """
65
 
    t = test.get_transport()
 
68
    t = get_transport(".")
66
69
    if include_base:
67
70
        test.assertTransportMode(t, base, dir_mode)
68
71
    for root, dirs, files in os.walk(base):
69
72
        for d in dirs:
70
 
            p = '/'.join([urlutils.quote(x) for x in root.split('/\\') + [d]])
 
73
            p = '/'.join([urllib.quote(x) for x in root.split('/\\') + [d]])
71
74
            test.assertTransportMode(t, p, dir_mode)
72
75
        for f in files:
73
76
            p = os.path.join(root, f)
74
 
            p = '/'.join([urlutils.quote(x) for x in root.split('/\\') + [f]])
 
77
            p = '/'.join([urllib.quote(x) for x in root.split('/\\') + [f]])
75
78
            test.assertTransportMode(t, p, file_mode)
76
79
 
77
80
 
83
86
 
84
87
        t = self.make_branch_and_tree('.')
85
88
        b = t.branch
86
 
        with open('a', 'wb') as f:
87
 
            f.write(b'foo\n')
 
89
        open('a', 'wb').write('foo\n')
88
90
        # ensure check_mode_r works with capital-letter file-ids like TREE_ROOT
89
 
        t.add('a', b'CAPS-ID')
 
91
        t.add('a', 'CAPS-ID')
90
92
        t.commit('foo')
91
93
 
92
 
        chmod_r('.bzr', 0o644, 0o755)
93
 
        check_mode_r(self, '.bzr', 0o644, 0o755)
 
94
        chmod_r('.bzr', 0644, 0755)
 
95
        check_mode_r(self, '.bzr', 0644, 0755)
94
96
 
95
97
        # although we are modifying the filesystem
96
98
        # underneath the objects, they are not locked, and thus it must
99
101
        # when a new lock is taken out.
100
102
        t = WorkingTree.open('.')
101
103
        b = t.branch
102
 
        self.assertEqualMode(0o755, b.control_files._dir_mode)
103
 
        self.assertEqualMode(0o644, b.control_files._file_mode)
104
 
        self.assertEqualMode(0o755, b.controldir._get_dir_mode())
105
 
        self.assertEqualMode(0o644, b.controldir._get_file_mode())
 
104
        self.assertEqualMode(0755, b.control_files._dir_mode)
 
105
        self.assertEqualMode(0644, b.control_files._file_mode)
 
106
        self.assertEqualMode(0755, b.bzrdir._get_dir_mode())
 
107
        self.assertEqualMode(0644, b.bzrdir._get_file_mode())
106
108
 
107
109
        # Modifying a file shouldn't break the permissions
108
 
        with open('a', 'wb') as f:
109
 
            f.write(b'foo2\n')
 
110
        open('a', 'wb').write('foo2\n')
110
111
        t.commit('foo2')
111
112
        # The mode should be maintained after commit
112
 
        check_mode_r(self, '.bzr', 0o644, 0o755)
 
113
        check_mode_r(self, '.bzr', 0644, 0755)
113
114
 
114
115
        # Adding a new file should maintain the permissions
115
 
        with open('b', 'wb') as f:
116
 
            f.write(b'new b\n')
 
116
        open('b', 'wb').write('new b\n')
117
117
        t.add('b')
118
118
        t.commit('new b')
119
 
        check_mode_r(self, '.bzr', 0o644, 0o755)
 
119
        check_mode_r(self, '.bzr', 0644, 0755)
120
120
 
121
121
        # Recursively update the modes of all files
122
 
        chmod_r('.bzr', 0o664, 0o775)
123
 
        check_mode_r(self, '.bzr', 0o664, 0o775)
 
122
        chmod_r('.bzr', 0664, 0775)
 
123
        check_mode_r(self, '.bzr', 0664, 0775)
124
124
        t = WorkingTree.open('.')
125
125
        b = t.branch
126
 
        self.assertEqualMode(0o775, b.control_files._dir_mode)
127
 
        self.assertEqualMode(0o664, b.control_files._file_mode)
128
 
        self.assertEqualMode(0o775, b.controldir._get_dir_mode())
129
 
        self.assertEqualMode(0o664, b.controldir._get_file_mode())
 
126
        self.assertEqualMode(0775, b.control_files._dir_mode)
 
127
        self.assertEqualMode(0664, b.control_files._file_mode)
 
128
        self.assertEqualMode(0775, b.bzrdir._get_dir_mode())
 
129
        self.assertEqualMode(0664, b.bzrdir._get_file_mode())
130
130
 
131
 
        with open('a', 'wb') as f:
132
 
            f.write(b'foo3\n')
 
131
        open('a', 'wb').write('foo3\n')
133
132
        t.commit('foo3')
134
 
        check_mode_r(self, '.bzr', 0o664, 0o775)
 
133
        check_mode_r(self, '.bzr', 0664, 0775)
135
134
 
136
 
        with open('c', 'wb') as f:
137
 
            f.write(b'new c\n')
 
135
        open('c', 'wb').write('new c\n')
138
136
        t.add('c')
139
137
        t.commit('new c')
140
 
        check_mode_r(self, '.bzr', 0o664, 0o775)
 
138
        check_mode_r(self, '.bzr', 0664, 0775)
141
139
 
142
140
    def test_new_files_group_sticky_bit(self):
143
141
        if sys.platform == 'win32':
144
142
            raise TestSkipped('chmod has no effect on win32')
145
 
        elif sys.platform == 'darwin' or 'freebsd' in sys.platform:
146
 
            # FreeBSD-based platforms create temp dirs with the 'wheel' group,
147
 
            # which users are not likely to be in, and this prevents us from
148
 
            # setting the sgid bit
 
143
        elif sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
 
144
            # OS X (and FreeBSD) create temp dirs with the 'wheel' group, which
 
145
            # users are not likely to be in, and this prevents us from setting
 
146
            # the sgid bit
149
147
            os.chown(self.test_dir, os.getuid(), os.getgid())
150
148
 
151
149
        t = self.make_branch_and_tree('.')
153
151
 
154
152
        # Test the group sticky bit
155
153
        # Recursively update the modes of all files
156
 
        chmod_r('.bzr', 0o664, 0o2775)
157
 
        check_mode_r(self, '.bzr', 0o664, 0o2775)
 
154
        chmod_r('.bzr', 0664, 02775)
 
155
        check_mode_r(self, '.bzr', 0664, 02775)
158
156
        t = WorkingTree.open('.')
159
157
        b = t.branch
160
 
        self.assertEqualMode(0o2775, b.control_files._dir_mode)
161
 
        self.assertEqualMode(0o664, b.control_files._file_mode)
162
 
        self.assertEqualMode(0o2775, b.controldir._get_dir_mode())
163
 
        self.assertEqualMode(0o664, b.controldir._get_file_mode())
 
158
        self.assertEqualMode(02775, b.control_files._dir_mode)
 
159
        self.assertEqualMode(0664, b.control_files._file_mode)
 
160
        self.assertEqualMode(02775, b.bzrdir._get_dir_mode())
 
161
        self.assertEqualMode(0664, b.bzrdir._get_file_mode())
164
162
 
165
 
        with open('a', 'wb') as f:
166
 
            f.write(b'foo4\n')
 
163
        open('a', 'wb').write('foo4\n')
167
164
        t.commit('foo4')
168
 
        check_mode_r(self, '.bzr', 0o664, 0o2775)
 
165
        check_mode_r(self, '.bzr', 0664, 02775)
169
166
 
170
 
        with open('d', 'wb') as f:
171
 
            f.write(b'new d\n')
 
167
        open('d', 'wb').write('new d\n')
172
168
        t.add('d')
173
169
        t.commit('new d')
174
 
        check_mode_r(self, '.bzr', 0o664, 0o2775)
 
170
        check_mode_r(self, '.bzr', 0664, 02775)
175
171
 
176
172
 
177
173
class TestSftpPermissions(TestCaseWithSFTPServer):
184
180
 
185
181
        # bodge around for stubsftpserver not letting use connect
186
182
        # more than once
187
 
        _t = self.get_transport()
 
183
        _t = get_transport(self.get_url())
188
184
 
189
185
        os.mkdir('local')
190
186
        t_local = self.make_branch_and_tree('local')
191
187
        b_local = t_local.branch
192
 
        with open('local/a', 'wb') as f:
193
 
            f.write(b'foo\n')
 
188
        open('local/a', 'wb').write('foo\n')
194
189
        t_local.add('a')
195
190
        t_local.commit('foo')
196
191
 
197
192
        # Delete them because we are modifying the filesystem underneath them
198
 
        chmod_r('local/.bzr', 0o644, 0o755)
199
 
        check_mode_r(self, 'local/.bzr', 0o644, 0o755)
 
193
        chmod_r('local/.bzr', 0644, 0755)
 
194
        check_mode_r(self, 'local/.bzr', 0644, 0755)
200
195
 
201
196
        t = WorkingTree.open('local')
202
197
        b_local = t.branch
203
 
        self.assertEqualMode(0o755, b_local.control_files._dir_mode)
204
 
        self.assertEqualMode(0o644, b_local.control_files._file_mode)
205
 
        self.assertEqualMode(0o755, b_local.controldir._get_dir_mode())
206
 
        self.assertEqualMode(0o644, b_local.controldir._get_file_mode())
 
198
        self.assertEqualMode(0755, b_local.control_files._dir_mode)
 
199
        self.assertEqualMode(0644, b_local.control_files._file_mode)
 
200
        self.assertEqualMode(0755, b_local.bzrdir._get_dir_mode())
 
201
        self.assertEqualMode(0644, b_local.bzrdir._get_file_mode())
207
202
 
208
203
        os.mkdir('sftp')
209
204
        sftp_url = self.get_url('sftp')
210
 
        b_sftp = ControlDir.create_branch_and_repo(sftp_url)
 
205
        b_sftp = BzrDir.create_branch_and_repo(sftp_url)
211
206
 
212
207
        b_sftp.pull(b_local)
213
208
        del b_sftp
214
 
        chmod_r('sftp/.bzr', 0o644, 0o755)
215
 
        check_mode_r(self, 'sftp/.bzr', 0o644, 0o755)
 
209
        chmod_r('sftp/.bzr', 0644, 0755)
 
210
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
216
211
 
217
212
        b_sftp = Branch.open(sftp_url)
218
 
        self.assertEqualMode(0o755, b_sftp.control_files._dir_mode)
219
 
        self.assertEqualMode(0o644, b_sftp.control_files._file_mode)
220
 
        self.assertEqualMode(0o755, b_sftp.controldir._get_dir_mode())
221
 
        self.assertEqualMode(0o644, b_sftp.controldir._get_file_mode())
 
213
        self.assertEqualMode(0755, b_sftp.control_files._dir_mode)
 
214
        self.assertEqualMode(0644, b_sftp.control_files._file_mode)
 
215
        self.assertEqualMode(0755, b_sftp.bzrdir._get_dir_mode())
 
216
        self.assertEqualMode(0644, b_sftp.bzrdir._get_file_mode())
222
217
 
223
 
        with open('local/a', 'wb') as f:
224
 
            f.write(b'foo2\n')
 
218
        open('local/a', 'wb').write('foo2\n')
225
219
        t_local.commit('foo2')
226
220
        b_sftp.pull(b_local)
227
221
        # The mode should be maintained after commit
228
 
        check_mode_r(self, 'sftp/.bzr', 0o644, 0o755)
 
222
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
229
223
 
230
 
        with open('local/b', 'wb') as f:
231
 
            f.write(b'new b\n')
 
224
        open('local/b', 'wb').write('new b\n')
232
225
        t_local.add('b')
233
226
        t_local.commit('new b')
234
227
        b_sftp.pull(b_local)
235
 
        check_mode_r(self, 'sftp/.bzr', 0o644, 0o755)
 
228
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
236
229
 
237
230
        del b_sftp
238
231
        # Recursively update the modes of all files
239
 
        chmod_r('sftp/.bzr', 0o664, 0o775)
240
 
        check_mode_r(self, 'sftp/.bzr', 0o664, 0o775)
 
232
        chmod_r('sftp/.bzr', 0664, 0775)
 
233
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
241
234
 
242
235
        b_sftp = Branch.open(sftp_url)
243
 
        self.assertEqualMode(0o775, b_sftp.control_files._dir_mode)
244
 
        self.assertEqualMode(0o664, b_sftp.control_files._file_mode)
245
 
        self.assertEqualMode(0o775, b_sftp.controldir._get_dir_mode())
246
 
        self.assertEqualMode(0o664, b_sftp.controldir._get_file_mode())
 
236
        self.assertEqualMode(0775, b_sftp.control_files._dir_mode)
 
237
        self.assertEqualMode(0664, b_sftp.control_files._file_mode)
 
238
        self.assertEqualMode(0775, b_sftp.bzrdir._get_dir_mode())
 
239
        self.assertEqualMode(0664, b_sftp.bzrdir._get_file_mode())
247
240
 
248
 
        with open('local/a', 'wb') as f:
249
 
            f.write(b'foo3\n')
 
241
        open('local/a', 'wb').write('foo3\n')
250
242
        t_local.commit('foo3')
251
243
        b_sftp.pull(b_local)
252
 
        check_mode_r(self, 'sftp/.bzr', 0o664, 0o775)
 
244
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
253
245
 
254
 
        with open('local/c', 'wb') as f:
255
 
            f.write(b'new c\n')
 
246
        open('local/c', 'wb').write('new c\n')
256
247
        t_local.add('c')
257
248
        t_local.commit('new c')
258
249
        b_sftp.pull(b_local)
259
 
        check_mode_r(self, 'sftp/.bzr', 0o664, 0o775)
 
250
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
260
251
 
261
252
    def test_sftp_server_modes(self):
262
253
        if sys.platform == 'win32':
263
254
            raise TestSkipped('chmod has no effect on win32')
264
255
 
265
 
        umask = 0o022
 
256
        umask = 0022
266
257
        original_umask = os.umask(umask)
267
258
 
268
259
        try:
269
 
            t = self.get_transport()
 
260
            t = get_transport(self.get_url())
270
261
            # Direct access should be masked by umask
271
 
            with t._sftp_open_exclusive('a', mode=0o666) as f:
272
 
                f.write(b'foo\n')
273
 
            self.assertTransportMode(t, 'a', 0o666 & ~umask)
 
262
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
 
263
            self.assertTransportMode(t, 'a', 0666 &~umask)
274
264
 
275
265
            # but Transport overrides umask
276
 
            t.put_bytes('b', b'txt', mode=0o666)
277
 
            self.assertTransportMode(t, 'b', 0o666)
278
 
 
279
 
            t._get_sftp().mkdir('c', mode=0o777)
280
 
            self.assertTransportMode(t, 'c', 0o777 & ~umask)
281
 
 
282
 
            t.mkdir('d', mode=0o777)
283
 
            self.assertTransportMode(t, 'd', 0o777)
 
266
            t.put_bytes('b', 'txt', mode=0666)
 
267
            self.assertTransportMode(t, 'b', 0666)
 
268
 
 
269
            t._get_sftp().mkdir('c', mode=0777)
 
270
            self.assertTransportMode(t, 'c', 0777 &~umask)
 
271
 
 
272
            t.mkdir('d', mode=0777)
 
273
            self.assertTransportMode(t, 'd', 0777)
284
274
        finally:
285
275
            os.umask(original_umask)