class DoctorTestCase(TestCase):
def setUp(self):
print('\n------- MODULO DOCTOR (médico) -------')
print("Configurando testes do model Doctor")
self.faker = Faker('pt_BR')
self.specialty = Specialty.objects.create(name=self.faker.job())
def test_create_doctor_only_required_fields(self):
print("Testando criação de médico apenas com nome e crm")
doctor = Doctor.objects.create(
name=self.faker.name(),
crm=self.faker.random_number(),
)
doctor.save()
query = Doctor.objects.get(name=doctor.name)
self.assertEqual(doctor.name, query.name)
def test_create_doctor(self):
print("Testando criação de médico")
doctor = Doctor.objects.create(
name=self.faker.name(),
crm=self.faker.random_number(),
email=self.faker.email(),
phone=self.faker.phone_number(),
specialty=self.specialty,
)
doctor.save()
query = Doctor.objects.get(name=doctor.name)
self.assertEqual(doctor.name, query.name)
def export_data(file_name, num_rows):
fake = Faker()
with open(file_name, "w", newline='') as csv_file:
writer = csv.writer(csv_file)
# establish titles for each value
writer.writerow([
"Email", "PartySize", "ReservationTime", "Quantity", "Price",
"FoodName", "FoodTypeName"
])
# create 'num_rows' entries
for x in range(num_rows):
email = fake.email()
# party size between 1 and 10
party = fake.random_number(1, 10)
# reservatinons within a year
time = fake.date_time_between(start_date='now', end_date='+365d')
# quantity between 1 and 20
qty = fake.random_number(1, 20)
# between 5 and 17 dollars
price = fake.random_int(50, 170) / 10.0
# generate random (non food related words for names and types)
foodname = fake.word()
foodtypename = fake.word()
writer.writerow(
[email, party, time, qty, price, foodname, foodtypename])
class SiteBotTestCase(unittest.TestCase):
def setUp(self):
self.fake = Faker()
def fake_event(self):
return {
'id': self.fake.random_number(),
'title': self.fake.sentence(4),
'time': self.fake.date_time_this_year(True, True),
'excerpt': self.fake.sentence(4),
'venue_name': self.fake.company(),
'venue_location': self.fake.street_address()
}
def fake_event_old(self):
# All times come from Meetup in milliseconds
return {
'created': 1000 * time.mktime(
self.fake.date_time_this_year(True, True).timetuple()),
'duration': 7200000,
'id': self.fake.random_number(),
'name': self.fake.sentence(4),
'self': {
'actions': [
'upload_photo',
'delete',
'edit_hosts',
'edit',
'comment',
'rsvp'
]
},
'status': random.choice(['cancelled', 'upcoming', 'past',
'proposed', 'suggested', 'draft']),
'time': 1000 * time.mktime(
self.fake.date_time_this_year(True, True).timetuple()),
'updated': 1000 * time.mktime(
self.fake.date_time_this_year(True, True).timetuple()),
'utc_offset': -21600000,
'venue': {
'id': self.fake.random_number(),
'name': self.fake.company(),
'lat': float(self.fake.latitude()),
'lon': float(self.fake.longitude()),
'repinned': False,
'address_1': self.fake.street_address(),
'city': self.fake.city(),
'country': 'us',
'localized_country_name': 'USA',
'zip': self.fake.zipcode(),
'state': self.fake.state_abbr()
},
'link': self.fake.uri(),
'description': '''
<p>Hello <a href="http://example.com">World</a></p>
<p>Here is some more content</p>
''',
'how_to_find_us': self.fake.sentence(10),
'visibility': random.choice([True, False])
}
def test_create_method(self):
"""
assert serializer_class can
successfully create requested users.
"""
faker = Faker()
serializer_class = RegisterAdminUserSerializer()
company = baker.make('backend.Company')
profile = faker.profile(fields=['username'])
user_types = ['admin', 'engineer', 'client', 'support', 'arduino']
data = {
'username': profile['username'],
'first_name': faker.first_name(),
'last_name': faker.last_name(),
'email': faker.email(),
'company': company,
'password': faker.text,
'phone': faker.random_number(),
'ext': faker.random_number(),
'celphone': faker.random_number(),
'user_type': choice(user_types),
'is_staff': bool(getrandbits(1)),
'is_superuser': bool(getrandbits(1))
}
user = serializer_class.create(data)
instance = VibroUser.objects.filter(id=user.id)
self.assertTrue(instance.exists())
def generate_random_csv(old_file_path, length=100, change_range=5):
"""
This method generates csv file which has
following header
id,key,value,created_at
:param file_path:
:param length:
:param change_range: how many changes effect on v2
:return: csv_file
"""
myFactory = Faker()
new_file_path = old_file_path + '_v2'
generate_count = 0
with open(old_file_path, 'w') as fp_old_csv_file:
with open(new_file_path, 'w') as fp_new_csv_file:
old_csv_file = csv.writer(fp_old_csv_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
new_csv_file = csv.writer(fp_new_csv_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
old_csv_file.writerow(['ID', 'KEY', 'VALUE', 'CREATED_AT'])
new_csv_file.writerow(['ID', 'KEY', 'VALUE', 'CREATED_AT'])
for row in range(1, length):
id = row
key = myFactory.random_number()
value = myFactory.word()
created_at = myFactory.date_object()
old_csv_file.writerow([id, key, value, created_at])
if generate_count < change_range:
# Deleted
pass
elif change_range <= generate_count < 2 * change_range:
# Updated
key_2 = key = myFactory.random_number()
value_2 = myFactory.word()
new_csv_file.writerow([id, key_2, value_2, created_at])
elif 2 * change_range <= generate_count < 3 * change_range:
# Inserted
new_csv_file.writerow(
[id + length, key, value, created_at])
new_csv_file.writerow([id, key, value, created_at])
else:
new_csv_file.writerow([id, key, value, created_at])
generate_count += 1
return old_file_path, new_file_path
def faker():
if request.args.get('remove'):
model = False
if request.args.get('remove') == 'categories':
model = Category
if request.args.get('remove') == 'products':
model = Product
if model:
model.query.delete()
db.session.commit()
return redirect('/admin/faker', code=302)
if request.args.get('count') and request.args.get('model'):
objs = []
for i in range(int(request.args.get('count'))):
fake = Faker()
# model = request.args.get('model')()
if request.args.get('model') == 'categories':
name = fake.word()
if Category.query.filter_by(name=name).count() > 0:
continue
model = Category()
model.name = name
model.parent_id = get_random_elem(Category.query.all())
db.session.add(model)
db.session.commit()
if request.args.get('model') == 'products':
name = fake.word()
if Product.query.filter_by(name=name).count() > 0:
continue
model = Product()
model.name = name
model.category_id = get_random_elem(Category.query.all(),
False)
model.price = fake.random_number(4)
model.prop1 = fake.random_number(1, True)
model.prop2 = fake.random_number(2, True)
db.session.add(model)
db.session.commit()
return redirect('/admin/faker', code=302)
categories = Category.query.all()
products = Product.query.all()
return render_template('admin/faker.html',
categories=categories,
products=products)
class ProfileProvider(BaseProvider):
def __init__(self, generator):
super().__init__(generator)
self.fake = Faker()
def first_name(self):
return self.fake.first_name()
def last_name(self):
return self.fake.last_name()
def patronymic(self):
return self.fake.first_name()
def type(self):
return random.choice(user_type_choices)
def birth_date(self):
return str(self.fake.date())
def github_id(self):
return self.fake.random_number(10)
def stepic_id(self):
return self.fake.random_number(10)
def election_date(self):
return str(self.fake.date())
def contract_date(self):
return str(self.fake.date())
def academic_status(self):
return random.choice(user_academic_status_choices)
def year_of_academic_status(self):
return self.fake.year()
def moevm_profile(self):
return {
'last_name': self.last_name(),
'first_name': self.first_name(),
'patronymic': self.patronymic(),
'type': self.type(),
'birth_date': self.birth_date(),
'github_id': self.github_id(),
'stepic_id': self.stepic_id(),
'election_date': self.election_date(),
'contract_date': self.contract_date(),
'academic_status': self.academic_status(),
'year_of_academic_status': self.year_of_academic_status()
}
class TestMath(unittest.TestCase):
def setUp(self):
self.fake = Faker()
def test_should_not_pass_when_is_none(self):
number = self.fake.random_number()
self.assertIsNotNone(OddNumbers.is_even(number))
def test_should_return_false_when_number_is_odd(self):
odd_number = self.fake.random_number() * 2
self.assertFalse(OddNumbers.is_even(odd_number))
def test_should_return_true_when_number_is_even(self):
even_number = self.fake.random_number() * 2 + 1
self.assertTrue(OddNumbers.is_even(even_number))
class TestMathCase(unittest.TestCase):
def setUp(self):
self.fake = Faker()
def test_odd_number_is_not_none(self):
number = self.fake.random_number()
self.assertIsNotNone(OddNumber.odd_number(number))
def test_return_true_when_odd_number_is_odd(self):
number = self.fake.random_number() * 2
self.assertEqual(OddNumber.odd_number(number), True)
def test_return_false_when_odd_number_is_even(self):
number = self.fake.random_number() * 2 + 1
self.assertEqual(OddNumber.odd_number(number), False)
def add_vendor_profile(user):
fa = Faker()
return Vendor.objects.create(user=user,
name=fa.company()[0],
email=fa.email()[0],
gstin_number=fa.random_number(6),
address=fa.address())
class ScheduleTestCase(TestCase):
def setUp(self):
print('\n------- MODULO SCHEDULR (agenda para médico) -------')
print("Configurando testes do model Schedule")
self.faker = Faker('pt_BR')
self.mock_date_future = datetime.fromtimestamp(1604975388)
self.mock_date_past = datetime.fromtimestamp(1594348188)
self.specialty = Specialty.objects.create(name=self.faker.job())
self.time = Timetable.objects.bulk_create([
Timetable(time=self.faker.time()),
Timetable(time=self.faker.time()),
Timetable(time=self.faker.time()),
Timetable(time=self.faker.time()),
])
self.doctor = Doctor.objects.create(
name=self.faker.name(),
crm=self.faker.random_number(),
email=self.faker.email(),
phone=self.faker.phone_number(),
specialty=self.specialty,
)
def test_create_schedule(self):
print("Testando criação de agenda")
schedule = Schedule.objects.create(
doctor=self.doctor,
day=self.mock_date_future.date(),
)
schedule.save()
query = Schedule.objects.get(doctor=schedule.doctor)
self.assertEqual(self.doctor, query.doctor)
def test_fail_create_schedule_ony_day_doctor(self):
print(
"Testando falha na criação de agenda: Apenas uma agenda para um médico por dia"
)
with self.assertRaises(IntegrityError):
schedule = Schedule.objects.create(
doctor=self.doctor,
day=self.mock_date_future.date(),
)
schedule.save()
schedule = Schedule.objects.create(
doctor=self.doctor,
day=self.mock_date_future.date(),
)
schedule.save()
def test_fail_create_schedule_past_days(self):
print(
"Testando falha na criação de agenda: Não cria com um dia que ja passou"
)
with self.assertRaises(ValidationError):
schedule = Schedule.objects.create(
doctor=self.doctor,
day=self.mock_date_past.date(),
)
schedule.save()
def test_add_employee_success():
"""
make sure if we call function with correct parameters
1. user login
2. create valid employee request data
3. call function add_employee with employee data
4. ensure that employee was created
"""
# l1.login
resp = hrm.login()
# 2
f = Faker()
first_name = f.first_name()
last_name = f.last_name()
emp_number = str(f.random_number(6))
# 3
response = hrm.add_employee(emp_number, first_name, last_name)
assert '/pim/viewPersonalDetails/empNumber' in response.url
# 4.Optional step, to check that data posted correctly
resp = hrm.get_employee_details(resp.url)
# soup = bs4.BeautifulSoup(resp.content, 'html5lib')
print(resp.html_data)
actual_emp_id = resp.html_data.select_one(
'#personal_txtEmployeeId')['value']
assert str(emp_number) == actual_emp_id
class SoldierProvider(BaseProvider):
def __init__(self, generator):
super().__init__(generator)
with open(
f"{os.path.dirname(os.path.realpath(__file__))}/data/army.yml"
) as f:
d = yaml.load(f, Loader=yaml.SafeLoader)
self.ranks = d["ranks"]
Faker.seed(int(round(datetime.now().timestamp() * 1000)))
self.fake = Faker()
def soldier(self, locale='en_US'):
if locale in [None, "en_US"]:
locale = "en_US"
name = self.fake.name()
elif locale == 'ru_TL':
name = RussianNames(count=1, gender=0.9,
transliterate=True).get_batch()[0]
rank_type = choice(["non_officer", "officer"])
return {
"Name": name,
"Rank": choice(self.ranks[locale][rank_type]),
"Company": self.fake.random_number(digits=5, fix_len=True),
"Age": self.fake.random_int(18, 55)
}
class StudentProvider(BaseProvider):
def __init__(self, generator):
super().__init__(generator)
with open(
f"{os.path.dirname(os.path.realpath(__file__))}/data/education.yml"
) as f:
d = yaml.load(f, Loader=yaml.SafeLoader)
self.faculties = d["university"]["faculties"]
Faker.seed(int(round(datetime.now().timestamp() * 1000)))
self.fake = Faker()
def student(self, locale='en_US'):
if locale in [None, "en_US"]:
locale = "en_US"
name = self.fake.name()
elif locale == 'ru_TL':
name = RussianNames(count=1, gender=0.5,
transliterate=True).get_batch()[0]
return {
"Name": name,
"Faculty": choice(self.faculties),
"Group": self.fake.random_number(digits=3, fix_len=True),
"AvgScore": self.fake.random_int(1, 10)
}
class FakeData():
def __init__(self):
self.fake = Faker(['pt_BR'])
self.data = []
def dispatch_view_messages(self):
for _ in range(1000):
lat_long = self.fake.local_latlng(country_code='BR')
self.data.append({
'product': {
'id': self.fake.random_number(digits=6, fix_len=True),
'name': self.fake.sentence(nb_words=3)
},
'customer': {
'id': self.fake.lexify(text='???????????????????'),
'zipCode': self.fake.postcode(),
},
'demandedAt':
datetime.today().strftime('%Y-%m-%dT%H:%M:%S'),
'status':
'VIEW'
})
def dispatch_added_to_cart_messages(self):
for item in random.sample(self.data, 400):
item['status'] = 'ADDED_TO_CART'
self.data.append(item)
def dispatch_bought_messages(self):
for item in random.sample(self.data, 200):
item['status'] = 'BOUGHT'
self.data.append(item)
def create_finalsel_file(source_file, output_file):
fake = Faker('en_GB')
with open(source_file, "r") as file_in:
reader = csv.reader(file_in, delimiter=':')
with open(output_file, 'w') as file_new:
writer = csv.writer(file_new, delimiter=':', lineterminator='\n')
for i in reader:
if 'N' not in i[20]:
reporting_unit_reference = i[0]
live_local_unit = i[14]
live_vat = i[15]
live_paye = i[16]
legal_status = i[17]
region = i[18]
cell_number = i[19]
selection_marker = i[20]
inclusion_exclusion_marker = i[22]
i[1] = fake.random_uppercase_letter() # Check letter
i[14] = reporting_unit_reference[
1:] # enterprise reference
i[15] = random.randrange(
WOW_START_REF, WOW_END_REF) # wow enterprise reference
i[16] = fake.random_number(12) # VAT reference
i[17] = fake.random_number(13) # VAT paye
i[18] = fake.random_number(
8) # Company registration number
i[19] = live_local_unit
i[20] = live_vat
i[21] = live_paye
del i[22] # Deleting empty column
i.extend(
(legal_status, "E", region,
fake.date(pattern='%d/%m/%Y'), fake.company(),
fake.company_suffix(), "", fake.company(), "", "",
fake.building_number(), fake.street_name(),
fake.city(), fake.country(), "", fake.postcode(),
random.choice(['Franchise', 'Sole Trader',
'']), "", "", fake.name(),
fake.phone_number(), fake.phone_number(),
selection_marker, inclusion_exclusion_marker,
cell_number, "0004", "*", random.choice(['E', 'S'])))
writer.writerow(i)
class MathTestCase(unittest.TestCase):
def setUp(self):
self.fake = Faker()
def test_odd_number_not_none(self):
test_number = self.fake.random_number()
is_odd_number = OddNumber.odd_number(test_number)
self.assertIsNotNone(is_odd_number)
def test_odd_number_is_tre(self):
test_number = self.fake.random_number() * 2
is_odd_number = OddNumber.odd_number(test_number)
self.assertEquals(is_odd_number, True)
def test_odd_number_is_false(self):
test_number = self.fake.random_number() * 2 + 1
is_odd_number = OddNumber.odd_number(test_number)
self.assertEquals(is_odd_number, False)
def create_human():
fake = Faker()
human = Human(
avatar=ImageFile(open('static/avatar_sample.jpg', 'rb')),
first_name=fake.first_name(),
second_name=fake.last_name(),
age=fake.random_number(),
gender=random.choice(['M', 'F'])
)
human.save()
def gen_vendors(number=1, **kwargs):
fa = Faker()
user = gen_users(number)[0]
return [
Vendor.objects.create(user=user,
name=fa.company()[0],
email=fa.email()[0],
gstin_number=fa.random_number(6),
address=fa.address()) for i in range(number)
]
def setData1():
print('这是setdata函数')
faker = Faker(locale='zh_CN')
file = open('deviceData.csv', 'w', newline='')
fwrite = csv.writer(file)
p = Pinyin()
faker1 = Faker()
for i in range(1,2):
deciveName = "设备名称"+str(faker.random_number(6))
deciveNumber = faker.random_int()
deciveXinghao = str(faker.random_int())+str(faker.random_digit_not_null())
decivePinpai = "设备品牌"+str(faker.random_number(4))
runTime =faker.random_int(4)
firstTime=faker.past_date()#随机生成已经过去的日期
lastTime =faker.future_date()#未来日期
recentTime=faker.date_between(start_date='-30y', end_date=firstTime)
purchaserName=faker.name()
picFile = 'C:/Users/dell/Pictures/mingxing/fengji.jpg'
fwrite.writerow([deciveName, deciveNumber, deciveXinghao,decivePinpai, runTime, firstTime,lastTime,recentTime,purchaserName,picFile])
file.close()
def generate():
fake = Faker()
name = generate_name()
addr = fake.street_address()
city = cities.get_random()
phone = fake.random_number(digits=10)
license = ''.join(random.choice('0123456789ABCDEF') for i in range(8))
night_club = Night_Club(name, addr, city, phone, license)
return night_club
def create_posts_for_user(to_populate=None, count=100):
"""
Create a number of StreetArtPost objects and associate them with the given
user.
:param to_populate: The user to populate.
:param count: The number of posts to add to the user.
:return: The newly-created posts.
"""
new_posts = []
faker = Faker()
for i in range(count):
new_posts.append(StreetArtPost.objects.create(
latitude=float(faker.random_number()) * 0.01,
longitude=float(faker.random_number()) * 0.01,
title=faker.word(),
description=faker.paragraph(),
s3_bucket=faker.word(),
s3_key=str(uuid4()),
user=to_populate,
))
return new_posts
class BookkeepingProvider(BaseProvider):
def __init__(self, generator):
super().__init__(generator)
Faker.seed(int(round(datetime.now().timestamp() * 1000)))
self.fake = Faker()
def record(self, locale=None):
if locale in [None, "en_US"]:
locale = "en_US"
name = self.fake.name()
salary = self.fake.random_number(digits=4, fix_len=True)
elif locale == 'ru_TL':
name = RussianNames(count=1, gender=0.5,
transliterate=True).get_batch()[0]
salary = self.fake.random_number(digits=5, fix_len=True)
return {
"Name": name,
"Job": self.fake.job(),
"Project": self.fake.catch_phrase(),
"Salary": salary
}
def handle(self, *args, **options):
faker = Faker("pl_PL")
for i in range(10):
book = Book()
book.title = faker.text(50)
book.isbn = faker.isbn13()
book.pages = faker.random_number()
book.cover_type = "soft"
book.save()
people = Author.objects.all()
book.author.add(random.choice(people))
book.save()
self.stdout.write(self.style.SUCCESS(f'Create:{book}'))
def seed_db():
from main import bcrypt
from models.Menu import Menu
from models.User import User
from models.Order import Order
from faker import Faker
import random
faker = Faker()
users = []
menus = []
for i in range(10):
user = User()
user.email = faker.email()
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
user.first_name = faker.first_name()
user.last_name = faker.last_name()
user.admin = faker.boolean(chance_of_getting_true=50)
users.append(user)
db.session.add(user)
print(f"{i} users created")
db.session.commit()
for i in range(10):
menu = Menu()
menu.title = faker.color_name()
menu.price = faker.random_number(digits=2)
menu.vegetarian = faker.boolean(chance_of_getting_true=50)
menus.append(menu)
db.session.add(menu)
print(f"{i} book record(s) created")
db.session.commit()
for i in range(10):
order = Order()
order.menu_id = random.choice(menus).id
order.user_id = random.choice(users).id
order.test = "test"
db.session.add(order)
print(f"{i} order created")
db.session.commit()
print("Tables seeded")
def forge(count):
"""Generate fake messages."""
from faker import Faker
db.drop_all()
db.create_all()
fake = Faker(locale='zh_CN')
click.echo('Working...')
status = ['正常营业', '休息中', '停业整顿', '已关店']
for i in range(count):
#with open('static/favicon.ico','rb') as img:
# img=base64.b64encode(img.read())
shop_message = Shop(
user_id=str(fake.random_number(20)),
shop_name=fake.company(),
shop_info=fake.paragraph(3),
shop_delivery_fee=fake.random_int(min=0, max=5),
shop_rate=fake.random_int(),
shop_rate_number=fake.random_int(),
shop_balance=fake.random_number(),
shop_contact=fake.phone_number(),
shop_location=fake.street_address(),
shop_location_detail=fake.address(),
shop_license_number=str(fake.random_number(9)),
shop_status=random.choice(status),
# add avatar at the last step
#shop_avatar = img
)
db.session.add(shop_message)
shop_message = Shop(
user_id=str(fake.random_number(20)),
shop_name="兰小花",
shop_info="卖牛肉面的",
shop_delivery_fee=fake.random_int(min=0, max=5),
shop_rate=fake.random_int(),
shop_rate_number=fake.random_int(),
shop_balance=fake.random_number(),
shop_contact=fake.phone_number(),
shop_location="潘多拉",
shop_location_detail="学生活动中心一楼潘多拉美食广场",
shop_license_number=str(fake.random_number(9)),
shop_status="正常营业",
# add avatar at the last step
#shop_avatar = img
)
db.session.add(shop_message)
product_message = Product(
product_name="兰小花牛肉面",
# product_avatar =
product_info="一碗牛肉面",
product_price=14,
total_sale=100)
db.session.add(product_message)
product_message.shop = shop_message
db.session.commit()
click.echo('Created %d fake messages.' % count)
def valueset(self, nbvalues, step):
"""
Generate the values
"""
values = []
f = Faker()
for i in range(nbvalues):
values.append({"company": 3,
"name": f.name()[:300],
"street_address": f.street_address()[:300],
"email": "{}-{}".format(step,f.email()),
"value": f.random_number() + step,
"vali": f.random_number() + step,
"country": f.country()[:100],
"latitude": f.latitude(),
"longitude": f.longitude(),
"city": f.city()[:50],
"city_suffix": f.city_suffix()[:20],
"locale": f.locale()[:8],
})
return values
def generateRandomData():
fake = Faker()
d = dict()
name = fake.name()
names = name.split(" ")
d['firstname'] = names[0]
d['lastname'] = names[1]
d['email'] = fake.email()
d['address'] = fake.street_address()
d['city'] = fake.city()
d['state'] = fake.state()
d['postcode'] = fake.postcode()
d['mobile'] = fake.random_number(digits=10, fix_len=False)
return d
def valueset(self, nbvalues, step):
"""
Generate the values
"""
values = []
f = Faker()
for i in range(nbvalues):
values.append({"name": f.name(),
"datetms": f.latitude(),
"email": "{}-{}".format(step, f.email()),
"value": f.random_number() + step})
return values
def test_create_method(self):
"""
assert serializer_class can
successfully create requested users.
"""
faker = Faker()
serializer_class = RegisterVibroUserSerializer()
company = baker.make('backend.Company')
profile = faker.profile(fields=['username'])
data = {
'username': profile['username'],
'first_name': faker.first_name(),
'last_name': faker.last_name(),
'email': faker.email(),
'company': company,
'password': faker.text,
'phone': faker.random_number(),
'ext': faker.random_number(),
'celphone': faker.random_number(),
}
user = serializer_class.create(data)
instance = VibroUser.objects.filter(id=user.id)
self.assertTrue(instance.exists())
def test_users(n=50):
fake = Faker(locale='de_DE')
fake.seed(42)
users = []
for i in xrange(n):
u = User()
u.first_name = fake.first_name()
u.last_name = fake.last_name()
u.email_address = fake.email()
u.password = u.original_password = fake.password()
u.tracking_key = fake.random_number(digits=6)
users.append(u)
return users
def test_parse_extracts_integer_properties(faker: Faker, string: str,
attribute: str) -> None:
"""Test parsing of properties that are integers."""
description = faker.sentence()
value = faker.random_number()
task_arguments = [
description,
f"{string}:{value}",
]
result = _parse_changes(task_arguments)
assert result.task_attributes == {
"description": description,
attribute: value
}
def test_users(n=50):
fake = Faker(locale='de_DE')
fake.seed(42)
users = []
for i in xrange(n):
u = User()
u.first_name = fake.first_name()
u.last_name = fake.last_name()
u.email_address = fake.email()
u.password = u.original_password = fake.password()
u.tracking_key = fake.random_number(digits=6)
users.append(u)
return users
def generate():
DRINKER_AGE_MIN = 21
DRINKER_AGE_MAX = 60
fake = Faker()
is_male = True if random.randint(0, 1) == 0 else False
name = names.get_full_name(gender=('male' if is_male else 'female'))
addr = fake.street_address()
city = cities.get_random()
gender = 'M' if is_male else 'F'
phone = fake.random_number(digits=10)
age = random.randint(DRINKER_AGE_MIN, DRINKER_AGE_MAX)
drinker = Drinker(name, addr, city, gender, phone, age)
return drinker
def get_or_create_db_record(request):
fake_data = Faker()
for i in range(5):
ename = fake_data.name()
eid = fake_data.random_number(5)
e_department = 'information Technology'
e_post = fake_data.random_element(
elements=('Software Engineer', 'Python Developer',
'Python Full Stack developer'))
e_address = fake_data.random_element(elements=('kandivali', 'Borivali',
'Malad', 'Chembur',
'Uttarpradesh'))
emp_records = Employee.objects.get_or_create(ename=ename,
eid=eid,
e_department=e_department,
e_post=e_post,
e_address=e_address)
return HttpResponse()
from faker import Faker
fake = Faker()
for x in range(30):
first = fake.first_name()
last = fake.last_name()
name_string = "{}, {} X.".format(last, first)
email = "{}.{}@arl.org".format(first, last)
print(
"INSERT INTO F15A4_emp(employee_name, email, phone, status_effective_date, active, is_sys_admin, is_lab_dir, is_chair, is_exec_dir, F15A4_lab_lab_id, F15A4_auth_auth_id) VALUES('{}', '{}', '{}', TO_DATE('{}','YYYY-MM-DD HH24:MI:SS'));".format(
name_string,
email,
fake.random_number(digits=10),
fake.date_time_this_year(before_now=True, after_now=False),
)
)