/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/features.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-10 16:40:42 UTC
  • mfrom: (6653.6.7 rename-controldir)
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170610164042-zrxqgy2htyduvke2
Merge rename-controldir branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/features.py
1
 
# Copyright (C) 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2009, 2010, 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
"""A collection of commonly used 'Features' to optionally run tests.
 
18
"""
 
19
 
17
20
import os
 
21
import subprocess
18
22
import stat
19
 
 
20
 
from bzrlib import tests
21
 
from bzrlib.symbol_versioning import deprecated_in
22
 
 
23
 
 
24
 
apport = tests.ModuleAvailableFeature('apport')
25
 
paramiko = tests.ModuleAvailableFeature('paramiko')
26
 
pycurl = tests.ModuleAvailableFeature('pycurl')
27
 
subunit = tests.ModuleAvailableFeature('subunit')
28
 
 
29
 
 
30
 
class _PosixPermissionsFeature(tests.Feature):
 
23
import sys
 
24
import tempfile
 
25
 
 
26
from .. import (
 
27
    osutils,
 
28
    symbol_versioning,
 
29
    )
 
30
 
 
31
 
 
32
class Feature(object):
 
33
    """An operating system Feature."""
 
34
 
 
35
    def __init__(self):
 
36
        self._available = None
 
37
 
 
38
    def available(self):
 
39
        """Is the feature available?
 
40
 
 
41
        :return: True if the feature is available.
 
42
        """
 
43
        if self._available is None:
 
44
            self._available = self._probe()
 
45
        return self._available
 
46
 
 
47
    def _probe(self):
 
48
        """Implement this method in concrete features.
 
49
 
 
50
        :return: True if the feature is available.
 
51
        """
 
52
        raise NotImplementedError
 
53
 
 
54
    def __str__(self):
 
55
        if getattr(self, 'feature_name', None):
 
56
            return self.feature_name()
 
57
        return self.__class__.__name__
 
58
 
 
59
 
 
60
class _SymlinkFeature(Feature):
 
61
 
 
62
    def _probe(self):
 
63
        return osutils.has_symlinks()
 
64
 
 
65
    def feature_name(self):
 
66
        return 'symlinks'
 
67
 
 
68
SymlinkFeature = _SymlinkFeature()
 
69
 
 
70
 
 
71
class _HardlinkFeature(Feature):
 
72
 
 
73
    def _probe(self):
 
74
        return osutils.has_hardlinks()
 
75
 
 
76
    def feature_name(self):
 
77
        return 'hardlinks'
 
78
 
 
79
HardlinkFeature = _HardlinkFeature()
 
80
 
 
81
 
 
82
class _OsFifoFeature(Feature):
 
83
 
 
84
    def _probe(self):
 
85
        return getattr(os, 'mkfifo', None)
 
86
 
 
87
    def feature_name(self):
 
88
        return 'filesystem fifos'
 
89
 
 
90
OsFifoFeature = _OsFifoFeature()
 
91
 
 
92
 
 
93
class _UnicodeFilenameFeature(Feature):
 
94
    """Does the filesystem support Unicode filenames?"""
 
95
 
 
96
    def _probe(self):
 
97
        try:
 
98
            # Check for character combinations unlikely to be covered by any
 
99
            # single non-unicode encoding. We use the characters
 
100
            # - greek small letter alpha (U+03B1) and
 
101
            # - braille pattern dots-123456 (U+283F).
 
102
            os.stat(u'\u03b1\u283f')
 
103
        except UnicodeEncodeError:
 
104
            return False
 
105
        except (IOError, OSError):
 
106
            # The filesystem allows the Unicode filename but the file doesn't
 
107
            # exist.
 
108
            return True
 
109
        else:
 
110
            # The filesystem allows the Unicode filename and the file exists,
 
111
            # for some reason.
 
112
            return True
 
113
 
 
114
UnicodeFilenameFeature = _UnicodeFilenameFeature()
 
115
 
 
116
 
 
117
class _CompatabilityThunkFeature(Feature):
 
118
    """This feature is just a thunk to another feature.
 
119
 
 
120
    It issues a deprecation warning if it is accessed, to let you know that you
 
121
    should really use a different feature.
 
122
    """
 
123
 
 
124
    def __init__(self, dep_version, module, name,
 
125
                 replacement_name, replacement_module=None):
 
126
        super(_CompatabilityThunkFeature, self).__init__()
 
127
        self._module = module
 
128
        if replacement_module is None:
 
129
            replacement_module = module
 
130
        self._replacement_module = replacement_module
 
131
        self._name = name
 
132
        self._replacement_name = replacement_name
 
133
        self._dep_version = dep_version
 
134
        self._feature = None
 
135
 
 
136
    def _ensure(self):
 
137
        if self._feature is None:
 
138
            from breezy import pyutils
 
139
            depr_msg = self._dep_version % ('%s.%s'
 
140
                                            % (self._module, self._name))
 
141
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
 
142
                                               self._replacement_name)
 
143
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning,
 
144
                                   stacklevel=5)
 
145
            # Import the new feature and use it as a replacement for the
 
146
            # deprecated one.
 
147
            self._feature = pyutils.get_named_object(
 
148
                self._replacement_module, self._replacement_name)
 
149
 
 
150
    def _probe(self):
 
151
        self._ensure()
 
152
        return self._feature._probe()
 
153
 
 
154
 
 
155
class ModuleAvailableFeature(Feature):
 
156
    """This is a feature than describes a module we want to be available.
 
157
 
 
158
    Declare the name of the module in __init__(), and then after probing, the
 
159
    module will be available as 'self.module'.
 
160
 
 
161
    :ivar module: The module if it is available, else None.
 
162
    """
 
163
 
 
164
    def __init__(self, module_name):
 
165
        super(ModuleAvailableFeature, self).__init__()
 
166
        self.module_name = module_name
 
167
 
 
168
    def _probe(self):
 
169
        sentinel = object()
 
170
        module = sys.modules.get(self.module_name, sentinel)
 
171
        if module is sentinel:
 
172
            try:
 
173
                self._module = __import__(self.module_name, {}, {}, [''])
 
174
                return True
 
175
            except ImportError:
 
176
                return False
 
177
        else:
 
178
            self._module = module
 
179
            return True
 
180
 
 
181
    @property
 
182
    def module(self):
 
183
        if self.available():
 
184
            return self._module
 
185
        return None
 
186
 
 
187
    def feature_name(self):
 
188
        return self.module_name
 
189
 
 
190
 
 
191
class _HTTPSServerFeature(Feature):
 
192
    """Some tests want an https Server, check if one is available.
 
193
 
 
194
    Right now, the only way this is available is under python2.6 which provides
 
195
    an ssl module.
 
196
    """
 
197
 
 
198
    def _probe(self):
 
199
        try:
 
200
            import ssl
 
201
            return True
 
202
        except ImportError:
 
203
            return False
 
204
 
 
205
    def feature_name(self):
 
206
        return 'HTTPSServer'
 
207
 
 
208
 
 
209
HTTPSServerFeature = _HTTPSServerFeature()
 
210
 
 
211
 
 
212
class _ByteStringNamedFilesystem(Feature):
 
213
    """Is the filesystem based on bytes?"""
 
214
 
 
215
    def _probe(self):
 
216
        if os.name == "posix":
 
217
            return True
 
218
        return False
 
219
 
 
220
ByteStringNamedFilesystem = _ByteStringNamedFilesystem()
 
221
 
 
222
 
 
223
class _UTF8Filesystem(Feature):
 
224
    """Is the filesystem UTF-8?"""
 
225
 
 
226
    def _probe(self):
 
227
        if osutils._fs_enc.upper() in ('UTF-8', 'UTF8'):
 
228
            return True
 
229
        return False
 
230
 
 
231
UTF8Filesystem = _UTF8Filesystem()
 
232
 
 
233
 
 
234
class _BreakinFeature(Feature):
 
235
    """Does this platform support the breakin feature?"""
 
236
 
 
237
    def _probe(self):
 
238
        from breezy import breakin
 
239
        if breakin.determine_signal() is None:
 
240
            return False
 
241
        if sys.platform == 'win32':
 
242
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
 
243
            # We trigger SIGBREAK via a Console api so we need ctypes to
 
244
            # access the function
 
245
            try:
 
246
                import ctypes
 
247
            except OSError:
 
248
                return False
 
249
        return True
 
250
 
 
251
    def feature_name(self):
 
252
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
 
253
 
 
254
 
 
255
BreakinFeature = _BreakinFeature()
 
256
 
 
257
 
 
258
class _CaseInsCasePresFilenameFeature(Feature):
 
259
    """Is the file-system case insensitive, but case-preserving?"""
 
260
 
 
261
    def _probe(self):
 
262
        fileno, name = tempfile.mkstemp(prefix='MixedCase')
 
263
        try:
 
264
            # first check truly case-preserving for created files, then check
 
265
            # case insensitive when opening existing files.
 
266
            name = osutils.normpath(name)
 
267
            base, rel = osutils.split(name)
 
268
            found_rel = osutils.canonical_relpath(base, name)
 
269
            return (found_rel == rel
 
270
                    and os.path.isfile(name.upper())
 
271
                    and os.path.isfile(name.lower()))
 
272
        finally:
 
273
            os.close(fileno)
 
274
            os.remove(name)
 
275
 
 
276
    def feature_name(self):
 
277
        return "case-insensitive case-preserving filesystem"
 
278
 
 
279
CaseInsCasePresFilenameFeature = _CaseInsCasePresFilenameFeature()
 
280
 
 
281
 
 
282
class _CaseInsensitiveFilesystemFeature(Feature):
 
283
    """Check if underlying filesystem is case-insensitive but *not* case
 
284
    preserving.
 
285
    """
 
286
    # Note that on Windows, Cygwin, MacOS etc, the file-systems are far
 
287
    # more likely to be case preserving, so this case is rare.
 
288
 
 
289
    def _probe(self):
 
290
        if CaseInsCasePresFilenameFeature.available():
 
291
            return False
 
292
 
 
293
        from breezy import tests
 
294
 
 
295
        if tests.TestCaseWithMemoryTransport.TEST_ROOT is None:
 
296
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
 
297
            tests.TestCaseWithMemoryTransport.TEST_ROOT = root
 
298
        else:
 
299
            root = tests.TestCaseWithMemoryTransport.TEST_ROOT
 
300
        tdir = osutils.mkdtemp(prefix='case-sensitive-probe-', suffix='',
 
301
            dir=root)
 
302
        name_a = osutils.pathjoin(tdir, 'a')
 
303
        name_A = osutils.pathjoin(tdir, 'A')
 
304
        os.mkdir(name_a)
 
305
        result = osutils.isdir(name_A)
 
306
        tests._rmtree_temp_dir(tdir)
 
307
        return result
 
308
 
 
309
    def feature_name(self):
 
310
        return 'case-insensitive filesystem'
 
311
 
 
312
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
 
313
 
 
314
 
 
315
class _CaseSensitiveFilesystemFeature(Feature):
 
316
 
 
317
    def _probe(self):
 
318
        if CaseInsCasePresFilenameFeature.available():
 
319
            return False
 
320
        elif CaseInsensitiveFilesystemFeature.available():
 
321
            return False
 
322
        else:
 
323
            return True
 
324
 
 
325
    def feature_name(self):
 
326
        return 'case-sensitive filesystem'
 
327
 
 
328
# new coding style is for feature instances to be lowercase
 
329
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
 
330
 
 
331
 
 
332
class _NotRunningAsRoot(Feature):
 
333
 
 
334
    def _probe(self):
 
335
        try:
 
336
            uid = os.getuid()
 
337
        except AttributeError:
 
338
            # If there is no uid, chances are there is no root either
 
339
            return True
 
340
        return uid != 0
 
341
 
 
342
    def feature_name(self):
 
343
        return 'Not running as root'
 
344
 
 
345
 
 
346
not_running_as_root = _NotRunningAsRoot()
 
347
 
 
348
apport = ModuleAvailableFeature('apport')
 
349
gpgme = ModuleAvailableFeature('gpgme')
 
350
lzma = ModuleAvailableFeature('lzma')
 
351
meliae = ModuleAvailableFeature('meliae.scanner')
 
352
paramiko = ModuleAvailableFeature('paramiko')
 
353
pywintypes = ModuleAvailableFeature('pywintypes')
 
354
subunit = ModuleAvailableFeature('subunit')
 
355
testtools = ModuleAvailableFeature('testtools')
 
356
 
 
357
compiled_patiencediff_feature = ModuleAvailableFeature(
 
358
    'breezy._patiencediff_c')
 
359
lsprof_feature = ModuleAvailableFeature('breezy.lsprof')
 
360
 
 
361
 
 
362
class _BackslashDirSeparatorFeature(Feature):
 
363
 
 
364
    def _probe(self):
 
365
        try:
 
366
            os.lstat(os.getcwd() + '\\')
 
367
        except OSError:
 
368
            return False
 
369
        else:
 
370
            return True
 
371
 
 
372
    def feature_name(self):
 
373
        return "Filesystem treats '\\' as a directory separator."
 
374
 
 
375
backslashdir_feature = _BackslashDirSeparatorFeature()
 
376
 
 
377
 
 
378
class _ChownFeature(Feature):
 
379
    """os.chown is supported"""
 
380
 
 
381
    def _probe(self):
 
382
        return os.name == 'posix' and hasattr(os, 'chown')
 
383
 
 
384
chown_feature = _ChownFeature()
 
385
 
 
386
 
 
387
class ExecutableFeature(Feature):
 
388
    """Feature testing whether an executable of a given name is on the PATH."""
 
389
 
 
390
    def __init__(self, name):
 
391
        super(ExecutableFeature, self).__init__()
 
392
        self.name = name
 
393
        self._path = None
 
394
 
 
395
    @property
 
396
    def path(self):
 
397
        # This is a property, so accessing path ensures _probe was called
 
398
        self.available()
 
399
        return self._path
 
400
 
 
401
    def _probe(self):
 
402
        self._path = osutils.find_executable_on_path(self.name)
 
403
        return self._path is not None
 
404
 
 
405
    def feature_name(self):
 
406
        return '%s executable' % self.name
 
407
 
 
408
 
 
409
bash_feature = ExecutableFeature('bash')
 
410
diff_feature = ExecutableFeature('diff')
 
411
sed_feature = ExecutableFeature('sed')
 
412
msgmerge_feature = ExecutableFeature('msgmerge')
 
413
 
 
414
 
 
415
class _PosixPermissionsFeature(Feature):
31
416
 
32
417
    def _probe(self):
33
418
        def has_perms():
34
 
            # create temporary file and check if specified perms are maintained.
35
 
            import tempfile
36
 
 
 
419
            # Create temporary file and check if specified perms are
 
420
            # maintained.
37
421
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
38
422
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
39
423
            fd, name = f
40
424
            os.close(fd)
41
 
            os.chmod(name, write_perms)
 
425
            osutils.chmod_if_possible(name, write_perms)
42
426
 
43
 
            read_perms = os.stat(name).st_mode & 0777
 
427
            read_perms = os.stat(name).st_mode & 0o777
44
428
            os.unlink(name)
45
429
            return (write_perms == read_perms)
46
430
 
53
437
posix_permissions_feature = _PosixPermissionsFeature()
54
438
 
55
439
 
56
 
class _ChownFeature(tests.Feature):
57
 
    """os.chown is supported"""
58
 
 
59
 
    def _probe(self):
60
 
        return os.name == 'posix' and hasattr(os, 'chown')
61
 
 
62
 
chown_feature = _ChownFeature()
63
 
 
 
440
class _StraceFeature(Feature):
 
441
 
 
442
    def _probe(self):
 
443
        try:
 
444
            proc = subprocess.Popen(['strace'],
 
445
                stderr=subprocess.PIPE,
 
446
                stdout=subprocess.PIPE)
 
447
            proc.communicate()
 
448
            return True
 
449
        except OSError as e:
 
450
            if e.errno == errno.ENOENT:
 
451
                # strace is not installed
 
452
                return False
 
453
            else:
 
454
                raise
 
455
 
 
456
    def feature_name(self):
 
457
        return 'strace'
 
458
 
 
459
 
 
460
strace_feature = _StraceFeature()
 
461
 
 
462
 
 
463
class _AttribFeature(Feature):
 
464
 
 
465
    def _probe(self):
 
466
        if (sys.platform not in ('cygwin', 'win32')):
 
467
            return False
 
468
        try:
 
469
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
 
470
        except OSError as e:
 
471
            return False
 
472
        return (0 == proc.wait())
 
473
 
 
474
    def feature_name(self):
 
475
        return 'attrib Windows command-line tool'
 
476
 
 
477
 
 
478
AttribFeature = _AttribFeature()
 
479
 
 
480
 
 
481
class Win32Feature(Feature):
 
482
    """Feature testing whether we're running selftest on Windows
 
483
    or Windows-like platform.
 
484
    """
 
485
 
 
486
    def _probe(self):
 
487
        return sys.platform == 'win32'
 
488
 
 
489
    def feature_name(self):
 
490
        return "win32 platform"
 
491
 
 
492
 
 
493
win32_feature = Win32Feature()
 
494
 
 
495
 
 
496
class _ColorFeature(Feature):
 
497
 
 
498
    def _probe(self):
 
499
        from breezy._termcolor import allow_color
 
500
        return allow_color()
 
501
 
 
502
    def feature_name(self):
 
503
        return "Terminal supports color."
 
504
 
 
505
ColorFeature = _ColorFeature()