def skip_if_not_implemented(*args, **kwargs):
try:
return func(*args, **kwargs)
except NotImplementedError as e:
raise testcase.TestSkipped(str(e))
except Exception as e:
if 'not implemented' in str(e):
raise testcase.TestSkipped(str(e))
raise
def skip_if_not_implemented(*args, **kwargs):
try:
return func(*args, **kwargs)
except panko.NotImplementedError as e:
raise testcase.TestSkipped(six.text_type(e))
except webtest.app.AppError as e:
if 'not implemented' in six.text_type(e):
raise testcase.TestSkipped(six.text_type(e))
raise
def inner(*args, **kwargs):
if not CONF.cache.enabled:
raise testcase.TestSkipped('Cache globally disabled.')
for s in sections:
conf_sec = getattr(CONF, s, None)
if conf_sec is not None:
if not getattr(conf_sec, 'caching', True):
raise testcase.TestSkipped('%s caching disabled.' % s)
return f(*args, **kwargs)
def skip_if_not_implemented(*args, **kwargs):
try:
return func(*args, **kwargs)
except AssertionError:
raise
except NotImplementedError as e:
raise testcase.TestSkipped(six.text_type(e))
except Exception as e:
if 'not implemented' in six.text_type(e):
raise testcase.TestSkipped(six.text_type(e))
raise
def setUp(self):
super(TestBase, self).setUp()
db_url = os.environ.get('PIFPAF_URL',
"sqlite://").replace("mysql://",
"mysql+pymysql://")
engine = urlparse.urlparse(db_url).scheme
# in case some drivers have additional specification, for example:
# PyMySQL will have scheme mysql+pymysql
engine = engine.split('+')[0]
# NOTE(Alexei_987) Shortcut to skip expensive db setUp
test_method = self._get_test_method()
if (hasattr(test_method, '_run_with')
and engine not in test_method._run_with):
raise testcase.TestSkipped('Test is not applicable for %s' %
engine)
self.CONF = service.prepare_service([], [])
manager = self.DRIVER_MANAGERS.get(engine)
if not manager:
self.skipTest("missing driver manager: %s" % engine)
self.db_manager = manager(db_url, self.CONF)
self.useFixture(self.db_manager)
self.conn = self.db_manager.connection
self.conn.upgrade()
self.useFixture(
mockpatch.Patch('panko.storage.get_connection',
side_effect=self._get_connection))
def _create_key_manager(self):
key_mgr = vault_key_manager.VaultKeyManager(cfg.CONF)
if ('VAULT_TEST_URL' not in os.environ
or 'VAULT_TEST_ROOT_TOKEN' not in os.environ):
raise testcase.TestSkipped('Missing Vault setup information')
self.root_token_id = os.environ['VAULT_TEST_ROOT_TOKEN']
self.vault_url = os.environ['VAULT_TEST_URL']
test_uuid = str(uuid.uuid4())
vault_policy = 'policy-{}'.format(test_uuid)
vault_approle = 'approle-{}'.format(test_uuid)
self.session = requests.Session()
self.session.headers.update({'X-Vault-Token': self.root_token_id})
self._mount_kv(self.mountpoint)
self._enable_approle()
self._create_policy(vault_policy)
self._create_approle(vault_approle, vault_policy)
key_mgr._approle_role_id, key_mgr._approle_secret_id = (
self._retrieve_approle(vault_approle))
key_mgr._kv_mountpoint = self.mountpoint
key_mgr._vault_url = self.vault_url
return key_mgr
def run_test(*args, **kwargs):
__e = None
try:
f(*args, **kwargs)
except Exception as __e:
if (expected_exception != Exception
and not isinstance(__e, expected_exception)):
raise AssertionError(
'Work In Progress Test Failed%(bugstr)s with '
'unexpected exception. Expected "%(expected)s" '
'got "%(exception)s": %(message)s ' % {
'message': message,
'bugstr': bugstr,
'expected': expected_exception.__class__.__name__,
'exception': __e.__class__.__name__
})
# NOTE(notmorgan): We got the expected exception we can safely
# skip this test.
raise testcase.TestSkipped('Work In Progress Test Failed as '
'expected%(bugstr)s: %(message)s' %
{
'message': message,
'bugstr': bugstr
})
raise AssertionError('Work In Progress Test Passed%(bugstr)s: '
'%(message)s' % {
'message': message,
'bugstr': bugstr
})
def run_test(*args, **kwargs):
try:
f(*args, **kwargs)
except Exception:
raise testcase.TestSkipped('work in progress test failed: ' +
message)
raise AssertionError('work in progress test passed: ' + message)
def setUp(self):
super(VaultlockerFuncBaseTestCase, self).setUp()
self.vault_client = None
self.vault_addr = os.environ.get('PIFPAF_VAULT_ADDR')
self.root_token = os.environ.get('PIFPAF_ROOT_TOKEN')
self.test_uuid = str(uuid.uuid4())
self.vault_backend = 'vaultlocker-test-{}'.format(self.test_uuid)
self.vault_policy = 'vaultlocker-policy-{}'.format(self.test_uuid)
self.vault_approle = 'vaultlocker-approle-{}'.format(self.test_uuid)
if not self.vault_addr or not self.root_token:
raise testcase.TestSkipped('Vault not running')
self.vault_client = hvac.Client(url=self.vault_addr,
token=self.root_token)
self.vault_client.enable_secret_backend(
backend_type='kv',
description='vault test backend',
mount_point=self.vault_backend
)
try:
self.vault_client.enable_auth_backend('approle')
except hvac.exceptions.InvalidRequest:
pass
self.vault_client.set_policy(
name=self.vault_policy,
rules=TEST_POLICY.format(backend=self.vault_backend)
)
self.vault_client.create_role(
self.vault_approle,
token_ttl='60s',
token_max_ttl='60s',
policies=[self.vault_policy],
bind_secret_id='true',
bound_cidr_list='127.0.0.1/32')
self.approle_uuid = self.vault_client.get_role_id(self.vault_approle)
self.secret_id = self.vault_client.write(
'auth/approle/role/{}/secret-id'.format(self.vault_approle)
)['data']['secret_id']
self.test_config = {
'vault': {
'url': self.vault_addr,
'approle': self.approle_uuid,
'secret_id': self.secret_id,
'backend': self.vault_backend,
}
}
self.config = mock.MagicMock()
self.config.get.side_effect = \
lambda s, k: self.test_config.get(s).get(k)
def setUp(self):
if not base._TEST_INTEGRATION:
raise testcase.TestSkipped('Only run in integration mode')
super(TestQueues, self).setUp()
self.project_id = uuidutils.generate_uuid()
self.headers = {'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': self.project_id}
self.client = websocket.create_connection('ws://localhost:9000/')
self.addCleanup(self.client.close)
def setUp(self):
super(BarbicanKeyManagerTestCase, self).setUp()
try:
self.ctxt = self.get_context()
self.key_mgr._get_barbican_client(self.ctxt)
except Exception as e:
# When we run functional-vault target, This test class needs
# to be skipped as barbican is not running
raise testcase.TestSkipped(str(e))
def setUp(self):
super(MongoDbManager, self).setUp()
with warnings.catch_warnings():
warnings.filterwarnings(
action='ignore',
message='.*you must provide a username and password.*')
try:
self.connection = storage.get_connection(self._conf, self.url)
except storage.StorageBadVersion as e:
raise testcase.TestSkipped(six.text_type(e))
def _create_key_manager(self):
key_mgr = vault_key_manager.VaultKeyManager(cfg.CONF)
if ('VAULT_TEST_URL' not in os.environ
or 'VAULT_TEST_ROOT_TOKEN' not in os.environ):
raise testcase.TestSkipped('Missing Vault setup information')
key_mgr._root_token_id = os.environ['VAULT_TEST_ROOT_TOKEN']
key_mgr._vault_url = os.environ['VAULT_TEST_URL']
return key_mgr
def setUp(self):
super(TestAPI, self).setUp()
self.group_id = self._get_random_uuid()
self.member_id = self._get_random_uuid()
self._coord = tooz.coordination.get_coordinator(
self.url, self.member_id)
try:
self._coord.start()
except tooz.coordination.ToozConnectionError as e:
raise testcase.TestSkipped(str(e))
def test_heartbeat_loop(self):
if not self._coord.requires_beating:
raise testcase.TestSkipped("Test not applicable (heartbeating"
" not required)")
heart = self._coord.heart
self.assertFalse(heart.is_alive())
heart.start()
# This will timeout if nothing ever is done...
try:
while not heart.beats:
time.sleep(1)
finally:
heart.stop()
heart.wait()
def setUp(self):
super(TestBase, self).setUp()
db_url = os.environ.get('PIFPAF_URL',
"sqlite://").replace("mysql://",
"mysql+pymysql://")
engine = urlparse.urlparse(db_url).scheme
# in case some drivers have additional specification, for example:
# PyMySQL will have scheme mysql+pymysql
engine = engine.split('+')[0]
# NOTE(Alexei_987) Shortcut to skip expensive db setUp
test_method = self._get_test_method()
if (hasattr(test_method, '_run_with')
and engine not in test_method._run_with):
raise testcase.TestSkipped('Test is not applicable for %s' %
engine)
self.CONF = self.useFixture(fixture_config.Config()).conf
self.CONF([], project='ceilometer', validate_default_values=True)
manager = self.DRIVER_MANAGERS.get(engine)
if not manager:
self.skipTest("missing driver manager: %s" % engine)
self.db_manager = manager(db_url)
self.useFixture(self.db_manager)
self.conn = self.db_manager.connection
self.conn.upgrade()
self.event_conn = self.db_manager.event_connection
self.event_conn.upgrade()
self.useFixture(
mockpatch.Patch('ceilometer.storage.get_connection',
side_effect=self._get_connection))
# Set a default location for the pipeline config file so the
# tests work even if ceilometer is not installed globally on
# the system.
self.CONF.import_opt('pipeline_cfg_file', 'ceilometer.pipeline')
self.CONF.set_override('pipeline_cfg_file',
self.path_get('etc/ceilometer/pipeline.yaml'))
def setUp(self):
super(TestBase, self).setUp()
db_url = os.environ.get(
'AODH_TEST_STORAGE_URL',
os.environ.get("OVERTEST_URL",
'sqlite://').replace("mysql://",
"mysql+pymysql://"))
engine = urlparse.urlparse(db_url).scheme
# In case some drivers have additional specification, for example:
# PyMySQL will have scheme mysql+pymysql.
engine = engine.split('+')[0]
# NOTE(Alexei_987) Shortcut to skip expensive db setUp
test_method = self._get_test_method()
if (hasattr(test_method, '_run_with')
and engine not in test_method._run_with):
raise testcase.TestSkipped('Test is not applicable for %s' %
engine)
conf = service.prepare_service(argv=[], config_files=[])
self.CONF = self.useFixture(fixture_config.Config(conf)).conf
self.CONF.set_override('connection',
db_url,
group="database",
enforce_type=True)
manager = self.DRIVER_MANAGERS.get(engine)
if not manager:
self.skipTest("missing driver manager: %s" % engine)
self.db_manager = manager(self.CONF)
self.useFixture(self.db_manager)
self.CONF.set_override('connection',
self.db_manager.url,
group="database",
enforce_type=True)
self.alarm_conn = storage.get_connection_from_config(self.CONF)
self.alarm_conn.upgrade()
self.useFixture(
mockpatch.Patch('aodh.storage.get_connection_from_config',
side_effect=self._get_connection))
def test_restartable(self):
if not self.restartable:
raise testcase.TestSkipped("not restartable")
else:
executor = self.executor_cls(**self.executor_kwargs)
fut = executor.submit(returns_one)
self.assertEqual(1, fut.result())
executor.shutdown()
self.assertEqual(1, executor.statistics.executed)
self.assertRaises(RuntimeError, executor.submit, returns_one)
executor.restart()
self.assertEqual(0, executor.statistics.executed)
fut = executor.submit(returns_one)
self.assertEqual(1, fut.result())
self.assertEqual(1, executor.statistics.executed)
executor.shutdown()
def skip_if_not_implemented(*args, **kwargs):
try:
return func(*args, **kwargs)
except exceptions.NotImplementedError as e:
raise testcase.TestSkipped(six.text_type(e))
def skip_if_not_implemented(*args, **kwargs):
try:
return func(*args, **kwargs)
except tooz.NotImplemented as e:
raise testcase.TestSkipped(str(e))
def wrapper(*args, **kwargs):
test_obj = args[0]
if not test_obj.identity_api.multiple_domains_supported:
raise testcase.TestSkipped('No multiple domains support')
return f(*args, **kwargs)
def skip_if_not_implemented(*args, **kwargs):
try:
return func(*args, **kwargs)
except ceilometer.NotImplementedError as e:
raise testcase.TestSkipped(str(e))
def test_connection_error(self):
if not hasattr(self, "bad_url"):
raise testcase.TestSkipped("No bad URL provided")
coord = tooz.coordination.get_coordinator(self.bad_url, self.member_id)
self.assertRaises(tooz.coordination.ToozConnectionError, coord.start)
def test_heartbeat(self):
if not self._coord.requires_beating:
raise testcase.TestSkipped("Test not applicable (heartbeating"
" not required)")
self._coord.heartbeat()
