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)
