def test(self, grid: str, device: Device) -> None:
chrome: Remote = Chrome(grid)
registration = RegisterAffiliatePage(chrome)
person = Person()
registration.load(device)
registration.fill_personal_details(person.name(), person.last_name(),
person.email(), person.telephone())
registration.press_pay_method()
registration.fill_information(person.full_name(),
f"www.{person.username()}.com",
"2332153467", person.email())
registration.fill_password(person.password())
registration.press_continue()
assert RegAffiliateSuccessPage(chrome).available()
def registration_positive_test(self, device: Device) -> None:
generator = Person()
assert "success" in UserRegistration(
Identity(generator.name(), generator.last_name(),
generator.telephone()),
Credentials(generator.email(), generator.password(), "0"),
).registration_response(device)
def handle(self, *args, **options):
# raise NotImplementedError()
Snippet.objects.all().delete()
users = []
person = Person()
for _ in range(40):
User.objects.create(password=person.password(),
username=person.username(),
first_name=person.name(),
last_name=person.last_name(),
email=person.email())
text = Text()
users = User.objects.all()
for _ in range(30):
language = choice(['python', 'javascript', 'ruby', 'java'])
if language == "java":
content = open(BASE_DIR + "/core/fakecode/file.java").read()
elif language == "python":
content = open(BASE_DIR + "/core/fakecode/python.py").read()
elif language == "javascript":
content = open(BASE_DIR +
"/core/fakecode/javascript.js").read()
else:
content = open(BASE_DIR + "/core/fakecode/ruby.rb").read()
title = text.sentence()
if not Snippet.objects.filter(title=title).exists():
Snippet.objects.create(author=choice(users),
title=title,
language=language,
content=content)
def insert_in_batches(col, total, batch_size):
many_people = []
inserted_count = 0
start_time = datetime.utcnow()
previous_time = start_time
p = Person("en", seed=0xBEE)
for i in range(total):
proxy_person = {
"name": p.first_name(),
"surname": p.surname(),
"email": p.email(),
"password": p.password()
}
many_people.append(proxy_person)
if (len(many_people) % batch_size) == 0:
col.insert_many(many_people)
inserted_count = inserted_count + len(many_people)
time_now = datetime.utcnow()
elapsed_time = time_now - previous_time
previous_time = time_now
print(f"Inserted {len(many_people)} people in {elapsed_time}")
many_people.clear()
if len(many_people) > 0:
col.insert_many(many_people)
inserted_count = inserted_count + len(many_people)
end_time = datetime.utcnow()
duration = end_time - start_time
print(f"Inserting {inserted_count} records took {duration}")
def run():
person = Person()
text = Text()
internet = Internet()
dateTime = Datetime()
for i in range(100):
User.objects.create(password="******",
username=person.username(),
first_name=person.name(),
last_name=person.last_name(),
email=person.email())
users = User.objects.all()
for i in range(100):
Post.objects.create(author=choice(users),
link=internet.home_page(),
title=text.title(),
description=text.text())
posts = Post.objects.all()
for i in range(100):
Comment.objects.create(author=choice(users),
post=choice(posts),
description=text.text())
def create_human(n):
"""
:param n: язык генерации данных
:return: сгенерированные фейковые данные
"""
log.info("Генерируем тестовые данные")
if n == 1:
person = Person('ru')
else:
person = Person('en')
log.info("person: " + str(person))
client_info = generate_id_passport()
print('\nфамилия:\t', person.last_name())
print('имя:\t\t', person.name())
print('отчество:\t', person.surname(), '\n')
passport = generate_number_passport()
print('личный №:\t', client_info.get('idn'))
print('документ:\t', passport)
print('пол:\t\t', client_info.get('sex'))
print('возраст:\t', person.age(13, 70), '\n')
# print('аватар\t', person.avatar())
print('гражд-во:\t', person.get_current_locale())
print('Нац-сть:\t',person.nationality())
print('телефон:\t', person.telephone('+37529#######'))
print('email:\t\t', person.email())
print('проф-ия:\t', person.occupation(), '\n')
print('обращение:\t', person.title())
print('взгляды:\t', person.views_on())
print('вера:\t\t', person.worldview(), '\n')
def handle(self, *args, **options):
UserProfile.objects.all().delete()
Author.objects.all().delete()
person = Person('en')
for _ in range(COUNT_ELEM):
first_name = person.first_name()
last_name = person.last_name()
login = f'{first_name}.{last_name}'
email = person.email()
birthday_year = datetime.today().year - person.age(minimum=14,
maximum=100)
print(f'Created:{login} - {email}')
user = {
"user_name": login,
"first_name": first_name,
"last_name": last_name,
"gender": person.sex('M', 'F'),
"birthday_year": birthday_year,
"email": email
}
author = {
"first_name": first_name,
"last_name": last_name,
"birthday_year": birthday_year,
}
new_user = UserProfile(**user)
new_user.save()
new_author = Author(**author)
new_author.save()
User.objects.all().delete()
User.objects.create_superuser('admin', 'admin@localhost', 'admin')
def fill_persondata():
db = MySQLdb.connect(host=config.DB_HOST,
user=config.DB_USER,
passwd=config.DB_PASSWORD,
db=config.DB_NAME)
cursor = db.cursor()
# Zero client, anon
cursor.execute(
"""INSERT INTO PersonData (first_name, last_name, birth_date, email, mobile, gender) VALUES (%s, %s, %s, %s,
%s, %s);""", [
'anon', 'anon',
Datetime().date(start=1950, end=2001), None, None, None
])
for _ in range(config.N_PERSONS):
p = Person('ru')
cursor.execute(
"""INSERT INTO PersonData (first_name, last_name, birth_date, email, mobile, gender) VALUES (%s, %s, %s,
%s, %s, %s);""", [
p.name(),
p.surname(),
Datetime().date(start=1950, end=2001),
p.email(),
p.telephone('#' * 11),
'M' if p.gender(iso5218=True) == 1 else 'F'
])
db.commit()
cursor.close()
db.close()
def test_sign_up_user(browser):
person = Person()
TEST_DATA = {
'first_name': person.first_name(),
'last_name': person.last_name(),
'email': person.email(),
'telephone': person.telephone(),
'password': person.password(8)
}
sign_up_page = SignUpPage(browser)
sign_up_page.open()
sign_up_page.fill_user_data(first_name=TEST_DATA['first_name'],
last_name=TEST_DATA['last_name'],
email=TEST_DATA['email'],
telephone=TEST_DATA['telephone'],
password=TEST_DATA['password'])
TopMenu(browser).logout()
sign_in_page = SignInPage(browser)
sign_in_page.confirm_logout()
sign_in_page.open()
sign_in_page.login(TEST_DATA['email'], TEST_DATA['password'])
assert sign_in_page.get_available_actions_header() == 'My Account'
def register_new_user(self):
person = Person('en')
email = person.email()
password = person.password(10)
self.fill_the_field(*LoginPageLocators.REGISTER_EMAIL, email)
self.fill_the_field(*LoginPageLocators.REGISTER_PASSWORD, password)
self.fill_the_field(*LoginPageLocators.REGISTER_CONFIRM_PASSWORD, password)
self.browser.find_element(*LoginPageLocators.REGISTER_BUTTON).click()
def get_new_user() -> User:
person = Person()
username = person.username()
email = person.email(domains=["gmail.com", "yahoo.com"])
password = person.password(length=25)
user = User(username=username, email=email, password=password)
user, error = user.save()
return user
def setup(self, driver):
link = 'http://selenium1py.pythonanywhere.com/en-gb/catalogue/coders-at-work_207/'
page = LoginPage(driver, link)
page.open()
person = Person('en')
page.go_to_login_page()
page.register_new_user(person.email(domains=None, unique=False),
person.password(length=10, hashed=False))
page.should_be_authorized_user()
def rediscluster_testset(n):
for a in range(n):
person = Person('zh')
name = person.email()
age = person.password()
# t=time.asctime(time.localtime(time.time()))
rc.set(name, age)
print(rc.get(name))
time.sleep(1)
def setup(self, browser):
link = 'http://selenium1py.pythonanywhere.com/en-gb/accounts/login/'
page = LoginPage(browser, link)
page.open()
user = Person()
email = user.email()
password = user.password(length=9)
page.register_new_user(email, password)
page.should_be_authorized_user()
def test_setup(self, browser):
person = Person("en")
login_link = "http://selenium1py.pythonanywhere.com/en-gb/accounts/login/"
email = person.email()
password = person.password(length=9)
page = LoginPage(browser, login_link)
page.open()
page.register_new_user(email, password)
page.should_be_authorized_user()
def handle(self, *args, **options):
print('Deleting database!')
Post.objects.all().delete()
User.objects.filter(is_superuser=False).delete()
Comment.objects.all().delete()
Favorite.objects.all().delete()
Like.objects.all().delete()
person = Person()
fake = Faker()
# populator = Faker.getPopulator()
users = []
for fake_user in range(100):
fake_user = User.objects.create_user(person.username(),
person.email(), 'password')
users.append(fake_user)
print("100 Fake users created!")
fake_posts = []
for i in range(50):
post_dictionary = {
'title': fake.sentence(),
'description': fake.text(),
'user': users[random.randrange(100)],
}
fake_posts.append(post_dictionary)
posts = []
for post_data in fake_posts:
post = Post.objects.create(**post_data)
posts.append(post)
print('50 Posts imported!!!')
for i in range(100):
Like.objects.create(post=posts[random.randrange(50)],
user=users[i])
print('100 Likes imported!!!')
for i in range(100):
Favorite.objects.create(post=posts[random.randrange(50)],
user=users[i])
print('100 Favorites imported!!!')
for i in range(200):
Comment.objects.create(post=posts[random.randrange(50)],
user=users[random.randrange(100)],
comment=fake.sentence())
print('200 comments imported!')
for i in range(100):
Follow.objects.create(following=users[i],
followed=users[random.randrange(30)])
print('100 follows imported!')
print('All data imported successfully!')
def persin_test():
person = Person("en")
print("u")
user_info = dict(username=person.username(),
email=person.email(),
password=person.password(),
real_name=person.full_name(),
gender='men',
birthday=("1", "3", "1990"))
print(user_info)
def test(self, grid: str, device: Device) -> None:
chrome: Remote = Chrome(grid)
registration = RegisterAccountPage(chrome)
registration.load(device)
person = Person()
registration.fill_personal_details(person.name(), person.last_name(),
person.email(), person.telephone())
registration.fill_password(person.password())
registration.press_continue()
assert RegistrationSuccessPage(chrome).available()
def setup(self, browser):
link = 'http://selenium1py.pythonanywhere.com/en-gb/'
page = MainPage(browser, link)
page.open()
page.go_to_login_page()
login_page = LoginPage(browser, link)
person = Person()
login_page.register_new_user(person.email(),
person.password(length=10))
login_page.should_be_authorized_user()
def generate_users(count=1024, locale="en"):
logging.info(f"Generating {count} users.")
person = Person(locale)
for i in range(count):
user = UserModel()
user.first_name = person.name()
user.last_name = person.surname()
user.email = person.email()
user.password = person.password()
user.phone = person.telephone(mask="###.###.####")
user.save()
def test_contact_us(self, device: Device) -> None:
person = Person()
assert_if_request_contains_success_response_url(
Post(
f"https://{device.connections.main.ip}/index.php?route=information/contact",
{
"name": person.name(),
"email": person.email(),
"enquiry": "test data test data"
},
))
def _generate_user_data(locale='ru'):
person = Person(locale)
date = Datetime(locale)
gender = get_random_item(Gender)
return {
'password': _generate_password(),
'first_name': person.surname(gender=gender),
'last_name': person.name(gender=gender),
'email': person.email(),
'date_joined': date.datetime(start=2014, end=2015).replace(tzinfo=utc),
}
def test_affiliate_reg(self, device: Device) -> None:
urllib3.disable_warnings()
person = Person()
(assert_if_request_contains_success_response_url(
Post(
f"https://{device.connections.main.ip}/index.php?route=affiliate/register",
{
"firstname": person.name(),
"lastname": person.last_name(),
"email": person.email(),
"telephone": person.telephone(),
"company": person.full_name(),
"website": f"www.{person.username()}.net",
"tax": "123456",
"payment": "paypal",
"paypal": person.email(),
"password": person.password(),
"confirm": person.password(),
"agree": 1,
},
)))
def setup(self, browser):
link = ProductPageLinks.LINK_PRODUCT_PAGE
page = ProductPage(browser, link)
page.open()
page.go_to_login_page(
) # выполняем метод страницы — переходим на страницу логина
login_page = LoginPage(browser, browser.current_url)
user = Person()
email = user.email()
password = user.telephone()
login_page.register_new_user(email, password)
login_page.should_be_authorized_user()
def handle(self, *args, **options):
person = Person('ru')
for i in range(25):
gender = random.choice([Gender.FEMALE, Gender.MALE])
user = User.objects.create_user(email=person.email(),
password='******')
user.first_name = person.name(gender=gender)
user.last_name = person.last_name(gender=gender)
user.save()
self.stdout.write(self.style.SUCCESS('Пользователи успешно созданы'))
def setup(self, browser):
product_url = ProductPageLocators.PRODUCT_THE_CITY_AND_THE_STARS[0]
self.product_page = ProductPage(browser, product_url)
self.product_page.open()
self.product_page.go_to_login_page()
self.login_page = LoginPage(browser, LoginPageLocators.LOGIN_URL)
person = Person()
name_new_user = person.full_name()
email_new_user = person.email(
domains=[name_new_user.replace(' ', '').lower() + '.com'])
password_new_user = passgenerator.generate(10)
self.login_page.register_new_user(email_new_user, password_new_user)
self.login_page.should_be_authorized_user()
def setUp(self):
"""Generate some fake data."""
self.app = Flask('test')
util.init_app(self.app)
self.app.config['CLASSIC_DATABASE_URI'] = 'sqlite:///test.db'
self.app.config['CLASSIC_SESSION_HASH'] = 'foohash'
with self.app.app_context():
util.create_all()
with util.transaction() as session:
person = Person('en')
net = Internet('en')
ip_addr = net.ip_v4()
email = person.email()
approved = 1
deleted = 0
banned = 0
first_name = person.name()
last_name = person.surname()
suffix_name = person.title()
joined_date = util.epoch(
Datetime('en').datetime().replace(tzinfo=EASTERN))
db_user = models.DBUser(
first_name=first_name,
last_name=last_name,
suffix_name=suffix_name,
share_first_name=1,
share_last_name=1,
email=email,
flag_approved=approved,
flag_deleted=deleted,
flag_banned=banned,
flag_edit_users=0,
flag_edit_system=0,
flag_email_verified=1,
share_email=8,
email_bouncing=0,
policy_class=2, # Public user. TODO: consider admin.
joined_date=joined_date,
joined_ip_num=ip_addr,
joined_remote_host=ip_addr)
session.add(db_user)
self.user = domain.User(user_id=str(db_user.user_id),
username='******',
email=db_user.email,
name=domain.UserFullName(
forename=db_user.first_name,
surname=db_user.last_name,
suffix=db_user.suffix_name))
def setup(self, browser):
login = Person()
# генерируем логин и пароль с помощью методов класса Person библиотеки mimesis
email = login.email(domains=['@gmail.com'])
password = login.password(length=9, hashed=False)
link = "http://selenium1py.pythonanywhere.com"
page = MainPage(browser, link)
page.open()
page.go_to_login_page()
login_page = LoginPage(browser,
browser.current_url,
email=email,
password=password)
login_page.register_new_user()
login_page.should_be_authorized_user()
def handle(self, *args, **kwargs):
person = Person('ru')
total = kwargs['total']
admin = kwargs['admin']
for i in range(total):
password = User.objects.make_random_password()
if admin:
user = User.objects.create_superuser(
username=person.username(),
first_name=person.first_name(),
last_name=person.last_name(),
email=person.email(),
password=password,
)
print(f'Create new Superuser: {user} and password: {password}')
else:
user = User.objects.create_user(
username=person.username(),
first_name=person.first_name(),
last_name=person.last_name(),
email=person.email(),
password=password,
)
print(f'Create new user: {user} and password: {password}')
def insert_one_at_a_time(col, total):
start_time = datetime.utcnow()
p = Person("en", seed=0xBEE)
for i in range(total): # 0..total-1
proxy_person = {
"name": p.first_name(),
"surname": p.surname(),
"email": p.email(),
"password": p.password()
}
col.insert_one(proxy_person)
if ((i + 1) % 10) == 0:
print(f"Inserted {i+1} docs")
end_time = datetime.utcnow()
duration = end_time - start_time
print(f"Inserting {i + 1} records took {duration}")
