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