← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/features.py

  • Committer: John Arbash Meinel
  • Date: 2008-08-22 21:11:25 UTC
  • mto: This revision was merged to the branch mainline in revision 3653.
  • Revision ID: john@arbash-meinel.com-20080822211125-p9bmwrug1j4ann6d
Shrink the page size so that the three_level and iter_all
tests don't have to use so many keys to get a three-level index.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/features.py
1
 
# Copyright (C) 2009, 2010, 2011 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
"""A collection of commonly used 'Features' to optionally run tests.
18
 
"""
19
 
 
20
 
import os
21
 
import subprocess
22
 
import stat
23
 
import sys
24
 
import tempfile
25
 
 
26
 
from bzrlib 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 bzrlib 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 bzrlib 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 bzrlib 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
 
pycurl = ModuleAvailableFeature('pycurl')
354
 
pywintypes = ModuleAvailableFeature('pywintypes')
355
 
subunit = ModuleAvailableFeature('subunit')
356
 
testtools = ModuleAvailableFeature('testtools')
357
 
 
358
 
compiled_patiencediff_feature = ModuleAvailableFeature(
359
 
    'bzrlib._patiencediff_c')
360
 
lsprof_feature = ModuleAvailableFeature('bzrlib.lsprof')
361
 
 
362
 
 
363
 
class _BackslashDirSeparatorFeature(Feature):
364
 
 
365
 
    def _probe(self):
366
 
        try:
367
 
            os.lstat(os.getcwd() + '\\')
368
 
        except OSError:
369
 
            return False
370
 
        else:
371
 
            return True
372
 
 
373
 
    def feature_name(self):
374
 
        return "Filesystem treats '\\' as a directory separator."
375
 
 
376
 
backslashdir_feature = _BackslashDirSeparatorFeature()
377
 
 
378
 
 
379
 
class _ChownFeature(Feature):
380
 
    """os.chown is supported"""
381
 
 
382
 
    def _probe(self):
383
 
        return os.name == 'posix' and hasattr(os, 'chown')
384
 
 
385
 
chown_feature = _ChownFeature()
386
 
 
387
 
 
388
 
class ExecutableFeature(Feature):
389
 
    """Feature testing whether an executable of a given name is on the PATH."""
390
 
 
391
 
    def __init__(self, name):
392
 
        super(ExecutableFeature, self).__init__()
393
 
        self.name = name
394
 
        self._path = None
395
 
 
396
 
    @property
397
 
    def path(self):
398
 
        # This is a property, so accessing path ensures _probe was called
399
 
        self.available()
400
 
        return self._path
401
 
 
402
 
    def _probe(self):
403
 
        self._path = osutils.find_executable_on_path(self.name)
404
 
        return self._path is not None
405
 
 
406
 
    def feature_name(self):
407
 
        return '%s executable' % self.name
408
 
 
409
 
 
410
 
bash_feature = ExecutableFeature('bash')
411
 
diff_feature = ExecutableFeature('diff')
412
 
sed_feature = ExecutableFeature('sed')
413
 
msgmerge_feature = ExecutableFeature('msgmerge')
414
 
 
415
 
 
416
 
class _PosixPermissionsFeature(Feature):
417
 
 
418
 
    def _probe(self):
419
 
        def has_perms():
420
 
            # Create temporary file and check if specified perms are
421
 
            # maintained.
422
 
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
423
 
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
424
 
            fd, name = f
425
 
            os.close(fd)
426
 
            osutils.chmod_if_possible(name, write_perms)
427
 
 
428
 
            read_perms = os.stat(name).st_mode & 0777
429
 
            os.unlink(name)
430
 
            return (write_perms == read_perms)
431
 
 
432
 
        return (os.name == 'posix') and has_perms()
433
 
 
434
 
    def feature_name(self):
435
 
        return 'POSIX permissions support'
436
 
 
437
 
 
438
 
posix_permissions_feature = _PosixPermissionsFeature()
439
 
 
440
 
 
441
 
class _StraceFeature(Feature):
442
 
 
443
 
    def _probe(self):
444
 
        try:
445
 
            proc = subprocess.Popen(['strace'],
446
 
                stderr=subprocess.PIPE,
447
 
                stdout=subprocess.PIPE)
448
 
            proc.communicate()
449
 
            return True
450
 
        except OSError, e:
451
 
            if e.errno == errno.ENOENT:
452
 
                # strace is not installed
453
 
                return False
454
 
            else:
455
 
                raise
456
 
 
457
 
    def feature_name(self):
458
 
        return 'strace'
459
 
 
460
 
 
461
 
strace_feature = _StraceFeature()
462
 
 
463
 
 
464
 
class _AttribFeature(Feature):
465
 
 
466
 
    def _probe(self):
467
 
        if (sys.platform not in ('cygwin', 'win32')):
468
 
            return False
469
 
        try:
470
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
471
 
        except OSError, e:
472
 
            return False
473
 
        return (0 == proc.wait())
474
 
 
475
 
    def feature_name(self):
476
 
        return 'attrib Windows command-line tool'
477
 
 
478
 
 
479
 
AttribFeature = _AttribFeature()
480
 
 
481
 
 
482
 
class Win32Feature(Feature):
483
 
    """Feature testing whether we're running selftest on Windows
484
 
    or Windows-like platform.
485
 
    """
486
 
 
487
 
    def _probe(self):
488
 
        return sys.platform == 'win32'
489
 
 
490
 
    def feature_name(self):
491
 
        return "win32 platform"
492
 
 
493
 
 
494
 
win32_feature = Win32Feature()
495
 
 
496
 
 
497
 
class _ColorFeature(Feature):
498
 
 
499
 
    def _probe(self):
500
 
        from bzrlib._termcolor import allow_color
501
 
        return allow_color()
502
 
 
503
 
    def feature_name(self):
504
 
        return "Terminal supports color."
505
 
 
506
 
ColorFeature = _ColorFeature()