def person(locale=None): if locale is None: locales = _MIMESIS_LOCALES else: locales = [locale] p = mimesis.Person(locale=choice(locales)) gender = choice(['Male'] * 20 + ['Female'] * 21 + ['Other']) g = mimesis.enums.Gender.MALE if gender.lower( ) == 'male' else mimesis.enums.Gender.FEMALE first = p.name(g) last = p.last_name(g) return { 'first_name': first, 'last_name': last, 'name': first + ' ' + last, # western 'age': p.age(), 'gender': gender, 'id': p.identifier(), 'occupation': p.occupation(), 'telephone': p.telephone(), 'title': p.title(g), 'username': p.username(), 'university': p.university(), }
def importToEmployee(): try: dsnStr = cx_Oracle.makedsn("217.173.198.135", "1522", "orcltp") con = cx_Oracle.connect(user="******", password="******", dsn=dsnStr) num = int(input("How many rows should be entered? ")) last_id = getLastID("employee") print("Fetching rows...") for x in range(num): y = mimesis.Person('en') name = y.first_name() surname = y.last_name() code = '#' + y.identifier(mask='###') position = y.occupation() phone = y.telephone() email = y.email(domains=['mail.com']) login = y.username() passwd = y.password() location_id = random.randint(1, getLastID("location")) query = "INSERT INTO employee (id_employee, name, surname, code, position, phone, email, location_id, " \ "login, password) VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10) " cursor = con.cursor() last_id = last_id + 1 cursor.execute(query, (last_id, name, surname, code, position, phone, email, location_id, login, passwd)) print(query) cursor.close() con.commit() print("Rows added successfully") except cx_Oracle.Error as error: print("Error occurred:") print(error) consoleInput()
def test_registration_false2(self, browser: "class Browser", capabilities, domain): """ Проверка валидации: login: Короткое имя pass: короткий пороль confirm pass: Пароль отличный от поля pass """ self.browser = browser string = f"{capabilities[1]}, версия {capabilities[0]['version']}" browser.data["name"] = f"{self._NAME} попытка регистрации на занятый логин браузер {capabilities[0]['browserName']} {string}" browser.setup_browser(capabilities[0]["browserName"], remote=True, desired_capabilities=capabilities[0]) page = Personal(browser) page.open() browser.driver.set_window_size(1920, 1080) page.open_reg_form() password = mimesis.Person().password(length=12) page.registration(login="******", password=password, password_confirm=password) if not browser.debug: btn = page.registration_sumbit() btn.hover() btn.click() assert btn.visible(wait=5), ("Ошибка: Кнопка подтверждения регистрации пропала." "Вероятно регистрация с некоректными данными успешна") error = page.get_registration_error() assert 'Пользователь с логином "test" уже существует.' == error
def importToAsset(): try: dsnStr = cx_Oracle.makedsn("217.173.198.135", "1522", "orcltp") con = cx_Oracle.connect(user="******", password="******", dsn=dsnStr) num = int(input("How many rows should be entered? ")) last_id = getLastID("asset") print("Fetching rows...") for x in range(num): y = mimesis.Person('en') d = mimesis.Datetime() name = 'Personal Computer' model_id = random.randint(1, getLastID("model")) supplier_id = random.randint(1, getLastID("supplier")) price = y.identifier(mask="####") date_of_creation = d.date(start=2015, end=2021) date_of_purchase = d.date(start=2015, end=2021) serial = y.identifier(mask="######") query = "INSERT INTO asset (id_asset, name, model_id, supplier_id, price, date_of_creation, date_of_purchase, serial) VALUES (:1, :2, :3, :4, :5, :6, :7, :8)" cursor = con.cursor() last_id = last_id + 1 cursor.execute(query, (last_id, name, model_id, supplier_id, price, date_of_creation, date_of_purchase, serial)) print(query) cursor.close() con.commit() print("Rows added successfully") except cx_Oracle.Error as error: print("Error occurred:") print(error) consoleInput()
def importToSupplier(): try: dsnStr = cx_Oracle.makedsn("217.173.198.135", "1522", "orcltp") con = cx_Oracle.connect(user="******", password="******", dsn=dsnStr) num = int(input("How many rows should be entered? ")) last_id = getLastID("supplier") print("Fetching rows...") for x in range(num): a = mimesis.Address('en') p = mimesis.Person('en') b = mimesis.Business('en') address = a.city() name = b.company() print(name) contact_person = p.full_name() phone = p.telephone() email = p.email(domains=['mail.com']) query = "INSERT INTO supplier (id_supplier, address, name, contact_person, phone, email) VALUES (:1, :2, " \ ":3, :4, :5, :6) " cursor = con.cursor() last_id = last_id + 1 cursor.execute( query, (last_id, address, name, contact_person, phone, email)) print(query) cursor.close() con.commit() print("Rows added successfully") except cx_Oracle.Error as error: print("Error occurred:") print(error) consoleInput()
def generate_email_list(num: int) -> (str, dict): """ Generates an unleash-style list of emails for testing. :param num: :return: """ first_email = mimesis.Person('en').email() email_list_string = first_email context = {"userId": first_email} for _ in range(num - 1): email_list_string += "," + mimesis.Person('en').email() return (email_list_string, context)
def new_schooluser() -> dict: """Generate data for fake school user :return: dictionary with personal data :rtype: dict """ random.seed() _person = mimesis.Person(locales.RU) _person_ru = mimesis.builtins.RussiaSpecProvider() _date = mimesis.Datetime() _gender = random.choice((enums.Gender.MALE, enums.Gender.FEMALE)) _username = _person.username('ld') return { 'username': _username, 'password': _username, 'first_name': _person.name(_gender), 'last_name': _person.surname(_gender), 'patronymic_name': _person_ru.patronymic(_gender), 'birth_date': _date.formatted_date(fmt='%Y-%m-%d', start=1990, end=2000), 'email': _person.email(), 'language': random.choice(LANGUAGES), 'is_active': True, 'is_staff': False, 'is_superuser': False }
def create_company(save=False): company = edgewise.new_doc("Company") company.name = mimesis.Person("en").last_name() + " "\ + mimesis.Business().company_type(abbr=True) company.country = "United States" if save: company.save() return company
async def get_user(user_id: int): fake_user = mimesis.Person() return { "user_id": user_id, "username": fake_user.username(), "firstname": fake_user.first_name(), "lastname": fake_user.last_name(), }
def populate(count=100) -> Generator['People', None, None]: import mimesis person = mimesis.Person() return (People(id=int(person.identifier('####')), first_name=person.name(), last_name=person.surname(), twitter=person.username()) for _ in range(count))
def good_import_generator(n_citizens=20, n_relations=30): data = [] address_generator = mimesis.Address('ru') number_generator = mimesis.Numbers() person_generator = mimesis.Person('ru') gender_generator = mimesis.Person('en') datetime_generator = mimesis.Datetime() for i in range(1, n_citizens + 1): street, building = address_generator.address().rsplit(' ', maxsplit=1) gender = gender_generator.gender().lower() while gender != 'male' and gender != 'female': gender = gender_generator.gender().lower() data.append({ "citizen_id": i, "town": address_generator.city(), "street": street, "building": building, "apartment": number_generator.between(1, 100000), "name": person_generator.full_name(), "birth_date": datetime_generator.date(1900, 2018).strftime("%d.%m.%Y"), "gender": gender, "relatives": [] }) relations = set() for i in range(n_relations): relation = (number_generator.between(1, n_citizens), number_generator.between(1, n_citizens)) while relation in relations or (relation[1], relation[0]) in relations: relation = (number_generator.between(1, n_citizens), number_generator.between(1, n_citizens)) relations.add(relation) data[relation[0] - 1]["relatives"].append(relation[1]) if relation[0] != relation[1]: data[relation[1] - 1]["relatives"].append(relation[0]) return data
def setup(self, browser): reg_link = "http://selenium1py.pythonanywhere.com/en-gb/accounts/login/" page = LoginPage(browser, reg_link) page.open()\ .should_be_register_form() f_person = mimesis.Person() f_email = f_person.email(domains=['mimesis.name'], unique=True) f_password = f_person.password(length=10, hashed=False) page.register_new_user(f_email, f_password)
async def read_item(user_id: int, locale: Optional[str] = None): fake_user = mimesis.Person(locale=locale) return { "user_id": user_id, "username": fake_user.username(), "fullname": fake_user.full_name(), "age": fake_user.age(), "firstname": fake_user.first_name(), "lastname": fake_user.last_name(), }
def test_registration_true(self, browser: "class Browser", capabilities, domain): self.browser = browser string = f"{capabilities[1]}, версия {capabilities[0]['version']}" browser.data["name"] = f"{self._NAME} корректный ввод браузер {capabilities[0]['browserName']} {string}" browser.setup_browser(capabilities[0]["browserName"], remote=True, desired_capabilities=capabilities[0]) page = Personal(browser) page.open() browser.driver.set_window_size(1920, 1080) page.open_reg_form() login = mimesis.Person().password(length=12) password = mimesis.Person().password(length=12) page.registration(login=login, password=password, password_confirm=password) if not browser.debug: btn = page.registration_sumbit() btn.hover() btn.click() assert btn.hidden(wait=5), "Ошибка Клика: После клика не сработало событие регистрации и кнопка не пропала" page_profile = Profile(browser) page_profile.open() assert page_profile.sumbit().visible(), "Ошибка: Подтверждения регистрации"
def next_author(data_locale: str) -> typing.Iterator[Author]: personal = mimesis.Person(data_locale) author_id = 0 while True: author_id += 1 author = Author(author_id) author.first_name = personal.name() author.last_name = personal.surname() yield author
def create_user(save=False): person = mimesis.Person("en") user = edgewise.new_doc("User") user.first_name = person.name() user.last_name = person.last_name() # user.email = person.email() user.password = person.password() user.username = person.username() user.rbac_role = edgewise.new_doc("RBACRole", name='Database Administrator') if save: user.save() return user
def generate_dummy_data(data_tokens): """ Insert dummy data based on data tokens I - integer id L - login/username E - email P - password T - piece of text :return: """ token_list = data_tokens.split(",") samples_count = random.randint(100, 1000) inserted_data = [] for i in range(samples_count): values = [] person = mimesis.Person("en") for token in token_list: person = mimesis.Person() if token == "I": values.append(i) if token == "L": data = person.username() values.append(data) if token == "E": data = person.email() values.append(data) if token == "P": data = person.password() values.append(data) if token == "T": sample_length = random.randint(1, 10) data = mimesis.Text().text(quantity=sample_length) values.append(data) inserted_data.append(tuple(values)) return inserted_data, token_list
def next_owner(data_locale: str) -> typing.Iterator[Owner]: personal = mimesis.Person(data_locale) address = mimesis.Address(data_locale) owner_id = 0 while True: owner_id += 1 owner = Owner(owner_id) owner.first_name = personal.name() owner.last_name = personal.surname() owner.address = address.address() yield owner
def seed(): address = mimesis.Address() business = mimesis.Business() person = mimesis.Person() for _ in range(1, 6): distributor = models.Distributor( name=business.company(), email=person.email(), address=address.address(), campaign_cost=random.uniform(0, 10), max_sales_count=random.uniform(2, 10), ow_cost=random.uniform(0, 10), ) db.session.add(distributor) db.session.commit()
def seed(): person = mimesis.Person() super_admin_role = models.Role.query.filter_by( name="Super Admin").first() account = models.Account( username="******", password="******", email="*****@*****.**", first_name="admin", last_name="admin", role=super_admin_role, ) db.session.add(account) db.session.commit() distributors = models.Distributor.query.all() user_roles = models.Role.query.filter( models.Role.name != "Super Admin").all() for distributor in distributors: for user_role in user_roles: num_accounts = 2 if user_role.name not in { "Shopper", "Admin Buyer" } else 1 for _ in range(num_accounts): first_name = person.first_name() last_name = person.last_name() username = f"{first_name[0]}{last_name}{random.randint(1, 9)}" account = models.Account( username=username.lower(), password="******", email=person.email(), first_name=first_name, last_name=last_name, distributor_id=distributor.id, role=user_role, ) db.session.add(account) db.session.commit()
def seed(): address = mimesis.Address() business = mimesis.Business() person = mimesis.Person() vendor_types = [ { "is_supplier": True }, { "is_decorator": True }, { "is_pick_pack": True }, { "is_supplier": True, "is_pick_pack": True }, { "is_decorator": True, "is_pick_pack": True }, ] product_types = models.ProductType.query.all() # create five vendors for each product type for product_type in product_types: for vendor_type in vendor_types: vendor = models.Vendor( name=f"{address.state()} {business.company()}", email=person.email(), address=address.address(), **vendor_type, ) product_type.vendors.append(vendor) db.session.add(vendor) db.session.add(product_type) db.session.commit()
def importToModel(): try: dsnStr = cx_Oracle.makedsn("217.173.198.135", "1522", "orcltp") con = cx_Oracle.connect(user="******", password="******", dsn=dsnStr) num = int(input("How many rows should be entered? ")) last_id = getLastID("model") print("Fetching rows...") for x in range(num): y = mimesis.Person() producer_id = random.randint(1, getLastID("producer")) type_id = random.randint(1, getLastID("type")) name = 'T' + y.identifier(mask="####") query = "INSERT INTO model (id_model, name, producer_id, type_id) VALUES (:1, :2, :3, :4)" cursor = con.cursor() last_id = last_id + 1 cursor.execute(query, (last_id, name, producer_id, type_id)) print(query) cursor.close() con.commit() print("Rows added successfully") except cx_Oracle.Error as error: print("Error occurred:") print(error) consoleInput()
def generate_userpass(seed): person = mimesis.Person(seed=seed) return [(f'{person.name()}_{person.surname()}', person.password(24, True)) for i in range(30)]
# Generate a CSV with information for 50,000 fake persons import mimesis import csv import random person = mimesis.Person(locale='en') genderEnum = mimesis.enums.Gender with open('persons.csv', mode='w', newline='\n', encoding='utf-8') as person_file: writer = csv.writer(person_file) # Header Row writer.writerow(['Id', 'Full Name', 'Age', 'Occupation', 'Email', 'Telephone', 'Nationality']) for i in range(0, 50000): rando = random.uniform(0, 1) if rando >= 0.5: gender = genderEnum.FEMALE else: gender = genderEnum.MALE row = [ i, person.full_name(gender=gender), person.age(), person.occupation(), person.email(), person.telephone(), person.nationality()
outsize = config["customers"]["total"] max_age = config["customers"]["max_age"] min_age = config["customers"]["min_age"] joined_start_date = config["customers"]["joined_start_date"] joined_end_date = config["customers"]["joined_end_date"] genders = config["genders"][language] gender_prob = config["genders"]["percentages"] # data processing config amounts_cpu = config["data_processing"]["amount_in_cpu"] auto_batch = True if config["data_processing"][ "auto_batch_based_in_cpu"] == "True" else False # loading mocking data type business = mimesis.Business(language) person = mimesis.Person(language) address = mimesis.Address(language) dates = mimesis.Datetime(language) # Calculating random probabilities # 245 countries country_prob = common_functions.random_probabilities(1, 245) ages_probab = common_functions.random_probabilities(min_age, max_age) # Global customers array customers = [] def generate_customers(amount, index_start): # generates customers' info # amount: number of customer to generate
def create_rbac_role(save=False): role = edgewise.new_doc("RBACRole") role.name = mimesis.Person("en").occupation().replace(' ', '') if save: role.save() return role
def person(request): return mimesis.Person(request.param)
def _mname(locale='en'): return mimesis.Person(locale).full_name()
import unittest import mimesis from api.blueprints import create_app from api.blueprints.models import Post, User from api.blueprints.tests.api_tests import utils MODELS = [Post, User] URL = '/api' p = mimesis.Person() t = mimesis.Text() class AdminRegistrationTests(unittest.TestCase): link = f'{URL}/admin' def setUp(self): self.app, self.db = create_app(testing=True) username, password = p.username(), p.password() User.from_dict(dict(username=username, email=p.email(), password=password, is_admin=True)) self.code, self.admin = utils.post( self.app, f'{URL}/auth/login', username=username, password=password ) self.headers = {'x-access-token': self.admin['token']}
def _occupation(locale='en'): return mimesis.Person(locale).occupation()