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()