← 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: John Arbash Meinel
  • Date: 2007-11-13 20:37:09 UTC
  • mto: This revision was merged to the branch mainline in revision 3001.
  • Revision ID: john@arbash-meinel.com-20071113203709-kysdte0emqv84pnj
https://launchpad.net/bugs/162486
Fix bug #162486, by having RemoteBranch properly initialize self._revision_id_to_revno_map.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_permissions.py
1
 
# Copyright (C) 2005 by 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
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?
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 cStringIO import StringIO
 
37
import urllib
36
38
 
37
39
from bzrlib.branch import Branch
38
 
from bzrlib.tests import TestCaseInTempDir, TestSkipped
 
40
from bzrlib.bzrdir import BzrDir
 
41
from bzrlib.lockable_files import LockableFiles, TransportLock
 
42
from bzrlib.tests import TestCaseWithTransport, TestSkipped
39
43
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
40
 
from bzrlib.tests.test_transport import check_mode
 
44
from bzrlib.transport import get_transport
 
45
from bzrlib.workingtree import WorkingTree
41
46
 
42
47
 
43
48
def chmod_r(base, file_mode, dir_mode):
63
68
    :param include_base: If false, only check the subdirectories
64
69
    """
65
70
    assert os.path.isdir(base)
 
71
    t = get_transport(".")
66
72
    if include_base:
67
 
        check_mode(test, base, dir_mode)
 
73
        test.assertTransportMode(t, base, dir_mode)
68
74
    for root, dirs, files in os.walk(base):
69
75
        for d in dirs:
70
 
            p = os.path.join(root, d)
71
 
            check_mode(test, p, dir_mode)
 
76
            p = '/'.join([urllib.quote(x) for x in root.split('/\\') + [d]])
 
77
            test.assertTransportMode(t, p, dir_mode)
72
78
        for f in files:
73
79
            p = os.path.join(root, f)
74
 
            check_mode(test, p, file_mode)
75
 
 
76
 
 
77
 
def assertEqualMode(test, mode, mode_test):
78
 
    test.assertEqual(mode, mode_test,
79
 
                     'mode mismatch %o != %o' % (mode, mode_test))
80
 
 
81
 
 
82
 
class TestPermissions(TestCaseInTempDir):
 
80
            p = '/'.join([urllib.quote(x) for x in root.split('/\\') + [f]])
 
81
            test.assertTransportMode(t, p, file_mode)
 
82
 
 
83
 
 
84
class TestPermissions(TestCaseWithTransport):
83
85
 
84
86
    def test_new_files(self):
85
87
        if sys.platform == 'win32':
86
88
            raise TestSkipped('chmod has no effect on win32')
87
89
 
88
 
        b = Branch.initialize(u'.')
89
 
        t = b.working_tree()
 
90
        t = self.make_branch_and_tree('.')
 
91
        b = t.branch
90
92
        open('a', 'wb').write('foo\n')
91
 
        t.add('a')
 
93
        # ensure check_mode_r works with capital-letter file-ids like TREE_ROOT
 
94
        t.add('a', 'CAPS-ID')
92
95
        t.commit('foo')
93
96
 
94
 
        # Delete them because we are modifying the filesystem underneath them
95
 
        del b, t 
96
97
        chmod_r('.bzr', 0644, 0755)
97
98
        check_mode_r(self, '.bzr', 0644, 0755)
98
99
 
99
 
        b = Branch.open('.')
100
 
        t = b.working_tree()
101
 
        assertEqualMode(self, 0755, b._dir_mode)
102
 
        assertEqualMode(self, 0644, b._file_mode)
 
100
        # although we are modifying the filesystem
 
101
        # underneath the objects, they are not locked, and thus it must
 
102
        # be safe for most operations. But here we want to observe a 
 
103
        # mode change in the control bits, which current do not refresh
 
104
        # when a new lock is taken out.
 
105
        t = WorkingTree.open('.')
 
106
        b = t.branch
 
107
        self.assertEqualMode(0755, b.control_files._dir_mode)
 
108
        self.assertEqualMode(0644, b.control_files._file_mode)
103
109
 
104
110
        # Modifying a file shouldn't break the permissions
105
111
        open('a', 'wb').write('foo2\n')
113
119
        t.commit('new b')
114
120
        check_mode_r(self, '.bzr', 0644, 0755)
115
121
 
116
 
        del b, t
117
122
        # Recursively update the modes of all files
118
123
        chmod_r('.bzr', 0664, 0775)
119
124
        check_mode_r(self, '.bzr', 0664, 0775)
120
 
        b = Branch.open('.')
121
 
        t = b.working_tree()
122
 
        assertEqualMode(self, 0775, b._dir_mode)
123
 
        assertEqualMode(self, 0664, b._file_mode)
 
125
        t = WorkingTree.open('.')
 
126
        b = t.branch
 
127
        self.assertEqualMode(0775, b.control_files._dir_mode)
 
128
        self.assertEqualMode(0664, b.control_files._file_mode)
124
129
 
125
130
        open('a', 'wb').write('foo3\n')
126
131
        t.commit('foo3')
132
137
        check_mode_r(self, '.bzr', 0664, 0775)
133
138
 
134
139
        # Test the group sticky bit
135
 
        del b, t
136
140
        # Recursively update the modes of all files
137
141
        chmod_r('.bzr', 0664, 02775)
138
142
        check_mode_r(self, '.bzr', 0664, 02775)
139
 
        b = Branch.open('.')
140
 
        t = b.working_tree()
141
 
        assertEqualMode(self, 02775, b._dir_mode)
142
 
        assertEqualMode(self, 0664, b._file_mode)
 
143
        t = WorkingTree.open('.')
 
144
        b = t.branch
 
145
        self.assertEqualMode(02775, b.control_files._dir_mode)
 
146
        self.assertEqualMode(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_bytes('my-lock', '')
 
163
            lockable = LockableFiles(transport, 'my-lock', TransportLock)
 
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', TransportLock)
 
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', TransportLock)
 
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', TransportLock)
 
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', TransportLock)
 
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
184
 
 
185
 
    def test_new_branch(self):
186
 
        if sys.platform == 'win32':
187
 
            raise TestSkipped('chmod has no effect on win32')
188
 
 
189
 
        os.mkdir('a')
190
 
        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)
194
 
 
195
 
        os.mkdir('b')
196
 
        os.chmod('b', 02777)
197
 
        b = Branch.initialize('b')
198
 
        assertEqualMode(self, 02777, b._dir_mode)
199
 
        assertEqualMode(self, 00666, b._file_mode)
200
 
        check_mode_r(self, 'b/.bzr', 00666, 02777)
201
 
 
202
 
        os.mkdir('c')
203
 
        os.chmod('c', 02750)
204
 
        b = Branch.initialize('c')
205
 
        assertEqualMode(self, 02750, b._dir_mode)
206
 
        assertEqualMode(self, 00640, b._file_mode)
207
 
        check_mode_r(self, 'c/.bzr', 00640, 02750)
208
 
 
209
 
        os.mkdir('d')
210
 
        os.chmod('d', 0700)
211
 
        b = Branch.initialize('d')
212
 
        assertEqualMode(self, 0700, b._dir_mode)
213
 
        assertEqualMode(self, 0600, b._file_mode)
214
 
        check_mode_r(self, 'd/.bzr', 00600, 0700)
 
191
            LockableFiles._set_dir_mode = True
 
192
            LockableFiles._set_file_mode = True
215
193
 
216
194
 
217
195
class TestSftpPermissions(TestCaseWithSFTPServer):
222
200
        # Though it would be nice to test that SFTP to a server
223
201
        # which does support chmod has the right effect
224
202
 
225
 
        from bzrlib.transport.sftp import SFTPTransport
226
 
 
227
 
        # We don't actually use it directly, we just want to
228
 
        # keep the connection open, since StubSFTPServer only
229
 
        # allows 1 connection
230
 
        self.delayed_setup()
231
 
        _transport = SFTPTransport(self._sftp_url)
 
203
        # bodge around for stubsftpserver not letting use connect
 
204
        # more than once
 
205
        _t = get_transport(self.get_url())
232
206
 
233
207
        os.mkdir('local')
234
 
        b_local = Branch.initialize(u'local')
235
 
        t_local = b_local.working_tree()
 
208
        t_local = self.make_branch_and_tree('local')
 
209
        b_local = t_local.branch
236
210
        open('local/a', 'wb').write('foo\n')
237
211
        t_local.add('a')
238
212
        t_local.commit('foo')
239
213
 
240
214
        # Delete them because we are modifying the filesystem underneath them
241
 
        del b_local, t_local 
242
215
        chmod_r('local/.bzr', 0644, 0755)
243
216
        check_mode_r(self, 'local/.bzr', 0644, 0755)
244
217
 
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)
 
218
        t = WorkingTree.open('local')
 
219
        b_local = t.branch
 
220
        self.assertEqualMode(0755, b_local.control_files._dir_mode)
 
221
        self.assertEqualMode(0644, b_local.control_files._file_mode)
249
222
 
250
223
        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)
 
224
        sftp_url = self.get_url('sftp')
 
225
        b_sftp = BzrDir.create_branch_and_repo(sftp_url)
254
226
 
255
227
        b_sftp.pull(b_local)
256
228
        del b_sftp
258
230
        check_mode_r(self, 'sftp/.bzr', 0644, 0755)
259
231
 
260
232
        b_sftp = Branch.open(sftp_url)
261
 
        assertEqualMode(self, 0755, b_sftp._dir_mode)
262
 
        assertEqualMode(self, 0644, b_sftp._file_mode)
 
233
        self.assertEqualMode(0755, b_sftp.control_files._dir_mode)
 
234
        self.assertEqualMode(0644, b_sftp.control_files._file_mode)
263
235
 
264
236
        open('local/a', 'wb').write('foo2\n')
265
237
        t_local.commit('foo2')
279
251
        check_mode_r(self, 'sftp/.bzr', 0664, 0775)
280
252
 
281
253
        b_sftp = Branch.open(sftp_url)
282
 
        assertEqualMode(self, 0775, b_sftp._dir_mode)
283
 
        assertEqualMode(self, 0664, b_sftp._file_mode)
 
254
        self.assertEqualMode(0775, b_sftp.control_files._dir_mode)
 
255
        self.assertEqualMode(0664, b_sftp.control_files._file_mode)
284
256
 
285
257
        open('local/a', 'wb').write('foo3\n')
286
258
        t_local.commit('foo3')
301
273
        original_umask = os.umask(umask)
302
274
 
303
275
        try:
304
 
            from bzrlib.transport.sftp import SFTPTransport
305
 
            self.delayed_setup()
306
 
            t = SFTPTransport(self._sftp_url)
 
276
            t = get_transport(self.get_url())
307
277
            # Direct access should be masked by umask
308
278
            t._sftp_open_exclusive('a', mode=0666).write('foo\n')
309
 
            check_mode(self, 'a', 0666 &~umask)
 
279
            self.assertTransportMode(t, 'a', 0666 &~umask)
310
280
 
311
281
            # but Transport overrides umask
312
 
            t.put('b', 'txt', mode=0666)
313
 
            check_mode(self, 'b', 0666)
 
282
            t.put_bytes('b', 'txt', mode=0666)
 
283
            self.assertTransportMode(t, 'b', 0666)
314
284
 
315
 
            t._sftp.mkdir('c', mode=0777)
316
 
            check_mode(self, 'c', 0777 &~umask)
 
285
            t._get_sftp().mkdir('c', mode=0777)
 
286
            self.assertTransportMode(t, 'c', 0777 &~umask)
317
287
 
318
288
            t.mkdir('d', mode=0777)
319
 
            check_mode(self, 'd', 0777)
 
289
            self.assertTransportMode(t, 'd', 0777)
320
290
        finally:
321
291
            os.umask(original_umask)
322
 
 
323