class JobFactory(DjangoModelFactory):
class Meta:
model = Job
owner = SubFactory(UserFactory)
title = Sequence(lambda n: 'job_title_%i' % n)
@post_generation
def set_created(obj, create, extracted, **kwargs):
"""
Update the creation time of the built instance. As it is an auto-generated field, we must
set its value after creation.
To use: JobFactory(set_created='1985-10-26 09:00Z')
"""
if extracted:
obj.created = extracted
obj.save()
class CommentFactory(ModularOdmFactory):
class Meta:
model = Comment
content = Sequence(lambda n: 'Comment {0}'.format(n))
is_public = True
@classmethod
def _build(cls, target_class, *args, **kwargs):
node = kwargs.pop('node', None) or NodeFactory()
user = kwargs.pop('user', None) or node.creator
target = kwargs.pop('target', None) or Guid.load(node._id)
content = kwargs.pop('content', None) or 'Test comment.'
instance = target_class(node=node,
user=user,
target=target,
content=content,
*args,
**kwargs)
if isinstance(target.referent, target_class):
instance.root_target = target.referent.root_target
else:
instance.root_target = target
return instance
@classmethod
def _create(cls, target_class, *args, **kwargs):
node = kwargs.pop('node', None) or NodeFactory()
user = kwargs.pop('user', None) or node.creator
target = kwargs.pop('target', None) or Guid.load(node._id)
content = kwargs.pop('content', None) or 'Test comment.'
instance = target_class(node=node,
user=user,
target=target,
content=content,
*args,
**kwargs)
if isinstance(target.referent, target_class):
instance.root_target = target.referent.root_target
else:
instance.root_target = target
instance.save()
return instance
class UserFactory(DjangoModelFactory):
class Meta:
model = User
django_get_or_create = ("username", )
username = Sequence(lambda n: f"testuser{n}")
password = Faker(
"password",
length=10,
special_chars=True,
digits=True,
upper_case=True,
lower_case=True,
)
email = Faker("email")
first_name = Faker("first_name")
last_name = Faker("last_name")
is_active = True
is_staff = False
class ResultFactory(DjangoModelFactory):
class Meta:
model = ResultM
program = SubFactory(ProgramFactory)
indicator = SubFactory(IndicatorFactory)
comments = Sequence(lambda n: 'Data description {0}'.format(n))
achieved = 10
@post_generation
def sites(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if type(extracted) is list:
# A list of program were passed in, use them
for site in extracted:
self.site.add(site)
class AbstractUserFactory(DjangoModelFactory):
"""Abstract factory for creating users."""
password = PostGenerationMethodCall("set_password", TEST_PASSWORD)
username = Sequence(lambda n: "user%d" % n)
first_name = Faker("first_name")
last_name = Faker("last_name")
email = Faker("email")
is_active = False
is_staff = False
is_superuser = False
class Meta:
"""Meta options."""
model = settings.AUTH_USER_MODEL
django_get_or_create = ("username", )
abstract = True
class ParentCategoryFactory(DjangoModelFactory):
name = Sequence(lambda n: 'Parent category {}'.format(n))
slug = LazyAttribute(lambda o: slugify(o.name))
handling = FuzzyChoice([c[0] for c in Category.HANDLING_CHOICES])
handling_message = 'Test handling message (parent category)'
is_active = True
class Meta:
model = Category
django_get_or_create = ('slug', )
@post_generation
def questions(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for question in extracted:
self.questions.add(question)
class IndicatorFactory(DjangoModelFactory):
class Meta:
model = IndicatorM
django_get_or_create = ('name',)
class Params:
lop_indicator = Trait(
lop_target=1000,
target_frequency=IndicatorM.LOP,
periodic_target=RelatedFactory(
'factories.indicators_models.PeriodicTargetFactory',
'indicator',
target=1000,
start_date=SelfAttribute('indicator.program.reporting_period_start'),
end_date=SelfAttribute('indicator.program.reporting_period_end'),
)
)
name = Sequence(lambda n: 'Indicator {0}'.format(n))
class AbstractUserFactory(DjangoModelFactory):
"""Abstract factory for creating users."""
password = PostGenerationMethodCall('set_password', TEST_PASSWORD)
username = Sequence(lambda n: 'user%d' % n)
first_name = Faker('first_name')
last_name = Faker('last_name')
email = Faker('email')
is_active = False
is_staff = False
is_superuser = False
class Meta(object):
"""Meta."""
model = settings.AUTH_USER_MODEL
django_get_or_create = ('username', )
abstract = True
class AuthorityFactory(BaseFactory):
"""Authority factory."""
name = Sequence(lambda n: 'authority{0}'.format(n))
owner = '*****@*****.**'
plugin = {'slug': 'test-issuer'}
authority_certificate = SubFactory(CertificateFactory)
class Meta:
"""Factory configuration."""
model = Authority
@post_generation
def roles(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for role in extracted:
self.roles.append(role)
class BookFactory(BaseFactory):
"""Book factory."""
isbn13 = Sequence(lambda n: 'isbn13{0}'.format(n))
# isbn13 = "book0"
title = "Lalala"
author = "Alvin Tan"
publisher = "Penguin Books"
year_of_pub = 2016
num_of_copies = 50
price = 25
format = "paperback"
keywords = "la"
subject = "fiction"
class Meta:
"""Factory configuration."""
model = Book
class UserFactory(BaseFactory):
"""User factory."""
# user_id = Faker('pyint')
username = Faker('user_name')
email = Sequence(lambda n: '{}@example.com'.format(n))
password = PostGenerationMethodCall('set_password', 'example')
active = True
first_name = Faker('first_name')
salt = Faker('md5')
last_name = Faker('last_name')
created_at = Faker('date_time')
api_token = Faker('md5')
is_admin = False
class Meta:
"""Factory configuration."""
model = User
class ProjectFactory(BaseFactory):
"""Project Factory."""
name = Sequence(lambda n: f"project{n}")
description = FuzzyText()
default = Faker().pybool()
color = Faker().color()
class Meta:
"""Factory Configuration."""
model = Project
@post_generation
def organization(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.organization_id = extracted.id
class UserFactory(DjangoModelFactory):
class Meta:
model = get_user_model()
strategy = CREATE_STRATEGY
is_active = True
is_staff = False
display_name = LazyAttribute(lambda _: faker.name())
email = Sequence(lambda n: str(n) + faker.email())
description = LazyAttribute(lambda _: faker.text())
# Use display_name as password, as it is readable
password = PostGeneration(
lambda obj, *args, **kwargs: obj.set_password(obj.display_name))
@classmethod
def _create(cls, model_class, *args, **kwargs):
manager = cls._get_manager(model_class)
user = manager.create_user(*args, **kwargs)
return user
class UserFactory(DjangoModelFactory):
"""Builds a ``django.contrib.auth.models.User`` object.
The user built has a random username and password. Both the username and
password consist of a set of UTF-8 characters.
>>> UserFactory.build().full_clean()
>>> UserFactory.create().id is None
False
>>> UserFactory.build(
... password = make_password('hackme')
... ).check_password('hackme')
True
"""
# pylint: disable=R0903
# pylint: disable=W0232
FACTORY_FOR = User
username = Sequence(lambda n: user_username(n)) # pylint: disable=W0108
password = FuzzyAttribute(lambda: user_password()) # pylint: disable=W0108
class TagFactory(BaseFactory):
"""Tag Factory."""
name = Sequence(lambda n: f"app{n}")
uri = "https://example.com"
uri_source = "foobar"
class Meta:
"""Factory Configuration."""
model = Tag
@post_generation
def incidents(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for incident in extracted:
self.incidents.append(incident)
class ApiKeyFactory(BaseFactory):
"""Api Key Factory."""
name = Sequence(lambda n: "api_key_{0}".format(n))
revoked = False
ttl = -1
issued_at = 1
class Meta:
"""Factory Configuration."""
model = ApiKey
@post_generation
def user(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.userId = extracted.id
class RouteFactory(DjangoModelFactory):
class Meta:
model = Route
activity_type = SubFactory(ActivityTypeFactory)
name = Faker("text", max_nb_chars=100)
source_id = Sequence(lambda n: 1000 + n)
data_source = "homebytwo"
description = Faker("bs")
athlete = SubFactory(AthleteFactory)
garmin_id = None
total_elevation_gain = Faker("random_int", min=0, max=5000)
total_elevation_loss = Faker("random_int", min=0, max=5000)
total_distance = Faker("random_int", min=1, max=5000)
geom = fromfile(get_data_file_path("route.ewkb").as_posix())
start_place = SubFactory(PlaceFactory,
geom=Point(geom.coords[0], srid=geom.srid))
end_place = SubFactory(PlaceFactory,
geom=Point(geom.coords[-1], srid=geom.srid))
data = read_json(load_data("route_data.json"), orient="records")
class GroupFactory(DjangoModelFactory):
class Meta:
model = GroupModel
@post_generation
def members(self, created, extracted, **kwargs):
if created and extracted:
for member in extracted:
membership = self.groupmembership_set.create(
user=member, roles=[roles.GROUP_EDITOR])
membership.add_notification_types([
GroupNotificationType.NEW_APPLICATION,
GroupNotificationType.NEW_OFFER,
])
membership.save()
@post_generation
def newcomers(self, created, extracted, **kwargs):
if created and extracted:
for member in extracted:
self.groupmembership_set.create(user=member)
@post_generation
def photo(self, created, extracted, **kwargs):
if created and extracted:
image_path = extracted
with open(image_path, 'rb') as file:
upload = SimpleUploadedFile(
name=os.path.basename(image_path),
content=file.read(),
content_type='image/jpeg',
)
self.photo = upload
self.save()
name = Sequence(lambda n: ' '.join(['Group', str(n), faker.name()]))
description = LazyAttribute(lambda x: faker.sentence(nb_words=40))
public_description = LazyAttribute(lambda x: faker.sentence(nb_words=20))
application_questions = LazyAttribute(
lambda x: faker.sentence(nb_words=20))
welcome_message = LazyAttribute(lambda x: faker.sentence(nb_words=30))
class ProgramFactory(DjangoModelFactory):
class Meta:
model = ProgramM
django_get_or_create = ('gaitid',)
class Params:
active = True
old_levels = Trait(
_using_results_framework=ProgramM.NOT_MIGRATED
)
has_rf = Trait(
generate_levels=PostGeneration(generate_mc_levels)
)
name = 'Health and Survival for Syrians in Affected Regions'
gaitid = Sequence(lambda n: "%0030d" % n)
country = RelatedFactory(CountryFactory, country='United States', code='US')
funding_status = LazyAttribute(lambda o: "funded" if o.active else "Inactive")
_using_results_framework = ProgramM.RF_ALWAYS
auto_number_indicators = True
generate_levels = None
@post_generation
def indicators(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if type(extracted) is list:
# Use the list of provided indicators
self.indicator_set.add(*extracted)
@post_generation
def countries(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if type(extracted) is list:
# Use the list of provided countries
self.country.add(*extracted)
class MatchFactory(Factory):
class Meta:
model = models.Match
id = Sequence(lambda n: n)
radiant_win = bool(randrange(0, 2))
duration = randrange(1500, 3500)
game_mode = 1
start_time = randrange(1423, 1752) * 100000
@staticmethod
def generate_with_all_stats(*args, **kwargs):
match = MatchFactory(*args, **kwargs)
heroes = list(
get_dota2_heroes(current_app.config['STEAM_API_KEY']).values())
pms = []
for slot in (list(range(5)) + list(range(128, 133))):
hero = heroes.pop(slot % len(heroes)).replace('npc_dota_hero_', '')
player = PlayerFactory()
season_stats = SeasonStatsFactory(season_id=match.season_id,
steam_id=player.steam_id)
pts_diff = 20 if slot < 6 else -20
if not match.radiant_win:
pts_diff = pts_diff * (-1)
pms.append(
PlayerMatchStatsFactory(match_id=match.id,
hero=hero,
pts_diff=pts_diff,
season_stats_id=season_stats.id,
player_slot=slot))
match.players_stats = pms
db.session.add(match)
db.session.flush()
return match
@staticmethod
def generate_batch_with_all_stats(amount, *args, **kwargs):
return [
MatchFactory.generate_with_all_stats(*args, **kwargs)
for i in range(amount)
]
class IncidentFactory(BaseFactory):
"""Incident Factory."""
id = Sequence(lambda n: f"1{n}")
title = FuzzyText()
description = FuzzyText()
status = FuzzyChoice(["Active", "Stable", "Closed"])
class Meta:
"""Factory Configuration."""
model = Incident
@post_generation
def participants(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for participant in extracted:
self.participants.append(participant)
class GroupFactory(DjangoModelFactory):
name = Faker('company')
status = Group.STATUS.active
kind = Group.KIND.quartet
code = ''
start_date = None
end_date = None
email = Faker('email')
phone = Faker('phone_number')
location = ''
website = ''
facebook = ''
twitter = ''
image = ''
description = ''
notes = ''
bhs_id = Sequence(lambda x: x)
parent = None
class Meta:
model = Group
class PersonFactory(DjangoModelFactory):
# name = Faker('name_male')
first_name = Faker('first_name_male')
middle_name = ''
last_name = Faker('last_name_male')
nick_name = ''
status = Person.STATUS.active
birth_date = None
location = ''
website = ''
facebook = ''
twitter = ''
email = LazyAttribute(lambda x: '{0}@barberscore.com'.format(x.bhs_id))
phone = ''
image = ''
description = ''
notes = ''
bhs_id = Sequence(lambda x: '1{0:05d}'.format(x))
class Meta:
model = Person
class IndicatorFactory(DjangoModelFactory):
class Meta:
model = IndicatorM
django_get_or_create = ('name', )
name = Sequence(lambda n: 'Indicator {0}'.format(n))
@post_generation
def program(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if type(extracted) is list:
# A list of program were passed in, use them
for program in extracted:
self.program.add(program)
elif extracted:
self.program.add(extracted)
else:
pass
class OrganizationFactory(DjangoModelFactory):
class Meta:
model = Organization
django_get_or_create = ["name"]
name = Sequence(lambda n: "Open Thing %d" % n)
# This is most useful if we get usable Organizations by default
status = 'approved'
@classmethod
def _create(cls, model_class, *args, **kwargs):
"""Override the default ``_create``to incorporate add_child."""
if 'parent' in kwargs.values():
parent = kwargs['parent']
elif model_class.get_first_root_node():
parent = model_class.get_first_root_node()
else:
parent = model_class.add_root(name='Root')
obj = model_class(**kwargs)
obj.slug = slugify(obj.name)
return parent.add_child(instance=obj)
class DocumentFactory(ResourceBaseFactory):
"""Document Factory."""
name = Sequence(lambda n: f"document{n}")
description = FuzzyText()
evergreen = Faker().pybool()
evergreen_owner = FuzzyText()
evergreen_reminder_interval = FuzzyInteger(low=0, high=100)
evergreen_last_reminder_at = FuzzyDateTime(datetime(2020, 1, 1,
tzinfo=UTC))
class Meta:
"""Factory Configuration."""
model = Document
@post_generation
def incident(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.incident_id = extracted.id
@post_generation
def report(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.report_id = extracted.id
@post_generation
def filters(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for filter in extracted:
self.filters.append(filter)
class CustomerFactory(Factory):
class Meta:
model = Customer
_start_date = '-2years'
_state_values = 'disabled,invited,enabled,declined'.split(',')
_opt_in_levels = 'single_opt_in,confirmed_opt_in,unknown'.split(',')
accepts_marketing = Faker("pybool")
accepts_marketing_updated_at = Faker("date_time_between", start_date=_start_date)
currency = Faker("currency_code")
created_at = Faker("date_time_between", start_date=_start_date)
default_address = SubFactory(
AddressFactory,
customer_id=SelfAttribute('..id'),
first_name=SelfAttribute('..first_name'),
last_name=SelfAttribute('..last_name'), phone=SelfAttribute('..phone')
)
addresses = LazyAttribute(lambda o: [o.default_address])
email = Faker("safe_email")
first_name = Faker("first_name")
id = Sequence(lambda n: n)
last_name = Faker("last_name")
last_order_id = Faker("random_int")
last_order_name = ''
orders_count = 0 # To be incremented with actual orders
state = Faker('random_element', elements=_state_values) # can be disabled, invited, enabled, declined
tags = ''
tax_exempt = Faker("pybool")
tax_exemptions = []
total_spent = 0.0 # To be incremented with actual orders
updated_at = SelfAttribute('created_at')
verified_email = True
admin_graphql_api_id = "dfsdfd"
marketing_opt_in_level = Faker('random_element', elements=_opt_in_levels)
multipass_identifier = ''
note = ''
phone = Faker("safe_e164")
metafield = None
class CategoryFactory(DjangoModelFactory):
parent = SubFactory(
'signals.apps.signals.factories.category.ParentCategoryFactory')
name = Sequence(lambda n: 'Category {}'.format(n))
slug = LazyAttribute(lambda o: slugify(o.name))
handling = FuzzyChoice([c[0] for c in Category.HANDLING_CHOICES])
handling_message = 'Test handling message (child category)'
is_active = True
questionnaire = None
public_name = None
is_public_accessible = False
class Meta:
model = Category
django_get_or_create = (
'parent',
'slug',
)
@post_generation
def departments(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for department in extracted:
self.departments.add(department,
through_defaults={
'is_responsible': True,
'can_view': True
})
@post_generation
def questions(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for question in extracted:
self.questions.add(question)
class SignalDepartmentsFactory(DjangoModelFactory):
class Meta:
model = SignalDepartments
_signal = SubFactory('signals.apps.signals.factories.signal.SignalFactory',
category_assignment=None)
created_by = Sequence(lambda n: 'beheerder{}@example.com'.format(n))
relation_type = fuzzy.FuzzyChoice(SignalDepartments.REL_CHOICES)
@post_generation
def set_one_to_one_relation(self, create, extracted, **kwargs):
self.signal = self._signal
@post_generation
def departments(self, create, extracted, **kwargs):
if not create:
return
if extracted:
# A list of groups were passed in, use them
for department in extracted:
self.departments.add(department)
class AuthorityFactory(BaseFactory):
"""Authority factory."""
name = Sequence(lambda n: "authority{0}".format(n))
owner = "*****@*****.**"
plugin = {"slug": "test-issuer"}
description = FuzzyText(length=128)
authority_certificate = SubFactory(CACertificateFactory)
class Meta:
"""Factory configuration."""
model = Authority
@post_generation
def roles(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for role in extracted:
self.roles.append(role)
