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)