def test_update_row(self):
"""Testing method / function update_row."""
# Add a language entry to the database
code = data.hashstring(str(random()))
_translation = data.hashstring(str(random()))
language.insert_row(code, _translation)
idx_language = language.exists(code)
# Make sure row does not exist
translation = data.hashstring(str(random()))
key = data.hashstring(str(random()))
result = agent_xlate.agent_xlate_exists(idx_language, key)
self.assertFalse(result)
# Add an entry to the database
agent_xlate.insert_row(key, translation, idx_language)
# Test existence
result = agent_xlate.agent_xlate_exists(idx_language, key)
self.assertTrue(result)
# Test update
new_translation = data.hashstring(str(random()))
agent_xlate.update_row(key, new_translation, idx_language)
with db.db_query(20134) as session:
row = session.query(AgentXlate).filter(
and_(AgentXlate.agent_program == key.encode(),
AgentXlate.idx_language == idx_language)).one()
self.assertEqual(row.translation.decode(), new_translation)
def test_idx_pair_xlate_group(self):
"""Testing method / function idx_pair_xlate_group."""
# Create a new PairXlateGroup entry
translation = data.hashstring(str(random()))
pair_xlate_group.insert_row(translation)
idx_pair_xlate_group = pair_xlate_group.exists(translation)
# Add an entry to the database
translation = data.hashstring(str(random()))
agent_group.insert_row(translation)
# Make sure it exists
idx_agent_group = agent_group.exists(translation)
# Assign AgentGroup
agent_group.assign(idx_agent_group, idx_pair_xlate_group)
# Add an entry to the database
agent_id = data.hashstring(str(random()))
agent_target = data.hashstring(str(random()))
agent_program = data.hashstring(str(random()))
agent.insert_row(agent_id, agent_target, agent_program)
idx_agent = agent.exists(agent_id, agent_target)
# Assign Agent got AgentGroup
agent.assign(idx_agent, idx_agent_group)
# Test
result = agent.idx_pair_xlate_group(agent_id)
self.assertEqual(result, idx_pair_xlate_group)
def _idx_datapoint():
"""Create a new DataPoint db entry.
Args:
value: Value to convert
Returns:
result: idx_datapoint value for new DataPoint
"""
# Initialize key variables
polling_interval = 1
# Create a new Agent entry
agent_id = data.hashstring(str(random()))
agent_target = data.hashstring(str(random()))
agent_program = data.hashstring(str(random()))
agent.insert_row(agent_id, agent_target, agent_program)
idx_agent = agent.exists(agent_id, agent_target)
# Create entry and check
_checksum = data.hashstring(str(random()))
result = datapoint.checksum_exists(_checksum)
datapoint.insert_row(_checksum, DATA_FLOAT, polling_interval, idx_agent)
result = datapoint.checksum_exists(_checksum)
return result
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_update_name(self):
"""Testing method / function update_name."""
# Add an entry to the database
code = data.hashstring(str(random()))
name = data.hashstring(str(random()))
language.insert_row(code, name)
# Get current name
with db.db_query(20003) as session:
result = session.query(
Language.name).filter(Language.code == code.encode()).one()
# Test
self.assertEqual(name, result.name.decode())
# Update the name
new_name = data.hashstring(str(random()))
language.update_name(code, new_name)
# Get current name
with db.db_query(20045) as session:
result = session.query(
Language.name).filter(Language.code == code.encode()).one()
# Test
self.assertEqual(new_name, result.name.decode())
def test_update_name(self):
"""Testing method / function update_name."""
# Add an entry to the database
name = data.hashstring(str(random()))
# Make sure it does not exist
result = pair_xlate_group.exists(name)
self.assertFalse(bool(result))
# Add row to database
pair_xlate_group.insert_row(name)
# Make sure it exists
idx = pair_xlate_group.exists(name)
# Get current name
with db.db_query(20093) as session:
result = session.query(PairXlateGroup.name).filter(
PairXlateGroup.idx_pair_xlate_group == idx).one()
# Test
self.assertEqual(name, result.name.decode())
# Update the name
new_name = data.hashstring(str(random()))
pair_xlate_group.update_name(idx, new_name)
# Get current name
with db.db_query(20094) as session:
result = session.query(PairXlateGroup.name).filter(
PairXlateGroup.idx_pair_xlate_group == idx).one()
# Test
self.assertEqual(new_name, result.name.decode())
def test_assign(self):
"""Testing method / function assign."""
# Add an entry to the database
name = data.hashstring(str(random()))
pair_xlate_group.insert_row(name)
# Make sure it exists
idx_pair_xlate_group = pair_xlate_group.exists(name)
# Verify the index exists
result = pair_xlate_group.idx_exists(idx_pair_xlate_group)
self.assertTrue(result)
# Prepare for adding an entry to the database
agent_id = data.hashstring(str(random()))
agent_target = data.hashstring(str(random()))
agent_program = data.hashstring(str(random()))
# Make sure it does not exist
result = agent.exists(agent_id, agent_target)
self.assertFalse(bool(result))
# Add an entry to the database
agent.insert_row(agent_id, agent_target, agent_program)
idx_agent = agent.exists(agent_id, agent_target)
# Assign
agent.assign(idx_agent, idx_pair_xlate_group)
# Get assigned idx_pair_xlate_group for the agent group
with db.db_query(20099) as session:
result = session.query(Agent.idx_pair_xlate_group).filter(
Agent.idx_agent == idx_agent).one()
idx_new = result.idx_pair_xlate_group
self.assertEqual(idx_pair_xlate_group, idx_new)
def test_insert_row(self):
"""Testing method / function insert_row."""
# Add a language and pair_xlate_group entry to the database
code = data.hashstring(str(random()))
_translation = data.hashstring(str(random()))
language.insert_row(code, _translation)
idx_language = language.exists(code)
pair_xlate_group.insert_row(_translation)
idx_pair_xlate_group = pair_xlate_group.exists(_translation)
# Make sure row does not exist
translation = data.hashstring(str(random()))
key = data.hashstring(str(random()))
units = data.hashstring(str(random()))
result = pair_xlate.pair_xlate_exists(idx_pair_xlate_group,
idx_language, key)
self.assertFalse(result)
# Add an entry to the database
pair_xlate.insert_row(key, translation, units, idx_language,
idx_pair_xlate_group)
# Test
result = pair_xlate.pair_xlate_exists(idx_pair_xlate_group,
idx_language, key)
self.assertTrue(result)
def _insert_user():
"""Insert starting default entries into the User table.
Args:
None
Returns:
None
"""
# Insert into User
if user.idx_exists(1) is False:
password = ''.join(
random.SystemRandom().choice(string.ascii_uppercase +
string.digits) for _ in range(50))
user.insert_row(
DbRowUser(username='******',
password=data.hashstring(password),
first_name='pattoo',
last_name='pattoo',
user_type=1,
change_password=1,
enabled=0))
# Insert admin into User table
if user.idx_exists(2) is False:
password = '******'
user.insert_row(
DbRowUser(username='******',
password=data.hashstring(password),
first_name='admin',
last_name='admin',
user_type=0,
change_password=0,
enabled=1))
def test_idx_exists(self):
"""Testing method or function named "idx_exists"."""
# Add chart entry to database
chart_name = data.hashstring(str(random()))
chart_checksum = data.hashstring(str(random()))
chart.insert_row(
DbRowChart(name=chart_name, checksum=chart_checksum, enabled=0))
# Make sure chart entry exists
idx_chart = chart.exists(chart_checksum)
self.assertTrue(bool(idx_chart))
# Create idx datapoint
idx_datapoint = _idx_datapoint()
# Add chart datapoint entry to database
chart_datapoint.insert_row(
DbRowChartDataPoint(idx_datapoint=idx_datapoint,
idx_chart=idx_chart,
enabled=0))
# Make sure the chart datapoint exists
idx_chart_datapoint = chart_datapoint.exists(idx_chart, idx_datapoint)
# Verify that the index exists
result = chart_datapoint.idx_exists(idx_chart_datapoint)
self.assertTrue(result)
def test_exists(self):
"""Testing method or function named "exists"."""
# Add chart entry to database
chart_name = data.hashstring(str(random()))
chart_checksum = data.hashstring(str(random()))
chart.insert_row(
DbRowChart(name=chart_name, checksum=chart_checksum, enabled=0))
# Make sure chart entry exists
idx_chart = chart.exists(chart_checksum)
# Create idx datapoint
idx_datapoint = _idx_datapoint()
# Subtest to make sure chart datapoint does not exist
with self.subTest():
result = chart_datapoint.exists(idx_chart, idx_datapoint)
self.assertFalse(bool(result))
# Add chart datapoint entry to database
chart_datapoint.insert_row(
DbRowChartDataPoint(idx_datapoint=idx_datapoint,
idx_chart=idx_chart,
enabled=0))
# Make sure the chart datapoint exists
result = chart_datapoint.exists(idx_chart, idx_datapoint)
self.assertTrue(bool(result))
def test_assign(self):
"""Testing method / function assign."""
# Create a new PairXlateGroup entry
name = data.hashstring(str(random()))
pair_xlate_group.insert_row(name)
idx_pair_xlate_group = pair_xlate_group.exists(name)
# Add an entry to the database
name = data.hashstring(str(random()))
agent_group.insert_row(name)
# Make sure it exists
idx_agent_group = agent_group.exists(name)
# Get current idx_pair_xlate_group for the agent group
with db.db_query(20095) as session:
result = session.query(AgentGroup.idx_pair_xlate_group).filter(
AgentGroup.idx_agent_group == idx_agent_group).one()
idx_original = result.idx_pair_xlate_group
self.assertNotEqual(idx_pair_xlate_group, idx_original)
# Assign
agent_group.assign(idx_agent_group, idx_pair_xlate_group)
# Get current idx_pair_xlate_group for the agent group
with db.db_query(20098) as session:
result = session.query(AgentGroup.idx_pair_xlate_group).filter(
AgentGroup.idx_agent_group == idx_agent_group).one()
idx_new = result.idx_pair_xlate_group
self.assertEqual(idx_pair_xlate_group, idx_new)
def test_exists(self):
"""Testing method or function named "exists"."""
# Create a translation
uname = data.hashstring(str(random()))
passwrd = data.hashstring(str(random()))
f_name = data.hashstring(str(random()))
l_name = data.hashstring(str(random()))
# Make sure it does not exist
result = user.exists(uname)
self.assertFalse(bool(result))
# Add database row
user.insert_row(
DbRowUser(
username=uname,
password=passwrd,
first_name=f_name,
last_name=l_name,
role=1,
password_expired=0,
enabled=0
)
)
# Make sure it exists
result = user.exists(uname)
self.assertTrue(bool(result))
def test_idx_exists(self):
"""Testing method or function named "idx_exists"."""
# Add entry to database
uname = data.hashstring(str(random()))
passwrd = data.hashstring(str(random()))
f_name = data.hashstring(str(random()))
l_name = data.hashstring(str(random()))
user.insert_row(
DbRowUser(
username=uname,
password=passwrd,
first_name=f_name,
last_name=l_name,
role=1,
password_expired=1,
enabled=0
)
)
# Make sure it exists
idx_user = user.exists(uname)
# Verify that the index exists
result = user.idx_exists(idx_user)
self.assertTrue(result)
def test_chart_timestamp_args(self):
"""Testing function chart_timestamp_args."""
# Create a new Agent entry
_pi = 1000
agent_id = data.hashstring(str(random()))
agent_target = data.hashstring(str(random()))
agent_program = data.hashstring(str(random()))
agent.insert_row(agent_id, agent_target, agent_program)
idx_agent = agent.exists(agent_id, agent_target)
# Create entry and check
checksum = data.hashstring(str(random()))
result = datapoint.checksum_exists(checksum)
self.assertFalse(result)
datapoint.insert_row(checksum, DATA_FLOAT, _pi, idx_agent)
idx_datapoint = datapoint.checksum_exists(checksum)
# Test
values = [False, None]
for value in values:
now = normalized_timestamp(_pi, int(time.time() * 1000))
result = uri.chart_timestamp_args(idx_datapoint, value)
self.assertEqual(result + 604800000, now)
values = [-1, -6011, 1, 6011]
for value in values:
now = normalized_timestamp(_pi, int(time.time() * 1000))
result = uri.chart_timestamp_args(idx_datapoint, value)
self.assertEqual(result + (abs(value) * 1000), now)
values = ['foo', [None]]
for value in values:
now = normalized_timestamp(_pi, int(time.time() * 1000))
result = uri.chart_timestamp_args(idx_datapoint, value)
self.assertEqual(result + 604800000, now)
def test_exists(self):
"""Testing method / function exists."""
# Add an entry to the database
code = data.hashstring(str(random()))
name = data.hashstring(str(random()))
language.insert_row(code, name)
# Make sure it exists
result = language.exists(code)
self.assertTrue(bool(result))
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_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_insert_rows(self):
"""Testing method / function insert_rows."""
# Initialize key variables
key = data.hashstring(str(random()))
value = data.hashstring(str(random()))
result = pair.pair_exists(key, value)
self.assertFalse(result)
# Create entry and check
pair.insert_rows((key, value))
result = pair.pair_exists(key, value)
self.assertTrue(bool(result))
self.assertTrue(isinstance(result, int))
def test_insert_row(self):
"""Testing method / function insert_row."""
# Add an entry to the database
code = data.hashstring(str(random()))
name = data.hashstring(str(random()))
language.insert_row(code, name)
# Make sure it exists
idx_language = language.exists(code)
# Verify the index exists
result = language.idx_exists(idx_language)
self.assertTrue(result)
def test_insert_row(self):
"""Testing method / function insert_row."""
# Add an entry to the database
agent_id = data.hashstring(str(random()))
agent_target = data.hashstring(str(random()))
agent_program = data.hashstring(str(random()))
agent.insert_row(agent_id, agent_target, agent_program)
# Make sure it exists
idx_agent = agent.exists(agent_id, agent_target)
# Verify the index exists
result = agent.idx_exists(idx_agent)
self.assertTrue(result)
def test_insert_row(self):
"""Testing method or function named insert_row."""
# Add an entry to the database
chart_name = data.hashstring(str(random()))
chart_checksum = data.hashstring(str(random()))
chart.insert_row(
DbRowChart(name=chart_name, checksum=chart_checksum, enabled=0))
# Make sure it exists
idx_chart = chart.exists(chart_checksum)
# Verify the index exists
result = chart.idx_exists(idx_chart)
self.assertTrue(result)
def _insert_user():
"""Insert starting default entries into the User table.
Args:
None
Returns:
default_users: dictionary containing the default user credentials
"""
default_users = []
# Insert into User
if user.idx_exists(1) is False:
# Creating initial password
password = data.hashstring(''.join(random.SystemRandom().choice(
string.ascii_uppercase + string.digits) for _ in range(50)))
# Inserting default user
user.insert_row(
DbRowUser(
username='******',
password=password,
first_name='pattoo',
last_name='pattoo',
role=1,
password_expired=1,
enabled=0)
)
default_users.append(('pattoo', password, 1))
# Insert admin into User table
if user.idx_exists(2) is False:
# Creating initial password
password = data.hashstring(''.join(random.SystemRandom().choice(
string.ascii_uppercase + string.digits) for _ in range(50)))
user.insert_row(
DbRowUser(
username='******',
password=password,
first_name='admin',
last_name='admin',
role=0,
password_expired=1,
enabled=1)
)
default_users.append(('admin', password, 0))
return default_users
def test_main(self):
"""Testing method / function main."""
#
# NOTE!
#
# This test is to verify that multiprocessing is supported without
# hanging. We don't want database hanging if there is a large load of
# connections to the database. This is a very important test. It MUST
# pass for pattoo to be reliable.
# Initialize key variables
loops = 10
process_count = 100
timeout = 600
code = data.hashstring(str(random()))
names = [data.hashstring(str(random())) for _ in range(loops)]
Arguments = namedtuple('Arguments', 'loops process_count code names')
# Add an entry to the database
language.insert_row(code, names[0])
# Make sure it exists
idx_language = language.exists(code)
# Verify the index exists
result = language.idx_exists(idx_language)
self.assertTrue(result)
# Create arguments
arguments = Arguments(code=code,
loops=loops,
names=names,
process_count=process_count)
# Spawn a single process with a timeout
process = multiprocessing.Process(target=run_, args=(arguments, ))
process.start()
process.join(timeout)
# Test if timing out
if process.is_alive():
# Multiprocessing is failing if this times out. I could be due to
# the loops taking too long (unlikely, but should be checked), or
# it could be a general failure in the database engine code in
# pattoo.db.__init__.py.
print('''\
Test for multiprocessing database update is hanging. Please check possible \
causes.''')
sys.exit(2)
def test_update(self):
"""Testing method / function update."""
# Add a language and pair_xlate_group entry to the database
code = data.hashstring(str(random()))
_translation = data.hashstring(str(random()))
language.insert_row(code, _translation)
idx_language = language.exists(code)
pair_xlate_group.insert_row(_translation)
idx_pair_xlate_group = pair_xlate_group.exists(_translation)
# Create data
_data = []
for key in range(0, 10):
_data.append(
[code, str(key), '_{}_'.format(key), '0{}0'.format(key)])
_df0 = pd.DataFrame(
_data, columns=['language', 'key', 'translation', 'units'])
pair_xlate.update(_df0, idx_pair_xlate_group)
# Update data
_data = []
for key in range(0, 10):
_data.append(
[code, str(key), '|{}|'.format(key), '1{}1'.format(key)])
_df = pd.DataFrame(_data,
columns=['language', 'key', 'translation', 'units'])
pair_xlate.update(_df, idx_pair_xlate_group)
# Test updated data
for key in range(0, 10):
with db.db_query(20125) as session:
row = session.query(PairXlate).filter(
and_(
PairXlate.idx_pair_xlate_group == idx_pair_xlate_group,
PairXlate.key == str(key).encode(),
PairXlate.idx_language == idx_language)).one()
self.assertEqual(row.translation.decode(), _df['translation'][key])
self.assertEqual(row.units.decode(), _df['units'][key])
# Old translations should not exist
for translation in _df0['translation']:
with db.db_query(20126) as session:
row = session.query(PairXlate).filter(
and_(
PairXlate.idx_pair_xlate_group == idx_pair_xlate_group,
PairXlate.translation == translation.encode(),
PairXlate.idx_language == idx_language))
self.assertEqual(row.count(), 0)
def add(self, items):
"""Add DataPointMetadata to the internal self.metadata list.
Args:
items: A DataPointMetadata object list
Returns:
None
"""
# Ensure there is a list of objects
if isinstance(items, list) is False:
items = [items]
# Only append approved data types
for item in items:
if isinstance(item, Metadata) is True:
# Ignore invalid values
if item.valid is False or item.key in DATAPOINT_KEYS:
continue
# Process
if item.key not in self._metakeys:
self.metadata[item.key] = item.value
self._metakeys.append(item.key)
if bool(item.update_checksum) is True:
self.checksum = data.hashstring('''\
{}{}{}'''.format(self.checksum, item.key, item.value))
def main():
"""Test all the pattoo modules with unittests.
Args:
None
Returns:
None
"""
# Set up parser
parser = argparse.ArgumentParser()
parser.add_argument(
'--username', '-u', help='Username to create',
type=str, default='*****@*****.**')
args = parser.parse_args()
# Determine whether user already exists
username = args.username
if bool(user.exists(username)) is False:
row = DbRowUser(
username=username,
password=data.hashstring(str(random())),
first_name='Pattoo: {}'.format(username),
last_name='Test: {}'.format(username),
enabled=True,
)
user.insert_row(row)
def test_install(self):
"""Unittest to test the install function."""
# Test with undefined requirements directory
with self.subTest():
with self.assertRaises(SystemExit) as cm_:
requirements_dir = data.hashstring(str(random()))
install(requirements_dir)
self.assertEqual(cm_.exception.code, 3)
# Test with default expected behaviour
with self.subTest():
# At least one expected package
expected_package = 'PattooShared'
expected = True
# Create temporary directory
with tempfile.TemporaryDirectory() as temp_dir:
result = install(ROOT_DIR, temp_dir)
# Get raw packages in requirements format
packages = shared.run_script('python3 -m pip freeze')[1]
# Get packages with versions removed
installed_packages = [package.decode().split('==')[
0] for package in packages.split()]
result = expected_package in installed_packages
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_cli_show_dump(self):
"""Testing method / function cli_show_dump."""
# Add an entry to the database
code = data.hashstring(str(random()))
name = data.hashstring(str(random()))
language.insert_row(code, name)
# Make sure it exists
idx_language = language.exists(code)
result = language.cli_show_dump()
for item in result:
if item.idx_language == idx_language:
self.assertEqual(item.name, name)
self.assertEqual(item.code, code)
break
