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)
