def only_run_with_partitioned_database(cls):
"""
Only runs the test with the partitioned database settings.
"""
skip_unless = skipUnless(settings.USE_PARTITIONED_DATABASE,
'Only applicable if sharding is setup')
return skip_unless(partitioned(cls))
def only_run_with_partitioned_database(cls):
"""
Only runs the test with the partitioned database settings.
"""
skip_unless = skipUnless(
settings.USE_PARTITIONED_DATABASE, 'Only applicable if sharding is setup'
)
return skip_unless(partitioned(cls))
def _importorskip(modname, minversion=None):
try:
mod = importlib.import_module(modname)
has = True
if minversion is not None:
if LooseVersion(mod.__version__) < LooseVersion(minversion):
raise ImportError('Minimum version not satisfied')
except ImportError:
has = False
# TODO: use pytest.skipif instead of unittest.skipUnless
# Using `unittest.skipUnless` is a temporary workaround for pytest#568,
# wherein class decorators stain inherited classes.
# xref: xarray#1531, implemented in xarray #1557.
func = unittest.skipUnless(has, reason='requires {}'.format(modname))
return has, func
def _importorskip(modname, minversion=None):
try:
mod = importlib.import_module(modname)
has = True
if minversion is not None:
if LooseVersion(mod.__version__) < LooseVersion(minversion):
raise ImportError('Minimum version not satisfied')
except ImportError:
has = False
# TODO: use pytest.skipif instead of unittest.skipUnless
# Using `unittest.skipUnless` is a temporary workaround for pytest#568,
# wherein class decorators stain inherited classes.
# xref: xarray#1531, implemented in xarray #1557.
func = unittest.skipUnless(has, reason='requires {}'.format(modname))
return has, func
pass
elif "asyncore" in EVENT_LOOP_MANAGER:
from cassandra.io.asyncorereactor import AsyncoreConnection
connection_class = AsyncoreConnection
elif "twisted" in EVENT_LOOP_MANAGER:
from cassandra.io.twistedreactor import TwistedConnection
connection_class = TwistedConnection
elif "asyncio" in EVENT_LOOP_MANAGER:
from cassandra.io.asyncioreactor import AsyncioConnection
connection_class = AsyncioConnection
else:
try:
from cassandra.io.libevreactor import LibevConnection
connection_class = LibevConnection
except ImportError as e:
log.debug('Could not import LibevConnection, '
'using connection_class=None; '
'failed with error:\n {}'.format(
repr(e)
))
connection_class = None
def is_windows():
return "Windows" in platform.system()
notwindows = unittest.skipUnless(not is_windows(), "This test is not adequate for windows")
notpypy = unittest.skipUnless(not platform.python_implementation() == 'PyPy', "This tests is not suitable for pypy")
if "gevent" in EVENT_LOOP_MANAGER:
import gevent.monkey
gevent.monkey.patch_all()
from cassandra.io.geventreactor import GeventConnection
connection_class = GeventConnection
elif "eventlet" in EVENT_LOOP_MANAGER:
from eventlet import monkey_patch
monkey_patch()
from cassandra.io.eventletreactor import EventletConnection
connection_class = EventletConnection
elif "async" in EVENT_LOOP_MANAGER:
from cassandra.io.asyncorereactor import AsyncoreConnection
connection_class = AsyncoreConnection
elif "twisted" in EVENT_LOOP_MANAGER:
from cassandra.io.twistedreactor import TwistedConnection
connection_class = TwistedConnection
else:
try:
from cassandra.io.libevreactor import LibevConnection
connection_class = LibevConnection
except ImportError:
connection_class = None
MONKEY_PATCH_LOOP = bool(os.getenv('MONKEY_PATCH_LOOP', False))
notwindows = unittest.skipUnless(not "Windows" in platform.system(), "This test is not adequate for windows")
notpypy = unittest.skipUnless(not platform.python_implementation() == 'PyPy', "This tests is not suitable for pypy")
notmonkeypatch = unittest.skipUnless(MONKEY_PATCH_LOOP, "Skipping this test because monkey patching is required")
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
def local_decorator_creator():
if not CASSANDRA_IP.startswith("127.0.0."):
return unittest.skip('Tests only runs against local C*')
def _id_and_mark(f):
f.local = True
return _id_and_mark
local = local_decorator_creator()
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1,
'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(
PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(
PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
protocolv5 = unittest.skipUnless(
5 in get_supported_protocol_versions(),
'Protocol versions less than 5 are not supported')
greaterthancass20 = unittest.skipUnless(
CASSANDRA_VERSION >= Version('2.1'),
'Cassandra version 2.1 or greater required')
greaterthancass21 = unittest.skipUnless(
CASSANDRA_VERSION >= Version('2.2'),
'Cassandra version 2.2 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(
has_matplotlib, requires_matplotlib = _importorskip('matplotlib')
has_scipy, requires_scipy = _importorskip('scipy')
has_pydap, requires_pydap = _importorskip('pydap.client')
has_netCDF4, requires_netCDF4 = _importorskip('netCDF4')
has_h5netcdf, requires_h5netcdf = _importorskip('h5netcdf')
has_pynio, requires_pynio = _importorskip('Nio')
has_dask, requires_dask = _importorskip('dask')
has_bottleneck, requires_bottleneck = _importorskip('bottleneck')
has_rasterio, requires_rasterio = _importorskip('rasterio')
has_pathlib, requires_pathlib = _importorskip('pathlib')
# some special cases
has_scipy_or_netCDF4 = has_scipy or has_netCDF4
requires_scipy_or_netCDF4 = unittest.skipUnless(
has_scipy_or_netCDF4, reason='requires scipy or netCDF4')
if not has_pathlib:
has_pathlib, requires_pathlib = _importorskip('pathlib2')
if has_dask:
import dask
dask.set_options(get=dask.get)
try:
_SKIP_FLAKY = not pytest.config.getoption("--run-flaky")
_SKIP_NETWORK_TESTS = not pytest.config.getoption("--run-network-tests")
except (ValueError, AttributeError):
# Can't get config from pytest, e.g., because xarray is installed instead
# of being run from a development version (and hence conftests.py is not
# available). Don't run flaky tests.
_SKIP_FLAKY = True
if Version(CASSANDRA_VERSION) >= Version('2.2'):
return None
if Version(CASSANDRA_VERSION) >= Version('2.1'):
return 4
elif Version(CASSANDRA_VERSION) >= Version('2.0'):
return 3
else:
return None
default_protocol_version = get_default_protocol()
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
local = unittest.skipUnless(CASSANDRA_IP.startswith("127.0.0."),
'Tests only runs against local C*')
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1,
'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(
PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(
PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
protocolv5 = unittest.skipUnless(
5 in get_supported_protocol_versions(),
'Protocol versions less than 5 are not supported')
greaterthancass20 = unittest.skipUnless(
CASSANDRA_VERSION >= '2.1', 'Cassandra version 2.1 or greater required')
greaterthancass21 = unittest.skipUnless(
CASSANDRA_VERSION >= '2.2', 'Cassandra version 2.2 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(
log.info("Using DSE credentials file located at {0}".format(DSE_CRED))
CCM_KWARGS['dse_credentials_file'] = DSE_CRED
if CASSANDRA_VERSION >= '2.2':
default_protocol_version = 4
elif CASSANDRA_VERSION >= '2.1':
default_protocol_version = 3
elif CASSANDRA_VERSION >= '2.0':
default_protocol_version = 2
else:
default_protocol_version = 1
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1, 'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
greaterthancass20 = unittest.skipUnless(CASSANDRA_VERSION >= '2.1', 'Cassandra version 2.1 or greater required')
greaterthancass21 = unittest.skipUnless(CASSANDRA_VERSION >= '2.2', 'Cassandra version 2.2 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(CASSANDRA_VERSION >= '3.0', 'Cassandra version 3.0 or greater required')
lessthancass30 = unittest.skipUnless(CASSANDRA_VERSION < '3.0', 'Cassandra version less then 3.0 required')
dseonly = unittest.skipUnless(DSE_VERSION, "Test is only applicalbe to DSE clusters")
def wait_for_node_socket(node, timeout):
binary_itf = node.network_interfaces['binary']
if not common.check_socket_listening(binary_itf, timeout=timeout):
log.warn("Unable to connect to binary socket for node " + node.name)
else:
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Various utilities used in tests."""
import contextlib
import os
import tempfile
import shutil
import sys
import six
import unittest2
RunOnlyOnPython27 = unittest2.skipUnless(sys.version_info[:2] == (2, 7),
'Only runs in Python 2.7')
@contextlib.contextmanager
def TempDir(change_to=False):
if change_to:
original_dir = os.getcwd()
path = tempfile.mkdtemp()
try:
if change_to:
os.chdir(path)
yield path
finally:
if change_to:
os.chdir(original_dir)
shutil.rmtree(path)
import cassandra
_connections = {}
DEFAULT_KEYSPACE = 'cqlengine_test'
CQL_SKIP_EXECUTE = bool(os.getenv('CQL_SKIP_EXECUTE', False))
CASSANDRA_VERSION = "2.2.7"
PROTOCOL_VERSION = 4
cass_version = None
cql_version = None
log = logging.getLogger(__name__)
pypy = unittest.skipUnless(
platform.python_implementation() == "PyPy",
"Test is skipped unless it's on PyPy",
)
def get_server_versions():
"""
Probe system.local table to determine Cassandra and CQL version.
Returns a tuple of (cassandra_version, cql_version).
"""
global cass_version, cql_version
if cass_version is not None:
return (cass_version, cql_version)
c = Cluster()
s = c.connect()
import os
import sys
try:
import unittest2 as unittest
except ImportError:
import unittest
from rpaths import unicode, Path, PosixPath, WindowsPath
windows_only = unittest.skipUnless(issubclass(Path, WindowsPath),
"Only runs on Windows")
posix_only = unittest.skipUnless(issubclass(Path, PosixPath),
"Only runs on POSIX")
class TestConcrete(unittest.TestCase):
"""Tests for Path.
Because this tests the concrete Path, it needs to be run on both Windows
and POSIX to ensure everything is correct.
"""
def test_cwd(self):
"""Tests cwd, in_dir."""
cwd = os.getcwd()
if os.name == 'nt' and isinstance(cwd, bytes):
cwd = cwd.decode('mbcs')
elif os.name != 'nt' and isinstance(cwd, unicode):
cwd = cwd.encode(sys.getfilesystemencoding())
self.assertEqual(Path.cwd().path, cwd)
class TestGitWorkingCopy(unittest.TestCase, BaseTestWorkingCopy):
def setUp(self):
self.repository_path = os.path.abspath("../example_repositories/git")
os.symlink("%s/git" % self.repository_path, "%s/.git" % self.repository_path)
self.repos = GitRepository(self.repository_path)
self.tmpdir = tempfile.mkdtemp()
self.repos.checkout(self.tmpdir)
self.wc = GitWorkingCopy(self.tmpdir)
self.latest_version = "38598c93c7036a1c44bbb6075517243edfa88860"
self.previous_version = "3491ce1d9a66abc9d49d5844ee05167c6a854ad9"
def tearDown(self):
os.unlink("%s/.git" % self.repository_path)
shutil.rmtree(self.tmpdir)
TestGitWorkingCopy = unittest.skipUnless(have_git, "Could not import git")(TestGitWorkingCopy) # not using as class decorator for the sake of Python 2.5
#@unittest.skipUnless(have_pysvn, "Could not import pysvn")
class TestSubversionWorkingCopy(unittest.TestCase, BaseTestWorkingCopy):
def setUp(self):
self.repository_path = os.path.abspath("../example_repositories/subversion")
self.repos = SubversionRepository("file://%s" % self.repository_path)
self.tmpdir = tempfile.mkdtemp()
self.repos.checkout(self.tmpdir)
self.wc = SubversionWorkingCopy(self.tmpdir)
self.latest_version = "3"
self.previous_version = "1"
def tearDown(self):
class TestGitWorkingCopy(unittest.TestCase, BaseTestWorkingCopy):
def setUp(self):
self.repository_path = os.path.abspath("../example_repositories/git")
os.symlink("%s/git" % self.repository_path, "%s/.git" % self.repository_path)
self.repos = GitRepository(self.repository_path)
self.tmpdir = tempfile.mkdtemp()
self.repos.checkout(self.tmpdir)
self.wc = GitWorkingCopy(self.tmpdir)
self.latest_version = "38598c93c7036a1c44bbb6075517243edfa88860"
self.previous_version = "3491ce1d9a66abc9d49d5844ee05167c6a854ad9"
def tearDown(self):
os.unlink("%s/.git" % self.repository_path)
shutil.rmtree(self.tmpdir)
TestGitWorkingCopy = unittest.skipUnless(have_git, "Could not import git")(TestGitWorkingCopy) # not using as class decorator for the sake of Python 2.5
#@unittest.skipUnless(have_pysvn, "Could not import pysvn")
class TestSubversionWorkingCopy(unittest.TestCase, BaseTestWorkingCopy):
def setUp(self):
self.repository_path = os.path.abspath("../example_repositories/subversion")
self.repos = SubversionRepository("file://%s" % self.repository_path)
self.tmpdir = tempfile.mkdtemp()
self.repos.checkout(self.tmpdir)
self.wc = SubversionWorkingCopy(self.tmpdir)
self.latest_version = "3"
self.previous_version = "1"
def tearDown(self):
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
def local_decorator_creator():
if not CASSANDRA_IP.startswith("127.0.0."):
return unittest.skip('Tests only runs against local C*')
def _id_and_mark(f):
f.local = True
return f
return _id_and_mark
local = local_decorator_creator()
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1, 'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
protocolv5 = unittest.skipUnless(5 in get_supported_protocol_versions(), 'Protocol versions less than 5 are not supported')
greaterthancass20 = unittest.skipUnless(CASSANDRA_VERSION >= Version('2.1'), 'Cassandra version 2.1 or greater required')
greaterthancass21 = unittest.skipUnless(CASSANDRA_VERSION >= Version('2.2'), 'Cassandra version 2.2 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.0'), 'Cassandra version 3.0 or greater required')
greaterthanorequalcass36 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.6'), 'Cassandra version 3.6 or greater required')
greaterthanorequalcass3_10 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.10'), 'Cassandra version 3.10 or greater required')
greaterthanorequalcass3_11 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.11'), 'Cassandra version 3.10 or greater required')
greaterthanorequalcass40 = unittest.skipUnless(CASSANDRA_VERSION >= Version('4.0'), 'Cassandra version 4.0 or greater required')
lessthanorequalcass40 = unittest.skipIf(CASSANDRA_VERSION >= Version('4.0'), 'Cassandra version 4.0 or greater required')
lessthancass30 = unittest.skipUnless(CASSANDRA_VERSION < Version('3.0'), 'Cassandra version less then 3.0 required')
pypy = unittest.skipUnless(platform.python_implementation() == "PyPy", "Test is skipped unless it's on PyPy")
notpy3 = unittest.skipIf(sys.version_info >= (3, 0), "Test not applicable for Python 3.x runtime")
self._load_product_from_data(self.global_env, self.default_product)
self._env = env = ProductEnvironment(
self.global_env, self.default_product)
return env
@env.setter
def env(self, value):
pass
def setUp(self):
test_pygments.PygmentsRendererTestCase.setUp(self)
self.pygments = Mimeview(self.env).renderers[0]
def tearDown(self):
self.global_env.reset_db()
self.global_env = self._env = None
ProductPygmentsRendererTestCase = unittest.skipUnless(
test_pygments.have_pygments,
'mimeview/tests/pygments (no pygments installed)'
)(ProductPygmentsRendererTestCase)
def test_suite():
return unittest.TestSuite([
unittest.makeSuite(ProductPygmentsRendererTestCase,'test'),
])
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
has_scipy, requires_scipy = _importorskip('scipy')
has_pydap, requires_pydap = _importorskip('pydap.client')
has_netCDF4, requires_netCDF4 = _importorskip('netCDF4')
has_h5netcdf, requires_h5netcdf = _importorskip('h5netcdf')
has_pynio, requires_pynio = _importorskip('Nio')
has_cftime, requires_cftime = _importorskip('cftime')
has_dask, requires_dask = _importorskip('dask')
has_bottleneck, requires_bottleneck = _importorskip('bottleneck')
has_rasterio, requires_rasterio = _importorskip('rasterio')
has_pathlib, requires_pathlib = _importorskip('pathlib')
has_zarr, requires_zarr = _importorskip('zarr', minversion='2.2')
has_np112, requires_np112 = _importorskip('numpy', minversion='1.12.0')
# some special cases
has_scipy_or_netCDF4 = has_scipy or has_netCDF4
requires_scipy_or_netCDF4 = unittest.skipUnless(
has_scipy_or_netCDF4, reason='requires scipy or netCDF4')
has_cftime_or_netCDF4 = has_cftime or has_netCDF4
requires_cftime_or_netCDF4 = unittest.skipUnless(
has_cftime_or_netCDF4, reason='requires cftime or netCDF4')
if not has_pathlib:
has_pathlib, requires_pathlib = _importorskip('pathlib2')
if has_dask:
import dask
if LooseVersion(dask.__version__) < '0.18':
dask.set_options(get=dask.get)
else:
dask.config.set(scheduler='sync')
try:
import_seaborn()
has_seaborn = True
except ImportError:
errors = data['validation_errors']
self.assertIn('email', errors)
self.assertIn('enter a value', errors['email'].lower())
# everything required is now provided
person = dict(name='Jeffrey', email='*****@*****.**', age=24)
response = self.app.post('/api/test', data=dumps(person))
self.assertEqual(response.status_code, 201)
personid = loads(response.data)['id']
# check that the provided field values are in there
response = self.app.get('/api/test/' + str(personid))
self.assertEqual(response.status_code, 200)
data = loads(response.data)
self.assertEqual(data['name'], 'Jeffrey')
self.assertEqual(data['email'], '*****@*****.**')
# skipUnless should be used as a decorator, but Python 2.5 doesn't have
# decorators.
SAVTest = skipUnless(has_savalidation and sav_version >= (0, 2),
'savalidation not found.')(SAVTest)
def load_tests(loader, standard_tests, pattern):
"""Returns the test suite for this module."""
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(SimpleValidationTest))
suite.addTest(loader.loadTestsFromTestCase(SAVTest))
return suite
else:
import unittest
import logbook
import six
_missing = object()
def get_total_delta_seconds(delta):
"""
Replacement for datetime.timedelta.total_seconds() for Python 2.5, 2.6 and 3.1
"""
return (delta.microseconds + (delta.seconds + delta.days * 24 * 3600) * 10**6) / 10**6
require_py3 = unittest.skipUnless(six.PY3, "Requires Python 3")
def require_module(module_name):
try:
__import__(module_name)
except ImportError:
return unittest.skip("Requires the %r module" % (module_name,))
return lambda func: func
class LogbookTestSuite(unittest.TestSuite):
pass
class LogbookTestCase(unittest.TestCase):
def setUp(self):
self.log = logbook.Logger('testlogger')
# silence deprecation warning displayed on Py 3.2
else:
log.info("Using Cassandra version: %s", CASSANDRA_VERSION)
CCM_KWARGS["version"] = CASSANDRA_VERSION
if CASSANDRA_VERSION >= "2.2":
default_protocol_version = 4
elif CASSANDRA_VERSION >= "2.1":
default_protocol_version = 3
elif CASSANDRA_VERSION >= "2.0":
default_protocol_version = 2
else:
default_protocol_version = 1
PROTOCOL_VERSION = int(os.getenv("PROTOCOL_VERSION", default_protocol_version))
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1, "Protocol v1 not supported")
lessthenprotocolv4 = unittest.skipUnless(PROTOCOL_VERSION < 4, "Protocol versions 4 or greater not supported")
greaterthanprotocolv3 = unittest.skipUnless(PROTOCOL_VERSION >= 4, "Protocol versions less than 4 are not supported")
greaterthancass20 = unittest.skipUnless(CASSANDRA_VERSION >= "2.1", "Cassandra version 2.1 or greater required")
greaterthanorequalcass30 = unittest.skipUnless(CASSANDRA_VERSION >= "3.0", "Cassandra version 3.0 or greater required")
lessthancass30 = unittest.skipUnless(CASSANDRA_VERSION < "3.0", "Cassandra version less then 3.0 required")
def get_cluster():
return CCM_CLUSTER
def get_node(node_id):
return CCM_CLUSTER.nodes["node%s" % node_id]
def skipSlowTest():
return skipUnless(os.environ.get('PYCHEF_SLOW_TESTS'), 'slow tests skipped, set $PYCHEF_SLOW_TESTS=1 to enable')
default_handler = signal.getsignal(signal.SIGINT)
unittest2.installHandler()
unittest2.removeHandler()
self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
# check that calling removeHandler multiple times has no ill-effect
unittest2.removeHandler()
self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
def testRemoveHandlerAsDecorator(self):
default_handler = signal.getsignal(signal.SIGINT)
unittest2.installHandler()
def test():
self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
test = unittest2.removeHandler(test)
test()
self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
# Should also skip some tests on Jython
skipper = unittest2.skipUnless(
hasattr(os, 'kill') and signal is not None,
"test uses os.kill(...) and the signal module")
TestBreak = skipper(TestBreak)
if __name__ == '__main__':
unittest2.main()
def skipSlowTest():
return skipUnless(
os.environ.get('PYCHEF_SLOW_TESTS'),
'slow tests skipped, set $PYCHEF_SLOW_TESTS=1 to enable')
@unittest.skipIf(sys.platform =="win32", "Test cannot run on Windows")
@unittest.skipIf(sys.platform == 'freebsd6', "Test kills regrtest on freebsd6 "
"if threads have been used")
class TestBreakDefaultIntHandler(TestBreak):
int_handler = signal.default_int_handler
@unittest.skipUnless(hasattr(os, 'kill'), "Test requires os.kill")
@unittest.skipIf(sys.platform =="win32", "Test cannot run on Windows")
@unittest.skipIf(sys.platform == 'freebsd6', "Test kills regrtest on freebsd6 "
"if threads have been used")
class TestBreakSignalIgnored(TestBreak):
int_handler = signal.SIG_IGN
@unittest.skipUnless(hasattr(os, 'kill'), "Test requires os.kill")
@unittest.skipIf(sys.platform =="win32", "Test cannot run on Windows")
@unittest.skipIf(sys.platform == 'freebsd6', "Test kills regrtest on freebsd6 "
"if threads have been used")
class TestBreakSignalDefault(TestBreak):
int_handler = signal.SIG_DFL
# Should also skip some tests on Jython
skipper = unittest2.skipUnless(hasattr(os, 'kill') and signal is not None,
"test uses os.kill(...) and the signal module")
skipper2 = unittest2.skipIf(sys.platform == 'win32', "can't run on windows")
TestBreak = skipper(skipper2(TestBreak))
if __name__ == '__main__':
unittest2.main()
has_scipy, requires_scipy = _importorskip('scipy')
has_pydap, requires_pydap = _importorskip('pydap.client')
has_netCDF4, requires_netCDF4 = _importorskip('netCDF4')
has_h5netcdf, requires_h5netcdf = _importorskip('h5netcdf')
has_pynio, requires_pynio = _importorskip('Nio')
has_cftime, requires_cftime = _importorskip('cftime')
has_dask, requires_dask = _importorskip('dask')
has_bottleneck, requires_bottleneck = _importorskip('bottleneck')
has_rasterio, requires_rasterio = _importorskip('rasterio')
has_pathlib, requires_pathlib = _importorskip('pathlib')
has_zarr, requires_zarr = _importorskip('zarr', minversion='2.2')
has_np112, requires_np112 = _importorskip('numpy', minversion='1.12.0')
# some special cases
has_scipy_or_netCDF4 = has_scipy or has_netCDF4
requires_scipy_or_netCDF4 = unittest.skipUnless(
has_scipy_or_netCDF4, reason='requires scipy or netCDF4')
has_cftime_or_netCDF4 = has_cftime or has_netCDF4
requires_cftime_or_netCDF4 = unittest.skipUnless(
has_cftime_or_netCDF4, reason='requires cftime or netCDF4')
if not has_pathlib:
has_pathlib, requires_pathlib = _importorskip('pathlib2')
if has_dask:
import dask
dask.set_options(get=dask.get)
try:
import_seaborn()
has_seaborn = True
except ImportError:
has_seaborn = False
requires_seaborn = unittest.skipUnless(has_seaborn, reason='requires seaborn')
def skip_unless_words(func):
return unittest2.skipUnless(
os.path.isfile(words_file),
'Cannot find system words file {}'.format(words_file)
)(func)
PUBCHEM_SDF,
errors="this-is-not.a.valid! setting")
# Test classes for the different toolkits
class TestOpenBabelReadStructureFingerprints(unittest2.TestCase,
ReadStructureFingerprints):
type = "OpenBabel-FP2/1"
num_bits = 1021
fp_size = 128
TestOpenBabelReadStructureFingerprints = (unittest2.skipUnless(
has_openbabel,
"Open Babel not available")(TestOpenBabelReadStructureFingerprints))
class TestOpenEyeReadStructureFingerprints(unittest2.TestCase,
ReadStructureFingerprints):
type = "OpenEye-Path/1"
num_bits = 1024
fp_size = 128
TestOpenEyeReadStructureFingerprints = (unittest2.skipUnless(
has_openeye,
"OpenEye not available")(TestOpenEyeReadStructureFingerprints))
log.info("Using DSE credentials file located at {0}".format(DSE_CRED))
CCM_KWARGS['dse_credentials_file'] = DSE_CRED
if CASSANDRA_VERSION >= '2.2':
default_protocol_version = 4
elif CASSANDRA_VERSION >= '2.1':
default_protocol_version = 3
elif CASSANDRA_VERSION >= '2.0':
default_protocol_version = 2
else:
default_protocol_version = 1
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1, 'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
greaterthancass20 = unittest.skipUnless(CASSANDRA_VERSION >= '2.1', 'Cassandra version 2.1 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(CASSANDRA_VERSION >= '3.0', 'Cassandra version 3.0 or greater required')
lessthancass30 = unittest.skipUnless(CASSANDRA_VERSION < '3.0', 'Cassandra version less then 3.0 required')
def get_cluster():
return CCM_CLUSTER
def get_node(node_id):
return CCM_CLUSTER.nodes['node%s' % node_id]
else:
log.info('Using Cassandra version: %s', CASSANDRA_VERSION)
CCM_KWARGS['version'] = CASSANDRA_VERSION
if CASSANDRA_VERSION >= '2.2':
default_protocol_version = 4
elif CASSANDRA_VERSION >= '2.1':
default_protocol_version = 3
elif CASSANDRA_VERSION >= '2.0':
default_protocol_version = 2
else:
default_protocol_version = 1
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1, 'Protocol v1 not supported')
def get_cluster():
return CCM_CLUSTER
def get_node(node_id):
return CCM_CLUSTER.nodes['node%s' % node_id]
def use_multidc(dc_list):
use_cluster(MULTIDC_CLUSTER_NAME, dc_list, start=True)
def use_singledc(start=True):
import unittest
import logbook
from logbook.helpers import StringIO
_missing = object()
def get_total_delta_seconds(delta):
"""
Replacement for datetime.timedelta.total_seconds() for Python 2.5, 2.6 and 3.1
"""
return (delta.microseconds +
(delta.seconds + delta.days * 24 * 3600) * 10**6) / 10**6
require_py3 = unittest.skipUnless(sys.version_info[0] == 3,
"Requires Python 3")
def require_module(module_name):
try:
__import__(module_name)
except ImportError:
return unittest.skip("Requires the %r module" % (module_name, ))
return lambda func: func
class LogbookTestSuite(unittest.TestSuite):
pass
class LogbookTestCase(unittest.TestCase):
def check_rd201012():
import rdkit.rdBase
from rdkit.rdBase import rdkitVersion
assert rdkitVersion[:7] == "2010.12", rdkitVersion
def check_rd201112_svn():
import rdkit.rdBase
from rdkit.rdBase import rdkitVersion
assert rdkitVersion[:7] == "2011.12", rdkitVersion
def _check(required):
req = required.split()
for name in versions:
if name in req:
return
raise AssertionError("Missing one of %r: %r" % (required, versions))
class TestToxVersion(unittest2.TestCase):
def test_enough_specifications(self):
_check("x32 x64")
_check("py25 py26 py27 py32")
_check("oe174 oe2011Oct ob223 ob230 ob23svn1 rd201106 rd201103 rd201012 rd201112_svn")
def test_version(self):
for name in versions:
func = globals()["check_" + name]
func()
TestToxVersion = unittest2.skipUnless(envstr, "Not building under the tox environment")(
TestToxVersion)
# See the License for the specific language governing permissions and
# limitations under the License.
"""Various utilities used in tests."""
import contextlib
import os
import tempfile
import shutil
import sys
import six
import unittest2
RunOnlyOnPython27 = unittest2.skipUnless(sys.version_info[:2] == (2, 7), "Only runs in Python 2.7")
@contextlib.contextmanager
def TempDir(change_to=False):
if change_to:
original_dir = os.getcwd()
path = tempfile.mkdtemp()
try:
if change_to:
os.chdir(path)
yield path
finally:
if change_to:
os.chdir(original_dir)
shutil.rmtree(path)
from tests.integration import VERIFY_CYTHON
except ImportError:
VERIFY_CYTHON = False
try:
import unittest2 as unittest
except ImportError:
import unittest # noqa
def cyimport(import_path):
"""
Import a Cython module if available, otherwise return None
(and skip any relevant tests).
"""
if HAVE_CYTHON:
import pyximport
py_importer, pyx_importer = pyximport.install()
mod = __import__(import_path, fromlist=[True])
pyximport.uninstall(py_importer, pyx_importer)
return mod
# @cythontest
# def test_something(self): ...
cythontest = unittest.skipUnless((HAVE_CYTHON or VERIFY_CYTHON)
or VERIFY_CYTHON, 'Cython is not available')
notcython = unittest.skipIf(HAVE_CYTHON, 'Cython not supported')
numpytest = unittest.skipUnless((HAVE_CYTHON and HAVE_NUMPY) or VERIFY_CYTHON,
'NumPy is not available')
if Version(CASSANDRA_VERSION) >= Version('2.2'):
return None
if Version(CASSANDRA_VERSION) >= Version('2.1'):
return 4
elif Version(CASSANDRA_VERSION) >= Version('2.0'):
return 3
else:
return None
default_protocol_version = get_default_protocol()
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1, 'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
protocolv5 = unittest.skipUnless(5 in get_supported_protocol_versions(), 'Protocol versions less than 5 are not supported')
greaterthancass20 = unittest.skipUnless(CASSANDRA_VERSION >= '2.1', 'Cassandra version 2.1 or greater required')
greaterthancass21 = unittest.skipUnless(CASSANDRA_VERSION >= '2.2', 'Cassandra version 2.2 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(CASSANDRA_VERSION >= '3.0', 'Cassandra version 3.0 or greater required')
greaterthanorequalcass36 = unittest.skipUnless(CASSANDRA_VERSION >= '3.6', 'Cassandra version 3.6 or greater required')
lessthancass30 = unittest.skipUnless(CASSANDRA_VERSION < '3.0', 'Cassandra version less then 3.0 required')
dseonly = unittest.skipUnless(DSE_VERSION, "Test is only applicalbe to DSE clusters")
pypy = unittest.skipUnless(platform.python_implementation() == "PyPy", "Test is skipped unless it's on PyPy")
def wait_for_node_socket(node, timeout):
binary_itf = node.network_interfaces['binary']
import os
from functools import partial
try:
import unittest2 as unittest
except ImportError:
import unittest
if not hasattr(unittest, "skipUnless"):
raise Exception("Please install unittest2 package (unittest.skipUnless attribute is missing)")
SKLIK_LOGIN = os.environ.get("SKLIK_LOGIN")
SKLIK_PASSWORD = os.environ.get("SKLIK_PASSWORD")
SKLIK_BAJAJA_URL = "https://api.sklik.cz/sandbox/bajaja/RPC2"
SKLIK_CIPISEK_URL = "https://api.sklik.cz/sandbox/cipisek/RPC2"
only_with_login = partial(
unittest.skipUnless(SKLIK_LOGIN and SKLIK_PASSWORD, "SKLIK_LOGIN or SKLIK_PASSWORD environment var not set")
)
def get_client(cls, url=SKLIK_CIPISEK_URL):
return cls(url, SKLIK_LOGIN, SKLIK_PASSWORD, debug=False)
def skipUnlessPlatform(oslist):
"""Decorate the item to skip tests unless running on one of the listed platforms."""
# This decorator cannot be ported to `skipIf` yet because it is used on entire
# classes, which `skipIf` explicitly forbids.
return unittest2.skipUnless(lldbplatformutil.getPlatform() in oslist,
"requires one of %s" % (", ".join(oslist)))
from __future__ import unicode_literals
import os
import sys
try:
import unittest2 as unittest
except ImportError:
import unittest
from rpaths import unicode, dict_union, Path, PosixPath, WindowsPath, \
Pattern, pattern2re
windows_only = unittest.skipUnless(issubclass(Path, WindowsPath),
"Only runs on Windows")
posix_only = unittest.skipUnless(issubclass(Path, PosixPath),
"Only runs on POSIX")
class TestConcrete(unittest.TestCase):
"""Tests for Path.
Because this tests the concrete Path, it needs to be run on both Windows
and POSIX to ensure everything is correct.
"""
def test_cwd(self):
"""Tests cwd, in_dir."""
cwd = os.getcwd()
if os.name == 'nt' and isinstance(cwd, bytes):
cwd = cwd.decode('mbcs')
elif os.name != 'nt' and isinstance(cwd, unicode):
def is_gevent_monkey_patched():
if 'gevent.monkey' not in sys.modules:
return False
import gevent.socket
return socket.socket is gevent.socket.socket
def is_gevent_time_monkey_patched():
import gevent.monkey
return "time" in gevent.monkey.saved
def is_eventlet_time_monkey_patched():
import eventlet
return eventlet.patcher.is_monkey_patched('time')
def is_monkey_patched():
return is_gevent_monkey_patched() or is_eventlet_monkey_patched()
MONKEY_PATCH_LOOP = bool(os.getenv('MONKEY_PATCH_LOOP', False))
notwindows = unittest.skipUnless(not "Windows" in platform.system(),
"This test is not adequate for windows")
notpypy = unittest.skipUnless(not platform.python_implementation() == 'PyPy',
"This tests is not suitable for pypy")
notmonkeypatch = unittest.skipUnless(
MONKEY_PATCH_LOOP, "Skpping this test because monkey patching is required")
log.setLevel('DEBUG')
# if nose didn't already attach a log handler, add one here
if not log.handlers:
handler = logging.StreamHandler()
handler.setFormatter(
logging.Formatter(
'%(asctime)s %(levelname)s [%(module)s:%(lineno)s]: %(message)s'))
log.addHandler(handler)
def is_eventlet_monkey_patched():
if 'eventlet.patcher' not in sys.modules:
return False
import eventlet.patcher
return eventlet.patcher.is_monkey_patched('socket')
def is_gevent_monkey_patched():
if 'gevent.monkey' not in sys.modules:
return False
import gevent.socket
return socket.socket is gevent.socket.socket
def is_monkey_patched():
return is_gevent_monkey_patched() or is_eventlet_monkey_patched()
notwindows = unittest.skipUnless(not "Windows" in platform.system(),
"This test is not adequate for windows")
log.info(
"Using DSE credentials file located at {0}".format(DSE_CRED))
CCM_KWARGS['dse_credentials_file'] = DSE_CRED
if CASSANDRA_VERSION >= '2.2':
default_protocol_version = 4
elif CASSANDRA_VERSION >= '2.1':
default_protocol_version = 3
elif CASSANDRA_VERSION >= '2.0':
default_protocol_version = 2
else:
default_protocol_version = 1
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1,
'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(
PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(
PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
greaterthancass20 = unittest.skipUnless(
CASSANDRA_VERSION >= '2.1', 'Cassandra version 2.1 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(
CASSANDRA_VERSION >= '3.0', 'Cassandra version 3.0 or greater required')
lessthancass30 = unittest.skipUnless(
CASSANDRA_VERSION < '3.0', 'Cassandra version less then 3.0 required')
def wait_for_node_socket(node, timeout):
binary_itf = node.network_interfaces['binary']
import os
from functools import partial
try:
import unittest2 as unittest
except ImportError:
import unittest
if not hasattr(unittest, 'skipUnless'):
raise Exception(
'Please install unittest2 package (unittest.skipUnless attribute is missing)'
)
SKLIK_LOGIN = os.environ.get('SKLIK_LOGIN')
SKLIK_PASSWORD = os.environ.get('SKLIK_PASSWORD')
SKLIK_BAJAJA_URL = 'https://api.sklik.cz/sandbox/bajaja/RPC2'
SKLIK_CIPISEK_URL = 'https://api.sklik.cz/sandbox/cipisek/RPC2'
only_with_login = partial(
unittest.skipUnless(
SKLIK_LOGIN and SKLIK_PASSWORD,
"SKLIK_LOGIN or SKLIK_PASSWORD environment var not set"))
def get_client(cls, url=SKLIK_CIPISEK_URL):
return cls(url, SKLIK_LOGIN, SKLIK_PASSWORD, debug=False)
# limitations under the License.
from cassandra.cython_deps import HAVE_CYTHON, HAVE_NUMPY
if HAVE_CYTHON:
import pyximport
pyximport.install()
try:
import unittest2 as unittest
except ImportError:
import unittest # noqa
def cyimport(import_path):
"""
Import a Cython module if available, otherwise return None
(and skip any relevant tests).
"""
try:
return __import__(import_path, fromlist=[True])
except ImportError:
if HAVE_CYTHON:
raise
return None
# @cythontest
# def test_something(self): ...
cythontest = unittest.skipUnless(HAVE_CYTHON, 'Cython is not available')
numpytest = unittest.skipUnless(HAVE_CYTHON and HAVE_NUMPY, 'NumPy is not available')
from cassandra.io.twistedreactor import TwistedConnection
connection_class = TwistedConnection
elif "asyncio" in EVENT_LOOP_MANAGER:
from cassandra.io.asyncioreactor import AsyncioConnection
connection_class = AsyncioConnection
else:
try:
from cassandra.io.libevreactor import LibevConnection
connection_class = LibevConnection
except ImportError:
connection_class = None
# If set to to true this will force the Cython tests to run regardless of whether they are installed
cython_env = os.getenv('VERIFY_CYTHON', "False")
VERIFY_CYTHON = False
if(cython_env == 'True'):
VERIFY_CYTHON = True
def is_windows():
return "Windows" in platform.system()
notwindows = unittest.skipUnless(not is_windows(), "This test is not adequate for windows")
notpypy = unittest.skipUnless(not platform.python_implementation() == 'PyPy', "This tests is not suitable for pypy")
def skipUnlessTargetAndroid(func):
return unittest2.skipUnless(lldbplatformutil.target_is_android(),
"requires target to be Android")(func)
self.assertEqual(200, response.status_code)
data = loads(response.data)
self.assertEqual(2, len(data["pets"]))
for pet in data["pets"]:
self.assertEqual(owner.id, pet["ownerid"])
response = self.app.get("/api/lazy_pet/1")
self.assertEqual(200, response.status_code)
data = loads(response.data)
self.assertFalse(isinstance(data["owner"], list))
self.assertEqual(owner.id, data["ownerid"])
# skipUnless should be used as a decorator, but Python 2.5 doesn't have
# decorators.
FSATest = skipUnless(has_flask_sqlalchemy, "Flask-SQLAlchemy not found.")(FSAModelTest)
class ModelTestCase(TestSupport):
"""Provides tests for helper functions which operate on pure SQLAlchemy
models.
"""
def test_get_columns(self):
"""Test for getting the names of columns as strings."""
columns = _get_columns(self.Person)
self.assertEqual(sorted(columns.keys()), sorted(["age", "birth_date", "computers", "id", "name", "other"]))
def test_get_relations(self):
"""Tests getting the names of the relations of a model as strings."""
def skipUnlessPlatform(oslist):
"""Decorate the item to skip tests unless running on one of the listed platforms."""
# This decorator cannot be ported to `skipIf` yet because it is used on entire
# classes, which `skipIf` explicitly forbids.
return unittest2.skipUnless(lldbplatformutil.getPlatform() in oslist,
"requires one of %s" % (", ".join(oslist)))
errors = data['validation_errors']
assert 'email' in errors
assert 'enter a value' in errors['email'].lower()
# everything required is now provided
person = dict(name='Jeffrey', email='*****@*****.**', age=24)
response = self.app.post('/api/test', data=dumps(person))
assert response.status_code == 201
personid = loads(response.data)['id']
# check that the provided field values are in there
response = self.app.get('/api/test/' + str(personid))
assert response.status_code == 200
data = loads(response.data)
assert data['name'] == 'Jeffrey'
assert data['email'] == '*****@*****.**'
# skipUnless should be used as a decorator, but Python 2.5 doesn't have
# decorators.
SAVTest = skipUnless(has_savalidation and sav_version >= (0, 2),
'savalidation not found.')(SAVTest)
def load_tests(loader, standard_tests, pattern):
"""Returns the test suite for this module."""
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(SimpleValidationTest))
suite.addTest(loader.loadTestsFromTestCase(SAVTest))
return suite
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
def local_decorator_creator():
if USE_CASS_EXTERNAL or not CASSANDRA_IP.startswith("127.0.0."):
return unittest.skip('Tests only runs against local C*')
def _id_and_mark(f):
f.local = True
return f
return _id_and_mark
local = local_decorator_creator()
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1, 'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
protocolv5 = unittest.skipUnless(5 in get_supported_protocol_versions(), 'Protocol versions less than 5 are not supported')
greaterthancass20 = unittest.skipUnless(CASSANDRA_VERSION >= Version('2.1'), 'Cassandra version 2.1 or greater required')
greaterthancass21 = unittest.skipUnless(CASSANDRA_VERSION >= Version('2.2'), 'Cassandra version 2.2 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.0'), 'Cassandra version 3.0 or greater required')
greaterthanorequalcass31 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.1'), 'Cassandra version 3.1 or greater required')
greaterthanorequalcass36 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.6'), 'Cassandra version 3.6 or greater required')
greaterthanorequalcass3_10 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.10'), 'Cassandra version 3.10 or greater required')
greaterthanorequalcass3_11 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.11'), 'Cassandra version 3.11 or greater required')
greaterthanorequalcass40 = unittest.skipUnless(CASSANDRA_VERSION >= Version('4.0-a'), 'Cassandra version 4.0 or greater required')
lessthanorequalcass40 = unittest.skipUnless(CASSANDRA_VERSION <= Version('4.0-a'), 'Cassandra version less or equal to 4.0 required')
lessthancass40 = unittest.skipUnless(CASSANDRA_VERSION < Version('4.0-a'), 'Cassandra version less than 4.0 required')
lessthancass30 = unittest.skipUnless(CASSANDRA_VERSION < Version('3.0'), 'Cassandra version less then 3.0 required')
greaterthanorequaldse68 = unittest.skipUnless(DSE_VERSION and DSE_VERSION >= Version('6.8'), "DSE 6.8 or greater required for this test")
log.info(
"Using DSE credentials file located at {0}".format(DSE_CRED))
CCM_KWARGS['dse_credentials_file'] = DSE_CRED
if CASSANDRA_VERSION >= '2.2':
default_protocol_version = 4
elif CASSANDRA_VERSION >= '2.1':
default_protocol_version = 3
elif CASSANDRA_VERSION >= '2.0':
default_protocol_version = 2
else:
default_protocol_version = 1
PROTOCOL_VERSION = int(os.getenv('PROTOCOL_VERSION', default_protocol_version))
notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1,
'Protocol v1 not supported')
lessthenprotocolv4 = unittest.skipUnless(
PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported')
greaterthanprotocolv3 = unittest.skipUnless(
PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported')
greaterthancass20 = unittest.skipUnless(
CASSANDRA_VERSION >= '2.1', 'Cassandra version 2.1 or greater required')
greaterthancass21 = unittest.skipUnless(
CASSANDRA_VERSION >= '2.2', 'Cassandra version 2.2 or greater required')
greaterthanorequalcass30 = unittest.skipUnless(
CASSANDRA_VERSION >= '3.0', 'Cassandra version 3.0 or greater required')
lessthancass30 = unittest.skipUnless(
CASSANDRA_VERSION < '3.0', 'Cassandra version less then 3.0 required')
dseonly = unittest.skipUnless(DSE_VERSION,
"Test is only applicalbe to DSE clusters")
response = self.app.get('/api/person')
assert response.status_code == 200
assert len(loads(response.data)['objects']) == 1
assert loads(response.data)['objects'][0]['id'] == 1
response = self.app.patch('/api2/person/1',
data=dumps(dict(name='bar')))
assert response.status_code == 200
assert loads(response.data)['id'] == 1
assert loads(response.data)['name'] == 'bar'
# test that the model is the same as before
response = self.app.get('/readonly/person')
assert response.status_code == 200
assert len(loads(response.data)['objects']) == 1
assert loads(response.data)['objects'][0]['id'] == 1
assert loads(response.data)['objects'][0]['name'] == 'bar'
# skipUnless should be used as a decorator, but Python 2.5 doesn't have
# decorators.
FSATest = skipUnless(has_flask_sqlalchemy,
'Flask-SQLAlchemy not found.')(FSATest)
def load_tests(loader, standard_tests, pattern):
"""Returns the test suite for this module."""
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(APIManagerTest))
suite.addTest(loader.loadTestsFromTestCase(FSATest))
return suite
else:
import unittest
import logbook
from logbook.helpers import StringIO
_missing = object()
def get_total_delta_seconds(delta):
"""
Replacement for datetime.timedelta.total_seconds() for Python 2.5, 2.6 and 3.1
"""
return (delta.microseconds + (delta.seconds + delta.days * 24 * 3600) * 10**6) / 10**6
require_py3 = unittest.skipUnless(sys.version_info[0] == 3, "Requires Python 3")
def require_module(module_name):
try:
__import__(module_name)
except ImportError:
return unittest.skip("Requires the %r module" % (module_name,))
return lambda func: func
class LogbookTestSuite(unittest.TestSuite):
pass
class LogbookTestCase(unittest.TestCase):
def setUp(self):
self.log = logbook.Logger('testlogger')
# silence deprecation warning displayed on Py 3.2
