def generate_users():
from faker import Faker
fake = Faker()
for _ in range(50):
user = User.objects.create_user(username=fake.user_name(),password='******',email=fake.email())
user.save()
print(user)
def create_data(seed=4000, tweets=10, comments=10):
fake = Faker('es_MX')
Faker.seed(seed)
tweets_dic = []
for _ in range(tweets):
comments_dic = []
for _ in range(comments):
comments_dic.append({
'contenido': fake.text(50),
'autor': fake.user_name(),
'fecha_comentario': fake.date_time()
})
tweets_dic.append({
'fecha_publicacion': fake.date_time(),
'contenido': fake.text(50),
'likes': fake.random_int(max=100),
'retwits': fake.random_int(max=100),
'comentarios': comments_dic
})
return {
'usuario': fake.user_name(),
'nombre': fake.name(),
'direccion': fake.address(),
'email': fake.email(),
'descripcion': fake.text(50),
'foto_perfil': fake.file_name(extension='jpg'),
'tweets': tweets_dic
}
class TestProjectView(TestCase):
def setUp(self):
self.fake = Faker() # Generate fake data using a faker generator
self.factory = RequestFactory()
self.project_category = ProjectCategory.objects.create(pk=1)
self.first_user = User.objects.create_user(
pk=1,
username=self.fake.user_name(),
password=self.fake.password())
self.second_user = User.objects.create_user(
pk=2,
username=self.fake.user_name(),
password=self.fake.password())
self.profile = Profile.objects.get(user=self.first_user)
self.project = Project.objects.create(pk=1,
user=self.profile,
category=self.project_category)
self.task = Task.objects.create(project=self.project)
self.task_offer = TaskOffer(task=self.task, offerer=self.profile)
self.task_offer.save()
def test_offer_response(self):
request = self.factory.post(
PROJECTS_ALL, {
'offer_response': '',
'taskofferid': 1,
'status': 'a',
'feedback': self.fake.sentence(nb_words=10)
})
request.user = self.first_user
response = project_view.project_view(request, 1)
self.assertEqual(response.status_code, 200)
def test_status_change(self):
request = self.factory.post(PROJECTS_ALL, {
'status_change': '',
'status': self.project.status
})
request.user = self.first_user
response = project_view.project_view(request, 1)
self.assertEqual(response.status_code, 200)
def test_offer_submit(self):
request = self.factory.post(
PROJECTS_ALL, {
'offer_submit': '',
'title': self.fake.sentence(nb_words=3),
'description': self.fake.sentence(nb_words=5),
'price': self.fake.random_int(min=10, max=100000, step=10),
'taskvalue': 1
})
request.user = self.second_user
response = project_view.project_view(request, 1)
self.assertEqual(response.status_code, 200)
def setUp(self):
fake = Faker() # Generate fake data using a faker generator
self.project_category = ProjectCategory.objects.create(pk=1)
self.first_user = User.objects.create_user(pk=1,
username=fake.user_name(),
password=fake.password())
self.second_user = User.objects.create_user(pk=2,
username=fake.user_name(),
password=fake.password())
self.first_profile = Profile.objects.get(user=self.first_user)
self.second_profile = Profile.objects.get(user=self.second_user)
self.project = Project.objects.create(pk=1,
user=self.first_profile,
category=self.project_category)
self.first_task = Task.objects.create(project=self.project)
self.second_task = Task.objects.create(project=self.project)
self.task_offer = TaskOffer.objects.create(task=self.second_task,
offerer=self.second_profile,
status='a')
class AccountUrlDataGetter:
ADMIN_DATA = {
"username": "******",
"email": "*****@*****.**",
"first_name": "admin_name",
"last_name": "admin_lastname",
"is_superuser": True,
"password": "******",
"password_confirmation": "admin1234admin",
}
def init_account_data_url(self):
self.faker = Faker()
self.register_view = reverse(views.RegisterView.name)
self.login_url = reverse(login_view_name)
self.logout_url = reverse(logout_view_name)
self.user_url = reverse(user_view_name)
self.profile_url = reverse(views.ProfileDetailView.name)
self.user_list_url = reverse(views.UserList.name)
def get_random_new_user_data(self):
new_user_data = {
"username": self.faker.user_name(),
"first_name": self.faker.first_name(),
"last_name": self.faker.last_name(),
"email": self.faker.safe_email(),
"password": "******",
"password_confirmation": "admin1234admin"
}
return new_user_data
def get_user_data(self):
user_data = {
"username": self.faker.user_name(),
"first_name": self.faker.first_name(),
"last_name": self.faker.last_name()
}
return user_data
def get_random_profile_data(self):
profile_data = {
"tice": "".join([str(random.randint(0, 9)) for i in range(10)]),
"cellphone":
"".join([str(random.randint(0, 9)) for i in range(9)]),
"age": random.randint(20, 70),
"date_of_birth": str(self.faker.date_this_year()),
}
return profile_data
def create_users(self):
users = []
faker = Faker()
for i in range(USER_COUNT):
user = Profile(username=faker.user_name(),
nickname=faker.user_name(),
password='******'.format(i),
email=faker.email())
users.append(user)
Profile.objects.bulk_create(users, batch_size=10000)
def create_profiles():
profiles = []
faker = Faker()
for i in range(USER_COUNT):
profile = Profile(username=faker.user_name(),
email=faker.email(),
nickname=faker.user_name(),
avatar_path="https://gamepedia.cursecdn.com/stalker_ru_gamepedia/thumb/f/f5/Vano_face.jpg"
"/300px-Vano_face.jpg?version=76de5b552f817c469f5f7a1d5dee6c6e")
profile.set_password(faker.word())
profiles.append(profile)
Profile.objects.bulk_create(profiles)
class TestRegistrationService(TestCase):
def setUp(self):
self.faker = Faker()
def test_payload_invalid_email(self):
payload = {
'username': self.faker.user_name(),
'email': 'test',
'password': self.faker.word(),
'password_confirm': self.faker.word()
}
form = RegistrationForm(payload)
registration = RegistrationService(payload, form)
with self.assertRaises(ServiceValidationError) as exc:
registration.validate()
def test_payload_not_match_password(self):
payload = {
'username': self.faker.user_name(),
'email': self.faker.free_email(),
'password': self.faker.word(),
'password_confirm': self.faker.word()
}
form = RegistrationForm(payload)
registration = RegistrationService(payload, form)
with self.assertRaises(ServiceValidationError) as exc:
registration.validate()
def test_registration_success(self):
password = self.faker.word()
email = self.faker.free_email()
payload = {
'username': self.faker.user_name(),
'email': email,
'password': password,
'password_confirm': password
}
form = RegistrationForm(payload)
registration = RegistrationService(payload, form)
member = registration.validate().call()
self.assertEqual(member.user.email, email)
self.assertFalse(member.user.is_active)
self.assertIsNotNone(member.activation_code)
class TestUploadFile(TestCase):
def setUp(self):
self.fake = Faker() # Generate fake data using a faker generator
self.factory = RequestFactory()
self.project_category = ProjectCategory.objects.create(pk=1)
# Firs user is project owner and second user creates offer
self.first_user = User.objects.create_user(
pk=1,
username=self.fake.user_name(),
password=self.fake.password())
self.second_user = User.objects.create_user(
pk=2,
username=self.fake.user_name(),
password=self.fake.password())
self.first_profile = Profile.objects.get(user=self.first_user)
self.second_profile = Profile.objects.get(user=self.second_user)
self.project = Project.objects.create(pk=1,
user=self.first_profile,
category=self.project_category)
self.first_task = Task.objects.create(project=self.project)
self.first_task_offer = TaskOffer(task=self.first_task,
offerer=self.second_profile,
status='a')
self.first_task_offer.save()
self.delivery = Delivery.objects.create(
task=self.first_task, delivery_user=self.second_profile)
def test_upload_file(self):
f = open("projects/tests/demofile.txt", "r")
request = self.factory.post(
'/projects/' + str(self.project.id) + '/tasks/' +
str(self.first_task.id) + '/upload/', {'file': f})
request.user = self.first_user
upload_file_to_task(request, self.project.id, self.first_task.id)
db_file = None
try:
db_delivery = TaskFile.objects.get(task=self.first_task)
db_file = db_delivery.file
except:
pass
self.assertEquals(
db_file, "static/uploads/tasks/" + str(self.first_task.id) +
"/demofile.txt")
def load_fake_data():
'''Create some fake users and statuses'''
# It is encouraged to import only where needed!
from faker import Faker
import random
fake = Faker()
# Need to clear existing data!
Favorite.objects.all().delete()
Status.objects.all().delete()
User.objects.exclude(username='******').delete()
users = []
for _ in range(50):
new_user = User(username=fake.user_name(),
email=fake.email(),
password=fake.password())
new_user.save()
users.append(new_user)
statuses = []
for _ in range(1000):
new_status = Status(user=random.choice(users),
posted_at=fake.date_time_this_year(),
text=fake.text(max_nb_chars=141))
new_status.save()
statuses.append(new_status)
for _ in range(4000):
favorite = Favorite(user=random.choice(users),
status=random.choice(statuses))
favorite.save()
def _generate_fake_users(self):
FAKER = Faker('it_IT')
_users = {}
for idx, _ in enumerate(range(10)):
_is_even = (idx % 2 == 0)
name = FAKER.first_name_male() if _is_even \
else FAKER.first_name_female()
lastname = FAKER.last_name_male() if _is_even \
else FAKER.last_name_female()
fiscal_number = exrex.getone(
r'[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]')
_users[FAKER.user_name() if idx > 0 else 'test'] = {
'attrs': {
'spidCode': FAKER.uuid4(),
'name': name,
'familyName': lastname,
'gender': 'M' if _is_even else 'F',
'dateOfBirth': FAKER.date(),
'companyName': FAKER.company(),
'registeredOffice': FAKER.address(),
'fiscalNumber': 'TINIT-{}'.format(fiscal_number),
'email': FAKER.email()
},
'pwd': 'test',
'sp': None
}
return _users
class ModelTestCase(TestCase):
"""Class defines test suite for our model"""
def setUp(self):
self.fake = Faker()
user = User.objects.create(username=self.fake.user_name())
self.first_name = self.fake.first_name()
self.last_name = self.fake.last_name()
self.email = self.fake.email()
self.user_data = UserModel(
owner=user,
first_name=self.first_name,
last_name=self.last_name,
email=self.email,
)
def test_model_can_create_user_table_in_db(self):
old_count = UserModel.objects.count()
self.user_data.save()
new_count = UserModel.objects.count()
self.assertNotEqual(old_count, new_count)
def test_model_can_create_account_details_table(self):
pass
def test_model_can_create__table_in_db(self):
pass
def fake_broadcast():
"""
Broadcast fake events (useful for testing).
:return: None
"""
fake = Faker()
while True:
random_types = ('tweet', 'retweet', 'favorite')
random_tweet = fake.text(max_nb_chars=140)
data = {
'created_at': str(datetime.datetime.now(pytz.utc)),
'type': random.choice(random_types),
'tweet': random_tweet,
'user': fake.user_name()
}
faye_protocol = {
'channel': '/cats',
'data': data,
'ext': {
'pushToken': BROADCAST_PUSH_TOKEN
}
}
broadcast_message.delay(BROADCAST_INTERNAL_URL, faye_protocol)
logging.info(data)
sleep(1)
return None
def populate_db(num_users=5):
"""
Fills the database with fake data.
"""
from app.user.models import User
fake = Faker()
admin_username = '******'
admin_email = '*****@*****.**'
admin_password = '******'
users = []
for _ in range(int(num_users)):
users.append(
User(fake.user_name(), fake.email(),
fake.word() + fake.word(), fake.ipv4()))
users.append(
User(admin_username,
admin_email,
admin_password,
fake.ipv4(),
active=True,
is_admin=True))
for user in users:
db.session.add(user)
db.session.commit()
class TestAcceptedTaskOffer(TestCase):
def setUp(self):
self.fake = Faker() # Generate fake data using a faker generator
self.project_category = ProjectCategory.objects.create(pk=1)
self.user = User.objects.create_user(pk=1,
username=self.fake.user_name(),
password=self.fake.password())
self.profile = Profile.objects.get(user=self.user)
self.project = Project.objects.create(pk=1,
user=self.profile,
category=self.project_category)
self.task = Task.objects.create(project=self.project)
self.accepted_offer = TaskOffer.objects.create(task=self.task,
offerer=self.profile,
status='a')
# Check that accepted offer returned from accepted_task_offer is equal to task created in set up
def test_accepted_task_offer(self):
accepted_offer = self.task.accepted_task_offer()
self.assertEqual(accepted_offer, self.accepted_offer)
def gen_fake_header():
fake = Faker()
header = {}
header['X-Forwarded-User'] = fake.user_name()
header['user_agent'] = fake.user_agent()
header['X-Forwarded-For'] = fake.ipv4()
return header
def faker_info(gender,age):
fake = Faker()
if gender == "male" :
print("\n\t\tM. " + fake.name_male())
else :
print("\n\t\tMs. " + fake.name_female())
a = fake.profile(fields="residence,blood_group")
print(
"Personnal info : ",
"\n\tUsername :"******"\n\tBirthdate : " + str(fake.date_of_birth(tzinfo=None, minimum_age=age, maximum_age=age)),
"\n\tBlood group : " + a["blood_group"],
"\n\tNationality : " + fake.bank_country(),
"\n\tAddress : " + a["residence"],
"\n\tSSN : " + fake.ssn(),
"\n\tLicense plate : " + fake.license_plate(),
"\nWork : ",
"\n\tCompany : " + fake.company() + " " + fake.company_suffix(),
"\n\tJob : " + fake.job(),
"\nBanking : ",
"\n\t" + fake.credit_card_provider(card_type=None),
":\n\t" + fake.credit_card_number(card_type=None),
"\n\t" + fake.credit_card_expire(start="now", end="+10y", date_format="%m/%y"),
"\t" + fake.credit_card_security_code(card_type=None),
"\n\tBBAN : " + fake.bban(),
"\n\tIBAN : " + fake.iban(),
)
def create_fake_users(db, nb_users=50, fake=None):
from app.models import User
from app.models import UserRole
from app.models import Whitelist
if fake is None:
fake = Faker()
#logging.getLogger('faker.factory').setLevel(logging.ERROR)
wl1 = Whitelist(label=fake.word())
admin = UserRole(label=fake.word())
contributor = UserRole(label=fake.word())
db.session.add(wl1)
db.session.add(admin)
db.session.add(contributor)
db.session.commit()
roles = [admin, contributor]
whitelists = [wl1]
for i in range(0, nb_users):
u1 = User(username=fake.user_name(),
password=fake.user_name(),
email=fake.free_email(),
active=1,
first_name=fake.first_name(),
last_name=fake.last_name())
u1.role = roles[1]
u1.whitelists = whitelists
db.session.add(u1)
db.session.commit()
def obtenerResultadosUsuarios(numeroPersonas = 9):
usuarios = []
fake = Faker()
for i in range(numeroPersonas):
usuarios.append("@"+fake.user_name())
return usuarios
def __init__(self):
f = Faker('zh_CN')
self.nickname = f.user_name()
self.name = f.name()
self.sex = f.random_int(min=1, max=2)
self.address = f.street_address()
self.province = f.province()
self.city = f.city_suffix()
self.country = f.country()
self.wxunionid = f.isbn10()
self.memtype = f.random_int(min=0, max=4)
self.mobile = f.phone_number()
self.email = f.email()
self.birthday = f.date()
self.education = f.word()
self.industry = f.word()
self.background = f.word()
self.changetime = f.date_time()
self.createtime = f.date_time()
self.emailVerified = f.random_int(min=0, max=1)
self.lastloginip = f.ipv4()
self.lastdevice = f.word()
self.lastlogintime = f.date_time()
self.balance = f.pyfloat(left_digits=4, right_digits=2, positive=True)
self.school_id = f.random_digit()
self.inviter_id = f.random_digit()
self.status = f.random_int(min=0, max=1)
"""
def populate_db(num_users):
"""Populates the database with seed data."""
fake = Faker()
users = []
for _ in range(num_users):
users.append(
User(
username=fake.user_name(),
email=fake.email(),
password=fake.word() + fake.word(),
remote_addr=fake.ipv4()
)
)
users.append(
User(
username='******',
email='*****@*****.**',
password='******',
remote_addr=fake.ipv4(),
active=True,
is_admin=True
)
)
for user in users:
db.session.add(user)
db.session.commit()
class ApacheLog(Log):
def __init__(self, timestamp):
Log.__init__(self)
self._fake = Faker('en_US')
self._fake.add_provider(WebProvider)
self._ipv4 = self._fake.ipv4_public()
#_faketime = _fake.date_time_between_dates(datetime_start=None, datetime_end=None, tzinfo=None)
#logdate = LogLine.faketime + timedelta(seconds=randint(0, 50000))
#LogLine.faketime = logdate
#tz
self._timestamp = timestamp
self._useragent = self._fake.user_agent()
self._uri_path = self._fake.uri_path(deep=2)
self._uri_page = self._fake.uri_page()
self._uri_extension = self._fake.uri_extension()
self._endpoint = choice(["/uploads/" + self._fake.file_name(), "/"\
+ self._uri_path + "/" + self._uri_page + self._uri_extension])
self._user = self._makeUser(self._fake.user_name())
if not timestamp:
self._faketime = self._fake.date_time_between_dates(datetime_start=datetime.now() - timedelta(days=15), datetime_end=datetime.now(), tzinfo=None)
else:
print("This is the timestamp:", self._timestamp)
try:
self._faketime = self._fake.date_time_between_dates(datetime_start=self._timestamp, datetime_end=datetime.now(), tzinfo=None)
except ValueError:
pass
self._logtime = self._faketime + timedelta(seconds=randint(0, 360))
def _makeUser(self, uname):
return choice(["-", uname])
def test_sponsors_case4(self):
faker = Faker()
# 创建保健方账号
staff_api = SponsorsManagermentApi()
staff_token = get_admin_token()
set_login_status(staff_api, staff_token)
sponsor = {
"account": get_random_name(6, 25),
"password": faker.password(),
"name": faker.user_name(),
"email": faker.email(),
"phone": faker.phone_number()
}
staff_api.staff_sponsors_post(post_sponsor=sponsor)
# 管理后台获取保健列表
res = staff_api.staff_sponsors_get(page=1, name=sponsor.get("name"))
sponsor_id = ''
assert res.meta.total_count == 1
for item in res.items:
assert item.account == sponsor.get("account")
assert item.email == sponsor.get("email")
assert item.name == sponsor.get("name")
assert item.status is True
sponsor_id = item.id
# 修改保荐方状态
payload = {'id': sponsor_id, 'status': False}
staff_api.staff_sponsor_status_put(put_sponsor_status=payload)
# 获取保荐方列表
res = staff_api.staff_sponsors_get(page=1)
for item in res.items:
if item.name == sponsor.get("name"):
assert item.account == sponsor.get("account")
assert item.email == sponsor.get("email")
assert item.status is False
assert item.id
def LG_04(driver):
# Logowanie do konta, błędny login, poprawne hasło.
wait = WebDriverWait(driver, 3)
fake = Faker('pl_PL')
haslo_moje = "jankowalski"
driver.get('http://kmg.hcm.pl/testowanie/')
login = driver.find_element_by_id('userLogin')
login.send_keys(fake.user_name())
haslo = driver.find_element_by_id('passwordLogin')
haslo.send_keys(haslo_moje)
driver.execute_script(
"element = document.querySelector('#login'); element.click()")
try:
wait.until(EC.alert_is_present())
print(" pozytywnym.")
except TimeoutException:
print(" negatywnym.")
driver.quit()
def load_raters():
from faker import Faker
import random
fake = Faker()
raters = []
with open('ratingsdb/data/users.dat') as f:
reader = csv.DictReader([line.replace('::', '\t') for line in f],
fieldnames=['UserID', 'Gender', 'Age',
'Occupation', 'Zip-code'],
delimiter='\t')
for line in reader:
User.objects.create_user(username=fake.user_name() +
str(random.randint(100, 999)),
email=fake.email(),
password='******',
pk=int(line['UserID']))
rater = {
'fields': {
'gender': line['Gender'],
'age': line['Age'],
'occupation': line['Occupation'],
'zipcode': line['Zip-code']
},
'model': 'ratingsdb.Rater',
'pk': int(line['UserID'])
}
raters.append(rater)
with open('ratingsdb/fixtures/raters.json', 'w') as f:
f.write(json.dumps(raters))
def forge(count):
"""随机生成虚拟用户及文章."""
from random import randint
from sqlalchemy.exc import IntegrityError
from faker import Faker
fake = Faker('zh-CN')
click.echo('准备生成随机虚拟数据...')
i = 0
while i < count:
u = User(email=fake.email(),
username=fake.user_name(),
password='******',
confirmed=True,
name=fake.name(),
location=fake.city(),
about_me=fake.text(),
member_since=fake.past_date())
db.session.add(u)
try:
db.session.commit()
i += 1
User.add_self_follows()
except IntegrityError:
db.session.rollback()
click.echo('创建 %d 个用户完毕.' % count)
user_count = User.query.count()
for i in range(count):
u = User.query.offset(randint(0, user_count - 1)).first()
p = Post(body=fake.text(), timestamp=fake.past_date(), author=u)
db.session.add(p)
db.session.commit()
click.echo('创建 %d 条信息完毕.' % count)
class Utils:
def __init__(self):
with open(_pwd +
"overworld\\frontend\\src\\tests\\data\\config\\config.json"
) as json_file:
self.config_data = json.load(json_file)
self.fake = Faker()
def set_webdriver(self, driver):
driver = driver.lower()
if driver == "chromedriver":
driver_instance = webdriver.Chrome(
self.config_data["chromedriver_path"])
driver_instance.implicitly_wait(
self.config_data["implicit_wait_timeout"])
return driver_instance
def close_webdriver(self, driver):
driver.close()
def get_config_data(self):
return self.config_data
def get_test_data(self, test_data_name, test_env):
with open(_pwd + "overworld\\frontend\\src\\tests\\data\\test_data\\" +
test_data_name + ".json") as json_file:
return json.load(json_file)[test_env]
def generate_test_email(self, domain=None):
return self.fake.email(domain)
def generate_test_username(self):
return self.fake.user_name()
def fake_broadcast():
"""
Broadcast fake events (useful for testing).
:return: None
"""
fake = Faker()
while True:
random_types = ('tweet', 'retweet', 'favorite')
random_tweet = fake.text(max_nb_chars=140)
data = {
'created_at': str(datetime.datetime.now(pytz.utc)),
'type': random.choice(random_types),
'tweet': random_tweet,
'user': fake.user_name()
}
faye_protocol = {
'channel': '/cats',
'data': data,
'ext': {
'pushToken': BROADCAST_PUSH_TOKEN
}
}
broadcast_message.delay(BROADCAST_INTERNAL_URL, faye_protocol)
logging.info(data)
sleep(1)
return None
def setUp(self):
fake = Faker() # Generate fake data using a faker generator
self.above_max_username = FuzzyText(length=151)
self.below_max_username = FuzzyText(length=150)
self.normal_username = fake.user_name()
self.above_max_email = FuzzyText(length=245, suffix="@gmail.com")
self.below_max_email = FuzzyText(length=244, suffix="@gmail.com")
self.above_min_email = FuzzyText(length=1, suffix="@gmail.com")
self.below_min_email = FuzzyText(length=1)
self.normal_email = fake.email()
self.above_min_password = FuzzyText(length=8)
self.below_min_password = FuzzyText(length=7)
self.normal_password = fake.password()
self.above_max_50 = FuzzyText(length=51)
self.below_max_50 = FuzzyText(length=50)
self.above_max_30 = FuzzyText(length=31)
self.below_max_30 = FuzzyText(length=30)
self.normal = FuzzyText(length=20)
self.above_min = FuzzyText(length=1)
self.below_min = ""
self.categories = [ProjectCategory.objects.create(pk=1),
ProjectCategory.objects.create(pk=2), ProjectCategory.objects.create(pk=3)]
self.above_min_categories = [ProjectCategory.objects.create(pk=4)]
self.below_min_categories = []
def test_service_form__basic__correct():
fake = Faker()
form = ServiceForm(data={"owner": fake.user_name(), "name": fake.word()})
assert form.is_valid()
new_service = form.save()
assert Service.objects.filter(id=new_service.id).exists()
class TestJaJP(unittest.TestCase):
""" Tests internet in the ja_JP locale """
def setUp(self):
self.factory = Faker('ja')
def test_internet(self):
names = JaProvider.last_romanized_names
domain_word = self.factory.domain_word()
self.assertIsInstance(domain_word, six.string_types)
assert any(domain_word == text.slugify(name) for name in names)
domain_name = self.factory.domain_name()
deep_domain_name = self.factory.domain_name(3)
self.assertIsInstance(domain_name, six.string_types)
self.assertIsInstance(deep_domain_name, six.string_types)
assert deep_domain_name.count('.') == 3
with pytest.raises(ValueError):
self.factory.domain_name(-1)
user_name = self.factory.user_name()
self.assertIsInstance(user_name, six.string_types)
tld = self.factory.tld()
self.assertIsInstance(tld, six.string_types)
class TestWework:
def setup_class(self):
corpid = "XXXXXXXXXXXXXXXXXXXXXXXXX"
contact_corpsecret = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
self.fake = Faker(locale='zh_CN')
self.wework = User_API()
self.wework.get_access_token(corpid,contact_corpsecret)
self.department = department_API()
self.department.get_access_token(corpid,contact_corpsecret)
def test_Adduesr(self):
userid = self.fake.user_name()
name = self.fake.name()
mobile = "+86 "+ self.fake.phone_number()
department =[self.department.get_department().json()['department'][-1]['id']]
email = self.fake.ascii_company_email()
print(f"userid:{userid},name:{name},mobile:{mobile},department:{department},email:{email}")
e = self.wework.create_User(userid,name,mobile,department=[4],email=email)
print(e.json())
assert e.json()["errcode"] == 0
def test_delUser(self):
print(self.department.get_department().json())
userid = self.department.get_department_uesr().json()["userlist"][0]["userid"]
print(userid)
a = self.wework.del_User(userid)
assert a.json()["errcode"] == 0
assert userid not in json.dumps(self.department.get_department_uesr().json(), indent=2, ensure_ascii=False)
class TestJaJP(unittest.TestCase):
""" Tests internet in the ja_JP locale """
def setUp(self):
self.factory = Faker('ja')
def test_internet(self):
names = JaProvider.last_romanized_names
domain_word = self.factory.domain_word()
self.assertIsInstance(domain_word, six.string_types)
assert any(domain_word == text.slugify(name) for name in names)
domain_name = self.factory.domain_name()
deep_domain_name = self.factory.domain_name(3)
self.assertIsInstance(domain_name, six.string_types)
self.assertIsInstance(deep_domain_name, six.string_types)
assert deep_domain_name.count('.') == 3
with pytest.raises(ValueError):
self.factory.domain_name(-1)
user_name = self.factory.user_name()
self.assertIsInstance(user_name, six.string_types)
tld = self.factory.tld()
self.assertIsInstance(tld, six.string_types)
def users(count=100):
fake=Faker()
i = 0
while i < count:
u = User(
email = fake.email(),
username = fake.user_name(),
password = '******',
confirmed = True,
name = fake.name(),
location = fake.city(),
about_me = fake.text(),
member_since = fake.past_date()
)
db.session.add(u)
try:
db.session.commit()
i += 1
# This will be raised if there is a field generated with duplicate values
# and the field has the unique=True tag in it.
# This is normally caught in the form by validating the username and
# password, but needs it here since you're essentially working in the
# terminal.
except IntegrityError:
# This clears the db commit()
db.session.rollback()
def main():
f = Faker(locale='zh_CN')
print("Generating information:")
print("Name: " + f.name())
print("Birthdate: " + f.profile()['birthdate'])
print("E-mail: " + f.email())
print("Phone: " + f.phone_number())
print("Blood: " + f.profile()['blood_group'])
print("Address: " + f.address())
print("Website: " + f.uri())
print("Username: "******"Password: "******"Company: " + f.company())
print("Job: " + f.job())
print("Credit Card: \n" + f.credit_card_full(card_type=None), end='')
print("ISBN: " + f.isbn13(separator="-"))
print("IPv4: " + f.ipv4_public(network=False, address_class=None))
print("IPv6: " + f.ipv6())
print("UUID: " + f.uuid4())
print("Win Token: " + f.windows_platform_token())
print("Linux Token: " + f.linux_platform_token())
print(
"Chrome Agent: " +
f.chrome(version_from=13, version_to=63, build_from=800, build_to=899))
print("Firefox Agent: " + f.firefox())
def load_users():
"""Load users generated with Faker into database."""
print("Users")
# Delete all rows in table, so if we need to run this a second time,
# we won't be trying to add duplicate users
User.query.delete()
# Create new users with Faker
for i, person in enumerate(range(0, 30)):
faker = Faker()
email = faker.email()
username = faker.user_name()
password = faker.password(length=choice(range(10, 16)), special_chars=False, digits=True, upper_case=True, lower_case=True)
user = User(email=email,
username=username,
password=password)
# Hashes generated password before a user is saved/committed to the db
user.create_passhash(password)
# Add to session and commit
user.save()
# Progess yay!
if i % 10 == 0:
print(i)
def create_users():
fake = Faker()
for rater in Rater.objects.all():
if rater.user is None:
rater.user = User.objects.create_user(username=fake.user_name()+str(random.randint(1, 999)),
email= fake.email(),
password='******')
rater.save()
print(rater.user.username)
def generate_users():
from faker import Faker
fake = Faker()
user_list = [x for x in {fake.user_name() for _ in range(9000)}]
count = 0
for _ in range(100):
user = User.objects.create_user(user_list[count],password='******',email=fake.email())
user.save()
count += 1
def generate_fake(count=100):
from sqlalchemy.exc import IntegrityError
from faker import Faker
fake = Faker()
for i in range(count):
u = User(phone_no=fake.numerify(text="+### ## ### ####"),
nickname=fake.user_name())
db.session.add(u)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
def handle(self, *args, **options):
# 1. Make some fake users
fake = Faker()
for _ in range(800):
while True:
fake_username = fake.user_name() + \
choice(list('0123456789'))
try:
user = User.objects.create_user(fake_username,
fake.email(),
'password')
user.save()
break
except:
continue
def handle(self, *args, **options):
fake = Faker()
for rater in Rater.objects.all():
if rater.user is None:
while True:
fake_username = fake.user_name() + \
choice(list('0123456789'))
try:
rater.user = User.objects.create_user(fake_username,
fake.email(),
'password')
rater.save()
break
except:
continue
def seed():
from app.users.models import User, Address
from faker import Faker
fake = Faker()
users = [User(username=fake.user_name(), name=fake.name(),
email=fake.email(), password='******') for i in range(20)]
db.session.add_all(users)
db.session.commit()
addresses = []
for user in users:
address = Address()
address.user = user
address.address = fake.address()
addresses.append(address)
db.session.add_all(addresses)
db.session.commit()
def handle(self, *args, **options):
"""Create fake users and statuses for Mowdie."""
from faker import Faker
import random
from django.conf import settings
from PyMarkovTextGenerator import Markov
fake = Faker()
textgen = Markov(prob=True, level=3)
with open(settings.BASE_DIR + "/../john_carter.txt") as file:
textgen.parse(file.read())
def update_text():
return textgen.generate(
startf=lambda db: random.choice([x for x in db if x[0][0].isupper()]), endf=lambda s: len(s) > 120
)
Favorite.objects.all().delete()
Update.objects.all().delete()
User.objects.all().delete()
users = []
for _ in range(20):
user = User(username=fake.user_name(), email=fake.email())
user.set_password("password")
user.save()
Profile(user=user).save()
users.append(user)
user = User(username="******", email="*****@*****.**", is_staff=True, is_superuser=True)
user.set_password("password")
user.save()
Profile(user=user).save()
updates = []
for _ in range(100):
update = Update(
text=update_text(), posted_at=make_aware(fake.date_time_this_year()), user=random.choice(users)
)
update.save()
updates.append(update)
combos = random.sample([(user, update) for user in users for update in updates], 200)
for user, update in combos:
favorite = Favorite(user=user, update=update)
favorite.save()
def users(count=100):
fake = Faker()
i = 0
while i < count:
u = User(email=fake.email(),
username=fake.user_name(),
password='******',
confirmed=True,
name=fake.name(),
location=fake.city(),
about_me=fake.text(),
member_since=fake.past_date())
db.session.add(u)
try:
db.session.commit()
i += 1
except IntegrityError:
db.session.rollback()
def load_rater_data():
import csv
import json
from faker import Faker
count = 1
fake = Faker()
User.objects.all().delete()
'''
from reviews.models import *
load_rater_data()
'''
raters = []
with open('ml-1m/users.dat', encoding='Windows-1252') as f:
reader = csv.DictReader([line.replace('::', '\t') for line in f],
fieldnames='UserID::Gender::Age::Occupation::Zip-code'.split(
'::'),
delimiter='\t')
user_set = {fake.user_name() for _ in range(8000)}
user_list = [x for x in user_set]
for row in reader:
print('Reading row: {}'.format(count))
auth_user = User(username=user_list[count],
email=fake.email(),
password='******',
pk=row['UserID'])
rater = {
'fields': {
'gender': row['Gender'],
'age': row['Age'],
'occupation': row['Occupation'],
'zipcode': row['Zip-code'],
},
'model': 'reviews.Rater',
'pk': auth_user.pk
}
raters.append(rater)
auth_user.save()
count += 1
with open('raters.json', 'w') as f: # place to dump/put the rater data
f.write(json.dumps(raters))
def generate_fake(count=10):
from faker import Faker
fake = Faker()
# fake.seed(3123)
fake_users = []
i = 0
while i < count:
user = User(
confirmed=True,
username=fake.user_name(),
email=fake.safe_email(),
api_key=make_api_key()
)
try:
user.password = fake.md5()
user.save()
fake_users.append(user)
i += 1
except:
pass
return fake_users
def create_valid_member_data():
fake = Faker('ja_JP')
data = dict()
while True:
data['name'] = random.choice([fake.name(), fake.user_name()])
if 0 < len(data['name']) <= 100:
break
email = random.choice(['b', 'c', 'e', 'm', 'd', 'h'])
email += random.choice(string.digits)
email += '1'
email += str(random.randint(0, datetime.now().year % 100)).zfill(2)
for i in range(5):
email += random.choice(string.digits)
email += '@edu.teu.ac.jp'
data['email'] = email
data['experience'] = random.choice([True, False])
return data
def get_customer_json():
faker = Faker()
billing = {
"first_name": faker.first_name(),
"last_name": faker.last_name(),
"company": "",
"address_1": faker.street_address(),
"address_2": "",
"city": faker.city(),
"state": faker.state_abbr(),
"postcode": faker.postalcode(),
"country": faker.country_code(),
"email": faker.email(),
"phone": faker.phone_number()
}
shipping = {
"first_name": billing['first_name'],
"last_name": billing['last_name'],
"company": "",
"address_1": billing['address_1'],
"address_2": "",
"city": billing['city'],
"state": billing['state'],
"postcode": billing['postcode'],
"country": billing['country']
}
data = {
"email": billing['email'],
"first_name": billing['first_name'],
"last_name": billing['last_name'],
"username": faker.user_name(),
"billing": billing,
"shipping": shipping
}
return data
def handle(self, *args, **options):
'''Create some fake users and statuses'''
fake = Faker()
Favorite.objects.all().delete()
Status.objects.all().delete()
Profile.objects.all().delete()
User.objects.all().delete()
User.objects.create_superuser(username='******', password='******', email='')
users = []
statuses = []
for _ in range(50):
new_user = User(username=fake.user_name(),
email=fake.email())
new_user.set_password('password')
new_user.save()
profile = Profile(user=new_user, favorite_color='blue')
profile.save()
users.append(new_user)
for _ in range(1000):
new_status = Status(user=random.choice(users),
posted_at=make_aware(fake.date_time_this_year()),
text=fake.text(max_nb_chars=141))
new_status.save()
statuses.append(new_status)
for _ in range(4000):
try:
favorite = Favorite(user=random.choice(users),
status=random.choice(statuses))
favorite.save()
except IntegrityError:
continue
def load_fake_data():
'''Create some fake users and statuses'''
from faker import Faker
import random
fake = Faker()
Favorite.objects.all().delete()
Status.objects.all().delete()
User.objects.exclude(username='******').delete()
users = []
statuses = []
for _ in range(50):
new_user = User(username=fake.user_name(),
email=fake.email(),
password=fake.password())
new_user.save()
users.append(new_user)
for _ in range(1000):
new_status = Status(user=random.choice(users),
posted_at=fake.date_time_this_year(),
text=fake.text(max_nb_chars=141))
new_status.save()
statuses.append(new_status)
for _ in range(4000):
try:
favorite = Favorite(user=random.choice(users),
status=random.choice(statuses))
favorite.save()
except IntegrityError:
continue
fake.name()
date_of_births = [
'1970-03-01',
'1979-04-02',
'1973-05-01',
'1985-06-03',
'2000-07-04',
'1990-08-09',
'1980-09-11',
]
# register counters
for a in range(0, 10):
counter = User.objects.create_user(
username=fake.user_name(),
email=fake.email(),
password='******',
type='counter',
latitude=fake.latitude(),
longitude=fake.longitude(),
address=fake.address(),
city=fake.city(),
mobile_number=fake.phone_number(),
date_of_birth=random.choice(date_of_births),
name=fake.name(),
)
# simulate counter top ups
balances = [800000, 700000, 500000, 1000000, 2000000, 50000, 250000]
counters = User.objects.filter(type='counter')
from webium.wait import wait
from basilisk import *
import pytest
from allure.constants import AttachmentType
import allure
import driver
from config import *
import webium.settings
from faker import Faker
webium.settings.wait_timeout = 5
fake = Faker()
url = "http://basilisk.fintegro.com/"
fname = fake.first_name()
lname = fake.last_name()
login = fake.user_name()
passw = fake.password()
email = fake.email()
univer = "Z"
promo = fake.postcode()
def test_reg_valid(webdriver):
visit(url)
driver.browser.maximize_window()
page = BasiliskPage(driver = driver.browser)
page.login_link.click()
wait(lambda: page.is_element_present('log_btn'))
page.reg_link.click()
page = RegistrationPage(driver = driver.browser)
wait(lambda: page.is_element_present('button_reg'))
class RegisteredProfile(Profile):
def __init__(self, username='', password='', profile_id=0, first_name='', last_name=''):
self.faker = Faker()
self.profile_id = profile_id
self.thumb_src = ''
self.image_src = ''
self.people_also_viewed = []
self.has_people_also_viewed = None
self.html = None
if first_name != '':
self.first_name = first_name
else:
self.first_name = self.faker.first_name()
if last_name != '':
self.last_name = last_name
else:
self.last_name = self.faker.last_name()
self.name = self.first_name + ' ' + self.last_name
if username != '':
self.username = username
else:
self.username = self.faker.user_name() + '@killbotlogic.com'
if password != '':
self.password = password
else:
self.password = self.faker.password()
if self.profile_id == 0:
self.profile_id = 0
def register(self):
req_html = request.urlopen("https://www.linkedin.com/reg/join").read()
soup = BeautifulSoup(req_html)
register_data = parse.urlencode({
'isJsEnabled': 'false',
'firstName': self.first_name,
'lastName': self.last_name,
'email': self.username,
'password': self.password,
'csrfToken': soup.find(id="csrfToken-coldRegistrationForm")['value'],
'sourceAlias': soup.find(id="sourceAlias-coldRegistrationForm")['value'],
'webmailImport': 'false',
'trcode': '',
'genie-reg': '',
'mod': '',
'key': '',
'authToken': '',
'authType': ''
})
data = register_data.encode()
time.sleep(10.3867)
response = request.urlopen("https://www.linkedin.com/reg/join-create", data)
res_html = BeautifulSoup(response.read())
Profile.dump_stuff('{}.html'.format('wtf'), str(res_html))
pass
def log_in(self):
"""
Handle login. This should populate our cookie jar.
"""
if self.is_logged_in():
return
req_html = request.urlopen("https://www.linkedin.com/uas/login").read()
soup = BeautifulSoup(req_html)
csrf = soup.find(id="loginCsrfParam-login")['value']
login_data = parse.urlencode({
'session_key': self.username,
'session_password': self.password,
'loginCsrfParam': csrf
})
data = login_data.encode()
password_manager = request.HTTPPasswordMgrWithDefaultRealm()
password_manager.add_password(None, "https://www.linkedin.com/", self.username, self.password)
Registration.opener.add_handler(request.HTTPBasicAuthHandler(password_manager))
response = request.urlopen("https://www.linkedin.com/uas/login-submit", data)
res_html = BeautifulSoup(response.read())
Registration.jar.save(Registration.cookie_filename)
return response
def is_logged_in(self):
res = request.urlopen("https://www.linkedin.com/profile/view?id=" + str(self.profile_id))
if res.geturl() == "https://www.linkedin.com/profile/view?id=" + str(self.profile_id):
return True
return False
class Command(BaseCommand):
help = 'Add fake data to the database.'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.faker = Faker()
self.faker.add_provider(UniqueUrlProvider)
def add_arguments(self, parser):
parser.add_argument(
'--seed', action='store', default=None,
help='Provide an initial seed for randomization mechanism.',
)
def fake_airports(self):
"""Add some airports."""
# we're not doing anything here, since data migrations already add some
# airports
self.stdout.write('Generating 0 fake airports...')
def fake_roles(self):
"""Provide fixed roles."""
roles = [
('helper', 'Helper'),
('instructor', 'Instructor'),
('host', 'Workshop host'),
('learner', 'Learner'),
('organizer', 'Workshop organizer'),
('contributor', 'Contributed to lesson materials')
]
self.stdout.write('Generating {} fake roles...'.format(len(roles)))
for name, verbose_name in roles:
Role.objects.get_or_create(
name=name,
defaults=dict(verbose_name=verbose_name)
)
def fake_groups(self):
"""Provide authentication groups."""
groups = ['administrators', 'invoicing', 'steering committee',
'trainers']
self.stdout.write(
'Generating {} auth groups...'.format(len(groups)))
for group in groups:
Group.objects.get_or_create(name=group)
def fake_tags(self):
"""Provide fixed tags. All other tags are pre-created through data
migrations."""
tags = [
('SWC', 'Software Carpentry Workshop'),
('DC', 'Data Carpentry Workshop'),
('LC', 'Library Carpentry Workshop'),
('WiSE', 'Women in Science and Engineering'),
('TTT', 'Train the Trainers'),
('online', 'Events taking place entirely online'),
('stalled', 'Events with lost contact with the host or TTT events'
' that aren\'t running.'),
('unresponsive', 'Events whose hosts and/or organizers aren\'t '
'going to send attendance data'),
('hackathon', 'Event is a hackathon'),
('cancelled', 'Events that were supposed to happen but due to some'
' circumstances got cancelled'),
('LSO', 'Lesson Specific Onboarding'),
('ITT', 'Instructor Trainer Training (Trainer Training)'),
('LMO', 'Lesson Maintainer Onboarding'),
]
self.stdout.write('Generating {} fake tags...'.format(len(tags)))
for tag, details in tags:
Tag.objects.get_or_create(name=tag, defaults=dict(details=details))
def fake_badges(self):
"""Provide fixed badges."""
badges = [
('creator', 'Creator', 'Creating learning materials and other '
'content'),
('swc-instructor', 'Software Carpentry Instructor',
'Teaching at Software Carpentry workshops or online'),
('member', 'Member', 'Software Carpentry Foundation member'),
('organizer', 'Organizer', 'Organizing workshops and learning '
'groups'),
('dc-instructor', 'Data Carpentry Instructor',
'Teaching at Data Carpentry workshops or online'),
('maintainer', 'Maintainer', 'Maintainer of Software or Data '
'Carpentry lesson'),
('trainer', 'Trainer', 'Teaching instructor training workshops'),
('mentor', 'Mentor', 'Mentor of Carpentry Instructors'),
('mentee', 'Mentee', 'Mentee in Carpentry Mentorship Program'),
('lc-instructor', 'Library Carpentry Instructor',
'Teaching at Library Carpentry workshops or online'),
]
self.stdout.write('Generating {} fake badges...'.format(len(badges)))
for name, title, criteria in badges:
Badge.objects.get_or_create(
name=name, defaults=dict(title=title, criteria=criteria))
def fake_instructors(self, count=30):
self.stdout.write('Generating {} fake instructors...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True)
def fake_trainers(self, count=10):
self.stdout.write('Generating {} fake trainers...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True, is_trainer=True)
def fake_admins(self, count=10):
self.stdout.write('Generating {} fake admins...'.format(count))
for _ in range(count):
person = self.fake_person(is_instructor=randbool(0.5))
person.groups.add(choice(Group.objects.all()))
person.is_active = True
person.set_password(person.username)
person.save()
def fake_trainees(self, count=30):
self.stdout.write('Generating {} fake trainees (and their training '
'progresses and training requests)...'.format(count))
for _ in range(count):
p = self.fake_person(is_instructor=randbool(0.1))
training = choice(Event.objects.ttt())
Task.objects.create(person=p, event=training,
role=Role.objects.get(name='learner'))
self.fake_training_request(p)
self.fake_training_progresses(p, training)
def fake_training_progresses(self, p, training):
trainers = Person.objects.filter(award__badge__name='trainer')
for r in TrainingRequirement.objects.all():
if randbool(0.4):
if 'Homework' in r.name and randbool(0.5):
state = 'n'
else:
state = 'p' if randbool(0.95) else 'f'
evaluated_by = None if state == 'n' else choice(trainers)
event = training if r.name == 'Training' else None
url = self.faker.url() if 'Homework' in r.name else None
TrainingProgress.objects.create(
trainee=p,
requirement=r,
evaluated_by=evaluated_by,
state=state,
discarded=randbool(0.05),
event=event,
url=url,
notes='',
)
def fake_training_request(self, person_or_None):
if person_or_None is None:
state = 'p' if randbool(0.5) else 'd'
person = self.fake_person(is_instructor=False)
else:
state = 'a'
person = person_or_None
occupation = choice(TrainingRequest._meta.get_field('occupation')
.choices)[0]
training_completion_agreement = randbool(0.5)
underrepresented_choices = (
TrainingRequest._meta.get_field('underrepresented').choices
)
req = TrainingRequest.objects.create(
state=state,
person=person_or_None,
group_name=self.faker.city() if randbool(0.1) else '',
personal=person.personal,
middle='',
family=person.family,
email=person.email,
github=person.github,
occupation=occupation,
occupation_other=self.faker.job() if occupation == '' else '',
affiliation=person.affiliation,
location=self.faker.city(),
country=choice(Countries)[0],
underresourced=randbool(0.6),
domains_other='',
underrepresented=choice(underrepresented_choices)[0],
underrepresented_details=choice(
['', self.faker.paragraph(nb_sentences=1)]
),
nonprofit_teaching_experience='',
previous_training=choice(
TrainingRequest.PREVIOUS_TRAINING_CHOICES)[0],
previous_training_other='',
previous_training_explanation=self.faker.text(),
previous_experience=choice(
TrainingRequest.PREVIOUS_EXPERIENCE_CHOICES)[0],
previous_experience_other='',
programming_language_usage_frequency=choice(
TrainingRequest.PROGRAMMING_LANGUAGE_USAGE_FREQUENCY_CHOICES)[0],
teaching_frequency_expectation=choice(
TrainingRequest.TEACHING_FREQUENCY_EXPECTATION_CHOICES)[0],
teaching_frequency_expectation_other='',
max_travelling_frequency=choice(
TrainingRequest.MAX_TRAVELLING_FREQUENCY_CHOICES)[0],
max_travelling_frequency_other='',
reason=self.faker.text(),
training_completion_agreement=training_completion_agreement,
workshop_teaching_agreement=randbool(0.5) if training_completion_agreement else False,
)
req.domains.set(sample(KnowledgeDomain.objects.all()))
req.previous_involvement.set(sample(Role.objects.all()))
if person_or_None is None:
person.delete()
def fake_person(self, *, is_instructor, is_trainer=False):
airport = choice(Airport.objects.all())
email = choice([self.faker.email(),
self.faker.safe_email(),
self.faker.free_email(),
self.faker.company_email()])
gender = choice(Person.GENDER_CHOICES)[0]
if gender == 'F':
personal_name = self.faker.first_name_female()
family_name = self.faker.last_name_female()
elif gender == 'M':
personal_name = self.faker.first_name_male()
family_name = self.faker.last_name_male()
else:
personal_name = self.faker.first_name()
family_name = self.faker.last_name()
social_username = self.faker.user_name()
if randbool(0.6):
# automatically generate username
username = create_username(personal_name, family_name)
else:
# assume that the username is provided by the person
username = social_username
github = social_username
twitter = social_username
url = self.faker.url() if randbool(0.5) else ''
person = Person.objects.create(
personal=personal_name,
family=family_name,
email=email,
gender=gender,
may_contact=randbool(0.5),
publish_profile=randbool(0.5),
airport=airport,
twitter=twitter,
github=github,
url=url,
username=username,
country=choice(Countries)[0],
)
if is_instructor:
# Add one or more instructor badges
awards = []
badges = sample(Badge.objects.instructor_badges())
for badge in badges:
date = self.faker.date_time_between(start_date='-5y').date()
awards.append(Award(person=person, badge=badge, awarded=date))
Award.objects.bulk_create(awards)
if randbool(0.75):
# Add one or more qualifications
Qualification.objects.bulk_create(
Qualification(person=person, lesson=lesson)
for lesson in sample(Lesson.objects.all())
)
if is_trainer:
date = self.faker.date_time_between(start_date='-5y').date()
trainer = Badge.objects.get(name='trainer')
Award.objects.create(person=person, badge=trainer, awarded=date)
return person
def fake_organizations(self, count=10):
"""Add some organizations that host events."""
self.stdout.write('Generating {} fake organizations...'.format(count))
for _ in range(count):
Organization.objects.create(
domain=self.faker.domain_name(),
fullname=self.faker.company(),
country=choice(Countries)[0],
)
def fake_memberships(self, count=10):
self.stdout.write('Generating {} fake memberships...'.format(count))
for _ in range(count):
start = self.faker.date_time_between(start_date='-5y').date()
Membership.objects.create(
variant=choice(Membership.MEMBERSHIP_CHOICES)[0],
agreement_start=start,
agreement_end=start + timedelta(days=365),
contribution_type=choice(Membership.CONTRIBUTION_CHOICES)[0],
workshops_without_admin_fee_per_agreement=randint(5, 15),
self_organized_workshops_per_agreement=randint(5, 15),
organization=choice(Organization.objects.all()),
)
def fake_current_events(self, count=5, **kwargs):
"""Ongoing and upcoming events."""
self.stdout.write('Generating {} fake current events...'.format(count))
for _ in range(count):
self.fake_event(future_date=True, **kwargs)
def fake_unpublished_events(self, count=5):
"""Events with missing location data (which is required for publishing
them)."""
self.stdout.write(
'Generating {} fake unpublished events...'.format(count))
for _ in range(count):
self.fake_event(location_data=False)
def fake_self_organized_events(self, count=5):
"""Full-blown events with 'self-organized' host."""
self.stdout.write(
'Generating {} fake self organized events...'.format(count))
for _ in range(count):
e = self.fake_event(self_organized=True)
e.invoice_status = choice(Event.INVOICED_CHOICES)[0]
e.save()
def fake_ttt_events(self, count=10):
self.stdout.write(
'Generating {} fake train-the-trainer events...'.format(count))
for _ in range(count):
e = self.fake_event()
e.slug += '-ttt'
e.tags.set([Tag.objects.get(name='TTT')])
e.save()
def fake_event(self, *, location_data=True, self_organized=False,
add_tags=True, future_date=False):
if future_date:
start = self.faker.date_time_between(start_date='now',
end_date='+120d').date()
else:
start = self.faker.date_time_between(start_date='-120d').date()
city = self.faker.city().replace(' ', '-').lower()
if self_organized:
org = Organization.objects.get(domain='self-organized')
else:
org = choice(Organization.objects.exclude(domain='self-organized'))
# The following line may result in IntegrityError from time to time,
# because we don't guarantee that the url is unique. In that case,
# simply create new database (rm db.sqlite3 && python manage.py migrate)
# and rerun fake_database command (python manage.py fake_database). Be
# aware that creating a database deletes all data in the existing
# database!
e = Event.objects.create(
slug='{:%Y-%m-%d}-{}'.format(start, city),
start=start,
end=start + timedelta(days=2),
url=self.faker.unique_url(),
host=org,
# needed in order for event to be published
country=choice(Countries)[0] if location_data else None,
venue=self.faker.word().title() if location_data else '',
address=self.faker.street_address() if location_data else '',
latitude=uniform(-90, 90) if location_data else None,
longitude=uniform(0, 180) if location_data else None,
metadata_changed=randbool(0.1),
)
if add_tags:
e.tags.set(sample(Tag.objects.exclude(name='TTT'), 2))
return e
def fake_tasks(self, count=120):
self.stdout.write('Generating {} fake tasks...'.format(count))
events = Event.objects.all()
persons = Person.objects.all()
roles = Role.objects.all()
all_possible = itertools.product(events, persons, roles)
for event, person, role in sample(all_possible, count):
Task.objects.create(
event=event,
person=person,
role=role,
title=(self.faker.sentence(nb_words=4, variable_nb_words=True)
if randbool(0.2) else ''),
url=self.faker.url() if randbool(0.2) else '',
)
def fake_unmatched_training_requests(self, count=20):
self.stdout.write('Generating {} fake unmatched '
'training requests...'.format(count))
for _ in range(count):
self.fake_training_request(None)
def fake_duplicated_people(self, count=5):
self.stdout.write('Generating {} fake '
'people duplications...'.format(count))
for _ in range(count):
p = Person.objects.order_by('?').first()
p.id = None
# avoid integrity errors due to unique constraints
p.username = create_username(p.personal, p.family)
p.twitter = None
p.github = None
p.email = self.faker.email()
p.save()
def fake_workshop_requests(self, count=10):
self.stdout.write('Generating {} fake '
'workshop requests...'.format(count))
curricula = Curriculum.objects.filter(active=True)
organizations = Organization.objects.all()
for _ in range(count):
if randbool(0.5):
language = Language.objects.get(subtag='en')
else:
language = choice(Language.objects.all())
if randbool(0.3):
org = choice(organizations)
org_name = ''
else:
org = None
org_name = self.faker.company()
organization_type = choice(
WorkshopRequest.ORGANIZATION_TYPE_CHOICES)[0]
if organization_type == 'self':
self_organized_github = self.faker.uri()
centrally_organized_fee = 'nonprofit' # doesn't matter
waiver_circumstances = ""
travel_expences_agreement = False
travel_expences_management = ""
travel_expences_management_other = ""
else:
self_organized_github = ""
centrally_organized_fee = choice(WorkshopRequest.FEE_CHOICES)[0]
waiver_circumstances = (
self.faker.sentence()
if centrally_organized_fee == 'waiver'
else "")
travel_expences_agreement = True
travel_expences_management = choice(
WorkshopRequest.TRAVEL_EXPENCES_MANAGEMENT_CHOICES)[0]
travel_expences_management_other = (
self.faker.sentence()
if travel_expences_management == ''
else "")
req = WorkshopRequest.objects.create(
state=choice(['p', 'd', 'a']),
data_privacy_agreement=randbool(0.5),
code_of_conduct_agreement=randbool(0.5),
host_responsibilities=randbool(0.5),
personal=self.faker.first_name(),
family=self.faker.last_name(),
email=self.faker.email(),
institution=org,
institution_name=org_name,
institution_department='',
location=self.faker.city(),
country=choice(Countries)[0],
conference_details='',
preferred_dates=str(self.faker.date_time_between(
start_date='now', end_date='+1y').date()),
language=language,
number_attendees=choice(
WorkshopRequest.ATTENDEES_NUMBER_CHOICES)[0],
# domains=[], # will be selected below because it's M2M
domains_other='',
# academic_levels=[], # will be selected below
# computing_levels=[], # will be selected below
audience_description=self.faker.sentence(),
# requested_workshop_types=[], # will be selected below
organization_type=organization_type,
self_organized_github=self_organized_github,
centrally_organized_fee=centrally_organized_fee,
waiver_circumstances=waiver_circumstances,
travel_expences_agreement=travel_expences_agreement,
travel_expences_management=travel_expences_management,
travel_expences_management_other=travel_expences_management_other,
user_notes = self.faker.sentence(),
)
req.domains.set(sample(KnowledgeDomain.objects.all()))
req.academic_levels.set(sample(AcademicLevel.objects.all()))
req.computing_levels.set(sample(ComputingExperienceLevel.objects.all()))
req.requested_workshop_types.set(sample(curricula))
req.save()
def handle(self, *args, **options):
seed = options['seed']
if seed is not None:
self.faker.seed(seed)
try:
self.fake_groups()
self.fake_airports()
self.fake_roles()
self.fake_tags()
self.fake_badges()
self.fake_instructors()
self.fake_trainers()
self.fake_admins()
self.fake_organizations()
self.fake_memberships()
self.fake_current_events()
self.fake_unpublished_events()
self.fake_self_organized_events()
self.fake_ttt_events()
self.fake_tasks()
self.fake_trainees()
self.fake_unmatched_training_requests()
self.fake_duplicated_people()
self.fake_workshop_requests()
except IntegrityError as e:
print("!!!" * 10)
print("Delete the database, and rerun this script.")
print("!!!" * 10)
raise e
def add(db):
fake = Faker()
db.add(User(fake.user_name(), fullname=fake.name(), password=fake.sha1()))
redirect("/user/")
fulfillment['grams'] = round(random.uniform(1, 1000),2)
fulfillment['id'] = faker.ean13()
fulfillment['total_price'] = round(purchase_amount,2)
products = {}
products['product_id'] = random.choice(product_ids)
products['quantity'] = random.randint(1, 10)
products['requires_shipping'] = 1
fulfillment['products'] = products
shopper_profile = {}
shopper_profile['name'] = faker.name_female()
shopper_profile['username'] = faker.user_name()
shopper_profile['sex']='F'
shopper_profile['mail']= faker.ascii_safe_email()
order = {}
order['billing_address'] = billing_address
order['credit_card'] = creditcard_info
order['web_client_details'] = client_details
order['fulfillment'] = fulfillment
order['shopper'] = shopper_profile
order['buyer_accepts_marketing'] = faker.boolean(chance_of_getting_true=50)
order['cart_token'] = faker.uuid4()
print(json.dumps(order))
#f.write(json.dumps(order))
fake = Faker()
users = []
todos = []
#Find Ken
# ken = User.objects.get_or_create(username='******')
# #Create ken's tasks
# for num in range(1,5):
# new_task = ToDo(title=fake.sentence())
# new_task.user = ken[0]
# new_task.save()
#Create random users
for num in range(0, 20):
user = User.objects.get_or_create(username=fake.user_name())
profile = UserProfile()
profile.user = user[0]
profile.api_key = hashlib.md5((user[0].username + str(datetime.now())).encode('utf-8')).hexdigest()
profile.save()
users.append(user)
#Create and assign tasks for random people
# for num in range(0, len(users)):
# new_task = ToDo(title=fake.sentence())
# new_task.user = users[randint(0, len(users)-1)][0]
# if num % 2 == 0:
# new_task.completed = True
# new_task.save()
# todos.append(new_task)
class RandomEmailSanitizer(BaseSanitizer):
"""Sanitizes configured fields in `fields_to_sanitize` by updating them
with semi-randomized email addresses.
Will use the domain configured in the sanitizer.
If no domain is configured, will attempt to reuse any domain found in the
sanitized value.
At worst, will generate an email of valid format, with randomized strings
and ending in `.com`.
"""
force_domain = None # xyz.com
def __init__(self, model_class, *args, **kwargs):
self.fake = Faker(TEXT_LOCALE)
super(RandomEmailSanitizer, self).__init__(model_class)
def validate(self, row_object, field_name, field_value):
if self.force_domain:
parts = self.force_domain.split(".")
if len(parts) == 1: # No dot(s)?
raise SanitizerValidationException(
"The format of 'force_domain' class parameter value {0} "
"appears invalid in {1}.".format(self.force_domain, self))
return True
def sanitize(self, row_object, field_name, field_value):
"""Generates a random email string.
:return: Email address
:rtype: str
"""
if self.force_domain:
new_email = self._get_forced_domain_email()
else:
new_email = self._get_field_value_domain_email(field_value)
if not new_email:
new_email = self._get_random_email()
# Add some randomness to the value to avoid problems
# if the field value must be unique
if self.is_model_field_unique(field_name):
new_email = new_email.replace(
"@", ".{0}.{1}@".format(self.fake.word(),
randint(0, 999999999)))
return new_email
def _get_forced_domain_email(self):
return "{0}@{1}".format(self.fake.user_name(), self.force_domain)
def _get_field_value_domain_email(self, field_value):
domain = field_value.split("@")[-1]
if not domain:
return None
else:
parts = domain.split(".")
if len(parts) == 1:
return None
return "{0}@{1}".format(self.fake.user_name(), domain)
def _get_random_email(self):
return self.fake.safe_email()
class Command(BaseCommand):
help = 'Add fake data to the database.'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.faker = Faker()
self.faker.add_provider(UniqueUrlProvider)
def add_arguments(self, parser):
parser.add_argument(
'--seed', action='store', default=None,
help='Provide an initial seed for randomization mechanism.',
)
def fake_airports(self):
"""Add some airports."""
# we're not doing anything here, since:
# 1. data migrations add some airports already
# 2. we'll have more airports as fixtures as of #626
pass
def fake_roles(self):
self.stdout.write('Generating fake roles...')
roles = [
('helper', 'Helper'),
('instructor', 'Instructor'),
('host', 'Workshop host'),
('learner', 'Learner'),
('organizer', 'Workshop organizer'),
('contributor', 'Contributed to lesson materials')
]
"""Provide fixed roles (before they end up in fixtures, see #626)."""
for name, verbose_name in roles:
Role.objects.create(name=name, verbose_name=verbose_name)
def fake_groups(self):
# Two groups are already in the migrations: Administrator
# and Steering Committee
self.stdout.write('Generating fake groups...')
Group.objects.create(name='invoicing')
Group.objects.create(name='trainers')
def fake_tags(self):
"""Provide fixed tags (before they end up in fixtures, see #626)."""
self.stdout.write('Generating fake tags...')
tags = [
('SWC', 'Software Carpentry Workshop'),
('DC', 'Data Carpentry Workshop'),
('LC', 'Library Carpentry Workshop'),
('WiSE', 'Women in Science and Engineering'),
('TTT', 'Train the Trainers'),
]
for tag, details in tags:
Tag.objects.create(name=tag, details=details)
def fake_badges(self):
"""Provide fixed badges (before they end up in fixtures, see #626)."""
# 4 badges are already in the migrations: swc-instructor,
# dc-instructor, maintainer, and trainer
self.stdout.write('Generating fake badges...')
badges = [
('creator', 'Creator',
'Creating learning materials and other content'),
('member', 'Member', 'Software Carpentry Foundation member'),
('organizer', 'Organizer',
'Organizing workshops and learning groups'),
]
for name, title, criteria in badges:
Badge.objects.create(name=name, title=title, criteria=criteria)
def fake_instructors(self, count=30):
self.stdout.write('Generating {} fake instructors...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True)
def fake_trainers(self, count=10):
self.stdout.write('Generating {} fake trainers...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True, is_trainer=True)
def fake_admins(self, count=10):
self.stdout.write('Generating {} fake admins...'.format(count))
for _ in range(count):
person = self.fake_person(is_instructor=randbool(0.5))
person.groups.add(choice(Group.objects.all()))
person.is_active = True
person.set_password(person.username)
person.save()
def fake_trainees(self, count=30):
self.stdout.write('Generating {} fake trainees '
'(and their training progresses '
'as well as training requests)...'.format(count))
for _ in range(count):
p = self.fake_person(is_instructor=randbool(0.1))
training = choice(Event.objects.ttt())
Task.objects.create(person=p, event=training,
role=Role.objects.get(name='learner'))
self.fake_training_progresses(p, training)
if randbool(0.8):
self.fake_training_request(p)
def fake_training_progresses(self, p, training):
trainers = Person.objects.filter(award__badge__name='trainer')
for r in TrainingRequirement.objects.all():
if randbool(0.4):
if 'Homework' in r.name and randbool(0.5):
state = 'n'
else:
state = 'p' if randbool(0.95) else 'f'
evaluated_by = None if state == 'n' else choice(trainers)
event = training if r.name == 'Training' else None
url = self.faker.url() if 'Homework' in r.name else None
TrainingProgress.objects.create(
trainee=p,
requirement=r,
evaluated_by=evaluated_by,
state=state,
discarded=randbool(0.05),
event=event,
url=url,
notes='',
)
def fake_training_request(self, person_or_None):
if person_or_None is None:
state = 'p' if randbool(0.5) else 'd'
person = self.fake_person(is_instructor=False)
else:
state = 'a'
person = person_or_None
occupation = choice(ProfileUpdateRequest.OCCUPATION_CHOICES)[0]
req = TrainingRequest.objects.create(
state=state,
person=person_or_None,
group_name=self.faker.city() if randbool(0.1) else '',
personal=person.personal,
middle='',
family=person.family,
email=person.email,
github=person.github,
occupation=occupation,
occupation_other=self.faker.job() if occupation == '' else '',
affiliation=person.affiliation,
location=self.faker.city(),
country=choice(Countries)[0],
domains_other='',
gender=person.gender,
gender_other='',
previous_training=choice(
TrainingRequest.PREVIOUS_TRAINING_CHOICES)[0],
previous_training_other='',
previous_training_explanation=self.faker.text(),
previous_experience=choice(
TrainingRequest.PREVIOUS_EXPERIENCE_CHOICES)[0],
previous_experience_other='',
programming_language_usage_frequency=choice(
TrainingRequest.PROGRAMMING_LANGUAGE_USAGE_FREQUENCY_CHOICES)[0],
reason=self.faker.text(),
teaching_frequency_expectation=choice(
TrainingRequest.TEACHING_FREQUENCY_EXPECTATION_CHOICES)[0],
teaching_frequency_expectation_other='',
max_travelling_frequency=choice(
TrainingRequest.MAX_TRAVELLING_FREQUENCY_CHOICES)[0],
max_travelling_frequency_other='',
additional_skills=self.faker.job() if randbool(0.2) else '',
comment=self.faker.text() if randbool(0.3) else '',
)
req.domains = sample(KnowledgeDomain.objects.all())
req.previous_involvement = sample(Role.objects.all())
if person_or_None is None:
person.delete()
def fake_person(self, *, is_instructor, is_trainer=False):
airport = choice(Airport.objects.all())
email = choice([self.faker.email(),
self.faker.safe_email(),
self.faker.free_email(),
self.faker.company_email()])
gender = choice(Person.GENDER_CHOICES)[0]
if gender == 'F':
personal_name = self.faker.first_name_female()
family_name = self.faker.last_name_female()
elif gender == 'M':
personal_name = self.faker.first_name_male()
family_name = self.faker.last_name_male()
else:
personal_name = self.faker.first_name()
family_name = self.faker.last_name()
social_username = self.faker.user_name()
if randbool(0.6):
# automatically generate username
username = create_username(personal_name, family_name)
else:
# assume that the username is provided by the person
username = social_username
github = social_username if randbool(0.5) else None
twitter = social_username if randbool(0.5) else None
url = self.faker.url() if randbool(0.5) else ''
person = Person.objects.create(
personal=personal_name,
family=family_name,
email=email,
gender=gender,
may_contact=randbool(0.5),
airport=airport,
twitter=twitter,
github=github,
url=url,
username=username,
)
if is_instructor:
# Add one or more instructor badges
awards = []
badges = sample(Badge.objects.instructor_badges())
for badge in badges:
date = self.faker.date_time_between(start_date='-5y').date()
awards.append(Award(person=person, badge=badge, awarded=date))
Award.objects.bulk_create(awards)
if randbool(0.75):
# Add one or more qualifications
Qualification.objects.bulk_create(
Qualification(person=person, lesson=lesson)
for lesson in sample(Lesson.objects.all())
)
if is_trainer:
date = self.faker.date_time_between(start_date='-5y').date()
trainer = Badge.objects.get(name='trainer')
Award.objects.create(person=person, badge=trainer, awarded=date)
return person
def fake_organizations(self, count=10):
"""Add some organizations that host events."""
self.stdout.write('Generating {} fake organizations...'.format(count))
for _ in range(count):
Organization.objects.create(
domain=self.faker.domain_name(),
fullname=self.faker.company(),
country=choice(Countries)[0],
)
def fake_memberships(self, count=10):
self.stdout.write('Generating {} fake memberships...'.format(count))
for _ in range(count):
start = self.faker.date_time_between(start_date='-5y').date()
Membership.objects.create(
variant=choice(Membership.MEMBERSHIP_CHOICES),
agreement_start=start,
agreement_end=start + timedelta(days=365),
contribution_type=choice(Membership.CONTRIBUTION_CHOICES),
workshops_without_admin_fee_per_year=randint(5, 15),
self_organized_workshops_per_year=randint(5, 15),
notes='',
organization=choice(Organization.objects.all()),
)
def fake_current_events(self, count=5, **kwargs):
"""Ongoing and upcoming events."""
self.stdout.write('Generating {} fake current events...'.format(count))
for _ in range(count):
self.fake_event(**kwargs)
def fake_uninvoiced_events(self, count=5):
"""Preferably in the past, and with 'uninvoiced' status."""
self.stdout.write(
'Generating {} fake uninvoiced events...'.format(count))
for _ in range(count):
e = self.fake_event()
e.invoice_status = 'not-invoiced'
e.save()
def fake_unpublished_events(self, count=5):
"""Events with missing location data (which is required for publishing
them)."""
self.stdout.write(
'Generating {} fake unpublished events...'.format(count))
for _ in range(count):
self.fake_event(location_data=False)
def fake_self_organized_events(self, count=5):
"""Full-blown events with 'self-organized' host."""
self.stdout.write(
'Generating {} fake self organized events...'.format(count))
for _ in range(count):
e = self.fake_event(self_organized=True)
e.invoice_status = choice(Event.INVOICED_CHOICES)[0]
e.save()
def fake_ttt_events(self, count=10):
self.stdout.write(
'Generating {} fake train-the-trainer events...'.format(count))
for _ in range(count):
e = self.fake_event()
e.slug += '-ttt'
e.tags.set([Tag.objects.get(name='TTT')])
e.save()
def fake_event(self, *, location_data=True, self_organized=False,
add_tags=True):
start = self.faker.date_time_between(start_date='-5y').date()
city = self.faker.city().replace(' ', '-').lower()
if self_organized:
org = Organization.objects.get(domain='self-organized')
else:
org = choice(Organization.objects.exclude(domain='self-organized'))
# The following line may result in IntegrityError from time to time,
# because we don't guarantee that the url is unique. In that case,
# simply create new database (rm db.sqlite3 && python manage.py migrate)
# and rerun fake_database command (python manage.py fake_database). Be
# aware that creating a database deletes all data in the existing
# database!
e = Event.objects.create(
slug='{:%Y-%m-%d}-{}'.format(start, city),
start=start,
end=start + timedelta(days=2),
url=self.faker.unique_url(),
host=org,
# needed in order for event to be published
country=choice(Countries)[0] if location_data else None,
venue=self.faker.word().title() if location_data else '',
address=self.faker.street_address() if location_data else '',
latitude=uniform(-90, 90) if location_data else None,
longitude=uniform(0, 180) if location_data else None,
metadata_changed=randbool(0.1),
)
if add_tags:
e.tags = sample(Tag.objects.exclude(name='TTT'), 2)
return e
def fake_tasks(self, count=120):
self.stdout.write('Generating {} fake tasks...'.format(count))
events = Event.objects.all()
persons = Person.objects.all()
roles = Role.objects.all()
all_possible = itertools.product(events, persons, roles)
for event, person, role in sample(all_possible, count):
Task.objects.create(
event=event,
person=person,
role=role,
title=(self.faker.sentence(nb_words=4, variable_nb_words=True)
if randbool(0.2) else ''),
url=self.faker.url() if randbool(0.2) else '',
)
def fake_unmatched_training_requests(self, count=20):
self.stdout.write('Generating {} fake unmatched '
'training requests...'.format(count))
for _ in range(count):
self.fake_training_request(None)
def fake_duplicated_people(self, count=5):
self.stdout.write('Generating {} fake '
'people duplications...'.format(count))
for _ in range(count):
p = Person.objects.order_by('?').first()
p.id = None
# avoid integrity errors due to unique constraints
p.username = create_username(p.personal, p.family)
p.twitter = None
p.github = None
p.email = self.faker.email()
p.save()
def fake_workshop_requests(self, count=10):
self.stdout.write('Generating {} fake '
'workshop requests...'.format(count))
for _ in range(count):
if randbool(0.5):
language = Language.objects.get(subtag='en')
else:
language = choice(Language.objects.all())
req = EventRequest.objects.create(
name=self.faker.name(),
email=self.faker.email(),
affiliation=self.faker.company(),
location=self.faker.city(),
country=choice(Countries)[0],
conference='',
preferred_date=str(self.faker.date_time_between(
start_date='now', end_date='+1y').date()),
language=language,
workshop_type=choice(EventRequest.WORKSHOP_TYPE_CHOICES)[0],
approx_attendees=choice(
EventRequest.ATTENDEES_NUMBER_CHOICES)[0],
attendee_domains_other='',
data_types=choice(EventRequest.DATA_TYPES_CHOICES)[0],
understand_admin_fee=True,
admin_fee_payment=choice(
EventRequest.ADMIN_FEE_PAYMENT_CHOICES)[0],
fee_waiver_request=randbool(0.2),
cover_travel_accomodation=randbool(0.6),
travel_reimbursement=choice(
EventRequest.TRAVEL_REIMBURSEMENT_CHOICES)[0],
travel_reimbursement_other='',
comment='',
)
req.attendee_domains = sample(KnowledgeDomain.objects.all())
req.attendee_academic_levels = sample(AcademicLevel.objects.all())
req.attendee_computing_levels = sample(
ComputingExperienceLevel.objects.all())
req.attendee_data_analysis_level = sample(
DataAnalysisLevel.objects.all())
req.save()
def fake_workshop_submissions(self, count=10):
self.stdout.write('Generating {} fake '
'workshop submissions...'.format(count))
for _ in range(count):
EventSubmission.objects.create(
url=self.faker.url(),
contact_name=self.faker.name(),
contact_email=self.faker.email(),
self_organized=randbool(0.5),
notes='',
)
def fake_dc_selforganized_workshop_requests(self, count=5):
self.stdout.write('Generating {} fake dc self-organized '
'workshops requests...'.format(count))
for _ in range(count):
date = self.faker.date_time_between(start_date='now',
end_date='+1y')
req = DCSelfOrganizedEventRequest.objects.create(
name=self.faker.name(),
email=self.faker.email(),
organization=self.faker.company(),
instructor_status=choice(
DCSelfOrganizedEventRequest.INSTRUCTOR_CHOICES)[0],
is_partner=choice(
DCSelfOrganizedEventRequest.PARTNER_CHOICES)[0],
is_partner_other='',
location=self.faker.city(),
country=choice(Countries)[0],
associated_conference='',
dates=str(date.date()),
domains_other='',
topics_other='',
payment=choice(DCSelfOrganizedEventRequest.PAYMENT_CHOICES)[0],
fee_waiver_reason='',
handle_registration=True,
distribute_surveys=True,
follow_code_of_conduct=True,
)
req.domains = sample(DCWorkshopDomain.objects.all())
req.topics = sample(DCWorkshopTopic.objects.all())
req.attendee_academic_levels = sample(AcademicLevel.objects.all())
req.attendee_data_analysis_level = sample(
DataAnalysisLevel.objects.all())
def fake_profile_update_requests(self, count=20):
self.stdout.write('Generating {} fake '
'profile update requests...'.format(count))
for _ in range(count):
p = Person.objects.order_by('?').first() # type: Person
req = ProfileUpdateRequest.objects.create(
active=randbool(0.5),
personal=(p.personal if randbool(0.9)
else self.faker.first_name()),
middle=p.middle,
family=p.family if randbool(0.9) else self.faker.last_name(),
email=p.email if randbool(0.8) else self.faker.email(),
affiliation=(p.affiliation if randbool(0.8)
else self.faker.company()),
airport_iata=(p.airport.iata
if randbool(0.9) and p.airport is not None
else choice(Airport.objects.all()).iata),
occupation=choice(ProfileUpdateRequest.OCCUPATION_CHOICES)[0],
occupation_other='',
github=p.github or '',
twitter=p.twitter or '',
orcid=p.orcid or '',
website=p.url or '',
gender=choice(ProfileUpdateRequest.GENDER_CHOICES)[0],
gender_other='',
domains_other='',
lessons_other='',
notes='',
)
req.domains = (p.domains.all() if randbool(0.9) else
sample(KnowledgeDomain.objects.all()))
req.languages = (p.languages.all() if randbool(0.9) else
sample(Language.objects.all()))
req.lessons = (p.lessons.all() if randbool(0.9) else
sample(Lesson.objects.all()))
def fake_invoice_requests(self, count=10):
self.stdout.write('Generating {} fake '
'invoice requests...'.format(count))
for _ in range(count):
status = choice(InvoiceRequest.STATUS_CHOICES)[0]
sent_date = (None if status == 'not-invoiced' else
self.faker.date_time_between(start_date='-1y').date())
paid_date = (
self.faker.date_time_between(start_date=sent_date).date()
if status == 'paid' else None)
org = Organization.objects.order_by('?').first()
event = (Event.objects.order_by('?').first()
if randbool(0.8) else None)
req = InvoiceRequest.objects.create(
status=status,
sent_date=sent_date,
paid_date=paid_date,
organization=org,
reason=choice(InvoiceRequest.INVOICE_REASON)[0],
reason_other='',
date=(self.faker.date_time_between(start_date='-1y').date()
if sent_date is None else sent_date),
event=event,
event_location='',
item_id='',
postal_number='',
contact_name=org.fullname,
contact_email=self.faker.email(),
contact_phone='',
full_address=self.faker.address(),
amount=choice([1000, 2000, 10000]),
currency=choice(InvoiceRequest.CURRENCY)[0],
currency_other='',
breakdown='',
vendor_form_required=
choice(InvoiceRequest.VENDOR_FORM_CHOICES)[0],
vendor_form_link='',
form_W9=randbool(0.5),
receipts_sent=choice(InvoiceRequest.RECEIPTS_CHOICES)[0],
shared_receipts_link='',
notes='',
)
def handle(self, *args, **options):
seed = options['seed']
if seed is not None:
self.faker.seed(seed)
self.fake_airports()
self.fake_roles()
self.fake_groups()
self.fake_tags()
self.fake_badges()
self.fake_instructors()
self.fake_trainers()
self.fake_admins()
self.fake_organizations()
self.fake_memberships()
self.fake_current_events()
self.fake_uninvoiced_events()
self.fake_unpublished_events()
self.fake_self_organized_events()
self.fake_ttt_events()
self.fake_tasks()
self.fake_trainees()
self.fake_unmatched_training_requests()
self.fake_duplicated_people()
self.fake_workshop_requests()
self.fake_workshop_submissions()
self.fake_dc_selforganized_workshop_requests()
self.fake_profile_update_requests()
self.fake_invoice_requests()
#generaData.py from faker import Faker f = Faker() for i in xrange(5): print print "nombre: ", f.name() print "usuario: ", f.user_name() print "email: ", f.email() print "cia: ", f.company() print "tel: ", f.phone_number() print "direccion: ", f.address() print "tarjeta: ", f.credit_card_security_code(card_type=None)