def test_high_doubled_transaction_constraint_fail(self):
self.account.logs.append({
"merchant": "Burger King",
"amount": 20,
"time": "2019-09-09T15:52:00.000Z"
})
self.account.logs.append({
"merchant": "Burger King",
"amount": 20,
"time": "2019-09-09T15:53:00.000Z"
})
base_time = datetime.strptime('2019-09-09T15:54:00.000Z',
"%Y-%m-%dT%H:%M:%S.%fZ")
validator = Validator(DoubledTransaction(base_time))
event = {
"transaction": {
"merchant": "Burger King",
"amount": 20,
"time": "2019-09-09T15:54:00.000Z"
}
}
violations = validator.validate(self.account, event)
self.assertEqual(violations, ['doubled_transaction'])
def test_create_account_constraint_fail(self):
validator = Validator(CreateAccount())
event = {"account": {"activeCard": "true", "availableLimit": 100}}
violations = validator.validate(self.account, event)
self.assertEqual(violations, ['account-already-initialized'])
def test_empty_validator_pass(self):
account = Account()
validator = Validator()
violations = validator.validate(account, {})
self.assertEqual(violations, [])
def test_high_frequency_small_interval_constraint_fail(self):
self.account.logs.append({
"merchant": "Burger King",
"amount": 20,
"time": "2019-09-09T15:52:00.000Z"
})
self.account.logs.append({
"merchant": "Burger King",
"amount": 20,
"time": "2019-09-09T15:52:30.000Z"
})
self.account.logs.append({
"merchant": "Burger King",
"amount": 20,
"time": "2019-09-09T15:53:30.000Z"
})
base_time = datetime.strptime('2019-09-09T15:54:00.000Z',
"%Y-%m-%dT%H:%M:%S.%fZ")
validator = Validator(HighFrequencySmallInterval(base_time))
event = {
"transaction": {
"merchant": "Burger King",
"amount": 20,
"time": "2019-09-09T15:54:00.000Z"
}
}
violations = validator.validate(self.account, event)
self.assertEqual(violations, ['high_frequency_small_interval'])
def test_create_account_constraint_pass(self):
account = Account()
validator = Validator(CreateAccount())
event = {"account": {"activeCard": "true", "availableLimit": 100}}
violations = validator.validate(account, event)
self.assertEqual(violations, [])
def _validate_vodml_block(self):
base_path = os.path.dirname(os.path.realpath(__file__))
validator = Validator(
os.path.join(base_path, "../../schema/", "vodml_lite.xsd"))
validator.validate_string(self.vodml_block)
logger.info("VODML block is valid")
self.json_block = xmltodict.parse(self.vodml_block)
def test_basic_checks(self):
validator = Validator("test")
validator.json_data = {"data_resource": "test", "pdb_id": "1abc"}
self.assertTrue(validator.basic_checks())
validator.json_data = {"data_resource": "test"}
self.assertFalse(validator.basic_checks())
validator.json_data = {"pdb_id": "1abc"}
self.assertFalse(validator.basic_checks())
def test_json_validation(self):
validator = Validator("ProKinO")
validator.load_json("data/test_data.json")
validator.load_schema("data/funpdbe_schema.json")
validation = validator.validate_against_schema()
self.assertTrue(validation)
validator.load_json("data/test_data_invalid.json")
validation = validator.validate_against_schema()
self.assertFalse(validation)
def test_accountmanager_create_account_wrong_parameters(self):
event = {"accountt": {"activeCardd": "falsee", "availableLimitt": 100}}
self.accountmanager.events(event).validations(
Validator(self.constraints))
self.assertEqual(
self.accountmanager.process(), {
'account': {
'activeCard': False,
'availableLimit': 0
},
'violations': []
})
def test_accountmanager_create_account_no_active_card_pass(self):
event = {"account": {"activeCard": False, "availableLimit": 100}}
self.accountmanager.events(event).validations(
Validator(self.constraints))
self.assertEqual(
self.accountmanager.process(), {
'account': {
'activeCard': False,
'availableLimit': 100
},
'violations': []
})
def test_active_card_constraint_pass(self):
validator = Validator(ActiveCard())
event = {
"transaction": {
"merchant": "Burger King",
"amount": 20,
"time": "2019-09-09T15:52:00.000Z"
}
}
violations = validator.validate(self.account, event)
self.assertEqual(violations, [])
def test_insufficient_limit_constraint_fail(self):
validator = Validator(InsufficientLimit())
event = {
"transaction": {
"merchant": "Burger King",
"amount": 101,
"time": "2019-09-09T15:52:00.000Z"
}
}
violations = validator.validate(self.account, event)
self.assertEqual(violations, ['insufficient_limit'])
def test_accountmanager_transaction_pass(self):
event = {"account": {"activeCard": True, "availableLimit": 100}}
self.accountmanager.events(event).validations(
Validator(self.constraints))
self.accountmanager.process()
event = {
"transaction": {
"merchant": "Burger King",
"amount": 10,
"time": "2019-09-09T15:52:00.000Z"
}
}
self.accountmanager.events(event).validations(
Validator(self.constraints))
self.assertEqual(
self.accountmanager.process(), {
'account': {
'activeCard': True,
'availableLimit': 90
},
'violations': []
})
def test_accountmanager_create_account_fail(self):
self.account.created = True
self.account.active_card = True
self.account.available_limit = 100
event = {"account": {"activeCard": True, "availableLimit": 100}}
self.accountmanager.events(event).validations(
Validator(self.constraints))
self.assertEqual(
self.accountmanager.process(), {
'account': {
'activeCard': True,
'availableLimit': 100
},
'violations': ['account-already-initialized']
})
def validate(
zone_infos: ZoneInfoMap,
zone_policies: ZonePolicyMap,
zone: str,
year: int,
start_year: int,
until_year: int,
validate_buffer_size: bool,
validate_test_data: bool,
viewing_months: int,
validate_dst_offset: bool,
debug_validator: bool,
debug_specifier: bool,
in_place_transitions: bool,
optimize_candidates: bool,
) -> None:
# Set the default to set both --validate_buffer_size and
# --validate_test_data if neither flags are given explicitly.
if not validate_buffer_size and not validate_test_data:
validate_buffer_size = True
validate_test_data = True
validator = Validator(zone_infos=zone_infos,
zone_policies=zone_policies,
viewing_months=viewing_months,
validate_dst_offset=validate_dst_offset,
debug_validator=debug_validator,
debug_specifier=debug_specifier,
zone_name=zone,
year=year,
start_year=start_year,
until_year=until_year,
in_place_transitions=in_place_transitions,
optimize_candidates=optimize_candidates)
if validate_buffer_size:
logging.info('======== Validating transition buffer sizes')
validator.validate_buffer_size()
if validate_test_data:
logging.info('======== Validating test data')
validator.validate_test_data()
def main():
accountmanager = AccountManager()
constraints = Constraint()
constraints \
.set_next(CreateAccount()) \
.set_next(ActiveCard()) \
.set_next(InsufficientLimit()) \
.set_next(HighFrequencySmallInterval()) \
.set_next(DoubledTransaction()) \
validator = Validator(constraints)
for line in fileinput.input():
event = json.loads(line)
accountmanager.events(event).validations(validator)
result = accountmanager.process()
print(json.dumps(result))
def test_resource_name_mismatch(self):
validator = Validator("test")
validator.json_data = {"data_resource": "test2", "pdb_id": "1abc"}
self.assertFalse(validator._test_resource())
def test_no_resource_name(self):
validator = Validator("test")
validator.json_data = {"pdb_id": "1abc"}
self.assertFalse(validator._test_resource())
def test_json_parser(self):
validator = Validator("resource_name")
data = validator._parse_json("data/test_data.json")
self.assertIsNotNone(data)
validator._parse_json("data/test_data_malformed.json")
self.assertIn("JSON error", validator.error_log)
def test_no_file_at_path(self):
validator = Validator("resource_name")
validator._parse_json("invalid_path")
self.assertIn("File error", validator.error_log)
def __init__(self):
self.bd = BDEngine(projsettings.DBNAME, projsettings.DB_USER,
projsettings.DB_PASSWORD, projsettings.DB_HOST)
self.formatter = Formatter()
self.validator = Validator()
def __init__(self):
self.url_manager = UrlManager()
self.html_downloader = HtmlDownloader()
self.html_parser = HtmlParser()
self.validator = Validator()
self.sqlite_handle = SqliteHandle()
def setUp(self):
self.validator = Validator()
import os
import sys
import traceback
import json
import xmltodict
from validator.validator import Validator
base_path = os.path.dirname(os.path.realpath(__file__))
validator = Validator(os.path.join(base_path
, "../../schema/"
, "vodml_lite.xsd"))
# Open a file
sample_path = os.path.join(base_path
, "../../mapping_sample")
dirs = os.listdir( sample_path )
# This would print all the files and directories
for file in dirs:
if not file.endswith(".xml"):
continue
sample_file = os.path.join(sample_path, file)
try:
validator.validate_file(sample_file)
print(file + ' is Valid')
with open(sample_file, 'r') as f:
def test_invalid_pdb_id(self):
validator = Validator("test")
validator.json_data = {"data_resource": "test", "pdb_id": "invalid"}
self.assertFalse(validator._test_pdb_id())
def __init__(self):
self.__validator = Validator()
def validations(self, validator=Validator()):
self.validator = validator
return self
