def test_contents(self):
"""Testing function contents."""
# Initialize key variables
devicename = general.hashstring(general.randomstring())
id_agent = general.hashstring(general.randomstring())
agent_name = general.hashstring(general.randomstring())
hosthash = general.hashstring(devicename)
timestamp = general.normalized_timestamp()
# Create a directory and filename for testing
directory = tempfile.mkdtemp()
filename = ('%s/%s_%s_%s.json') % (directory, timestamp, id_agent,
hosthash)
# Test with good data
data = {
'id_agent': id_agent,
'agent': agent_name,
'devicename': devicename,
'timestamp': timestamp
}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(filename)
contents = result.contents()
for key in contents.keys():
self.assertEqual(contents[key], data[key])
self.assertEqual(len(contents), len(data))
class TestGetDeviceAgent(unittest.TestCase):
"""Checks all functions and methods."""
#########################################################################
# General object setup
#########################################################################
# Initiazlize key variables
data = {}
data['devicename'] = general.randomstring()
data['id_agent'] = general.randomstring()
data['agent'] = general.randomstring()
data['timestamp'] = int(time.time())
# Setup database
unittest_db.initialize_db()
(idx_device_good, idx_agent_good) = unittest_db.setup_db_deviceagent(data)
# Create device object
good_device = db_deviceagent.GetDeviceAgent(
idx_device_good, idx_agent_good)
def test___init__(self):
"""Testing method __init__."""
# Test with non existent IDXDevice
record = db_deviceagent.GetDeviceAgent('bogus', 'bogus')
self.assertEqual(record.exists(), False)
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.GetDeviceAgent(None, 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.data['timestamp'])
def test_idx_deviceagent(self):
"""Testing method idx_deviceagent."""
# Testing with known good value
result = self.good_device.idx_deviceagent()
self.assertEqual(result, 1)
class TestFunctions(unittest.TestCase):
"""Checks all functions."""
#########################################################################
# General object setup
#########################################################################
# Initiazlize key variables
data = {}
data['devicename'] = general.randomstring()
data['id_agent'] = general.randomstring()
data['agent'] = general.randomstring()
data['timestamp'] = int(time.time())
# Setup database
unittest_db.initialize_db()
(idx_device_good, idx_agent_good) = unittest_db.setup_db_deviceagent(data)
def test_device_agent_exists(self):
"""Testing function device_agent_exists."""
# Testing with known good value
result = db_deviceagent.device_agent_exists(
self.idx_device_good, self.idx_agent_good)
self.assertEqual(result, True)
# Testing with known good value
result = db_deviceagent.device_agent_exists(None, None)
self.assertEqual(result, False)
def test_all_device_indices(self):
"""Testing function all_device_indices."""
# Testing with known good value
result = db_deviceagent.all_device_indices()
self.assertEqual(result, [1])
def test_device_indices(self):
"""Testing function device_indices."""
# Testing with known good value
result = db_deviceagent.device_indices(self.idx_agent_good)
self.assertEqual(result, [1])
def test_agent_indices(self):
"""Testing function agent_indices."""
# Testing with known good value
result = db_deviceagent.agent_indices(
self.idx_agent_good)
self.assertEqual(result, [1])
def test_get_all_device_agents(self):
"""Testing function get_all_device_agents."""
results = db_deviceagent.get_all_device_agents()
for result in results:
for key, _ in result.items():
self.assertEqual(result[key], 1)
def test___init__(self):
"""Testing function __init__."""
# Test non existent file
directory = tempfile.mkdtemp()
badfile = general.randomstring()
result = validate._CheckFile(badfile)
self.assertEqual(result.valid(), False)
# Test bad filename, existing file (Non hex characters in name)
badfile = ('%s/%s_%s_%s.json') % (directory, int(
time.time()), general.randomstring(), general.randomstring())
data = general.randomstring()
with open(badfile, 'w') as f_handle:
f_handle.write(data)
result = validate._CheckFile(badfile)
self.assertEqual(result.valid(), False)
os.remove(badfile)
# Test good filename, no data
id_agent = general.hashstring(general.randomstring())
hosthash = general.hashstring(general.randomstring())
filename = ('%s/%s_%s_%s.json') % (directory, int(
time.time()), id_agent, hosthash)
data = general.randomstring()
with open(filename, 'w') as f_handle:
f_handle.write(data)
result = validate._CheckFile(badfile)
self.assertEqual(result.valid(), False)
os.remove(filename)
def test_valid(self):
"""Testing function valid."""
# Initialize key variables
devicename = general.hashstring(general.randomstring())
id_agent = general.hashstring(general.randomstring())
agent_name = general.hashstring(general.randomstring())
hosthash = general.hashstring(devicename)
timestamp = general.normalized_timestamp()
# Create a directory and filename for testing
directory = tempfile.mkdtemp()
filename = ('%s/%s_%s_%s.json') % (
directory,
timestamp,
id_agent,
hosthash)
# Test with good data
data = {
'id_agent': id_agent,
'agent': agent_name,
'devicename': devicename,
'timestamp': timestamp
}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(filename)
self.assertEqual(result.valid(), True)
# Test with bad data (missing id_agent value)
data = {
'id_agent': '',
'agent': agent_name,
'devicename': devicename,
'timestamp': timestamp
}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(filename)
self.assertEqual(result.valid(), False)
# Cleanup
os.remove(filename)
def test__read_data_from_file(self):
"""Testing function _read_data_from_file."""
# Create filename
document = tempfile.NamedTemporaryFile(delete=False)
filename = document.name
# Write non JSON to file and test
data = general.randomstring()
with open(filename, 'w') as f_handle:
f_handle.write(data)
result = validate._read_data_from_file(filename)
self.assertEqual(bool(result), False)
self.assertEqual(result, {})
# Write JSON to file and test
data = {'key0': 0, 'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._read_data_from_file(filename)
for key in result.keys():
self.assertEqual(result[key], data[key])
# Delete temporary file
os.remove(filename)
def test__keys_in_filename(self):
"""Testing function _keys_in_filename."""
# Initialize key variables
id_agent = general.hashstring(general.randomstring())
hosthash = general.hashstring(general.randomstring())
timestamp = general.normalized_timestamp()
# Create a directory and filename for testing
directory = tempfile.mkdtemp()
filename = ('%s/%s_%s_%s.json') % (directory, timestamp, id_agent,
hosthash)
# Test with good data
data = {'id_agent': id_agent, 'timestamp': timestamp}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(filename)
self.assertEqual(result._keys_in_filename(), True)
# Test with bad data (missing id_agent value)
data = {'id_agent': '', 'timestamp': timestamp}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(filename)
self.assertEqual(result._keys_in_filename(), False)
# Test with bad data (mismatched timestamp value)
data = {'id_agent': id_agent, 'timestamp': 0}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(filename)
self.assertEqual(result._keys_in_filename(), False)
# Test with bad data (string timestamp value)
data = {'id_agent': id_agent, 'timestamp': str(timestamp)}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(filename)
self.assertEqual(result._keys_in_filename(), False)
# Test with bad data (string timestamp value)
data = {'id_agent': id_agent, 'timestamp': str(timestamp)}
with open(filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(filename)
self.assertEqual(result._keys_in_filename(), False)
# Test with bad data
# (non normalized timestamp value in filename and data)
bad_time = timestamp + 1
bad_filename = ('%s/%s_%s_%s.json') % (directory, bad_time, id_agent,
hosthash)
data = {'id_agent': id_agent, 'timestamp': str(timestamp)}
with open(bad_filename, 'w') as f_handle:
json.dump(data, f_handle)
result = validate._CheckFile(bad_filename)
self.assertEqual(result._keys_in_filename(), False)
# Cleanup
# Get all files in directory
filenames = [
filename for filename in os.listdir(directory)
if os.path.isfile(os.path.join(directory, filename))
]
# Get the full filepath for the cache file and post
for filename in filenames:
filepath = os.path.join(directory, filename)
os.remove(filepath)
def __init__(self):
"""Method initializing the class."""
# Initialize key variables
self.data = {}
self.data['idx_datapoint'] = 1
self.data['idx_agentname'] = 1
self.data['idx_billcode'] = 1
self.data['idx_device'] = 1
self.data['idx_deviceagent'] = 1
self.data['idx_department'] = 1
self.data['timestamp'] = general.normalized_timestamp()
self.data['id_datapoint'] = general.hashstring(general.randomstring())
self.data['devicename'] = general.hashstring(general.randomstring())
self.data['id_agent'] = general.hashstring(general.randomstring())
self.data['id_datapoint'] = general.hashstring(general.randomstring())
self.data['devicename'] = general.hashstring(general.randomstring())
self.data['device_description'] = general.hashstring(
general.randomstring())
self.data['agent_name'] = general.hashstring(general.randomstring())
self.data['agent_source'] = general.hashstring(general.randomstring())
self.data['agent_label'] = general.hashstring(general.randomstring())
self.data['department_code'] = general.hashstring(
general.randomstring())
self.data['department_name'] = general.hashstring(
general.randomstring())
self.data['billcode_code'] = general.hashstring(general.randomstring())
self.data['billcode_name'] = general.hashstring(general.randomstring())
# Drop the database and create tables
initialize_db()
# Initialize agent variables
agent_data = {}
agent_data['devicename'] = self.data['devicename']
agent_data['device_description'] = self.data['device_description']
agent_data['id_agent'] = self.data['id_agent']
agent_data['agent'] = self.data['agent_name']
agent_data['timestamp'] = self.data['timestamp']
(self.data['idx_device'],
self.data['idx_agent']) = _setup_db_deviceagent(agent_data)
# Get DeviceAgent index value
deviceagent = hagent.GetDeviceAgent(self.data['idx_device'],
self.data['idx_agent'])
self.data['idx_deviceagent'] = deviceagent.idx_deviceagent()
# Insert Department data into database
dept_data = Department(name=self.data['department_name'].encode(),
code=self.data['department_code'].encode())
database = db.Database()
database.add_all([dept_data], 1035)
# Insert Billcode data into database
bill_data = Billcode(name=self.data['billcode_name'].encode(),
code=self.data['billcode_code'].encode())
database = db.Database()
database.add_all([bill_data], 1039)
# Insert Datapoint data into database
new_data = Datapoint(agent_source=self.data['agent_source'].encode(),
agent_label=self.data['agent_label'].encode(),
last_timestamp=self.data['timestamp'],
idx_deviceagent=self.data['idx_deviceagent'],
id_datapoint=self.data['id_datapoint'].encode())
database = db.Database()
database.add_all([new_data], 1072)
def test__valid_filename(self):
"""Testing function _valid_filename."""
# Test bad filename
filename = general.randomstring()
result = validate._valid_filename(filename)
self.assertEqual(result, False)
# Test bad filename
filename = str(int(time.time()))
result = validate._valid_filename(filename)
self.assertEqual(result, False)
# Test bad filename
filename = ('%s_%s') % (int(
time.time()), general.hashstring(general.randomstring()))
result = validate._valid_filename(filename)
self.assertEqual(result, False)
# Test bad filename
filename = ('%s_%s_%s') % (int(
time.time()), general.hashstring(general.randomstring()),
general.hashstring(general.randomstring()))
result = validate._valid_filename(filename)
self.assertEqual(result, False)
# Test bad filename (Non hex characters in name)
filename = ('%s_%s') % (int(time.time()), general.randomstring())
result = validate._valid_filename(filename)
self.assertEqual(result, False)
# Test bad filename (Non hex characters in name)
filename = ('%s_%s_%s') % (int(
time.time()), general.randomstring(), general.randomstring())
result = validate._valid_filename(filename)
self.assertEqual(result, False)
# Test bad filename (Non hex characters in name)
filename = ('%s_%s_%s.json') % (int(
time.time()), general.randomstring(), general.randomstring())
result = validate._valid_filename(filename)
self.assertEqual(result, False)
# Test good filename
filename = ('%s_%s_%s.json') % (
int(time.time()), general.hashstring(general.randomstring()),
general.hashstring(general.randomstring()))
result = validate._valid_filename(filename)
self.assertEqual(result, True)
def __init__(self):
"""Method initializing the class."""
# Initialize key variables
self.data = {}
self.data['idx_datapoint'] = 1
self.data['idx_agentname'] = 1
self.data['idx_billcode'] = 1
self.data['idx_device'] = 1
self.data['idx_deviceagent'] = 1
self.data['idx_department'] = 1
self.data['timestamp'] = general.normalized_timestamp()
self.data['last_timestamp'] = general.normalized_timestamp()
self.data['devicename'] = general.hashstring(general.randomstring())
self.data['id_agent'] = general.hashstring(general.randomstring())
self.data['id_datapoint'] = general.hashstring(general.randomstring())
self.data['devicename'] = general.hashstring(general.randomstring())
self.data['device_description'] = general.hashstring(
general.randomstring())
self.data['agent'] = general.hashstring(general.randomstring())
self.data['agent_source'] = general.hashstring(general.randomstring())
self.data['agent_label'] = general.hashstring(general.randomstring())
self.data['department_code'] = general.hashstring(
general.randomstring())
self.data['department_name'] = general.hashstring(
general.randomstring())
self.data['billcode_code'] = general.hashstring(
general.randomstring())
self.data['billcode_name'] = general.hashstring(
general.randomstring())
# Define data to Insert
self.data['values'] = []
for timestamp in _timestamps():
value_dict = {
'idx_datapoint': self.data['idx_datapoint'],
'value': timestamp * (1 + random.uniform(0, 1)),
'timestamp': timestamp}
self.data['values'].append(value_dict)
# Drop the database and create tables
initialize_db()
# Initialize agent variables
agent_data = {}
agent_data['devicename'] = self.data['devicename']
agent_data['device_description'] = self.data['device_description']
agent_data['id_agent'] = self.data['id_agent']
agent_data['agent'] = self.data['agent']
agent_data['timestamp'] = self.data['timestamp']
(
self.data['idx_device'],
self.data['idx_agent']) = _setup_db_deviceagent(agent_data)
# Get DeviceAgent index value
deviceagent = hagent.GetDeviceAgent(
self.data['idx_device'], self.data['idx_agent'])
self.data['idx_deviceagent'] = deviceagent.idx_deviceagent()
# Insert Department data into database
dept_data = Department(
name=self.data['department_name'].encode(),
code=self.data['department_code'].encode()
)
database = db.Database()
database.add_all([dept_data], 1035)
# Insert Billcode data into database
bill_data = Billcode(
name=self.data['billcode_name'].encode(),
code=self.data['billcode_code'].encode()
)
database = db.Database()
database.add_all([bill_data], 1039)
# Insert Datapoint data into database
new_data = Datapoint(
agent_source=self.data['agent_source'].encode(),
agent_label=self.data['agent_label'].encode(),
last_timestamp=self.data['last_timestamp'],
idx_deviceagent=self.data['idx_deviceagent'],
id_datapoint=self.data['id_datapoint'].encode())
database = db.Database()
database.add_all([new_data], 1144)
# Insert timeseries data into database
new_data_list = []
for item in self.data['values']:
new_data_list.append(
Data(
idx_datapoint=item['idx_datapoint'],
timestamp=item['timestamp'],
value=item['value']))
database = db.Database()
database.add_all(new_data_list, 1072)
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_db.initialize_db()
# 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
#################################################################
#################################################################
unittest_db.setup_db_deviceagent(self.data)
# Attempting to insert duplicate data should fail
with open(filepath, 'w') as f_handle:
json.dump(self.data, 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_db.initialize_db()
# 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)
