def setUp(self):
self.body = {'worker_status': 'online'}
self.body_disk = {
"disk_usage": {
"/dev/sda1": {
"total": 313764528,
"used": 112512436
}
}
}
self.body_load = {
"load_average": {
"1": 0.24755859375,
"5": 1.0751953125,
"15": 0.9365234375
}
}
self.body_bad = {'not_status': 'bad_status'}
self.status = jsonutils.dumps(self.body)
self.disk = jsonutils.dumps(self.body_disk)
self.load = jsonutils.dumps(self.body_load)
self.status = jsonutils.dumps(self.body)
self.req = MagicMock()
self.resp = MagicMock()
self.registration = WorkerRegistration('correlation').format()
self.worker_dict = Worker(**self.registration).format()
self.worker_not_found = None
self.db_handler = MagicMock()
self.resource = WorkerUpdateResource(self.db_handler)
self.worker_id = '51375fc4eea50d53066292b6'
def set_token(self, tenant_id, token):
if self.cache.cache_exists(tenant_id, CACHE_TOKEN):
self.cache.cache_update(tenant_id, jsonutils.dumps(token.format()),
DEFAULT_EXPIRES, CACHE_TOKEN)
else:
self.cache.cache_set(tenant_id, jsonutils.dumps(token.format()),
DEFAULT_EXPIRES, CACHE_TOKEN)
def set_config(self, worker_config):
if self.cache.cache_exists('worker_configuration', CACHE_CONFIG):
self.cache.cache_update('worker_configuration',
jsonutils.dumps(worker_config.format()),
CONFIG_EXPIRES, CACHE_CONFIG)
else:
self.cache.cache_set('worker_configuration',
jsonutils.dumps(worker_config.format()),
CONFIG_EXPIRES, CACHE_CONFIG)
def set_tenant(self, tenant):
if self.cache.cache_exists(tenant.tenant_id, CACHE_TENANT):
self.cache.cache_update(
tenant.tenant_id, jsonutils.dumps(tenant.format()),
DEFAULT_EXPIRES, CACHE_TENANT)
else:
self.cache.cache_set(
tenant.tenant_id, jsonutils.dumps(tenant.format()),
DEFAULT_EXPIRES, CACHE_TENANT)
def set_tenant(self, tenant):
if self.cache.cache_exists(tenant.tenant_id, CACHE_TENANT):
self.cache.cache_update(
tenant.tenant_id, jsonutils.dumps(tenant.format()),
DEFAULT_EXPIRES, CACHE_TENANT)
else:
self.cache.cache_set(
tenant.tenant_id, jsonutils.dumps(tenant.format()),
DEFAULT_EXPIRES, CACHE_TENANT)
def set_token(self, tenant_id, token):
if self.cache.cache_exists(tenant_id, CACHE_TOKEN):
self.cache.cache_update(
tenant_id, jsonutils.dumps(token.format()),
DEFAULT_EXPIRES, CACHE_TOKEN)
else:
self.cache.cache_set(
tenant_id, jsonutils.dumps(token.format()),
DEFAULT_EXPIRES, CACHE_TOKEN)
def set_config(self, worker_config):
if self.cache.cache_exists('worker_configuration', CACHE_CONFIG):
self.cache.cache_update(
'worker_configuration',
jsonutils.dumps(worker_config.format()),
CONFIG_EXPIRES, CACHE_CONFIG)
else:
self.cache.cache_set(
'worker_configuration',
jsonutils.dumps(worker_config.format()),
CONFIG_EXPIRES, CACHE_CONFIG)
def set_routes(self, pipeline_workers):
if self.cache.cache_exists('routes', CACHE_CONFIG):
self.cache.cache_update(
'routes',
jsonutils.dumps(pipeline_workers),
CONFIG_EXPIRES, CACHE_CONFIG)
else:
self.cache.cache_set(
'routes',
jsonutils.dumps(pipeline_workers),
CONFIG_EXPIRES, CACHE_CONFIG)
def setUp(self):
self.tenant_id = "12673247623548752387452378"
self.tenant_dict = {
"tenant_id":
self.tenant_id,
"tenant_name":
"TenantName",
"_id":
"507f1f77bcf86cd799439011",
"event_producers": [{
"id": 123,
"name": "apache",
"pattern": "apache2.cee",
"durable": False,
"encrypted": False,
"sinks": ["elasticsearch"]
}, {
"id": 124,
"name": "system.auth",
"pattern": "auth_log.cee",
"durable": False,
"encrypted": False,
"sinks": ["elasticsearch", "hdfs"]
}],
"token": {
"valid": "c8a4db32-635a-46b6-94ed-04b1bd533f41",
"previous": None,
"last_changed": "2013-03-19T18:16:48.411029Z"
}
}
self.producer_id = "234"
self.event_producer = EventProducer(_id=self.producer_id,
name="nginx",
pattern="nginx")
self.ds_handler = MagicMock()
self.ds_handler.find_one.return_value = self.tenant_dict
self.tenant_obj = tenant_util.load_tenant_from_dict(self.tenant_dict)
self.tenant_cache = MagicMock()
self.tenant_cache.cache_get.return_value = jsonutils.dumps(
self.tenant_dict)
self.tenant_cache.cache_exists.return_value = True
self.tenant_cache.cache_update = MagicMock()
self.token_cache = MagicMock()
self.token_cache.cache_get.return_value = jsonutils.dumps(
self.tenant_dict['token'])
self.token_cache.cache_exists.return_value = True
self.cache_empty = MagicMock()
self.cache_empty.cache_exists.return_value = False
self.cache_empty.cache_set = MagicMock()
def setUp(self):
self.tenant_id = "12673247623548752387452378"
self.tenant_dict = {
"tenant_id": self.tenant_id,
"tenant_name": "TenantName",
"_id": "507f1f77bcf86cd799439011",
"event_producers": [
{
"id": 123,
"name": "apache",
"pattern": "apache2.cee",
"durable": False,
"encrypted": False,
"sinks": ["elasticsearch"]
},
{
"id": 124,
"name": "system.auth",
"pattern": "auth_log.cee",
"durable": False,
"encrypted": False,
"sinks": ["elasticsearch", "hdfs"]
}
],
"token": {
"valid": "c8a4db32-635a-46b6-94ed-04b1bd533f41",
"previous": None,
"last_changed": "2013-03-19T18:16:48.411029Z"
}
}
self.producer_id = "234"
self.event_producer = EventProducer(
_id=self.producer_id, name="nginx", pattern="nginx")
self.ds_handler = MagicMock()
self.ds_handler.find_one.return_value = self.tenant_dict
self.tenant_obj = tenant_util.load_tenant_from_dict(self.tenant_dict)
self.tenant_cache = MagicMock()
self.tenant_cache.cache_get.return_value = jsonutils.dumps(
self.tenant_dict)
self.tenant_cache.cache_exists.return_value = True
self.tenant_cache.cache_update = MagicMock()
self.token_cache = MagicMock()
self.token_cache.cache_get.return_value = jsonutils.dumps(
self.tenant_dict['token'])
self.token_cache.cache_exists.return_value = True
self.cache_empty = MagicMock()
self.cache_empty.cache_exists.return_value = False
self.cache_empty.cache_set = MagicMock()
def setUp(self):
self.tenant = {
"tenant_id": "12345",
"tenant_name": "TenantName",
"_id": "507f1f77bcf86cd799439011",
"event_producers": [
{
"id": 123,
"name": "apache",
"pattern": "apache2.cee",
"durable": False,
"encrypted": False,
"sinks": ["elasticsearch"]
},
{
"id": 124,
"name": "system.auth",
"pattern": "auth_log.cee",
"durable": False,
"encrypted": False,
"sinks": ["elasticsearch", "hdfs"]
}
],
"token": {
"valid": "c8a4db32-635a-46b6-94ed-04b1bd533f41",
"previous": None,
"last_changed": "2013-03-19T18:16:48.411029Z"
}
}
self.ds_handler = MagicMock()
self.ds_handler.find_one.return_value = self.tenant
self.ds_handler_empty = MagicMock()
self.ds_handler_empty.find_one.return_value = None
self.ds_handler_no_tenant = MagicMock()
self.ds_handler_no_tenant.put = MagicMock()
self.ds_handler_no_tenant.find_one.side_effect = [None, self.tenant]
self.tenant_cache = MagicMock()
self.tenant_cache.cache_get.return_value = jsonutils.dumps(self.tenant)
self.tenant_cache.cache_exists.return_value = True
self.tenant_cache.cache_update = MagicMock()
self.token_cache = MagicMock()
self.token_cache.cache_get.return_value = jsonutils.dumps(
self.tenant['token'])
self.token_cache.cache_exists.return_value = True
self.cache_empty = MagicMock()
self.cache_empty.cache_exists.return_value = False
self.cache_empty.cache_set = MagicMock()
def setUp(self):
self.tenant = {
"tenant_id":
"12345",
"tenant_name":
"TenantName",
"_id":
"507f1f77bcf86cd799439011",
"event_producers": [{
"id": 123,
"name": "apache",
"pattern": "apache2.cee",
"durable": False,
"encrypted": False,
"sinks": ["elasticsearch"]
}, {
"id": 124,
"name": "system.auth",
"pattern": "auth_log.cee",
"durable": False,
"encrypted": False,
"sinks": ["elasticsearch", "hdfs"]
}],
"token": {
"valid": "c8a4db32-635a-46b6-94ed-04b1bd533f41",
"previous": None,
"last_changed": "2013-03-19T18:16:48.411029Z"
}
}
self.ds_handler = MagicMock()
self.ds_handler.find_one.return_value = self.tenant
self.ds_handler_empty = MagicMock()
self.ds_handler_empty.find_one.return_value = None
self.ds_handler_no_tenant = MagicMock()
self.ds_handler_no_tenant.put = MagicMock()
self.ds_handler_no_tenant.find_one.side_effect = [None, self.tenant]
self.tenant_cache = MagicMock()
self.tenant_cache.cache_get.return_value = jsonutils.dumps(self.tenant)
self.tenant_cache.cache_exists.return_value = True
self.tenant_cache.cache_update = MagicMock()
self.token_cache = MagicMock()
self.token_cache.cache_get.return_value = jsonutils.dumps(
self.tenant['token'])
self.token_cache.cache_exists.return_value = True
self.cache_empty = MagicMock()
self.cache_empty.cache_exists.return_value = False
self.cache_empty.cache_set = MagicMock()
def test_return_201_for_multiple_supported_sink(self):
save_tenant = MagicMock()
create_event_producer = MagicMock()
with patch(
'meniscus.api.tenant.resources.tenant_util.find_tenant',
self.tenant_found), \
patch(
'meniscus.api.tenant.resources.tenant_util.save_tenant',
save_tenant), \
patch(
'meniscus.api.tenant.resources.'
'tenant_util.create_event_producer',
create_event_producer):
self.simulate_request(
self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(
{
'event_producer': {
'name': 'producer55',
'pattern': 'syslog',
'sinks': ["elasticsearch", "hdfs"]
}
}
)
)
self.assertEqual(falcon.HTTP_201, self.srmock.status)
def test_return_201_for_multiple_supported_sink(self):
save_tenant = MagicMock()
create_event_producer = MagicMock()
with patch(
'meniscus.api.tenant.resources.tenant_util.find_tenant',
self.tenant_found), \
patch(
'meniscus.api.tenant.resources.tenant_util.save_tenant',
save_tenant), \
patch(
'meniscus.api.tenant.resources.'
'tenant_util.create_event_producer',
create_event_producer):
self.simulate_request(self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps({
'event_producer': {
'name': 'producer55',
'pattern': 'syslog',
'sinks': ["elasticsearch", "hdfs"]
}
}))
self.assertEqual(falcon.HTTP_201, self.srmock.status)
def test_return_201_with_optional_fields(self):
save_tenant = MagicMock()
create_event_producer = MagicMock()
with patch(
'meniscus.api.tenant.resources.tenant_util.find_tenant',
self.tenant_found), \
patch(
'meniscus.api.tenant.resources.tenant_util.save_tenant',
save_tenant), \
patch(
'meniscus.api.tenant.resources.'
'tenant_util.create_event_producer',
create_event_producer):
self.simulate_request(self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps({
'event_producer': {
'name': 'producer55',
'pattern': 'syslog',
'durable': True,
'encrypted': False,
'sinks': ['elasticsearch']
}
}))
self.assertEqual(falcon.HTTP_201, self.srmock.status)
def test_return_201_with_optional_fields(self):
save_tenant = MagicMock()
create_event_producer = MagicMock()
with patch(
'meniscus.api.tenant.resources.tenant_util.find_tenant',
self.tenant_found), \
patch(
'meniscus.api.tenant.resources.tenant_util.save_tenant',
save_tenant), \
patch(
'meniscus.api.tenant.resources.'
'tenant_util.create_event_producer',
create_event_producer):
self.simulate_request(
self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(
{
'event_producer': {
'name': 'producer55',
'pattern': 'syslog',
'durable': True,
'encrypted': False,
'sinks': ['elasticsearch']
}
}
)
)
self.assertEqual(falcon.HTTP_201, self.srmock.status)
def format(self, record):
message = {'message': record.getMessage(),
'asctime': self.formatTime(record, self.datefmt),
'name': record.name,
'msg': record.msg,
'args': record.args,
'levelname': record.levelname,
'levelno': record.levelno,
'pathname': record.pathname,
'filename': record.filename,
'module': record.module,
'lineno': record.lineno,
'funcname': record.funcName,
'created': record.created,
'msecs': record.msecs,
'relative_created': record.relativeCreated,
'thread': record.thread,
'thread_name': record.threadName,
'process_name': record.processName,
'process': record.process,
'traceback': None}
if hasattr(record, 'extra'):
message['extra'] = record.extra
if record.exc_info:
message['traceback'] = self.formatException(record.exc_info)
return jsonutils.dumps(message)
def test_return_200_producer_updated(self):
save_tenant = MagicMock()
with patch(
'meniscus.api.tenant.resources.tenant_util.find_tenant',
self.tenant_found), \
patch(
'meniscus.api.tenant.resources.tenant_util.save_tenant',
save_tenant):
self.simulate_request(
'/v1/tenant/{tenant_id}/producers/{event_producer_id}'.format(
tenant_id=self.tenant_id,
event_producer_id=self.producer_id
),
method='PUT',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(
{
'event_producer': {
'name': self.producer_name,
'pattern': 'syslog',
'encrypted': False,
'durable': False
}
}
)
)
self.assertEqual(falcon.HTTP_200, self.srmock.status)
def _register_with_coordinator(self, coordinator_uri, personality,
registration, auth_header):
"""
register with the coordinator and persist the configuration to cache
"""
try:
resp = http_request(coordinator_uri + '/pairing',
auth_header,
jsonutils.dumps(registration),
http_verb='POST')
except requests.RequestException:
_LOG.exception(
'Pairing Process: error posting worker registration')
return False
_LOG.debug('resp.status_code: {0}'.format(resp.status_code))
if resp.status_code == httplib.ACCEPTED:
body = resp.json()['worker_identity']
config = WorkerConfiguration(personality,
body['personality_module'],
body['worker_token'],
body['worker_id'], coordinator_uri)
config_cache = ConfigCache()
config_cache.set_config(config)
return True
def format(self, record):
message = {
'message': record.getMessage(),
'asctime': self.formatTime(record, self.datefmt),
'name': record.name,
'msg': record.msg,
'args': record.args,
'levelname': record.levelname,
'levelno': record.levelno,
'pathname': record.pathname,
'filename': record.filename,
'module': record.module,
'lineno': record.lineno,
'funcname': record.funcName,
'created': record.created,
'msecs': record.msecs,
'relative_created': record.relativeCreated,
'thread': record.thread,
'thread_name': record.threadName,
'process_name': record.processName,
'process': record.process,
'traceback': None
}
if hasattr(record, 'extra'):
message['extra'] = record.extra
if record.exc_info:
message['traceback'] = self.formatException(record.exc_info)
return jsonutils.dumps(message)
def _send_target_list_to_broadcaster(db, worker):
"""
send broadcast list to broadcaster
"""
# list of broadcasters
broadcasters = _get_broadcaster_list(db)
if not broadcasters:
## todo log no online broadcasters
return False
# list of broadcast targets
broadcast_targets = _get_broadcast_targets(db, worker)
if not broadcast_targets:
## todo: log failed to find target
return False
for broadcaster_uri in broadcasters:
resp = None
try:
## todo refactor callback address to not include /v1/callback/"
resp = http_request(
'{0}:8080/v1/broadcast'.format(broadcaster_uri),
jsonutils.dumps(broadcast_targets), http_verb='PUT')
except requests.RequestException:
raise coordinator_errors.BroadcasterCommunicationError
if resp.status_code == httplib.OK:
return True
else:
## todo Log broadcaster connection failure
return False
def _register_with_coordinator(
self, coordinator_uri, personality, registration, auth_header):
"""
register with the coordinator and persist the configuration to cache
"""
try:
resp = http_request(coordinator_uri + '/pairing', auth_header,
jsonutils.dumps(
registration), http_verb='POST')
except requests.RequestException:
_LOG.exception(
'Pairing Process: error posting worker registration')
return False
_LOG.debug('resp.status_code: {0}'.format(resp.status_code))
if resp.status_code == httplib.ACCEPTED:
body = resp.json()['worker_identity']
config = WorkerConfiguration(
personality, body['personality_module'], body['worker_token'],
body['worker_id'], coordinator_uri)
config_cache = ConfigCache()
config_cache.set_config(config)
return True
def test_returns_200_worker_status(self):
self.db_handler.find_one.return_value = self.worker_dict
self.simulate_request(self.test_route,
method='PUT',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(self.worker_status))
self.assertEqual(falcon.HTTP_200, self.srmock.status)
def test_return_400_for_invalidate_now_not_provided(self):
with patch('meniscus.api.tenant.resources.find_tenant',
self.tenant_found):
self.simulate_request(self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps({'token': {}}))
self.assertEqual(falcon.HTTP_400, self.srmock.status)
def test_returns_400_body_validation(self):
with patch('meniscus.data.model.worker_util.save_worker', MagicMock()):
self.simulate_request(
self.test_route,
method='PUT',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(self.bad_worker_status))
self.assertEqual(falcon.HTTP_400, self.srmock.status)
def test_returns_200_worker_status(self):
self.db_handler.find_one.return_value = self.worker_dict
self.simulate_request(
self.test_route,
method='PUT',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(self.worker_status))
self.assertEqual(falcon.HTTP_200, self.srmock.status)
def test_returns_400_for_bad_personality(self):
self.simulate_request(
self.test_route,
method='POST',
headers={
'content-type': 'application/json',
},
body=jsonutils.dumps(self.body_bad_personality))
self.assertEqual(falcon.HTTP_400, self.srmock.status)
def test_return_400_for_tenant_id_empty(self):
with patch('meniscus.api.tenant.resources.tenant_util.find_tenant',
self.tenant_not_found):
self.simulate_request(
self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps({'tenant': {"tenant_id": ""}}))
self.assertEqual(falcon.HTTP_400, self.srmock.status)
def test_returns_415_for_unsupported_content_type(self):
self.simulate_request(
self.test_route,
method='POST',
headers={
'content-type': 'application/xml',
},
body=jsonutils.dumps(self.body))
self.assertEqual(falcon.HTTP_415, self.srmock.status)
def test_returns_400_for_bad_personality(self):
self.simulate_request(
self.test_route,
method='POST',
headers={
'content-type': 'application/json',
},
body=jsonutils.dumps(self.body_bad_personality))
self.assertEqual(falcon.HTTP_400, self.srmock.status)
def test_returns_400_for_no_message_token_header(self):
self.simulate_request(
self.test_route,
method='POST',
headers={
'content-type': 'application/json'
},
body=jsonutils.dumps(self.message))
self.assertEquals(falcon.HTTP_400, self.srmock.status)
def test_returns_202_for_registered_worker(self):
self.simulate_request(
self.test_route,
method='POST',
headers={
'content-type': 'application/json',
},
body=jsonutils.dumps(self.body))
self.assertEqual(falcon.HTTP_202, self.srmock.status)
def test_raises_worker_not_found(self):
with patch('meniscus.data.model.worker_util.find_worker',
MagicMock(return_value=None)):
self.simulate_request(
self.test_route,
method='PUT',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(self.worker_status))
self.assertEqual(falcon.HTTP_404, self.srmock.status)
def test_returns_415_for_unsupported_content_type(self):
self.simulate_request(
self.test_route,
method='POST',
headers={
'content-type': 'application/xml',
},
body=jsonutils.dumps(self.body))
self.assertEqual(falcon.HTTP_415, self.srmock.status)
def test_set_tenant_calls_cache_update(self):
with patch.object(
NativeProxy, 'cache_exists', self.cache_true
), patch.object(NativeProxy, 'cache_update', self.cache_update):
tenant_cache = TenantCache()
tenant_cache.set_tenant(self.tenant)
self.cache_update.assert_called_once_with(
self.tenant_id, jsonutils.dumps(self.tenant.format()),
DEFAULT_EXPIRES, CACHE_TENANT)
def test_should_return_200_on_post(self):
with patch('meniscus.api.pairing.resources.PairingProcess',
MagicMock()):
self.simulate_request(self.test_route,
method='POST',
headers={
'content-type': 'application/json',
},
body=jsonutils.dumps(self.configuration))
self.assertEqual(falcon.HTTP_200, self.srmock.status)
def test_set_token_calls_cache_set(self):
with patch.object(
NativeProxy, 'cache_exists', self.cache_false
), patch.object(NativeProxy, 'cache_set', self.cache_set):
token_cache = TokenCache()
token_cache.set_token(self.tenant_id, self.token)
self.cache_set.assert_called_once_with(
self.tenant_id, jsonutils.dumps(self.token.format()),
DEFAULT_EXPIRES, CACHE_TOKEN)
def test_set_config_calls_cache_set(self):
with patch.object(NativeProxy, 'cache_exists',
self.cache_false), patch.object(
NativeProxy, 'cache_set', self.cache_set):
config_cache = ConfigCache()
config_cache.set_config(self.config)
self.cache_set.assert_called_once_with(
'worker_configuration', jsonutils.dumps(self.config.format()),
CONFIG_EXPIRES, CACHE_CONFIG)
def test_set_config_calls_cache_set(self):
with patch.object(
NativeProxy, 'cache_exists', self.cache_false
), patch.object(NativeProxy, 'cache_set', self.cache_set):
config_cache = ConfigCache()
config_cache.set_config(self.config)
self.cache_set.assert_called_once_with(
'worker_configuration', jsonutils.dumps(self.config.format()),
CONFIG_EXPIRES, CACHE_CONFIG)
def test_set_token_calls_cache_set(self):
with patch.object(NativeProxy, 'cache_exists',
self.cache_false), patch.object(
NativeProxy, 'cache_set', self.cache_set):
token_cache = TokenCache()
token_cache.set_token(self.tenant_id, self.token)
self.cache_set.assert_called_once_with(
self.tenant_id, jsonutils.dumps(self.token.format()),
DEFAULT_EXPIRES, CACHE_TOKEN)
def test_set_tenant_calls_cache_update(self):
with patch.object(NativeProxy, 'cache_exists',
self.cache_true), patch.object(
NativeProxy, 'cache_update', self.cache_update):
tenant_cache = TenantCache()
tenant_cache.set_tenant(self.tenant)
self.cache_update.assert_called_once_with(
self.tenant_id, jsonutils.dumps(self.tenant.format()),
DEFAULT_EXPIRES, CACHE_TENANT)
def test_set_routes_calls_cache_set(self):
with patch.object(
NativeProxy, 'cache_exists', self.cache_false
), patch.object(NativeProxy, 'cache_set', self.cache_set):
config_cache = ConfigCache()
config_cache.set_routes(self.routes)
self.cache_set.assert_called_once_with(
'routes', jsonutils.dumps(self.routes),
CONFIG_EXPIRES, CACHE_CONFIG)
def setUp(self):
self.cache_clear = MagicMock()
self.cache_true = MagicMock(return_value=True)
self.cache_false = MagicMock(return_value=False)
self.cache_update = MagicMock()
self.cache_set = MagicMock()
self.cache_del = MagicMock()
self.config = WorkerConfiguration(
personality='correlation',
personality_module='meniscus.personas.worker.correlation.app',
worker_id='fgc7104e-8d93-47dc-a49a-8fb0d39e5192',
worker_token='bbd6307f-8d93-47dc-a49a-8fb0d39e5192',
coordinator_uri='http://192.168.1.2/v1')
self.config_json = jsonutils.dumps(self.config.format())
self.cache_get_config = MagicMock(return_value=self.config_json)
self.routes = [
{
"service_domain": "correlation|normalization|storage",
"targets": [
{
"worker_id": "488eb3fc-34dd-48ad-a1bb-99ee2a43bf1d",
"ip_address_v4": "192.168.100.101",
"ip_address_v6": "::1",
"status": "online|draining"
},
{
"worker_id": "e0ac0dc3-694e-4522-94f0-fb25a4dbb8a1",
"ip_address_v4": "192.168.100.102",
"ip_address_v6": "::1",
"status": "online|draining"
},
{
"worker_id": "64d7a5ab-55b6-4ff7-b362-0d67544bb6f8",
"ip_address_v4": "192.168.100.103",
"ip_address_v6": "::1",
"status": "online|draining"
}
]
}
]
self.routes_json = jsonutils.dumps(self.routes)
self.cache_get_routes = MagicMock(return_value=self.routes_json)
def test_return_200_for_tenant_created(self):
with patch('meniscus.api.tenant.resources.find_tenant',
self.tenant_not_found):
self.simulate_request(self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(
{'tenant': {
"tenant_id": "1234"
}}))
self.assertEqual(falcon.HTTP_201, self.srmock.status)
def setUp(self):
self.cache_clear = MagicMock()
self.cache_true = MagicMock(return_value=True)
self.cache_false = MagicMock(return_value=False)
self.cache_update = MagicMock()
self.cache_set = MagicMock()
self.cache_del = MagicMock()
self.tenant_id = '101'
self.token = Token()
self.token_json = jsonutils.dumps(self.token.format())
self.cache_get_token = MagicMock(return_value=self.token_json)
def setUp(self):
self.cache_clear = MagicMock()
self.cache_true = MagicMock(return_value=True)
self.cache_false = MagicMock(return_value=False)
self.cache_update = MagicMock()
self.cache_set = MagicMock()
self.cache_del = MagicMock()
self.tenant_id = '101'
self.token = Token()
self.token_json = jsonutils.dumps(self.token.format())
self.cache_get_token = MagicMock(return_value=self.token_json)
def test_should_return_200_on_post(self):
with patch('meniscus.api.pairing.resources.PairingProcess',
MagicMock()):
self.simulate_request(
self.test_route,
method='POST',
headers={
'content-type': 'application/json',
},
body=jsonutils.dumps(self.configuration))
self.assertEqual(falcon.HTTP_200, self.srmock.status)
def test_should_return_true_for_register_with_coordinator(self):
self.resp.status_code = httplib.ACCEPTED
self.resp._content = jsonutils.dumps({
'worker_identity': {
"personality_module": "meniscus.personas.pairing.app",
"worker_token": "3F2504E0-4F89-11D3-9A0C-0305E82C3301",
"worker_id": "3F2504E0-4F89-11D3-9A0C-0305E82C3301"
}
})
auth_header = {'X-AUTH-TOKEN': self.api_secret}
with patch('meniscus.api.pairing.pairing_process.'
'http_request', self.http_request):
self.assertTrue(
self.pairing_process._register_with_coordinator(
self.coordinator_uri, self.personality, self.registration,
auth_header))
self.http_request.assert_called_once_with(
self.coordinator_uri + '/pairing',
auth_header,
jsonutils.dumps(self.registration),
http_verb='POST')
def test_should_return_true_for_register_with_coordinator(self):
self.resp.status_code = httplib.ACCEPTED
self.resp._content = jsonutils.dumps({
'worker_identity': {
"personality_module": "meniscus.personas.pairing.app",
"worker_token": "3F2504E0-4F89-11D3-9A0C-0305E82C3301",
"worker_id": "3F2504E0-4F89-11D3-9A0C-0305E82C3301"
}
})
auth_header = {'X-AUTH-TOKEN': self.api_secret}
with patch('meniscus.api.pairing.pairing_process.'
'http_request', self.http_request):
self.assertTrue(
self.pairing_process._register_with_coordinator(
self.coordinator_uri, self.personality,
self.registration, auth_header))
self.http_request.assert_called_once_with(
self.coordinator_uri + '/pairing',
auth_header,
jsonutils.dumps(self.registration),
http_verb='POST')
def test_return_201_without_optional_fields(self):
with patch('meniscus.api.tenant.resources.find_tenant',
self.tenant_found):
self.simulate_request(self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps({
'event_producer': {
'name': 'producer55',
'pattern': 'syslog'
}
}))
self.assertEqual(falcon.HTTP_201, self.srmock.status)
def setUp(self):
self.cache_clear = MagicMock()
self.cache_true = MagicMock(return_value=True)
self.cache_false = MagicMock(return_value=False)
self.cache_update = MagicMock()
self.cache_set = MagicMock()
self.cache_del = MagicMock()
self.config = WorkerConfiguration(
personality='worker',
hostname='worker01',
coordinator_uri='http://192.168.1.2/v1')
self.config_json = jsonutils.dumps(self.config.format())
self.cache_get_config = MagicMock(return_value=self.config_json)
def test_return_200_for_new_worker_when_worker_found(self):
save_worker = MagicMock()
with patch('meniscus.data.model.worker_util.find_worker',
MagicMock(return_value=self.returned_worker)), \
patch('meniscus.data.model.worker_util.save_worker',
save_worker):
self.simulate_request(
self.test_route,
method='PUT',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(self.worker))
def test_returns_202_for_non_durable_message(self):
correlate_http_msg_func = MagicMock()
with patch('meniscus.correlation.correlator.correlate_http_message',
correlate_http_msg_func):
self.simulate_request(self.test_route,
method='POST',
headers={
'content-type': 'application/json',
MESSAGE_TOKEN: self.token
},
body=jsonutils.dumps(self.message))
correlate_http_msg_func.assert_called_once()
self.assertEquals(falcon.HTTP_202, self.srmock.status)
def test_return_400_for_bad_encrypted(self):
with patch('meniscus.api.tenant.resources.find_tenant',
self.tenant_found):
self.simulate_request(self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps({
'event_producer': {
'name': self.producer_name,
'pattern': 'syslog',
'encrypted': "true"
}
}))
self.assertEqual(falcon.HTTP_400, self.srmock.status)
def test_return_201_for_one_supported_sink(self):
with patch('meniscus.api.tenant.resources.find_tenant',
self.tenant_found):
self.simulate_request(self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps({
'event_producer': {
'name': 'producer55',
'pattern': 'syslog',
'sinks': ['elasticsearch']
}
}))
self.assertEqual(falcon.HTTP_201, self.srmock.status)
def setUp(self):
self.cache_clear = MagicMock()
self.cache_true = MagicMock(return_value=True)
self.cache_false = MagicMock(return_value=False)
self.cache_update = MagicMock()
self.cache_set = MagicMock()
self.cache_del = MagicMock()
self.config = WorkerConfiguration(
personality='correlation',
personality_module='meniscus.personas.worker.correlation.app',
worker_id='fgc7104e-8d93-47dc-a49a-8fb0d39e5192',
worker_token='bbd6307f-8d93-47dc-a49a-8fb0d39e5192',
coordinator_uri='http://192.168.1.2/v1')
self.config_json = jsonutils.dumps(self.config.format())
self.cache_get_config = MagicMock(return_value=self.config_json)
self.routes = [{
"service_domain":
"correlation|normalization|storage",
"targets": [{
"worker_id": "488eb3fc-34dd-48ad-a1bb-99ee2a43bf1d",
"ip_address_v4": "192.168.100.101",
"ip_address_v6": "::1",
"status": "online|draining"
}, {
"worker_id": "e0ac0dc3-694e-4522-94f0-fb25a4dbb8a1",
"ip_address_v4": "192.168.100.102",
"ip_address_v6": "::1",
"status": "online|draining"
}, {
"worker_id": "64d7a5ab-55b6-4ff7-b362-0d67544bb6f8",
"ip_address_v4": "192.168.100.103",
"ip_address_v6": "::1",
"status": "online|draining"
}]
}]
self.routes_json = jsonutils.dumps(self.routes)
self.cache_get_routes = MagicMock(return_value=self.routes_json)
def test_return_203_for_invalidate_now_false(self):
with patch('meniscus.api.tenant.resources.find_tenant',
self.tenant_found):
self.simulate_request(self.test_route,
method='POST',
headers={'content-type': 'application/json'},
body=jsonutils.dumps(
{'token': {
'invalidate_now': False
}}))
self.assertEqual(falcon.HTTP_203, self.srmock.status)
self.assertNotEqual(self.tenant.token.valid, self.token_original)
self.assertEqual(self.tenant.token.previous, self.token_original)
self.assertGreater(self.tenant.token.last_changed,
self.timestamp_original)
