def test_key_value_pairs(self): """Testing method / function key_value_pairs.""" # Create a PattooDBrecord record = PattooDBrecord( pattoo_checksum='1', pattoo_key='3', pattoo_agent_polling_interval=1, pattoo_agent_id=4, pattoo_timestamp=5, pattoo_data_type=DATA_FLOAT, pattoo_value=6, pattoo_agent_polled_target='x', pattoo_agent_program='y', pattoo_agent_hostname='z', pattoo_metadata=[('key1', 'value'), ('key2', 'value')] ) # Test expected = [ ('pattoo_key', 'y_3'), ('y_key1', 'value'), ('y_key2', 'value') ] result = get.key_value_pairs(record) self.assertEqual(sorted(result), expected) # Test with a list result = get.key_value_pairs([record]) self.assertEqual(result, expected)
def test_idx_datapoint(self): """Testing method / function idx_datapoint.""" # Initialize key variables checksum = data.hashstring(str(random())) pattoo_db_record = PattooDBrecord( pattoo_checksum=checksum, pattoo_metadata=[('key', 'value')], pattoo_data_type=32, pattoo_key='polar_bear', pattoo_value=0.0, pattoo_timestamp=1575789070108, pattoo_agent_polled_target='panda_bear', pattoo_agent_program='koala_bear', pattoo_agent_hostname='grizzly_bear', pattoo_agent_id='red_stripe_beer', pattoo_agent_polling_interval=10000) # Checksum should not exist self.assertFalse(datapoint.checksum_exists(checksum)) # Test creation result = datapoint.idx_datapoint(pattoo_db_record) expected = datapoint.checksum_exists(checksum) self.assertEqual(result, expected) # Test after creation result = datapoint.idx_datapoint(pattoo_db_record) expected = datapoint.checksum_exists(checksum) self.assertEqual(result, expected)
def test_pairs(self): """Testing method / function pairs.""" pair1 = ('key1', data.hashstring(str(random()))) pair2 = ('key2', data.hashstring(str(random()))) pap = 'y' # Create a PattooDBrecord record = PattooDBrecord(pattoo_checksum='1', pattoo_key='3', pattoo_agent_id=4, pattoo_agent_polling_interval=1, pattoo_timestamp=5, pattoo_data_type=DATA_FLOAT, pattoo_value=6, pattoo_agent_polled_target='x', pattoo_agent_program=pap, pattoo_agent_hostname='z', pattoo_metadata=[pair1, pair2]) # Pairs shouldn't exist self.assertFalse( pair.pair_exists(get.make_key(pap, pair1[0]), pair1[1])) self.assertFalse( pair.pair_exists(get.make_key(pap, pair2[0]), pair2[1])) # Insert items result = get.pairs(record) self.assertTrue(pair.pair_exists(get.make_key(pap, pair1[0]), pair1[1])) self.assertTrue(pair.pair_exists(get.make_key(pap, pair2[0]), pair2[1])) self.assertTrue( pair.pair_exists(get.make_key(pap, pair1[0]), pair1[1]) in result) self.assertTrue( pair.pair_exists(get.make_key(pap, pair2[0]), pair2[1]) in result)
def test_data(self): """Testing method / function data.""" # Initialize key variables _data = [] expected = [] checksum = data.hashstring(str(random())) pattoo_key = data.hashstring(str(random())) agent_id = data.hashstring(str(random())) polling_interval = 300 * 1000 data_type = DATA_FLOAT _pattoo_value = 27 _timestamp = int(time.time() * 1000) ts_start = _timestamp for count in range(0, 10): timestamp = _timestamp + (polling_interval * count) ts_stop = timestamp pattoo_value = _pattoo_value * count insert = PattooDBrecord( pattoo_checksum=checksum, pattoo_key=pattoo_key, pattoo_agent_id=agent_id, pattoo_agent_polling_interval=polling_interval, pattoo_timestamp=timestamp, pattoo_data_type=data_type, pattoo_value=pattoo_value * count, pattoo_agent_polled_target='pattoo_agent_polled_target', pattoo_agent_program='pattoo_agent_program', pattoo_agent_hostname='pattoo_agent_hostname', pattoo_metadata=[]) # Create checksum entry in the DB, then update the data table idx_datapoint = datapoint.idx_datapoint(insert) _data.append( IDXTimestampValue(idx_datapoint=idx_datapoint, polling_interval=polling_interval, timestamp=timestamp, value=pattoo_value)) # Append to expected results expected.append({ 'timestamp': times.normalized_timestamp(polling_interval, timestamp), 'value': pattoo_value }) # Insert rows of new data lib_data.insert_rows(_data) # Test obj = DataPoint(idx_datapoint) result = obj.data(ts_start, ts_stop) self.assertEqual(result, expected)
def test_route_graphql(self): """Testing method / function add_url_rule (graphql).""" # Initialize key variables _data = [] pattoo_checksum = data.hashstring(str(random())) pattoo_key = data.hashstring(str(random())) agent_id = data.hashstring(str(random())) pattoo_agent_polled_target = data.hashstring(str(random())) _pi = 300 * 1000 data_type = DATA_FLOAT timestamp = int(time.time()) * 1000 pattoo_value = round(uniform(1, 100), 5) insert = PattooDBrecord( pattoo_checksum=pattoo_checksum, pattoo_key=pattoo_key, pattoo_agent_id=agent_id, pattoo_agent_polling_interval=_pi, pattoo_timestamp=timestamp, pattoo_data_type=data_type, pattoo_value=pattoo_value, pattoo_agent_polled_target=pattoo_agent_polled_target, pattoo_agent_program='pattoo_agent_program', pattoo_agent_hostname='pattoo_agent_hostname', pattoo_metadata=[]) # Create checksum entry in the DB, then update the data table idx_datapoint = datapoint.idx_datapoint(insert) _data.append( IDXTimestampValue(idx_datapoint=idx_datapoint, polling_interval=_pi, timestamp=timestamp, value=pattoo_value)) # Insert rows of new data lib_data.insert_rows(_data) # Test query = ('''\ { allDatapoints(idxDatapoint: "IDX") { edges { node { checksum } } } } '''.replace('IDX', str(idx_datapoint))) # Test graphql_result = _get(query) result = graphql_result['data']['allDatapoints']['edges'][0]['node'] self.assertEqual(result['checksum'], pattoo_checksum)
def test_insert_rows(self): """Testing method / function insert_rows.""" # Initialize key variables checksum = lib_data.hashstring(str(random())) agent_id = lib_data.hashstring(str(random())) data_type = DATA_FLOAT polling_interval = 10 pattoo_value = 27 pattoo_key = lib_data.hashstring(str(random())) timestamp = int(time.time() * 1000) insert = PattooDBrecord( pattoo_checksum=checksum, pattoo_key=pattoo_key, pattoo_agent_id=agent_id, pattoo_agent_polling_interval=polling_interval, pattoo_timestamp=timestamp, pattoo_data_type=data_type, pattoo_value=pattoo_value, pattoo_agent_polled_target='pattoo_agent_polled_target', pattoo_agent_program='pattoo_agent_program', pattoo_agent_hostname='pattoo_agent_hostname', pattoo_metadata=[] ) # Create checksum entry in the DB, then update the data table idx_datapoint = datapoint.idx_datapoint(insert) _data = [IDXTimestampValue( idx_datapoint=idx_datapoint, polling_interval=polling_interval, timestamp=timestamp, value=pattoo_value)] data.insert_rows(_data) # Verify that the data is there with db.db_query(20015) as session: rows = session.query( Data.value).filter(and_( Data.idx_datapoint == idx_datapoint, Data.timestamp == timestamp)) for row in rows: self.assertEqual(row.value, pattoo_value)
def make_records(): """Testing method / function process_db_records.""" # Initialize key variables checksum = lib_data.hashstring(str(random())) agent_id = lib_data.hashstring(str(random())) data_type = DATA_FLOAT _pi = 10 * 1000 pattoo_key = lib_data.hashstring(str(random())) _timestamp = times.normalized_timestamp(_pi, int(time.time() * 1000)) expected = [] timestamps = [] records = [] result = {} # Create a list of PattooDBrecord objects for pattoo_value in range(0, 5): timestamp = _timestamp + (pattoo_value * _pi) expected.append({'timestamp': timestamp, 'value': pattoo_value}) timestamps.append(timestamp) record = PattooDBrecord( pattoo_checksum=checksum, pattoo_key=pattoo_key, pattoo_agent_id=agent_id, pattoo_agent_polling_interval=_pi, pattoo_timestamp=timestamp, pattoo_data_type=data_type, pattoo_value=pattoo_value, pattoo_agent_polled_target='pattoo_agent_polled_target', pattoo_agent_program='pattoo_agent_program', pattoo_agent_hostname='pattoo_agent_hostname', pattoo_metadata=[]) records.append(record) result['records'] = records result['expected'] = expected result['timestamps'] = timestamps result['checksum'] = checksum return result
def test_route_data(self): """Testing method / function route_data.""" # Initialize key variables secondsago = 3600 ts_start = uri.chart_timestamp_args(secondsago) # Initialize key variables _data = [] checksum = data.hashstring(str(random())) pattoo_key = data.hashstring(str(random())) agent_id = data.hashstring(str(random())) _pi = 300 * 1000 data_type = DATA_FLOAT now = int(time.time()) * 1000 count = 0 for timestamp in range(ts_start, now, _pi): insert = PattooDBrecord( pattoo_checksum=checksum, pattoo_key=pattoo_key, pattoo_agent_id=agent_id, pattoo_agent_polling_interval=_pi, pattoo_timestamp=timestamp, pattoo_data_type=data_type, pattoo_value=count, pattoo_agent_polled_target='pattoo_agent_polled_target', pattoo_agent_program='pattoo_agent_program', pattoo_agent_hostname='pattoo_agent_hostname', pattoo_metadata=[]) count += 1 # Create checksum entry in the DB, then update the data table idx_datapoint = datapoint.idx_datapoint(insert) _data.append( IDXTimestampValue(idx_datapoint=idx_datapoint, polling_interval=_pi, timestamp=timestamp, value=count)) # Insert rows of new data lib_data.insert_rows(_data) # Test obj = DataPoint(idx_datapoint) ts_stop = obj.last_timestamp() expected = obj.data(ts_start, ts_stop) # Create URL config = WebConfig() url = ('{}/{}'.format(config.web_api_server_url(graphql=False), idx_datapoint)) # Check response with requests.get(url) as response: result = response.json() count = 0 for item in result: ts_norm = times.normalized_timestamp(_pi, ts_start) if item['timestamp'] < ts_norm: self.assertIsNone(item['value']) else: self.assertEqual(item, expected[count]) count += 1
def test_cache_to_keypairs(self): """Testing method or function named cache_to_keypairs.""" cache = { 'pattoo_agent_id': '123bb3a17c6cc915a98a859226d282b394ee0964956b7' 'd23c145fe9d94567241', 'pattoo_agent_polling_interval': 10000, 'pattoo_agent_timestamp': 1575789070210, 'pattoo_datapoints': { 'datapoint_pairs': [ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [11, 1, 2, 3, 4, 5, 6, 7, 12, 13, 14]], 'key_value_pairs': { '0': ['agent_snmpd_oid', '.1.3.6.1.2.1.2.2.1.10.1'], '1': ['pattoo_agent_hostname', 'swim'], '2': ['pattoo_agent_id', '123bb3a17c6cc915a98a859226d282b' '394ee0964956b7d23c145fe9d94567241'], '3': ['pattoo_agent_polled_target', 'localhost'], '4': ['pattoo_agent_polling_interval', '10000'], '5': ['pattoo_agent_program', 'pattoo_agent_snmpd'], '6': ['pattoo_key', 'agent_snmpd_.1.3.6.1.2.1.2.2.1.10'], '7': ['pattoo_data_type', 32], '8': ['pattoo_value', 4057039287.0], '9': ['pattoo_timestamp', 1575789070107], '10': ['pattoo_checksum', 'f6ac40a45ec4fa7d19823d8c318bb0c6d0a19f79ad4b04ab5' '290d65f42250296'], '11': ['agent_snmpd_oid', '.1.3.6.1.2.1.2.2.1.10.2'], '12': ['pattoo_value', 0.0], '13': ['pattoo_timestamp', 1575789070108], '14': ['pattoo_checksum', '2849bef00a05419c4614610814a1a8088a89a81a8192dbfa2' '77598e1ff3389da'] } } } # Test pattoo_db_records = converter.cache_to_keypairs(cache) # pattoo_db_records[0] # should have the values in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] result = pattoo_db_records[0] expected = PattooDBrecord( pattoo_checksum='5306d34dac4c0c90b5cdc09c37a62c0d3056c6f58044b7a9' 'e2c93c65d0de9d88e4173b5972e73b59cecdad4a80e28fc7' 'a0edd32db653156b05cf80efb818f5c8', pattoo_metadata=[ ('agent_snmpd_oid', '.1.3.6.1.2.1.2.2.1.10.1')], pattoo_data_type=32, pattoo_key='agent_snmpd_.1.3.6.1.2.1.2.2.1.10', pattoo_value=4057039287.0, pattoo_timestamp=1575789070107, pattoo_agent_polled_target='localhost', pattoo_agent_program='pattoo_agent_snmpd', pattoo_agent_hostname='swim', pattoo_agent_id='123bb3a17c6cc915a98a859226d282b394ee0964956b7d2' '3c145fe9d94567241', pattoo_agent_polling_interval='10000') self.assertEqual(result, expected) # pattoo_db_records[1] # should have the values in [11, 1, 2, 3, 4, 5, 6, 7, 12, 13, 14] result = pattoo_db_records[1] expected = PattooDBrecord( pattoo_checksum='5decef67c60b4528f142373f2d796b28241c9af51d78abe5' '29c92830e7491134de1dd600fb9c517f72a57a0f68640684' '4a3ca1138c69a494cbedcb36e5e866b9', pattoo_metadata=[ ('agent_snmpd_oid', '.1.3.6.1.2.1.2.2.1.10.2')], pattoo_data_type=32, pattoo_key='agent_snmpd_.1.3.6.1.2.1.2.2.1.10', pattoo_value=0.0, pattoo_timestamp=1575789070108, pattoo_agent_polled_target='localhost', pattoo_agent_program='pattoo_agent_snmpd', pattoo_agent_hostname='swim', pattoo_agent_id='123bb3a17c6cc915a98a859226d282b394ee0964956b7d23' 'c145fe9d94567241', pattoo_agent_polling_interval='10000') self.assertEqual(result, expected)
def test_route_graphql(self): """Testing method / function add_url_rule (graphql).""" # Initialize key variables _data = [] pattoo_checksum = data.hashstring(str(random())) pattoo_key = data.hashstring(str(random())) agent_id = data.hashstring(str(random())) pattoo_agent_polled_target = data.hashstring(str(random())) _pi = 300 * 1000 data_type = DATA_FLOAT timestamp = int(time.time()) * 1000 pattoo_value = round(uniform(1, 100), 5) insert = PattooDBrecord( pattoo_checksum=pattoo_checksum, pattoo_key=pattoo_key, pattoo_agent_id=agent_id, pattoo_agent_polling_interval=_pi, pattoo_timestamp=timestamp, pattoo_data_type=data_type, pattoo_value=pattoo_value, pattoo_agent_polled_target=pattoo_agent_polled_target, pattoo_agent_program='pattoo_agent_program', pattoo_agent_hostname='pattoo_agent_hostname', pattoo_metadata=[]) # Create checksum entry in the DB, then update the data table idx_datapoint = datapoint.idx_datapoint(insert) _data.append( IDXTimestampValue(idx_datapoint=idx_datapoint, polling_interval=_pi, timestamp=timestamp, value=pattoo_value)) # Insert rows of new data lib_data.insert_rows(_data) # Creating required test admin test_admin = { "username": "******", "first_name": "Pattoo Test", "last_name": "Pattoo Test", "password": "******", "role": 0, "password_expired": 0, "enabled": 1 } user.insert_row(DbRowUser(**test_admin)) # Get accesss token to make test queries acesss_query = ('''\ mutation{ authenticate(Input: {username: "******", password: "******"}) { accessToken refreshToken } } ''') # Replacing username and password in access_query acesss_query = acesss_query.replace("USERNAME", test_admin['username']) acesss_query = acesss_query.replace("PASSWORD", test_admin['password']) access_request = _query(acesss_query, query_type="Mutation") acesss_token = access_request['data']['authenticate']['accessToken'] # Test query = ('''\ { allDatapoints(idxDatapoint: "IDX", token: "TOKEN") { edges { node { checksum } } } } ''') # Replacing IDX and TOKEN in query query = query.replace("IDX", str(idx_datapoint)) query = query.replace("TOKEN", str(acesss_token)) # Test graphql_result = _query(query) result = graphql_result['data']['allDatapoints']['edges'][0]['node'] self.assertEqual(result['checksum'], pattoo_checksum)
def test_checksums(self): """Testing method / function checksums.""" # Initialize key variables expected = {} polling_interval = 1 pattoo_agent_polled_target = 'panda_bear' pattoo_agent_program = 'koala_bear' pattoo_agent_hostname = 'grizzly_bear' # Insert an entry in the agent table agent_id = data.hashstring(str(random())) idx_agent = agent.idx_agent(agent_id, pattoo_agent_polled_target, pattoo_agent_program) # Populate database with key-value pairs for data_index in range(0, 10): time.sleep(0.1) # Add the checksum to the database checksum = data.hashstring(str(random())) datapoint.insert_row(checksum, DATA_FLOAT, polling_interval, idx_agent) idx_datapoint = datapoint.checksum_exists(checksum) # Define what we expect from the test function expected[checksum] = ChecksumLookup( idx_datapoint=idx_datapoint, polling_interval=polling_interval, last_timestamp=1) # Add key-pairs to the database record = PattooDBrecord( pattoo_checksum=checksum, pattoo_key='key', pattoo_agent_polling_interval=polling_interval, pattoo_agent_id=agent_id, pattoo_timestamp=int(time.time() * 1000), pattoo_data_type=DATA_FLOAT, pattoo_value=(data_index * 10), pattoo_agent_polled_target=pattoo_agent_polled_target, pattoo_agent_program=pattoo_agent_program, pattoo_agent_hostname=pattoo_agent_hostname, pattoo_metadata=[]) pairs = get.key_value_pairs(record) pair.insert_rows(pairs) idx_pairs = pair.idx_pairs(pairs) # Create glue entry glue.insert_rows(idx_datapoint, idx_pairs) ####################################################################### # This is added to verify that we only get a subset of results ####################################################################### # Insert an entry in the agent table fake_agent_id = data.hashstring(str(random())) idx_agent = agent.idx_agent(fake_agent_id, pattoo_agent_polled_target, pattoo_agent_program) # Populate database with key-value pairs for data_index in range(0, 17): time.sleep(0.1) # Add the checksum to the database checksum = data.hashstring(str(random())) datapoint.insert_row(checksum, DATA_FLOAT, polling_interval, idx_agent) idx_datapoint = datapoint.checksum_exists(checksum) # Add key-pairs to the database record = PattooDBrecord( pattoo_checksum=checksum, pattoo_key='key', pattoo_agent_polling_interval=polling_interval, pattoo_agent_id=fake_agent_id, pattoo_timestamp=int(time.time() * 1000), pattoo_data_type=DATA_FLOAT, pattoo_value=(data_index * 10), pattoo_agent_polled_target=pattoo_agent_polled_target, pattoo_agent_program=pattoo_agent_program, pattoo_agent_hostname=pattoo_agent_hostname, pattoo_metadata=[]) pairs = get.key_value_pairs(record) pair.insert_rows(pairs) idx_pairs = pair.idx_pairs(pairs) # Create glue entry glue.insert_rows(idx_datapoint, idx_pairs) # Test result = misc.agent_checksums(agent_id) self.assertTrue(bool(result)) self.assertTrue(isinstance(result, dict)) self.assertEqual(len(result), len(expected)) for key, value in result.items(): self.assertEqual(value.idx_datapoint, expected[key].idx_datapoint) self.assertEqual(value.polling_interval, expected[key].polling_interval) self.assertEqual(value.last_timestamp, expected[key].last_timestamp)