def test_auto_resub(self):
config = test_api_base.setup_config(with_fake_datasource=False,
api=False, policy=False)
node = config['node']
config['ds_manager'].synchronizer.start()
sub = fake_datasource.FakeDataSource('sub')
pub = fake_datasource.FakeDataSource('pub')
node.register_service(sub)
node.register_service(pub)
sub.subscribe('pub', 'p')
helper.retry_check_function_return_value(
lambda: hasattr(sub, 'last_msg'), True)
helper.retry_check_function_return_value(
lambda: sub.last_msg['data'], set([]))
sub.receive_data_sequenced(
'pub', 'p', [[1, 1]], 1, is_snapshot=True)
helper.retry_check_function_return_value(
lambda: sub.last_msg['data'], set([(1, 1)]))
# skipping seqnum 2
sub.receive_data_sequenced(
'pub', 'p', [[3, 3]], 3, is_snapshot=True)
# check that out-of-sequence update not applied
self.assertRaises(
tenacity.RetryError,
helper.retry_check_function_return_value,
lambda: sub.last_msg['data'], set([(3, 3)]))
# check that resub takes place, setting data to initial state
helper.retry_check_function_return_value(
lambda: sub.last_msg['data'], set([]))
node.stop()
def setUp(self):
super(TestDriverModel, self).setUp()
services = api_base.setup_config()
self.node = services['node']
self.node.add_datasource(self._get_datasource_request())
self.driver_model = services['api']['api-system']
def setUp(self):
super(TestWebhookModel, self).setUp()
services = api_base.setup_config(with_fake_json_ingester=True)
self.webhook_model = services['api']['api-webhook']
self.node = services['node']
self.data = services['data']
self.json_ingester = services['json_ingester']
def setUp(self):
super(TestWebhookModel, self).setUp()
services = api_base.setup_config(with_fake_json_ingester=True)
self.webhook_model = services['api']['api-webhook']
self.node = services['node']
self.data = services['data']
self.json_ingester = services['json_ingester']
def test_auto_resub(self):
config = test_api_base.setup_config(with_fake_datasource=False,
api=False,
policy=False)
node = config['node']
config['ds_manager'].synchronizer.start()
sub = fake_datasource.FakeDataSource('sub')
pub = fake_datasource.FakeDataSource('pub')
node.register_service(sub)
node.register_service(pub)
sub.subscribe('pub', 'p')
helper.retry_check_function_return_value(
lambda: hasattr(sub, 'last_msg'), True)
helper.retry_check_function_return_value(lambda: sub.last_msg['data'],
set([]))
sub.receive_data_sequenced('pub', 'p', [[1, 1]], 1, is_snapshot=True)
helper.retry_check_function_return_value(lambda: sub.last_msg['data'],
set([(1, 1)]))
# skipping seqnum 2
sub.receive_data_sequenced('pub', 'p', [[3, 3]], 3, is_snapshot=True)
# check that out-of-sequence update not applied
self.assertRaises(tenacity.RetryError,
helper.retry_check_function_return_value,
lambda: sub.last_msg['data'], set([(3, 3)]))
# check that resub takes place, setting data to initial state
helper.retry_check_function_return_value(lambda: sub.last_msg['data'],
set([]))
node.stop()
def setUp(self):
super(TestDataSource, self).setUp()
config = api_base.setup_config(with_fake_datasource=False,
api=False,
policy=False)
self.dseNode = config['node']
self.ds_manager = config['ds_manager']
def test_drivers_list_with_custom_drivers(self):
cfg.CONF.set_override(
'custom_driver_endpoints',
'test=congress.tests.test_custom_driver:TestCustomDriver')
services = api_base.setup_config(node_id='test-node-2')
driver_api = services['api']['api-system']
ret = [d['id'] for d in driver_api.get_items({}, {})['results']]
self.assertIn('test', ret)
def test_drivers_list_with_disabled_drivers(self):
cfg.CONF.set_override('disabled_drivers', 'plexxi')
services = api_base.setup_config(node_id='test-node-1')
driver_api = services['api']['api-system']
drivers = [d['id'] for d in helper.supported_drivers()]
drivers.remove('plexxi')
ret = [d['id'] for d in driver_api.get_items({}, {})['results']]
self.assertEqual(sorted(drivers), sorted(ret))
def setUp(self):
super(TestStatusModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.rule_model = services['api']['api-rule']
self.status_model = services['api']['api-status']
self.node = services['node']
self.datasource = services['data']
def setUp(self):
super(BaseTestPolicyCongress, self).setUp()
self.services = tests_api_base.setup_config(with_fake_datasource=False)
self.api = self.services['api']
self.node = self.services['node']
self.engine = self.services['engine']
self.neutronv2 = self._create_neutron_mock('neutron')
def setUp(self):
super(BaseTestPolicyCongress, self).setUp()
self.services = tests_api_base.setup_config(with_fake_datasource=False)
self.api = self.services['api']
self.node = self.services['node']
self.engine = self.services['engine']
self.neutronv2 = self._create_neutron_mock('neutron')
def setUp(self):
super(TestRowModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.rule_model = services['api']['api-rule']
self.row_model = services['api']['api-row']
self.node = services['node']
self.data = services['data']
def setUp(self):
super(TestRowModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.rule_model = services['api']['api-rule']
self.row_model = services['api']['api-row']
self.node = services['node']
self.data = services['data']
def setUp(self):
super(TestStatusModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.rule_model = services['api']['api-rule']
self.status_model = services['api']['api-status']
self.node = services['node']
self.datasource = services['data']
def test_drivers_list_with_custom_drivers(self):
cfg.CONF.set_override(
'custom_driver_endpoints',
'test=congress.tests.test_custom_driver:TestCustomDriver')
services = api_base.setup_config(node_id='test-node-2')
driver_api = services['api']['api-system']
ret = [d['id'] for d in driver_api.get_items({}, {})['results']]
self.assertIn('test', ret)
def test_drivers_list_with_disabled_drivers(self):
cfg.CONF.set_override('disabled_drivers', 'plexxi')
services = api_base.setup_config(node_id='test-node-1')
driver_api = services['api']['api-system']
drivers = [d['id'] for d in helper.supported_drivers()]
drivers.remove('plexxi')
ret = [d['id'] for d in driver_api.get_items({}, {})['results']]
self.assertEqual(sorted(drivers), sorted(ret))
def setUp(self):
super(TestDatasourceModel, self).setUp()
services = api_base.setup_config(with_fake_datasource=False)
self.datasource_model = services['api']['api-datasource']
self.data = services['data']
self.node = services['node']
self.engine = services['engine']
self.datasource = self._get_datasource_request()
self.node.add_datasource(self.datasource)
def setUp(self):
super(TestDatasourceModel, self).setUp()
services = api_base.setup_config(with_fake_datasource=False)
self.datasource_model = services['api']['api-datasource']
self.data = services['data']
self.node = services['node']
self.engine = services['engine']
self.datasource = self._get_datasource_request()
self.node.add_datasource(self.datasource)
def test_missing_driver_datasources(self, mock_driver_info):
services = api_base.setup_config(api=False, policy=False)
node = services['node']
ds_manager = services['ds_manager']
ds = self._get_datasource_request()
ds_manager.add_datasource(ds)
mock_driver_info.side_effect = [exception.DriverNotFound]
node.delete_missing_driver_datasources()
self.assertRaises(exception.DatasourceNotFound, node.get_datasource,
'datasource1')
def setUp(self):
super(TestPolicyModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.rule_api = services['api']['api-rule']
self.node = services['node']
self.engine = services['engine']
self.initial_policies = set(self.engine.policy_names())
self._add_test_policy()
def setUp(self):
super(TestPolicyModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.rule_api = services['api']['api-rule']
self.node = services['node']
self.engine = services['engine']
self.initial_policies = set(self.engine.policy_names())
self._add_test_policy()
def setUp(self):
super(TestDsePerformance, self).setUp()
self.services = api_base.setup_config(with_fake_datasource=False,
node_id="perf")
cfg.CONF.set_override(
'drivers',
[('congress.tests.datasources.performance_datasource_driver'
'.PerformanceTestDriver')])
self.node = self.services['node']
self.engine = self.services['engine']
def setUp(self):
super(TestTableModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.table_model = services['api']['api-table']
self.api_rule = services['api']['api-rule']
self.node = services['node']
self.engine = services['engine']
self.data = services['data']
# create test policy
self._create_test_policy()
def setUp(self):
super(TestDsePerformance, self).setUp()
self.services = api_base.setup_config(with_fake_datasource=False,
node_id="perf")
cfg.CONF.set_override(
'drivers',
[('congress.tests.datasources.performance_datasource_driver'
'.PerformanceTestDriver')])
self.node = self.services['node']
self.engine = self.services['engine']
def setUp(self):
super(TestRuleModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.rule_model = services['api']['api-rule']
self.node = services['node']
self.action_policy = self.policy_model.get_item('action', {})
self.context = {'policy_id': self.action_policy["name"]}
self._add_test_rule()
def setUp(self):
super(TestRuleModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.rule_model = services['api']['api-rule']
self.node = services['node']
self.action_policy = self.policy_model.get_item('action', {})
self.context = {'policy_id': self.action_policy["name"]}
self._add_test_rule()
def setUp(self):
super(TestTableModel, self).setUp()
services = api_base.setup_config()
self.policy_model = services['api']['api-policy']
self.table_model = services['api']['api-table']
self.api_rule = services['api']['api-rule']
self.node = services['node']
self.engine = services['engine']
self.data = services['data']
# create test policy
self._create_test_policy()
def test_missing_driver_datasources(self, mock_driver_info, mock_validate):
services = api_base.setup_config(api=False, policy=False)
node = services['node']
ds_manager = services['ds_manager']
ds = self._get_datasource_request()
mock_driver_info.return_value = {'secret': []}
ds_manager.add_datasource(ds)
mock_driver_info.side_effect = [exception.DriverNotFound]
node.delete_missing_driver_datasources()
self.assertRaises(exception.DatasourceNotFound,
node.get_datasource, 'datasource1')
def setUp(self):
super(TestLibraryPolicyModel, self).setUp()
services = api_base.setup_config()
self.library_policy_model = services['api']['api-library-policy']
self.node = services['node']
self.engine = services['engine']
# clear the library policies loaded on startup
db_library_policies.delete_policies()
self._add_test_policy()
def setUp(self):
super(TestDatasourceModel, self).setUp()
cfg.CONF.set_override(
'custom_driver_endpoints',
'test=congress.tests.test_custom_driver:TestCustomDriver')
services = api_base.setup_config(with_fake_datasource=False)
self.datasource_model = services['api']['api-datasource']
self.data = services['data']
self.node = services['node']
self.engine = services['engine']
self.ds_manager = services['ds_manager']
self.datasource = self._get_datasource_request()
self.ds_manager.add_datasource(self.datasource)
def setUp(self):
super(TestDatasourceModel, self).setUp()
cfg.CONF.set_override(
'custom_driver_endpoints',
'test=congress.tests.test_custom_driver:TestCustomDriver')
services = api_base.setup_config(with_fake_datasource=False)
self.datasource_model = services['api']['api-datasource']
self.data = services['data']
self.node = services['node']
self.engine = services['engine']
self.ds_manager = services['ds_manager']
self.datasource = self._get_datasource_request()
self.ds_manager.add_datasource(self.datasource)
def test__check_monasca_webhook_driver_warning(self):
services = api_base.setup_config(with_fake_datasource=False)
self.datasource_model = services['api']['api-datasource']
self.data = services['data']
self.node = services['node']
self.engine = services['engine']
self.ds_manager = services['ds_manager']
monasca_setting = {
'name': 'datasource_name',
'driver': 'monasca_webhook',
'config': None,
}
self.ds_manager.add_datasource(monasca_setting)
check_result = self.cmd._check_monasca_webhook_driver()
self.assertEqual(
Code.WARNING, check_result.code)
def test_enable_schema(self, patched_persisted_rules):
class TestRule(object):
def __init__(self, id, name, rule_str, policy_name, comment=None):
self.id = id
self.name = name
self.rule = rule_str
self.policy_name = policy_name
self.comment = comment
persisted_rule = [
TestRule('rule-id', 'rule-name', "p(x):-nova:services(id=x)",
'classification'),
]
patched_persisted_rules.return_value = persisted_rule
services = tests_api_base.setup_config()
engine2 = services['engine']
node = services['node']
node.invoke_service_rpc = mock.MagicMock()
node.invoke_service_rpc.return_value = [
['id1', 'name1', 'status1'],
['id2', 'name2', 'status2'],
]
# loaded rule is disabled
subscriptions = engine2.subscription_list()
self.assertEqual([], subscriptions)
nova_schema = {
'services': [{
'name': 'id',
'desc': 'id of the service'
}, {
'name': 'name',
'desc': 'name of the service'
}, {
'name': 'status',
'desc': 'status of the service'
}]
}
engine2.initialize_datasource('nova', nova_schema)
# loaded rule is enabled and subscribes the table
subscriptions = engine2.subscription_list()
self.assertEqual([('nova', 'services')], subscriptions)
def setUp(self):
super(APILocalRouting, self).setUp()
# set up second API+PE node
self.services = tests_api_base.setup_config(
with_fake_datasource=False, node_id='testnode2',
same_partition_as_node=self.node)
self.api2 = self.services['api']
self.node2 = self.services['node']
self.engine2 = self.services['engine']
self.data = self.services['data']
# add different data to two PE instances
# going directly to agnostic not via API to make sure faulty API
# routing (subject of the test) would not affect test accuracy
self.engine.create_policy('policy')
self.engine2.create_policy('policy')
self.engine.insert('p(1) :- NOT q()', 'policy')
# self.engine1.insert('p(1)', 'policy')
self.engine2.insert('p(2) :- NOT q()', 'policy')
self.engine2.insert('p(3) :- NOT q()', 'policy')
def setUp(self):
super(APILocalRouting, self).setUp()
# set up second API+PE node
self.services = tests_api_base.setup_config(
with_fake_datasource=False, node_id='testnode2',
same_partition_as_node=self.node)
self.api2 = self.services['api']
self.node2 = self.services['node']
self.engine2 = self.services['engine']
self.data = self.services['data']
# add different data to two PE instances
# going directly to agnostic not via API to make sure faulty API
# routing (subject of the test) would not affect test accuracy
self.engine.create_policy('policy')
self.engine2.create_policy('policy')
self.engine.insert('p(1) :- NOT q()', 'policy')
# self.engine1.insert('p(1)', 'policy')
self.engine2.insert('p(2) :- NOT q()', 'policy')
self.engine2.insert('p(3) :- NOT q()', 'policy')
def test_enable_schema(self, patched_persisted_rules):
class TestRule(object):
def __init__(self, id, name, rule_str,
policy_name, comment=None):
self.id = id
self.name = name
self.rule = rule_str
self.policy_name = policy_name
self.comment = comment
persisted_rule = [
TestRule('rule-id', 'rule-name',
"p(x):-nova:services(id=x)", 'classification'),
]
patched_persisted_rules.return_value = persisted_rule
services = tests_api_base.setup_config()
engine2 = services['engine']
node = services['node']
node.invoke_service_rpc = mock.MagicMock()
node.invoke_service_rpc.return_value = [
0, [['id1', 'name1', 'status1'], ['id2', 'name2', 'status2']]]
# loaded rule is disabled
subscriptions = engine2.subscription_list()
self.assertEqual([], subscriptions)
nova_schema = {
'services': [
{'name': 'id', 'desc': 'id of the service'},
{'name': 'name', 'desc': 'name of the service'},
{'name': 'status', 'desc': 'status of the service'}]}
engine2.initialize_datasource('nova', nova_schema)
# loaded rule is enabled and subscribes the table
subscriptions = engine2.subscription_list()
self.assertEqual([('nova', 'services')], subscriptions)
def setUp(self):
super(TestDriverModel, self).setUp()
services = api_base.setup_config()
self.node = services['node']
self.driver_model = services['api']['api-system']
def setUp(self):
super(TestActionModel, self).setUp()
services = api_base.setup_config()
self.action_model = services['api']['api-action']
self.datasource = services['data']
def setUp(self):
super(TestSchemaModel, self).setUp()
services = api_base.setup_config()
self.schema_model = services['api']['api-schema']
self.data = services['data']
def setUp(self):
super(TestWebhookModel, self).setUp()
services = api_base.setup_config()
self.webhook_model = services['api']['api-webhook']
self.node = services['node']
self.data = services['data']
def setUp(self):
super(TestDriverModel, self).setUp()
services = api_base.setup_config()
self.node = services['node']
self.driver_model = services['api']['api-system']
def setUp(self):
super(TestDataSource, self).setUp()
self.dseNode = api_base.setup_config(with_fake_datasource=False,
api=False, policy=False)['node']
def setUp(self):
super(TestSchemaModel, self).setUp()
services = api_base.setup_config()
self.schema_model = services['api']['api-schema']
self.data = services['data']
def setUp(self):
super(TestDataSource, self).setUp()
self.dseNode = api_base.setup_config(with_fake_datasource=False,
api=False,
policy=False)['node']
def setUp(self):
super(TestActionModel, self).setUp()
services = api_base.setup_config()
self.action_model = services['api']['api-action']
self.datasource = services['data']
