class RecruitProjectInReviewFactory(RecruitProjectFactory):
start_time = factory.lazy_attribute(
lambda *a, **k: timezone.now() - timedelta(days=15)
)
review_request_time = factory.lazy_attribute(
lambda *a, **k: timezone.now() - timedelta(days=10)
)
class SourceFactory(factory.django.DjangoModelFactory):
name = factory.lazy_attribute(lambda o: random.choice(sources_names))
ident = factory.lazy_attribute(
lambda o: str(faker.random_digit_not_null()))
class Meta:
model = Source
class SteFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.SteStationEvent
dep = factory.SubFactory("whalesdb.test.WhalesdbFactoryFloor.DepFactory")
set_type = factory.lazy_attribute(
lambda o: models.SetStationEventCode.objects.all()[faker.random_int(
0,
models.SetStationEventCode.objects.count() - 1)])
crs = factory.SubFactory(
"whalesdb.test.WhalesdbFactoryFloor.CruiseFactory")
ste_date = factory.lazy_attribute(lambda o: faker.date())
rtt_id = factory.SubFactory(
"whalesdb.test.WhalesdbFactoryFloor.RttFactory")
@staticmethod
def get_valid_data():
dep = DepFactory()
crs = CruiseFactory()
ste = SteFactory.build()
rtt = RttFactory()
valid_data = {
"dep": dep.pk,
"set_type": ste.set_type.pk,
'rtt_id': rtt.pk,
"crs": crs.pk,
"ste_date": ste.ste_date
}
return valid_data
class MediaPatronFactory(DjangoModelFactory):
class Meta:
model = MediaPatron
name = lazy_attribute(lambda o: faker.company())
url = lazy_attribute(lambda o: faker.url())
active = True
class EqrFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.EqrRecorderProperties
emm = factory.SubFactory(
"whalesdb.test.WhalesdbFactoryFloor.EmmFactory",
eqt=factory.lazy_attribute(lambda o: models.EqtEquipmentTypeCode.
objects.get(pk=faker.random_int(1, 3))))
ert = factory.lazy_attribute(lambda o: models.ErtRecorderType.objects.get(
pk=faker.random_int(1, 4)))
eqr_internal_hydro = factory.lazy_attribute(lambda o: faker.boolean())
@staticmethod
def get_valid_data():
# specifically testing when an equipment is an Acoustic Recorder
eqt = models.EqtEquipmentTypeCode.objects.get(pk=1)
emm = EmmFactory(eqt=eqt)
valid_data = {
'emm': emm.pk,
'ert': faker.random_int(1, 4),
'eqr_internal_hydro': faker.boolean()
}
return valid_data
class RstFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.RstRecordingStage
rst_channel_no = factory.lazy_attribute(lambda o: faker.random_int(0, 9))
rsc = factory.SubFactory("whalesdb.test.WhalesdbFactoryFloor.RscFactory")
rst_active = factory.lazy_attribute(
lambda o: faker.random_element(elements=("A", "S")))
rst_duration = factory.lazy_attribute(lambda o: faker.random_int(0, 10000))
rst_rate = factory.lazy_attribute(
lambda o: faker.pyfloat(left_digits=5, right_digits=2))
@staticmethod
def get_valid_data():
rsc = RscFactory()
valid_data = {
"rst_channel_no": faker.random_int(0, 9),
"rsc": rsc.pk,
"rst_active": faker.random_element(elements=("A", "S")),
"rst_duration": faker.random_int(0, 10000),
"rst_rate": faker.pyfloat(left_digits=5, right_digits=2)
}
return valid_data
class StaffFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.Staff
project_year = factory.SubFactory(ProjectYearFactory)
funding_source = factory.SubFactory(FundingSourceFactory)
amount = factory.lazy_attribute(lambda o: faker.pyfloat(positive=True))
is_lead = factory.lazy_attribute(lambda o: faker.pybool())
user = factory.SubFactory(UserFactory)
employee_type = factory.lazy_attribute(
lambda o: models.EmployeeType.objects.all()[faker.random_int(
0,
models.EmployeeType.objects.count() - 1)])
@staticmethod
def get_valid_data():
return {
'project_year':
ProjectYearFactory().id,
'funding_source':
FundingSourceFactory().id,
'amount':
faker.pyfloat(positive=True),
'user':
UserFactory().id,
'is_lead':
faker.pybool(),
'employee_type':
models.EmployeeType.objects.all()[faker.random_int(
0,
models.EmployeeType.objects.count() - 1)].id,
}
class EmmFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.EmmMakeModel
eqt = factory.lazy_attribute(lambda o: models.EqtEquipmentTypeCode.objects.
get(pk=faker.random_int(1, 4)))
emm_make = factory.lazy_attribute(lambda o: faker.word())
emm_model = factory.lazy_attribute(lambda o: faker.word())
emm_depth_rating = factory.lazy_attribute(
lambda o: faker.random_int(10, 10000))
emm_description = factory.lazy_attribute(lambda o: faker.text())
# if providing an eqt_type use the WhalesdbFactory._eqt_type_codes array
@staticmethod
def get_valid_data(eqt_id=None):
eqt_id = eqt_id if eqt_id else faker.random_int(1, 4)
eqt = models.EqtEquipmentTypeCode.objects.get(pk=eqt_id)
valid_data = {
'eqt': eqt.pk,
'emm_make': faker.word(),
'emm_model': faker.word(),
'emm_depth_rating': faker.random_int(10, 10000),
'emm_description': faker.text()
}
return valid_data
class TravellerFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.Traveller
request = factory.SubFactory(TripRequestFactory)
user = factory.SubFactory(UserFactory)
start_date = factory.lazy_attribute(lambda o: faker.date_time_this_year(
tzinfo=timezone.get_current_timezone()))
end_date = factory.lazy_attribute(lambda o: o.start_date + datetime.
timedelta(days=faker.random_int(1, 10)))
is_public_servant = factory.lazy_attribute(lambda o: faker.pybool())
is_research_scientist = factory.lazy_attribute(lambda o: faker.pybool())
@staticmethod
def get_valid_data():
start_date = faker.future_datetime(
tzinfo=timezone.get_current_timezone())
end_date = start_date + datetime.timedelta(
days=faker.random_int(1, 10))
trip = TripFactory(
start_date=start_date,
end_date=end_date,
)
return {
'request': TripRequestFactory().id,
"user": UserFactory().id,
"start_date": trip.start_date.strftime("%Y-%m-%d %H:%M"),
"end_date": trip.end_date.strftime("%Y-%m-%d %H:%M"),
'is_public_servant': faker.pybool(),
'is_research_scientist': faker.pybool(),
}
class TripReviewerFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.TripReviewer
trip = factory.SubFactory(TripFactory)
role = factory.lazy_attribute(lambda o: models.TripReviewer.role_choices[
faker.random_int(0,
len(models.TripReviewer.role_choices) - 1)][0])
status = factory.lazy_attribute(
lambda o: models.TripReviewer.status_choices[faker.random_int(
0,
len(models.TripReviewer.status_choices) - 1)][0])
user = factory.SubFactory(UserFactory)
order = factory.lazy_attribute(lambda o: faker.pyint(1, 10))
@staticmethod
def get_valid_data():
return {
'trip':
TripFactory().id,
'user':
UserFactory().id,
'role':
models.TripReviewer.role_choices[faker.random_int(
0,
len(models.TripReviewer.role_choices) - 1)][0],
'status':
models.TripReviewer.status_choices[faker.random_int(
0,
len(models.TripReviewer.status_choices) - 1)][0],
'order':
faker.pyint(1, 10),
}
class ObservationFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.Observation
section = factory.SubFactory(SectionFactory)
sex = factory.lazy_attribute(lambda o: models.Observation.sex_choices[
faker.random_int(0,
len(models.Observation.sex_choices) - 1)][0])
certainty_rating = factory.lazy_attribute(lambda o: faker.pyint(0, 1))
carapace_length_mm = factory.lazy_attribute(
lambda o: faker.pyfloat(positive=True))
@staticmethod
def get_valid_data():
return {
'section_id':
SectionFactory().id,
'sex':
models.Observation.sex_choices[faker.random_int(
0,
len(models.Observation.sex_choices) - 1)][0],
'certainty_rating':
faker.pyint(0, 1),
'carapace_length_mm':
faker.pyfloat(positive=True),
}
class SampleFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.Sample
collection = factory.SubFactory(CollectionFactory)
unique_sample_identifier = factory.lazy_attribute(
lambda o: faker.pyint(1, 100000))
datetime = factory.lazy_attribute(lambda o: faker.date_time_this_year(
tzinfo=timezone.get_current_timezone()))
latitude = factory.lazy_attribute(lambda o: faker.pyfloat(positive=True))
longitude = factory.lazy_attribute(lambda o: faker.pyfloat())
@staticmethod
def get_valid_data():
return {
'collection':
CollectionFactory().id,
'unique_sample_identifier':
faker.pyint(1, 100000),
'datetime':
faker.date_time_this_year(tzinfo=timezone.get_current_timezone()),
'latitude':
faker.pyfloat(positive=True),
'longitude':
faker.pyfloat(),
}
class _Us_one_trace_order(factory.Factory):
SSN = factory.lazy_attribute(lambda x: fake.ssn().replace('-', ''))
first_name = factory.lazy_attribute(lambda x: fake.first_name())
last_name = factory.lazy_attribute(lambda x: fake.last_name())
class Meta:
model = dict
class _Us_one_trace_phone(factory.Factory):
number_is_public = factory.lazy_attribute(lambda x: random.choice(
('YES', 'NO')))
phone_number = factory.lazy_attribute(lambda x: fake.phone_number())
class Meta:
model = dict
class OMCostFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.OMCost
project_year = factory.SubFactory(ProjectYearFactory)
funding_source = factory.SubFactory(FundingSourceFactory)
amount = factory.lazy_attribute(lambda o: faker.pyfloat(positive=True))
om_category = factory.lazy_attribute(
lambda o: models.OMCategory.objects.all()[faker.random_int(
0,
models.OMCategory.objects.count() - 1)])
description = factory.lazy_attribute(lambda o: faker.text())
@staticmethod
def get_valid_data():
return {
'project_year':
ProjectYearFactory().id,
'funding_source':
FundingSourceFactory().id,
'amount':
faker.pyfloat(positive=True),
'description':
faker.text(),
'om_category':
models.OMCategory.objects.all()[faker.random_int(
0,
models.OMCategory.objects.count() - 1)].id,
}
class EcpFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.EcpChannelProperty
eqr = factory.SubFactory("whalesdb.test.WhalesdbFactoryFloor.EqrFactory")
ecp_channel_no = factory.lazy_attribute(lambda o: faker.random_int(1, 9))
eqa_adc_bits = factory.lazy_attribute(
lambda o: models.EqaAdcBitsCode.objects.get(pk=faker.random_int(1, 3)))
ecp_voltage_range_min = factory.lazy_attribute(
lambda o: faker.random_int(1, 1000))
ecp_voltage_range_max = factory.lazy_attribute(
lambda o: o.ecp_voltage_range_min + faker.random_int(1, 1000))
@staticmethod
def get_valid_data():
# specifically testing when an equipment is an Acoustic Recorder
eqr = EqrFactory()
min_volt = faker.random_int(1, 1000)
valid_data = {
'eqr':
eqr.pk,
'ecp_channel_no':
faker.random_int(1, 9),
'eqa_adc_bits':
models.EqaAdcBitsCode.objects.get(pk=faker.random_int(1, 3)),
'ecp_voltage_range_min':
min_volt,
'ecp_voltage_range_max':
min_volt + faker.random_int(1, 1000),
}
return valid_data
class ProjectFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.Project
section = factory.SubFactory(SectionFactory)
functional_group = factory.SubFactory(FunctionalGroupFactory)
default_funding_source = factory.SubFactory(FundingSourceFactory)
title = factory.lazy_attribute(lambda o: faker.catch_phrase())
activity_type = factory.lazy_attribute(
lambda o: models.ActivityType.objects.all()[faker.random_int(
0,
models.ActivityType.objects.count() - 1)])
@staticmethod
def get_valid_data():
return {
'section':
SectionFactory().id,
'functional_group':
FunctionalGroupFactory().id,
'default_funding_source':
FundingSourceFactory().id,
'title':
faker.catch_phrase(),
'activity_type':
models.ActivityType.objects.all()[faker.random_int(
0,
models.ActivityType.objects.count() - 1)].id,
}
class EqpFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.EqpEquipment
emm = factory.SubFactory("whalesdb.test.WhalesdbFactoryFloor.EmmFactory")
eqp_serial = factory.lazy_attribute(
lambda o: faker.random_int(1, 1000000000))
eqp_asset_id = factory.Sequence(
lambda n: "DFO-{}".format(faker.random_int(9000000, 9999999)))
eqp_date_purchase = factory.lazy_attribute(lambda o: faker.date())
eqp_notes = factory.lazy_attribute(lambda o: faker.text())
eqp_retired = factory.lazy_attribute(lambda o: faker.boolean())
eqo_owned_by = factory.SubFactory(
"whalesdb.test.WhalesdbFactoryFloor.EqoFactory")
@staticmethod
def get_valid_data():
emm = EmmFactory()
eqo = EqoFactory()
valid_data = {
"emm": emm.pk,
'eqp_serial': faker.random_int(1, 1000000000),
'eqp_asset_id': "DFO-{}".format(faker.random_int(9000000,
9999999)),
'eqp_date_purchase': faker.date(),
'eqp_notes': faker.text(),
'eqp_retired': faker.boolean(),
'eqo_owned_by': eqo.pk
}
return valid_data
class ProjectYearFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.ProjectYear
project = factory.SubFactory(ProjectFactory)
status = factory.lazy_attribute(lambda o: faker.pyint(1, 100))
start_date = factory.lazy_attribute(
lambda o: datetime.datetime(year=faker.pyint(2000, 2030),
month=4,
day=1,
tzinfo=timezone.get_current_timezone()))
end_date = factory.lazy_attribute(
lambda o: datetime.datetime(year=o.start_date.year + 1,
month=3,
day=31,
tzinfo=timezone.get_current_timezone()))
@staticmethod
def get_valid_data():
start_date = datetime.datetime(year=faker.pyint(2000, 2030),
month=4,
day=1,
tzinfo=timezone.get_current_timezone())
end_date = datetime.datetime(year=start_date.year + 1,
month=3,
day=31,
tzinfo=timezone.get_current_timezone())
return {
'project': ProjectFactory().id,
'status': faker.pyint(1, 100),
'start_date': start_date,
'end_date': end_date,
}
class ReeFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.ReeRecordingEvent
rec_id = factory.SubFactory(
"whalesdb.test.WhalesdbFactoryFloor.RecFactory")
ret_id = factory.lazy_attribute(lambda o: models.RetRecordingEventType.
objects.get(pk=faker.random_int(1, 6)))
rtt_id = factory.SubFactory(
"whalesdb.test.WhalesdbFactoryFloor.RttFactory")
ree_date = factory.lazy_attribute(lambda o: faker.date())
ree_time = factory.lazy_attribute(lambda o: faker.time())
tea_id = factory.SubFactory(
"whalesdb.test.WhalesdbFactoryFloor.TeaFactory")
@staticmethod
def get_valid_data():
rec = RecFactory()
ret = models.RetRecordingEventType.objects.get(
pk=faker.random_int(1, 6))
rtt = RttFactory()
tea = TeaFactory()
valid_data = {
'rec_id': rec.pk,
'ret_id': ret.pk,
'rtt_id': rtt.pk,
'ree_date': faker.date(),
'ree_time': faker.time(),
'tea_id': tea.pk
}
return valid_data
class RelationshipFactory(Factory):
class Meta:
model = Relationship
type = lazy_attribute(
lambda x: [RelationshipTypeFactory(), None][randint(0, 1)])
id = lazy_attribute(lambda x: fake.pystr())
class StnFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.StnStation
django_get_or_create = ('stn_code', )
stn_name = factory.lazy_attribute(lambda o: faker.name())
stn_code = factory.Iterator(_stn_codes_)
stn_revision = 1
stn_planned_lat = factory.lazy_attribute(
lambda o: faker.pydecimal(left_digits=2, right_digits=5))
stn_planned_lon = factory.lazy_attribute(
lambda o: faker.pydecimal(left_digits=2, right_digits=5))
stn_planned_depth = factory.lazy_attribute(
lambda o: faker.random_int(0, 1000))
stn_notes = factory.lazy_attribute(lambda o: faker.text())
@staticmethod
def get_valid_data():
valid_data = {
"stn_name": faker.name(),
"stn_code": _stn_codes_[faker.random_int(0,
len(_stn_codes_) - 1)],
"stn_revision": 1,
"stn_planned_lat": faker.pydecimal(left_digits=2, right_digits=5),
"stn_planned_lon": faker.pydecimal(left_digits=2, right_digits=5),
"stn_planned_depth": faker.random_int(0, 1000),
"stn_notes": faker.text()
}
return valid_data
class SurfaceFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.Surface
line = factory.SubFactory(LineFactory)
surface_type = factory.lazy_attribute(
lambda o: models.Surface.SURFACE_TYPE_CHOICES[faker.random_int(
0,
len(models.Surface.SURFACE_TYPE_CHOICES) - 1)][0])
label = factory.lazy_attribute(lambda o: faker.catch_phrase())
is_lost = factory.lazy_attribute(lambda o: faker.pybool())
is_damaged = factory.lazy_attribute(lambda o: faker.pybool())
@staticmethod
def get_valid_data():
return {
'line':
LineFactory().id,
'surface_type':
models.Surface.SURFACE_TYPE_CHOICES[faker.random_int(
0,
len(models.Surface.SURFACE_TYPE_CHOICES) - 1)][0],
'label':
faker.catch_phrase(),
'is_lost':
faker.pybool(),
'is_damaged':
faker.pybool(),
}
class PartnerFactory(DjangoModelFactory):
class Meta:
model = Partner
name = lazy_attribute(lambda o: faker.company())
url = lazy_attribute(lambda o: faker.url())
active = True
class Sub_profile(factory.Factory):
response = factory.lazy_attribute(lambda x: faker.pydict())
raw_response = factory.lazy_attribute(lambda x: faker.pydict())
source = factory.lazy_attribute(lambda x: ".".join(faker.words()))
class Meta:
model = Sub_profile_model
class ColaboratorFactory(DjangoModelFactory):
class Meta:
model = Colaborator
name = lazy_attribute(lambda o: faker.company())
url = lazy_attribute(lambda o: faker.url())
active = True
class UserFactory(factory.DjangoModelFactory):
"""
Factory for User accounts
"""
username = factory.lazy_attribute(
lambda o: slugify(o.first_name + '.' + o.last_name))
email = factory.lazy_attribute(lambda o: '*****@*****.**' % o.username)
mobile_number = '+919876543210'
gender = fuzzy.FuzzyChoice(User.GENDER_CHOICES, getter=lambda c: c[0])
is_staff = False
@lazy_attribute
def first_name(self):
faker = Faker()
return faker.first_name_male(
) if self.gender is User.MALE else faker.first_name_female()
@lazy_attribute
def last_name(self):
faker = Faker()
return faker.last_name_male(
) if self.gender is User.MALE else faker.last_name_female()
generic_cart = None
class Params:
has_cart = factory.Trait(generic_cart=factory.RelatedFactory(
'tests.restaurant.factories.GenericCartFactory', 'user'))
class Meta:
model = User
class IEI_fact_address(factory.Factory):
street_name = factory.lazy_attribute(lambda x: fake.street_name())
street_number = factory.lazy_attribute(lambda x: fake.building_number())
street_suffix = factory.lazy_attribute(lambda x: fake.street_suffix())
fullstreet = factory.lazy_attribute(lambda x: fake.street_address())
city = factory.lazy_attribute(lambda x: fake.city())
state = factory.lazy_attribute(lambda x: fake.state_abbr())
county = factory.lazy_attribute(lambda x: fake.city())
from_date = factory.SubFactory(Dict_partial_date)
to_date = factory.SubFactory(Dict_partial_date)
zip = factory.lazy_attribute(lambda x: fake.postalcode())
zip4 = factory.lazy_attribute(lambda x: fake.numerify(text="####"))
street_pre_direction = factory.lazy_attribute(lambda x: fake.city_prefix())
@factory.post_generation
def groups(self, *arg, **kwargs):
from_date = self.pop('from_date', None)
self['from-date'] = from_date
to_date = self.pop('to_date', None)
self['to-date'] = to_date
class Meta:
model = dict
class EntryFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.Entry
status = factory.lazy_attribute(lambda o: models.Status.objects.all()[
faker.random_int(0,
models.Status.objects.count() - 1)])
entry_type = factory.lazy_attribute(lambda o: models.EntryType.objects.all(
)[faker.random_int(0,
models.EntryType.objects.count() - 1)])
title = factory.lazy_attribute(lambda o: faker.catch_phrase())
@staticmethod
def get_valid_data():
return {
'status':
models.Status.objects.all()[faker.random_int(
0,
models.Status.objects.count() - 1)].id,
'entry_type':
models.EntryType.objects.all()[faker.random_int(
0,
models.EntryType.objects.count() - 1)].id,
'title':
faker.catch_phrase(),
'regions':
RegionFactory().id,
'sectors':
SectorFactory().id,
}
class VisitorFactory(factory.django.DjangoModelFactory):
class Meta:
model = 'users.User'
first_name = lazy_attribute(lambda o: faker_data.first_name())
last_name = lazy_attribute(lambda o: faker_data.last_name())
is_active = False
from datetime import timedelta
import random
from django.utils import timezone
from factory import lazy_attribute, post_generation
from factory.django import DjangoModelFactory
from core.faker import faker
from . import models
lazy = lambda call: lazy_attribute(lambda obj: call())
lazy_bool = lazy(lambda: random.choice([True, False]))
rand_obj = lambda model: model.objects.order_by('?').first()
lazy_obj = lambda model: lazy(lambda: model.objects.order_by('?').first())
lazy_subobj = lambda get_model: \
lazy_attribute(lambda obj: get_model(obj).order_by('?').first())
lazy_choice = lambda choices: lazy(lambda: random.choice(choices))
lazy_randint = lambda min, max: lazy(lambda: random.randint(min, max))
class Mode(DjangoModelFactory):
class Meta:
model = models.Mode
django_get_or_create = ['name']
name = lazy(faker.word)
class Map(DjangoModelFactory):
class Meta:
model = models.Map
