class OrganizationFactory(SalesforceRecordFactory):
uuid = factory.LazyFunction(uuid4)
key = FuzzyText()
name = FuzzyText()
description = FuzzyText()
homepage_url = FuzzyURL()
logo_image = FuzzyText()
banner_image = FuzzyText()
certificate_logo_image = FuzzyText()
partner = factory.SubFactory(PartnerFactory)
class Meta:
model = Organization
class WorkflowInstanceFactory(BaseFactory):
"""WorkflowInstance Factory."""
parameters = [{}]
run_reason = FuzzyText()
status = FuzzyChoice(["Submitted", "Created", "Running", "Completed", "Failed"])
class Meta:
"""Factory Configuration."""
model = WorkflowInstance
@post_generation
def artifacts(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for artifact in extracted:
self.artifacts.append(artifact)
@post_generation
def workflow(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.workflow_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 creator(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.creator_id = extracted.id
class PluginFactory(BaseFactory):
"""Plugin Factory."""
title = FuzzyText()
slug = FuzzyText()
description = FuzzyText()
version = FuzzyText()
author = FuzzyText()
author_url = FuzzyText()
type = FuzzyText()
multiple = Faker().pybool()
class Meta:
"""Factory Configuration."""
model = Plugin
sqlalchemy_get_or_create = ("slug",)
class ServerFactory(DjangoModelFactory):
class Meta:
model = Server
name = LazyAttribute(lambda x: faker.text(max_nb_chars=20))
notes = LazyAttribute(
lambda x: faker.paragraph(nb_sentences=3, variable_nb_sentences=True))
virtual = Iterator([True, False])
ip_address = LazyAttribute(lambda o: faker.ipv4(network=False))
created = LazyAttribute(lambda x: faker.date_time_between(
start_date="-1y", end_date="now", tzinfo=timezone(settings.TIME_ZONE)))
online_date = LazyAttribute(lambda x: faker.date_time_between(
start_date="-1y", end_date="now", tzinfo=timezone(settings.TIME_ZONE)))
operating_system = SubFactory(OperatingSystemFactory)
server_id = LazyAttribute(
lambda x: FuzzyText(length=6, chars=string.digits).fuzz())
use = Iterator(Server.USE_CHOICES, getter=lambda x: x[0])
comments = LazyAttribute(
lambda x: faker.paragraph(nb_sentences=3, variable_nb_sentences=True))
class TriggerRuleFactory(factory.DjangoModelFactory):
class Meta:
model = TriggerRule
slug = FuzzyText()
title = 'OU812'
description = 'Oh, you ate one, too?'
url = 'https://wiki.mozilla.org/Firefox/Input'
is_enabled = True
@factory.post_generation
def products(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for product in extracted:
self.products.add(product)
def test_vendor_number_list_view(self):
for i in range(3):
user = UserFactory(is_staff=True)
user.first_name = 'Test'
user.save()
profile = user.profile
profile.vendor_number = FuzzyText().fuzz()
profile.save()
for i in range(3):
TravelAgentFactory()
with self.assertNumQueries(2):
response = self.forced_auth_req('get',
reverse('t2f:vendor_numbers'),
user=self.unicef_staff)
response_json = json.loads(response.rendered_content)
self.assertEqual(len(response_json), 6)
class SimulationFactory(BaseFactory):
"""Factory for creating mock users"""
class Meta: # pylint: disable=missing-docstring
model = Simulation
name = factory.Sequence(lambda n: 'sim%d' % n)
description = FuzzyText()
tsum1 = random.randint(700, 999)
tsum2 = random.randint(700, 999)
location_lat = random.randint(35, 37)
location_lon = random.randint(-4, 1)
location = "37.7, -4.88"
@classmethod
def create_batch(cls, size, **kwargs):
"""When creating batch, we create one less than requested size and then add admin user
at the end"""
super(SimulationFactory, cls).create_batch(size - 1, **kwargs)
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])
reporting_type = FuzzyChoice([name for name, __ in ReportingType.choices])
hidden = False
weeks_to_complete = FuzzyInteger(1)
license = 'all-rights-reserved'
has_ofac_restrictions = True
@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 PageContentFactory(factory.django.DjangoModelFactory):
page = factory.SubFactory(PageFactory)
language = FuzzyChoice(["en", "fr", "it"])
title = FuzzyText(length=12)
page_title = FuzzyText(length=12)
menu_title = FuzzyText(length=12)
meta_description = FuzzyText(length=12)
redirect = FuzzyText(length=12)
created_by = FuzzyText(length=12)
changed_by = FuzzyText(length=12)
in_navigation = FuzzyChoice([True, False])
soft_root = FuzzyChoice([True, False])
limit_visibility_in_menu = constants.VISIBILITY_USERS
template = 'page.html'
xframe_options = FuzzyInteger(0, 25)
class Meta:
model = PageContent
class VulnerabilityFactory(VulnerabilityGenericFactory,
HasParentHostOrService):
host = factory.SubFactory(HostFactory,
workspace=factory.SelfAttribute('..workspace'))
service = factory.SubFactory(
ServiceFactory, workspace=factory.SelfAttribute('..workspace'))
description = FuzzyText()
type = "vulnerability"
@classmethod
def build_dict(cls, **kwargs):
ret = super().build_dict(**kwargs)
assert ret['type'] == 'vulnerability'
ret['type'] = 'Vulnerability'
return ret
class Meta:
model = Vulnerability
sqlalchemy_session = db.session
def test_save_form_data(self, mock_optimize_from_buffer):
"""Calling save_form_data() on an OptimizedImageField calls optimize_from_buffer()."""
generic_model = factories.GenericModelFactory(title='Generic Model',
image=None)
# So far there is no optimized image, and mock_optimize_from_buffer has not been called
self.assertEqual(generic_model.image.name, None)
self.assertEqual(mock_optimize_from_buffer.call_count, 0)
new_io = io.StringIO()
new_io.write('something')
new_file = InMemoryUploadedFile(
new_io, 'image', 'static/images/{}.png'.format(FuzzyText().fuzz()),
'image/jpeg', len(new_io.getvalue()), 'utf-8')
# Call save_form_data on the OptimizedImageField
generic_model.image.field.save_form_data(generic_model, new_file)
# Now the mock_optimize_from_buffer has been called once
self.assertEqual(mock_optimize_from_buffer.call_count, 1)
self.assertEqual(mock_optimize_from_buffer.call_args[0][0], new_file)
def test_save_does_not_create_optimized_image(self,
mock_optimize_from_buffer):
"""Saving an image to an OptimizedImageField does not call optimize_from_buffer()."""
generic_model = factories.GenericModelFactory(title='Generic Model',
image=None)
# So far there is no optimized image, and mock_optimize_from_buffer has not been called
self.assertEqual(generic_model.image.name, None)
self.assertEqual(mock_optimize_from_buffer.call_count, 0)
new_io = io.StringIO()
new_io.write('something')
new_file = InMemoryUploadedFile(
new_io, 'image', 'static/images/{}.png'.format(FuzzyText().fuzz()),
'image/jpeg', len(new_io.getvalue()), 'utf-8')
generic_model.image = new_file
generic_model.save()
self.assertNotEqual(generic_model.image.name, None)
# The mock_optimize_from_buffer still has not been called
self.assertEqual(mock_optimize_from_buffer.call_count, 0)
def test_send_email(self):
self.assertEqual(len(mail.outbox), 0)
status_text = FuzzyText(length=400)
signal = SignalFactory.create(status__state=self.state,
status__text=status_text,
status__send_email=self.send_email,
reporter__email='*****@*****.**')
self.assertTrue(self.action(signal, dry_run=False))
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(
mail.outbox[0].subject,
f'Uw melding {signal.get_id_display()} {self.action.key}')
self.assertEqual(mail.outbox[0].to, [
signal.reporter.email,
])
self.assertEqual(mail.outbox[0].from_email,
settings.DEFAULT_FROM_EMAIL)
self.assertEqual(Note.objects.count(), 1)
self.assertTrue(Note.objects.filter(text=self.action.note).exists())
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
def test_happy_flow(self):
status_text = FuzzyText(length=400)
# create signal in prev status
signal = SignalFactory.create(status__state=self.prev_state,
status__text=status_text,
status__send_email=self.send_email,
reporter__email='*****@*****.**')
# create the new current state
status = StatusFactory.create(_signal=signal, state=self.state)
signal.status = status
signal.save()
feedback = FeedbackFactory.create(
allows_contact=True,
_signal=signal,
)
feedback.save()
self.assertTrue(self.rule(signal))
class LicenceFactory(DjangoModelFactory):
licence_type = factory.SubFactory(LicenceTypeFactory)
software = factory.SubFactory(SoftwareFactory)
region = factory.SubFactory(RegionFactory)
manufacturer = factory.SubFactory(ManufacturerFactory)
niw = FuzzyText()
number_bought = 10
invoice_date = date_now - timedelta(days=15)
valid_thru = date_now + timedelta(days=365)
invoice_no = factory.Sequence(lambda n: 'Invoice number ' + str(n))
budget_info = factory.SubFactory(BudgetInfoFactory)
sn = factory.Faker('ssn')
order_no = factory.Sequence(lambda n: 'Order number ' + str(n))
property_of = factory.SubFactory(AssetHolderFactory)
office_infrastructure = factory.SubFactory(OfficeInfrastructureFactory)
depreciation_rate = '100.00'
class Meta:
model = Licence
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(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 PostFactory(factory.DjangoModelFactory):
FACTORY_FOR = Post
title = factory.Sequence(lambda n: u'Post Title #{}'.format(n))
feed = factory.SubFactory(FeedFactory)
url = factory.LazyAttribute(
lambda obj: u'post-{}.html'.format(obj.feed.blog.url))
guid = factory.Sequence(lambda n: u'GUID-{}'.format(n))
content = FuzzyText(length=200)
@factory.post_generation
def authors(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if extracted:
# A list of groups were passed in, use them
for author in extracted:
PostAuthorDataFactory.create(post=self, author=author)
class FlightFactory(factory.django.DjangoModelFactory):
class Meta:
model = 'app.Flight'
django_get_or_create = ('ident', )
ident = FuzzyText(prefix='C', chars=string.ascii_uppercase, length=4)
flight_path = factory.LazyAttribute(lambda obj: LineString(
obj.departure_facility.location, obj.arrival_facility.location))
departure_facility = factory.Iterator(Facility.objects.all())
departure_time = FuzzyDateTime(utc_now_offset(hours=3))
arrival_facility = factory.Iterator(Facility.objects.reverse(
)) # Get a different iterator than departure_facility
arrival_time = factory.LazyAttribute(
lambda obj: obj.departure_time + datetime.timedelta(minutes=random.
randint(30, 90)))
status = FlightStatus.FILED.value
time = FuzzyDateTime(utc_now_offset())
location = FuzzyPoint()
heading = FuzzyInteger(0, 359)
class Comment(factory.Factory):
"""A factory class for creating CKAN datasets."""
class Meta:
model = model.Comment
thread = factory.LazyAttribute(lambda _: Thread())
content = FuzzyText("content:", 140)
@classmethod
def _create(cls, target_class, *args, **kwargs):
context = {"user": factories._get_action_user_name(kwargs)}
thread = kwargs.pop("thread")
kwargs["subject_id"] = thread["subject_id"]
kwargs["subject_type"] = thread["subject_type"]
comment_dict = helpers.call_action("comments_comment_create",
context=context,
**kwargs)
return comment_dict
class LocationFactory(DjangoModelFactory):
class Meta:
model = Location
_signal = SubFactory(
'signals.apps.signals.factories.signal.signal.SignalFactory',
location=None)
buurt_code = FuzzyText(length=4)
stadsdeel = FuzzyChoice(choices=(s[0] for s in STADSDELEN))
geometrie = get_puntje()
address = {
'straat': 'Sesamstraat',
'huisnummer': 666,
'postcode': '1011AA',
'openbare_ruimte': 'Ergens'
}
@post_generation
def set_one_to_one_relation(self, create, extracted, **kwargs):
self.signal = self._signal
class TaskFactory(ResourceBaseFactory):
"""Task Factory."""
resolved_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
last_reminder_at = FuzzyDateTime(datetime(2020, 1, 1, tzinfo=UTC))
creator = "*****@*****.**"
assignees = "*****@*****.**"
description = FuzzyText()
class Meta:
"""Factory Configuration."""
model = Task
@post_generation
def incident(self, create, extracted, **kwargs):
if not create:
return
if extracted:
self.incident_id = extracted.id
def test_send_email_anonymous(self):
self.assertEqual(len(mail.outbox), 0)
status_text = FuzzyText(length=400)
signal = SignalFactory.create(status__state=self.state,
status__text=status_text,
status__send_email=self.send_email,
reporter__email='')
self.assertFalse(self.action(signal, dry_run=False))
self.assertEqual(len(mail.outbox), 0)
self.assertEqual(Note.objects.count(), 0)
self.assertFalse(Note.objects.filter(text=self.action.note).exists())
signal = SignalFactory.create(status__state=self.state,
status__text=status_text,
status__send_email=self.send_email,
reporter__email=None)
self.assertFalse(self.action(signal, dry_run=False))
self.assertEqual(len(mail.outbox), 0)
self.assertEqual(Note.objects.count(), 0)
self.assertFalse(Note.objects.filter(text=self.action.note).exists())
class PatientFactory(factory.django.DjangoModelFactory):
last_name = factory.Faker("last_name")
id_document_number = FuzzyText(length=10, chars=string.digits)
job_title = factory.Faker("job")
birthdate = FuzzyDate(datetime.date(1920, 1, 1))
phone = FuzzyChoice([
"+593983761752",
"+13053991321",
"+593987309076",
"+16262005695",
"+918668999704",
])
whatsapp = FuzzyChoice([True, False, True, True])
health_insurance_company = FuzzyChoice(
["Health Inc", "Moderna", "BMI", "Google Health", "Apple Health"])
email = factory.Faker("free_email")
referral_source = FuzzyChoice(Patient.ReferralSourceChoices.values)
class Meta:
abstract = True
model = Patient
class EmploymentFactory(DjangoModelFactory):
"""
A factory for work history
"""
profile = SubFactory(ProfileFactory)
city = FuzzyText(suffix=" city")
country = FuzzyText(suffix=" land")
state_or_territory = FuzzyText(suffix=" state")
company_name = FuzzyText(suffix=" XYZ-ABC")
industry = FuzzyText(suffix=" IT")
position = FuzzyText(suffix=" developer")
end_date = FuzzyDate(date(1850, 1, 1))
start_date = FuzzyDate(date(1850, 1, 1))
class Meta: # pylint: disable=missing-docstring
model = Employment
class UserFactory(BaseFactory):
"""User Factory."""
username = Sequence(lambda n: "user{0}".format(n))
email = Sequence(lambda n: "user{0}@example.com".format(n))
active = True
password = FuzzyText(length=24)
certificates = []
class Meta:
"""Factory Configuration."""
model = User
@post_generation
def roles(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for role in extracted:
self.roles.append(role)
@post_generation
def certificates(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for cert in extracted:
self.certificates.append(cert)
@post_generation
def authorities(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for authority in extracted:
self.authorities.append(authority)
class AgentFactory(FaradayFactory):
name = FuzzyText()
active = True
@factory.post_generation
def workspaces(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if extracted:
# A list of groups were passed in, use them
for workspace in extracted:
self.workspaces.append(workspace)
else:
self.workspaces.append(WorkspaceFactory())
self.workspaces.append(WorkspaceFactory())
class Meta:
model = Agent
sqlalchemy_session = db.session
def test_context(self):
"""
Assert context values for logged in user
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
self.client.force_login(profile.user)
# ProgramFaculty and ProgramCourse are asserted via ProgramPageSerializer below
FacultyFactory.create_batch(3, program_page=self.program_page)
courses = self.program_page.program.course_set.all()
ProgramCourseFactory.create_batch(len(courses),
program_page=self.program_page,
course=Iterator(courses))
ga_tracking_id = FuzzyText().fuzz()
with self.settings(
GA_TRACKING_ID=ga_tracking_id,
ENVIRONMENT='environment',
VERSION='version',
):
response = self.client.get(self.program_page.url)
assert response.context['authenticated'] is True
assert response.context['username'] is None
assert response.context['title'] == self.program_page.title
assert response.context['is_public'] is True
assert response.context['has_zendesk_widget'] is True
assert response.context['is_staff'] is False
self.assertContains(response, 'Share this page')
js_settings = json.loads(response.context['js_settings_json'])
assert js_settings == {
'gaTrackingID': ga_tracking_id,
'environment': 'environment',
'sentry_dsn': None,
'host': 'testserver',
'release_version': 'version',
'user': serialize_maybe_user(profile.user),
'program': ProgramPageSerializer(self.program_page).data,
}
class RoomV4Factory(DjangoModelFactory):
class Meta:
model = RoomV4
id = factory.LazyFunction(uuid.uuid4)
name = FuzzyText(length=60)
image = factory.django.ImageField()
default_image = factory.SubFactory(DefaultRoomImageFactory)
owner = factory.SubFactory(AccountFactory)
@factory.post_generation
def participants(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for _participant in extracted:
self.participants.add(_participant)
@factory.post_generation
def left_members(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for _left_member in extracted:
self.left_members.add(_left_member)
@factory.post_generation
def closed_members(self, create, extracted, **kwargs):
if not create:
return
if extracted:
for _closed_member in extracted:
self.closed_members.add(_closed_member)
max_num_participants = 1
is_exclude_different_gender = False
created_at = timezone.now()
is_end = False
is_active = False
class UserFactory(factory.django.DjangoModelFactory):
username = FuzzyText(length=12)
first_name = factory.Faker("first_name")
last_name = factory.Faker("last_name")
email = factory.LazyAttribute(lambda u: "*****@*****.**" %
(u.first_name.lower(), u.last_name.lower()))
class Meta:
model = get_user_model()
@classmethod
def _create(cls, model_class, *args, **kwargs):
"""Return existing user instance if found.
Otherwise create a new user."""
manager = cls._get_manager(model_class)
username = kwargs.get("username")
if username is not None:
try:
return manager.get(username=username)
except model_class.DoesNotExist:
pass
return manager.create_user(*args, **kwargs)
