class PostFactory(DjangoModelFactory):
class Meta:
model = models.Post
title = Sequence(lambda count: 'title{}'.format(count))
text = Sequence(lambda count: '# post text\ntext {}'.format(count))
is_public = True
description = LazyAttribute(
lambda instance: '{}_description'.format(instance.title))
keywords = LazyAttribute(
lambda instance: '{}_keyword'.format(instance.title))
created_at = FuzzyDateTime(
start_dt=timezone.datetime(2021, 1, 1, tzinfo=tzinfo))
updated_at = FuzzyDateTime(
start_dt=timezone.datetime(2021, 1, 1, tzinfo=tzinfo))
@post_generation
def tags(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for tag in extracted:
self.tags.add(tag)
@post_generation
def relation_posts(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for post in extracted:
self.relation_posts.add(post)
class CourseRunFactory(factory.DjangoModelFactory):
status = CourseRunStatus.Published
uuid = factory.LazyFunction(uuid4)
key = FuzzyText(prefix='course-run-id/', suffix='/fake')
course = factory.SubFactory(CourseFactory)
title_override = None
short_description_override = None
full_description_override = None
language = factory.Iterator(LanguageTag.objects.all())
start = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC))
end = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC)).end_dt
enrollment_start = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC))
enrollment_end = FuzzyDateTime(datetime.datetime(2014, 1, 1,
tzinfo=UTC)).end_dt
announcement = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC))
card_image_url = FuzzyURL()
video = factory.SubFactory(VideoFactory)
min_effort = FuzzyInteger(1, 10)
max_effort = FuzzyInteger(10, 20)
pacing_type = FuzzyChoice([name for name, __ in CourseRunPacing.choices])
slug = FuzzyText()
weeks_to_complete = FuzzyInteger(1)
@factory.post_generation
def staff(self, create, extracted, **kwargs):
if create:
add_m2m_data(self.staff, extracted)
class Meta:
model = CourseRun
@factory.post_generation
def transcript_languages(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.transcript_languages, extracted)
class CourseRunFactory(factory.DjangoModelFactory):
course = factory.SubFactory(CourseFactory)
start = FuzzyDateTime(datetime(2014, 1, 1, tzinfo=UTC))
end = FuzzyDateTime(datetime(2014, 1, 1, tzinfo=UTC)).end_dt
certificate_generation = FuzzyDateTime(datetime(2014, 1, 1, tzinfo=UTC))
min_effort = FuzzyInteger(1, 10)
max_effort = FuzzyInteger(10, 20)
language = factory.Iterator(LanguageTag.objects.all())
pacing_type = FuzzyChoice(CourseRunPacing.values.keys())
length = FuzzyInteger(1, 10)
notes = FuzzyText()
preview_url = factory.Faker('url')
contacted_partner_manager = FuzzyChoice((True, False))
video_language = factory.Iterator(LanguageTag.objects.all())
short_description_override = FuzzyText()
title_override = FuzzyText()
full_description_override = FuzzyText()
@factory.post_generation
def staff(self, create, extracted, **kwargs): # pylint: disable=unused-argument
if create:
add_m2m_data(self.staff, extracted)
@factory.post_generation
def transcript_languages(self, create, extracted, **kwargs): # pylint: disable=unused-argument
if create:
add_m2m_data(self.transcript_languages, extracted)
class Meta:
model = CourseRun
class SensorFactory(factory.Factory):
class Meta:
model = Sensor
sensor_id = factory.LazyAttribute(lambda s: '%s_%s' %
(s.segment_id, s.sensor_type))
segment_id = factory.LazyAttribute(lambda s: 'Z1_64TG3_CONT_%s-%s' %
(utils.datetime_to_str(s.started_at),
utils.datetime_to_str(s.ended_at)))
sensor_type = factory.Iterator(Sensor.SENSOR_TYPES)
project_name = fuzzy.FuzzyText(length=4,
chars=string.ascii_uppercase +
string.digits)
car_id = fuzzy.FuzzyText(length=5,
chars=string.ascii_uppercase + string.digits)
cluster_id = fuzzy.FuzzyText(length=4,
prefix='cl-',
chars=string.ascii_lowercase + string.digits)
started_at = FuzzyDateTime(datetime(2010, 1, 1, tzinfo=UTC))
ended_at = FuzzyDateTime(datetime(2010, 1, 1, tzinfo=UTC))
created_at = FuzzyDateTime(datetime(2010, 1, 1, tzinfo=UTC))
updated_at = FuzzyDateTime(datetime(2010, 1, 1, tzinfo=UTC))
state = Sensor.State.CREATED
tags = ['test', 'raining']
perm_path = factory.LazyAttribute(lambda d: '/perm/path/%s' % d.segment_id)
output_path = factory.LazyAttribute(
lambda d: '/output/path/%s' % d.segment_id)
resim_path = factory.LazyAttribute(
lambda d: '/resim/path/%s' % d.segment_id)
class CommandFactory(WorkspaceObjectFactory):
command = FuzzyText()
tool = FuzzyText()
end_date = FuzzyDateTime(datetime.datetime.utcnow().replace(tzinfo=pytz.utc) + datetime.timedelta(20), datetime.datetime.utcnow().replace(tzinfo=pytz.utc) + datetime.timedelta(30))
start_date = FuzzyDateTime(datetime.datetime.utcnow().replace(tzinfo=pytz.utc) - datetime.timedelta(30), datetime.datetime.utcnow().replace(tzinfo=pytz.utc) - datetime.timedelta(20))
ip = FuzzyText()
user = FuzzyText()
hostname = FuzzyText()
import_source = 'shell'
class Meta:
model = Command
sqlalchemy_session = db.session
@factory.post_generation
def attach_vuln_object(self, create, extracted, **kwargs):
if create:
host = HostFactory.create(workspace=self.workspace)
vuln = VulnerabilityFactory.create(workspace=self.workspace, host=host, service=None, severity='low')
db.session.flush()
CommandObjectFactory.create(
object_type='vulnerability',
object_id=vuln.id,
command=self,
workspace=self.workspace
)
CommandObjectFactory.create(
object_type='host',
object_id=host.id,
command=self,
workspace=self.workspace
)
class EventFactory(BaseFactory):
"""Event Factory."""
uuid = LazyAttribute(lambda _: str(uuid.uuid4()))
started_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
ended_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
source = FuzzyText()
description = FuzzyText()
class Meta:
"""Factory Configuration."""
model = Event
@post_generation
def incident(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.incident_id = extracted.id
@post_generation
def individual_contact(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.individual_contact_id = extracted.id
class SegmentFactory(factory.Factory):
class Meta:
model = Segment
segment_id = factory.LazyAttribute(
lambda d: '%s-%s' % (d.drive_id, utils.datetime_to_str(d.ended_at)))
sequence = factory.Sequence(lambda n: '%04d' % (n + 1, ))
drive_id = factory.LazyAttribute(lambda s: '%s_%s_CONT_%s' % (
s.project_name, s.car_id, utils.datetime_to_str(s.started_at)))
project_name = fuzzy.FuzzyText(length=4,
chars=string.ascii_uppercase +
string.digits)
car_id = fuzzy.FuzzyText(length=5,
chars=string.ascii_uppercase + string.digits)
cluster_id = fuzzy.FuzzyText(length=4,
prefix='cl-',
chars=string.ascii_lowercase + string.digits)
started_at = FuzzyDateTime(datetime(2010, 1, 1, tzinfo=UTC))
ended_at = FuzzyDateTime(datetime(2010, 1, 1, tzinfo=UTC))
created_at = FuzzyDateTime(datetime(2010, 1, 1, tzinfo=UTC))
updated_at = FuzzyDateTime(datetime(2010, 1, 1, tzinfo=UTC))
state = Segment.State.CREATED
tags = ['test', 'raining']
perm_path = factory.LazyAttribute(lambda d: '/perm/path/%s/%s' %
(d.drive_id, d.segment_id))
output_path = factory.LazyAttribute(lambda d: '/output/path/%s/%s' %
(d.drive_id, d.segment_id))
resim_path = factory.LazyAttribute(lambda d: '/resim/path/%s/%s' %
(d.drive_id, d.segment_id))
class ChallengeFactory(factory.django.DjangoModelFactory):
class Meta:
model = Challenge
target = FuzzyChoice(choices=settings.CHALLENGE_TYPES)
type = FuzzyChoice(choices=('set', 'numeric'))
name = FuzzyText(length=50)
description = FuzzyText(length=1000)
rating = FuzzyInteger(0, 5)
number = FuzzyInteger(0, 50)
multiplier = FuzzyInteger(1, 5)
bonus = FuzzyInteger(0, 200)
complete_bonus = FuzzyInteger(0, 1000)
start_time = FuzzyDateTime(datetime.datetime.now().replace(tzinfo=UTC))
end_time = FuzzyDateTime(start_dt=datetime.datetime(2099, 1, 1,
tzinfo=UTC),
end_dt=datetime.datetime(2199, 1, 1, tzinfo=UTC))
index = FuzzyInteger(0, 9999)
image = None
@factory.post_generation
def solarsystemobjects(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for solarsystemobject in extracted:
self.solarsystemobjects.add(solarsystemobject)
@factory.post_generation
def astroobjects(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for astroobject in extracted:
self.astroobjects.add(astroobject)
class TaskFactory(ResourceBaseFactory):
"""Task Factory."""
description = FuzzyText()
last_reminder_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
priority = FuzzyChoice(["Low", "Medium", "High"])
reminders = Faker().pybool()
resolve_by = FuzzyDateTime(datetime(2020, 1, 2, tzinfo=UTC))
resolved_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
source = FuzzyChoice(["Incident", "Post Incident Review"])
status = FuzzyChoice(["Open", "Resolved"])
incident = SubFactory(IncidentFactory)
class Meta:
"""Factory Configuration."""
model = Task
@post_generation
def creator(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.creator_id = extracted.id
@post_generation
def owner(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.owner_id = extracted.id
@post_generation
def incident(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.incident_id = extracted.id
@post_generation
def assignees(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for assignee in extracted:
self.assignees.append(assignee)
@post_generation
def tickets(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for ticket in extracted:
self.tickets.append(ticket)
class CourseRunFactory(factory.DjangoModelFactory):
class Meta:
model = CourseRun
course = factory.SubFactory(CourseFactory)
uuid = factory.LazyFunction(uuid4)
key = FuzzyText(prefix='course-run-id/', suffix='/fake')
title_override = None
start_date = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC))
end_date = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC)).end_dt
class ElectionFactory(DjangoModelFactory):
FACTORY_FOR = Election
name_english = Sequence(lambda n: "Election %d" % n)
name_arabic = Sequence(lambda n: "Election %d (ar)" % n)
polling_start_time = FuzzyDateTime(start_dt=start_dt - timedelta(days=2),
end_dt=start_dt - timedelta(days=1))
polling_end_time = FuzzyDateTime(start_dt=start_dt + timedelta(days=2),
end_dt=start_dt + timedelta(days=3))
class ParticipantFactory(BaseFactory):
"""Participant Factory."""
is_active = True
active_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
inactive_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
class Meta:
"""Factory Configuration."""
model = Participant
@post_generation
def incident(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.incident_id = extracted.id
@post_generation
def individual_contact(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.individual_contact_id = extracted.id
@post_generation
def team(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.team_id = extracted.id
@post_generation
def participant_roles(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for participant_role in extracted:
self.participant_roles.append(participant_role)
@post_generation
def status_reports(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for report in extracted:
self.status_reports.append(report)
class EventFactory(DjangoModelFactory):
name = FuzzyText()
start_date = FuzzyDateTime(
start_dt=datetime.datetime(2019, 1, 1, tzinfo=datetime.timezone.utc),
end_dt=datetime.datetime(2019, 12, 31, tzinfo=datetime.timezone.utc))
finish_date = FuzzyDateTime(
start_dt=datetime.datetime(2019, 1, 1, tzinfo=datetime.timezone.utc),
end_dt=datetime.datetime(2019, 12, 31, tzinfo=datetime.timezone.utc))
venue = SubFactory(VenueFactory)
class Meta:
model = 'events.Event'
class ActivityFactory(DjangoModelFactory):
event = SubFactory(EventFactory)
zone = SubFactory(ZoneFactory)
type = FuzzyChoice(choices=ActivityType.values)
start_date = FuzzyDateTime(
start_dt=datetime.datetime(2019, 1, 1, tzinfo=datetime.timezone.utc),
end_dt=datetime.datetime(2019, 12, 31, tzinfo=datetime.timezone.utc))
finish_date = FuzzyDateTime(
start_dt=datetime.datetime(2019, 1, 1, tzinfo=datetime.timezone.utc),
end_dt=datetime.datetime(2019, 12, 31, tzinfo=datetime.timezone.utc))
class Meta:
model = 'events.Activity'
class TaskFactory(DjangoModelFactory):
class Meta:
model = models.Task
title = Sequence(lambda count: 'title{}'.format(count))
text = Sequence(lambda count: '# post text\ntext {}'.format(count))
is_done = False
point = FuzzyInteger(1, 1000)
target_date = FuzzyDateTime(
start_dt=timezone.datetime(2021, 1, 1, tzinfo=tzinfo))
created_at = FuzzyDateTime(
start_dt=timezone.datetime(2021, 1, 1, tzinfo=tzinfo))
updated_at = FuzzyDateTime(
start_dt=timezone.datetime(2021, 1, 1, tzinfo=tzinfo))
class CommandFactory(WorkspaceObjectFactory):
command = FuzzyText()
tool = FuzzyText()
end_date = FuzzyDateTime(
datetime.datetime.utcnow().replace(tzinfo=pytz.utc) +
datetime.timedelta(20),
datetime.datetime.utcnow().replace(tzinfo=pytz.utc) +
datetime.timedelta(30))
start_date = FuzzyDateTime(
datetime.datetime.utcnow().replace(tzinfo=pytz.utc) -
datetime.timedelta(30),
datetime.datetime.utcnow().replace(tzinfo=pytz.utc) -
datetime.timedelta(20))
ip = FuzzyText()
user = FuzzyText()
hostname = FuzzyText()
import_source = 'shell'
class Meta:
model = Command
sqlalchemy_session = db.session
@factory.post_generation
def attach_vuln_object(self, create, extracted, **kwargs):
if create:
host = HostFactory.create(workspace=self.workspace)
vuln = VulnerabilityFactory.create(workspace=self.workspace,
host=host,
service=None,
severity='low')
db.session.flush()
CommandObjectFactory.create(object_type='vulnerability',
object_id=vuln.id,
command=self,
workspace=self.workspace)
CommandObjectFactory.create(object_type='host',
object_id=host.id,
command=self,
workspace=self.workspace)
@classmethod
def build_dict(cls, **kwargs):
# Ugly hack to JSON-serialize datetimes
ret = super().build_dict(**kwargs)
ret['itime'] = time.mktime(ret['start_date'].utctimetuple())
ret['duration'] = (ret['end_date'] - ret['start_date']).seconds + (
(ret['end_date'] - ret['start_date']).microseconds / 1000000.0)
ret.pop('start_date')
ret.pop('end_date')
return ret
class EventFactory(factory.django.DjangoModelFactory):
venue = factory.SubFactory(VenueFactory)
title = factory.Sequence(lambda n: f"event {n}")
description = FuzzyText(length=100)
host = FuzzyText(length=20)
# any time before now
start_time = FuzzyDateTime(start_dt=now() - datetime.timedelta(days=30), )
end_time = FuzzyDateTime(
start_dt=now() + datetime.timedelta(seconds=1),
end_dt=now() + datetime.timedelta(days=2),
)
class Meta:
model = Event
class FeedbackFactory(BaseFactory):
"""Feedback Factory."""
created_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
rating = FuzzyChoice([
"Very satisfied",
"Somewhat satisfied",
"Neither satisfied nor dissatisfied",
"Somewhat dissatisfied",
"Very dissatisfied",
])
feedback = FuzzyText()
class Meta:
"""Factory Configuration."""
model = Feedback
@post_generation
def incident(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.incident_id = extracted.id
@post_generation
def participant(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.participant_id = extracted.id
class SchemaResponseFactory(DjangoModelFactory):
initiator = factory.SubFactory(AuthUserFactory)
revision_justification = "We're talkin' about practice!"
submitted_timestamp = FuzzyDateTime(
datetime.datetime(1970, 1, 1, tzinfo=pytz.UTC))
registration = factory.SubFactory(RegistrationFactory)
class Meta:
model = models.SchemaResponse
@classmethod
def _create(cls, *args, **kwargs):
from django.contrib.contenttypes.models import ContentType
SchemaResponse = models.SchemaResponse
justification = kwargs.get('revision_justification')
initiator = kwargs.get('initiator')
registration = kwargs.get('registration')
content_type = ContentType.objects.get_for_model(registration)
schema = registration.registered_schema.get()
if not registration.schema_responses.exists():
return SchemaResponse.create_initial_response(
initiator, registration, schema, justification)
else:
previous_schema_response = SchemaResponse.objects.filter(
object_id=registration.id, content_type_id=content_type).get()
previous_schema_response.approvals_state_machine.set_state(
ApprovalStates.APPROVED)
previous_schema_response.save()
return SchemaResponse.create_from_previous_response(
initiator, previous_schema_response, justification)
class ReportFactory(BaseFactory):
"""Report Factory."""
created_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
details = FuzzyText()
details_raw = FuzzyText()
type = FuzzyChoice(["Tactical Report", "Executive Report"])
class Meta:
"""Factory Configuration."""
model = Report
@post_generation
def incident(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.incident_id = extracted.id
@post_generation
def participant(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.participant_id = extracted.id
class PersonFactory(factory.django.DjangoModelFactory):
class Meta:
model = Person
age = FuzzyInteger(21, 99)
eye_color = FuzzyChoice([Person.EYE_BLUE, Person.EYE_BROWN])
name = factory.Sequence(lambda n: f"Person{n}")
gender = FuzzyChoice([Person.GENDER_MALE, Person.GENDER_FEMALE])
phone = factory.Sequence(lambda n: "0486-992-%03d" % n)
email = factory.LazyAttribute(lambda obj: f"{obj.name}@test.com".lower())
address = factory.Faker("address")
registered = FuzzyDateTime(datetime.datetime(2020, 1, 1, tzinfo=UTC))
company = factory.SubFactory(CompanyFactory)
about = FuzzyText()
greeting = FuzzyText()
balance = FuzzyDecimal(low=0)
@factory.post_generation
def favourite_foods(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for food in extracted:
self.favourite_foods.add(food)
@factory.post_generation
def friends(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for friend in extracted:
self.friends.add(friend)
class EmptyCommandFactory(WorkspaceObjectFactory):
"""
A command without command objects.
"""
command = FuzzyText()
tool = FuzzyText()
end_date = FuzzyDateTime(datetime.datetime.utcnow().replace(tzinfo=pytz.utc) + datetime.timedelta(20), datetime.datetime.utcnow().replace(tzinfo=pytz.utc) + datetime.timedelta(30))
start_date = FuzzyDateTime(datetime.datetime.utcnow().replace(tzinfo=pytz.utc) - datetime.timedelta(30), datetime.datetime.utcnow().replace(tzinfo=pytz.utc) - datetime.timedelta(20))
ip = FuzzyText()
user = FuzzyText()
hostname = FuzzyText()
import_source = 'shell'
class Meta:
model = Command
sqlalchemy_session = db.session
class OrderFactory(PeeweeModelFactory):
class Meta:
model = operational.Order
customer = factory.LazyFunction(
lambda: operational.Customer.select().order_by(fn.Rand()).get())
created_at = FuzzyDateTime(
start_dt=(datetime.now(pytz.timezone('Europe/Belgrade')) -
relativedelta(years=1)),
end_dt=datetime.now(pytz.timezone('Europe/Belgrade'))
) #factory.Faker('date_time_this_year', before_now=True, after_now=False, tzinfo=None)
status = FuzzyChoice([status[0] for status in Order.OrderStatus])
@factory.post_generation
def articles(self, create, extracted, **kwargs):
if not create:
return
n_offers = randrange(1, 5)
offers = [
offer
for offer in Offer.select().order_by(fn.Rand()).limit(n_offers)
]
for i in range(n_offers):
offer_order = OfferOrder()
offer_order.order_id = self.id
offer_order.offer = offers[i]
offer_order.amount = randrange(1, 2)
offer_order.save(force_insert=True)
class MessageFactory(DjangoModelFactory):
class Meta:
model = models.Message
content = Sequence(lambda count: 'content{}'.format(count))
created_at = FuzzyDateTime(
start_dt=timezone.datetime(2021, 1, 1, tzinfo=tzinfo))
class FinancialAidFactory(DjangoModelFactory):
"""
Factory for FinancialAid
"""
# user = SubFactory(UserFactory) is implied, since it is created in the cls.create() method
tier_program = SubFactory(TierProgramFactory)
status = FuzzyChoice(
# the reset status is a special case, so removing it from the options
[
status for status in FinancialAidStatus.ALL_STATUSES
if status != FinancialAidStatus.RESET
])
income_usd = FuzzyFloat(low=0, high=12345)
original_income = FuzzyFloat(low=0, high=12345)
original_currency = Faker('currency_code')
country_of_income = Faker('country_code')
country_of_residence = Faker('country_code')
date_exchange_rate = FuzzyDateTime(
datetime.datetime(2000, 1, 1, tzinfo=UTC))
date_documents_sent = FuzzyDate(datetime.date(2000, 1, 1))
@classmethod
def create(cls, **kwargs):
"""
Overrides the default .create() method so that if no user is specified in kwargs, this factory
will create a user with an associated profile without relying on signals.
"""
if "user" not in kwargs:
with mute_signals(post_save):
profile = ProfileFactory.create()
kwargs["user"] = profile.user
return super().create(**kwargs)
class Meta:
model = FinancialAid
class PersonFactory(factory.django.DjangoModelFactory):
class Meta:
model = Person
guid = FuzzyText(length=10, chars=string.ascii_lowercase + string.digits)
age = FuzzyInteger(21, 99)
eye_color = 'brown'
name = factory.Sequence(lambda n: "User{}".format(n))
gender = 'Male'
phone = factory.Sequence(lambda n: '0486-992-%03d' % n)
email = factory.LazyAttribute(
lambda obj: u'{}@test.com'.format(obj.name).lower())
address = factory.Faker('address')
registered = FuzzyDateTime(datetime.datetime(2020, 1, 1, tzinfo=UTC))
company = factory.SubFactory(CompanyFactory)
@factory.post_generation
def favourite_food(self, create, extracted, **kwargs):
if not create:
# simple build, do nothing
return
if extracted:
for food in extracted:
self.favourite_food.add(food)
@factory.post_generation
def friends(self, create, extracted, **kwargs):
if not create:
# simple build, do nothing
return
if extracted:
for friend in extracted:
self.friends.add(friend)
class AccessTokenFactory(DjangoModelFactory):
class Meta:
model = models.AccessToken
access_token = Sequence(lambda count: 'access2token{}'.format(count))
created_at = FuzzyDateTime(
start_dt=timezone.datetime(2021, 1, 1, tzinfo=tzinfo))
class StatusReportFactory(BaseFactory):
"""Status Report Factory."""
created_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
conditions = FuzzyText()
actions = FuzzyText()
needs = FuzzyText()
class Meta:
"""Factory Configuration."""
model = StatusReport
@post_generation
def incident(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.incident_id = extracted.id
@post_generation
def participant(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.participant_id = extracted.id
class CourseRunFactory(SalesforceRecordFactory):
status = CourseRunStatus.Published
uuid = factory.LazyFunction(uuid4)
key = FuzzyText(prefix='course-run-id/', suffix='/fake')
external_key = None
course = factory.SubFactory(CourseFactory)
title_override = None
short_description_override = None
full_description_override = None
language = factory.Iterator(LanguageTag.objects.all())
start = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC))
end = FuzzyDateTime(datetime.datetime.now(tz=UTC),
datetime.datetime(2030, 1, 1, tzinfo=UTC))
go_live_date = None
enrollment_start = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC))
enrollment_end = FuzzyDateTime(datetime.datetime.now(tz=UTC),
datetime.datetime(2029, 1, 1, tzinfo=UTC))
announcement = FuzzyDateTime(datetime.datetime(2014, 1, 1, tzinfo=UTC))
card_image_url = FuzzyURL()
video = factory.SubFactory(VideoFactory)
min_effort = FuzzyInteger(1, 9)
max_effort = FuzzyInteger(10, 20)
pacing_type = FuzzyChoice([name for name, __ in CourseRunPacing.choices])
reporting_type = FuzzyChoice([name for name, __ in ReportingType.choices])
hidden = False
weeks_to_complete = FuzzyInteger(1)
license = 'all-rights-reserved'
has_ofac_restrictions = True
type = factory.SubFactory(CourseRunTypeFactory)
@factory.post_generation
def staff(self, create, extracted, **kwargs):
if create:
add_m2m_data(self.staff, extracted)
class Meta:
model = CourseRun
@factory.post_generation
def transcript_languages(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.transcript_languages, extracted)
@factory.post_generation
def authoring_organizations(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.authoring_organizations, extracted)
class EventDescriptionFactory(factory_boy.DjangoModelFactory):
class Meta:
model = models.EventDescription
title = factory_boy.Sequence(lambda _: ' '.join(faker.words(5)))
description = factory_boy.Sequence(lambda _: ' '.join(faker.words(5)))
resolution_date = FuzzyDateTime(datetime.now(pytz.utc))
ipfs_hash = factory_boy.Sequence(lambda n: '{:046d}'.format(n))
