def test_get_table_row_count(self, database_populated): """ Starts with an populated database with 5 redirect rules. Test the get_table_row_count() function. Expected behaviour: 1. Counts the entries in a table in the DB correctly 2. When one is deleted the count should decrease """ # Get session from redirectory.libs_int.database import DatabaseManager db_session = DatabaseManager().get_session() # Import needed functions and classes from redirectory.libs_int.database import db_get_table_row_count from redirectory.models import RedirectRule, PathRule # Check count = db_get_table_row_count(db_session, RedirectRule) assert count == 5 instance: RedirectRule = db_session.query(RedirectRule).get(1) instance.delete(db_session) count = db_get_table_row_count(db_session, RedirectRule) assert count == 4 count = db_get_table_row_count(db_session, PathRule) assert count == 4 # Return session DatabaseManager().return_session(db_session)
def test_delete_ambiguous_request(self, database_ambiguous): """ Starts with an populated database with 5 ambiguous request entries Test the delete_ambiguous_request() function. Expected behaviour: 1. Deletes an existing entry amd returns True 2. Tries to delete a non existent entry and returns False """ # Get session from redirectory.libs_int.database import DatabaseManager db_session = DatabaseManager().get_session() # Import needed functions and classes from redirectory.libs_int.database import delete_ambiguous_request, db_get_table_row_count from redirectory.models import AmbiguousRequest # Check result = delete_ambiguous_request(db_session, 1) count = db_get_table_row_count(db_session, AmbiguousRequest) assert result assert count == 4 result = delete_ambiguous_request(db_session, 1001) assert result is False result = delete_ambiguous_request(db_session, 2) count = db_get_table_row_count(db_session, AmbiguousRequest) assert result assert count == 3 # Return session DatabaseManager().return_session(db_session)
def test_delete_redirect_rule(self, database_populated): """ Starts with a populated database with 5 Redirect Rule entries Test the delete_redirect_rule() function. Expected behaviour: 1. Deletes a rule correctly 2. If a rule does not exist it should return False """ # Get session from redirectory.libs_int.database import DatabaseManager db_session = DatabaseManager().get_session() # Import needed functions and classes from redirectory.libs_int.database import delete_redirect_rule, db_get_table_row_count from redirectory.models import RedirectRule # Check deletion result = delete_redirect_rule(db_session, 1) assert result count = db_get_table_row_count(db_session, RedirectRule) assert count == 4 # Check deletion of non existent result = delete_redirect_rule(db_session, 1001) assert result is False # Return session DatabaseManager().return_session(db_session)
def get(self): db_session = DatabaseManager().get_session() sync = Synchronizer() # Check if sqlite DB is empty. redirect_rule_table_row_count = db_get_table_row_count( db_session, RedirectRule) DatabaseManager().return_session(db_session) if redirect_rule_table_row_count == 0: return api_error( message="Unable to compile new Hyperscan database", errors= f"Can't compile new Hyperscan database from no Redirect rules stored in the SQL database", status_code=400) compiler = CompilerJob(sync.util_new_hs_db_version_callback_test) compile_thread = Thread(target=compiler.run) compile_thread.start() # Metrics metric_update_rules_total() return make_response( jsonify({ "message": "New hyperscan DB are compiled for testing", "status": "done" }), 200)
def test_list_ambiguous_requests(self, database_ambiguous): """ Starts with an populated database with 5 ambiguous request entries Test the list_ambiguous_requests() function. Expected behaviour: 1. Returns a list of all the entries in the Ambiguous request table """ # Get session from redirectory.libs_int.database import DatabaseManager db_session = DatabaseManager().get_session() # Import needed functions and classes from redirectory.libs_int.database import list_ambiguous_requests, db_get_table_row_count from redirectory.models import AmbiguousRequest # Base for comparison original_count = db_get_table_row_count(db_session, AmbiguousRequest) # Check result = list_ambiguous_requests(db_session) assert isinstance(result, list) assert len(result) == original_count # Return session DatabaseManager().return_session(db_session)
def update_rules_total(): """ This function updates the RULES_TOTAL metric every time it is called with a count from the DB """ from redirectory.libs_int.database import db_get_table_row_count, DatabaseManager from redirectory.models import RedirectRule # Get count from DB db_session = DatabaseManager().get_session() new_count = db_get_table_row_count(db_session, RedirectRule) DatabaseManager().return_session(db_session) # Set count to metric RULES_TOTAL.set(new_count)
def test_add_ambiguous_request(self, database_empty): """ Starts with an empty database. Test the add_ambiguous_request() function. Expected behaviour: 1. Adds a new entry if non existent already 2. Returns None if entry already exists """ # Get session from redirectory.libs_int.database import DatabaseManager db_session = DatabaseManager().get_session() # Import needed functions and classes from redirectory.libs_int.database import add_ambiguous_request, db_get_table_row_count from redirectory.models import AmbiguousRequest # Check new_entry = add_ambiguous_request(db_session, 'https://www.test.com') assert new_entry is not None assert new_entry.id == 1 assert new_entry.request == 'https://www.test.com' new_entry = add_ambiguous_request(db_session, 'https://www.test.com') assert new_entry is None # Already exists new_entry = add_ambiguous_request(db_session, 'https://www.example.com') assert new_entry is not None assert new_entry.id == 2 assert new_entry.request == 'https://www.example.com' count = db_get_table_row_count(db_session, AmbiguousRequest) assert count == 2 # We added 2 ambiguous request # Return session DatabaseManager().return_session(db_session)
def test_add_redirect_rule(self, database_empty): """ Starts with an empty database. Test the add_redirect_rule() function. Expected behaviour: 1. Adds a redirect rule correctly 2. Checks if a rule already exists 3. Does not create new paths for new rules if they are already used in other rules """ # Get session from redirectory.libs_int.database import DatabaseManager db_session = DatabaseManager().get_session() # Import needed functions and classes from redirectory.libs_int.database import add_redirect_rule, db_get_table_row_count from redirectory.models import RedirectRule, DomainRule, PathRule, DestinationRule # Add a two rules rule_1: RedirectRule = add_redirect_rule(db_session, 'kumina.nl', False, '/test/path', False, 'https://new.kumina.nl', False, 100) rule_2: RedirectRule = add_redirect_rule(db_session, 'ivaylo.bg', False, '/test', False, 'https://new.kumina.nl', False, 100) rule_3: RedirectRule = add_redirect_rule(db_session, 'arenabg.com', False, '/test', False, 'https://new.kumina.nl', False, 100) # Check domain_count = db_get_table_row_count(db_session, DomainRule) path_count = db_get_table_row_count(db_session, PathRule) destination_count = db_get_table_row_count(db_session, DestinationRule) assert domain_count == 3 assert path_count == 2 assert destination_count == 1 assert rule_1.id == 1 and rule_2.id == 2 and rule_3.id == 3 assert rule_1.path_rule.id == 1 assert rule_3.path_rule.id == 2 # Check already existing rule_same = add_redirect_rule(db_session, 'ivaylo.bg', False, '/test', False, 'https://new.kumina.nl', False, 100) assert isinstance(rule_same, int) assert rule_same == 2 # Check rewrite validation rule_same = add_redirect_rule(db_session, 'ivaylo.bg', False, '/test(?P<asd>.*)', True, 'https://new.kumina.nl{asda}', True, 100) assert isinstance(rule_same, int) assert rule_same == 1 rule_same = add_redirect_rule(db_session, 'ivaylo.bg', False, '/test(?asd>.*[?])', True, 'https://new.kumina.nl{asda}', True, 100) assert isinstance(rule_same, int) assert rule_same == 1 # Return session DatabaseManager().return_session(db_session)