def db_getidxdeviceagent(value):
"""Get DeviceAgent data from the DB by idx value.
Args:
value: idx_deviceagent
Returns:
data: JSON data for the selected deviceagent
"""
# Initialize key variables
idx_deviceagent = int(value)
# Get data from cache
key = ('DB/DeviceAgent/idx_deviceagent/{}'.format(idx_deviceagent))
cache_value = CACHE.get(key)
# Process cache miss
if cache_value is None:
query = db_deviceagent.GetIDXDeviceAgent(idx_deviceagent)
data = query.everything()
CACHE.set(key, data)
else:
data = cache_value
# Return
return jsonify(data)
def test___init__(self):
"""Testing method __init__."""
# Test with non existent IDXDevice
record = db_deviceagent.GetIDXDeviceAgent('bogus')
self.assertEqual(record.exists(), False)
self.assertEqual(record.enabled(), None)
self.assertEqual(record.idx_agent(), None)
self.assertEqual(record.idx_device(), None)
self.assertEqual(record.idx_deviceagent(), None)
self.assertEqual(record.last_timestamp(), None)
record = db_deviceagent.GetIDXDeviceAgent(-1)
self.assertEqual(record.exists(), False)
self.assertEqual(record.enabled(), None)
self.assertEqual(record.idx_agent(), None)
self.assertEqual(record.idx_device(), None)
self.assertEqual(record.idx_deviceagent(), None)
self.assertEqual(record.last_timestamp(), None)
def listing(idx_deviceagent, base_type=None):
"""List of datapoint data for a specific idx_device, idx_agent combination.
Args:
idx_deviceagent: DeviceAgent index
base_type: base_type to filter by
Returns:
dict_list: List of dicts containing data
"""
# Initialize key variables
dict_list = []
# Process information
deviceagent = db_deviceagent.GetIDXDeviceAgent(idx_deviceagent)
if deviceagent.exists() is True:
# Establish a database session
database = db.Database()
session = database.session()
if base_type is None:
result = session.query(Datapoint).filter(
Datapoint.idx_deviceagent == idx_deviceagent)
else:
result = session.query(Datapoint).filter(
and_(
Datapoint.base_type == base_type,
Datapoint.idx_deviceagent == idx_deviceagent)
)
# Add to the list of device idx_datapoint values
for instance in result:
data_dict = {}
data_dict['idx_datapoint'] = instance.idx_datapoint
data_dict['id_datapoint'] = general.decode(instance.id_datapoint)
data_dict['idx_deviceagent'] = instance.idx_deviceagent
data_dict['idx_department'] = instance.idx_department
data_dict['idx_billcode'] = instance.idx_billcode
data_dict[
'agent_label'] = general.decode(instance.agent_label)
data_dict[
'agent_source'] = general.decode(instance.agent_source)
data_dict['enabled'] = bool(instance.enabled)
data_dict['billable'] = bool(instance.billable)
data_dict['base_type'] = instance.base_type
data_dict[
'timefixed_value'] = general.decode(instance.timefixed_value)
data_dict['last_timestamp'] = instance.last_timestamp
data_dict['exists'] = True
dict_list.append(data_dict)
# Return the connection to the pool
database.close()
# Return
return dict_list
def test_exists(self):
"""Testing method exists."""
# Testing with known good value
result = self.good_device.exists()
self.assertEqual(result, True)
# Test with known bad value
expected = db_deviceagent.GetIDXDeviceAgent(None)
result = expected.exists()
self.assertEqual(result, False)
def deviceagents_query(value):
"""Get DeviceAgent data from the DB by idx value.
Args:
value: idx_deviceagent
Returns:
data: JSON data for the selected deviceagent
"""
# Initialize key variables
idx_deviceagent = int(value)
# Process cache miss
query = db_deviceagent.GetIDXDeviceAgent(idx_deviceagent)
data = query.everything()
# Return
return jsonify(data)
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_deviceagent'] = database.idx_deviceagent()
# Retrieve data
test_object = db_deviceagent.GetIDXDeviceAgent(expected['idx_deviceagent'])
def setUp(self):
"""Setup the environment prior to testing."""
# Test mode
API.config['TESTING'] = True
self.API = API.test_client()
def test_deviceagents_query(self):
"""Testing method / function db_getidxdeviceagent."""
# Clear the memory cache
CACHE.clear()
# Get results
uri = ('/infoset/api/v1/deviceagents/{}'
''.format(self.expected['idx_deviceagent']))
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['idx_device'], self.test_object.idx_device())
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['last_timestamp'],
self.test_object.last_timestamp())
self.assertEqual(result['idx_deviceagent'],
self.test_object.idx_deviceagent())
# Test the number and names of keys
keys = [
'last_timestamp', 'idx_deviceagent', 'idx_agent', 'idx_device',
'enabled', 'exists'
]
self.assertEqual(len(result), len(keys))
for key in keys:
self.assertEqual(key in result, True)
def test_deviceagents(self):
"""Testing method / function db_devagt_get_all_device_agents."""
# Clear the memory cache
CACHE.clear()
# Get results
response = self.API.get('/infoset/api/v1/deviceagents')
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['idx_device'], self.test_object.idx_device())
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['last_timestamp'],
self.test_object.last_timestamp())
self.assertEqual(result['idx_deviceagent'],
self.test_object.idx_deviceagent())
# Test the number and names of keys
keys = [
'last_timestamp', 'idx_deviceagent', 'idx_agent', 'idx_device',
'enabled', 'exists'
]
self.assertEqual(len(result), len(keys))
for key in keys:
self.assertEqual(key in result, True)
class TestGetIDXDeviceAgent(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_deviceagent'] = database.idx_deviceagent()
expected['idx_device'] = database.idx_device()
expected['idx_agent'] = database.idx_agent()
expected['last_timestamp'] = database.last_timestamp()
expected['enabled'] = True
expected['exists'] = True
# Create device object
good_device = db_deviceagent.GetIDXDeviceAgent(expected['idx_deviceagent'])
def test___init__(self):
"""Testing method __init__."""
# Test with non existent IDXDevice
record = db_deviceagent.GetIDXDeviceAgent('bogus')
self.assertEqual(record.exists(), False)
self.assertEqual(record.enabled(), None)
self.assertEqual(record.idx_agent(), None)
self.assertEqual(record.idx_device(), None)
self.assertEqual(record.idx_deviceagent(), None)
self.assertEqual(record.last_timestamp(), None)
record = db_deviceagent.GetIDXDeviceAgent(-1)
self.assertEqual(record.exists(), False)
self.assertEqual(record.enabled(), None)
self.assertEqual(record.idx_agent(), None)
self.assertEqual(record.idx_device(), None)
self.assertEqual(record.idx_deviceagent(), None)
self.assertEqual(record.last_timestamp(), None)
def test_exists(self):
"""Testing method exists."""
# Testing with known good value
result = self.good_device.exists()
self.assertEqual(result, True)
# Test with known bad value
expected = db_deviceagent.GetIDXDeviceAgent(None)
result = expected.exists()
self.assertEqual(result, False)
def test_enabled(self):
"""Testing method enabled."""
# Testing with known good value
result = self.good_device.enabled()
self.assertEqual(result, True)
def test_last_timestamp(self):
"""Testing method last_timestamp."""
# Testing with known good value
result = self.good_device.last_timestamp()
self.assertEqual(result, self.expected['last_timestamp'])
def test_idx_deviceagent(self):
"""Testing method idx_deviceagent."""
# Testing with known good value
result = self.good_device.idx_deviceagent()
self.assertEqual(result, self.expected['idx_deviceagent'])
def test_idx_agent(self):
"""Testing method idx_agent."""
# Testing with known good value
result = self.good_device.idx_agent()
self.assertEqual(result, self.expected['idx_agent'])
def test_idx_device(self):
"""Testing method idx_device."""
# Testing with known good value
result = self.good_device.idx_device()
self.assertEqual(result, self.expected['idx_device'])
def test_everything(self):
"""Testing method everything."""
# Testing with known good value
result = self.good_device.everything()
for key, _ in self.expected.items():
self.assertEqual(result[key], self.expected[key])
# Test the number and names of keys
keys = [
'last_timestamp', 'idx_deviceagent', 'idx_agent', 'idx_device',
'enabled', 'exists'
]
self.assertEqual(len(result), len(keys))
for key in keys:
self.assertEqual(key in result, True)
