class TestFunctions(unittest.TestCase):
"""Checks all functions and methods."""
# Initialize key variables
setup = unittest_setup.TestVariables()
data = setup.cache_data()
def test__id_datapoint(self):
"""Testing function _id_datapoint."""
# Initialize key variables
id_agent = 'id_agent'
label = 'label'
index = 'index'
agent_name = 'agent_name'
devicename = 'devicename'
# Test
result = drain._id_datapoint(id_agent, label, index, agent_name,
devicename)
self.assertEqual(
result, '9af342e9f23a5e2ff09d8a799a2b9f5234b'
'addc31f3c09b309be9dfe6801ee40')
def test__main_keys(self):
"""Testing function _main_keys."""
# Initialize key variables
agent_meta_keys = ['timestamp', 'id_agent', 'agent', 'devicename']
# Test
result = drain._main_keys(self.data)
for key in agent_meta_keys:
self.assertEqual(result[key], self.data[key])
def test__base_type(self):
"""Testing function _base_type."""
# Initialize key variables
base_types = [1, 32, 64]
# Test
for base_type in base_types:
# Test with know values
result = drain._base_type(base_type)
self.assertEqual(result, base_type)
result = drain._base_type(str(base_type))
self.assertEqual(result, None)
class TestDrain(unittest.TestCase):
"""Checks all functions and methods."""
# Initialize key variables
setup = unittest_setup.TestVariables()
data = setup.cache_data()
# Create valid file filled with valid data
directory = tempfile.mkdtemp()
filepath = ('%s/%s_%s_%s.json') % (
directory,
data['timestamp'],
data['id_agent'],
general.hashstring(data['devicename']))
with open(filepath, 'w') as f_handle:
json.dump(data, f_handle)
# Create a valid Drain object
ingest = drain.Drain(filepath)
@classmethod
def tearDownClass(cls):
"""Clean up when all over."""
# Delete unnecessary files
os.remove(cls.filepath)
def test___init__(self):
"""Testing function __init__."""
pass
def test_valid(self):
"""Testing function valid."""
# Test
result = self.ingest.valid()
self.assertEqual(result, True)
def test_id_agent(self):
"""Testing function id_agent."""
# Test
result = self.ingest.id_agent()
self.assertEqual(result, self.data['id_agent'])
def test_timestamp(self):
"""Testing function timestamp."""
# Test
result = self.ingest.timestamp()
self.assertEqual(result, self.data['timestamp'])
def test_agent(self):
"""Testing function agent."""
# Test
result = self.ingest.agent()
self.assertEqual(result, self.data['agent'])
def test_devicename(self):
"""Testing function devicename."""
# Test
result = self.ingest.devicename()
self.assertEqual(result, self.data['devicename'])
def test_counter32(self):
"""Testing function counter32."""
# Initialize key variables
datapoints = _expected(self.data, 32)
found = 0
# Test
results = self.ingest.counter32()
for datapoint in datapoints:
for result in results:
if result['id_datapoint'] == datapoint['id_datapoint']:
self.assertEqual(
result['timestamp'], datapoint['timestamp'])
self.assertEqual(
result['value'], datapoint['value'])
self.assertEqual(
result['id_agent'], datapoint['id_agent'])
# Increment found
found += 1
# Make sure that all are found
self.assertEqual(len(results), len(datapoints))
self.assertEqual(len(results), found)
def test_counter64(self):
"""Testing function counter64."""
# Initialize key variables
datapoints = _expected(self.data, 64)
found = 0
# Test
results = self.ingest.counter64()
for datapoint in datapoints:
for result in results:
if result['id_datapoint'] == datapoint['id_datapoint']:
self.assertEqual(
result['timestamp'], datapoint['timestamp'])
self.assertEqual(
result['value'], datapoint['value'])
self.assertEqual(
result['id_agent'], datapoint['id_agent'])
# Increment found
found += 1
# Make sure that all are found
self.assertEqual(len(results), len(datapoints))
self.assertEqual(len(results), found)
def test_floating(self):
"""Testing function floating."""
# Initialize key variables
datapoints = _expected(self.data, 1)
found = 0
# Test
results = self.ingest.floating()
for datapoint in datapoints:
for result in results:
if result['id_datapoint'] == datapoint['id_datapoint']:
self.assertEqual(
result['timestamp'], datapoint['timestamp'])
self.assertEqual(
result['value'], datapoint['value'])
self.assertEqual(
result['id_agent'], datapoint['id_agent'])
# Increment found
found += 1
# Make sure that all are found
self.assertEqual(len(results), len(datapoints))
self.assertEqual(len(results), found)
def test_timeseries(self):
"""Testing function timeseries."""
# Initialize key variables
datapoints = []
found = 0
# Populate datapoints list
datapoints.extend(_expected(self.data, 1))
datapoints.extend(_expected(self.data, 32))
datapoints.extend(_expected(self.data, 64))
# Test
results = self.ingest.timeseries()
for datapoint in datapoints:
for result in results:
if result['id_datapoint'] == datapoint['id_datapoint']:
self.assertEqual(
result['timestamp'], datapoint['timestamp'])
self.assertEqual(
result['value'], datapoint['value'])
self.assertEqual(
result['id_agent'], datapoint['id_agent'])
# Increment found
found += 1
# Make sure that all are found
self.assertEqual(len(results), len(datapoints))
self.assertEqual(len(results), found)
def test_timefixed(self):
"""Testing function timefixed."""
# Initialize key variables
datapoints = _expected(self.data, None)
found = 0
# Test
results = self.ingest.timefixed()
for datapoint in datapoints:
for result in results:
if result['id_datapoint'] == datapoint['id_datapoint']:
self.assertEqual(
result['timestamp'], datapoint['timestamp'])
self.assertEqual(
result['value'], datapoint['value'])
self.assertEqual(
result['id_agent'], datapoint['id_agent'])
# Increment found
found += 1
# Make sure that all are found
self.assertEqual(len(results), len(datapoints))
self.assertEqual(len(results), found)
def test_sources(self):
"""Testing function sources."""
# Initialize key variables
sources = _sources(self.data)
found = 0
# Test
results = self.ingest.sources()
for source in sources:
for result in results:
if result['id_datapoint'] == source['id_datapoint']:
self.assertEqual(
result['id_agent'], source['id_agent'])
self.assertEqual(
result['agent_label'], source['agent_label'])
self.assertEqual(
result['agent_source'], source['agent_source'])
self.assertEqual(
result['description'], source['description'])
self.assertEqual(
result['base_type'], source['base_type'])
# Increment found
found += 1
# Make sure that all are found
self.assertEqual(len(results), len(sources))
self.assertEqual(len(results), found)
def test_purge(self):
"""Testing function purge."""
directory = tempfile.mkdtemp()
filepath = ('%s/%s_%s_%s.json') % (
directory,
self.data['timestamp'],
self.data['id_agent'],
general.hashstring(self.data['devicename']))
with open(filepath, 'w') as f_handle:
json.dump(self.data, f_handle)
# Create a valid Drain object
ingest = drain.Drain(filepath)
# Test
self.assertEqual(os.path.exists(filepath), True)
self.assertEqual(os.path.isfile(filepath), True)
ingest.purge()
self.assertEqual(os.path.exists(filepath), False)
self.assertEqual(os.path.isfile(filepath), False)
class TestCheckData(unittest.TestCase):
"""Checks all functions and methods."""
# Initialize key variables
data = unittest_setup.TestVariables().cache_data()
def test___init__(self):
"""Testing function __init__."""
# Test with value that is not a dict
result = validate._CheckData('string')
self.assertEqual(result.valid(), False)
def test__data_keys_ok(self):
"""Testing function _data_keys_ok."""
# Test with good data
data_dict = copy.deepcopy(self.data)
result = validate._CheckData(data_dict)
self.assertEqual(result._data_keys_ok(), True)
# Test with good data (missing one time keys)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timefixed', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._data_keys_ok(), True)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timeseries', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._data_keys_ok(), True)
# Test with bad data (no time keys)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timefixed', None)
data_dict.pop('timeseries', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._data_keys_ok(), False)
def test__agent_label_keys_ok(self):
"""Testing function _agent_label_keys_ok."""
# Test with good data
data_dict = copy.deepcopy(self.data)
result = validate._CheckData(data_dict)
self.assertEqual(result._agent_label_keys_ok(), True)
# Test with good data (missing one time keys)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timefixed', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._agent_label_keys_ok(), True)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timeseries', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._agent_label_keys_ok(), True)
# Test with bad data (missing all time keys)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timeseries', None)
data_dict.pop('timefixed', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._agent_label_keys_ok(), False)
# Test with bad data (no keys under agent_label)
data_dict = copy.deepcopy(self.data)
for _, sub_dict in data_dict['timeseries'].items():
sub_dict.pop('base_type', None)
result = validate._CheckData(sub_dict)
self.assertEqual(result._agent_label_keys_ok(), False)
data_dict = copy.deepcopy(self.data)
for _, sub_dict in data_dict['timeseries'].items():
sub_dict.pop('description', None)
result = validate._CheckData(sub_dict)
self.assertEqual(result._agent_label_keys_ok(), False)
data_dict = copy.deepcopy(self.data)
for _, sub_dict in data_dict['timeseries'].items():
sub_dict.pop('data', None)
result = validate._CheckData(sub_dict)
self.assertEqual(result._agent_label_keys_ok(), False)
# Test with bad data (not enough keys under 'data')
data_dict = copy.deepcopy(self.data)
for agent_label, _ in data_dict['timeseries'].items():
data_dict['timeseries'][agent_label]['data'][0].remove(
data_dict['timeseries'][agent_label]['data'][0][-1])
break
result = validate._CheckData(sub_dict)
self.assertEqual(result._agent_label_keys_ok(), False)
def test__timeseries_data_ok(self):
"""Testing function _timeseries_data_ok."""
# Test with good data
data_dict = copy.deepcopy(self.data)
result = validate._CheckData(data_dict)
self.assertEqual(result._timeseries_data_ok(), True)
# Test with bad data (base_type is non-numeric string)
data_dict = copy.deepcopy(self.data)
for agent_label, _ in data_dict['timeseries'].items():
data_dict['timeseries'][agent_label]['base_type'] = 'string'
break
result = validate._CheckData(data_dict)
self.assertEqual(result._timeseries_data_ok(), False)
# Test with bad data ('data' value is non numeric)
data_dict = copy.deepcopy(self.data)
for agent_label, _ in data_dict['timeseries'].items():
data_dict['timeseries'][agent_label]['data'][0][1] = 'string'
break
result = validate._CheckData(data_dict)
self.assertEqual(result._timeseries_data_ok(), False)
# Test with good data (missing one time keys)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timeseries', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._timeseries_data_ok(), True)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timefixed', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._timeseries_data_ok(), True)
# Test with bad data (no timeseries key)
data_dict = copy.deepcopy(self.data)
data_dict.pop('timeseries', None)
data_dict.pop('timefixed', None)
result = validate._CheckData(data_dict)
self.assertEqual(result._timeseries_data_ok(), False)
# Test with bad data (no keys under agent_label)
data_dict = copy.deepcopy(self.data)
for _, sub_dict in data_dict['timeseries'].items():
sub_dict.pop('base_type', None)
result = validate._CheckData(sub_dict)
self.assertEqual(result._timeseries_data_ok(), False)
data_dict = copy.deepcopy(self.data)
for _, sub_dict in data_dict['timeseries'].items():
sub_dict.pop('data', None)
result = validate._CheckData(sub_dict)
self.assertEqual(result._timeseries_data_ok(), False)
def test_valid(self):
"""Testing function valid."""
# Test with good data
data_dict = copy.deepcopy(self.data)
result = validate._CheckData(data_dict)
self.assertEqual(result.valid(), True)
# Test with bad data (base_type is non-numeric string)
data_dict = copy.deepcopy(self.data)
for agent_label, _ in data_dict['timeseries'].items():
data_dict['timeseries'][agent_label]['base_type'] = 'string'
break
result = validate._CheckData(data_dict)
self.assertEqual(result.valid(), False)
class TestCheckMainKeys(unittest.TestCase):
"""Checks all functions and methods."""
# Initialize key variables
data = unittest_setup.TestVariables().cache_data()
def test___init__(self):
"""Testing function __init__."""
# Test with value that is not a dict
result = validate._CheckMainKeys('string')
self.assertEqual(result.valid(), False)
def test__timestamp(self):
"""Testing function _timestamp."""
# Initialize key variables
test_dict = copy.deepcopy(self.data)
# Test good data
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._timestamp(), True)
# Test bad data (key is string)
test_dict['timestamp'] = 'string'
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._timestamp(), False)
# Test bad data (no key)
test_dict.pop('timestamp', None)
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._timestamp(), False)
def test__id_agent(self):
"""Testing function _id_agent."""
# Initialize key variables
test_dict = copy.deepcopy(self.data)
# Test good data
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._id_agent(), True)
# Test bad data (key is integer)
test_dict['id_agent'] = 0
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._id_agent(), False)
# Test bad data (no key)
test_dict.pop('id_agent', None)
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._id_agent(), False)
def test__agent(self):
"""Testing function _agent."""
# Initialize key variables
test_dict = copy.deepcopy(self.data)
# Test good data
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._agent(), True)
# Test bad data (key is integer)
test_dict['agent'] = 0
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._agent(), False)
# Test bad data (no key)
test_dict.pop('agent', None)
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._agent(), False)
def test__devicename(self):
"""Testing function _devicename."""
# Initialize key variables
test_dict = copy.deepcopy(self.data)
# Test good data
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._devicename(), True)
# Test bad data (key is integer)
test_dict['devicename'] = 0
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._devicename(), False)
# Test bad data (no key)
test_dict.pop('devicename', None)
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result._devicename(), False)
def test_valid(self):
"""Testing function valid."""
# Initialize key variables
test_dict = copy.deepcopy(self.data)
# Test good data
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result.valid(), True)
# Test bad data (key is integer)
test_dict['devicename'] = 0
result = validate._CheckMainKeys(test_dict)
self.assertEqual(result.valid(), False)
class TestCheckDuplicates(unittest.TestCase):
"""Checks all functions and methods."""
# Initialize key variables
data = unittest_setup.TestVariables().cache_data()
def test___init__(self):
"""Testing function __init__."""
# Test with value that is not a dict
result = validate._CheckDuplicates('string')
self.assertEqual(result.valid(), False)
def test_valid(self):
"""Testing function valid."""
# Initialize key variables
devicename = self.data['devicename']
id_agent = self.data['id_agent']
last_timestamp = self.data['timestamp']
# Drop the database and create tables
unittest_setup_db.TestData()
# Add record to the database
record = Agent(id_agent=general.encode(id_agent))
database = db.Database()
database.add(record, 1040)
# Test must be good as DeviceAgent last_timestamp not updated
result = validate._CheckDuplicates(self.data)
self.assertEqual(result.valid(), True)
# Get idx_agent value from database
data = db_agent.GetIDAgent(id_agent)
idx_agent = data.idx_agent()
# Add record to the database
record = Device(devicename=general.encode(devicename))
database = db.Database()
database.add(record, 1024)
# Test must be good as DeviceAgent last_timestamp not updated
result = validate._CheckDuplicates(self.data)
self.assertEqual(result.valid(), True)
# Get idx of newly added device
device_info = db_device.GetDevice(devicename)
idx_device = device_info.idx_device()
# Update DeviceAgent table
if hagent.device_agent_exists(idx_device, idx_agent) is False:
# Add to DeviceAgent table
record = DeviceAgent(idx_device=idx_device, idx_agent=idx_agent)
database = db.Database()
database.add(record, 1055)
# Test must be good as DeviceAgent last_timestamp not updated
result = validate._CheckDuplicates(self.data)
self.assertEqual(result.valid(), True)
# Update database with timestamp
database = db.Database()
session = database.session()
record = session.query(DeviceAgent).filter(
and_(DeviceAgent.idx_device == idx_device,
DeviceAgent.idx_agent == idx_agent)).one()
record.last_timestamp = last_timestamp
database.commit(session, 1044)
# Test must fail as DeviceAgent last_timestamp not updated
result = validate._CheckDuplicates(self.data)
self.assertEqual(result.valid(), False)
class TestValidateCache(unittest.TestCase):
"""Checks all functions and methods."""
# Initialize key variables
data = unittest_setup.TestVariables().cache_data()
def test___init__(self):
"""Testing function __init__."""
# Initialize key variables
directory = tempfile.mkdtemp()
id_agent = self.data['id_agent']
last_timestamp = self.data['timestamp']
filepath = ('%s/%s_%s_%s.json') % (directory, last_timestamp, id_agent,
general.hashstring(
general.randomstring()))
# Drop the database and create tables
unittest_setup_db.TestData()
# Test with valid data
result = validate.ValidateCache(data=self.data)
self.assertEqual(result.valid(), True)
# Test with invalid data (string)
result = validate.ValidateCache(data='string')
self.assertEqual(result.valid(), False)
# Test with invalid data (string)
data_dict = copy.deepcopy(self.data)
data_dict.pop('agent', None)
result = validate.ValidateCache(data=data_dict)
self.assertEqual(result.valid(), False)
# Write good data to file and test
with open(filepath, 'w') as f_handle:
json.dump(self.data, f_handle)
result = validate.ValidateCache(filepath=filepath)
self.assertEqual(result.valid(), True)
#################################################################
#################################################################
# Add record to DeviceAgent table and test for validity with the
# same data, which should be False
#################################################################
#################################################################
data_dict = copy.deepcopy(self.data)
# Populate dictionary with data values of prior entries
database = unittest_setup_db.TestData()
data_dict['timestamp'] = database.timestamp()
data_dict['devicename'] = database.devicename()
data_dict['agent'] = database.agent()
data_dict['id_agent'] = database.id_agent()
# Attempting to insert duplicate data should fail
with open(filepath, 'w') as f_handle:
json.dump(data_dict, f_handle)
result = validate.ValidateCache(filepath=filepath)
self.assertEqual(result.valid(), False)
#################################################################
#################################################################
# Test with invalid data in file
#################################################################
#################################################################
# Drop the database and create tables
unittest_setup_db.TestData()
# Write bad data to file and test
data_dict = copy.deepcopy(self.data)
data_dict.pop('agent', None)
with open(filepath, 'w') as f_handle:
json.dump(data_dict, f_handle)
result = validate.ValidateCache(filepath=filepath)
self.assertEqual(result.valid(), False)
# Cleanup
os.remove(filepath)
os.removedirs(directory)
def test_getinfo(self):
"""Testing function getinfo."""
# Drop the database and create tables
unittest_setup_db.TestData()
# Test with valid data
result = validate.ValidateCache(data=self.data)
data_dict = result.getinfo()
# Check main keys
for key, _ in self.data.items():
self.assertEqual(self.data[key], data_dict[key])
def test_valid(self):
"""Testing function valid."""
# Drop the database and create tables
unittest_setup_db.TestData()
# Test with valid data
result = validate.ValidateCache(data=self.data)
self.assertEqual(result.valid(), True)
# Test with invalid data (string)
result = validate.ValidateCache(data='string')
self.assertEqual(result.valid(), False)