class Params:
is_secure = False
key_pair = factory.LazyFunction(generate_new_rsa_identity)
class LeaveFactory(factory.DjangoModelFactory):
class Meta:
model = models.Leave
description = factory.LazyFunction(lambda: fake.text(max_nb_chars=200))
class ProjectContractFactory(ContractFactory):
class Meta:
model = models.ProjectContract
fixed_fee = factory.LazyFunction(lambda: random.randint(0, 9999))
class CorporateEndorsementFactory(DictFactoryBase):
corporation_name = factory.Faker('company')
image = ImageFactory()
individual_endorsements = factory.LazyFunction(
partial(generate_instances, EndorserFactory))
class SeatFactory(DictFactoryBase):
currency = 'USD'
price = factory.Faker('random_int')
sku = factory.LazyFunction(generate_seat_sku)
type = 'verified'
upgrade_deadline = factory.LazyFunction(generate_zulu_datetime)
class ProjectFactory(WarehouseFactory):
class Meta:
model = Project
id = factory.LazyFunction(uuid.uuid4)
name = factory.fuzzy.FuzzyText(length=12)
class IssueFactory(TitledFactory):
class Meta:
model = all_models.Issue
due_date = factory.LazyFunction(datetime.datetime.utcnow)
class GoodChangesetFactory(HarmfulChangesetFactory):
harmful = False
checked = True
check_user = factory.SubFactory(UserFactory)
check_date = factory.LazyFunction(timezone.now)
class Annotation(ModelFactory):
class Meta:
model = models.Annotation
sqlalchemy_session_persistence = (
"flush" # Always flush the db to generate annotation.id.
)
tags = factory.LazyFunction(lambda: FAKER.words(nb=random.randint(0, 5)))
target_uri = factory.Faker("uri")
text = factory.Faker("paragraph")
userid = factory.LazyFunction(lambda: "acct:{username}@{authority}".format(
username=FAKER.user_name(), authority=FAKER.domain_name(levels=1)))
document = factory.SubFactory(Document)
groupid = "__world__"
@factory.lazy_attribute
def target_selectors(self):
return [
{
"endContainer":
"/div[1]/article[1]/section[1]/div[1]/div[2]/div[1]",
"endOffset": 76,
"startContainer":
"/div[1]/article[1]/section[1]/div[1]/div[2]/div[1]",
"startOffset": 0,
"type": "RangeSelector",
},
{
"end": 362,
"start": 286,
"type": "TextPositionSelector"
},
{
"exact":
"If you wish to install Hypothesis on your own site then head over to GitHub.",
"prefix": " browser extension.\n ",
"suffix": "\n \n \n \n ",
"type": "TextQuoteSelector",
},
]
@factory.post_generation
def make_metadata(self, create, extracted, **kwargs):
"""Create associated document metadata for the annotation."""
# The metadata objects are going to be added to the db, so if we're not
# using the create strategy then simply don't make any.
if not create:
return
def document_uri_dict():
"""
Return a randomly generated DocumentURI dict for this annotation.
This doesn't add anything to the database session yet.
"""
document_uri = DocumentURI.build(document=None,
claimant=self.target_uri,
uri=self.target_uri)
return dict(
claimant=document_uri.claimant,
uri=document_uri.uri,
type=document_uri.type,
content_type=document_uri.content_type,
)
document_uri_dicts = [
document_uri_dict() for _ in range(random.randint(1, 3))
]
def document_meta_dict(type_=None):
"""
Return a randomly generated DocumentMeta dict for this annotation.
This doesn't add anything to the database session yet.
"""
kwargs = {"document": None, "claimant": self.target_uri}
if type_ is not None:
kwargs["type"] = type_
document_meta = DocumentMeta.build(**kwargs)
return dict(
claimant=document_meta.claimant,
type=document_meta.type,
value=document_meta.value,
)
document_meta_dicts = [
document_meta_dict() for _ in range(random.randint(1, 3))
]
# Make sure that there's always at least one DocumentMeta with
# type='title', so that we never get annotation.document.title is None:
if "title" not in [m["type"] for m in document_meta_dicts]:
document_meta_dicts.append(document_meta_dict(type_="title"))
self.document = update_document_metadata(
orm.object_session(self),
self.target_uri,
document_meta_dicts=document_meta_dicts,
document_uri_dicts=document_uri_dicts,
created=self.created,
updated=self.updated,
)
@factory.post_generation
def make_id(self, create, extracted, **kwargs):
"""Add a randomly ID if the annotation doesn't have one yet."""
# If using the create strategy don't generate an id.
# models.Annotation.id's server_default function will generate one
# when the annotation is saved to the DB.
if create:
return
# Don't generate an id if the user passed in one of their own.
if getattr(self, "id", None):
return
self.id = uuid.uuid4().hex
@factory.post_generation
def timestamps(self, create, extracted, **kwargs):
# If using the create strategy let sqlalchemy set the created and
# updated times when saving to the DB.
if create:
return
# When using the build or stub strategy sqlalchemy won't set created or updated
# times for us, so do it ourselves instead.
#
# We're generating created and updated separately (calling now() twice
# instead of just once) so created and updated won't be exactly the
# same. This is consistent with how models.Annotation does it when
# saving to the DB.
self.created = self.created or datetime.datetime.now()
self.updated = self.updated or datetime.datetime.now()
class CarModelFactory(factory.DjangoModelFactory):
brand = factory.SubFactory(CarBrandFactory)
name = factory.LazyFunction(lambda: uuid4().hex)
class Meta:
model = CarModel
class HarmfulChangesetFactory(SuspectChangesetFactory):
checked = True
check_user = factory.SubFactory(UserFactory)
check_date = factory.LazyFunction(timezone.now)
harmful = True
class OrderFactory(factory.django.DjangoModelFactory):
"""Order factory."""
created_by = factory.SubFactory(AdviserFactory)
modified_by = factory.SelfAttribute('created_by')
company = factory.SubFactory(CompanyFactory)
contact = factory.SubFactory(
ContactFactory,
company=factory.SelfAttribute('..company'),
)
primary_market_id = Country.france.value.id
sector_id = Sector.aerospace_assembly_aircraft.value.id
uk_region_id = UKRegion.england.value.id
description = factory.Faker('text')
contacts_not_to_approach = factory.Faker('text')
product_info = factory.Faker('text')
further_info = factory.Faker('text')
existing_agents = factory.Faker('text')
permission_to_approach_contacts = factory.Faker('text')
delivery_date = factory.LazyFunction(
lambda: (now() + datetime.timedelta(days=60)).date(), )
contact_email = factory.Faker('email')
contact_phone = '+44 (0)7123 123456'
status = OrderStatus.DRAFT
po_number = factory.Faker('text', max_nb_chars=50)
discount_value = factory.Faker('random_int', max=100)
discount_label = factory.Faker('text', max_nb_chars=50)
vat_status = VATStatus.EU
vat_number = '0123456789'
vat_verified = True
billing_company_name = factory.LazyAttribute(lambda o: o.company.name)
billing_contact_name = factory.Faker('name')
billing_email = factory.Faker('email')
billing_phone = '+44 (0)444 123456'
billing_address_1 = factory.Sequence(lambda n: f'Apt {n}.')
billing_address_2 = factory.Sequence(lambda n: f'{n} Foo st.')
billing_address_country_id = Country.united_kingdom.value.id
billing_address_county = factory.Faker('text')
billing_address_postcode = factory.Faker('postcode')
billing_address_town = factory.Faker('city')
@to_many_field
def service_types(self):
"""
Add support for setting service_types.
If nothing specified when instantiating the object, the value returned by
this method will be used by default.
"""
return ServiceType.objects.filter(
disabled_on__isnull=True).order_by('?')[:2]
@to_many_field
def assignees(self):
"""
Add support for setting assignees.
If nothing specified when instantiating the object, the value returned by
this method will be used by default.
"""
return OrderAssigneeFactory.create_batch(1, order=self, is_lead=True)
class Meta:
model = 'order.Order'
class Params:
hq = factory.Trait(headquarter_type=factory.LazyFunction(
lambda: random_obj_for_model(HeadquarterType)), )
class GroupFactory(factory.alchemy.SQLAlchemyModelFactory):
class Meta(BaseMeta):
model = Group
name = factory.LazyFunction(lambda: str(uuid.uuid4()))
users = []
class PublicKeyFactory(factory.Factory):
class Meta:
model = keys.PublicKey
public_key_bytes = factory.LazyFunction(_mk_public_key_bytes)
class EventStockFactory(StockFactory):
offer = factory.SubFactory(EventOfferFactory)
beginningDatetime = factory.LazyFunction(
lambda: datetime.datetime.now() + datetime.timedelta(days=5))
bookingLimitDatetime = factory.LazyAttribute(
lambda stock: stock.beginningDatetime - datetime.timedelta(minutes=60))
users = utils.session.query(models.User)
users = {u.id: u for u in list(users)}
print(f'{len(users)} created.')
print('Creating Pictures...', end=' ', flush=True)
pictures = PictureFactory.build_batch(size=NUM_PICTURES)
utils.session.bulk_save_objects(pictures)
utils.session.commit()
pictures = list(utils.session.query(models.Picture))
all_user_ids = set(users.keys())
print(f'{len(pictures)} created.')
print('Creating Listings...', end=' ', flush=True)
listings = ListingFactory.build_batch(
size=NUM_LISTINGS,
seller_id=factory.LazyFunction(
lambda: fake.random_element(all_user_ids)))
utils.session.bulk_save_objects(listings)
utils.session.commit()
listings = {l.id: l for l in utils.session.query(models.Listing)}
print(f'{len(listings)} created.')
print('Creating Bids...', end=' ', flush=True)
max_bids_data = []
all_bids = []
for l in listings.values():
user_ids = all_user_ids - {l.seller_id}
bids_size = random.randint(MIN_BIDS, MAX_BIDS)
bidders = random.choices([x for x in users.values()], k=bids_size)
bidder_gen1 = (x for x in bidders)
bidder_gen2 = (x for x in bidders)
bids = BidFactory.build_batch(
from app.api.mines.incidents.models.mine_incident import MineIncident
from app.api.mines.status.models.mine_status import MineStatus
from app.api.mines.subscription.models.subscription import Subscription
from app.api.mines.tailings.models.tailings import MineTailingsStorageFacility
from app.api.parties.party.models.party import Party
from app.api.parties.party.models.address import Address
from app.api.parties.party_appt.models.mine_party_appt import MinePartyAppointment
from app.api.mines.permits.permit.models.permit import Permit
from app.api.mines.permits.permit_amendment.models.permit_amendment import PermitAmendment
from app.api.mines.permits.permit_amendment.models.permit_amendment_document import PermitAmendmentDocument
from app.api.users.core.models.core_user import CoreUser, IdirUserDetail
from app.api.users.minespace.models.minespace_user import MinespaceUser
from app.api.variances.models.variance import Variance
from app.api.parties.party_appt.models.party_business_role_appt import PartyBusinessRoleAppointment
GUID = factory.LazyFunction(uuid.uuid4)
TODAY = factory.LazyFunction(datetime.now)
FACTORY_LIST = []
class FactoryRegistry:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
FACTORY_LIST.append(cls)
class BaseFactory(factory.alchemy.SQLAlchemyModelFactory, FactoryRegistry):
class Meta:
abstract = True
sqlalchemy_session = db.session
class CourseCredential(DictFactoryBase):
credential_id = factory.Faker('random_int')
course_id = factory.LazyFunction(generate_course_run_key)
certificate_type = 'verified'
class MineFactory(BaseFactory):
class Meta:
model = Mine
class Params:
minimal = factory.Trait(
mine_no=None,
mine_note=None,
mine_region='NE',
mine_location=None,
mine_type=None,
verified_status=None,
mine_status=None,
mine_tailings_storage_facilities=0,
mine_permit=0,
mine_expected_documents=0,
mine_incidents=0,
mine_variance=0,
)
mine_guid = GUID
mine_no = factory.Faker('ean', length=8)
mine_name = factory.Faker('company')
mine_note = factory.Faker('sentence', nb_words=6, variable_nb_words=True)
major_mine_ind = factory.Faker('boolean', chance_of_getting_true=50)
mine_region = factory.LazyFunction(RandomMineRegionCode)
ohsc_ind = factory.Faker('boolean', chance_of_getting_true=50)
union_ind = factory.Faker('boolean', chance_of_getting_true=50)
mine_location = factory.RelatedFactory(MineLocationFactory, 'mine')
mine_type = factory.RelatedFactory(MineTypeFactory, 'mine')
verified_status = factory.RelatedFactory(MineVerifiedStatusFactory, 'mine')
mine_status = factory.RelatedFactory(MineStatusFactory, 'mine')
mine_tailings_storage_facilities = []
mine_permit = []
mine_expected_documents = []
mine_incidents = []
mine_variance = []
@factory.post_generation
def mine_tailings_storage_facilities(obj, create, extracted, **kwargs):
if not create:
return
if not isinstance(extracted, int):
extracted = 1
MineTailingsStorageFacilityFactory.create_batch(size=extracted, mine=obj, **kwargs)
@factory.post_generation
def mine_permit(obj, create, extracted, **kwargs):
if not create:
return
if not isinstance(extracted, int):
extracted = 1
PermitFactory.create_batch(size=extracted, mine=obj, **kwargs)
@factory.post_generation
def mine_expected_documents(obj, create, extracted, **kwargs):
if not create:
return
if not isinstance(extracted, int):
extracted = 1
MineExpectedDocumentFactory.create_batch(size=extracted, mine=obj, **kwargs)
@factory.post_generation
def mine_incidents(obj, create, extracted, **kwargs):
if not create:
return
if not isinstance(extracted, int):
extracted = 1
MineIncidentFactory.create_batch(size=extracted, mine_guid=obj.mine_guid, **kwargs)
@factory.post_generation
def mine_variance(obj, create, extracted, **kwargs):
if not create:
return
if not isinstance(extracted, int):
extracted = 1
VarianceFactory.create_batch(size=extracted, mine=obj, **kwargs)
class EventFactory(factory.django.DjangoModelFactory):
class Meta:
model = Event
id = factory.Sequence(lambda n: f"evt_{n}")
data = factory.LazyFunction(lambda: {})
class Params:
expired = factory.Trait(
expiration_date=factory.LazyFunction(timezone.now))
class ProgramTypeFactory(DictFactoryBase):
name = factory.Faker('word')
logo_image = factory.LazyFunction(generate_sized_stdimage)
class ProgramFactory(factory.django.DjangoModelFactory):
class Meta(object):
model = Program
title = factory.Sequence(lambda n: 'test-program-{}'.format(n)) # pylint: disable=unnecessary-lambda
uuid = factory.LazyFunction(uuid4)
subtitle = FuzzyText()
type = factory.SubFactory(ProgramTypeFactory)
status = ProgramStatus.Active
marketing_slug = factory.Sequence(lambda n: 'test-slug-{}'.format(n)) # pylint: disable=unnecessary-lambda
banner_image_url = FuzzyText(prefix='https://example.com/program/banner')
card_image_url = FuzzyText(prefix='https://example.com/program/card')
partner = factory.SubFactory(PartnerFactory)
overview = FuzzyText()
weeks_to_complete = FuzzyInteger(1)
min_hours_effort_per_week = FuzzyInteger(2)
max_hours_effort_per_week = FuzzyInteger(4)
credit_redemption_overview = FuzzyText()
order_courses_by_start_date = True
@factory.post_generation
def courses(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.courses, extracted)
@factory.post_generation
def excluded_course_runs(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.excluded_course_runs, extracted)
@factory.post_generation
def authoring_organizations(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.authoring_organizations, extracted)
@factory.post_generation
def corporate_endorsements(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.corporate_endorsements, extracted)
@factory.post_generation
def credit_backing_organizations(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.credit_backing_organizations, extracted)
@factory.post_generation
def expected_learning_items(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.expected_learning_items, extracted)
@factory.post_generation
def faq(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.faq, extracted)
@factory.post_generation
def individual_endorsements(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.individual_endorsements, extracted)
@factory.post_generation
def job_outlook_items(self, create, extracted, **kwargs):
if create: # pragma: no cover
add_m2m_data(self.job_outlook_items, extracted)
class LeaveTypeFactory(factory.DjangoModelFactory):
class Meta:
model = models.LeaveType
name = factory.Sequence(lambda n: 'LeaveType%d' % n)
description = factory.LazyFunction(lambda: fake.text(max_nb_chars=200))
class UserFactory(factory.django.DjangoModelFactory):
email = factory.LazyFunction(faker.email)
username = factory.LazyAttribute(lambda a: a.email)
class Meta:
model = get_user_model()
class LeaveDateFactory(factory.DjangoModelFactory):
class Meta:
model = models.LeaveDate
starts_at = factory.LazyFunction(lambda: fake.date_time_between(start_date='-1h', end_date='now', tzinfo=utc))
ends_at = factory.LazyFunction(lambda: fake.date_time_between(start_date='now', end_date='+1h', tzinfo=utc))
class PrivateKeyFactory(factory.Factory):
class Meta:
model = keys.PrivateKey
private_key_bytes = factory.LazyFunction(_mk_private_key_bytes)
class ConsultancyContractFactory(ContractFactory):
class Meta:
model = models.ConsultancyContract
duration = factory.LazyFunction(lambda: random.randint(0, 9999))
day_rate = factory.LazyFunction(lambda: random.randint(0, 9999))
class Params:
is_secure = False
key_pair = factory.LazyFunction(generate_new_rsa_identity)
muxer_opt = {MPLEX_PROTOCOL_ID: Mplex}
