def add_datapoints(self):
"""Add new datapoints to the database.
Args:
None
Returns:
None
"""
# Initialize key variables
new_datapoint_ids = []
# Add newly found datapoints to database if agent is enabled
agent_object = agent.GetIDXAgent(self._idx_agent)
if agent_object.enabled() is True:
# Create map of DIDs to database row index values
dp_metadata = self.get_datapoints()
# Update datapoint metadata if not there
# Use a dictionary query versus individual database calls
# which was slow.
for source in self.agent_data['sources']:
id_datapoint = source['id_datapoint']
if id_datapoint not in dp_metadata:
# This is a protection against the scenario where
# the very first contact from an agent is a result
# of a stream of data postings of cached data.
# The datapoints are not originally in the database
# and so there is the risk of duplicate insertions
if id_datapoint not in new_datapoint_ids:
self._add_datapoint(source)
# Note the datapoint that was added
new_datapoint_ids.append(id_datapoint)
def test_init(self):
"""Testing method init."""
# Test with non existent AgentIDX
record = db_agent.GetIDXAgent(-1)
self.assertEqual(record.exists(), False)
self.assertEqual(record.enabled(), None)
self.assertEqual(record.idx_agent(), None)
self.assertEqual(record.idx_agentname(), None)
class APITestCase(unittest.TestCase):
"""Checks all functions and methods."""
#########################################################################
# General object setup
#########################################################################
# Setup database based on the config
database = unittest_setup_db.TestData()
# Define expected values
expected = {}
expected['idx_agent'] = database.idx_agent()
# Retrieve data
good_agent = db_agent.GetIDXAgent(expected['idx_agent'])
def setUp(self):
"""Setup the environment prior to testing."""
API.config['TESTING'] = True
self.API = API.test_client()
def test_agents(self):
"""Testing method / function agents."""
# Initializing key variables
response = self.API.get(
'/infoset/api/v1/agents/{}'.format(self.expected['idx_agent']))
data = json.loads(response.get_data(as_text=True))
# Verify reponse code
self.assertEqual(response.status_code, 200)
# Verify response content
self.assertEqual(isinstance(data, dict), True)
self.assertEqual(data['id_agent'], self.good_agent.id_agent())
self.assertEqual(data['exists'], self.good_agent.exists())
self.assertEqual(data['enabled'], self.good_agent.enabled())
def test_agents_query(self):
"""Testing method / function agents_query."""
# Initializing key variables
response = self.API.get('/infoset/api/v1/agents')
data = json.loads(response.get_data(as_text=True))
# Verify reponse code
self.assertEqual(response.status_code, 200)
# Verify response content
self.assertEqual(isinstance(data, list), True)
self.assertEqual(data[0]['id_agent'], self.good_agent.id_agent())
self.assertEqual(data[0]['exists'], self.good_agent.exists())
self.assertEqual(data[0]['enabled'], self.good_agent.enabled())
class Other(unittest.TestCase):
"""Checks all functions and methods."""
# Setup database based on the config
database = unittest_setup_db.TestData()
# Define expected values
expected = {}
expected['idx_agent'] = database.idx_agent()
expected['idx_agentname'] = database.idx_agentname()
expected['id_agent'] = database.id_agent()
expected['enabled'] = True
expected['exists'] = True
# Retrieve data
good_agent = db_agent.GetIDXAgent(expected['idx_agent'])
def test_id_agent_exists(self):
"""Testing function id_agent_exists."""
# Testing with known good value
expected = True
result = db_agent.id_agent_exists(self.expected['id_agent'])
self.assertEqual(result, expected)
# Testing with known bad value
expected = False
result = db_agent.id_agent_exists('bogus')
self.assertEqual(result, expected)
def test_idx_agent_exists(self):
"""Testing function idx_agent_exists."""
# Testing with known good value
expected = True
result = db_agent.idx_agent_exists(self.expected['idx_agent'])
self.assertEqual(result, expected)
# Testing with known bad value
expected = False
result = db_agent.idx_agent_exists(None)
self.assertEqual(result, expected)
def test_get_all_agents(self):
"""Testing function get_all_agents."""
# Testing with known good value
result = db_agent.get_all_agents()
self.assertEqual(isinstance(result, list), True)
self.assertEqual(result[0]['idx_agent'], self.expected['idx_agent'])
self.assertEqual(result[0]['exists'], self.expected['exists'])
self.assertEqual(result[0]['enabled'], self.expected['enabled'])
self.assertEqual(result[0]['idx_agentname'],
self.expected['idx_agentname'])
def db_getidxagent(value):
"""Get Agent data from the DB by idx value.
Args:
None
Returns:
data: JSON data for the selected agent
"""
# Return
query = db_agent.GetIDXAgent(_integer(value))
data = query.everything()
return jsonify(data)
def agents(idx_agent):
"""Get Agent data from the DB by idx value.
Args:
idx_agent: Agent table idx_agent
Returns:
data: JSON data for the selected agent
"""
# Get data
query = db_agent.GetIDXAgent(general.integerize(idx_agent))
data = query.everything()
# Return
return jsonify(data)
def agents(idx_agent):
"""Get Agent data from the DB by idx value.
Args:
idx_agent: Agent table idx_agent
Returns:
data: JSON data for the selected agent
"""
# Get data from cache
key = ('DB/Agent/idx_agent/{}'.format(idx_agent))
cache_value = CACHE.get(key)
# Process cache miss
if cache_value is None:
query = db_agent.GetIDXAgent(general.integerize(idx_agent))
data = query.everything()
CACHE.set(key, data)
else:
data = cache_value
# Return
return jsonify(data)
class TestGetIDX(unittest.TestCase):
"""Checks all functions and methods."""
#########################################################################
# General object setup
#########################################################################
# Setup database based on the config
database = unittest_setup_db.TestData()
# Define expected values
expected = {}
expected['idx_agent'] = database.idx_agent()
expected['idx_agentname'] = database.idx_agentname()
expected['id_agent'] = database.id_agent()
expected['agent'] = database.agent()
expected['enabled'] = True
expected['exists'] = True
# Retrieve data
good_agent = db_agent.GetIDXAgent(expected['idx_agent'])
def test_init(self):
"""Testing method init."""
# Test with non existent AgentIDX
record = db_agent.GetIDXAgent(-1)
self.assertEqual(record.exists(), False)
self.assertEqual(record.enabled(), None)
self.assertEqual(record.idx_agent(), None)
self.assertEqual(record.agent(), None)
self.assertEqual(record.idx_agentname(), None)
def test_id_agent(self):
"""Testing method id_agent."""
# Testing with known good value
result = self.good_agent.id_agent()
self.assertEqual(result, self.expected['id_agent'])
# Testing with known bad value
expected = ('bogus')
result = self.good_agent.id_agent()
self.assertNotEqual(result, expected)
def test_idx_agent(self):
"""Testing method idx."""
# Testing with known good value
result = self.good_agent.idx_agent()
self.assertEqual(result, self.expected['idx_agent'])
# Testing with known bad value
expected = ('bogus')
result = self.good_agent.idx_agent()
self.assertNotEqual(result, expected)
def test_exists(self):
"""Testing method exists."""
# Testing with known good value
result = self.good_agent.exists()
self.assertEqual(result, True)
def test_idx_agentname(self):
"""Testing method idx_agentname."""
# Testing with known good value
result = self.good_agent.idx_agentname()
self.assertEqual(result, self.expected['idx_agentname'])
def test_agent(self):
"""Testing method name."""
# Testing with known good value
result = self.good_agent.agent()
self.assertEqual(result, self.expected['agent'])
def test_enabled(self):
"""Testing method enabled."""
# Testing with known good value
result = self.good_agent.enabled()
self.assertEqual(result, self.expected['enabled'])
# Testing with known bad value
expected = ('bogus')
result = self.good_agent.enabled()
self.assertNotEqual(result, expected)
def test_everything(self):
"""Testing method everything."""
# Testing with known good value
result = self.good_agent.everything()
for key, _ in self.expected.items():
self.assertEqual(result[key], self.expected[key])
# Test the number and names of keys
keys = [
'idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent',
'exists'
]
self.assertEqual(len(result), len(keys))
for key in keys:
self.assertEqual(key in result, True)
class APITestCase(unittest.TestCase):
"""Checks all functions and methods."""
#########################################################################
# General object setup
#########################################################################
# Setup database based on the config
database = unittest_setup_db.TestData()
# Define expected values
expected = {}
expected['idx_agent'] = database.idx_agent()
expected['id_agent'] = database.id_agent()
# Retrieve data
test_object = db_agent.GetIDXAgent(expected['idx_agent'])
def setUp(self):
"""Setup the environment prior to testing."""
# Test mode
API.config['TESTING'] = True
self.API = API.test_client()
def test_agents(self):
"""Testing method / function agents."""
# Clear the memory cache
CACHE.clear()
# Get results
uri = ('/infoset/api/v1/agents/{}'.format(self.expected['idx_agent']))
response = self.API.get(uri)
result = json.loads(response.get_data(as_text=True))
# Verify reponse code
self.assertEqual(response.status_code, 200)
# Verify response content
self.assertEqual(isinstance(result, dict), True)
self.assertEqual(result['id_agent'], self.test_object.id_agent())
self.assertEqual(result['exists'], self.test_object.exists())
self.assertEqual(result['enabled'], self.test_object.enabled())
self.assertEqual(result['idx_agent'], self.test_object.idx_agent())
self.assertEqual(result['idx_agentname'],
self.test_object.idx_agentname())
self.assertEqual(result['agent'], self.test_object.agent())
# Test the number and names of keys
keys = [
'idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent',
'exists'
]
self.assertEqual(len(result), len(keys))
for key in keys:
self.assertEqual(key in result, True)
def test_agents_query(self):
"""Testing method / function agents_query."""
# Clear the memory cache
CACHE.clear()
# Get results
response = self.API.get('/infoset/api/v1/agents')
data = json.loads(response.get_data(as_text=True))
result = data[0]
# Verify reponse code
self.assertEqual(response.status_code, 200)
# Verify response content
self.assertEqual(isinstance(data, list), True)
self.assertEqual(result['id_agent'], self.test_object.id_agent())
self.assertEqual(result['exists'], self.test_object.exists())
self.assertEqual(result['enabled'], self.test_object.enabled())
self.assertEqual(result['idx_agent'], self.test_object.idx_agent())
self.assertEqual(result['idx_agentname'],
self.test_object.idx_agentname())
self.assertEqual(result['agent'], self.test_object.agent())
# Test the number and names of keys
keys = [
'idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent',
'exists'
]
self.assertEqual(len(result), len(keys))
for key in keys:
self.assertEqual(key in result, True)
def test_agents_query_2(self):
"""Testing method / function agents_query."""
# Clear the memory cache
CACHE.clear()
# Get results
uri = ('/infoset/api/v1/agents?id_agent={}'
''.format(self.expected['id_agent']))
response = self.API.get(uri)
data = json.loads(response.get_data(as_text=True))
result = data[0]
# Verify reponse code
self.assertEqual(response.status_code, 200)
# Verify response content
self.assertEqual(isinstance(data, list), True)
self.assertEqual(result['id_agent'], self.test_object.id_agent())
self.assertEqual(result['exists'], self.test_object.exists())
self.assertEqual(result['enabled'], self.test_object.enabled())
self.assertEqual(result['agent'], self.test_object.agent())
# Test the number and names of keys
keys = [
'idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent',
'exists'
]
self.assertEqual(len(result), len(keys))
for key in keys:
self.assertEqual(key in result, True)
class TestGetIDX(unittest.TestCase):
"""Checks all functions and methods."""
#########################################################################
# General object setup
#########################################################################
# Setup database
(_, expected) = unittest_db.setup_db_agent()
# Retrieve data
good_agent = db_agent.GetIDXAgent(1)
def test_init_getidx(self):
"""Testing method init."""
# Test with non existent AgentIDX
record = db_agent.GetIDXAgent(-1)
self.assertEqual(record.exists(), False)
def test_id_agent_getidx(self):
"""Testing method id_agent."""
# Testing with known good value
result = self.good_agent.id_agent()
self.assertEqual(result, self.expected['id_agent'])
# Testing with known bad value
expected = ('bogus')
result = self.good_agent.id_agent()
self.assertNotEqual(result, expected)
def test_name_getidx(self):
"""Testing method name."""
# Testing with known good value
result = self.good_agent.name()
self.assertEqual(result, self.expected['name'])
# Testing with known bad value
expected = ('bogus')
result = self.good_agent.name()
self.assertNotEqual(result, expected)
def test_exists(self):
"""Testing method exists."""
# Testing with known good value
result = self.good_agent.exists()
self.assertEqual(result, True)
def test_enabled_getidx(self):
"""Testing method enabled."""
# Testing with known good value
result = self.good_agent.enabled()
self.assertEqual(result, self.expected['enabled'])
# Testing with known bad value
expected = ('bogus')
result = self.good_agent.enabled()
self.assertNotEqual(result, expected)
def test_last_timestamp_getidx(self):
"""Testing method last_timestamp."""
# Testing with known good value
result = self.good_agent.last_timestamp()
self.assertEqual(result, self.expected['last_timestamp'])
# Testing with known bad value
expected = ('bogus')
result = self.good_agent.last_timestamp()
self.assertNotEqual(result, expected)
def test_everything_getidx(self):
"""Testing method everything."""
# Testing with known good value
result = self.good_agent.everything()
for key, _ in self.expected.items():
self.assertEqual(result[key], self.expected[key])
def test_init_getidx(self):
"""Testing method init."""
# Test with non existent AgentIDX
record = db_agent.GetIDXAgent(-1)
self.assertEqual(record.exists(), False)