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_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_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_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_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_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_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_validate_row(self):
# given
record = Record('test|test2', {'size': 2})
expected_calls = [call(field, record) for field in record.get_fields()]
validator = Validator()
validator.validate_field = MagicMock(return_value=True)
# when
result = validator.validate_record(record)
# then
self.assertTrue(result)
validator.validate_field.assert_has_calls(expected_calls)
self.assertEqual(validator.validate_field.call_count, 2)
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())
class SpiderMan(object):
def __init__(self):
self.url_manager = UrlManager()
self.html_downloader = HtmlDownloader()
self.html_parser = HtmlParser()
self.validator = Validator()
self.sqlite_handle = SqliteHandle()
def crawl(self, root_url):
self.url_manager.add_new_url(root_url)
while self.url_manager.has_new_url(
) and self.url_manager.old_url_size() < 100:
try:
new_url = self.url_manager.get_new_url()
html_cont = self.html_downloader.download(new_url)
proxy_list = self.html_parser.parser(html_cont)
valid_proxy_list = self.validator.check_proxy(proxy_list)
total_count = len(proxy_list)
valid_count = len(valid_proxy_list)
valid_rate = float(valid_count) / float(total_count) * 100
logger.info(
'total_count:%s, valid_count:%s, valid_rate:%.2f%%' %
(str(total_count), str(valid_count), valid_rate))
self.sqlite_handle.insert_data(valid_proxy_list)
logger.info('Crawl→Download→Parse→Validate→Save: successfully')
except Exception as e:
logger.warn('Crawl→Download→Parse→Validate→Save: failed')
logger.error(e)
def test_validator(self):
validator = Validator.get_instance()
customer = Individual()
customer.set_cnp("198121203415")
customer.set_last_name("Dan")
customer.set_first_name("Popescu")
customer.set_phone_number("0756234876")
customer.set_email_address("*****@*****.**")
item = Item()
currency = Currency("$", "dollar", "USD")
item.set_name("Apple")
item.set_price(2)
item.set_discount(0)
item.set_currency(currency)
company = Company()
company.set_company_name("La Gigi")
company.set_fiscal_no("RO0123")
company.set_registration_number("123456")
company.set_email_address("*****@*****.**")
company.set_first_name("Ion")
company.set_last_name("Bogdan")
company.set_phone_number("0752314567")
company.set_fiscal_no("0000012345678")
company.set_registration_number("RO01923")
bill = Bill()
bill.set_currency(currency)
bill.set_customer(customer)
bill.set_issuer(company)
bill.set_issue_date("21.12.2020")
bill.set_due_date("21.02.2021")
bill.add_items(item)
validator.validate_bill(bill)
class MessageHandler:
""" While there are messages from the shared messagequeue route the messages to the correct functions
Read messages from the message queue and pass them to the validator.
"""
def __init__(self):
self.__validator = Validator()
def process_messages(self):
while True:
msg = MessageQueue.get_message()
if msg is None:
logger.debug("No more messages, thread ends")
return
self.__validator.validate(msg)
def main(data_file='examples/flat_data.dat', config_file='examples/config.json'):
configuration = {}
try:
configuration = load_configuration(config_file)
except IOError:
logging.error("Cannot open file: %s" % config_file)
exit()
data = []
try:
data = load_data_file(data_file)
except IOError:
logging.error("Cannot open file: %s" % data_file)
exit()
data_object = Data(data, configuration)
validator = Validator()
validator.validate_data(data_object)
def __init__(self, currency_file, item_file, customer_file, bill_file):
self.__currency_service = CurrencyService(
JsonCurrencyRepo(currency_file))
self.__item_service = ItemService(JsonItemRepo(item_file))
self.__customer_service = CustomerService(
JsonCustomerRepo(customer_file, Individual),
JsonCustomerRepo(customer_file, Company))
self.__bill_service = BillService(JsonBillRepo(bill_file, Invoice),
JsonBillRepo(bill_file, FiscalBill))
self.__validator = Validator.get_instance()
def test_validate_data(self):
# given
def return_value(data):
if data.get_fields()[0].get_value() == 'test':
return False
else:
return True
validator = Validator()
validator.validate_record = MagicMock(side_effect=return_value)
data = Data(['test', 'test2'])
expected_calls = [call(record) for record in data.get_records()]
# when
result = validator.validate_data(data)
# then
self.assertFalse(result)
validator.validate_record.assert_has_calls(expected_calls)
self.assertEqual(validator.validate_record.call_count, 2)
class TestValidator(unittest.TestCase):
def setUp(self):
self.validator = Validator()
def test_validate_time_validate_inset(self):
time = "23:00"
self.assertTrue(self.validator.validate_time(time))
def test_validate_time_validate_outset_hour(self):
time = "24:00"
self.assertFalse(self.validator.validate_time(time))
def test_validate_time_validate_outset_min(self):
time = "22:60"
self.assertFalse(self.validator.validate_time(time))
def test_validate_time_validate_invalid_min(self):
time = "21:1M"
self.assertFalse(self.validator.validate_time(time))
def test_validate_time_validate_invalid_hour(self):
time = "2M:11"
self.assertFalse(self.validator.validate_time(time))
def test_validate_time_validate_invalid(self):
time = "21:21:A"
self.assertFalse(self.validator.validate_time(time))
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_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_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 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 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 test_invalid_pdb_id(self):
validator = Validator("test")
validator.json_data = {"data_resource": "test", "pdb_id": "invalid"}
self.assertFalse(validator._test_pdb_id())
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 setUp(self):
self.validator = Validator()
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()
class Model(object):
def __init__(self):
self.bd = BDEngine(projsettings.DBNAME, projsettings.DB_USER,
projsettings.DB_PASSWORD, projsettings.DB_HOST)
self.formatter = Formatter()
self.validator = Validator()
def get_scheduler_between(self, station_from, station_to):
shed = self.bd.get_scheduler(station_from, station_to)
return shed
def get_search_result(self,
station_from,
station_to,
time=None,
select=None):
station_from = station_from.replace(" ", "")
station_to = station_to.replace(" ", "")
time = time.replace(" ", "")
if time == "None":
time = None
is_valid = self.validator.validate_data_from_search(
station_from, station_to, time, select)
if not is_valid:
return None, None
if time is not None:
time = time.split(":")
time = datetime.time(int(time[0]), int(time[1]))
results = self.bd.get_scheduler(station_from, station_to, time)
if results is None:
return [], None
results = self.formatter.trainlist_time_intervals(results, select)
result = self.formatter.get_data_for_trainlist_template(results)
select = self.formatter.get_data_for_trainlist_template_select(select)
return result, select
def get_train_info(self, number, departure_station):
is_valid = self.validator.validate_param_from_traininfo(
number, departure_station)
if not is_valid:
return None, None
result = self.bd.get_info_from_train_number2(str(number),
departure_station)
if result is None:
return None, None
station_list = result[1]
for i in range(len(station_list)):
station_list[i] = self.bd.get_station_from_id(station_list[i])
train_list, title = self.formatter.get_data_for_train_template(result)
return train_list, title
def get_nearest_station(self, geo, R=5):
is_valid = self.validator.validate_param_from_location(geo[0], geo[1])
if not is_valid:
return None, None
YandexStation = YandexNearestLocations(geo[0], geo[1],
projsettings.YA_API_KEY, R)
list_stations = YandexStation.run()
response = None
img = None
if len(list_stations) > 0:
response = list_stations
map = YandexMapShot(geo[0], geo[1], list_stations)
img = map.run()
return response, img
def write_map_img(self, img):
fname = str(hash(img)) + ".png"
path = "static/img/%s" % fname
with open(path, "wb") as f:
f.write(img)
return path
def get_map_info(self, lat, lon):
geo = (float(lat), float(lon))
stationlist, img = self.get_nearest_station(geo)
img_path = self.write_map_img(img)
stationlist = self.formatter.get_data_for_table_map(stationlist)
return stationlist, img_path
def auth_user(self, login, password):
print(threading.get_ident())
is_valid = self.validator.validate_login_pass(login)
if not is_valid:
return None
usr_psw = self.bd.get_user(login)
if len(usr_psw) != 1:
return False, None
usr_psw = usr_psw[0]
if password == usr_psw[2]:
return True, usr_psw[0]
else:
return False, None
def get_times(self, line, start_station, stop_station, index_st=0, step=1):
n = len(line)
for train_i in range(index_st, n, step):
train = line[train_i]
m = len(train[2])
time_start = train[3][0]
for station_i in range(m):
if train[2][station_i] == start_station:
time_start = train[3][station_i]
line[train_i].append(time_start)
elif train[2][station_i] == stop_station:
train1 = self.__diff_times_in_seconds(
time_start, train[3][station_i], True)
line[train_i].append(train1)
line[train_i].append(train[3][station_i])
break
return None
def start_thr(self, line, start_station, stop_station, count, rr=None):
pool = []
if rr is None:
rr = [0] * count
for i in range(count):
thr = threading.Thread(target=self.get_times,
args=(line, start_station, stop_station, i,
count))
time.sleep(rr[i])
thr.start()
pool.append(thr)
for i in range(count):
pool[i].join()
def __diff_times_in_seconds(self, t1, t2, mod=False):
h1, m1, s1 = t1.hour, t1.minute, t1.second
h2, m2, s2 = t2.hour, t2.minute, t2.second
t1_secs = s1 + 60 * (m1 + 60 * h1)
t2_secs = s2 + 60 * (m2 + 60 * h2)
res = (t2_secs - t1_secs)
if mod and res < 0:
res += 86400
return res
def route_time(self, station1, station2, count, node=None):
first_line = self.bd.get_scheduler(station1, node)
second_line = self.bd.get_scheduler(node, station2)
min_time = 86400
result = None
for train1 in first_line:
for train2 in second_line:
wait_time = self.__diff_times_in_seconds(
train1[-1], train2[-3])
if wait_time < 480:
continue
time = train1[-2] + train2[-2] + wait_time
if min_time > time:
min_time = time
result = (train1, train2)
result = list(result)
result.append(min_time)
return result
def __init__(self):
self.url_manager = UrlManager()
self.html_downloader = HtmlDownloader()
self.html_parser = HtmlParser()
self.validator = Validator()
self.sqlite_handle = SqliteHandle()
