Пример #1
0
    def _make_tarball(self, target_name):
        tmpdir = self.mkdtemp()
        self.write_file([tmpdir, 'file1'], 'xxx')
        self.write_file([tmpdir, 'file2'], 'xxx')
        os.mkdir(os.path.join(tmpdir, 'sub'))
        self.write_file([tmpdir, 'sub', 'file3'], 'xxx')
        tmpdir2 = self.mkdtemp()
        unittest.skipUnless(splitdrive(tmpdir)[0] == splitdrive(tmpdir2)[0], 'source and target should be on same drive')
        base_name = os.path.join(tmpdir2, target_name)
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(splitdrive(base_name)[1], '.')
        finally:
            os.chdir(old_dir)

        tarball = base_name + '.tar.gz'
        self.assertTrue(os.path.exists(tarball))
        base_name = os.path.join(tmpdir2, target_name)
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(splitdrive(base_name)[1], '.', compress=None)
        finally:
            os.chdir(old_dir)

        tarball = base_name + '.tar'
        self.assertTrue(os.path.exists(tarball))
        return
    def _make_tarball(self, tmpdir, target_name, suffix, **kwargs):
        tmpdir2 = self.mkdtemp()
        unittest.skipUnless(splitdrive(tmpdir)[0] == splitdrive(tmpdir2)[0],
                            "source and target should be on same drive")

        base_name = os.path.join(tmpdir2, target_name)

        # working with relative paths to avoid tar warnings
        with change_cwd(tmpdir):
            make_tarball(splitdrive(base_name)[1], 'dist', **kwargs)

        # check if the compressed tarball was created
        tarball = base_name + suffix
        self.assertTrue(os.path.exists(tarball))
        self.assertEqual(self._tarinfo(tarball), self._created_files)
Пример #3
0
def skip_if_missing_requirements(*requirements):
    try:
        pkg_resources.require(*requirements)
        msg = ''
    except pkg_resources.DistributionNotFound:
        msg = 'Missing one or more requirements (%s)' % '|'.join(requirements)
    return skipUnless(msg == '', msg)
Пример #4
0
def make_reviewed(fn):
    """
    Just setting the WIDGY_MEZZANINE_SITE is not enough during tests, because
    WidgyPage.root_node has been set to point to VersionTracker.  We have to
    manually point it to ReviewedVersionTracker.  We do this only in tests
    because on a normal run, you are never going to be changing what models a
    ForeignKey points to (I would hope).
    """
    from widgy.contrib.widgy_mezzanine.admin import publish_page_on_approve

    site = reviewed_widgy_site
    rel = WidgyPage._meta.get_field('root_node').rel
    old_model = rel.model
    dispatch_uid = str(uuid.uuid4())

    fn = override_settings(WIDGY_MEZZANINE_SITE=site)(fn)
    fn = skipUnless(REVIEW_QUEUE_INSTALLED, 'review_queue is not installed')(fn)

    def up():
        # BBB Django 1.8 compatiblity
        if django.VERSION < (1, 9):
            rel.to = site.get_version_tracker_model()
        else:
            rel.model = site.get_version_tracker_model()
        post_save.connect(publish_page_on_approve,
                          sender=site.get_version_tracker_model().commit_model,
                          dispatch_uid=dispatch_uid)

    def down():
        # BBB Django 1.8 compatiblity
        if django.VERSION < (1, 9):
            rel.to = old_model
        else:
            rel.model = old_model
        post_save.disconnect(dispatch_uid=dispatch_uid)

    if isinstance(fn, type):
        old_pre_setup = fn._pre_setup
        old_post_teardown = fn._post_teardown

        def _pre_setup(self):
            up()
            old_pre_setup(self)

        def _post_teardown(self):
            old_post_teardown(self)
            down()

        fn._pre_setup = _pre_setup
        fn._post_teardown = _post_teardown

        return fn
    else:
        def change_foreign_key(*args, **kwargs):
            up()
            try:
                return fn(*args, **kwargs)
            finally:
                down()
        return change_foreign_key
Пример #5
0
def create_simple_test_method(validator, expected, value, num):
    if expected is not None and issubclass(expected, Exception):
        test_mask = 'test_%s_raises_error_%d'

        def test_func(self):
            # assertRaises not used, so as to be able to produce an error message
            # containing the tested value
            try:
                validator(value)
            except expected:
                pass
            else:
                self.fail("%s not raised when validating '%s'" % (
                    expected.__name__, value))
    else:
        test_mask = 'test_%s_%d'

        def test_func(self):
            try:
                self.assertEqual(expected, validator(value))
            except ValidationError as e:
                self.fail("Validation of '%s' failed. Error message was: %s" % (
                    value, str(e)))
    if isinstance(validator, types.FunctionType):
        val_name = validator.__name__
    else:
        val_name = validator.__class__.__name__
    test_name = test_mask % (val_name, num)
    if validator is validate_image_file_extension:
        SKIP_MSG = "Pillow is required to test validate_image_file_extension"
        test_func = skipUnless(PILLOW_IS_INSTALLED, SKIP_MSG)(test_func)
    return test_name, test_func
Пример #6
0
 def add_test_based_on_test_class(class_, **attr):
     attr.update(create_storage=create_storage)
     new_class = class_.__class__(
         prefix + class_.__name__, (class_, ),
         attr,
         )
     new_class = unittest.skipUnless(storage_is_available, "Storage not available")(new_class)
     suite.addTest(unittest.makeSuite(new_class))
Пример #7
0
def skipUnlessGit(test_item):
    '''Decorator that skips test outside git repo.

    There are very few tests that an be run only in git. One example is
    correctness of example code that won't get included in RPM.
    ''' # pylint: disable=invalid-name

    return unittest.skipUnless(in_git, 'outside git tree')(test_item)
Пример #8
0
def skip_unless_master(func_or_class):
    """
    Only run the decorated test for code on master or destined for master.

    Use this to skip tests that we expect to fail on a named release branch.
    Please use carefully!
    """
    return unittest.skipUnless(RELEASE_LINE == "master", "Test often fails on named releases")(func_or_class)
Пример #9
0
def skipUnlessDom0(test_item):
    '''Decorator that skips test outside dom0.

    Some tests (especially integration tests) have to be run in more or less
    working dom0. This is checked by connecting to libvirt.
    ''' # pylint: disable=invalid-name

    return unittest.skipUnless(in_dom0, 'outside dom0')(test_item)
Пример #10
0
def skipUnlessEnv(varname):
    '''Decorator generator for skipping tests without environment variable set.

    Some tests require working X11 display, like those using GTK library, which
    segfaults without connection to X.
    Other require their own, custom variables.
    '''

    return unittest.skipUnless(os.getenv(varname), 'no {} set'.format(varname))
Пример #11
0
def requires_docker_image(image_name):
    """
    Mark a test as requiring a Docker image to run.
    """

    return unittest.skipUnless(
        docker_image_available(image_name),
        "Docker image {0} is required.".format(image_name)
    )
Пример #12
0
def skip_unless_pacemaker_features(version_tuple, feature):
    return skipUnless(
        is_minimum_pacemaker_features(*version_tuple),
        "Pacemaker must support feature set version {version} to test {feature}"
            .format(
                version=format_version(version_tuple),
                feature=feature
            )
    )
Пример #13
0
    def get_installed_locales(self, codes, msg=None):
        def normalize(code):
            # OS X and Ubuntu (at the very least) differ slightly in locale code formatting
            return code.strip().replace("-", "").lower()

        try:
            installed_codes = dict(((normalize(code), code) for
                                    code in subprocess.check_output(["locale", "-a"]).split()))
        except (subprocess.CalledProcessError, OSError):
            raise unittest.SkipTest("locale command not available, cannot test")

        if msg is None:
            msg = "One of %s tested locales is not installed" % (codes,)
        available_codes = []
        for code in codes:
            if normalize(code) in installed_codes:
                available_codes.append(installed_codes[normalize(code)])
        unittest.skipUnless(available_codes, msg)
        return available_codes
Пример #14
0
 def skip_if_not_supported(y):
     msg = "strftime() is limited to [1; 9999] with Visual Studio"
     # Check that it doesn't crash for year > 9999
     try:
         time.strftime('%Y', (y,) + (0,) * 8)
     except ValueError:
         cond = False
     else:
         cond = True
     return unittest.skipUnless(cond, msg)
Пример #15
0
def skipUnlessImported(module, obj):
    import importlib
    try:
        m = importlib.import_module(module)
    except ImportError:
        m = None
    return unittest.skipUnless(
        obj in dir(m),
        "Skipping test because {} could not be imported from {}".format(
            obj, module))
Пример #16
0
 def _wrapper(*args, **kwargs):
     task = args[0].task
     task_args = inspect.getargs(task.func_code).args
     if isinstance(param, str):
         condition = param in task_args
         reason = "%s doesn't have parameter '%s'" % (task.__name__, param)
     else:
         # should be a list
         condition = all([p in task_args for p in param])
         reason = "%s doesn't have parameter %s" % (task.__name__, map(lambda x: "'" + str(x) + "'", param))
     return unittest.skipUnless(condition, reason)(func)(*args, **kwargs)
Пример #17
0
def dont_run_with_thread(obj):
    '''Decorator for disabling process based test cases when the test suite
    runs in threading, rather than processing, mode.
    '''
    actor = pulsar.get_actor()
    if actor:
        d = unittest.skipUnless(actor.cfg.concurrency == 'process',
                                'Run only when concurrency is process')
        return d(obj)
    else:
        return obj
Пример #18
0
    def test_make_tarball(self):
        # creating something to tar
        tmpdir = self.mkdtemp()
        self.write_file([tmpdir, "file1"], "xxx")
        self.write_file([tmpdir, "file2"], "xxx")
        os.mkdir(os.path.join(tmpdir, "sub"))
        self.write_file([tmpdir, "sub", "file3"], "xxx")

        tmpdir2 = self.mkdtemp()
        # force shutil to create the directory
        os.rmdir(tmpdir2)
        unittest.skipUnless(
            splitdrive(tmpdir)[0] == splitdrive(tmpdir2)[0], "source and target should be on same drive"
        )

        base_name = os.path.join(tmpdir2, "archive")

        # working with relative paths to avoid tar warnings
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            _make_tarball(splitdrive(base_name)[1], ".")
        finally:
            os.chdir(old_dir)

        # check if the compressed tarball was created
        tarball = base_name + ".tar.gz"
        self.assertTrue(os.path.exists(tarball))

        # trying an uncompressed one
        base_name = os.path.join(tmpdir2, "archive")
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            _make_tarball(splitdrive(base_name)[1], ".", compress=None)
        finally:
            os.chdir(old_dir)
        tarball = base_name + ".tar"
        self.assertTrue(os.path.exists(tarball))
Пример #19
0
def skip_unless_pacemaker_version(version_tuple, feature):
    current_version = get_current_pacemaker_version()
    return skipUnless(
        is_version_sufficient(current_version, version_tuple),
        (
            "Pacemaker version is too old (current: {current_version},"
            " must be >= {minimal_version}) to test {feature}"
        ).format(
            current_version=format_version(current_version),
            minimal_version=format_version(version_tuple),
            feature=feature
        )
    )
Пример #20
0
def skipUnless(condition, reason):
    """
    Skip a test unless the condition is true.
    """
    if hasattr(condition, '__call__'):
        def decorator(test_item):
            test_item.__unittest_async_skip_unless__ = condition
            test_item.__unittest_skip_why__ = reason
            return test_item

        return decorator
    else:
        return unittest.skipUnless(condition, reason)
Пример #21
0
def django_hosts_installed_setup(func):
    func = override_settings(
        DEFAULT_HOST='default',
        ROOT_HOSTCONF='tenancy.tests.hosts',
        MIDDLEWARE_CLASSES=(
            'django_hosts.middleware.HostsMiddleware',
            'tenancy.middleware.TenantHostMiddleware'
        )
    )(func)
    return skipUnless(
        django_hosts,
        'django-hosts is not installed.'
    )(func)
Пример #22
0
    def test_make_tarball(self):
        # creating something to tar
        tmpdir = self.mkdtemp()
        write_file((tmpdir, 'file1'), 'xxx')
        write_file((tmpdir, 'file2'), 'xxx')
        os.mkdir(os.path.join(tmpdir, 'sub'))
        write_file((tmpdir, 'sub', 'file3'), 'xxx')

        tmpdir2 = self.mkdtemp()
        # force shutil to create the directory
        os.rmdir(tmpdir2)
        unittest.skipUnless(splitdrive(tmpdir)[0] == splitdrive(tmpdir2)[0],
                            "source and target should be on same drive")

        base_name = os.path.join(tmpdir2, 'archive')

        # working with relative paths to avoid tar warnings
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            _make_tarball(splitdrive(base_name)[1], '.')
        finally:
            os.chdir(old_dir)

        # check if the compressed tarball was created
        tarball = base_name + '.tar.gz'
        self.assertTrue(os.path.exists(tarball))

        # trying an uncompressed one
        base_name = os.path.join(tmpdir2, 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            _make_tarball(splitdrive(base_name)[1], '.', compress=None)
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar'
        self.assertTrue(os.path.exists(tarball))
Пример #23
0
def requires_tcl(*version):
    if len(version) <= 2:
        return unittest.skipUnless(tcl_version >= version,
            'requires Tcl version >= ' + '.'.join(map(str, version)))

    def deco(test):
        @functools.wraps(test)
        def newtest(self):
            if get_tk_patchlevel() < (8, 6, 5):
                self.skipTest('requires Tcl version >= ' +
                                '.'.join(map(str, get_tk_patchlevel())))
            test(self)
        return newtest
    return deco
Пример #24
0
def django_hosts_installed_setup(func):
    func = override_settings(
        DEFAULT_HOST='default',
        ROOT_HOSTCONF='tests.hosts',
        **{MIDDLEWARE_SETTING: [
            'django_hosts.middleware.HostsRequestMiddleware',
            'tenancy.middleware.TenantHostMiddleware',
            'django_hosts.middleware.HostsResponseMiddleware',
        ]}
    )(func)
    return skipUnless(
        django_hosts,
        'django-hosts is not installed.'
    )(func)
Пример #25
0
 def wrapper(*args, **kwargs):
     config = get_blockdevice_config()
     configured_backend = config.pop('backend')
     skipper = skipUnless(
         configured_backend == required_backend,
         'The backend in the supplied configuration '
         'is not suitable for this test. '
         'Found: {!r}. Required: {!r}.'.format(
             configured_backend, required_backend
         )
     )
     decorated_object = skipper(undecorated_object)
     result = decorated_object(*args, **kwargs)
     return result
Пример #26
0
def with_resolwe_host(wrapped_method, instance, args, kwargs):
    """Decorate unit test to give it access to a live Resolwe host.

    This is a slightly modified version of Resolwe's
    :func:`~resolwe.test.utils.with_resolwe_host` decorator which skips
    the decorated tests on non-Linux systems since accessing live
    Resolwe host from a Docker container on non-Linux systems is not
    possible yet.

    """
    return unittest.skipUnless(
        sys.platform.startswith('linux'),
        "Accessing live Resolwe host from a Docker container on non-Linux systems is not possible "
        "yet."
    )(resolwe_with_resolwe_host)(wrapped_method)(*args, **kwargs)
    def _make_tarball(self, target_name):
        # creating something to tar
        tmpdir = self.mkdtemp()
        self.write_file([tmpdir, 'file1'], 'xxx')
        self.write_file([tmpdir, 'file2'], 'xxx')
        os.mkdir(os.path.join(tmpdir, 'sub'))
        self.write_file([tmpdir, 'sub', 'file3'], 'xxx')

        tmpdir2 = self.mkdtemp()
        unittest.skipUnless(splitdrive(tmpdir)[0] == splitdrive(tmpdir2)[0],
                            "Source and target should be on same drive")

        base_name = os.path.join(tmpdir2, target_name)

        # working with relative paths to avoid tar warnings
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(splitdrive(base_name)[1], '.')
        finally:
            os.chdir(old_dir)

        # check if the compressed tarball was created
        tarball = base_name + '.tar.gz'
        self.assertTrue(os.path.exists(tarball))

        # trying an uncompressed one
        base_name = os.path.join(tmpdir2, target_name)
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(splitdrive(base_name)[1], '.', compress=None)
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar'
        self.assertTrue(os.path.exists(tarball))
Пример #28
0
Файл: skip.py Проект: google/grr
def Unless(condition, reason):
  """A decorator that skips test evaluation if the condition dot not hold.

  See documentation for the `If` decorator for more information.

  Args:
    condition: If false, the test is going to be skipped.
    reason: A reason why the test needed to be skipped.

  Returns:
    A decorator that can be applied to test method or classes.
  """
  if callable(condition):
    return _UnlessLazy(condition, reason)
  else:
    return unittest.skipUnless(condition, reason)
Пример #29
0
def make_image_test(name, img, expected_root=None, expected_options=None,
                    *extra_methods):
    """Test inspection of an image"""

    def setUp(self):
        self.img = image_for(img)
        self.img.converter.inspect()

    def testInspect(self):
        inspected = ET.fromstring(self.img.converter.inspect())

        root = inspected.xpath(u"/guestconv/root[@name='{root}']"
                               .format(root=expected_root))
        self.assertEqual(len(root), 1,
                        u'Expected to find root: {expected}\n{xml}'
                        .format(expected=expected_root,
                                xml=ET.tostring(inspected)))
        root = root[0]

        options = root.xpath(u'options')
        self.assertEqual(len(options), 1,
                        u'No options in returned inspection xml')
        options = options[0]

        for name in expected_options:
            values = expected_options[name]

            option = options.xpath(u"option[@name='{}']".format(name))
            self.assertEqual(len(option), 1, u'No {} option'.format(name))
            option = option[0]

            for value in values:
                v = option.xpath(u"value[. = '{}']".format(value))
                self.assertEqual(len(v), 1,
                                u'value {} not found for option {}'.
                                format(value, name))

    methods = { 'setUp': setUp }
    if expected_root is not None and expected_options is not None:
        methods['testInspect'] = testInspect

    for method_set in extra_methods:
        methods.update(method_set)

    return unittest.skipUnless(os.path.exists(img),
                               '{img} does not exist'.format(img=img))(
        type(name, (unittest.TestCase,), methods))
Пример #30
0
def skip_unless_path_separator_matches(func):
    if not PLATFORM_OS:
        return unittest.skip(
            'this test uses path manipulation, but we cannot detect the OS '
            'targeted by the configuration so the path separator is unknown.'
        )(func)
    if PLATFORM_OS == 'windows':
        target_separator = '\\'
    else:
        target_separator = '/'
    return unittest.skipUnless(
        os.path.sep == target_separator,
        reason=(
            'this test uses path manipulation, but the configuration targets '
            'an OS with a different path separator than your system.'
        )
    )(func)
Пример #31
0
def skipUnlessTorch(testfn, reason='pytorch is not installed'):
    """Decorate a test to skip if torch is not installed."""
    return unittest.skipUnless(TORCH_AVAILABLE, reason)(testfn)
Пример #32
0
def skipUnlessBPE(testfn, reason='Test requires a GPU'):
    """Decorate a test to skip if BPE is not installed."""
    return unittest.skipUnless(BPE_INSTALLED, reason)(testfn)
Пример #33
0
def skipUnlessIronPython():
    """Skips the test unless currently running on IronPython"""
    return unittest.skipUnless(is_cli, 'IronPython specific test')
Пример #34
0
    """
    try:
        socket.socket(family=socket.AF_UNIX).connect(DOCKER_SOCKET_PATH)
    except socket.error as e:
        if e.errno == errno.EACCES:
            return False
        if e.errno == errno.ENOENT:
            # Docker is not installed
            return False
        raise
    else:
        return True


if_docker_configured = skipUnless(
    docker_accessible(), "User '{}' does not have permission "
    "to access the Docker server socket '{}'".format(
        pwd.getpwuid(os.geteuid()).pw_name, DOCKER_SOCKET_PATH))


def wait_for_unit_state(docker_client, unit_name, expected_activation_states):
    """
    Wait until a unit is in the requested state.

    :param docker_client: A ``DockerClient`` instance.
    :param unicode unit_name: The name of the unit.
    :param expected_activation_states: Activation states to wait for.

    :return: ``Deferred`` that fires when required state has been reached.
    """
    def is_in_states(units):
        for unit in units:
Пример #35
0
import tempfile
from test.support import (captured_stdout, captured_stderr, requires_zlib,
                          can_symlink, EnvironmentVarGuard, rmtree)
import threading
import unittest
import venv

try:
    import ctypes
except ImportError:
    ctypes = None

# Platforms that set sys._base_executable can create venvs from within
# another venv, so no need to skip tests that require venv.create().
requireVenvCreate = unittest.skipUnless(
    hasattr(sys, '_base_executable') or sys.prefix == sys.base_prefix,
    'cannot run venv.create from within a venv on this platform')


def check_output(cmd, encoding=None):
    p = subprocess.Popen(cmd,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         encoding=encoding)
    out, err = p.communicate()
    if p.returncode:
        raise subprocess.CalledProcessError(p.returncode, cmd, out, err)
    return out, err


class BaseTest(unittest.TestCase):
Пример #36
0
threading = test_support.import_module('threading')

HOST = test_support.HOST
PORT = 0

SUPPORTS_SSL = False
if hasattr(poplib, 'POP3_SSL'):
    import ssl

    SUPPORTS_SSL = True
    CERTFILE = os.path.join(
        os.path.dirname(__file__) or os.curdir, "keycert3.pem")
    CAFILE = os.path.join(
        os.path.dirname(__file__) or os.curdir, "pycacert.pem")

requires_ssl = skipUnless(SUPPORTS_SSL, 'SSL not supported')

# the dummy data returned by server when LIST and RETR commands are issued
LIST_RESP = b'1 1\r\n2 2\r\n3 3\r\n4 4\r\n5 5\r\n.\r\n'
RETR_RESP = b"""From: [email protected]\
\r\nContent-Type: text/plain\r\n\
MIME-Version: 1.0\r\n\
Subject: Dummy\r\n\
\r\n\
line1\r\n\
line2\r\n\
line3\r\n\
.\r\n"""


class DummyPOP3Handler(asynchat.async_chat):
Пример #37
0
HAS_ALARM = hasattr(signal, "alarm")

LONG_SELECT = 0.2
SHORT_SELECT = 0.01

# Tolerance values for timer/speed fluctuations.
TOLERANCE = 0.75

# Detect whether we're running on Travis or AppVeyor.  This
# is used to skip some verification points inside of tests to
# not randomly fail our CI due to wild timer/speed differences.
TRAVIS_CI = "TRAVIS" in os.environ
APPVEYOR = "APPVEYOR" in os.environ

skipUnlessHasSelector = skipUnless(selectors.HAS_SELECT,
                                   "Platform doesn't have a selector")
skipUnlessHasENOSYS = skipUnless(hasattr(errno, 'ENOSYS'),
                                 "Platform doesn't have errno.ENOSYS")
skipUnlessHasAlarm = skipUnless(hasattr(signal, 'alarm'),
                                "Platform doesn't have signal.alarm()")


def patch_select_module(testcase, *keep, **replace):
    """ Helper function that removes all selectors from the select module
    except those listed in *keep and **replace. Those in keep will be kept
    if they exist in the select module and those in replace will be patched
    with the value that is given regardless if they exist or not. Cleanup
    will restore previous state. This helper also resets the selectors module
    so that a call to DefaultSelector() will do feature detection again. """
    selectors._DEFAULT_SELECTOR = None
    for s in ['select', 'poll', 'epoll', 'kqueue']:
Пример #38
0
URL_LIB_COMMIT = URL_LIB_DETAIL + 'commit/'  # Commit (POST) or revert (DELETE) all pending changes to this library
URL_LIB_BLOCKS = URL_LIB_DETAIL + 'blocks/'  # Get the list of XBlocks in this library, or add a new one
URL_LIB_TEAM = URL_LIB_DETAIL + 'team/'  # Get the list of users/groups authorized to use this library
URL_LIB_TEAM_USER = URL_LIB_TEAM + 'user/{username}/'  # Add/edit/remove a user's permission to use this library
URL_LIB_TEAM_GROUP = URL_LIB_TEAM + 'group/{group_name}/'  # Add/edit/remove a group's permission to use this library
URL_LIB_BLOCK = URL_PREFIX + 'blocks/{block_key}/'  # Get data about a block, or delete it
URL_LIB_BLOCK_OLX = URL_LIB_BLOCK + 'olx/'  # Get or set the OLX of the specified XBlock
URL_LIB_BLOCK_ASSETS = URL_LIB_BLOCK + 'assets/'  # List the static asset files of the specified XBlock
URL_LIB_BLOCK_ASSET_FILE = URL_LIB_BLOCK + 'assets/{file_name}'  # Get, delete, or upload a specific static asset file

URL_BLOCK_RENDER_VIEW = '/api/xblock/v2/xblocks/{block_key}/view/{view_name}/'
URL_BLOCK_GET_HANDLER_URL = '/api/xblock/v2/xblocks/{block_key}/handler_url/{handler_name}/'
URL_BLOCK_METADATA_URL = '/api/xblock/v2/xblocks/{block_key}/'

# Decorator for tests that require blockstore
requires_blockstore = unittest.skipUnless(
    settings.RUN_BLOCKSTORE_TESTS, "Requires a running Blockstore server")


def elasticsearch_test(func):
    """
    Decorator for tests which connect to elasticsearch when needed
    """
    # This is disabled by default. Set to True if the elasticsearch engine is needed to test parts of code.
    if settings.ENABLE_ELASTICSEARCH_FOR_TESTS:
        func = override_settings(
            SEARCH_ENGINE="search.elastic.ElasticSearchEngine")(func)
        func = override_settings(
            ELASTIC_SEARCH_CONFIG=[{
                'use_ssl': settings.TEST_ELASTICSEARCH_USE_SSL,
                'host': settings.TEST_ELASTICSEARCH_HOST,
                'port': settings.TEST_ELASTICSEARCH_PORT,
Пример #39
0
import socketserver

import test.support
from test.support import reap_children, verbose
from test.support import os_helper
from test.support import socket_helper
from test.support import threading_helper


test.support.requires("network")

TEST_STR = b"hello world\n"
HOST = socket_helper.HOST

HAVE_UNIX_SOCKETS = hasattr(socket, "AF_UNIX")
requires_unix_sockets = unittest.skipUnless(HAVE_UNIX_SOCKETS,
                                            'requires Unix sockets')
HAVE_FORKING = hasattr(os, "fork")
requires_forking = unittest.skipUnless(HAVE_FORKING, 'requires forking')

def signal_alarm(n):
    """Call signal.alarm when it exists (i.e. not on Windows)."""
    if hasattr(signal, 'alarm'):
        signal.alarm(n)

# Remember real select() to avoid interferences with mocking
_real_select = select.select

def receive(sock, n, timeout=test.support.SHORT_TIMEOUT):
    r, w, x = _real_select([sock], [], [], timeout)
    if sock in r:
        return sock.recv(n)
Пример #40
0
class Only:
    """
    Limit tests to given devices
    """

    softhsm2 = unittest.skipUnless(Is.softhsm2, "SoftHSMv2 only")
Пример #41
0
def skip_if_no_cuda(testfn, reason="Cuda is not available"):
    return unittest.skipUnless(CUDA_AVAILBLE, reason)(testfn)
Пример #42
0
def skip_if_no_network(testfn, reason="Network is not available"):
    return unittest.skipUnless(NETWORK_AVAILABLE, reason)(testfn)
Пример #43
0
 def _impl(reason=None):
     if reason is None:
         if default_reason is None:
             raise ValueError('%s requires a reason for skipping.' % name)
         reason = default_reason
     return unittest.skipUnless(guard(), reason)
Пример #44
0
def skip_unless_lms(func):
    """
    Only run the decorated test in the LMS test suite
    """
    return skipUnless(settings.ROOT_URLCONF == 'lms.urls',
                      'Test only valid in LMS')(func)
Пример #45
0
from test import support
from test.support import _4G, bigmemtest, import_fresh_module
from http.client import HTTPException

# Were we compiled --with-pydebug or with #define Py_DEBUG?
COMPILED_WITH_PYDEBUG = hasattr(sys, 'gettotalrefcount')

c_hashlib = import_fresh_module('hashlib', fresh=['_hashlib'])
py_hashlib = import_fresh_module('hashlib', blocked=['_hashlib'])

try:
    import _blake2
except ImportError:
    _blake2 = None

requires_blake2 = unittest.skipUnless(_blake2, 'requires _blake2')

try:
    import _sha3
except ImportError:
    _sha3 = None

requires_sha3 = unittest.skipUnless(_sha3, 'requires _sha3')


def hexstr(s):
    assert isinstance(s, bytes), repr(s)
    h = "0123456789abcdef"
    r = ''
    for i in s:
        r += h[(i >> 4) & 0xF] + h[i & 0xF]
Пример #46
0
                validate_schema_agreement(node, is_upgraded)

    def compact_sstable(self, node, sstable):
        mbean = make_mbean('db', type='CompactionManager')
        with JolokiaAgent(node) as jmx:
            jmx.execute_method(mbean, 'forceUserDefinedCompaction', [sstable])

    def get_all_sstables(self, node):
        # note that node.get_sstables(...) only returns current version sstables
        keyspace_dirs = [
            os.path.join(node.get_path(), "data{0}".format(x), "test13294")
            for x in xrange(0, node.cluster.data_dir_count)
        ]
        files = []
        for d in keyspace_dirs:
            for f in glob.glob(d + "/*/*Data*"):
                files.append(f)
        return files


for path in build_upgrade_pairs():
    gen_class_name = TestForRegressions.__name__ + path.name
    assert_not_in(gen_class_name, globals())
    spec = {'UPGRADE_PATH': path, '__test__': True}

    upgrade_applies_to_env = RUN_STATIC_UPGRADE_MATRIX or path.upgrade_meta.matches_current_env_version_family
    globals()[gen_class_name] = skipUnless(upgrade_applies_to_env,
                                           'test not applicable to env.')(type(
                                               gen_class_name,
                                               (TestForRegressions, ), spec))
Пример #47
0
def skipUnlessGIMarshallingTests(func):
    return unittest.skipUnless(GIMarshallingTests,
                               "GIMarshallingTests missing")(func)
Пример #48
0
def define_skip_condition(flag: str, explanation: str):
    return unittest.skipUnless(
        os.environ.get(flag, 0) or os.environ.get("TEST_ALL", 0),
        explanation + f" Set `{flag}=1` or `TEST_ALL=1` to run.",
    )
Пример #49
0
import unittest
from test import support
import binascii
import copy
import pickle
import random
import sys
from test.support import bigmemtest, _1G, _4G, import_helper

zlib = import_helper.import_module('zlib')

requires_Compress_copy = unittest.skipUnless(
    hasattr(zlib.compressobj(), "copy"), 'requires Compress.copy()')
requires_Decompress_copy = unittest.skipUnless(
    hasattr(zlib.decompressobj(), "copy"), 'requires Decompress.copy()')


class VersionTestCase(unittest.TestCase):

    # TODO: RUSTPYTHON
    @unittest.expectedFailure
    def test_library_version(self):
        # Test that the major version of the actual library in use matches the
        # major version that we were compiled against. We can't guarantee that
        # the minor versions will match (even on the machine on which the module
        # was compiled), and the API is stable between minor versions, so
        # testing only the major versions avoids spurious failures.
        self.assertEqual(zlib.ZLIB_RUNTIME_VERSION[0], zlib.ZLIB_VERSION[0])


class ChecksumTestCase(unittest.TestCase):
Пример #50
0
from test.support import (captured_stdout, captured_stderr, requires_zlib,
                          can_symlink, EnvironmentVarGuard, rmtree,
                          import_module)
import unittest
import venv
from unittest.mock import patch

try:
    import ctypes
except ImportError:
    ctypes = None

# Platforms that set sys._base_executable can create venvs from within
# another venv, so no need to skip tests that require venv.create().
requireVenvCreate = unittest.skipUnless(
    sys.prefix == sys.base_prefix or sys._base_executable != sys.executable,
    'cannot run venv.create from within a venv on this platform')


def check_output(cmd, encoding=None):
    p = subprocess.Popen(cmd,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         encoding=encoding)
    out, err = p.communicate()
    if p.returncode:
        raise subprocess.CalledProcessError(p.returncode, cmd, out, err)
    return out, err


class BaseTest(unittest.TestCase):
Пример #51
0
from test import support
from test.support import findfile, run_unittest, TESTFN
TEST_XMLFILE = findfile('test.xml', subdir='xmltestdata')
TEST_XMLFILE_OUT = findfile('test.xml.out', subdir='xmltestdata')
try:
    TEST_XMLFILE.encode('utf-8')
    TEST_XMLFILE_OUT.encode('utf-8')
except UnicodeEncodeError:
    raise unittest.SkipTest('filename is not encodable to utf8')
supports_nonascii_filenames = True
if not os.path.supports_unicode_filenames:
    try:
        support.TESTFN_UNICODE.encode(support.TESTFN_ENCODING)
    except (UnicodeError, TypeError):
        supports_nonascii_filenames = False
requires_nonascii_filenames = unittest.skipUnless(
    supports_nonascii_filenames, 'Requires non-ascii filenames support')
ns_uri = 'http://www.python.org/xml-ns/saxtest/'


class XmlTestBase(unittest.TestCase):
    def verify_empty_attrs(self, attrs):
        self.assertRaises(KeyError, attrs.getValue, 'attr')
        self.assertRaises(KeyError, attrs.getValueByQName, 'attr')
        self.assertRaises(KeyError, attrs.getNameByQName, 'attr')
        self.assertRaises(KeyError, attrs.getQNameByName, 'attr')
        self.assertRaises(KeyError, attrs.__getitem__, 'attr')
        self.assertEqual(attrs.getLength(), 0)
        self.assertEqual(attrs.getNames(), [])
        self.assertEqual(attrs.getQNames(), [])
        self.assertEqual(len(attrs), 0)
        self.assertNotIn('attr', attrs)
Пример #52
0
import test.test_support as support
from test.test_support import findfile, run_unittest, TESTFN
import unittest

TEST_XMLFILE = findfile("test.xml", subdir="xmltestdata")
TEST_XMLFILE_OUT = findfile("test.xml.out", subdir="xmltestdata")

supports_unicode_filenames = True
if not os.path.supports_unicode_filenames:
    try:
        support.TESTFN_UNICODE.encode(support.TESTFN_ENCODING)
    except (AttributeError, UnicodeError, TypeError):
        # Either the file system encoding is None, or the file name
        # cannot be encoded in the file system encoding.
        supports_unicode_filenames = False
requires_unicode_filenames = unittest.skipUnless(
    supports_unicode_filenames, 'Requires unicode filenames support')

ns_uri = "http://www.python.org/xml-ns/saxtest/"


class XmlTestBase(unittest.TestCase):
    def verify_empty_attrs(self, attrs):
        self.assertRaises(KeyError, attrs.getValue, "attr")
        self.assertRaises(KeyError, attrs.getValueByQName, "attr")
        self.assertRaises(KeyError, attrs.getNameByQName, "attr")
        self.assertRaises(KeyError, attrs.getQNameByName, "attr")
        self.assertRaises(KeyError, attrs.__getitem__, "attr")
        self.assertEqual(attrs.getLength(), 0)
        self.assertEqual(attrs.getNames(), [])
        self.assertEqual(attrs.getQNames(), [])
        self.assertEqual(len(attrs), 0)
Пример #53
0
# -*- encoding:utf-8 -*-
from __future__ import (
    absolute_import, division, print_function, unicode_literals,
)

import sys
from contextlib import contextmanager
from unittest import skipUnless

from django.db import DEFAULT_DB_ALIAS, connection, connections
from django.test.utils import CaptureQueriesContext
from django.utils import six

requiresPython2 = skipUnless(six.PY2, "Python 2 only")


# Copied from Django 1.8
@contextmanager
def captured_output(stream_name):
    """Return a context manager used by captured_stdout/stdin/stderr
    that temporarily replaces the sys stream *stream_name* with a StringIO.

    Note: This function and the following ``captured_std*`` are copied
          from CPython's ``test.support`` module."""
    orig_stdout = getattr(sys, stream_name)
    setattr(sys, stream_name, six.StringIO())
    try:
        yield getattr(sys, stream_name)
    finally:
        setattr(sys, stream_name, orig_stdout)
Пример #54
0
    logger = logging.getLogger(logger_name)
    orig = getattr(logger, log_level)
    setattr(logger, log_level, replacement)
    try:
        yield calls
    finally:
        setattr(logger, log_level, orig)


# On OSes that don't provide tzset (Windows), we can't set the timezone
# in which the program runs. As a consequence, we must skip tests that
# don't enforce a specific timezone (with timezone.override or equivalent),
# or attempt to interpret naive datetimes in the default timezone.

requires_tz_support = skipUnless(
    TZ_SUPPORT,
    "This test relies on the ability to run a program in an arbitrary "
    "time zone, but your operating system isn't able to do that.")


@contextmanager
def extend_sys_path(*paths):
    """Context manager to temporarily add paths to sys.path."""
    _orig_sys_path = sys.path[:]
    sys.path.extend(paths)
    try:
        yield
    finally:
        sys.path = _orig_sys_path


@contextmanager
Пример #55
0
def skipUnlessGPU(testfn, reason='Test requires a GPU'):
    """Decorate a test to skip if no GPU is available."""
    return unittest.skipUnless(GPU_AVAILABLE, reason)(testfn)
Пример #56
0
def skipUnlessPathExists(path):
    return unittest.skipUnless(os.path.exists(path),
                               ('File or directory at path "%s" used in test is'
                                ' not available in the system' % path))
Пример #57
0
def skip_database():
    return unittest.skipUnless(os.environ.get('INTELMQ_TEST_DATABASES'),
                               'Skipping database tests.')
Пример #58
0
def requires_tcl(*version):
    return unittest.skipUnless(
        tcl_version >= version,
        'requires Tcl version >= ' + '.'.join(map(str, version)))
Пример #59
0
from decimal import Decimal
from test.test_support import run_unittest
import math
import numbers
import operator
import fractions
import unittest
from copy import copy, deepcopy
from cPickle import dumps, loads
F = fractions.Fraction
gcd = fractions.gcd

# decorator for skipping tests on non-IEEE 754 platforms
requires_IEEE_754 = unittest.skipUnless(
    float.__getformat__("double").startswith("IEEE"),
    "test requires IEEE 754 doubles")


class DummyFloat(object):
    """Dummy float class for testing comparisons with Fractions"""
    def __init__(self, value):
        if not isinstance(value, float):
            raise TypeError("DummyFloat can only be initialized from float")
        self.value = value

    def _richcmp(self, other, op):
        if isinstance(other, numbers.Rational):
            return op(F.from_float(self.value), other)
        elif isinstance(other, DummyFloat):
            return op(self.value, other.value)
Пример #60
0
# Some simple queue module tests, plus some failure conditions
# to ensure the Queue locks remain stable.
import itertools
import random
import threading
import time
import unittest
import weakref
from test import support
from test.support import import_helper
from test.support import threading_helper

py_queue = import_helper.import_fresh_module('queue', blocked=['_queue'])
c_queue = import_helper.import_fresh_module('queue', fresh=['_queue'])
need_c_queue = unittest.skipUnless(c_queue, "No _queue module found")

QUEUE_SIZE = 5


def qfull(q):
    return q.maxsize > 0 and q.qsize() == q.maxsize


# A thread to run a function that unclogs a blocked Queue.
class _TriggerThread(threading.Thread):
    def __init__(self, fn, args):
        self.fn = fn
        self.args = args
        self.startedEvent = threading.Event()
        threading.Thread.__init__(self)