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 TestFunctions(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['id_datapoint'] = database.id_datapoint() expected['last_timestamp'] = database.timestamp() expected['idx_deviceagent'] = database.idx_deviceagent() expected['idx_datapoint'] = database.idx_datapoint() expected['idx_department'] = database.idx_department() expected['idx_billcode'] = database.idx_billcode() expected['agent_label'] = database.agent_label() expected['agent_source'] = database.agent_source() expected['enabled'] = True expected['exists'] = True expected['billable'] = False expected['base_type'] = 1 expected['timefixed_value'] = None def test_id_datapoint_exists(self): """Testing function id_datapoint_exists.""" # Testing with known good value expected = True result = db_datapoint.id_datapoint_exists( self.expected['id_datapoint']) self.assertEqual(result, expected) # Testing with known bad value expected = False result = db_datapoint.id_datapoint_exists('bogus') self.assertEqual(result, expected) def test_idx_datapoint_exists(self): """Testing function idx_datapoint_exists.""" # Testing with known good value expected = True result = db_datapoint.idx_datapoint_exists( self.expected['idx_datapoint']) self.assertEqual(result, expected) # Testing with known bad value expected = False result = db_datapoint.idx_datapoint_exists(None) self.assertEqual(result, expected) def test_listing(self): """Testing function listing.""" # Testing with known good value results = db_datapoint.listing(self.expected['idx_deviceagent']) for result in results: for key, _ in result.items(): self.assertEqual(result[key], self.expected[key])
class TestFunctions(unittest.TestCase): """Checks all functions.""" ######################################################################### # 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.timestamp() expected['enabled'] = True expected['exists'] = True def test_device_agent_exists(self): """Testing function device_agent_exists.""" # Testing with known good value result = db_deviceagent.device_agent_exists( self.expected['idx_device'], self.expected['idx_agent']) 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.expected['idx_agent']) self.assertEqual(result, [1]) def test_agent_indices(self): """Testing function agent_indices.""" # Testing with known good value result = db_deviceagent.agent_indices(self.expected['idx_device']) self.assertEqual(result, [1]) def test_get_all_device_agents(self): """Testing function get_all_device_agents.""" results = db_deviceagent.get_all_device_agents() # There should only be one item in the result list self.assertEqual(len(results), 1) # Verify values in only result item for result in results: for key, _ in result.items(): self.assertEqual(result[key], self.expected[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)
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])
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'])
class TestFunctions(unittest.TestCase): """Checks all functions.""" ######################################################################### # General object setup ######################################################################### # Setup database based on the config database = unittest_setup_db.TestData() # Define expected values expected = {} expected['idx_device'] = database.idx_device() expected['devicename'] = database.devicename() expected['description'] = database.device_description() expected['enabled'] = True expected['exists'] = True def test_all_devices(self): """Testing function all_devices.""" # Test known working value results = db_device.all_devices() for result in results: for key, _ in result.items(): self.assertEqual(result[key], self.expected[key]) def test_devicename_exists(self): """Testing function devicename_exists.""" # Test known working value result = db_device.devicename_exists(self.expected['devicename']) self.assertEqual(result, True) # Test known false value result = db_device.devicename_exists(False) self.assertEqual(result, False) def test_idx_device_exists(self): """Testing function idx_exists.""" # Test known working value result = db_device.idx_device_exists(self.expected['idx_device']) self.assertEqual(result, True) # Test known false value result = db_device.idx_device_exists(-1) self.assertEqual(result, False)
class TestFunctions(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_datapoint'] = database.idx_datapoint() expected['id_agent'] = database.id_agent() expected['devicename'] = database.devicename() expected['agent_label'] = database.agent_label() expected['agent_source'] = database.agent_source() expected['agent'] = database.agent() expected['idx_deviceagent'] = database.idx_deviceagent() def test_datapoint_summary_list(self): """Testing function datapoint_summary_list.""" # Start testing results = db_multitable.datapoint_summary_list() for data_dict in results: for key, _ in data_dict.items(): self.assertEqual(data_dict[key], self.expected[key]) def test_datapoint_summary(self): """Testing function datapoint_summary.""" # Start testing result = db_multitable.datapoint_summary() for idx_datapoint, _ in result.items(): data_dict = result[idx_datapoint] for key, _ in data_dict.items(): self.assertEqual(data_dict[key], self.expected[key]) def test__datapoint_summary(self): """Testing function _datapoint_summary.""" # Tested by test_datapoint_summary and test_datapoint_summary_list pass
class TestFunctions(unittest.TestCase): """Checks all functions and methods.""" # Setup database based on the config database = unittest_setup_db.TestData() # Define expected values expected = {} expected['idx_department'] = database.idx_department() expected['name'] = database.department_name() expected['code'] = database.department_code() expected['enabled'] = True expected['exists'] = True def test_code_exists(self): """Testing function code_exists.""" # Testing with known good value expected = True result = db_department.code_exists(self.expected['code']) self.assertEqual(result, expected) # Testing with known bad value expected = False result = db_department.code_exists('bogus') self.assertEqual(result, expected) def test_idx_department_exists(self): """Testing function idx_department_exists.""" # Testing with known good value expected = True result = db_department.idx_department_exists( self.expected['idx_department']) self.assertEqual(result, expected) # Testing with known bad value expected = False result = db_department.idx_department_exists(None) self.assertEqual(result, expected)
class TestGetCodeBillcode(unittest.TestCase): """Checks all functions and methods.""" # Setup database based on the config database = unittest_setup_db.TestData() # Define expected values expected = {} expected['idx_billcode'] = database.idx_billcode() expected['name'] = database.billcode_name() expected['code'] = database.billcode_code() expected['enabled'] = True expected['exists'] = True # Retrieve data good_agent = db_billcode.GetCodeBillcode(expected['code']) def test_init_getcode(self): """Testing method __init__.""" # Test with non existent AgentID record = db_billcode.GetCodeBillcode('bogus') self.assertEqual(record.enabled(), None) self.assertEqual(record.idx_billcode(), None) self.assertEqual(record.code(), None) self.assertEqual(record.name(), None) self.assertEqual(record.exists(), False) def test_idx_billcode(self): """Testing method idx_billcode.""" # Testing with known good value result = self.good_agent.idx_billcode() self.assertEqual(result, self.expected['idx_billcode']) # Testing with known bad value expected = ('bogus') result = self.good_agent.idx_billcode() self.assertNotEqual(result, expected) def test_name(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_code(self): """Testing method code.""" # Testing with known good value result = self.good_agent.code() self.assertEqual(result, self.expected['code']) # Testing with known bad value expected = ('bogus') result = self.good_agent.code() 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(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_billcode', 'code', 'name', 'enabled', '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_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 TestGetIDXDevice(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_device'] = database.idx_device() expected['devicename'] = database.devicename() expected['description'] = database.device_description() expected['enabled'] = True expected['exists'] = True # Create device object good_device = db_device.GetIDXDevice(expected['idx_device']) def test_init(self): """Testing method __init__.""" # Test with non existent IDXDevice record = db_device.GetIDXDevice('bogus') self.assertEqual(record.exists(), False) self.assertEqual(record.devicename(), None) self.assertEqual(record.enabled(), None) self.assertEqual(record.description(), None) self.assertEqual(record.idx_device(), None) def test_devicename(self): """Testing method devicename.""" # Testing with known good value result = self.good_device.devicename() self.assertEqual(result, self.expected['devicename']) # Testing with known bad value expected = ('bogus') result = self.good_device.devicename() self.assertNotEqual(result, expected) def test_description(self): """Testing function description.""" # Testing with known good value result = self.good_device.description() self.assertEqual(result, self.expected['description']) # Testing with known bad value expected = ('bogus') result = self.good_device.description() self.assertNotEqual(result, expected) def test_enabled(self): """Testing function enabled.""" # Testing with known good value result = self.good_device.enabled() self.assertEqual(result, self.expected['enabled']) # Testing with known bad value expected = ('bogus') result = self.good_device.enabled() self.assertNotEqual(result, expected) def test_exists(self): """Testing function exists.""" # Testing with known good value result = self.good_device.exists() self.assertEqual(result, True) 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 = ['idx_device', 'devicename', 'description', 'enabled', 'exists'] self.assertEqual(len(result), len(keys)) for key in keys: self.assertEqual(key in result, True)
class TestGetDevice(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_device'] = database.idx_device() expected['devicename'] = database.devicename() expected['description'] = database.device_description() expected['enabled'] = True expected['exists'] = True # Create device object good_device = db_device.GetDevice(expected['devicename']) def test___init__(self): """Testing function __init__.""" # Test with non existent DeviceIDX record = db_device.GetDevice('bogus') self.assertEqual(record.exists(), False) self.assertEqual(record.devicename(), None) self.assertEqual(record.enabled(), None) self.assertEqual(record.description(), None) self.assertEqual(record.idx_device(), None) 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']) # Testing with known bad value expected = ('bogus') result = self.good_device.devicename() self.assertNotEqual(result, expected) def test_exists(self): """Testing function exists.""" # Testing with known good value result = self.good_device.exists() self.assertEqual(result, True) def test_description(self): """Testing function description.""" # Testing with known good value result = self.good_device.description() self.assertEqual(result, self.expected['description']) # Testing with known bad value expected = ('bogus') result = self.good_device.description() self.assertNotEqual(result, expected) def test_enabled(self): """Testing function enabled.""" # Testing with known good value result = self.good_device.enabled() self.assertEqual(result, self.expected['enabled']) # Testing with known bad value expected = ('bogus') result = self.good_device.enabled() self.assertNotEqual(result, expected)
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_datapoint'] = database.idx_datapoint() expected['id_datapoint'] = database.id_datapoint() expected['idx_deviceagent'] = database.idx_deviceagent() expected['id_agent'] = database.id_agent() expected['devicename'] = database.devicename() expected['agent'] = database.agent() expected['values'] = database.values() # Retrieve data test_object = db_datapoint.GetIDXDatapoint(expected['idx_datapoint']) def setUp(self): """Setup the environment prior to testing.""" # Test mode API.config['TESTING'] = True self.API = API.test_client() def test_datapoints(self): """Testing method / function datapoints.""" # Clear the memory cache CACHE.clear() # Get results uri = ('/infoset/api/v1/datapoints/{}'.format( self.expected['idx_datapoint'])) 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_datapoint'], self.test_object.idx_datapoint()) self.assertEqual(result['id_datapoint'], self.test_object.id_datapoint()) self.assertEqual(result['idx_deviceagent'], self.test_object.idx_deviceagent()) self.assertEqual(result['idx_department'], self.test_object.idx_department()) self.assertEqual(result['idx_billcode'], self.test_object.idx_billcode()) self.assertEqual(result['agent_label'], self.test_object.agent_label()) self.assertEqual(result['agent_source'], self.test_object.agent_source()) self.assertEqual(result['billable'], self.test_object.billable()) self.assertEqual(result['base_type'], self.test_object.base_type()) self.assertEqual(result['timefixed_value'], self.test_object.timefixed_value()) self.assertEqual(result['last_timestamp'], self.test_object.last_timestamp()) self.assertEqual(result['exists'], self.test_object.exists()) self.assertEqual(result['enabled'], self.test_object.enabled()) # Test the number and names of keys keys = [ 'idx_datapoint', 'id_datapoint', 'idx_deviceagent', 'idx_department', 'idx_billcode', 'agent_label', 'agent_source', 'enabled', 'billable', 'base_type', 'timefixed_value', 'last_timestamp', 'exists' ] self.assertEqual(len(result), len(keys)) for key in keys: self.assertEqual(key in result, True) def test_datapoints_query_1(self): """Testing method / function datapoints_query.""" # Clear the memory cache CACHE.clear() ####################################################################### # Try with id_datapoint in query string ####################################################################### # Get results uri = ('/infoset/api/v1/datapoints?id_datapoint={}' ''.format(self.expected['id_datapoint'])) 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['idx_datapoint'], self.test_object.idx_datapoint()) self.assertEqual(result['id_datapoint'], self.test_object.id_datapoint()) self.assertEqual(result['idx_deviceagent'], self.test_object.idx_deviceagent()) self.assertEqual(result['idx_department'], self.test_object.idx_department()) self.assertEqual(result['idx_billcode'], self.test_object.idx_billcode()) self.assertEqual(result['agent_label'], self.test_object.agent_label()) self.assertEqual(result['agent_source'], self.test_object.agent_source()) self.assertEqual(result['billable'], self.test_object.billable()) self.assertEqual(result['base_type'], self.test_object.base_type()) self.assertEqual(result['timefixed_value'], self.test_object.timefixed_value()) self.assertEqual(result['last_timestamp'], self.test_object.last_timestamp()) self.assertEqual(result['exists'], self.test_object.exists()) self.assertEqual(result['enabled'], self.test_object.enabled()) # Test the number and names of keys keys = [ 'idx_datapoint', 'id_datapoint', 'idx_deviceagent', 'idx_department', 'idx_billcode', 'agent_label', 'agent_source', 'enabled', 'billable', 'base_type', 'timefixed_value', 'last_timestamp', 'exists' ] self.assertEqual(len(result), len(keys)) for key in keys: self.assertEqual(key in result, True) ####################################################################### # Try with idx_deviceagent in query string ####################################################################### # Clear the memory cache CACHE.clear() # Get results uri = ('/infoset/api/v1/datapoints?idx_deviceagent={}' ''.format(self.expected['idx_deviceagent'])) 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['idx_datapoint'], self.test_object.idx_datapoint()) self.assertEqual(result['id_datapoint'], self.test_object.id_datapoint()) self.assertEqual(result['idx_deviceagent'], self.test_object.idx_deviceagent()) self.assertEqual(result['idx_department'], self.test_object.idx_department()) self.assertEqual(result['idx_billcode'], self.test_object.idx_billcode()) self.assertEqual(result['agent_label'], self.test_object.agent_label()) self.assertEqual(result['agent_source'], self.test_object.agent_source()) self.assertEqual(result['billable'], self.test_object.billable()) self.assertEqual(result['base_type'], self.test_object.base_type()) self.assertEqual(result['timefixed_value'], self.test_object.timefixed_value()) self.assertEqual(result['last_timestamp'], self.test_object.last_timestamp()) self.assertEqual(result['exists'], self.test_object.exists()) self.assertEqual(result['enabled'], self.test_object.enabled()) # Test the number and names of keys keys = [ 'idx_datapoint', 'id_datapoint', 'idx_deviceagent', 'idx_department', 'idx_billcode', 'agent_label', 'agent_source', 'enabled', 'billable', 'base_type', 'timefixed_value', 'last_timestamp', 'exists' ] self.assertEqual(len(result), len(keys)) for key in keys: self.assertEqual(key in result, True) def test_getdata_secondsago_1(self): """Testing method / function getdata.""" # Clear the memory cache CACHE.clear() # Initialize key variables precision = 5 ####################################################################### # Try an hour ago ####################################################################### # Get results for up to an hour ago uri = ('/infoset/api/v1/datapoints/{}/data?secondsago=3600' ''.format(self.expected['idx_datapoint'])) response = self.API.get(uri) result = json.loads(response.get_data(as_text=True)) # Convert the list of expected values to an easy to compare dict check_dict = {} for item in self.expected['values']: check_dict[str(item['timestamp'])] = item['value'] # Verify the expected data is there for timestamp, value in sorted(result.items()): if timestamp in check_dict: self.assertEqual(round(result[timestamp], precision), round(check_dict[timestamp], precision)) else: self.assertEqual(value, 0) ####################################################################### # Try an 1/4 ago. No data should be present ####################################################################### # Clear the memory cache CACHE.clear() # Get results uri = ('/infoset/api/v1/datapoints/{}/data?secondsago=900' ''.format(self.expected['idx_datapoint'])) response = self.API.get(uri) result = json.loads(response.get_data(as_text=True)) # Go through the results for timestamp, value in sorted(result.items()): self.assertEqual(result[timestamp], 0) self.assertEqual(value, 0) def test_getdata_timestamp(self): """Testing method / function getdata.""" # Clear the memory cache CACHE.clear() # Initialize key variables precision = 5 ts_stop = int(datetime.utcnow().timestamp()) ts_start = ts_stop - 3600 # Get results for up to 1/4 hour ago - No data should be present uri = ('/infoset/api/v1/datapoints/{}/data?ts_start={}&ts_stop={}' ''.format(self.expected['idx_datapoint'], ts_start, ts_stop)) response = self.API.get(uri) result = json.loads(response.get_data(as_text=True)) # Convert the list of expected values to an easy to compare dict check_dict = {} for item in self.expected['values']: check_dict[str(item['timestamp'])] = item['value'] # Verify the expected data is there for timestamp, value in sorted(result.items()): if timestamp in check_dict: self.assertEqual(round(result[timestamp], precision), round(check_dict[timestamp], precision)) else: self.assertEqual(value, 0) def test_db_datapoint_summary(self): """Testing method / function db_datapoint_summary.""" # Clear the memory cache CACHE.clear() # Get results uri = '/infoset/api/v1/datapoints/all/summary' response = self.API.get(uri) 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(len(data), 1) for idx_datapoint, result in data.items(): self.assertEqual(int(idx_datapoint), self.test_object.idx_datapoint()) self.assertEqual(result['idx_deviceagent'], self.test_object.idx_deviceagent()) self.assertEqual(result['agent_label'], self.test_object.agent_label()) self.assertEqual(result['agent_source'], self.test_object.agent_source()) # Get remaining values self.assertEqual(result['devicename'], self.expected['devicename']) self.assertEqual(result['id_agent'], self.expected['id_agent']) self.assertEqual(result['agent'], self.expected['agent']) # Test the number and names of keys keys = [ 'idx_deviceagent', 'agent_label', 'agent_source', 'devicename', 'id_agent', 'agent' ] self.assertEqual(len(result), len(keys)) for key in keys: self.assertEqual(key in result, True) # All done break def test_db_datapoint_summary_list(self): """Testing method / function db_datapoint_summary_list.""" # Clear the memory cache CACHE.clear() # Get results uri = '/infoset/api/v1/datapoints/all/summarylist' 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['idx_datapoint'], self.test_object.idx_datapoint()) self.assertEqual(result['idx_deviceagent'], self.test_object.idx_deviceagent()) self.assertEqual(result['agent_label'], self.test_object.agent_label()) self.assertEqual(result['agent_source'], self.test_object.agent_source()) # Get remaining values self.assertEqual(result['devicename'], self.expected['devicename']) self.assertEqual(result['id_agent'], self.expected['id_agent']) self.assertEqual(result['agent'], self.expected['agent']) # Test the number and names of keys keys = [ 'idx_datapoint', 'idx_deviceagent', 'agent_label', 'agent_source', 'devicename', 'id_agent', 'agent' ] 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['values'] = database.values() expected['idx_device'] = database.idx_device() expected['idx_deviceagent'] = database.idx_deviceagent() expected['agent'] = database.agent() expected['devicename'] = database.devicename() expected['id_agent'] = database.id_agent() expected['agent_label'] = database.agent_label() # Retrieve data test_object = db_device.GetIDXDevice(expected['idx_device']) def setUp(self): """Setup the environment prior to testing.""" # Test mode API.config['TESTING'] = True self.API = API.test_client() def test_lastcontacts(self): """Testing method / function lastcontacts.""" # Initialize key variables precision = 5 ####################################################################### # Try with secondsago = 3600 ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = '/infoset/api/v1/lastcontacts?secondsago=3600' response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with secondsago = 60 (No values expected) ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to a minute ago uri = '/infoset/api/v1/lastcontacts?secondsago=60' response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) self.assertEqual(bool(results), False) ####################################################################### # Try with ts_start = 0 ####################################################################### # Clear the memory cache CACHE.clear() # Get results uri = '/infoset/api/v1/lastcontacts?ts_start=0' response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with ts_start = an hour ago ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago ts_start = int(datetime.utcnow().timestamp()) - 3600 uri = '/infoset/api/v1/lastcontacts?ts_start={}'.format(ts_start) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with ts_start = a minute ago ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago ts_start = int(datetime.utcnow().timestamp()) - 60 uri = '/infoset/api/v1/lastcontacts?ts_start={}'.format(ts_start) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test type of result self.assertEqual(isinstance(results, list), True) self.assertEqual(bool(results), False) def test_id_agents(self): """Testing method / function id_agents.""" # Initialize key variables precision = 5 ####################################################################### # Try with default values ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = '/infoset/api/v1/lastcontacts/id_agents' response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Further testing result = results[0] self.assertEqual(result['agent'], self.expected['agent']) self.assertEqual(result['devicename'], self.expected['devicename']) self.assertEqual(result['id_agent'], self.expected['id_agent']) self.assertEqual('timeseries' in result, True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] # We should only have a single result to test for agent_label, data_dict in result['timeseries'].items(): # Test match for agent_label self.assertEqual(agent_label, self.expected['agent_label']) for key, value in data_dict.items(): # Test presence of timeseries values if key == 'timestamp': self.assertEqual(value, expected['timestamp']) elif key == 'value': self.assertEqual( round(value, precision), round(expected['value'], precision)) ####################################################################### # Try with secondsago = 3600 ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = '/infoset/api/v1/lastcontacts/id_agents?secondsago=3600' response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Further testing result = results[0] self.assertEqual(result['agent'], self.expected['agent']) self.assertEqual(result['devicename'], self.expected['devicename']) self.assertEqual(result['id_agent'], self.expected['id_agent']) self.assertEqual('timeseries' in result, True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] # We should only have a single result to test for agent_label, data_dict in result['timeseries'].items(): # Test match for agent_label self.assertEqual(agent_label, self.expected['agent_label']) for key, value in data_dict.items(): # Test presence of timeseries values if key == 'timestamp': self.assertEqual(value, expected['timestamp']) elif key == 'value': self.assertEqual( round(value, precision), round(expected['value'], precision)) ####################################################################### # Try with secondsago = 60 (No response expected) ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = '/infoset/api/v1/lastcontacts/id_agents?secondsago=60' response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) self.assertEqual(bool(results), False) ####################################################################### # Try with ts_star = 0 ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = '/infoset/api/v1/lastcontacts/id_agents?ts_start=0' response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Further testing result = results[0] self.assertEqual(result['agent'], self.expected['agent']) self.assertEqual(result['devicename'], self.expected['devicename']) self.assertEqual(result['id_agent'], self.expected['id_agent']) self.assertEqual('timeseries' in result, True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] # We should only have a single result to test for agent_label, data_dict in result['timeseries'].items(): # Test match for agent_label self.assertEqual(agent_label, self.expected['agent_label']) for key, value in data_dict.items(): # Test presence of timeseries values if key == 'timestamp': self.assertEqual(value, expected['timestamp']) elif key == 'value': self.assertEqual( round(value, precision), round(expected['value'], precision)) ####################################################################### # Try with ts_start = an hour ago ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago ts_start = int(datetime.utcnow().timestamp()) - 3600 uri = ( '/infoset/api/v1/lastcontacts/id_agents?ts_start={}' ''.format(ts_start)) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Further testing result = results[0] self.assertEqual(result['agent'], self.expected['agent']) self.assertEqual(result['devicename'], self.expected['devicename']) self.assertEqual(result['id_agent'], self.expected['id_agent']) self.assertEqual('timeseries' in result, True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] # We should only have a single result to test for agent_label, data_dict in result['timeseries'].items(): # Test match for agent_label self.assertEqual(agent_label, self.expected['agent_label']) for key, value in data_dict.items(): # Test presence of timeseries values if key == 'timestamp': self.assertEqual(value, expected['timestamp']) elif key == 'value': self.assertEqual( round(value, precision), round(expected['value'], precision)) ####################################################################### # Try with ts_start = 15 minutes ago (No values expected) ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago ts_start = int(datetime.utcnow().timestamp()) - 900 uri = ( '/infoset/api/v1/lastcontacts/id_agents?ts_start={}' ''.format(ts_start)) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) self.assertEqual(bool(results), False) def test_deviceagents(self): """Testing method / function deviceagents.""" # Initialize key variables precision = 5 ####################################################################### # Try with secondsago = 3600 ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = ( '/infoset/api/v1/lastcontacts/deviceagents/{}?secondsago=3600' ''.format(self.expected['idx_deviceagent'])) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with secondsago = 60 (No response expected) ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = ( '/infoset/api/v1/lastcontacts/deviceagents/{}?secondsago=60' ''.format(self.expected['idx_deviceagent'])) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) self.assertEqual(bool(results), False) ####################################################################### # Try with ts_star = 0 ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = ( '/infoset/api/v1/lastcontacts/deviceagents/{}?ts_start=0' ''.format(self.expected['idx_deviceagent'])) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with ts_start = an hour ago ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago ts_start = int(datetime.utcnow().timestamp()) - 3600 uri = ( '/infoset/api/v1/lastcontacts/deviceagents/{}?ts_start={}' ''.format(self.expected['idx_deviceagent'], ts_start)) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with ts_start = 15 minutes ago (No values expected) ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago ts_start = int(datetime.utcnow().timestamp()) - 900 uri = ( '/infoset/api/v1/lastcontacts/deviceagents/{}?ts_start={}' ''.format(self.expected['idx_deviceagent'], ts_start)) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) self.assertEqual(bool(results), False) def test_devicename_agents(self): """Testing method / function devicename_agents.""" # Initialize key variables precision = 5 ####################################################################### # Try with secondsago = 3600 ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = ( '/infoset/api/v1/lastcontacts/devicenames/{}/id_agents/{}' '?secondsago=3600' ''.format(self.expected['devicename'], self.expected['id_agent'])) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with secondsago = 60 (No response expected) ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = ( '/infoset/api/v1/lastcontacts/devicenames/{}/id_agents/{}' '?secondsago=60' ''.format(self.expected['devicename'], self.expected['id_agent'])) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) self.assertEqual(bool(results), False) ####################################################################### # Try with ts_star = 0 ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago uri = ( '/infoset/api/v1/lastcontacts/devicenames/{}/id_agents/{}' '?ts_start=0' ''.format(self.expected['devicename'], self.expected['id_agent'])) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with ts_start = an hour ago ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago ts_start = int(datetime.utcnow().timestamp()) - 3600 uri = ( '/infoset/api/v1/lastcontacts/devicenames/{}/id_agents/{}' '?ts_start={}' ''.format( self.expected['devicename'], self.expected['id_agent'], ts_start)) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) # First item in expected should be the most recent contact. # Expected['values'] is sorted by timestamp. expected = self.expected['values'][0] result = results[0] self.assertEqual(result['timestamp'], expected['timestamp']) self.assertEqual( round(result['value'], precision), round(expected['value'], precision)) ####################################################################### # Try with ts_start = 15 minutes ago (No values expected) ####################################################################### # Clear the memory cache CACHE.clear() # Get results for up to an hour ago ts_start = int(datetime.utcnow().timestamp()) - 900 uri = ( '/infoset/api/v1/lastcontacts/devicenames/{}/id_agents/{}' '?ts_start={}' ''.format( self.expected['devicename'], self.expected['id_agent'], ts_start)) response = self.API.get(uri) results = json.loads(response.get_data(as_text=True)) # Test self.assertEqual(isinstance(results, list), True) self.assertEqual(bool(results), False) def test__start_timestamp(self): """Testing method / function _start_timestamp.""" # Tested by other unittests here pass
class TestGetDeviceAgent(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.GetDeviceAgent(expected['idx_device'], expected['idx_agent']) def test___init__(self): """Testing method __init__.""" # Test with non existent IDXDevice record = db_deviceagent.GetDeviceAgent('bogus', '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) 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.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)
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['id_datapoint'] = database.id_datapoint() expected['last_timestamp'] = database.timestamp() expected['idx_deviceagent'] = database.idx_deviceagent() expected['idx_datapoint'] = database.idx_datapoint() expected['idx_department'] = database.idx_department() expected['idx_billcode'] = database.idx_billcode() expected['agent_label'] = database.agent_label() expected['agent_source'] = database.agent_source() expected['enabled'] = True expected['exists'] = True expected['billable'] = False expected['base_type'] = 1 expected['timefixed_value'] = None # Retriev edata testing = db_datapoint.GetIDXDatapoint(expected['idx_datapoint']) def test___init__(self): """Testing function __init__.""" # Test with non existent AgentIDX record = db_datapoint.GetIDXDatapoint(-1) self.assertEqual(record.exists(), False) self.assertEqual(record.enabled(), None) self.assertEqual(record.last_timestamp(), None) self.assertEqual(record.timefixed_value(), None) self.assertEqual(record.base_type(), None) self.assertEqual(record.billable(), None) self.assertEqual(record.agent_source(), None) self.assertEqual(record.idx_deviceagent(), None) self.assertEqual(record.id_datapoint(), None) self.assertEqual(record.idx_datapoint(), None) self.assertEqual(record.idx_department(), None) self.assertEqual(record.idx_billcode(), None) self.assertEqual(record.agent_label(), None) def test_exists(self): """Testing function exists.""" # Testing with known good value result = self.testing.exists() self.assertEqual(result, self.expected['exists']) def test_everything(self): """Testing function everything.""" # Testing with known good value result = self.testing.everything() for key, _ in result.items(): self.assertEqual(result[key], self.expected[key]) def test_last_timestamp(self): """Testing function last_timestamp.""" # Testing with known good value result = self.testing.last_timestamp() self.assertEqual(result, self.expected['last_timestamp']) def test_timefixed_value(self): """Testing function timefixed_value.""" # Testing with known good value result = self.testing.timefixed_value() self.assertEqual(result, self.expected['timefixed_value']) def test_base_type(self): """Testing function base_type.""" # Testing with known good value result = self.testing.base_type() self.assertEqual(result, self.expected['base_type']) def test_enabled(self): """Testing function enabled.""" # Testing with known good value result = self.testing.base_type() self.assertEqual(result, self.expected['enabled']) def test_billable(self): """Testing function billable.""" # Testing with known good value result = self.testing.billable() self.assertEqual(result, self.expected['billable']) def test_agent_source(self): """Testing function agent_source.""" # Testing with known good value result = self.testing.agent_source() self.assertEqual(result, self.expected['agent_source']) def test_idx_deviceagent(self): """Testing function idx_deviceagent.""" # Testing with known good value result = self.testing.idx_deviceagent() self.assertEqual(result, self.expected['idx_deviceagent']) def test_id_datapoint(self): """Testing function id_datapoint.""" # Testing with known good value result = self.testing.id_datapoint() self.assertEqual(result, self.expected['id_datapoint']) def test_idx_datapoint(self): """Testing function idx_datapoint.""" # Testing with known good value result = self.testing.idx_datapoint() self.assertEqual(result, self.expected['idx_datapoint']) def test_idx_department(self): """Testing function idx_department.""" # Testing with known good value result = self.testing.idx_department() self.assertEqual(result, self.expected['idx_department']) def test_idx_billcode(self): """Testing function idx_billcode.""" # Testing with known good value result = self.testing.idx_billcode() self.assertEqual(result, self.expected['idx_billcode']) def test_agent_label(self): """Testing function agent_label.""" # Testing with known good value result = self.testing.agent_label() self.assertEqual(result, self.expected['agent_label'])
class TestGetCodeDepartment(unittest.TestCase): """Checks all functions and methods.""" # Setup database based on the config database = unittest_setup_db.TestData() # Define expected values expected = {} expected['idx_department'] = database.idx_department() expected['name'] = database.department_name() expected['code'] = database.department_code() expected['enabled'] = True expected['exists'] = True # Retrieve data good_agent = db_department.GetCodeDepartment(expected['code']) def test_init_getcode(self): """Testing method __init__.""" # Test with non existent AgentID record = db_department.GetCodeDepartment('bogus') self.assertEqual(record.exists(), False) def test_idx_department(self): """Testing method idx_department.""" # Testing with known good value result = self.good_agent.idx_department() self.assertEqual(result, self.expected['idx_department']) # Testing with known bad value expected = ('bogus') result = self.good_agent.idx_department() self.assertNotEqual(result, expected) def test_name(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_code(self): """Testing method code.""" # Testing with known good value result = self.good_agent.code() self.assertEqual(result, self.expected['code']) # Testing with known bad value expected = ('bogus') result = self.good_agent.code() 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(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)
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['timestamp'] = database.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['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___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)
class TestGetIdentifier(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['id_agent'] = database.id_agent() expected['idx_agentname'] = database.idx_agentname() expected['enabled'] = True expected['exists'] = True # Retrieve data good_agent = db_agent.GetIDAgent(expected['id_agent']) def test_init(self): """Testing method __init__.""" # Test with non existent AgentID record = db_agent.GetIDAgent('bogus') self.assertEqual(record.exists(), False) self.assertEqual(record.enabled(), None) self.assertEqual(record.idx_agent(), None) self.assertEqual(record.idx_agentname(), None) 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, True) 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_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])
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 TestGetIDXBillcode(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_billcode'] = database.idx_billcode() expected['name'] = database.billcode_name() expected['code'] = database.billcode_code() expected['enabled'] = True expected['exists'] = True # Retrieve data good_agent = db_billcode.GetIDXBillcode(expected['idx_billcode']) def test_init_(self): """Testing method init.""" # Test with non existent AgentIDX record = db_billcode.GetIDXBillcode(-1) self.assertEqual(record.exists(), False) self.assertEqual(record.enabled(), None) self.assertEqual(record.idx_billcode(), None) self.assertEqual(record.code(), None) self.assertEqual(record.name(), None) def test_idx_billcode(self): """Testing method idx_billcode.""" # Testing with known good value result = self.good_agent.idx_billcode() self.assertEqual(result, self.expected['idx_billcode']) # Testing with known bad value expected = ('bogus') result = self.good_agent.idx_billcode() self.assertNotEqual(result, expected) def test_name(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_code(self): """Testing method code.""" # Testing with known good value result = self.good_agent.code() self.assertEqual(result, self.expected['code']) # Testing with known bad value expected = ('bogus') result = self.good_agent.code() 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(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)