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)