class CrsAddFactory(NoDatabaseFactory):
class Meta:
model = iati.models.CrsAdd
activity = SubFactory(ActivityFactory)
channel_code = "21039"
loan_terms = RelatedFactory(CrsAddLoanTermsFactory, 'crs_add')
loan_status = RelatedFactory(CrsAddLoanStatusFactory, 'crs_add')
class TeamFactory(DjangoModelFactory):
user = SubFactory(UserFactory)
teammates = RelatedFactory(UserFactory)
requirements = RelatedFactory(UserFactory)
class Meta:
model = models.Team
class ResultFactory(NoDatabaseFactory):
class Meta:
model = iati.models.Result
activity = SubFactory(ActivityFactory)
type = SubFactory(ResultTypeFactory)
aggregation_status = False
resulttitle = RelatedFactory(ResultTitleFactory, 'result')
resultdescription = RelatedFactory(ResultDescriptionFactory, 'result')
class ResultIndicatorFactory(NoDatabaseFactory):
class Meta:
model = iati.models.ResultIndicator
result = SubFactory(ResultFactory)
resultindicatortitle = RelatedFactory(ResultIndicatorTitleFactory,
'result_indicator')
resultindicatordescription = RelatedFactory(
ResultIndicatorDescriptionFactory, 'result_indicator')
measure = SubFactory(IndicatorMeasureFactory)
ascending = True
class UserFactory(Factory):
class Meta:
model = settings.AUTH_USER_MODEL
strategy = CREATE_STRATEGY
first_name = LazyFunction(fake.first_name)
last_name = LazyFunction(fake.last_name)
email = LazyFunction(fake.email)
username = LazyAttribute(lambda o: o.email)
password = PostGeneration(
lambda obj, *args, **kwargs: obj.set_password(DEFAULT_PASSWORD))
profile = RelatedFactory(ProfileFactory, "user")
active_email = RelatedFactory(EmailAddressFactory, "user", email=email)
class ResultIndicatorPeriodFactory(NoDatabaseFactory):
class Meta:
model = iati.models.ResultIndicatorPeriod
result_indicator = SubFactory(ResultIndicatorFactory)
resultindicatorperiodactualcomment = RelatedFactory(
ResultIndicatorPeriodActualCommentFactory, 'result_indicator_period')
resultindicatorperiodtargetcomment = RelatedFactory(
ResultIndicatorPeriodTargetCommentFactory, 'result_indicator_period')
period_start = "2013-01-01"
period_end = "2013-03-31"
target = "10"
actual = "11"
class SignalFactory(DjangoModelFactory):
class Meta:
model = Signal
signal_id = FuzzyAttribute(uuid.uuid4)
text = LazyFunction(fake.paragraph)
text_extra = LazyFunction(fake.paragraph)
# Creating (reverse FK) related objects after this `Signal` is created.
location = RelatedFactory(
'signals.apps.signals.factories.location.LocationFactory', '_signal')
status = RelatedFactory(
'signals.apps.signals.factories.status.StatusFactory', '_signal')
category_assignment = RelatedFactory(
'signals.apps.signals.factories.category_assignment.CategoryAssignmentFactory',
'_signal',
)
reporter = RelatedFactory(
'signals.apps.signals.factories.reporter.ReporterFactory', '_signal')
priority = RelatedFactory(
'signals.apps.signals.factories.priority.PriorityFactory', '_signal')
incident_date_start = FuzzyDateTime(timezone.now() - timedelta(days=100),
timezone.now())
incident_date_end = LazyAttribute(
lambda o: _incident_date_end(o.incident_date_start))
extra_properties = {}
# SIG-884
parent = None
@post_generation
def set_one_to_one_relations(self, create, extracted, **kwargs):
"""Set o2o relations on given `Signal` object."""
self.location = self.locations.last()
self.status = self.statuses.last()
self.category_assignment = self.category_assignments.last()
self.reporter = self.reporters.last()
self.priority = self.priorities.last()
@post_generation
def set_default_type(self, create, extracted, **kwargs):
"""
This will add the default Type to the signal for a factory created signal
"""
if create:
from . import TypeFactory
TypeFactory(
_signal=self) # By default the type is set to "SIG (SIGNAL)"
class ResultIndicatorFactory(NoDatabaseFactory):
class Meta:
model = iati.models.ResultIndicator
result = SubFactory(ResultFactory)
resultindicatortitle = RelatedFactory(ResultIndicatorTitleFactory,
'result_indicator')
resultindicatordescription = RelatedFactory(
ResultIndicatorDescriptionFactory, 'result_indicator')
resultindicatorbaselinecomment = RelatedFactory(
ResultIndicatorBaselineCommentFactory, 'result_indicator')
measure = SubFactory(IndicatorMeasureFactory)
ascending = True
baseline_year = 2012
baseline_value = "10"
class DataFactory(DjangoModelFactory):
name = "test Data"
update_frequency = SubFactory(factories.UpdateFrequencyFactory)
area = SubFactory(factories.AreaFactory)
timeliness = SubFactory(factories.TimelinessFactory)
data_policy = SubFactory(factories.DataPolicyFactory)
data_type = SubFactory(factories.DataTypeFactory)
data_format = SubFactory(factories.DataFormatFactory)
status = SubFactory(factories.StatusFactory)
quality_control_procedure = SubFactory(factories.QualityControlProcedureFactory)
inspire_themes = RelatedFactory(factories.InspireThemeFactory)
dissemination = SubFactory(factories.DisseminationFactory)
geographical_coverage = RelatedFactory(factories.CountryFactory)
class Meta:
model = models.Data
class PictureFactory(CleanModelFactory):
title = FuzzyText()
RelatedFactory(ImageFactory, 'picture')
class Meta:
model = Picture
class FTestingRelatedFactory(DjangoModelFactory):
class Meta:
model = FTestingRelatedModel
int_field = fake.pyint()
str_field = fake.pystr(max_chars=FTestingRelatedModel._meta.get_field('str_field').max_length)
parent = RelatedFactory('dj_hybrid.tests.expression_wrapper.wrapper.factory.FTestingFactory', 'related')
class UserFactory(DjangoModelFactory):
"""Factory for Users"""
username = FuzzyText()
email = FuzzyText(suffix="@example.com")
name = Faker("name")
password = FuzzyText(length=8)
is_active = True
legal_address = RelatedFactory("users.factories.LegalAddressFactory",
"user")
profile = RelatedFactory("users.factories.ProfileFactory", "user")
class Meta:
model = User
class UserFactory(DjangoModelFactory):
username = '******'
organisationuser = RelatedFactory(OrganisationUserFactory, 'user')
class Meta:
model = User # Equivalent to ``model = myapp.models.User``
django_get_or_create = ('username', )
class ProgramFactory(DjangoModelFactory):
class Meta:
model = ProgramM
django_get_or_create = ('gaitid',)
name = 'Health and Survival for Syrians in Affected Regions'
gaitid = Sequence(lambda n: "%0030d" % n)
country = RelatedFactory(CountryFactory, country='United States', code='US')
@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 InstructorFactory(DjangoModelFactory):
class Meta:
model = Instructor
user = RelatedFactory(UserFactory)
recommendations = lazy_attribute(lambda x: random.randint(0, 50))
about = lazy_attribute(lambda x: faker.text())
rating = lazy_attribute(lambda x: faker.rating())
class NewsFactory(CleanModelFactory):
title = FuzzyText()
summary = FuzzyText()
RelatedFactory(ThumbnailFactory, 'news')
class Meta:
model = News
class GalleryFactory(CleanModelFactory):
title = FuzzyText()
summary = FuzzyText()
RelatedFactory(ThumbnailFactory, 'gallery')
class Meta:
model = Gallery
class BudgetItemFactory(NoDatabaseFactory):
class Meta:
model = iati.models.BudgetItem
code = SubFactory(BudgetIdentifierFactory) # Executive - executive
country_budget_item = SubFactory(CountryBudgetItemFactory)
description = RelatedFactory(BudgetItemDescriptionFactory, 'budget_item')
percentage = 50.2
class ProfileFactory(DjangoModelFactory):
class Meta:
model = Profile
user = RelatedFactory(UserFactory)
name = lazy_attribute(lambda x: faker.name())
avatar = lazy_attribute(lambda x: faker.avatar())
city = lazy_attribute(lambda x: faker.cities())
county = lazy_attribute(lambda x: faker.counties())
phone = lazy_attribute(lambda x: faker.phone_number())
class UserFactory(DjangoModelFactory):
first_name = Faker("first_name")
last_name = Faker("last_name")
username = Faker("user_name")
email = Faker("safe_email")
language = "en"
acls = RelatedFactory("emeis.core.factories.ACLFactory", "user")
class Meta:
model = models.User
class LocationFactory(NoDatabaseFactory):
class Meta:
model = iati.models.Location
activity = SubFactory(ActivityFactory)
ref = 'AF-KAN'
location_reach = SubFactory(GeographicLocationReachFactory)
location_id_vocabulary = SubFactory(GeographicVocabularyFactory)
location_id_code = '23213'
point_pos = GEOSGeometry(Point(20.22, 45.22), srid=4326)
point_srs_name = "http://www.opengis.net/def/crs/EPSG/0/4326"
exactness = SubFactory(GeographicExactnessFactory)
location_class = SubFactory(GeographicLocationClassFactory)
feature_designation = SubFactory(LocationTypeFactory)
name = RelatedFactory(LocationNameFactory, 'location')
description = RelatedFactory(LocationDescriptionFactory, 'location')
activity_description = RelatedFactory(LocationActivityDescriptionFactory,
'location')
class ProductRequirementFactory(DjangoModelFactory):
product = SubFactory(ProductFactory)
requirement = SubFactory(RequirementFactory)
level_of_definition = SubFactory(factories.DefinitionLevelFactory)
relevance = SubFactory(factories.RelevanceFactory)
criticality = SubFactory(factories.CriticalityFactory)
barriers = RelatedFactory(factories.BarrierFactory)
class Meta:
model = models.ProductRequirement
class OrganisationDocumentLinkFactory(NoDatabaseFactory):
class Meta:
model = iati_organisation.models.OrganisationDocumentLink
organisation = SubFactory(OrganisationFactory)
url = 'http://someuri.com'
file_format = SubFactory(FileFormatFactory)
documentlinktitle = RelatedFactory(OrganisationDocumentLinkTitleFactory,
'document_link')
iso_date = datetime.datetime.now()
class DocumentLinkFactory(NoDatabaseFactory):
class Meta:
model = iati.models.DocumentLink
activity = SubFactory(ActivityFactory)
url = 'http://someuri.com'
file_format = SubFactory(FileFormatFactory)
documentlinktitle = RelatedFactory(DocumentLinkTitleFactory,
'document_link')
iso_date = datetime.datetime.now()
class UserFactory(DjangoModelFactory):
class Meta:
model = 'auth.User'
django_get_or_create = ('username', )
first_name = 'Thom'
last_name = 'Yorke'
username = lazy_attribute(lambda o: slugify(o.first_name + '.' +
o.last_name))
email = lazy_attribute(lambda o: o.username + "@testenv.com")
tola_user = RelatedFactory('factories.workflow_models.TolaUserFactory', 'user')
class PortfolioFactory(factory.django.DjangoModelFactory):
class Meta:
model = Portfolio
strategy = factory.enums.BUILD_STRATEGY
name = factory.Faker("company")
amount = factory.Faker("random_int")
positions = RelatedFactory(
"core.tests.factories.position.PositionFactory",
factory_related_name="portfolio",
)
class Appointment(DjangoModelFactory):
class Meta:
model = AppointmentM
owner = uuid.uuid4()
name = Iterator(['David', 'Nina'])
start_date = datetime(2018, 1, 1, 12, 30, tzinfo=pytz.UTC)
end_date = datetime(2018, 1, 1, 15, 15, tzinfo=pytz.UTC)
type = ['Testtype1', 'Testtype2']
address = "Teststreet 1"
organization_uuid = uuid.uuid4()
notes = RelatedFactory(AppointmentNote)
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'),
)
)
class UserFactory(Factory):
class Meta:
model = User
sqlalchemy_session = db.session
name = "Henrique Lopes"
email = "*****@*****.**"
password = User.to_encrypt("lopes2")
phones = RelatedFactory(PhoneFactory, 'user')
@lazy_attribute
def token(self):
return jwt_encode(self.email)
class UserFactory(DjangoModelFactory):
"""Factory for Users"""
username = LazyFunction(lambda: ulid.new().str)
email = FuzzyText(suffix="@example.com")
first_name = FuzzyText()
last_name = FuzzyText()
profile = RelatedFactory("profiles.factories.ProfileFactory", "user")
class Meta:
model = User
class Params:
no_profile = Trait(profile=None)
