def _func():
return {
"host": faker.first_name(),
"username": faker.first_name(),
"user_dn":
f"uid={faker.first_name()},cn=users,dc={faker.first_name()}",
"password": faker.first_name(),
}
class UserFactory(DjangoModelFactory):
first_name = lazy_attribute(lambda o: faker.first_name())
last_name = lazy_attribute(lambda o: faker.last_name())
# username = lazy_attribute(lambda o: slugify(o.first_name + '.' + o.last_name))
username = factory.Sequence(lambda n: 'user%d' % n)
email = lazy_attribute(lambda o: o.username + "@example.com")
is_active = True
is_staff = False
is_superuser = False
password = factory.PostGenerationMethodCall('set_password', 'coygth14')
@factory.post_generation
def groups(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if extracted:
# A list of groups were passed in, use them
self.groups.add(*extracted)
@lazy_attribute
def date_joined(self):
return timezone.now() - dt.timedelta(days=randint(5, 50))
last_login = lazy_attribute(lambda o: o.date_joined + dt.timedelta(days=4))
class Meta:
model = 'auth.User'
def insert_random_client(cursor):
global clients_counter, client_fields_counter
clients_counter += 1
first_name = faker.first_name()
last_name = faker.last_name()
phone = faker.random_number(9, fix_len=True)
email = '{}.{}@gmail.com'.format(first_name, last_name)
conference = faker.boolean()
pesel = faker.random_number(11, fix_len=True)
address = faker.address()
cursor.execute('INSERT INTO clients '
'(id, first_name, last_name, phone, email, conference) '
'VALUES ({}, \'{}\', \'{}\', \'{}\', \'{}\', {})'.format(
clients_counter, first_name, last_name, phone, email,
conference))
client_fields_counter += 1
cursor.execute('INSERT INTO client_fields '
'(id, client_id, type, value) '
'VALUES ({}, {}, \'{}\', \'{}\')'.format(
client_fields_counter, clients_counter, 'PESEL', pesel))
client_fields_counter += 1
cursor.execute('INSERT INTO client_fields '
'(id, client_id, type, value) '
'VALUES ({}, {}, \'{}\', \'{}\')'.format(
client_fields_counter, clients_counter, 'ADDRESS',
address))
def create_random_user(locale="en", **kwargs):
user_model = get_user_model()
faker = get_faker(["person"], locale)
params = {
user_model.USERNAME_FIELD: slugify(faker.first_name())
}
params.update(kwargs or {})
return user_model.objects.create(**params)
class UserFactory(DjangoModelFactory):
class Meta:
model = User
username = Sequence(lambda n: "user_{0}".format(n))
first_name = lazy_attribute(lambda a: faker.first_name())
last_name = lazy_attribute(lambda a: faker.last_name())
last_session_key = Sequence(lambda n: "session_{0}.dat".format(n))
def create_random_user(locale="en", **kwargs):
user_model = get_user_model()
faker = get_faker(["person"], locale)
params = {
user_model.USERNAME_FIELD: slugify(faker.first_name())
}
params.update(kwargs or {})
return user_model.objects.create(**params)
class UserFactory(DjangoModelFactory):
class Meta:
model = User
username = lazy_attribute(lambda x: faker.user_name())
first_name = lazy_attribute(lambda x: faker.first_name())
last_name = lazy_attribute(lambda x: faker.last_name())
email = lazy_attribute(lambda x: faker.email())
password = lazy_attribute(lambda x: faker.password())
class UserFactory(factory.DjangoModelFactory):
class Meta:
model = User
first_name = factory.LazyAttribute(lambda o: faker.first_name())
last_name = factory.LazyAttribute(lambda o: faker.last_name())
email = factory.LazyAttribute(lambda a: '{0}.{1}@example.com'.format(
a.first_name, a.last_name).lower())
username = email
password = factory.PostGenerationMethodCall('set_password', '123456')
def test_create_patient(self):
test_password = '******'
username = faker.first_name()
data = {
'username': username,
'email': faker.email(),
'password1': test_password,
'password2': test_password,
'is_doctor': False
}
response = self.client.post(self.url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Patient.objects.count(), 1)
def test__add_or_update_user__existing_user__is_successful(db, s):
user = UserFactory()
db.add_or_update_user(s, user)
db_user = db.get_user_by_id(s, user.id)
user.first_name = faker.first_name()
user.last_name = faker.last_name()
user.username = f'{user.first_name}_{user.last_name}'.lower()
db.add_or_update_user(s, user)
for p in ('first_name', 'last_name', 'username'):
assert getattr(user, p) == getattr(db_user, p)
def seed_authors():
content_type = ContentType.objects.get(app_label='articles',
model='article')
create_article_permission, created = Permission.objects.get_or_create(
codename='can_create_articles',
defaults={
'name': 'Can create Articles',
'content_type': content_type
},
)
update_article_permission, created = Permission.objects.get_or_create(
codename='can_update_articles',
defaults={
'name': 'Can update Articles',
'content_type': content_type
},
)
delete_article_permission, created = Permission.objects.get_or_create(
codename='can_delete_articles',
defaults={
'name': 'Can delete Articles',
'content_type': content_type
},
)
authors_group, created = Group.objects.get_or_create(name='authors')
authors_group.permissions.add(create_article_permission)
authors_group.permissions.add(update_article_permission)
authors_group.permissions.add(delete_article_permission)
authors_count = AppUser.objects.filter(
groups__name__iexact='authors').count()
authors_to_seed = 5
sys.stdout.write('[+] Seeding %d authors\n' %
(authors_to_seed - authors_count))
for i in range(authors_count, authors_to_seed):
username = faker.profile(fields='username')['username']
first_name = faker.first_name()
last_name = faker.last_name()
email = faker.email()
password = '******'
# create_user instead of create, to hash
author = AppUser.objects.create_user(username=username,
first_name=first_name,
last_name=last_name,
email=email,
password=password)
author.groups.add(authors_group)
def seed_users():
users_count = AppUser.objects.count()
users_to_seed = 23
sys.stdout.write('[+] Seeding %d users\n' % (users_to_seed - users_count))
for i in range(users_count, users_to_seed):
username = faker.profile(fields='username')['username']
first_name = faker.first_name()
last_name = faker.last_name()
email = faker.email()
password = '******'
# create_user instead of create, to hash
AppUser.objects.create_user(username=username,
first_name=first_name,
last_name=last_name,
email=email,
password=password)
def test_create_doctor(self):
"""
Ensure we can create a new account object.
"""
test_password = '******'
username = faker.first_name()
data = {
'username': username,
'email': faker.email(),
'password1': test_password,
'password2': test_password,
'is_doctor': True
}
response = self.client.post(self.url, data, format='json')
# import pudb; pudb.set_trace()
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Doctor.objects.count(), 1)
help='output file in which to write json of create user details')
parser.add_argument('--num_users',
required=False,
default=10,
type=int,
help='number of users to create')
args = parser.parse_args()
if __name__ == '__main__':
faker = faker.Faker()
responses = []
print(args.num_users)
for i in range(0, args.num_users):
first_name = faker.first_name().lower()
last_name = faker.last_name().lower()
person_id = '{0}_{1}_test_user'.format(first_name, last_name)
person_password = '******'.format(first_name, last_name)
person_email = '{0}_{1}[email protected]'.format(
first_name, last_name)
headers = {
'Authorization': args.admin_key,
'content-type': 'application/json'
}
payload = json.dumps({
'name': person_id,
'email': person_email,
'password': person_password
})
response = requests.post('http://' + args.target +
class CategoryFactory(factory.django.DjangoModelFactory):
name = factory.lazy_attribute(lambda o: 'Category ' + faker.first_name())
class Meta:
model = Category
class ToDoEntryFactory(factory.django.DjangoModelFactory):
name = factory.lazy_attribute(lambda o: 'Task ' + faker.first_name())
category = factory.SubFactory('task.tests.factories.CategoryFactory')
class Meta:
model = ToDoEntry
