Beispiel #1
0
class MunicipalityFactory(BaseFactory):
    name = "Montbrun-Bocage"
    insee = FuzzyAttribute(lambda: str(Random().randint(10000, 97000)))
    siren = FuzzyAttribute(lambda: str(Random().randint(100000000, 300000000)))

    class Meta:
        model = models.Municipality
Beispiel #2
0
class CompanyFactory(DjangoModelFactory):
    name = FuzzyAttribute(fake_company_name)
    cnpj = FuzzyAttribute(cnpj_with_punctuation)
    owner = Faker("name", locale="pt_BR")
    ddd = FuzzyInteger(DDD_LOWER_LIMIT, DDD_UPPER_LIMIT)
    phone = FuzzyAttribute(fake_phone_number)

    class Meta:
        model = Company
Beispiel #3
0
class LearningPhdFactory(factory.Factory):
    des1_titulacion = factory.Sequence(lambda n: 'PHD recibido #{0}'.format(n))
    des1_organismo = FuzzyAttribute(
        lambda: 'Universidad #' + str(randint(0, 100)))
    f_expedicion = FuzzyAttribute(
        lambda: random.choice([None, FuzzyDate(d).fuzz()]))

    class Meta:
        model = dict
class TaskFactory(factory.DjangoModelFactory):
    name = factory.Sequence(lambda n: f'Task: {n}')
    user_defined_ordering = FuzzyAttribute(lambda: random.randint(1, 50))
    pomodoro_number = FuzzyAttribute(lambda: random.randint(1, 50))
    pomodoro_length = FuzzyAttribute(lambda: timedelta(minutes=50))
    break_length = FuzzyAttribute(lambda: timedelta(minutes=30))
    note = factory.Faker('text')

    class Meta:
        model = Task
Beispiel #5
0
class LearningFactory(factory.Factory):
    des1_titulacion = factory.Sequence(lambda n: u'Título #{0}'.format(n))
    des1_grado_titulacion = FuzzyAttribute(lambda: random.choice(
        st_cvn.OFFICIAL_TITLE_TYPE.keys() + ['GRADO', 'FP']))
    des1_organismo = FuzzyAttribute(
        lambda: random.choice([None, 'Universidad #' + str(randint(0, 100))]))
    f_expedicion = FuzzyAttribute(
        lambda: random.choice([None, FuzzyDate(d).fuzz()]))

    class Meta:
        model = dict
Beispiel #6
0
class SpellFactory(DjangoModelFactory):
    """Instantiate a ``gurps_manager.models.Spell`` object.

    >>> spell = SpellFactory.create()
    >>> spell.full_clean()
    >>> spell.id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    campaign = SubFactory(CampaignFactory)
    name = FuzzyAttribute(lambda: spell_name())  # pylint: disable=W0108
    school = FuzzyAttribute(lambda: spell_school())  # pylint: disable=W0108
    resist = FuzzyAttribute(lambda: spell_resist())  # pylint: disable=W0108
    duration = FuzzyAttribute(lambda: spell_duration())  # pylint: disable=W0108
    cast_time = FuzzyAttribute(lambda: spell_cast_time())  # pylint: disable=W0108
    difficulty = FuzzyAttribute(lambda: spell_difficulty())  # pylint: disable=W0108
    initial_fatigue_cost = FuzzyAttribute(lambda: spell_initial_fatigue_cost())  # pylint: disable=W0108
    maintenance_fatigue_cost = FuzzyAttribute(
        lambda: spell_maintenance_fatigue_cost()  # pylint: disable=W0108
    )

    class Meta(object):
        """Non-field information about this factory."""
        model = models.Spell
Beispiel #7
0
class FeedFactory(DjangoModelFactory):
    feed_address = FuzzyAttribute(generate_address)
    feed_link = FuzzyAttribute(generate_address)
    creation = factory.Faker('date')
    feed_title = factory.Faker('sentence')
    last_update = factory.Faker('date_time')
    next_scheduled_update = factory.Faker('date_time')
    last_story_date = factory.Faker('date_time')
    min_to_decay = 1
    last_modified = factory.Faker('date_time')
    hash_address_and_link = fake.sha1()

    class Meta:
        model = Feed
Beispiel #8
0
class ProfessionFactory(factory.Factory):
    des1_cargo = factory.Sequence(lambda n: 'Trabajo #{0}'.format(n))
    employer = FuzzyAttribute(lambda: 'Empresa #' + str(randint(0, 100)))
    f_toma_posesion = FuzzyDate(datetime.date(1940, 1, 1)).fuzz()
    f_hasta = FuzzyAttribute(
        lambda: random.choice([None, FuzzyDate(d).fuzz()]))
    centro = FuzzyAttribute(
        lambda: random.choice([None, 'Centro #' + str(randint(0, 100))]))
    des1_departamento = FuzzyAttribute(
        lambda: random.choice([None, 'Departamento #' + str(randint(0, 100))]))
    des1_dedicacion = FuzzyChoice([True, False, None])

    class Meta:
        model = dict
class PriorityFactory(factory.DjangoModelFactory):
    priority_level = FuzzyAttribute(lambda: random.randint(1, 10))
    name = factory.LazyAttributeSequence(lambda o, n: f'{n} Priority level: {o.priority_level}')
    color = factory.Faker('color')

    class Meta:
        model = Priority
Beispiel #10
0
class CategoryFactory(DjangoModelFactory):
    """Instantiate an ``elts.models.Category`` object.

    >>> category = CategoryFactory.create()
    >>> category.full_clean()
    >>> category.id is None
    False
    >>> CategoryFactory.create(tags = []).tags.count()
    0

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    FACTORY_FOR = models.Category
    user = SubFactory(UserFactory)
    name = FuzzyAttribute(lambda: category_name()) # pylint: disable=W0108

    @post_generation
    def tags(self, create, extracted, **kwargs):
        """Assign a value to the ``Category.tags`` model attribute.

        The ``@post_generation`` decorator ensures that this method is only
        called after the ``create()`` method is called. If an iterable is passed
        to the constructor, its values will be used when populating the ``tags``
        many-to-many relationship. Otherwise, the values returned by
        ``category_tags()`` are used.

        """
        if not create:
            # build() was called. ``self`` has not been saved.
            return
        if extracted is not None:
            for tag in extracted:
                self.tags.add(tag)
class InnerDateFrameFactory(factory.DjangoModelFactory):
    start = factory.Sequence(lambda n: timezone.now() + timedelta(minutes=(25 * n) + 2))
    frame_type = FuzzyAttribute(lambda: random.randint(0, 2))
    end = factory.LazyAttribute(lambda n: n.start + get_duration(instance=n))

    class Meta:
        model = DateFrame
class CuppingFactory(BaseFactory):
    class Meta:
        model = Cupping

    name = factory.Sequence(lambda n: u'Coffee %d' % n)
    scores = FuzzyAttribute(_generate_scores)
    overall_score = FuzzyDecimal(60, 100, precision=1)
Beispiel #13
0
class UserSubscriptionFactory(DjangoModelFactory):
    user = factory.SubFactory(UserFactory)
    feed = FuzzyAttribute(FeedFactory)
    last_read_date = factory.Faker('date_time')

    class Meta:
        model = UserSubscription
Beispiel #14
0
class CoursePriceFactory(DjangoModelFactory):
    """Factory for CoursePrice"""
    course_run = SubFactory(CourseRunFactory)
    is_valid = FuzzyAttribute(FAKE.boolean)
    price = FuzzyDecimal(low=0, high=12345)

    class Meta:  # pylint: disable=missing-docstring,no-init,too-few-public-methods,old-style-class
        model = CoursePrice
Beispiel #15
0
class TransactionFactory(DjangoModelFactory):
    company = SubFactory(CompanyFactory)
    client = FuzzyAttribute(cpf_with_punctuation)
    value = FuzzyFloat(MIN_VALUE, high=MAX_VALUE, precision=2)
    description = Faker("catch_phrase", locale="pt_BR")

    class Meta:
        model = Transaction
Beispiel #16
0
class NotificationDigestFactory(DjangoModelFactory):
    timestamp = FuzzyDateTime(datetime.datetime(1970, 1, 1, tzinfo=pytz.UTC))
    node_lineage = FuzzyAttribute(fuzzer=make_node_lineage)
    user = factory.SubFactory(UserFactory)
    send_type = FuzzyChoice(choices=NOTIFICATION_TYPES.keys())
    message = fake.text(max_nb_chars=2048)
    event = fake.text(max_nb_chars=50)
    class Meta:
        model = models.NotificationDigest
Beispiel #17
0
class TraitFactory(DjangoModelFactory):
    """Instantiate a ``gurps_manager.models.Trait`` object.

    >>> trait = TraitFactory.create()
    >>> trait.full_clean()
    >>> trait.id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    name = FuzzyAttribute(lambda: trait_name())  # pylint: disable=W0108
    points = FuzzyAttribute(lambda: trait_points())  # pylint: disable=W0108
    character = SubFactory(CharacterFactory)

    class Meta(object):
        """Non-field information about this factory."""
        model = models.Trait
Beispiel #18
0
class CharacterSpellFactory(DjangoModelFactory):
    """Instantiate a ``gurps_manager.models.Possession`` object.

    >>> characterspell = CharacterSpellFactory.create()
    >>> characterspell.full_clean()
    >>> characterspell.id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    character = SubFactory(CharacterFactory)
    spell = SubFactory(SpellFactory)
    points = FuzzyAttribute(lambda: characterspell_points())  # pylint: disable=W0108
    bonus_level = FuzzyAttribute(lambda: characterspell_bonus_level())  # pylint: disable=W0108

    class Meta(object):
        """Non-field information about this factory."""
        model = models.CharacterSpell
class CachedEnrollmentFactory(DjangoModelFactory):
    """Factory for Enrollment"""
    user = SubFactory(UserFactory)
    data = FuzzyAttribute(lambda: {'key{}'.format(i): FAKE.text() for i in range(3)})
    course_run = SubFactory(CourseRunFactory)
    # enrollments expire after 5 minutes, this generates a last request between 10 minutes ago and now
    last_request = FuzzyDateTime(datetime.now(tz=pytz.utc) - timedelta(minutes=10))

    class Meta:  # pylint: disable=missing-docstring,no-init,too-few-public-methods,old-style-class
        model = CachedEnrollment
Beispiel #20
0
class ItemFactory(DjangoModelFactory):
    """Instantiate a ``gurps_manager.models.Item`` object.

    >>> item = ItemFactory.create()
    >>> item.full_clean()
    >>> item.id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    campaign = SubFactory(CampaignFactory)
    name = FuzzyAttribute(lambda: item_name())  # pylint: disable=W0108
    value = FuzzyAttribute(lambda: item_value())  # pylint: disable=W0108
    weight = FuzzyAttribute(lambda: item_weight())  # pylint: disable=W0108

    class Meta(object):
        """Non-field information about this factory."""
        model = models.Item
Beispiel #21
0
class SkillFactory(DjangoModelFactory):
    """Instantiate a ``gurps_manager.models.Skill`` object.

    >>> skill = SkillFactory.create()
    >>> skill.full_clean()
    >>> skill.id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    name = FuzzyAttribute(lambda: skill_name())  # pylint: disable=W0108
    category = FuzzyAttribute(lambda: skill_category())  # pylint: disable=W0108
    difficulty = FuzzyAttribute(lambda: skill_difficulty())  # pylint: disable=W0108
    skillset = SubFactory(SkillSetFactory)

    class Meta(object):
        """Non-field information about this factory."""
        model = models.Skill
class CachedCertificateFactory(DjangoModelFactory):
    """Factory for Certificate"""
    user = SubFactory(UserFactory)
    data = FuzzyAttribute(lambda: dict(
        grade=randint(60, 100), **{'key{}'.format(i): FAKE.text() for i in range(3)}
    ))
    course_run = SubFactory(CourseRunFactory)
    # certificates expire after 6 hours, this generates a last request between 6:15 hours ago and now
    last_request = FuzzyDateTime(datetime.now(tz=pytz.utc) - timedelta(hours=6, minutes=15))

    class Meta:  # pylint: disable=missing-docstring,no-init,too-few-public-methods,old-style-class
        model = CachedCertificate
Beispiel #23
0
class FutureLendFactory(LendFactory):
    """An ``elts.models.Lend`` object whose ``due_out`` attribute is set.

    >>> lend = FutureLendFactory.create()
    >>> lend.full_clean()
    >>> lend.id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    due_out = FuzzyAttribute(lambda: lend_due_out()) # pylint: disable=W0108
Beispiel #24
0
class TierProgramFactory(DjangoModelFactory):
    """
    Factory for TierProgram
    """
    program = SubFactory(ProgramFactory)
    tier = SubFactory(TierFactory)
    discount_amount = FuzzyInteger(low=0, high=12345)
    current = FuzzyAttribute(FAKE.boolean)
    income_threshold = FuzzyInteger(low=0, high=10000)

    class Meta:  # pylint: disable=missing-docstring
        model = TierProgram
Beispiel #25
0
class HitLocationFactory(DjangoModelFactory):
    """Instantiate a ``gurps_manager.models.HitLocation`` object.

    >>> hitlocation = HitLocationFactory.create()
    >>> hitlocation.full_clean()
    >>> hitlocation.id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    character = SubFactory(CharacterFactory)
    name = FuzzyAttribute(lambda: hitlocation_name())  # pylint: disable=W0108
    damage_taken = FuzzyAttribute(lambda: hitlocation_damage_taken())  # pylint: disable=W0108
    damage_resistance = FuzzyAttribute(lambda: hitlocation_damage_resistance())  # pylint: disable=W0108
    passive_defense = FuzzyAttribute(lambda: hitlocation_passive_defense()  # pylint: disable=W0108
                                     )

    class Meta(object):
        """Non-field information about this factory."""
        model = models.HitLocation
Beispiel #26
0
class ItemFactory(DjangoModelFactory):
    """Instantiate an ``elts.models.Item`` object.

    >>> ItemFactory.build().full_clean()
    >>> ItemFactory.create().id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    FACTORY_FOR = models.Item
    name = FuzzyAttribute(lambda: item_name()) # pylint: disable=W0108
Beispiel #27
0
class TeachingFactory(factory.Factory):
    asignatura = factory.Sequence(lambda n: 'Asignatura #{0}'.format(n))
    categ_anyo = FuzzyAttribute(lambda: u'Profesión #' + str(randint(0, 100)))
    tipo_estudio = FuzzyAttribute(lambda: random.choice(
        st_cvn.SUBJECT_TYPE.keys() + [u'Titulación #' + str(randint(0, 100))]))
    tipologia = FuzzyAttribute(lambda: random.choice(st_cvn.SUBJECT_TYPE.keys(
    ) + ['Tipo asignatura #' + str(randint(0, 100))]))
    curso = FuzzyAttribute(lambda: str(randint(1, 5)))
    plan_nomid = factory.Sequence(lambda n: u'Titulación #{0}'.format(n))
    university = FuzzyAttribute(lambda: random.choice(
        [None, st_cvn.UNIVERSITY, 'Universidad #' + str(randint(0, 100))]))
    departamento = FuzzyAttribute(
        lambda: random.choice([None, 'Departamento #' + str(randint(0, 100))]))
    centro_nomid = FuzzyAttribute(
        lambda: random.choice([None, 'Facultad #' + str(randint(0, 100))]))
    curso_inicio = FuzzyAttribute(lambda: str(randint(1990, 2020)))
    creditos = FuzzyAttribute(lambda: str(round(uniform(0.5, 15.5), 2)))

    class Meta:
        model = dict
Beispiel #28
0
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)"
Beispiel #29
0
class LendNoteFactory(DjangoModelFactory):
    """Instantiate an ``elts.models.LendNote`` object.

    >>> lend_note = LendNoteFactory.create()
    >>> lend_note.full_clean()
    >>> lend_note.id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    FACTORY_FOR = models.LendNote
    author_id = SubFactory(UserFactory)
    lend_id = SubFactory(random_lend_factory())
    note_text = FuzzyAttribute(lambda: note_note_text()) # pylint: disable=W0108
Beispiel #30
0
class SkillSetFactory(DjangoModelFactory):
    """Instantiate a ``gurps_manager.models.SkillSet`` object.

    >>> SkillSetFactory.build().full_clean()
    >>> SkillSetFactory.create().id is None
    False

    """
    # pylint: disable=R0903
    # pylint: disable=W0232
    name = FuzzyAttribute(lambda: skillset_name())  # pylint: disable=W0108

    class Meta(object):
        """Non-field information about this factory."""
        model = models.SkillSet