/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 breezy/tests/test_permissions.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 18:59:44 UTC
  • mfrom: (7143.15.15 more-cleanups)
  • Revision ID: breezy.the.bot@gmail.com-20181116185944-biefv1sub37qfybm
Sprinkle some PEP8iness.

Merged from https://code.launchpad.net/~jelmer/brz/more-cleanups/+merge/358611

Show diffs side-by-side

added added

removed removed

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