From ced550784295839c784781530c8fd58ee2d3df46 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Freitag?= Date: Fri, 2 Jul 2021 16:50:41 +0200 Subject: [PATCH 1/4] [DO NOT REVIEW] Rewrite extra post-declarations loop in parse_declarations Avoid iterating twice over the extra_maybenonpost items. Clarify all items from extra_maybenonpost are split into two dicts. --- factory/builder.py | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/factory/builder.py b/factory/builder.py index dfc96d1a..9d810fbe 100644 --- a/factory/builder.py +++ b/factory/builder.py @@ -167,19 +167,17 @@ def parse_declarations(decls, base_pre=None, base_post=None): post_declarations.update(extra_post) # Fill in extra post-declaration context + extra_pre_declarations = {} + extra_post_declarations = {} post_overrides = post_declarations.filter(extra_maybenonpost) - post_declarations.update({ - k: v - for k, v in extra_maybenonpost.items() - if k in post_overrides - }) - - # Anything else is pre_declarations - pre_declarations.update({ - k: v - for k, v in extra_maybenonpost.items() - if k not in post_overrides - }) + for k, v in extra_maybenonpost.items(): + if k in post_overrides: + extra_post_declarations[k] = v + else: + # Anything else is pre_declarations + extra_pre_declarations[k] = v + pre_declarations.update(extra_pre_declarations) + post_declarations.update(extra_post_declarations) return pre_declarations, post_declarations From 5ed80f7c5e4e44ffb031a3f2e80a85a4bd4e1e46 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Freitag?= Date: Fri, 2 Jul 2021 16:44:40 +0200 Subject: [PATCH 2/4] Format code with Black Black is a very popular Python code formatter. It ensures a consistent coding style across the library. It is opinionated and not configurable, so that projects adopting Black are similar. The main advantage a code formatter is to avoid concerns about coding style. Many text editors have an integration for Black and can be configured to format on save. The isort profile has been set to "black" for compatibility. https://pycqa.github.io/isort/docs/configuration/black_compatibility/ https://github.com/psf/black Short multiline comprehensions were kept on multiple lines using # fmt: skip to improve the readability. --- Makefile | 4 +- README.rst | 4 + docs/conf.py | 3 +- examples/django_demo/django_demo/settings.py | 2 +- .../generic_foreignkey/factories.py | 3 +- .../migrations/0001_initial.py | 14 +- .../django_demo/generic_foreignkey/models.py | 1 + .../django_demo/generic_foreignkey/tests.py | 11 +- examples/flask_alchemy/test_demoapp.py | 1 - factory/alchemy.py | 21 +- factory/base.py | 106 +++++--- factory/builder.py | 23 +- factory/declarations.py | 61 +++-- factory/django.py | 39 ++- factory/faker.py | 5 +- factory/fuzzy.py | 46 ++-- factory/helpers.py | 7 +- factory/mogo.py | 1 + factory/utils.py | 15 +- setup.cfg | 1 + tests/alter_time.py | 15 +- tests/djapp/models.py | 5 +- tests/djapp/settings.py | 10 +- tests/test_alchemy.py | 11 +- tests/test_base.py | 9 +- tests/test_declarations.py | 7 +- tests/test_dev_experience.py | 1 + tests/test_django.py | 37 +-- tests/test_docs_internals.py | 8 +- tests/test_faker.py | 20 +- tests/test_fuzzy.py | 47 +++- tests/test_mongoengine.py | 1 + tests/test_regression.py | 1 + tests/test_using.py | 246 +++++++++++++----- tests/test_utils.py | 1 + tests/utils.py | 1 + 36 files changed, 551 insertions(+), 237 deletions(-) diff --git a/Makefile b/Makefile index 9474bae5..c5278f2c 100644 --- a/Makefile +++ b/Makefile @@ -6,6 +6,7 @@ SETUP_PY=setup.py # Use current python binary instead of system default. COVERAGE = python $(shell which coverage) +BLACK = black FLAKE8 = flake8 ISORT = isort CTAGS = ctags @@ -70,9 +71,10 @@ example-test: -# Note: we run the linter in two runs, because our __init__.py files has specific warnings we want to exclude # DOC: Perform code quality tasks lint: + $(BLACK) --target-version py36 --check --diff . + # Note: we run the linter in two runs, because our __init__.py files has specific warnings we want to exclude $(FLAKE8) --exclude $(PACKAGE)/__init__.py $(EXAMPLES_DIR) $(PACKAGE) $(SETUP_PY) $(TESTS_DIR) $(FLAKE8) --ignore F401 $(PACKAGE)/__init__.py $(ISORT) --check-only --diff $(EXAMPLES_DIR) $(PACKAGE) $(SETUP_PY) $(TESTS_DIR) diff --git a/README.rst b/README.rst index d0eb091c..2535360d 100644 --- a/README.rst +++ b/README.rst @@ -23,6 +23,10 @@ factory_boy :target: https://pypi.org/project/factory-boy/ :alt: License +.. image:: https://img.shields.io/badge/code%20style-black-000000.svg + :target: https://github.com/psf/black + :alt: Code style using Black + factory_boy is a fixtures replacement based on thoughtbot's `factory_bot `_. As a fixtures replacement tool, it aims to replace static, hard to maintain fixtures diff --git a/docs/conf.py b/docs/conf.py index 43e63fff..3d579b4a 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -65,7 +65,8 @@ if 'READTHEDOCS_VERSION' in os.environ: # Use the readthedocs version string in preference to our known version. html_title = "{} {} documentation".format( - project, os.environ['READTHEDOCS_VERSION']) + project, os.environ['READTHEDOCS_VERSION'] + ) # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, diff --git a/examples/django_demo/django_demo/settings.py b/examples/django_demo/django_demo/settings.py index 5135faf9..70248530 100644 --- a/examples/django_demo/django_demo/settings.py +++ b/examples/django_demo/django_demo/settings.py @@ -37,7 +37,7 @@ 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', - 'generic_foreignkey' + 'generic_foreignkey', ] MIDDLEWARE = [ diff --git a/examples/django_demo/generic_foreignkey/factories.py b/examples/django_demo/generic_foreignkey/factories.py index c7f5117e..273d49a5 100644 --- a/examples/django_demo/generic_foreignkey/factories.py +++ b/examples/django_demo/generic_foreignkey/factories.py @@ -23,7 +23,8 @@ class Meta: class TaggedItemFactory(factory.django.DjangoModelFactory): object_id = factory.SelfAttribute('content_object.id') content_type = factory.LazyAttribute( - lambda o: ContentType.objects.get_for_model(o.content_object)) + lambda o: ContentType.objects.get_for_model(o.content_object) + ) class Meta: exclude = ['content_object'] diff --git a/examples/django_demo/generic_foreignkey/migrations/0001_initial.py b/examples/django_demo/generic_foreignkey/migrations/0001_initial.py index ce5cf761..f3a02892 100644 --- a/examples/django_demo/generic_foreignkey/migrations/0001_initial.py +++ b/examples/django_demo/generic_foreignkey/migrations/0001_initial.py @@ -14,15 +14,23 @@ class Migration(migrations.Migration): migrations.CreateModel( name='TaggedItem', fields=[ - ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ( + 'id', + models.AutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name='ID', + ), + ), ('tag', models.SlugField()), ('object_id', models.PositiveIntegerField()), ( 'content_type', models.ForeignKey( on_delete=django.db.models.deletion.CASCADE, - to='contenttypes.ContentType' - ) + to='contenttypes.ContentType', + ), ), ], ), diff --git a/examples/django_demo/generic_foreignkey/models.py b/examples/django_demo/generic_foreignkey/models.py index 912a8d1f..bf92c320 100644 --- a/examples/django_demo/generic_foreignkey/models.py +++ b/examples/django_demo/generic_foreignkey/models.py @@ -5,6 +5,7 @@ class TaggedItem(models.Model): """Example GenericForeignKey model from django docs""" + tag = models.SlugField() content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE) object_id = models.PositiveIntegerField() diff --git a/examples/django_demo/generic_foreignkey/tests.py b/examples/django_demo/generic_foreignkey/tests.py index c1950a24..091b31d3 100644 --- a/examples/django_demo/generic_foreignkey/tests.py +++ b/examples/django_demo/generic_foreignkey/tests.py @@ -6,7 +6,6 @@ class GenericFactoryTest(TestCase): - def test_user_factory(self): user = UserFactory() self.assertEqual(user.first_name, 'Adam') @@ -19,10 +18,16 @@ def test_generic_user(self): model = TaggedUserFactory(tag='user') self.assertEqual(model.tag, 'user') self.assertTrue(isinstance(model.content_object, User)) - self.assertEqual(model.content_type, ContentType.objects.get_for_model(model.content_object)) + self.assertEqual( + model.content_type, + ContentType.objects.get_for_model(model.content_object), + ) def test_generic_group(self): model = TaggedGroupFactory(tag='group') self.assertEqual(model.tag, 'group') self.assertTrue(isinstance(model.content_object, Group)) - self.assertEqual(model.content_type, ContentType.objects.get_for_model(model.content_object)) + self.assertEqual( + model.content_type, + ContentType.objects.get_for_model(model.content_object), + ) diff --git a/examples/flask_alchemy/test_demoapp.py b/examples/flask_alchemy/test_demoapp.py index 04658c2f..dc42f4b2 100644 --- a/examples/flask_alchemy/test_demoapp.py +++ b/examples/flask_alchemy/test_demoapp.py @@ -5,7 +5,6 @@ class DemoAppTestCase(unittest.TestCase): - def setUp(self): demoapp.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://' demoapp.app.config['TESTING'] = True diff --git a/factory/alchemy.py b/factory/alchemy.py index ef7a591a..be37800c 100644 --- a/factory/alchemy.py +++ b/factory/alchemy.py @@ -18,8 +18,8 @@ class SQLAlchemyOptions(base.FactoryOptions): def _check_sqlalchemy_session_persistence(self, meta, value): if value not in VALID_SESSION_PERSISTENCE_TYPES: raise TypeError( - "%s.sqlalchemy_session_persistence must be one of %s, got %r" % - (meta, VALID_SESSION_PERSISTENCE_TYPES, value) + "%s.sqlalchemy_session_persistence must be one of %s, got %r" + % (meta, VALID_SESSION_PERSISTENCE_TYPES, value) ) def _build_default_options(self): @@ -36,7 +36,7 @@ def _build_default_options(self): class SQLAlchemyModelFactory(base.Factory): - """Factory for SQLAlchemy models. """ + """Factory for SQLAlchemy models.""" _options_class = SQLAlchemyOptions @@ -57,12 +57,12 @@ def _get_or_create(cls, model_class, session, args, kwargs): if field not in kwargs: raise errors.FactoryError( "sqlalchemy_get_or_create - " - "Unable to find initialization value for '%s' in factory %s" % - (field, cls.__name__)) + "Unable to find initialization value for '%s' in factory %s" + % (field, cls.__name__) + ) key_fields[field] = kwargs.pop(field) - obj = session.query(model_class).filter_by( - *args, **key_fields).one_or_none() + obj = session.query(model_class).filter_by(*args, **key_fields).one_or_none() if not obj: try: @@ -76,8 +76,11 @@ def _get_or_create(cls, model_class, session, args, kwargs): } if get_or_create_params: try: - obj = session.query(model_class).filter_by( - **get_or_create_params).one() + obj = ( + session.query(model_class) + .filter_by(**get_or_create_params) + .one() + ) except NoResultFound: # Original params are not a valid lookup and triggered a create(), # that resulted in an IntegrityError. diff --git a/factory/base.py b/factory/base.py index 36b2359a..28fdcbcc 100644 --- a/factory/base.py +++ b/factory/base.py @@ -41,8 +41,9 @@ def __call__(cls, **kwargs): elif cls._meta.strategy == enums.STUB_STRATEGY: return cls.stub(**kwargs) else: - raise errors.UnknownStrategy('Unknown Meta.strategy: {}'.format( - cls._meta.strategy)) + raise errors.UnknownStrategy( + 'Unknown Meta.strategy: {}'.format(cls._meta.strategy) + ) def __new__(mcs, class_name, bases, attrs): """Record attributes as a pattern for later instance construction. @@ -74,8 +75,7 @@ def __new__(mcs, class_name, bases, attrs): meta = options_class() attrs['_meta'] = meta - new_class = super().__new__( - mcs, class_name, bases, attrs) + new_class = super().__new__(mcs, class_name, bases, attrs) meta.contribute_to_class( new_class, @@ -110,6 +110,7 @@ class OptionDefault: checker: callable or None, an optional function used to detect invalid option values at declaration time """ + def __init__(self, name, value, inherit=False, checker=None): self.name = name self.value = value @@ -131,7 +132,10 @@ def apply(self, meta, base_meta): def __str__(self): return '%s(%r, %r, inherit=%r)' % ( self.__class__.__name__, - self.name, self.value, self.inherit) + self.name, + self.value, + self.inherit, + ) class FactoryOptions: @@ -150,12 +154,15 @@ def __init__(self): @property def declarations(self): base_declarations = dict(self.base_declarations) - for name, param in utils.sort_ordered_objects(self.parameters.items(), getter=lambda item: item[1]): + for name, param in utils.sort_ordered_objects( + self.parameters.items(), + getter=lambda item: item[1], + ): base_declarations.update(param.as_declarations(name, base_declarations)) return base_declarations def _build_default_options(self): - """"Provide the default value for all allowed fields. + """Provide the default value for all allowed fields. Custom FactoryOptions classes should override this method to update() its return value. @@ -163,10 +170,7 @@ def _build_default_options(self): def is_model(meta, value): if isinstance(value, FactoryMetaClass): - raise TypeError( - "%s is already a %s" - % (repr(value), Factory.__name__) - ) + raise TypeError("%s is already a %s" % (repr(value), Factory.__name__)) return [ OptionDefault('model', None, inherit=True, checker=is_model), @@ -185,11 +189,13 @@ def _fill_from_meta(self, meta, base_meta): meta_attrs = { k: v for (k, v) in vars(meta).items() - if not k.startswith('_') + if not k.startswith('_') # fmt: skip } for option in self._build_default_options(): - assert not hasattr(self, option.name), "Can't override field %s." % option.name + assert not hasattr(self, option.name), ( + "Can't override field %s." % option.name + ) value = option.apply(meta, base_meta) meta_attrs.pop(option.name, None) setattr(self, option.name, value) @@ -198,9 +204,12 @@ def _fill_from_meta(self, meta, base_meta): # Some attributes in the Meta aren't allowed here raise TypeError( "'class Meta' for %r got unknown attribute(s) %s" - % (self.factory, ','.join(sorted(meta_attrs.keys())))) + % (self.factory, ','.join(sorted(meta_attrs.keys()))) + ) - def contribute_to_class(self, factory, meta=None, base_meta=None, base_factory=None, params=None): + def contribute_to_class( + self, factory, meta=None, base_meta=None, base_factory=None, params=None + ): self.factory = factory self.base_factory = base_factory @@ -226,21 +235,27 @@ def contribute_to_class(self, factory, meta=None, base_meta=None, base_factory=N self.base_declarations[k] = v if params is not None: - for k, v in utils.sort_ordered_objects(vars(params).items(), getter=lambda item: item[1]): + for k, v in utils.sort_ordered_objects( + vars(params).items(), getter=lambda item: item[1] + ): if not k.startswith('_'): self.parameters[k] = declarations.SimpleParameter.wrap(v) self._check_parameter_dependencies(self.parameters) - self.pre_declarations, self.post_declarations = builder.parse_declarations(self.declarations) + self.pre_declarations, self.post_declarations = builder.parse_declarations( + self.declarations + ) def _get_counter_reference(self): """Identify which factory should be used for a shared counter.""" - if (self.model is not None - and self.base_factory is not None - and self.base_factory._meta.model is not None - and issubclass(self.model, self.base_factory._meta.model)): + if ( + self.model is not None + and self.base_factory is not None + and self.base_factory._meta.model is not None + and issubclass(self.model, self.base_factory._meta.model) + ): return self.base_factory._meta.counter_reference else: return self @@ -277,7 +292,8 @@ def reset_sequence(self, value=None, force=False): if self.counter_reference is not self and not force: raise ValueError( "Can't reset a sequence on descendant factory %r; reset sequence on %r or use `force=True`." - % (self.factory, self.counter_reference.factory)) + % (self.factory, self.counter_reference.factory) + ) if value is None: value = self.counter_reference.factory._setup_next_sequence() @@ -291,8 +307,11 @@ def prepare_arguments(self, attributes): # 2. Remove hidden objects kwargs = { - k: v for k, v in kwargs.items() - if k not in self.exclude and k not in self.parameters and v is not declarations.SKIP + k: v + for k, v in kwargs.items() + if k not in self.exclude + and k not in self.parameters + and v is not declarations.SKIP } # 3. Rename fields @@ -303,7 +322,7 @@ def prepare_arguments(self, attributes): # 4. Extract inline args args = tuple( kwargs.pop(arg_name) - for arg_name in self.inline_args + for arg_name in self.inline_args # fmt: skip ) return args, kwargs @@ -354,17 +373,22 @@ def _check_parameter_dependencies(self, parameters): field_revdeps = parameter.get_revdeps(parameters) if not field_revdeps: continue - deep_revdeps[name] = set.union(*(deep_revdeps[dep] for dep in field_revdeps)) + deep_revdeps[name] = set.union( + *(deep_revdeps[dep] for dep in field_revdeps) + ) deep_revdeps[name] |= set(field_revdeps) for dep in field_revdeps: deps[dep].add(name) # Check for cyclical dependencies - cyclic = [name for name, field_deps in deep_revdeps.items() if name in field_deps] + cyclic = [ + name for name, field_deps in deep_revdeps.items() if name in field_deps + ] if cyclic: raise errors.CyclicDefinitionError( "Cyclic definition detected on %r; Params around %s" - % (self.factory, ', '.join(cyclic))) + % (self.factory, ', '.join(cyclic)) + ) return deps def get_model_class(self): @@ -459,7 +483,8 @@ def _generate(cls, strategy, params): raise errors.FactoryError( "Cannot generate instances of abstract factory %(f)s; " "Ensure %(f)s.Meta.model is set and %(f)s.Meta.abstract " - "is either not set or False." % dict(f=cls.__name__)) + "is either not set or False." % dict(f=cls.__name__) + ) step = builder.StepBuilder(cls._meta, params, strategy) return step.build() @@ -573,7 +598,11 @@ def generate(cls, strategy, **kwargs): Returns: object: the generated instance """ - assert strategy in (enums.STUB_STRATEGY, enums.BUILD_STRATEGY, enums.CREATE_STRATEGY) + assert strategy in ( + enums.STUB_STRATEGY, + enums.BUILD_STRATEGY, + enums.CREATE_STRATEGY, + ) action = getattr(cls, strategy) return action(**kwargs) @@ -591,7 +620,11 @@ def generate_batch(cls, strategy, size, **kwargs): Returns: object list: the generated instances """ - assert strategy in (enums.STUB_STRATEGY, enums.BUILD_STRATEGY, enums.CREATE_STRATEGY) + assert strategy in ( + enums.STUB_STRATEGY, + enums.BUILD_STRATEGY, + enums.CREATE_STRATEGY, + ) batch_action = getattr(cls, '%s_batch' % strategy) return batch_action(size, **kwargs) @@ -644,13 +677,13 @@ class Meta(BaseMeta): class StubObject: """A generic container.""" + def __init__(self, **kwargs): for field, value in kwargs.items(): setattr(self, field, value) class StubFactory(Factory): - class Meta: strategy = enums.STUB_STRATEGY model = StubObject @@ -666,14 +699,14 @@ def create(cls, **kwargs): class BaseDictFactory(Factory): """Factory for dictionary-like classes.""" + class Meta: abstract = True @classmethod def _build(cls, model_class, *args, **kwargs): if args: - raise ValueError( - "DictFactory %r does not support Meta.inline_args." % cls) + raise ValueError("DictFactory %r does not support Meta.inline_args." % cls) return model_class(**kwargs) @classmethod @@ -688,14 +721,14 @@ class Meta: class BaseListFactory(Factory): """Factory for list-like classes.""" + class Meta: abstract = True @classmethod def _build(cls, model_class, *args, **kwargs): if args: - raise ValueError( - "ListFactory %r does not support Meta.inline_args." % cls) + raise ValueError("ListFactory %r does not support Meta.inline_args." % cls) # kwargs are constructed from a list, their insertion order matches the list # order, no additional sorting is required. @@ -726,4 +759,5 @@ def use_strategy(new_strategy): def wrapped_class(klass): klass._meta.strategy = new_strategy return klass + return wrapped_class diff --git a/factory/builder.py b/factory/builder.py index 9d810fbe..ceafa1cf 100644 --- a/factory/builder.py +++ b/factory/builder.py @@ -73,7 +73,8 @@ def update(self, values): extra_context_keys = set(self.contexts) - set(self.declarations) if extra_context_keys: raise errors.InvalidDeclarationError( - "Received deep context for unknown fields: %r (known=%r)" % ( + "Received deep context for unknown fields: %r (known=%r)" + % ( { self.join(root, sub): v for root in extra_context_keys @@ -92,7 +93,7 @@ def filter(self, entries): """ return [ entry for entry in entries - if self.split(entry)[0] in self.declarations + if self.split(entry)[0] in self.declarations # fmt: skip ] def sorted(self): @@ -210,10 +211,12 @@ def chain(self): def recurse(self, factory, declarations, force_sequence=None): from . import base + if not issubclass(factory, base.BaseFactory): raise errors.AssociatedClassError( "%r: Attempting to recursing into a non-factory object %r" - % (self, factory)) + % (self, factory) + ) builder = self.builder.recurse(factory._meta, declarations) return builder.build(parent_step=self, force_sequence=force_sequence) @@ -230,6 +233,7 @@ class StepBuilder: - factory: the factory class being built - strategy: the strategy to use """ + def __init__(self, factory_meta, extras, strategy): self.factory_meta = factory_meta self.strategy = strategy @@ -333,14 +337,18 @@ def __getattr__(self, name): """ if name in self.__pending: raise errors.CyclicDefinitionError( - "Cyclic lazy attribute definition for %r; cycle found in %r." % - (name, self.__pending)) + "Cyclic lazy attribute definition for %r; cycle found in %r." + % (name, self.__pending) + ) elif name in self.__values: return self.__values[name] elif name in self.__declarations: declaration = self.__declarations[name] value = declaration.declaration - if enums.get_builder_phase(value) == enums.BuilderPhase.ATTRIBUTE_RESOLUTION: + if ( + enums.get_builder_phase(value) + == enums.BuilderPhase.ATTRIBUTE_RESOLUTION + ): self.__pending.append(name) try: value = value.evaluate_pre( @@ -357,7 +365,8 @@ def __getattr__(self, name): else: raise AttributeError( "The parameter %r is unknown. Evaluated attributes are %r, " - "definitions are %r." % (name, self.__values, self.__declarations)) + "definitions are %r." % (name, self.__values, self.__declarations) + ) def __setattr__(self, name, value): """Prevent setting attributes once __init__ is done.""" diff --git a/factory/declarations.py b/factory/declarations.py index fe2e34d9..ed401393 100644 --- a/factory/declarations.py +++ b/factory/declarations.py @@ -40,6 +40,7 @@ def unroll_context(self, instance, step, context): return full_context import factory.base + subfactory = factory.base.DictFactory return step.recurse(subfactory, full_context, force_sequence=step.sequence) @@ -178,7 +179,11 @@ def evaluate(self, instance, step, extra): else: target = instance - logger.debug("SelfAttribute: Picking attribute %r on %r", self.attribute_name, target) + logger.debug( + "SelfAttribute: Picking attribute %r on %r", + self.attribute_name, + target, + ) return deepgetattr(target, self.attribute_name, self.default) def __repr__(self): @@ -205,7 +210,9 @@ def __init__(self, iterator, cycle=True, getter=None): self.iterator = None if cycle: - self.iterator_builder = lambda: utils.ResetableIterator(itertools.cycle(iterator)) + self.iterator_builder = lambda: utils.ResetableIterator( + itertools.cycle(iterator) + ) else: self.iterator_builder = lambda: utils.ResetableIterator(iterator) @@ -236,12 +243,17 @@ class Sequence(BaseDeclaration): function (function): A function, expecting the current sequence counter and returning the computed value. """ + def __init__(self, function): super().__init__() self.function = function def evaluate(self, instance, step, extra): - logger.debug("Sequence: Computing next value of %r for seq=%s", self.function, step.sequence) + logger.debug( + "Sequence: Computing next value of %r for seq=%s", + self.function, + step.sequence, + ) return self.function(int(step.sequence)) @@ -254,10 +266,14 @@ class LazyAttributeSequence(Sequence): type (function): A function converting an integer into the expected kind of counter for the 'function' attribute. """ + def evaluate(self, instance, step, extra): logger.debug( "LazyAttributeSequence: Computing next value of %r for seq=%s, obj=%r", - self.function, step.sequence, instance) + self.function, + step.sequence, + instance, + ) return self.function(instance, int(step.sequence)) @@ -270,6 +286,7 @@ class ContainerAttribute(BaseDeclaration): strict (bool): Whether evaluating should fail when the containers are not passed in (i.e used outside a SubFactory). """ + def __init__(self, function, strict=True): super().__init__() self.function = function @@ -290,7 +307,8 @@ def evaluate(self, instance, step, extra): if self.strict and not chain: raise TypeError( "A ContainerAttribute in 'strict' mode can only be used " - "within a SubFactory.") + "within a SubFactory." + ) return self.function(instance, chain) @@ -342,6 +360,7 @@ class _FactoryWrapper: Such args can be either a Factory subclass, or a fully qualified import path for that subclass (e.g 'myapp.factories.MyFactory'). """ + def __init__(self, factory_or_path): self.factory = None self.module = self.name = '' @@ -352,7 +371,8 @@ def __init__(self, factory_or_path): raise ValueError( "A factory= argument must receive either a class " "or the fully qualified path to a Factory subclass; got " - "%r instead." % factory_or_path) + "%r instead." % factory_or_path + ) self.module, self.name = factory_or_path.rsplit('.', 1) def get(self): @@ -403,7 +423,8 @@ def evaluate(self, instance, step, extra): subfactory = self.get_factory() logger.debug( "SubFactory: Instantiating %s.%s(%s), create=%r", - subfactory.__module__, subfactory.__name__, + subfactory.__module__, + subfactory.__name__, utils.log_pprint(kwargs=extra), step, ) @@ -463,7 +484,11 @@ def __init__(self, decider, yes_declaration=SKIP, no_declaration=SKIP): if len(used_phases) > 1: raise TypeError(f"Inconsistent phases for {self!r}: {phases!r}") - self.FACTORY_BUILDER_PHASE = used_phases.pop() if used_phases else enums.BuilderPhase.ATTRIBUTE_RESOLUTION + self.FACTORY_BUILDER_PHASE = ( + used_phases.pop() + if used_phases + else enums.BuilderPhase.ATTRIBUTE_RESOLUTION + ) def evaluate_post(self, instance, step, overrides): """Handle post-generation declarations""" @@ -472,11 +497,13 @@ def evaluate_post(self, instance, step, overrides): # Note: we work on the *builder stub*, not on the actual instance. # This gives us access to all Params-level definitions. choice = self.decider.evaluate_pre( - instance=step.stub, step=step, overrides=overrides) + instance=step.stub, step=step, overrides=overrides + ) else: assert decider_phase == enums.BuilderPhase.POST_INSTANTIATION choice = self.decider.evaluate_post( - instance=instance, step=step, overrides={}) + instance=instance, step=step, overrides={} + ) target = self.yes if choice else self.no if enums.get_builder_phase(target) == enums.BuilderPhase.POST_INSTANTIATION: @@ -552,6 +579,7 @@ def wrap(cls, value): class Trait(Parameter): """The simplest complex parameter, it enables a bunch of new declarations based on a boolean flag.""" + def __init__(self, **overrides): super().__init__() self.overrides = overrides @@ -561,7 +589,8 @@ def as_declarations(self, field_name, declarations): for maybe_field, new_value in self.overrides.items(): overrides[maybe_field] = Maybe( decider=SelfAttribute( - '%s.%s' % ( + '%s.%s' + % ( '.' * maybe_field.count(enums.SPLITTER), field_name, ), @@ -579,7 +608,7 @@ def get_revdeps(self, parameters): def __repr__(self): return '%s(%s)' % ( self.__class__.__name__, - ', '.join('%s=%r' % t for t in self.overrides.items()) + ', '.join('%s=%r' % t for t in self.overrides.items()), ) @@ -621,6 +650,7 @@ def call(self, instance, step, context): # pragma: no cover class PostGeneration(PostGenerationDeclaration): """Calls a given function once the object has been generated.""" + def __init__(self, function): super().__init__() self.function = function @@ -636,8 +666,7 @@ def call(self, instance, step, context): ), ) create = step.builder.strategy == enums.CREATE_STRATEGY - return self.function( - instance, create, context.value, **context.extra) + return self.function(instance, create, context.value, **context.extra) class RelatedFactory(PostGenerationDeclaration): @@ -671,7 +700,8 @@ def call(self, instance, step, context): logger.debug( "RelatedFactory: Using provided %r instead of generating %s.%s.", context.value, - factory.__module__, factory.__name__, + factory.__module__, + factory.__name__, ) return context.value @@ -730,6 +760,7 @@ class UserFactory(factory.Factory): ... password = factory.PostGenerationMethodCall('set_pass', password='') """ + def __init__(self, method_name, *args, **kwargs): super().__init__() if len(args) > 1: diff --git a/factory/django.py b/factory/django.py index 7e5427fe..98e755bd 100644 --- a/factory/django.py +++ b/factory/django.py @@ -41,6 +41,7 @@ def _lazy_load_get_model(): the settings haven't been configured yet. """ from django import apps as django_apps + _LAZY_LOADS['get_model'] = django_apps.apps.get_model @@ -54,11 +55,13 @@ def _build_default_options(self): def _get_counter_reference(self): counter_reference = super()._get_counter_reference() - if (counter_reference == self.base_factory - and self.base_factory._meta.model is not None - and self.base_factory._meta.model._meta.abstract - and self.model is not None - and not self.model._meta.abstract): + if ( + counter_reference == self.base_factory + and self.base_factory._meta.model is not None + and self.base_factory._meta.model._meta.abstract + and self.model is not None + and not self.model._meta.abstract + ): # Target factory is for an abstract model, yet we're for another, # concrete subclass => don't reuse the counter. return self.factory @@ -99,7 +102,8 @@ def _load_model_class(cls, definition): def _get_manager(cls, model_class): if model_class is None: raise errors.AssociatedClassError( - f"No model set on {cls.__module__}.{cls.__name__}.Meta") + f"No model set on {cls.__module__}.{cls.__name__}.Meta" + ) try: manager = model_class.objects @@ -127,15 +131,17 @@ def _get_or_create(cls, model_class, *args, **kwargs): assert 'defaults' not in cls._meta.django_get_or_create, ( "'defaults' is a reserved keyword for get_or_create " "(in %s._meta.django_get_or_create=%r)" - % (cls, cls._meta.django_get_or_create)) + % (cls, cls._meta.django_get_or_create) + ) key_fields = {} for field in cls._meta.django_get_or_create: if field not in kwargs: raise errors.FactoryError( "django_get_or_create - " - "Unable to find initialization value for '%s' in factory %s" % - (field, cls.__name__)) + "Unable to find initialization value for '%s' in factory %s" + % (field, cls.__name__) + ) key_fields[field] = kwargs.pop(field) key_fields['defaults'] = kwargs @@ -203,7 +209,11 @@ def _make_data(self, params): def _make_content(self, params): path = '' - _content_params = [params.get('from_path'), params.get('from_file'), params.get('from_func')] + _content_params = [ + params.get('from_path'), + params.get('from_file'), + params.get('from_func'), + ] if len([p for p in _content_params if p]) > 1: raise ValueError( "At most one argument from 'from_file', 'from_path', and 'from_func' should " @@ -289,8 +299,7 @@ def __init__(self, *signals): def __enter__(self): for signal in self.signals: - logger.debug('mute_signals: Disabling signal handlers %r', - signal.receivers) + logger.debug('mute_signals: Disabling signal handlers %r', signal.receivers) # Note that we're using implementation details of # django.signals, since arguments to signal.connect() @@ -300,8 +309,7 @@ def __enter__(self): def __exit__(self, exc_type, exc_value, traceback): for signal, receivers in self.paused.items(): - logger.debug('mute_signals: Restoring signal handlers %r', - receivers) + logger.debug('mute_signals: Restoring signal handlers %r', receivers) signal.receivers += receivers with signal.lock: @@ -322,11 +330,13 @@ def __call__(self, callable_obj): return callable_obj else: + @functools.wraps(callable_obj) def wrapper(*args, **kwargs): # A mute_signals() object is not reentrant; use a copy every time. with self.copy(): return callable_obj(*args, **kwargs) + return wrapper def wrap_method(self, method): @@ -336,4 +346,5 @@ def wrapped_method(*args, **kwargs): # A mute_signals() object is not reentrant; use a copy every time. with self.copy(): return method(*args, **kwargs) + return wrapped_method diff --git a/factory/faker.py b/factory/faker.py index 6ed2e28c..fcbc278d 100644 --- a/factory/faker.py +++ b/factory/faker.py @@ -35,12 +35,11 @@ class Faker(declarations.BaseDeclaration): Usage: >>> foo = factory.Faker('name') """ + def __init__(self, provider, **kwargs): locale = kwargs.pop('locale', None) self.provider = provider - super().__init__( - locale=locale, - **kwargs) + super().__init__(locale=locale, **kwargs) def evaluate(self, instance, step, extra): locale = extra.pop('locale') diff --git a/factory/fuzzy.py b/factory/fuzzy.py index ce89d7f7..0975c359 100644 --- a/factory/fuzzy.py +++ b/factory/fuzzy.py @@ -170,13 +170,16 @@ def __init__(self, start_date, end_date=None): if start_date > end_date: raise ValueError( "FuzzyDate boundaries should have start <= end; got %r > %r." - % (start_date, end_date)) + % (start_date, end_date) + ) self.start_date = start_date.toordinal() self.end_date = end_date.toordinal() def fuzz(self): - return datetime.date.fromordinal(random.randgen.randint(self.start_date, self.end_date)) + return datetime.date.fromordinal( + random.randgen.randint(self.start_date, self.end_date) + ) class BaseFuzzyDateTime(BaseFuzzyAttribute): @@ -188,16 +191,25 @@ class BaseFuzzyDateTime(BaseFuzzyAttribute): def _check_bounds(self, start_dt, end_dt): if start_dt > end_dt: raise ValueError( - """%s boundaries should have start <= end, got %r > %r""" % ( - self.__class__.__name__, start_dt, end_dt)) + """%s boundaries should have start <= end, got %r > %r""" + % (self.__class__.__name__, start_dt, end_dt) + ) def _now(self): raise NotImplementedError() - def __init__(self, start_dt, end_dt=None, - force_year=None, force_month=None, force_day=None, - force_hour=None, force_minute=None, force_second=None, - force_microsecond=None): + def __init__( + self, + start_dt, + end_dt=None, + force_year=None, + force_month=None, + force_day=None, + force_hour=None, + force_minute=None, + force_second=None, + force_microsecond=None, + ): super().__init__() if end_dt is None: @@ -220,7 +232,9 @@ def __init__(self, start_dt, end_dt=None, def fuzz(self): delta = self.end_dt - self.start_dt - microseconds = delta.microseconds + 1000000 * (delta.seconds + (delta.days * 86400)) + microseconds = delta.microseconds + 1000000 * ( + delta.seconds + (delta.days * 86400) + ) offset = random.randgen.randint(0, microseconds) result = self.start_dt + datetime.timedelta(microseconds=offset) @@ -256,11 +270,12 @@ def _check_bounds(self, start_dt, end_dt): if start_dt.tzinfo is not None: raise ValueError( "FuzzyNaiveDateTime only handles naive datetimes, got start=%r" - % start_dt) + % start_dt + ) if end_dt.tzinfo is not None: raise ValueError( - "FuzzyNaiveDateTime only handles naive datetimes, got end=%r" - % end_dt) + "FuzzyNaiveDateTime only handles naive datetimes, got end=%r" % end_dt + ) super()._check_bounds(start_dt, end_dt) @@ -278,9 +293,10 @@ def _check_bounds(self, start_dt, end_dt): if start_dt.tzinfo is None: raise ValueError( "FuzzyDateTime requires timezone-aware datetimes, got start=%r" - % start_dt) + % start_dt + ) if end_dt.tzinfo is None: raise ValueError( - "FuzzyDateTime requires timezone-aware datetimes, got end=%r" - % end_dt) + "FuzzyDateTime requires timezone-aware datetimes, got end=%r" % end_dt + ) super()._check_bounds(start_dt, end_dt) diff --git a/factory/helpers.py b/factory/helpers.py index 496de6e3..1bb6034f 100644 --- a/factory/helpers.py +++ b/factory/helpers.py @@ -36,7 +36,12 @@ class Meta: kwargs['Meta'] = Meta base_class = kwargs.pop('FACTORY_CLASS', base.Factory) - factory_class = type(base.Factory).__new__(type(base.Factory), factory_name, (base_class,), kwargs) + factory_class = type(base.Factory).__new__( + type(base.Factory), + factory_name, + (base_class,), + kwargs, + ) factory_class.__name__ = '%sFactory' % klass.__name__ factory_class.__doc__ = 'Auto-generated factory for class %s' % klass return factory_class diff --git a/factory/mogo.py b/factory/mogo.py index f886ae14..54c16ea0 100644 --- a/factory/mogo.py +++ b/factory/mogo.py @@ -9,6 +9,7 @@ class MogoFactory(base.Factory): """Factory for mogo objects.""" + class Meta: abstract = True diff --git a/factory/utils.py b/factory/utils.py index a74e0b35..3685839f 100644 --- a/factory/utils.py +++ b/factory/utils.py @@ -22,6 +22,7 @@ class log_pprint: Since it is only used with factory.debug(), the computation is performed lazily. """ + __slots__ = ['args', 'kwargs'] def __init__(self, args=(), kwargs=None): @@ -33,17 +34,14 @@ def __repr__(self): def __str__(self): return ', '.join( - [ - repr(arg) for arg in self.args - ] + [ - '%s=%s' % (key, repr(value)) - for key, value in self.kwargs.items() - ] + [repr(arg) for arg in self.args] + + ['%s=%s' % (key, repr(value)) for key, value in self.kwargs.items()] ) class ResetableIterator: """An iterator wrapper that can be 'reset()' to its start.""" + def __init__(self, iterator, **kwargs): super().__init__(**kwargs) self.iterator = iter(iterator) @@ -102,4 +100,7 @@ def sort_ordered_objects(items, getter=lambda x: x): >>> sort_ordered_objects([x, y, z]) >>> sort_ordered_objects(v.items(), getter=lambda e: e[1]) """ - return sorted(items, key=lambda x: getattr(getter(x), OrderedBase.CREATION_COUNTER_FIELD, -1)) + return sorted( + items, + key=lambda x: getattr(getter(x), OrderedBase.CREATION_COUNTER_FIELD, -1), + ) diff --git a/setup.cfg b/setup.cfg index 8c4e502b..eeb161b9 100644 --- a/setup.cfg +++ b/setup.cfg @@ -41,6 +41,7 @@ install_requires = Faker>=0.7.0 [options.extras_require] dev = + black coverage Django flake8 diff --git a/tests/alter_time.py b/tests/alter_time.py index 3da968d5..427b572f 100644 --- a/tests/alter_time.py +++ b/tests/alter_time.py @@ -83,19 +83,24 @@ def main(): # pragma: no cover print("Entering mock") with mock_datetime_now(target_dt, datetime): print("- now ->", datetime.datetime.now()) - print("- isinstance(now, dt) ->", isinstance(datetime.datetime.now(), datetime.datetime)) - print("- isinstance(target, dt) ->", isinstance(target_dt, datetime.datetime)) + now_is_datetime = isinstance(datetime.datetime.now(), datetime.datetime) + print("- isinstance(now, dt) ->", now_is_datetime) + target_dt_is_datetime = isinstance(target_dt, datetime.datetime) + print("- isinstance(target, dt) ->", target_dt_is_datetime) with mock_date_today(target_date, datetime): print("- today ->", datetime.date.today()) - print("- isinstance(now, date) ->", isinstance(datetime.date.today(), datetime.date)) + now_is_date = isinstance(datetime.date.today(), datetime.date) + print("- isinstance(now, date) ->", now_is_date) print("- isinstance(target, date) ->", isinstance(target_date, datetime.date)) print("Outside mock") print("- now ->", datetime.datetime.now()) - print("- isinstance(now, dt) ->", isinstance(datetime.datetime.now(), datetime.datetime)) + now_is_datetime = isinstance(datetime.datetime.now(), datetime.datetime) + print("- isinstance(now, dt) ->", now_is_datetime) print("- isinstance(target, dt) ->", isinstance(target_dt, datetime.datetime)) print("- today ->", datetime.date.today()) - print("- isinstance(now, date) ->", isinstance(datetime.date.today(), datetime.date)) + today_is_date = isinstance(datetime.date.today(), datetime.date) + print("- isinstance(now, date) ->", today_is_date) print("- isinstance(target, date) ->", isinstance(target_date, datetime.date)) diff --git a/tests/djapp/models.py b/tests/djapp/models.py index fb34e907..f74f85fc 100644 --- a/tests/djapp/models.py +++ b/tests/djapp/models.py @@ -68,7 +68,7 @@ class PointerModel(models.Model): PointedModel, related_name='pointer', null=True, - on_delete=models.CASCADE + on_delete=models.CASCADE, ) @@ -94,7 +94,9 @@ class WithImage(models.Model): animage = models.ImageField(upload_to=WITHFILE_UPLOAD_TO) size = models.IntegerField(default=0) + else: + class WithImage(models.Model): pass @@ -112,7 +114,6 @@ def __init__(self, post_save_signal_receiver=None): class CustomManager(models.Manager): - def create(self, arg=None, **kwargs): return super().create(**kwargs) diff --git a/tests/djapp/settings.py b/tests/djapp/settings.py index 13f7d366..fdfe8761 100644 --- a/tests/djapp/settings.py +++ b/tests/djapp/settings.py @@ -5,9 +5,9 @@ import os FACTORY_ROOT = os.path.join( - os.path.abspath(os.path.dirname(__file__)), # /path/to/fboy/tests/djapp/ - os.pardir, # /path/to/fboy/tests/ - os.pardir, # /path/to/fboy + os.path.abspath(os.path.dirname(__file__)), # /path/to/fboy/tests/djapp/ + os.pardir, # /path/to/fboy/tests/ + os.pardir, # /path/to/fboy ) MEDIA_ROOT = os.path.join(FACTORY_ROOT, 'tmp_test') @@ -22,9 +22,7 @@ } -INSTALLED_APPS = [ - 'tests.djapp' -] +INSTALLED_APPS = ['tests.djapp'] MIDDLEWARE_CLASSES = () diff --git a/tests/test_alchemy.py b/tests/test_alchemy.py index 95e7f857..5cbee984 100644 --- a/tests/test_alchemy.py +++ b/tests/test_alchemy.py @@ -63,7 +63,7 @@ class Meta: class WithMultipleGetOrCreateFieldsFactory(SQLAlchemyModelFactory): class Meta: model = models.MultifieldUniqueModel - sqlalchemy_get_or_create = ("slug", "text",) + sqlalchemy_get_or_create = ("slug", "text") sqlalchemy_session = models.session sqlalchemy_session_persistence = 'commit' @@ -135,11 +135,7 @@ def test_multicall(self): self.assertEqual(6, len(objs)) self.assertEqual(2, len(set(objs))) self.assertEqual( - list( - obj.slug for obj in models.session.query( - models.MultiFieldModel.slug - ) - ), + list(obj.slug for obj in models.session.query(models.MultiFieldModel.slug)), ["alt", "main"], ) @@ -210,6 +206,7 @@ class Meta: def test_type_error(self): with self.assertRaises(TypeError): + class BadPersistenceFactory(StandardFactory): class Meta: sqlalchemy_session_persistence = 'invalid_persistence_option' @@ -251,7 +248,6 @@ def test_force_pk(self): class SQLAlchemyNoSessionTestCase(unittest.TestCase): - def test_create_raises_exception_when_no_session_was_set(self): with self.assertRaises(RuntimeError): NoSessionFactory.create() @@ -268,6 +264,7 @@ class NameConflictTests(unittest.TestCase): See #775. """ + def test_no_name_conflict_on_save(self): class SpecialFieldWithSaveFactory(SQLAlchemyModelFactory): class Meta: diff --git a/tests/test_base.py b/tests/test_base.py index 0b9ffa15..76785daf 100644 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -48,6 +48,7 @@ def test_base_factory(self): class AbstractFactoryTestCase(unittest.TestCase): def test_factory_for_optional(self): """Ensure that model= is optional for abstract=True.""" + class TestObjectFactory(base.Factory): class Meta: abstract = True @@ -57,6 +58,7 @@ class Meta: def test_factory_for_and_abstract_factory_optional(self): """Ensure that Meta.abstract is optional.""" + class TestObjectFactory(base.Factory): pass @@ -234,6 +236,7 @@ def some_classmethod(cls): class FactoryTestCase(unittest.TestCase): def test_magic_happens(self): """Calling a FooFactory doesn't yield a FooFactory instance.""" + class TestObjectFactory(base.Factory): class Meta: model = TestObject @@ -262,6 +265,7 @@ class Meta: def test_inheritance_with_sequence(self): """Tests that sequence IDs are shared between parent and son.""" + class TestObjectFactory(base.Factory): class Meta: model = TestObject @@ -289,6 +293,7 @@ def setUp(self): class TestObjectFactory(base.Factory): class Meta: model = TestObject + one = declarations.Sequence(lambda n: n) self.TestObjectFactory = TestObjectFactory @@ -317,6 +322,7 @@ def test_reset_sequence_with_value(self): def test_reset_sequence_subclass_fails(self): """Tests that the sequence of a 'slave' factory cannot be reseted.""" + class SubTestObjectFactory(self.TestObjectFactory): pass @@ -325,6 +331,7 @@ class SubTestObjectFactory(self.TestObjectFactory): def test_reset_sequence_subclass_force(self): """Tests that reset_sequence(force=True) works.""" + class SubTestObjectFactory(self.TestObjectFactory): pass @@ -344,6 +351,7 @@ class SubTestObjectFactory(self.TestObjectFactory): def test_reset_sequence_subclass_parent(self): """Tests that the sequence of a 'slave' factory cannot be reseted.""" + class SubTestObjectFactory(self.TestObjectFactory): pass @@ -518,7 +526,6 @@ class Test(base.Factory): class PostGenerationParsingTestCase(unittest.TestCase): - def test_extraction(self): class TestObjectFactory(base.Factory): class Meta: diff --git a/tests/test_declarations.py b/tests/test_declarations.py index c9458ffe..e45d1bf3 100644 --- a/tests/test_declarations.py +++ b/tests/test_declarations.py @@ -47,7 +47,11 @@ def test_init(self): declarations.Maybe('foo', 1, 2) with self.assertRaisesRegex(TypeError, 'Inconsistent phases'): - declarations.Maybe('foo', declarations.LazyAttribute(None), declarations.PostGenerationDeclaration()) + declarations.Maybe( + 'foo', + declarations.LazyAttribute(None), + declarations.PostGenerationDeclaration(), + ) class SelfAttributeTestCase(unittest.TestCase): @@ -281,7 +285,6 @@ def test_multi_call_with_multi_method_args(self): class PostGenerationOrdering(unittest.TestCase): - def test_post_generation_declaration_order(self): postgen_results = [] diff --git a/tests/test_dev_experience.py b/tests/test_dev_experience.py index 6677b08c..ada91e5d 100644 --- a/tests/test_dev_experience.py +++ b/tests/test_dev_experience.py @@ -15,6 +15,7 @@ class DeclarationTests(unittest.TestCase): def test_subfactory_to_model(self): """A helpful error message occurs when pointing a subfactory to a model.""" + class CountryFactory(factory.Factory): class Meta: model = Country diff --git a/tests/test_django.py b/tests/test_django.py index 48b94329..2c38cafa 100644 --- a/tests/test_django.py +++ b/tests/test_django.py @@ -137,7 +137,7 @@ class Meta: class WithMultipleGetOrCreateFieldsFactory(factory.django.DjangoModelFactory): class Meta: model = models.MultifieldUniqueModel - django_get_or_create = ("slug", "text",) + django_get_or_create = ("slug", "text") slug = factory.Sequence(lambda n: "slug%s" % n) text = factory.Sequence(lambda n: "text%s" % n) @@ -280,7 +280,7 @@ def test_reuse_pk(self): class DjangoModelLoadingTestCase(django_test.TestCase): """Tests class Meta: - model = 'app.Model' pattern.""" + model = 'app.Model' pattern.""" def test_loading(self): class ExampleFactory(factory.django.DjangoModelFactory): @@ -302,6 +302,7 @@ def test_inherited_loading(self): See https://github.com/FactoryBoy/factory_boy/issues/109. """ + class ExampleFactory(factory.django.DjangoModelFactory): class Meta: model = 'djapp.StandardModel' @@ -317,6 +318,7 @@ def test_inherited_loading_and_sequence(self): See https://github.com/FactoryBoy/factory_boy/issues/109. """ + class ExampleFactory(factory.django.DjangoModelFactory): class Meta: model = 'djapp.StandardModel' @@ -387,6 +389,7 @@ def test_auto_sequence_grandson(self): def test_optional_abstract(self): """Users need not describe the factory for an abstract model as abstract.""" + class AbstractBaseFactory(factory.django.DjangoModelFactory): class Meta: model = models.AbstractBase @@ -403,7 +406,6 @@ class Meta: class DjangoRelatedFieldTestCase(django_test.TestCase): - @classmethod def setUpClass(cls): super().setUpClass() @@ -411,11 +413,13 @@ def setUpClass(cls): class PointedFactory(factory.django.DjangoModelFactory): class Meta: model = models.PointedModel + foo = 'foo' class PointerFactory(factory.django.DjangoModelFactory): class Meta: model = models.PointerModel + bar = 'bar' pointed = factory.SubFactory(PointedFactory, foo='new_foo') @@ -500,9 +504,7 @@ def test_create_pointed_related_extra(self): self.assertEqual(pointed.pointer.bar, 'extra_new_bar') def test_create_pointed_related_with_trait(self): - pointed = self.PointedRelatedWithTraitFactory( - with_pointer=True - ) + pointed = self.PointedRelatedWithTraitFactory(with_pointer=True) self.assertEqual(pointed, models.PointedModel.objects.get()) self.assertEqual(pointed.foo, 'foo') self.assertEqual(pointed.pointer, models.PointerModel.objects.get()) @@ -525,7 +527,6 @@ def test_create(self): class DjangoFileFieldTestCase(django_test.TestCase): - def tearDown(self): super().tearDown() for path in os.listdir(models.WITHFILE_UPLOAD_DIR): @@ -582,7 +583,7 @@ def test_with_file_empty_path(self): with open(testdata.TESTFILE_PATH, 'rb') as f: o = WithFileFactory.build( afile__from_file=f, - afile__from_path='' + afile__from_path='', ) # Django only allocates the full path on save() o.save() @@ -648,7 +649,6 @@ def test_no_file(self): class DjangoParamsTestCase(django_test.TestCase): - def test_undeclared_fields(self): class WithDefaultValueFactory(factory.django.DjangoModelFactory): class Meta: @@ -675,6 +675,7 @@ class Params: class PointerFactory(factory.django.DjangoModelFactory): class Meta: model = models.PointerModel + pointed = factory.SubFactory(PointedFactory) class Params: @@ -693,6 +694,7 @@ def test_random(self): class StandardModelFactory(factory.django.DjangoModelFactory): class Meta: model = models.StandardModel + foo = factory.Faker('pystr') o1 = StandardModelFactory() @@ -702,7 +704,6 @@ class Meta: @unittest.skipIf(Image is None, "PIL not installed.") class DjangoImageFieldTestCase(django_test.TestCase): - def tearDown(self): super().tearDown() for path in os.listdir(models.WITHFILE_UPLOAD_DIR): @@ -764,7 +765,11 @@ def test_rgba_image(self): self.assertEqual('RGBA', i.mode) def test_gif(self): - o = WithImageFactory.build(animage__width=13, animage__color='blue', animage__format='GIF') + o = WithImageFactory.build( + animage__width=13, + animage__color='blue', + animage__format='GIF', + ) self.assertIsNone(o.pk) o.save() @@ -802,7 +807,7 @@ def test_with_file_empty_path(self): with open(testdata.TESTIMAGE_PATH, 'rb') as f: o = WithImageFactory.build( animage__from_file=f, - animage__from_path='' + animage__from_path='', ) o.save() @@ -911,7 +916,9 @@ def test_context_manager(self): def test_receiver_created_during_model_instantiation_is_not_lost(self): with factory.django.mute_signals(signals.post_save): - instance = WithSignalsFactory(post_save_signal_receiver=self.handlers.created_during_instantiation) + instance = WithSignalsFactory( + post_save_signal_receiver=self.handlers.created_during_instantiation + ) self.assertTrue(self.handlers.created_during_instantiation.called) self.handlers.created_during_instantiation.reset_mock() @@ -1012,7 +1019,6 @@ def generate(cls): class PreventChainedSignalsTestCase(django_test.TestCase): - def setUp(self): self.post_save_mock = mock.Mock(side_effect=Exception('BOOM!')) signals.post_save.connect(self.post_save_mock, models.PointedModel) @@ -1029,6 +1035,7 @@ def test_class_decorator_with_muted_subfactory(self): class UndecoratedFactory(factory.django.DjangoModelFactory): class Meta: model = models.PointerModel + pointed = factory.SubFactory(self.WithSignalsDecoratedFactory) UndecoratedFactory() @@ -1039,6 +1046,7 @@ class UndecoratedFactory(factory.django.DjangoModelFactory): class Meta: model = models.PointerModel skip_postgeneration_save = True + pointed = factory.RelatedFactory(self.WithSignalsDecoratedFactory) UndecoratedFactory() @@ -1046,7 +1054,6 @@ class Meta: class DjangoCustomManagerTestCase(django_test.TestCase): - def test_extra_args(self): # Our CustomManager will remove the 'arg=' argument. WithCustomManagerFactory(arg='foo') diff --git a/tests/test_docs_internals.py b/tests/test_docs_internals.py index cfc76377..04c5d748 100644 --- a/tests/test_docs_internals.py +++ b/tests/test_docs_internals.py @@ -91,7 +91,7 @@ class Params: full_name = factory.Faker('name') creation_date = factory.fuzzy.FuzzyDateTime( datetime.datetime(2000, 1, 1, tzinfo=datetime.timezone.utc), - datetime.datetime(2015, 12, 31, 20, tzinfo=datetime.timezone.utc) + datetime.datetime(2015, 12, 31, 20, tzinfo=datetime.timezone.utc), ) # Conditional flags @@ -100,8 +100,10 @@ class Params: 'enabled', None, factory.fuzzy.FuzzyDateTime( - datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) - datetime.timedelta(days=10), - datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) - datetime.timedelta(days=1), + datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) + - datetime.timedelta(days=10), + datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) + - datetime.timedelta(days=1), ), ) diff --git a/tests/test_faker.py b/tests/test_faker.py index 00355b77..1e94bfe4 100644 --- a/tests/test_faker.py +++ b/tests/test_faker.py @@ -62,12 +62,22 @@ def __init__(self, first_name, last_name, email): class ProfileFactory(factory.Factory): class Meta: model = Profile + first_name = factory.Faker('first_name') last_name = factory.Faker('last_name', locale='fr_FR') email = factory.Faker('email') - self._setup_mock_faker(first_name="John", last_name="Doe", email="john.doe@example.org") - self._setup_mock_faker(first_name="Jean", last_name="Valjean", email="jvaljean@exemple.fr", locale='fr_FR') + self._setup_mock_faker( + first_name="John", + last_name="Doe", + email="john.doe@example.org", + ) + self._setup_mock_faker( + first_name="Jean", + last_name="Valjean", + email="jvaljean@exemple.fr", + locale='fr_FR', + ) profile = ProfileFactory() self.assertEqual("John", profile.first_name) @@ -89,7 +99,11 @@ class Meta: self._setup_mock_faker(first_name="John", last_name="Doe") self._setup_mock_faker(first_name="Jean", last_name="Valjean", locale='fr_FR') - self._setup_mock_faker(first_name="Johannes", last_name="Brahms", locale='de_DE') + self._setup_mock_faker( + first_name="Johannes", + last_name="Brahms", + locale='de_DE', + ) profile = ProfileFactory() self.assertEqual("John", profile.first_name) diff --git a/tests/test_fuzzy.py b/tests/test_fuzzy.py index 67cf7030..131132d2 100644 --- a/tests/test_fuzzy.py +++ b/tests/test_fuzzy.py @@ -179,7 +179,10 @@ def test_precision(self): with mock.patch('factory.random.randgen.uniform', fake_uniform): res = utils.evaluate_declaration(fuzz) - self.assertEqual(decimal.Decimal('8.001').quantize(decimal.Decimal(10) ** -3), res) + self.assertEqual( + decimal.Decimal('8.001').quantize(decimal.Decimal(10) ** -3), + res, + ) def test_no_approximation(self): """We should not go through floats in our fuzzy calls unless actually needed.""" @@ -200,17 +203,26 @@ def test_definition(self): fuzz = fuzzy.FuzzyFloat(2.0, 3.0) for _i in range(20): res = utils.evaluate_declaration(fuzz) - self.assertTrue(2.0 <= res <= 3.0, "value %d is not between 2.0 and 3.0" % res) + self.assertTrue( + 2.0 <= res <= 3.0, + "value %d is not between 2.0 and 3.0" % res, + ) fuzz = fuzzy.FuzzyFloat(4.0) for _i in range(20): res = utils.evaluate_declaration(fuzz) - self.assertTrue(0.0 <= res <= 4.0, "value %d is not between 0.0 and 4.0" % res) + self.assertTrue( + 0.0 <= res <= 4.0, + "value %d is not between 0.0 and 4.0" % res, + ) fuzz = fuzzy.FuzzyDecimal(1.0, 4.0, precision=5) for _i in range(20): res = utils.evaluate_declaration(fuzz) - self.assertTrue(1.0 <= res <= 4.0, "value %d is not between 1.0 and 4.0" % res) + self.assertTrue( + 1.0 <= res <= 4.0, + "value %d is not between 1.0 and 4.0" % res, + ) self.assertTrue(res.as_tuple().exponent, -5) def test_biased(self): @@ -343,12 +355,18 @@ def test_partial_definition(self): def test_aware_start(self): """Tests that a timezone-aware start datetime is rejected.""" with self.assertRaises(ValueError): - fuzzy.FuzzyNaiveDateTime(self.jan1.replace(tzinfo=datetime.timezone.utc), self.jan31) + fuzzy.FuzzyNaiveDateTime( + self.jan1.replace(tzinfo=datetime.timezone.utc), + self.jan31, + ) def test_aware_end(self): """Tests that a timezone-aware end datetime is rejected.""" with self.assertRaises(ValueError): - fuzzy.FuzzyNaiveDateTime(self.jan1, self.jan31.replace(tzinfo=datetime.timezone.utc)) + fuzzy.FuzzyNaiveDateTime( + self.jan1, + self.jan31.replace(tzinfo=datetime.timezone.utc), + ) def test_force_year(self): fuzz = fuzzy.FuzzyNaiveDateTime(self.jan1, self.jan31, force_year=4) @@ -535,7 +553,10 @@ def test_biased(self): with mock.patch('factory.random.randgen.randint', fake_randint): res = utils.evaluate_declaration(fuzz) - self.assertEqual(datetime.datetime(2013, 1, 16, tzinfo=datetime.timezone.utc), res) + self.assertEqual( + datetime.datetime(2013, 1, 16, tzinfo=datetime.timezone.utc), + res, + ) def test_biased_partial(self): """Tests a FuzzyDate with a biased random and implicit upper bound.""" @@ -546,11 +567,13 @@ def test_biased_partial(self): with mock.patch('factory.random.randgen.randint', fake_randint): res = utils.evaluate_declaration(fuzz) - self.assertEqual(datetime.datetime(2013, 1, 2, tzinfo=datetime.timezone.utc), res) + self.assertEqual( + datetime.datetime(2013, 1, 2, tzinfo=datetime.timezone.utc), + res, + ) class FuzzyTextTestCase(unittest.TestCase): - def test_unbiased(self): chars = ['a', 'b', 'c'] fuzz = fuzzy.FuzzyText(prefix='pre', suffix='post', chars=chars, length=12) @@ -602,7 +625,11 @@ def test_seeding(self): def test_seeding_warning(self): with warnings.catch_warnings(record=True) as w: # Do not turn expected warning into an error. - warnings.filterwarnings("default", category=UserWarning, module=r"tests\.test_fuzzy") + warnings.filterwarnings( + "default", + category=UserWarning, + module=r"tests\.test_fuzzy", + ) fuzz = fuzzy.FuzzyDate(datetime.date(2013, 1, 1)) utils.evaluate_declaration(fuzz) self.assertEqual(1, len(w)) diff --git a/tests/test_mongoengine.py b/tests/test_mongoengine.py index bc1915b0..591cd113 100644 --- a/tests/test_mongoengine.py +++ b/tests/test_mongoengine.py @@ -49,6 +49,7 @@ class MongoEngineTestCase(unittest.TestCase): @classmethod def setUpClass(cls): from pymongo import read_preferences as mongo_rp + cls.db = mongoengine.connect( db=cls.db_name, host=cls.db_host, diff --git a/tests/test_regression.py b/tests/test_regression.py index a9ea1c66..40b48db1 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -35,6 +35,7 @@ def test_locale_issue(self): See #785 #786 #787 #788 #790 #796. """ + class AuthorFactory(factory.Factory): class Meta: model = Author diff --git a/tests/test_using.py b/tests/test_using.py index 07dfbb47..4d277db2 100644 --- a/tests/test_using.py +++ b/tests/test_using.py @@ -46,7 +46,7 @@ def as_dict(self): def __repr__(self): return '%s(%s)' % ( self.__class__.__name__, - ', '.join('%s=%r' % pair for pair in sorted(self.as_dict.items())) + ', '.join('%s=%r' % pair for pair in sorted(self.as_dict.items())), ) @@ -113,7 +113,11 @@ def test_build(self): self.assertEqual(obj.four, None) def test_complex(self): - obj = factory.build(TestObject, two=2, three=factory.LazyAttribute(lambda o: o.two + 1)) + obj = factory.build( + TestObject, + two=2, + three=factory.LazyAttribute(lambda o: o.two + 1), + ) self.assertEqual(obj.one, None) self.assertEqual(obj.two, 2) self.assertEqual(obj.three, 3) @@ -142,7 +146,11 @@ def test_create(self): self.assertEqual(obj.foo, 'bar') def test_create_custom_base(self): - obj = factory.create(FakeModel, foo='bar', FACTORY_CLASS=factory.django.DjangoModelFactory) + obj = factory.create( + FakeModel, + foo='bar', + FACTORY_CLASS=factory.django.DjangoModelFactory, + ) self.assertEqual(obj.id, 2) self.assertEqual(obj.foo, 'bar') @@ -268,7 +276,12 @@ def test_simple_generate_create(self): self.assertEqual(obj.foo, 'bar') def test_simple_generate_create_custom_base(self): - obj = factory.simple_generate(FakeModel, True, foo='bar', FACTORY_CLASS=factory.django.DjangoModelFactory) + obj = factory.simple_generate( + FakeModel, + True, + foo='bar', + FACTORY_CLASS=factory.django.DjangoModelFactory, + ) self.assertEqual(obj.id, 2) self.assertEqual(obj.foo, 'bar') @@ -309,7 +322,11 @@ def test_simple_generate_batch_create_custom_base(self): self.assertEqual(obj.foo, 'bar') def test_make_factory(self): - fact = factory.make_factory(TestObject, two=2, three=factory.LazyAttribute(lambda o: o.two + 1)) + fact = factory.make_factory( + TestObject, + two=2, + three=factory.LazyAttribute(lambda o: o.two + 1), + ) obj = fact.build() self.assertEqual(obj.one, None) @@ -543,12 +560,14 @@ class TestModel2(FakeModel): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel + one = 3 three = factory.SelfAttribute('..bar') class TestModel2Factory(FakeModelFactory): class Meta: model = TestModel2 + bar = 4 two = factory.SubFactory(TestModelFactory, one=1) @@ -817,6 +836,7 @@ class Meta: def test_override_inherited(self): """Overriding inherited declarations""" + class TestObjectFactory(factory.Factory): class Meta: model = TestObject @@ -831,6 +851,7 @@ class TestObjectFactory2(TestObjectFactory): def test_override_inherited_deep(self): """Overriding inherited declarations""" + class TestObjectFactory(factory.Factory): class Meta: model = TestObject @@ -848,6 +869,7 @@ class TestObjectFactory3(TestObjectFactory2): def test_inheritance_and_sequences(self): """Sequence counters should be kept within an inheritance chain.""" + class TestObjectFactory(factory.Factory): class Meta: model = TestObject @@ -869,6 +891,7 @@ class Meta: def test_inheritance_sequence_inheriting_objects(self): """Sequence counters are kept with inheritance, incl. misc objects.""" + class TestObject2(TestObject): pass @@ -951,6 +974,7 @@ class Meta: class TestOtherFactory(factory.Factory): class Meta: model = TestObject + two = 'two' four = 'four' @@ -1057,7 +1081,7 @@ def __init__(self, *args, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - inline_args = ('one', 'two',) + inline_args = ('one', 'two') one = 1 two = 2 @@ -1181,7 +1205,11 @@ class Meta: b = 1 # biggest = 'b' if .b > .a else 'a' - biggest = factory.Maybe(factory.LazyAttribute(lambda o: o.a < o.b), 'b', 'a') + biggest = factory.Maybe( + factory.LazyAttribute(lambda o: o.a < o.b), + 'b', + 'a', + ) # max_value = .b if .b > .a else .a = max(.a, .b) max_value = factory.Maybe( factory.LazyAttribute(lambda o: o.a < o.b), @@ -1193,9 +1221,18 @@ class Meta: obj_equal = DummyFactory.build(a=3, b=3) obj_reverse = DummyFactory.build(a=5, b=4) - self.assertEqual(dict(a=1, b=2, biggest='b', max_value=2, ), obj_ordered.as_dict) - self.assertEqual(dict(a=3, b=3, biggest='a', max_value=3, ), obj_equal.as_dict) - self.assertEqual(dict(a=5, b=4, biggest='a', max_value=5, ), obj_reverse.as_dict) + self.assertEqual( + dict(a=1, b=2, biggest='b', max_value=2), + obj_ordered.as_dict, + ) + self.assertEqual( + dict(a=3, b=3, biggest='a', max_value=3), + obj_equal.as_dict, + ) + self.assertEqual( + dict(a=5, b=4, biggest='a', max_value=5), + obj_reverse.as_dict, + ) def test_post_generation(self): @@ -1303,6 +1340,7 @@ class Params: def test_traits_inheritance(self): """A trait can be set in an inherited class.""" + class TestObjectFactory(factory.Factory): class Meta: model = TestObject @@ -1330,6 +1368,7 @@ class EvenObjectFactory(TestObjectFactory): def test_traits_override_params(self): """Override a Params value in a trait""" + class TestObjectFactory(factory.Factory): class Meta: model = TestObject @@ -1345,6 +1384,7 @@ class Params: def test_traits_override(self): """Override a trait in a subclass.""" + class TestObjectFactory(factory.Factory): class Meta: model = TestObject @@ -1366,6 +1406,7 @@ class Params: def test_traits_chaining(self): """Use a trait to enable other traits.""" + class TestObjectFactory(factory.Factory): class Meta: model = TestObject @@ -1412,6 +1453,7 @@ class Params: def test_prevent_cyclic_traits(self): with self.assertRaises(errors.CyclicDefinitionError): + class TestObjectFactory(factory.Factory): class Meta: model = TestObject @@ -1480,11 +1522,13 @@ class TestModel2(FakeModel): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel + one = 3 class TestModel2Factory(FakeModelFactory): class Meta: model = TestModel2 + two = factory.SubFactory(TestModelFactory, one=1) test_model = TestModel2Factory(two__one=4) @@ -1503,6 +1547,7 @@ class Meta: class TestModel2Factory(FakeModelFactory): class Meta: model = TestModel2 + two = factory.SubFactory( TestModelFactory, one=factory.Sequence(lambda n: 'x%dx' % n), @@ -1520,11 +1565,13 @@ class TestModel2(FakeModel): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel + one = 3 class TestModel2Factory(FakeModelFactory): class Meta: model = TestModel2 + one = 'parent' child = factory.SubFactory( TestModelFactory, @@ -1593,18 +1640,21 @@ def test_sub_factory_deep_overrides(self): class AuthorFactory(factory.Factory): class Meta: model = Author + name = "John" country = 'XX' class BookFactory(factory.Factory): class Meta: model = Book + title = "The mighty adventures of nobody." author = factory.SubFactory(AuthorFactory) class ChapterFactory(factory.Factory): class Meta: model = Chapter + book = factory.SubFactory(BookFactory) number = factory.Sequence(lambda n: n) book__author__country = factory.LazyAttribute(lambda o: 'FR') @@ -1652,6 +1702,7 @@ def __init__(self, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + two = 'two' class WrappingTestObjectFactory(factory.Factory): @@ -1687,6 +1738,7 @@ def __init__(self, two='one', wrapped=None): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + two = 'two' # Intermediary factory @@ -1714,17 +1766,20 @@ def __init__(self, label, child=None): class LeafFactory(factory.Factory): class Meta: model = Node + label = 'leaf' class BranchFactory(factory.Factory): class Meta: model = Node + label = 'branch' child = factory.SubFactory(LeafFactory) class TreeFactory(factory.Factory): class Meta: model = Node + label = 'tree' child = factory.SubFactory(BranchFactory) child__child__label = 'magic-leaf' @@ -1752,6 +1807,7 @@ class Meta: def test_sub_factory_and_inheritance(self): """Test inheriting from a factory with subfactories, overriding.""" + class TestObject: def __init__(self, **kwargs): for k, v in kwargs.items(): @@ -1760,6 +1816,7 @@ def __init__(self, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + two = 'two' class WrappingTestObjectFactory(factory.Factory): @@ -1778,6 +1835,7 @@ class ExtendedWrappingTestObjectFactory(WrappingTestObjectFactory): def test_diamond_sub_factory(self): """Tests the case where an object has two fields with a common field.""" + class InnerMost: def __init__(self, a, b): self.a = a @@ -1800,17 +1858,20 @@ def __init__(self, foo, side_a, side_b): class InnerMostFactory(factory.Factory): class Meta: model = InnerMost + a = 15 b = 20 class SideAFactory(factory.Factory): class Meta: model = SideA + inner_from_a = factory.SubFactory(InnerMostFactory, a=20) class SideBFactory(factory.Factory): class Meta: model = SideB + inner_from_b = factory.SubFactory(InnerMostFactory, b=15) class OuterMostFactory(factory.Factory): @@ -1822,13 +1883,13 @@ class Meta: SideAFactory, inner_from_a__a=factory.ContainerAttribute( lambda obj, containers: containers[1].foo * 2, - ) + ), ) side_b = factory.SubFactory( SideBFactory, inner_from_b=factory.ContainerAttribute( lambda obj, containers: containers[0].side_a.inner_from_a, - ) + ), ) outer = OuterMostFactory.build() @@ -1850,12 +1911,17 @@ class TestModel2(FakeModel): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel + one = 3 - two = factory.ContainerAttribute(lambda obj, containers: len(containers or []), strict=False) + two = factory.ContainerAttribute( + lambda obj, containers: len(containers or []), + strict=False, + ) class TestModel2Factory(FakeModelFactory): class Meta: model = TestModel2 + one = 1 two = factory.SubFactory(TestModelFactory, one=1) @@ -1875,12 +1941,17 @@ class TestModel2(FakeModel): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel + sample_int = 3 - container_len = factory.ContainerAttribute(lambda obj, containers: len(containers or []), strict=True) + container_len = factory.ContainerAttribute( + lambda obj, containers: len(containers or []), + strict=True, + ) class TestModel2Factory(FakeModelFactory): class Meta: model = TestModel2 + sample_int = 1 descendant = factory.SubFactory(TestModelFactory, sample_int=1) @@ -1899,6 +1970,7 @@ class TestModel2(FakeModel): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel + sample_int = 3 @factory.container_attribute @@ -1910,6 +1982,7 @@ def container_len(self, containers): class TestModel2Factory(FakeModelFactory): class Meta: model = TestModel2 + sample_int = 1 descendant = factory.SubFactory(TestModelFactory, sample_int=1) @@ -1924,7 +1997,6 @@ class Meta: class IteratorTestCase(unittest.TestCase): - def test_iterator(self): class TestObjectFactory(factory.Factory): class Meta: @@ -1972,6 +2044,7 @@ def test_iterator_late_loading(self): This allows, for Django objects, to call: foo = factory.Iterator(models.MyThingy.objects.all()) """ + class DBRequest: def __init__(self): self.ready = False @@ -2067,6 +2140,7 @@ class MyFakeModelFactory(factory.django.DjangoModelFactory): class Meta: model = MyFakeModel django_get_or_create = ('x',) + x = 1 y = 4 z = 6 @@ -2089,6 +2163,7 @@ class MyFakeModelFactory(factory.django.DjangoModelFactory): class Meta: model = MyFakeModel django_get_or_create = ('x', 'y', 'z') + x = 1 y = 4 z = 6 @@ -2111,6 +2186,7 @@ class MyFakeModelFactory(factory.django.DjangoModelFactory): class Meta: model = MyFakeModel django_get_or_create = ('x',) + x = 1 y = 4 z = 6 @@ -2133,6 +2209,7 @@ class MyFakeModelFactory(factory.django.DjangoModelFactory): class Meta: model = MyFakeModel django_get_or_create = ('x', 'y', 'z') + x = 1 y = 4 z = 6 @@ -2196,6 +2273,7 @@ class Meta: def test_full_get_or_create(self): """Test a DjangoModelFactory with all fields in get_or_create.""" + class TestModelFactory(factory.django.DjangoModelFactory): class Meta: model = TestModel @@ -2277,7 +2355,6 @@ def incr_one(self, _create, increment=1): self.assertFalse(hasattr(obj, 'incr_one')) def test_post_generation_extraction_lambda(self): - def my_lambda(obj, create, extracted, **kwargs): self.assertTrue(isinstance(obj, TestObject)) self.assertFalse(create) @@ -2336,6 +2413,7 @@ def call(self, *args, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = 3 two = 2 post_call = factory.PostGenerationMethodCall('call', one=1) @@ -2382,12 +2460,14 @@ def __init__(self, obj=None, one=None, two=None): class TestRelatedObjectFactory(factory.Factory): class Meta: model = TestRelatedObject + one = 1 two = factory.LazyAttribute(lambda o: o.one + 1) class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = 3 two = 2 three = factory.RelatedFactory( @@ -2433,12 +2513,14 @@ def __init__(self, obj=None, one=None, two=None): class TestRelatedObjectFactory(factory.Factory): class Meta: model = TestRelatedObject + one = 1 two = factory.LazyAttribute(lambda o: o.one + 1) class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = 3 two = 2 three = factory.RelatedFactory(TestRelatedObjectFactory) @@ -2478,12 +2560,14 @@ def __init__(self, obj=None, one=None, two=None): class TestRelatedObjectFactory(factory.Factory): class Meta: model = TestRelatedObject + one = 1 two = factory.LazyAttribute(lambda o: o.one + 1) class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = 3 two = 2 three = factory.RelatedFactory( @@ -2509,6 +2593,7 @@ def __init__(self, obj=None, one=None, two=None): class TestRelatedObjectFactory(factory.Factory): class Meta: model = TestRelatedObject + one = 1 two = factory.LazyAttribute(lambda o: o.one + 1) @@ -2557,20 +2642,25 @@ def __init__(self, obj=None, one=None, two=None): class TestRelatedObjectFactoryList(factory.Factory): class Meta: model = TestRelatedObject + one = 1 two = factory.LazyAttribute(lambda o: o.one + 1) class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = 3 two = 2 # RELATED_LIST_SIZE is a lambda, this allows flexibility, as opposed # to creating "n" related objects for every parent object... - three = factory.RelatedFactoryList(TestRelatedObjectFactoryList, - 'obj', - size=RELATED_LIST_SIZE) + three = factory.RelatedFactoryList( + TestRelatedObjectFactoryList, + 'obj', + size=RELATED_LIST_SIZE, + ) # Create 5 TestObjectFactories: Each with 1, 2, ... 5 related objs + for related_list_size in reversed(related_list_sizes[1::2]): obj = TestObjectFactory.build() # Normal fields @@ -2623,16 +2713,21 @@ def __init__(self, obj=None, one=None, two=None): class TestRelatedObjectFactoryList(factory.Factory): class Meta: model = TestRelatedObject + one = 1 two = factory.LazyAttribute(lambda o: o.one + 1) class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = 3 two = 2 - three = factory.RelatedFactoryList(TestRelatedObjectFactoryList, 'obj', - size=RELATED_LIST_SIZE) + three = factory.RelatedFactoryList( + TestRelatedObjectFactoryList, + 'obj', + size=RELATED_LIST_SIZE, + ) obj = TestObjectFactory.build() # Normal fields @@ -2685,6 +2780,7 @@ class Meta: class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.RelatedFactory( TestRelatedObjectFactory, factory_related_name='obj', @@ -2717,12 +2813,14 @@ def test_example(self): sys.path.insert(0, os.path.abspath(os.path.dirname(__file__))) from .cyclic import foo + f = foo.FooFactory.build(bar__foo=None) self.assertEqual(42, f.x) self.assertEqual(13, f.bar.y) self.assertIsNone(f.bar.foo) from .cyclic import bar + b = bar.BarFactory.build(foo__bar__foo__bar=None) self.assertEqual(13, b.y) self.assertEqual(42, b.foo.x) @@ -2777,6 +2875,7 @@ def test_empty_dict(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.Dict({}) o = TestObjectFactory() @@ -2786,6 +2885,7 @@ def test_naive_dict(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.Dict({'a': 1}) o = TestObjectFactory() @@ -2795,6 +2895,7 @@ def test_sequence_dict(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.Dict({'a': factory.Sequence(lambda n: n + 2)}) o1 = TestObjectFactory() @@ -2807,6 +2908,7 @@ def test_dict_override(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.Dict({'a': 1}) o = TestObjectFactory(one__a=2) @@ -2816,6 +2918,7 @@ def test_dict_extra_key(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.Dict({'a': 1}) o = TestObjectFactory(one__b=2) @@ -2825,12 +2928,15 @@ def test_dict_merged_fields(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + two = 13 - one = factory.Dict({ - 'one': 1, - 'two': 2, - 'three': factory.SelfAttribute('two'), - }) + one = factory.Dict( + { + 'one': 1, + 'two': 2, + 'three': factory.SelfAttribute('two'), + } + ) o = TestObjectFactory(one__one=42) self.assertEqual({'one': 42, 'two': 2, 'three': 2}, o.one) @@ -2839,28 +2945,36 @@ def test_nested_dicts(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = 1 - two = factory.Dict({ - 'one': 3, - 'two': factory.SelfAttribute('one'), - 'three': factory.Dict({ - 'one': 5, - 'two': factory.SelfAttribute('..one'), - 'three': factory.SelfAttribute('...one'), - }), - }) + two = factory.Dict( + { + 'one': 3, + 'two': factory.SelfAttribute('one'), + 'three': factory.Dict( + { + 'one': 5, + 'two': factory.SelfAttribute('..one'), + 'three': factory.SelfAttribute('...one'), + } + ), + } + ) o = TestObjectFactory() self.assertEqual(1, o.one) - self.assertEqual({ - 'one': 3, - 'two': 3, - 'three': { - 'one': 5, + self.assertEqual( + { + 'one': 3, 'two': 3, - 'three': 1, + 'three': { + 'one': 5, + 'two': 3, + 'three': 1, + }, }, - }, o.two) + o.two, + ) class ListTestCase(unittest.TestCase): @@ -2868,6 +2982,7 @@ def test_empty_list(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.List([]) o = TestObjectFactory() @@ -2877,6 +2992,7 @@ def test_naive_list(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.List([1]) o = TestObjectFactory() @@ -2886,6 +3002,7 @@ def test_long_list(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.List(list(range(100))) o = TestObjectFactory() @@ -2895,6 +3012,7 @@ def test_sequence_list(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.List([factory.Sequence(lambda n: n + 2)]) o1 = TestObjectFactory() @@ -2907,6 +3025,7 @@ def test_list_override(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.List([1]) o = TestObjectFactory(one__0=2) @@ -2916,6 +3035,7 @@ def test_list_extra_key(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + one = factory.List([1]) o = TestObjectFactory(one__1=2) @@ -2925,12 +3045,9 @@ def test_list_merged_fields(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject + two = 13 - one = factory.List([ - 1, - 2, - factory.SelfAttribute('1'), - ]) + one = factory.List([1, 2, factory.SelfAttribute('1')]) o = TestObjectFactory(one__0=42) self.assertEqual([42, 2, 2], o.one) @@ -2941,24 +3058,23 @@ class Meta: model = TestObject one = 1 - two = factory.List([ - 3, - factory.SelfAttribute('0'), - factory.List([ - 5, - factory.SelfAttribute('..0'), - factory.SelfAttribute('...one'), - ]), - ]) + two = factory.List( + [ + 3, + factory.SelfAttribute('0'), + factory.List( + [ + 5, + factory.SelfAttribute('..0'), + factory.SelfAttribute('...one'), + ] + ), + ] + ) o = TestObjectFactory() self.assertEqual(1, o.one) - self.assertEqual([ - 3, - 3, - [ - 5, - 3, - 1, - ], - ], o.two) + self.assertEqual( + [3, 3, [5, 3, 1]], + o.two, + ) diff --git a/tests/test_utils.py b/tests/test_utils.py index 1d54eefe..80e9c32c 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -11,6 +11,7 @@ class ImportObjectTestCase(unittest.TestCase): def test_datetime(self): imported = utils.import_object('datetime', 'date') import datetime + d = datetime.date self.assertEqual(d, imported) diff --git a/tests/utils.py b/tests/utils.py index 8c62a018..cf63ad21 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -14,6 +14,7 @@ def decorated(*args, **kwargs): with warnings.catch_warnings(): warnings.simplefilter('ignore') return fun(*args, **kwargs) + return decorated From 1c9fe87cb2e2138245f036ebd557ca0f3c7bf15d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Freitag?= Date: Fri, 2 Jul 2021 17:39:32 +0200 Subject: [PATCH 3/4] Apply Black string normalization Black unifies strings to "". --- docs/conf.py | 52 +- examples/django_demo/django_demo/settings.py | 72 +- examples/django_demo/django_demo/urls.py | 2 +- .../django_demo/generic_foreignkey/apps.py | 2 +- .../generic_foreignkey/factories.py | 8 +- .../migrations/0001_initial.py | 16 +- .../django_demo/generic_foreignkey/models.py | 2 +- .../django_demo/generic_foreignkey/tests.py | 12 +- examples/flask_alchemy/demoapp.py | 10 +- examples/flask_alchemy/test_demoapp.py | 4 +- factory/__init__.py | 2 +- factory/alchemy.py | 10 +- factory/base.py | 44 +- factory/builder.py | 14 +- factory/declarations.py | 50 +- factory/django.py | 72 +- factory/enums.py | 14 +- factory/faker.py | 4 +- factory/fuzzy.py | 6 +- factory/helpers.py | 12 +- factory/utils.py | 8 +- tests/alchemyapp/models.py | 12 +- tests/alter_time.py | 4 +- tests/cyclic/bar.py | 2 +- tests/cyclic/self_ref.py | 2 +- tests/djapp/models.py | 6 +- tests/djapp/settings.py | 14 +- tests/test_alchemy.py | 74 +- tests/test_base.py | 60 +- tests/test_declarations.py | 100 +-- tests/test_dev_experience.py | 16 +- tests/test_django.py | 274 ++++---- tests/test_docs_internals.py | 20 +- tests/test_faker.py | 42 +- tests/test_fuzzy.py | 74 +- tests/test_helpers.py | 18 +- tests/test_mongoengine.py | 22 +- tests/test_using.py | 636 +++++++++--------- tests/test_utils.py | 22 +- tests/testdata/__init__.py | 4 +- tests/utils.py | 12 +- 41 files changed, 915 insertions(+), 915 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 3d579b4a..53e363ce 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -14,19 +14,19 @@ # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. -sys.path.insert(0, os.path.dirname(os.path.abspath('.'))) +sys.path.insert(0, os.path.dirname(os.path.abspath("."))) # -- Project information ----------------------------------------------------- -project = 'Factory Boy' -copyright = '2011-2015, Raphaël Barrois, Mark Sandstrom' -author = 'adfasf' +project = "Factory Boy" +copyright = "2011-2015, Raphaël Barrois, Mark Sandstrom" +author = "adfasf" # The full version, including alpha/beta/rc tags release = factory.__version__ # The short X.Y version. -version = '.'.join(release.split('.')[:2]) +version = ".".join(release.split(".")[:2]) # -- General configuration --------------------------------------------------- @@ -34,44 +34,44 @@ # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ - 'sphinx.ext.autodoc', - 'sphinx.ext.extlinks', - 'sphinx.ext.intersphinx', - 'sphinx.ext.viewcode', + "sphinx.ext.autodoc", + "sphinx.ext.extlinks", + "sphinx.ext.intersphinx", + "sphinx.ext.viewcode", ] extlinks = { - 'issue': ('https://github.com/FactoryBoy/factory_boy/issues/%s', 'issue #'), - 'pr': ('https://github.com/FactoryBoy/factory_boy/pull/%s', 'pull request #'), + "issue": ("https://github.com/FactoryBoy/factory_boy/issues/%s", "issue #"), + "pr": ("https://github.com/FactoryBoy/factory_boy/pull/%s", "pull request #"), } # Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] +templates_path = ["_templates"] # The master toctree document. -master_doc = 'index' +master_doc = "index" # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. -exclude_patterns = ['_build'] +exclude_patterns = ["_build"] # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. -html_theme = 'sphinx_rtd_theme' +html_theme = "sphinx_rtd_theme" -if 'READTHEDOCS_VERSION' in os.environ: +if "READTHEDOCS_VERSION" in os.environ: # Use the readthedocs version string in preference to our known version. html_title = "{} {} documentation".format( - project, os.environ['READTHEDOCS_VERSION'] + project, os.environ["READTHEDOCS_VERSION"] ) # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] +html_static_path = ["_static"] # -- linkcheck --------------------------------------------------------------- @@ -80,19 +80,19 @@ # -- intersphinx ------------------------------------------------------------- intersphinx_mapping = { - 'https://docs.python.org/': None, - 'django': ( - 'https://docs.djangoproject.com/en/dev/', - 'https://docs.djangoproject.com/en/dev/_objects/', + "https://docs.python.org/": None, + "django": ( + "https://docs.djangoproject.com/en/dev/", + "https://docs.djangoproject.com/en/dev/_objects/", ), - 'sqlalchemy': ( - 'https://docs.sqlalchemy.org/en/latest/', - 'https://docs.sqlalchemy.org/en/latest/objects.inv', + "sqlalchemy": ( + "https://docs.sqlalchemy.org/en/latest/", + "https://docs.sqlalchemy.org/en/latest/objects.inv", ), } # -- spelling --------------------------------------------------------------- spelling_exclude_patterns = [ - 'credits.rst', + "credits.rst", ] diff --git a/examples/django_demo/django_demo/settings.py b/examples/django_demo/django_demo/settings.py index 70248530..15b22cfa 100644 --- a/examples/django_demo/django_demo/settings.py +++ b/examples/django_demo/django_demo/settings.py @@ -20,7 +20,7 @@ # See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! -SECRET_KEY = 'kh)1s3@93ju6f6$qx!758f6h^(_3d0brqzoxubo@xsn3*%2wgu' +SECRET_KEY = "kh)1s3@93ju6f6$qx!758f6h^(_3d0brqzoxubo@xsn3*%2wgu" # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True @@ -31,53 +31,53 @@ # Application definition INSTALLED_APPS = [ - 'django.contrib.admin', - 'django.contrib.auth', - 'django.contrib.contenttypes', - 'django.contrib.sessions', - 'django.contrib.messages', - 'django.contrib.staticfiles', - 'generic_foreignkey', + "django.contrib.admin", + "django.contrib.auth", + "django.contrib.contenttypes", + "django.contrib.sessions", + "django.contrib.messages", + "django.contrib.staticfiles", + "generic_foreignkey", ] MIDDLEWARE = [ - 'django.middleware.security.SecurityMiddleware', - 'django.contrib.sessions.middleware.SessionMiddleware', - 'django.middleware.common.CommonMiddleware', - 'django.middleware.csrf.CsrfViewMiddleware', - 'django.contrib.auth.middleware.AuthenticationMiddleware', - 'django.contrib.messages.middleware.MessageMiddleware', - 'django.middleware.clickjacking.XFrameOptionsMiddleware', + "django.middleware.security.SecurityMiddleware", + "django.contrib.sessions.middleware.SessionMiddleware", + "django.middleware.common.CommonMiddleware", + "django.middleware.csrf.CsrfViewMiddleware", + "django.contrib.auth.middleware.AuthenticationMiddleware", + "django.contrib.messages.middleware.MessageMiddleware", + "django.middleware.clickjacking.XFrameOptionsMiddleware", ] -ROOT_URLCONF = 'django_demo.urls' +ROOT_URLCONF = "django_demo.urls" TEMPLATES = [ { - 'BACKEND': 'django.template.backends.django.DjangoTemplates', - 'DIRS': [], - 'APP_DIRS': True, - 'OPTIONS': { - 'context_processors': [ - 'django.template.context_processors.debug', - 'django.template.context_processors.request', - 'django.contrib.auth.context_processors.auth', - 'django.contrib.messages.context_processors.messages', + "BACKEND": "django.template.backends.django.DjangoTemplates", + "DIRS": [], + "APP_DIRS": True, + "OPTIONS": { + "context_processors": [ + "django.template.context_processors.debug", + "django.template.context_processors.request", + "django.contrib.auth.context_processors.auth", + "django.contrib.messages.context_processors.messages", ], }, }, ] -WSGI_APPLICATION = 'django_demo.wsgi.application' +WSGI_APPLICATION = "django_demo.wsgi.application" # Database # https://docs.djangoproject.com/en/1.10/ref/settings/#databases DATABASES = { - 'default': { - 'ENGINE': 'django.db.backends.sqlite3', - 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), + "default": { + "ENGINE": "django.db.backends.sqlite3", + "NAME": os.path.join(BASE_DIR, "db.sqlite3"), } } @@ -87,16 +87,16 @@ AUTH_PASSWORD_VALIDATORS = [ { - 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', + "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator", }, { - 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', + "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator", }, { - 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', + "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator", }, { - 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', + "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator", }, ] @@ -104,9 +104,9 @@ # Internationalization # https://docs.djangoproject.com/en/1.10/topics/i18n/ -LANGUAGE_CODE = 'en-us' +LANGUAGE_CODE = "en-us" -TIME_ZONE = 'UTC' +TIME_ZONE = "UTC" USE_I18N = True @@ -118,4 +118,4 @@ # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/1.10/howto/static-files/ -STATIC_URL = '/static/' +STATIC_URL = "/static/" diff --git a/examples/django_demo/django_demo/urls.py b/examples/django_demo/django_demo/urls.py index 2bf9b41a..41333627 100644 --- a/examples/django_demo/django_demo/urls.py +++ b/examples/django_demo/django_demo/urls.py @@ -17,5 +17,5 @@ from django.contrib import admin urlpatterns = [ - url(r'^admin/', admin.site.urls), + url(r"^admin/", admin.site.urls), ] diff --git a/examples/django_demo/generic_foreignkey/apps.py b/examples/django_demo/generic_foreignkey/apps.py index 4ca07241..fa7abfeb 100644 --- a/examples/django_demo/generic_foreignkey/apps.py +++ b/examples/django_demo/generic_foreignkey/apps.py @@ -2,4 +2,4 @@ class GenericForeignKeyConfig(AppConfig): - name = 'generic_foreignkey' + name = "generic_foreignkey" diff --git a/examples/django_demo/generic_foreignkey/factories.py b/examples/django_demo/generic_foreignkey/factories.py index 273d49a5..460019c3 100644 --- a/examples/django_demo/generic_foreignkey/factories.py +++ b/examples/django_demo/generic_foreignkey/factories.py @@ -7,27 +7,27 @@ class UserFactory(factory.django.DjangoModelFactory): - first_name = 'Adam' + first_name = "Adam" class Meta: model = User class GroupFactory(factory.django.DjangoModelFactory): - name = 'group' + name = "group" class Meta: model = Group class TaggedItemFactory(factory.django.DjangoModelFactory): - object_id = factory.SelfAttribute('content_object.id') + object_id = factory.SelfAttribute("content_object.id") content_type = factory.LazyAttribute( lambda o: ContentType.objects.get_for_model(o.content_object) ) class Meta: - exclude = ['content_object'] + exclude = ["content_object"] abstract = True diff --git a/examples/django_demo/generic_foreignkey/migrations/0001_initial.py b/examples/django_demo/generic_foreignkey/migrations/0001_initial.py index f3a02892..3d966b8f 100644 --- a/examples/django_demo/generic_foreignkey/migrations/0001_initial.py +++ b/examples/django_demo/generic_foreignkey/migrations/0001_initial.py @@ -7,29 +7,29 @@ class Migration(migrations.Migration): initial = True dependencies = [ - ('contenttypes', '0002_remove_content_type_name'), + ("contenttypes", "0002_remove_content_type_name"), ] operations = [ migrations.CreateModel( - name='TaggedItem', + name="TaggedItem", fields=[ ( - 'id', + "id", models.AutoField( auto_created=True, primary_key=True, serialize=False, - verbose_name='ID', + verbose_name="ID", ), ), - ('tag', models.SlugField()), - ('object_id', models.PositiveIntegerField()), + ("tag", models.SlugField()), + ("object_id", models.PositiveIntegerField()), ( - 'content_type', + "content_type", models.ForeignKey( on_delete=django.db.models.deletion.CASCADE, - to='contenttypes.ContentType', + to="contenttypes.ContentType", ), ), ], diff --git a/examples/django_demo/generic_foreignkey/models.py b/examples/django_demo/generic_foreignkey/models.py index bf92c320..7d953ab5 100644 --- a/examples/django_demo/generic_foreignkey/models.py +++ b/examples/django_demo/generic_foreignkey/models.py @@ -9,7 +9,7 @@ class TaggedItem(models.Model): tag = models.SlugField() content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE) object_id = models.PositiveIntegerField() - content_object = GenericForeignKey('content_type', 'object_id') + content_object = GenericForeignKey("content_type", "object_id") def __str__(self): return self.tag diff --git a/examples/django_demo/generic_foreignkey/tests.py b/examples/django_demo/generic_foreignkey/tests.py index 091b31d3..35cfe29c 100644 --- a/examples/django_demo/generic_foreignkey/tests.py +++ b/examples/django_demo/generic_foreignkey/tests.py @@ -8,15 +8,15 @@ class GenericFactoryTest(TestCase): def test_user_factory(self): user = UserFactory() - self.assertEqual(user.first_name, 'Adam') + self.assertEqual(user.first_name, "Adam") def test_group_factory(self): group = GroupFactory() - self.assertEqual(group.name, 'group') + self.assertEqual(group.name, "group") def test_generic_user(self): - model = TaggedUserFactory(tag='user') - self.assertEqual(model.tag, 'user') + model = TaggedUserFactory(tag="user") + self.assertEqual(model.tag, "user") self.assertTrue(isinstance(model.content_object, User)) self.assertEqual( model.content_type, @@ -24,8 +24,8 @@ def test_generic_user(self): ) def test_generic_group(self): - model = TaggedGroupFactory(tag='group') - self.assertEqual(model.tag, 'group') + model = TaggedGroupFactory(tag="group") + self.assertEqual(model.tag, "group") self.assertTrue(isinstance(model.content_object, Group)) self.assertEqual( model.content_type, diff --git a/examples/flask_alchemy/demoapp.py b/examples/flask_alchemy/demoapp.py index f8e762ff..c9c6c5e4 100644 --- a/examples/flask_alchemy/demoapp.py +++ b/examples/flask_alchemy/demoapp.py @@ -4,7 +4,7 @@ from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) -app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db' +app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:////tmp/test.db" db = SQLAlchemy(app) @@ -18,19 +18,19 @@ def __init__(self, username, email): self.email = email def __repr__(self): - return '' % self.username + return "" % self.username class UserLog(db.Model): id = db.Column(db.Integer, primary_key=True) message = db.Column(db.String(1000)) - user_id = db.Column(db.Integer, db.ForeignKey('user.id')) - user = db.relationship('User', backref=db.backref('logs', lazy='dynamic')) + user_id = db.Column(db.Integer, db.ForeignKey("user.id")) + user = db.relationship("User", backref=db.backref("logs", lazy="dynamic")) def __init__(self, message, user): self.message = message self.user = user def __repr__(self): - return f'' + return f"" diff --git a/examples/flask_alchemy/test_demoapp.py b/examples/flask_alchemy/test_demoapp.py index dc42f4b2..cb860d97 100644 --- a/examples/flask_alchemy/test_demoapp.py +++ b/examples/flask_alchemy/test_demoapp.py @@ -6,8 +6,8 @@ class DemoAppTestCase(unittest.TestCase): def setUp(self): - demoapp.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://' - demoapp.app.config['TESTING'] = True + demoapp.app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite://" + demoapp.app.config["TESTING"] = True self.app = demoapp.app.test_client() self.db = demoapp.db self.db.create_all() diff --git a/factory/__init__.py b/factory/__init__.py index b0ada75d..af0d4316 100644 --- a/factory/__init__.py +++ b/factory/__init__.py @@ -69,7 +69,7 @@ except ImportError: pass -__author__ = 'Raphaël Barrois ' +__author__ = "Raphaël Barrois " try: # Python 3.8+ from importlib.metadata import version diff --git a/factory/alchemy.py b/factory/alchemy.py index be37800c..c879e8ce 100644 --- a/factory/alchemy.py +++ b/factory/alchemy.py @@ -5,8 +5,8 @@ from . import base, errors -SESSION_PERSISTENCE_COMMIT = 'commit' -SESSION_PERSISTENCE_FLUSH = 'flush' +SESSION_PERSISTENCE_COMMIT = "commit" +SESSION_PERSISTENCE_FLUSH = "flush" VALID_SESSION_PERSISTENCE_TYPES = [ None, SESSION_PERSISTENCE_COMMIT, @@ -24,10 +24,10 @@ def _check_sqlalchemy_session_persistence(self, meta, value): def _build_default_options(self): return super()._build_default_options() + [ - base.OptionDefault('sqlalchemy_get_or_create', (), inherit=True), - base.OptionDefault('sqlalchemy_session', None, inherit=True), + base.OptionDefault("sqlalchemy_get_or_create", (), inherit=True), + base.OptionDefault("sqlalchemy_session", None, inherit=True), base.OptionDefault( - 'sqlalchemy_session_persistence', + "sqlalchemy_session_persistence", None, inherit=True, checker=self._check_sqlalchemy_session_persistence, diff --git a/factory/base.py b/factory/base.py index 28fdcbcc..925dfd70 100644 --- a/factory/base.py +++ b/factory/base.py @@ -7,7 +7,7 @@ from . import builder, declarations, enums, errors, utils -logger = logging.getLogger('factory.generate') +logger = logging.getLogger("factory.generate") # Factory metaclasses @@ -42,7 +42,7 @@ def __call__(cls, **kwargs): return cls.stub(**kwargs) else: raise errors.UnknownStrategy( - 'Unknown Meta.strategy: {}'.format(cls._meta.strategy) + "Unknown Meta.strategy: {}".format(cls._meta.strategy) ) def __new__(mcs, class_name, bases, attrs): @@ -66,14 +66,14 @@ def __new__(mcs, class_name, bases, attrs): else: base_factory = None - attrs_meta = attrs.pop('Meta', None) - attrs_params = attrs.pop('Params', None) + attrs_meta = attrs.pop("Meta", None) + attrs_params = attrs.pop("Params", None) - base_meta = resolve_attribute('_meta', bases) - options_class = resolve_attribute('_options_class', bases, FactoryOptions) + base_meta = resolve_attribute("_meta", bases) + options_class = resolve_attribute("_options_class", bases, FactoryOptions) meta = options_class() - attrs['_meta'] = meta + attrs["_meta"] = meta new_class = super().__new__(mcs, class_name, bases, attrs) @@ -89,9 +89,9 @@ def __new__(mcs, class_name, bases, attrs): def __str__(cls): if cls._meta.abstract: - return '<%s (abstract)>' % cls.__name__ + return "<%s (abstract)>" % cls.__name__ else: - return f'<{cls.__name__} for {cls._meta.model}>' + return f"<{cls.__name__} for {cls._meta.model}>" class BaseMeta: @@ -130,7 +130,7 @@ def apply(self, meta, base_meta): return value def __str__(self): - return '%s(%r, %r, inherit=%r)' % ( + return "%s(%r, %r, inherit=%r)" % ( self.__class__.__name__, self.name, self.value, @@ -173,12 +173,12 @@ def is_model(meta, value): raise TypeError("%s is already a %s" % (repr(value), Factory.__name__)) return [ - OptionDefault('model', None, inherit=True, checker=is_model), - OptionDefault('abstract', False, inherit=False), - OptionDefault('strategy', enums.CREATE_STRATEGY, inherit=True), - OptionDefault('inline_args', (), inherit=True), - OptionDefault('exclude', (), inherit=True), - OptionDefault('rename', {}, inherit=True), + OptionDefault("model", None, inherit=True, checker=is_model), + OptionDefault("abstract", False, inherit=False), + OptionDefault("strategy", enums.CREATE_STRATEGY, inherit=True), + OptionDefault("inline_args", (), inherit=True), + OptionDefault("exclude", (), inherit=True), + OptionDefault("rename", {}, inherit=True), ] def _fill_from_meta(self, meta, base_meta): @@ -204,7 +204,7 @@ def _fill_from_meta(self, meta, base_meta): # Some attributes in the Meta aren't allowed here raise TypeError( "'class Meta' for %r got unknown attribute(s) %s" - % (self.factory, ','.join(sorted(meta_attrs.keys()))) + % (self.factory, ",".join(sorted(meta_attrs.keys()))) ) def contribute_to_class( @@ -225,7 +225,7 @@ def contribute_to_class( # Scan the inheritance chain, starting from the furthest point, # excluding the current class, to retrieve all declarations. for parent in reversed(self.factory.__mro__[1:]): - if not hasattr(parent, '_meta'): + if not hasattr(parent, "_meta"): continue self.base_declarations.update(parent._meta.base_declarations) self.parameters.update(parent._meta.parameters) @@ -238,7 +238,7 @@ def contribute_to_class( for k, v in utils.sort_ordered_objects( vars(params).items(), getter=lambda item: item[1] ): - if not k.startswith('_'): + if not k.startswith("_"): self.parameters[k] = declarations.SimpleParameter.wrap(v) self._check_parameter_dependencies(self.parameters) @@ -387,7 +387,7 @@ def _check_parameter_dependencies(self, parameters): if cyclic: raise errors.CyclicDefinitionError( "Cyclic definition detected on %r; Params around %s" - % (self.factory, ', '.join(cyclic)) + % (self.factory, ", ".join(cyclic)) ) return deps @@ -438,7 +438,7 @@ class BaseFactory: def __new__(cls, *args, **kwargs): """Would be called if trying to instantiate the class.""" - raise errors.FactoryError('You cannot instantiate BaseFactory') + raise errors.FactoryError("You cannot instantiate BaseFactory") _meta = FactoryOptions() @@ -625,7 +625,7 @@ def generate_batch(cls, strategy, size, **kwargs): enums.BUILD_STRATEGY, enums.CREATE_STRATEGY, ) - batch_action = getattr(cls, '%s_batch' % strategy) + batch_action = getattr(cls, "%s_batch" % strategy) return batch_action(size, **kwargs) @classmethod diff --git a/factory/builder.py b/factory/builder.py index ceafa1cf..1eeafd4b 100644 --- a/factory/builder.py +++ b/factory/builder.py @@ -5,8 +5,8 @@ from . import declarations, enums, errors, utils DeclarationWithContext = collections.namedtuple( - 'DeclarationWithContext', - ['name', 'declaration', 'context'], + "DeclarationWithContext", + ["name", "declaration", "context"], ) @@ -132,7 +132,7 @@ def as_dict(self): return dict(self._items()) def __repr__(self): - return '' % self.as_dict() + return "" % self.as_dict() def parse_declarations(decls, base_pre=None, base_post=None): @@ -155,7 +155,7 @@ def parse_declarations(decls, base_pre=None, base_post=None): elif k in post_declarations: # Passing in a scalar value to a PostGenerationDeclaration # Set it as `key__` - magic_key = post_declarations.join(k, '') + magic_key = post_declarations.join(k, "") extra_post[magic_key] = v elif k in pre_declarations and isinstance( pre_declarations[k].declaration, declarations.Transformer @@ -238,7 +238,7 @@ def __init__(self, factory_meta, extras, strategy): self.factory_meta = factory_meta self.strategy = strategy self.extras = extras - self.force_init_sequence = extras.pop('__sequence', None) + self.force_init_sequence = extras.pop("__sequence", None) def build(self, parent_step=None, force_sequence=None): """Build a factory instance.""" @@ -327,7 +327,7 @@ def factory_parent(self): return self.__step.parent_step.stub if self.__step.parent_step else None def __repr__(self): - return '' % self.__step + return "" % self.__step def __getattr__(self, name): """Retrieve an attribute's value. @@ -373,4 +373,4 @@ def __setattr__(self, name, value): if not self.__initialized: return super().__setattr__(name, value) else: - raise AttributeError('Setting of object attributes is not allowed') + raise AttributeError("Setting of object attributes is not allowed") diff --git a/factory/declarations.py b/factory/declarations.py index ed401393..817b51aa 100644 --- a/factory/declarations.py +++ b/factory/declarations.py @@ -7,7 +7,7 @@ from . import enums, errors, utils -logger = logging.getLogger('factory.generate') +logger = logging.getLogger("factory.generate") class BaseDeclaration(utils.OrderedBase): @@ -58,7 +58,7 @@ def evaluate(self, instance, step, extra): extra (dict): additional, call-time added kwargs for the step. """ - raise NotImplementedError('This is an abstract method') + raise NotImplementedError("This is an abstract method") class OrderedDeclaration(BaseDeclaration): @@ -138,8 +138,8 @@ def deepgetattr(obj, name, default=_UNSPECIFIED): AttributeError: if obj has no 'name' attribute. """ try: - if '.' in name: - attr, subname = name.split('.', 1) + if "." in name: + attr, subname = name.split(".", 1) return deepgetattr(getattr(obj, attr), subname, default) else: return getattr(obj, name) @@ -165,7 +165,7 @@ class SelfAttribute(BaseDeclaration): def __init__(self, attribute_name, default=_UNSPECIFIED): super().__init__() - depth = len(attribute_name) - len(attribute_name.lstrip('.')) + depth = len(attribute_name) - len(attribute_name.lstrip(".")) attribute_name = attribute_name[depth:] self.depth = depth @@ -187,7 +187,7 @@ def evaluate(self, instance, step, extra): return deepgetattr(target, self.attribute_name, self.default) def __repr__(self): - return '<%s(%r, default=%r)>' % ( + return "<%s(%r, default=%r)>" % ( self.__class__.__name__, self.attribute_name, self.default, @@ -363,17 +363,17 @@ class _FactoryWrapper: def __init__(self, factory_or_path): self.factory = None - self.module = self.name = '' + self.module = self.name = "" if isinstance(factory_or_path, type): self.factory = factory_or_path else: - if not (isinstance(factory_or_path, str) and '.' in factory_or_path): + if not (isinstance(factory_or_path, str) and "." in factory_or_path): raise ValueError( "A factory= argument must receive either a class " "or the fully qualified path to a Factory subclass; got " "%r instead." % factory_or_path ) - self.module, self.name = factory_or_path.rsplit('.', 1) + self.module, self.name = factory_or_path.rsplit(".", 1) def get(self): if self.factory is None: @@ -385,9 +385,9 @@ def get(self): def __repr__(self): if self.factory is None: - return f'<_FactoryImport: {self.module}.{self.name}>' + return f"<_FactoryImport: {self.module}.{self.name}>" else: - return f'<_FactoryImport: {self.factory.__class__}>' + return f"<_FactoryImport: {self.factory.__class__}>" class SubFactory(BaseDeclaration): @@ -437,7 +437,7 @@ class Dict(SubFactory): FORCE_SEQUENCE = True - def __init__(self, params, dict_factory='factory.DictFactory'): + def __init__(self, params, dict_factory="factory.DictFactory"): super().__init__(dict_factory, **dict(params)) @@ -446,7 +446,7 @@ class List(SubFactory): FORCE_SEQUENCE = True - def __init__(self, params, list_factory='factory.ListFactory'): + def __init__(self, params, list_factory="factory.ListFactory"): params = {str(i): v for i, v in enumerate(params)} super().__init__(list_factory, **params) @@ -476,8 +476,8 @@ def __init__(self, decider, yes_declaration=SKIP, no_declaration=SKIP): self.no = no_declaration phases = { - 'yes_declaration': enums.get_builder_phase(yes_declaration), - 'no_declaration': enums.get_builder_phase(no_declaration), + "yes_declaration": enums.get_builder_phase(yes_declaration), + "no_declaration": enums.get_builder_phase(no_declaration), } used_phases = {phase for phase in phases.values() if phase is not None} @@ -531,7 +531,7 @@ def evaluate_pre(self, instance, step, overrides): return target def __repr__(self): - return f'Maybe({self.decider!r}, yes={self.yes!r}, no={self.no!r})' + return f"Maybe({self.decider!r}, yes={self.yes!r}, no={self.no!r})" class Parameter(utils.OrderedBase): @@ -589,9 +589,9 @@ def as_declarations(self, field_name, declarations): for maybe_field, new_value in self.overrides.items(): overrides[maybe_field] = Maybe( decider=SelfAttribute( - '%s.%s' + "%s.%s" % ( - '.' * maybe_field.count(enums.SPLITTER), + "." * maybe_field.count(enums.SPLITTER), field_name, ), default=False, @@ -606,9 +606,9 @@ def get_revdeps(self, parameters): return [param for param in parameters if param in self.overrides] def __repr__(self): - return '%s(%s)' % ( + return "%s(%s)" % ( self.__class__.__name__, - ', '.join('%s=%r' % t for t in self.overrides.items()), + ", ".join("%s=%r" % t for t in self.overrides.items()), ) @@ -630,9 +630,9 @@ class PostGenerationDeclaration(BaseDeclaration): def evaluate_post(self, instance, step, overrides): context = self.unroll_context(instance, step, overrides) postgen_context = PostGenerationContext( - value_provided=bool('' in context), - value=context.get(''), - extra={k: v for k, v in context.items() if k != ''}, + value_provided=bool("" in context), + value=context.get(""), + extra={k: v for k, v in context.items() if k != ""}, ) return self.call(instance, step, postgen_context) @@ -681,7 +681,7 @@ class RelatedFactory(PostGenerationDeclaration): UNROLL_CONTEXT_BEFORE_EVALUATION = False - def __init__(self, factory, factory_related_name='', **defaults): + def __init__(self, factory, factory_related_name="", **defaults): super().__init__() self.name = factory_related_name @@ -731,7 +731,7 @@ class RelatedFactoryList(RelatedFactory): returning a list of 'factory' objects w/ size 'size'. """ - def __init__(self, factory, factory_related_name='', size=2, **defaults): + def __init__(self, factory, factory_related_name="", size=2, **defaults): self.size = size super().__init__(factory, factory_related_name, **defaults) diff --git a/factory/django.py b/factory/django.py index 98e755bd..6cd54ea4 100644 --- a/factory/django.py +++ b/factory/django.py @@ -16,10 +16,10 @@ from . import base, declarations, errors -logger = logging.getLogger('factory.generate') +logger = logging.getLogger("factory.generate") -DEFAULT_DB_ALIAS = 'default' # Same as django.db.DEFAULT_DB_ALIAS +DEFAULT_DB_ALIAS = "default" # Same as django.db.DEFAULT_DB_ALIAS _LAZY_LOADS = {} @@ -27,10 +27,10 @@ def get_model(app, model): """Wrapper around django's get_model.""" - if 'get_model' not in _LAZY_LOADS: + if "get_model" not in _LAZY_LOADS: _lazy_load_get_model() - _get_model = _LAZY_LOADS['get_model'] + _get_model = _LAZY_LOADS["get_model"] return _get_model(app, model) @@ -42,15 +42,15 @@ def _lazy_load_get_model(): """ from django import apps as django_apps - _LAZY_LOADS['get_model'] = django_apps.apps.get_model + _LAZY_LOADS["get_model"] = django_apps.apps.get_model class DjangoOptions(base.FactoryOptions): def _build_default_options(self): return super()._build_default_options() + [ - base.OptionDefault('django_get_or_create', (), inherit=True), - base.OptionDefault('database', DEFAULT_DB_ALIAS, inherit=True), - base.OptionDefault('skip_postgeneration_save', False, inherit=True), + base.OptionDefault("django_get_or_create", (), inherit=True), + base.OptionDefault("database", DEFAULT_DB_ALIAS, inherit=True), + base.OptionDefault("skip_postgeneration_save", False, inherit=True), ] def _get_counter_reference(self): @@ -68,8 +68,8 @@ def _get_counter_reference(self): return counter_reference def get_model_class(self): - if isinstance(self.model, str) and '.' in self.model: - app, model_name = self.model.split('.', 1) + if isinstance(self.model, str) and "." in self.model: + app, model_name = self.model.split(".", 1) self.model = get_model(app, model_name) return self.model @@ -92,8 +92,8 @@ class Meta: @classmethod def _load_model_class(cls, definition): - if isinstance(definition, str) and '.' in definition: - app, model = definition.split('.', 1) + if isinstance(definition, str) and "." in definition: + app, model = definition.split(".", 1) return get_model(app, model) return definition @@ -128,7 +128,7 @@ def _get_or_create(cls, model_class, *args, **kwargs): """Create an instance of the model through objects.get_or_create.""" manager = cls._get_manager(model_class) - assert 'defaults' not in cls._meta.django_get_or_create, ( + assert "defaults" not in cls._meta.django_get_or_create, ( "'defaults' is a reserved keyword for get_or_create " "(in %s._meta.django_get_or_create=%r)" % (cls, cls._meta.django_get_or_create) @@ -143,7 +143,7 @@ def _get_or_create(cls, model_class, *args, **kwargs): % (field, cls.__name__) ) key_fields[field] = kwargs.pop(field) - key_fields['defaults'] = kwargs + key_fields["defaults"] = kwargs try: instance, _created = manager.get_or_create(*args, **key_fields) @@ -200,19 +200,19 @@ def __init__(self, password, *args, **kwargs): class FileField(declarations.BaseDeclaration): """Helper to fill in django.db.models.FileField from a Factory.""" - DEFAULT_FILENAME = 'example.dat' + DEFAULT_FILENAME = "example.dat" def _make_data(self, params): """Create data for the field.""" - return params.get('data', b'') + return params.get("data", b"") def _make_content(self, params): - path = '' + path = "" _content_params = [ - params.get('from_path'), - params.get('from_file'), - params.get('from_func'), + params.get("from_path"), + params.get("from_file"), + params.get("from_func"), ] if len([p for p in _content_params if p]) > 1: raise ValueError( @@ -220,18 +220,18 @@ def _make_content(self, params): "be non-empty when calling factory.django.FileField." ) - if params.get('from_path'): - path = params['from_path'] - with open(path, 'rb') as f: + if params.get("from_path"): + path = params["from_path"] + with open(path, "rb") as f: content = django_files.base.ContentFile(f.read()) - elif params.get('from_file'): - f = params['from_file'] + elif params.get("from_file"): + f = params["from_file"] content = django_files.File(f) path = content.name - elif params.get('from_func'): - func = params['from_func'] + elif params.get("from_func"): + func = params["from_func"] content = django_files.File(func()) path = content.name @@ -244,7 +244,7 @@ def _make_content(self, params): else: default_filename = self.DEFAULT_FILENAME - filename = params.get('filename', default_filename) + filename = params.get("filename", default_filename) return filename, content def evaluate(self, instance, step, extra): @@ -254,18 +254,18 @@ def evaluate(self, instance, step, extra): class ImageField(FileField): - DEFAULT_FILENAME = 'example.jpg' + DEFAULT_FILENAME = "example.jpg" def _make_data(self, params): # ImageField (both django's and factory_boy's) require PIL. # Try to import it along one of its known installation paths. from PIL import Image - width = params.get('width', 100) - height = params.get('height', width) - color = params.get('color', 'blue') - image_format = params.get('format', 'JPEG') - image_palette = params.get('palette', 'RGB') + width = params.get("width", 100) + height = params.get("height", width) + color = params.get("color", "blue") + image_format = params.get("format", "JPEG") + image_palette = params.get("palette", "RGB") thumb_io = io.BytesIO() with Image.new(image_palette, (width, height), color) as thumb: @@ -299,7 +299,7 @@ def __init__(self, *signals): def __enter__(self): for signal in self.signals: - logger.debug('mute_signals: Disabling signal handlers %r', signal.receivers) + logger.debug("mute_signals: Disabling signal handlers %r", signal.receivers) # Note that we're using implementation details of # django.signals, since arguments to signal.connect() @@ -309,7 +309,7 @@ def __enter__(self): def __exit__(self, exc_type, exc_value, traceback): for signal, receivers in self.paused.items(): - logger.debug('mute_signals: Restoring signal handlers %r', receivers) + logger.debug("mute_signals: Restoring signal handlers %r", receivers) signal.receivers += receivers with signal.lock: diff --git a/factory/enums.py b/factory/enums.py index 02f686e3..29e9deed 100644 --- a/factory/enums.py +++ b/factory/enums.py @@ -1,24 +1,24 @@ # Copyright: See the LICENSE file. # Strategies -BUILD_STRATEGY = 'build' -CREATE_STRATEGY = 'create' -STUB_STRATEGY = 'stub' +BUILD_STRATEGY = "build" +CREATE_STRATEGY = "create" +STUB_STRATEGY = "stub" #: String for splitting an attribute name into a #: (subfactory_name, subfactory_field) tuple. -SPLITTER = '__' +SPLITTER = "__" # Target build phase, for declarations class BuilderPhase: #: During attribute resolution/computation - ATTRIBUTE_RESOLUTION = 'attributes' + ATTRIBUTE_RESOLUTION = "attributes" #: Once the target object has been built - POST_INSTANTIATION = 'post_instance' + POST_INSTANTIATION = "post_instance" def get_builder_phase(obj): - return getattr(obj, 'FACTORY_BUILDER_PHASE', None) + return getattr(obj, "FACTORY_BUILDER_PHASE", None) diff --git a/factory/faker.py b/factory/faker.py index fcbc278d..90d6804e 100644 --- a/factory/faker.py +++ b/factory/faker.py @@ -37,12 +37,12 @@ class Faker(declarations.BaseDeclaration): """ def __init__(self, provider, **kwargs): - locale = kwargs.pop('locale', None) + locale = kwargs.pop("locale", None) self.provider = provider super().__init__(locale=locale, **kwargs) def evaluate(self, instance, step, extra): - locale = extra.pop('locale') + locale = extra.pop("locale") subfaker = self._get_faker(locale) return subfaker.format(self.provider, **extra) diff --git a/factory/fuzzy.py b/factory/fuzzy.py index 0975c359..b7056d64 100644 --- a/factory/fuzzy.py +++ b/factory/fuzzy.py @@ -64,7 +64,7 @@ class FuzzyText(BaseFuzzyAttribute): not important. """ - def __init__(self, prefix='', length=12, suffix='', chars=string.ascii_letters): + def __init__(self, prefix="", length=12, suffix="", chars=string.ascii_letters): super().__init__() self.prefix = prefix self.suffix = suffix @@ -73,7 +73,7 @@ def __init__(self, prefix='', length=12, suffix='', chars=string.ascii_letters): def fuzz(self): chars = [random.randgen.choice(self.chars) for _i in range(self.length)] - return self.prefix + ''.join(chars) + self.suffix + return self.prefix + "".join(chars) + self.suffix class FuzzyChoice(BaseFuzzyAttribute): @@ -153,7 +153,7 @@ def __init__(self, low, high=None, precision=15): def fuzz(self): base = random.randgen.uniform(self.low, self.high) - return float(format(base, '.%dg' % self.precision)) + return float(format(base, ".%dg" % self.precision)) class FuzzyDate(BaseFuzzyAttribute): diff --git a/factory/helpers.py b/factory/helpers.py index 1bb6034f..d7c50ea5 100644 --- a/factory/helpers.py +++ b/factory/helpers.py @@ -10,7 +10,7 @@ @contextlib.contextmanager -def debug(logger='factory', stream=None): +def debug(logger="factory", stream=None): logger_obj = logging.getLogger(logger) old_level = logger_obj.level @@ -28,13 +28,13 @@ def debug(logger='factory', stream=None): def make_factory(klass, **kwargs): """Create a new, simple factory for the given class.""" - factory_name = '%sFactory' % klass.__name__ + factory_name = "%sFactory" % klass.__name__ class Meta: model = klass - kwargs['Meta'] = Meta - base_class = kwargs.pop('FACTORY_CLASS', base.Factory) + kwargs["Meta"] = Meta + base_class = kwargs.pop("FACTORY_CLASS", base.Factory) factory_class = type(base.Factory).__new__( type(base.Factory), @@ -42,8 +42,8 @@ class Meta: (base_class,), kwargs, ) - factory_class.__name__ = '%sFactory' % klass.__name__ - factory_class.__doc__ = 'Auto-generated factory for class %s' % klass + factory_class.__name__ = "%sFactory" % klass.__name__ + factory_class.__doc__ = "Auto-generated factory for class %s" % klass return factory_class diff --git a/factory/utils.py b/factory/utils.py index 3685839f..f9daae79 100644 --- a/factory/utils.py +++ b/factory/utils.py @@ -23,7 +23,7 @@ class log_pprint: performed lazily. """ - __slots__ = ['args', 'kwargs'] + __slots__ = ["args", "kwargs"] def __init__(self, args=(), kwargs=None): self.args = args @@ -33,9 +33,9 @@ def __repr__(self): return repr(str(self)) def __str__(self): - return ', '.join( + return ", ".join( [repr(arg) for arg in self.args] - + ['%s=%s' % (key, repr(value)) for key, value in self.kwargs.items()] + + ["%s=%s" % (key, repr(value)) for key, value in self.kwargs.items()] ) @@ -72,7 +72,7 @@ class OrderedBase: Each instance (even from subclasses) will share a global creation counter. """ - CREATION_COUNTER_FIELD = '_creation_counter' + CREATION_COUNTER_FIELD = "_creation_counter" def __init__(self, **kwargs): super().__init__(**kwargs) diff --git a/tests/alchemyapp/models.py b/tests/alchemyapp/models.py index 8e76b5bd..70e0de73 100644 --- a/tests/alchemyapp/models.py +++ b/tests/alchemyapp/models.py @@ -8,20 +8,20 @@ from sqlalchemy.orm import scoped_session, sessionmaker session = scoped_session(sessionmaker()) -engine = create_engine('sqlite://') +engine = create_engine("sqlite://") session.configure(bind=engine) Base = declarative_base() class StandardModel(Base): - __tablename__ = 'StandardModelTable' + __tablename__ = "StandardModelTable" id = Column(Integer(), primary_key=True) foo = Column(Unicode(20)) class MultiFieldModel(Base): - __tablename__ = 'MultiFieldModelTable' + __tablename__ = "MultiFieldModelTable" id = Column(Integer(), primary_key=True) foo = Column(Unicode(20)) @@ -29,7 +29,7 @@ class MultiFieldModel(Base): class MultifieldUniqueModel(Base): - __tablename__ = 'MultiFieldUniqueModelTable' + __tablename__ = "MultiFieldUniqueModelTable" id = Column(Integer(), primary_key=True) slug = Column(Unicode(20), unique=True) @@ -38,13 +38,13 @@ class MultifieldUniqueModel(Base): class NonIntegerPk(Base): - __tablename__ = 'NonIntegerPk' + __tablename__ = "NonIntegerPk" id = Column(Unicode(20), primary_key=True) class SpecialFieldModel(Base): - __tablename__ = 'SpecialFieldModelTable' + __tablename__ = "SpecialFieldModelTable" id = Column(Integer(), primary_key=True) session = Column(Unicode(20)) diff --git a/tests/alter_time.py b/tests/alter_time.py index 427b572f..4c18828b 100644 --- a/tests/alter_time.py +++ b/tests/alter_time.py @@ -40,7 +40,7 @@ def now(cls, tz=None): def utcnow(cls): return target - return mock.patch.object(datetime_module, 'datetime', MockedDatetime) + return mock.patch.object(datetime_module, "datetime", MockedDatetime) real_date_class = datetime.date @@ -72,7 +72,7 @@ class MockedDate(real_date_class, metaclass=DateSubclassMeta): def today(cls): return target - return mock.patch.object(datetime_module, 'date', MockedDate) + return mock.patch.object(datetime_module, "date", MockedDate) def main(): # pragma: no cover diff --git a/tests/cyclic/bar.py b/tests/cyclic/bar.py index 6985a11f..c9dd15bb 100644 --- a/tests/cyclic/bar.py +++ b/tests/cyclic/bar.py @@ -16,4 +16,4 @@ class Meta: model = Bar y = 13 - foo = factory.SubFactory('cyclic.foo.FooFactory') + foo = factory.SubFactory("cyclic.foo.FooFactory") diff --git a/tests/cyclic/self_ref.py b/tests/cyclic/self_ref.py index b0111b07..5a49b7c8 100644 --- a/tests/cyclic/self_ref.py +++ b/tests/cyclic/self_ref.py @@ -16,4 +16,4 @@ class Meta: model = TreeElement name = factory.Sequence(lambda n: "tree%s" % n) - parent = factory.SubFactory('tests.cyclic.self_ref.TreeElementFactory') + parent = factory.SubFactory("tests.cyclic.self_ref.TreeElementFactory") diff --git a/tests/djapp/models.py b/tests/djapp/models.py index f74f85fc..831987bd 100644 --- a/tests/djapp/models.py +++ b/tests/djapp/models.py @@ -66,21 +66,21 @@ class PointerModel(models.Model): bar = models.CharField(max_length=20) pointed = models.OneToOneField( PointedModel, - related_name='pointer', + related_name="pointer", null=True, on_delete=models.CASCADE, ) class WithDefaultValue(models.Model): - foo = models.CharField(max_length=20, default='') + foo = models.CharField(max_length=20, default="") class WithPassword(models.Model): pw = models.CharField(max_length=128) -WITHFILE_UPLOAD_TO = 'django' +WITHFILE_UPLOAD_TO = "django" WITHFILE_UPLOAD_DIR = os.path.join(settings.MEDIA_ROOT, WITHFILE_UPLOAD_TO) diff --git a/tests/djapp/settings.py b/tests/djapp/settings.py index fdfe8761..ea1b751f 100644 --- a/tests/djapp/settings.py +++ b/tests/djapp/settings.py @@ -10,23 +10,23 @@ os.pardir, # /path/to/fboy ) -MEDIA_ROOT = os.path.join(FACTORY_ROOT, 'tmp_test') +MEDIA_ROOT = os.path.join(FACTORY_ROOT, "tmp_test") DATABASES = { - 'default': { - 'ENGINE': 'django.db.backends.sqlite3', + "default": { + "ENGINE": "django.db.backends.sqlite3", }, - 'replica': { - 'ENGINE': 'django.db.backends.sqlite3', + "replica": { + "ENGINE": "django.db.backends.sqlite3", }, } -INSTALLED_APPS = ['tests.djapp'] +INSTALLED_APPS = ["tests.djapp"] MIDDLEWARE_CLASSES = () -SECRET_KEY = 'testing.' +SECRET_KEY = "testing." # TODO: Will be the default after Django 5.0. Remove this setting when # Django 5.0 is the last supported version. diff --git a/tests/test_alchemy.py b/tests/test_alchemy.py index 5cbee984..133929f8 100644 --- a/tests/test_alchemy.py +++ b/tests/test_alchemy.py @@ -19,7 +19,7 @@ class Meta: sqlalchemy_session = models.session id = factory.Sequence(lambda n: n) - foo = factory.Sequence(lambda n: 'foo%d' % n) + foo = factory.Sequence(lambda n: "foo%d" % n) class NonIntegerPkFactory(SQLAlchemyModelFactory): @@ -27,7 +27,7 @@ class Meta: model = models.NonIntegerPk sqlalchemy_session = models.session - id = factory.Sequence(lambda n: 'foo%d' % n) + id = factory.Sequence(lambda n: "foo%d" % n) class NoSessionFactory(SQLAlchemyModelFactory): @@ -41,23 +41,23 @@ class Meta: class MultifieldModelFactory(SQLAlchemyModelFactory): class Meta: model = models.MultiFieldModel - sqlalchemy_get_or_create = ('slug',) + sqlalchemy_get_or_create = ("slug",) sqlalchemy_session = models.session - sqlalchemy_session_persistence = 'commit' + sqlalchemy_session_persistence = "commit" id = factory.Sequence(lambda n: n) - foo = factory.Sequence(lambda n: 'foo%d' % n) + foo = factory.Sequence(lambda n: "foo%d" % n) class WithGetOrCreateFieldFactory(SQLAlchemyModelFactory): class Meta: model = models.StandardModel - sqlalchemy_get_or_create = ('foo',) + sqlalchemy_get_or_create = ("foo",) sqlalchemy_session = models.session - sqlalchemy_session_persistence = 'commit' + sqlalchemy_session_persistence = "commit" id = factory.Sequence(lambda n: n) - foo = factory.Sequence(lambda n: 'foo%d' % n) + foo = factory.Sequence(lambda n: "foo%d" % n) class WithMultipleGetOrCreateFieldsFactory(SQLAlchemyModelFactory): @@ -65,7 +65,7 @@ class Meta: model = models.MultifieldUniqueModel sqlalchemy_get_or_create = ("slug", "text") sqlalchemy_session = models.session - sqlalchemy_session_persistence = 'commit' + sqlalchemy_session_persistence = "commit" id = factory.Sequence(lambda n: n) slug = factory.Sequence(lambda n: "slug%s" % n) @@ -80,32 +80,32 @@ def setUp(self): def test_pk_first(self): std = StandardFactory.build() - self.assertEqual('foo1', std.foo) + self.assertEqual("foo1", std.foo) def test_pk_many(self): std1 = StandardFactory.build() std2 = StandardFactory.build() - self.assertEqual('foo1', std1.foo) - self.assertEqual('foo2', std2.foo) + self.assertEqual("foo1", std1.foo) + self.assertEqual("foo2", std2.foo) def test_pk_creation(self): std1 = StandardFactory.create() - self.assertEqual('foo1', std1.foo) + self.assertEqual("foo1", std1.foo) self.assertEqual(1, std1.id) StandardFactory.reset_sequence() std2 = StandardFactory.create() - self.assertEqual('foo0', std2.foo) + self.assertEqual("foo0", std2.foo) self.assertEqual(0, std2.id) def test_pk_force_value(self): std1 = StandardFactory.create(id=10) - self.assertEqual('foo1', std1.foo) # sequence and pk are unrelated + self.assertEqual("foo1", std1.foo) # sequence and pk are unrelated self.assertEqual(10, std1.id) StandardFactory.reset_sequence() std2 = StandardFactory.create() - self.assertEqual('foo0', std2.foo) # Sequence doesn't care about pk + self.assertEqual("foo0", std2.foo) # Sequence doesn't care about pk self.assertEqual(0, std2.id) @@ -114,8 +114,8 @@ def setUp(self): models.session.rollback() def test_simple_call(self): - obj1 = WithGetOrCreateFieldFactory(foo='foo1') - obj2 = WithGetOrCreateFieldFactory(foo='foo1') + obj1 = WithGetOrCreateFieldFactory(foo="foo1") + obj2 = WithGetOrCreateFieldFactory(foo="foo1") self.assertEqual(obj1, obj2) def test_missing_arg(self): @@ -123,14 +123,14 @@ def test_missing_arg(self): MultifieldModelFactory() def test_raises_exception_when_existing_objs(self): - StandardFactory.create_batch(2, foo='foo') + StandardFactory.create_batch(2, foo="foo") with self.assertRaises(sqlalchemy.orm.exc.MultipleResultsFound): - WithGetOrCreateFieldFactory(foo='foo') + WithGetOrCreateFieldFactory(foo="foo") def test_multicall(self): objs = MultifieldModelFactory.create_batch( 6, - slug=factory.Iterator(['main', 'alt']), + slug=factory.Iterator(["main", "alt"]), ) self.assertEqual(6, len(objs)) self.assertEqual(2, len(set(objs))) @@ -155,9 +155,9 @@ def test_both_defined(self): WithMultipleGetOrCreateFieldsFactory(slug=obj1.slug, text="alt") def test_unique_field_not_in_get_or_create(self): - WithMultipleGetOrCreateFieldsFactory(title='Title') + WithMultipleGetOrCreateFieldsFactory(title="Title") with self.assertRaises(sqlalchemy.exc.IntegrityError): - WithMultipleGetOrCreateFieldsFactory(title='Title') + WithMultipleGetOrCreateFieldsFactory(title="Title") class SQLAlchemySessionPersistenceTestCase(unittest.TestCase): @@ -169,7 +169,7 @@ def test_flushing(self): class FlushingPersistenceFactory(StandardFactory): class Meta: sqlalchemy_session = self.mock_session - sqlalchemy_session_persistence = 'flush' + sqlalchemy_session_persistence = "flush" self.mock_session.commit.assert_not_called() self.mock_session.flush.assert_not_called() @@ -182,7 +182,7 @@ def test_committing(self): class CommittingPersistenceFactory(StandardFactory): class Meta: sqlalchemy_session = self.mock_session - sqlalchemy_session_persistence = 'commit' + sqlalchemy_session_persistence = "commit" self.mock_session.commit.assert_not_called() self.mock_session.flush.assert_not_called() @@ -209,7 +209,7 @@ def test_type_error(self): class BadPersistenceFactory(StandardFactory): class Meta: - sqlalchemy_session_persistence = 'invalid_persistence_option' + sqlalchemy_session_persistence = "invalid_persistence_option" model = models.StandardModel @@ -221,30 +221,30 @@ def setUp(self): def test_first(self): nonint = NonIntegerPkFactory.build() - self.assertEqual('foo0', nonint.id) + self.assertEqual("foo0", nonint.id) def test_many(self): nonint1 = NonIntegerPkFactory.build() nonint2 = NonIntegerPkFactory.build() - self.assertEqual('foo0', nonint1.id) - self.assertEqual('foo1', nonint2.id) + self.assertEqual("foo0", nonint1.id) + self.assertEqual("foo1", nonint2.id) def test_creation(self): nonint1 = NonIntegerPkFactory.create() - self.assertEqual('foo0', nonint1.id) + self.assertEqual("foo0", nonint1.id) NonIntegerPkFactory.reset_sequence() nonint2 = NonIntegerPkFactory.build() - self.assertEqual('foo0', nonint2.id) + self.assertEqual("foo0", nonint2.id) def test_force_pk(self): - nonint1 = NonIntegerPkFactory.create(id='foo10') - self.assertEqual('foo10', nonint1.id) + nonint1 = NonIntegerPkFactory.create(id="foo10") + self.assertEqual("foo10", nonint1.id) NonIntegerPkFactory.reset_sequence() nonint2 = NonIntegerPkFactory.create() - self.assertEqual('foo0', nonint2.id) + self.assertEqual("foo0", nonint2.id) class SQLAlchemyNoSessionTestCase(unittest.TestCase): @@ -272,7 +272,7 @@ class Meta: sqlalchemy_session = models.session id = factory.Sequence(lambda n: n) - session = '' + session = "" saved_child = SpecialFieldWithSaveFactory() self.assertEqual(saved_child.session, "") @@ -281,11 +281,11 @@ def test_no_name_conflict_on_get_or_create(self): class SpecialFieldWithGetOrCreateFactory(SQLAlchemyModelFactory): class Meta: model = models.SpecialFieldModel - sqlalchemy_get_or_create = ('session',) + sqlalchemy_get_or_create = ("session",) sqlalchemy_session = models.session id = factory.Sequence(lambda n: n) - session = '' + session = "" get_or_created_child = SpecialFieldWithGetOrCreateFactory() self.assertEqual(get_or_created_child.session, "") diff --git a/tests/test_base.py b/tests/test_base.py index 76785daf..2a88ea33 100644 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -137,11 +137,11 @@ class AbstractFactory(base.Factory): # And are available in class Meta self.assertEqual( - {'x': 1, 'y': lazy, 'y2': lazy2}, + {"x": 1, "y": lazy, "y2": lazy2}, AbstractFactory._meta.pre_declarations.as_dict(), ) self.assertEqual( - {'z': postgen}, + {"z": postgen}, AbstractFactory._meta.post_declarations.as_dict(), ) @@ -169,11 +169,11 @@ class OtherFactory(AbstractFactory): # And are available in class Meta self.assertEqual( - {'x': 1, 'y': lazy, 'a': lazy2}, + {"x": 1, "y": lazy, "a": lazy2}, OtherFactory._meta.pre_declarations.as_dict(), ) self.assertEqual( - {'z': postgen, 'b': postgen2}, + {"z": postgen, "b": postgen2}, OtherFactory._meta.post_declarations.as_dict(), ) @@ -199,11 +199,11 @@ class OtherFactory(AbstractFactory): # And are available in class Meta self.assertEqual( - {'x': 1, 'y': lazy2}, + {"x": 1, "y": lazy2}, OtherFactory._meta.pre_declarations.as_dict(), ) self.assertEqual( - {'z': postgen2}, + {"z": postgen2}, OtherFactory._meta.post_declarations.as_dict(), ) @@ -228,7 +228,7 @@ class Meta: def some_classmethod(cls): return cls.create() - self.assertTrue(hasattr(TestObjectFactory, 'some_classmethod')) + self.assertTrue(hasattr(TestObjectFactory, "some_classmethod")) obj = TestObjectFactory.some_classmethod() self.assertEqual(TestObject, obj.__class__) @@ -243,15 +243,15 @@ class Meta: self.assertEqual(TestObject, TestObjectFactory._meta.model) obj = TestObjectFactory.build() - self.assertFalse(hasattr(obj, '_meta')) + self.assertFalse(hasattr(obj, "_meta")) def test_display(self): class TestObjectFactory(base.Factory): class Meta: model = FakeDjangoModel - self.assertIn('TestObjectFactory', str(TestObjectFactory)) - self.assertIn('FakeDjangoModel', str(TestObjectFactory)) + self.assertIn("TestObjectFactory", str(TestObjectFactory)) + self.assertIn("FakeDjangoModel", str(TestObjectFactory)) def test_lazy_attribute_non_existent_param(self): class TestObjectFactory(base.Factory): @@ -376,10 +376,10 @@ class Meta: model = TestModel strategy = enums.BUILD_STRATEGY - one = 'one' + one = "one" test_model = TestModelFactory() - self.assertEqual(test_model.one, 'one') + self.assertEqual(test_model.one, "one") self.assertFalse(test_model.id) def test_create_strategy(self): @@ -389,10 +389,10 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" test_model = TestModelFactory() - self.assertEqual(test_model.one, 'one') + self.assertEqual(test_model.one, "one") self.assertTrue(test_model.id) def test_stub_strategy(self): @@ -401,19 +401,19 @@ class Meta: model = TestModel strategy = enums.STUB_STRATEGY - one = 'one' + one = "one" test_model = TestModelFactory() - self.assertEqual(test_model.one, 'one') - self.assertFalse(hasattr(test_model, 'id')) # We should have a plain old object + self.assertEqual(test_model.one, "one") + self.assertFalse(hasattr(test_model, "id")) # We should have a plain old object def test_unknown_strategy(self): class TestModelFactory(base.Factory): class Meta: model = TestModel - strategy = 'unknown' + strategy = "unknown" - one = 'one' + one = "one" with self.assertRaises(base.Factory.UnknownStrategy): TestModelFactory() @@ -424,7 +424,7 @@ class Meta: model = TestModel strategy = enums.CREATE_STRATEGY - one = 'one' + one = "one" with self.assertRaises(base.StubFactory.UnsupportedStrategy): TestModelFactory() @@ -435,7 +435,7 @@ class Meta: model = TestModel strategy = enums.BUILD_STRATEGY - one = 'one' + one = "one" obj = TestModelFactory() @@ -448,7 +448,7 @@ class Meta: model = TestModel strategy = enums.CREATE_STRATEGY - one = 'one' + one = "one" self.assertEqual(enums.CREATE_STRATEGY, TestModelFactory._meta.strategy) @@ -484,17 +484,17 @@ class StubA(base.StubFactory): class Meta: model = TestObject - one = 'blah' + one = "blah" class StubB(base.StubFactory): class Meta: model = TestObject - stubbed = declarations.SubFactory(StubA, two='two') + stubbed = declarations.SubFactory(StubA, two="two") b = StubB() - self.assertEqual('blah', b.stubbed.one) - self.assertEqual('two', b.stubbed.two) + self.assertEqual("blah", b.stubbed.one) + self.assertEqual("two", b.stubbed.two) def test_custom_creation(self): class TestModelFactory(FakeModelFactory): @@ -503,7 +503,7 @@ class Meta: @classmethod def _generate(cls, create, attrs): - attrs['four'] = 4 + attrs["four"] = 4 return super()._generate(create, attrs) b = TestModelFactory.build(one=1) @@ -533,7 +533,7 @@ class Meta: foo = declarations.PostGenerationDeclaration() - self.assertIn('foo', TestObjectFactory._meta.post_declarations.as_dict()) + self.assertIn("foo", TestObjectFactory._meta.post_declarations.as_dict()) def test_classlevel_extraction(self): class TestObjectFactory(base.Factory): @@ -543,5 +543,5 @@ class Meta: foo = declarations.PostGenerationDeclaration() foo__bar = 42 - self.assertIn('foo', TestObjectFactory._meta.post_declarations.as_dict()) - self.assertIn('foo__bar', TestObjectFactory._meta.post_declarations.as_dict()) + self.assertIn("foo", TestObjectFactory._meta.post_declarations.as_dict()) + self.assertIn("foo__bar", TestObjectFactory._meta.post_declarations.as_dict()) diff --git a/tests/test_declarations.py b/tests/test_declarations.py index e45d1bf3..f551488b 100644 --- a/tests/test_declarations.py +++ b/tests/test_declarations.py @@ -26,29 +26,29 @@ def test_chaining(self): obj.a.b = self.MyObj(3) obj.a.b.c = self.MyObj(4) - self.assertEqual(2, declarations.deepgetattr(obj, 'a').n) + self.assertEqual(2, declarations.deepgetattr(obj, "a").n) with self.assertRaises(AttributeError): - declarations.deepgetattr(obj, 'b') - self.assertEqual(2, declarations.deepgetattr(obj, 'a.n')) - self.assertEqual(3, declarations.deepgetattr(obj, 'a.c', 3)) + declarations.deepgetattr(obj, "b") + self.assertEqual(2, declarations.deepgetattr(obj, "a.n")) + self.assertEqual(3, declarations.deepgetattr(obj, "a.c", 3)) with self.assertRaises(AttributeError): - declarations.deepgetattr(obj, 'a.c.n') + declarations.deepgetattr(obj, "a.c.n") with self.assertRaises(AttributeError): - declarations.deepgetattr(obj, 'a.d') - self.assertEqual(3, declarations.deepgetattr(obj, 'a.b').n) - self.assertEqual(3, declarations.deepgetattr(obj, 'a.b.n')) - self.assertEqual(4, declarations.deepgetattr(obj, 'a.b.c').n) - self.assertEqual(4, declarations.deepgetattr(obj, 'a.b.c.n')) - self.assertEqual(42, declarations.deepgetattr(obj, 'a.b.c.n.x', 42)) + declarations.deepgetattr(obj, "a.d") + self.assertEqual(3, declarations.deepgetattr(obj, "a.b").n) + self.assertEqual(3, declarations.deepgetattr(obj, "a.b.n")) + self.assertEqual(4, declarations.deepgetattr(obj, "a.b.c").n) + self.assertEqual(4, declarations.deepgetattr(obj, "a.b.c.n")) + self.assertEqual(42, declarations.deepgetattr(obj, "a.b.c.n.x", 42)) class MaybeTestCase(unittest.TestCase): def test_init(self): - declarations.Maybe('foo', 1, 2) + declarations.Maybe("foo", 1, 2) - with self.assertRaisesRegex(TypeError, 'Inconsistent phases'): + with self.assertRaisesRegex(TypeError, "Inconsistent phases"): declarations.Maybe( - 'foo', + "foo", declarations.LazyAttribute(None), declarations.PostGenerationDeclaration(), ) @@ -56,33 +56,33 @@ def test_init(self): class SelfAttributeTestCase(unittest.TestCase): def test_standard(self): - a = declarations.SelfAttribute('foo.bar.baz') + a = declarations.SelfAttribute("foo.bar.baz") self.assertEqual(0, a.depth) - self.assertEqual('foo.bar.baz', a.attribute_name) + self.assertEqual("foo.bar.baz", a.attribute_name) self.assertEqual(declarations._UNSPECIFIED, a.default) def test_dot(self): - a = declarations.SelfAttribute('.bar.baz') + a = declarations.SelfAttribute(".bar.baz") self.assertEqual(1, a.depth) - self.assertEqual('bar.baz', a.attribute_name) + self.assertEqual("bar.baz", a.attribute_name) self.assertEqual(declarations._UNSPECIFIED, a.default) def test_default(self): - a = declarations.SelfAttribute('bar.baz', 42) + a = declarations.SelfAttribute("bar.baz", 42) self.assertEqual(0, a.depth) - self.assertEqual('bar.baz', a.attribute_name) + self.assertEqual("bar.baz", a.attribute_name) self.assertEqual(42, a.default) def test_parent(self): - a = declarations.SelfAttribute('..bar.baz') + a = declarations.SelfAttribute("..bar.baz") self.assertEqual(2, a.depth) - self.assertEqual('bar.baz', a.attribute_name) + self.assertEqual("bar.baz", a.attribute_name) self.assertEqual(declarations._UNSPECIFIED, a.default) def test_grandparent(self): - a = declarations.SelfAttribute('...bar.baz') + a = declarations.SelfAttribute("...bar.baz") self.assertEqual(3, a.depth) - self.assertEqual('bar.baz', a.attribute_name) + self.assertEqual("bar.baz", a.attribute_name) self.assertEqual(declarations._UNSPECIFIED, a.default) @@ -138,7 +138,7 @@ def test_getter(self): class TransformerTestCase(unittest.TestCase): def test_transform(self): - t = declarations.Transformer(lambda x: x.upper(), 'foo') + t = declarations.Transformer(lambda x: x.upper(), "foo") self.assertEqual("FOO", utils.evaluate_declaration(t)) @@ -160,7 +160,7 @@ def foo(*args, **kwargs): self.assertEqual(2, len(call_params)) self.assertEqual(3, len(call_params[0])) # instance, step, context.value - self.assertEqual({'bar': 42}, call_params[1]) + self.assertEqual({"bar": 42}, call_params[1]) def test_decorator_simple(self): call_params = [] @@ -180,13 +180,13 @@ def foo(*args, **kwargs): self.assertEqual(2, len(call_params)) self.assertEqual(3, len(call_params[0])) # instance, step, context.value - self.assertEqual({'bar': 42}, call_params[1]) + self.assertEqual({"bar": 42}, call_params[1]) class FactoryWrapperTestCase(unittest.TestCase): def test_invalid_path(self): with self.assertRaises(ValueError): - declarations._FactoryWrapper('UnqualifiedSymbol') + declarations._FactoryWrapper("UnqualifiedSymbol") with self.assertRaises(ValueError): declarations._FactoryWrapper(42) @@ -195,11 +195,11 @@ def test_class(self): self.assertEqual(datetime.date, w.get()) def test_path(self): - w = declarations._FactoryWrapper('datetime.date') + w = declarations._FactoryWrapper("datetime.date") self.assertEqual(datetime.date, w.get()) def test_lazyness(self): - f = declarations._FactoryWrapper('factory.declarations.Sequence') + f = declarations._FactoryWrapper("factory.declarations.Sequence") self.assertEqual(None, f.factory) factory_class = f.get() @@ -208,7 +208,7 @@ def test_lazyness(self): def test_cache(self): """Ensure that _FactoryWrapper tries to import only once.""" orig_date = datetime.date - w = declarations._FactoryWrapper('datetime.date') + w = declarations._FactoryWrapper("datetime.date") self.assertEqual(None, w.factory) factory_class = w.get() @@ -233,54 +233,54 @@ def build(self, declaration, **params): def test_simplest_setup_and_call(self): obj = self.build( - declarations.PostGenerationMethodCall('method'), + declarations.PostGenerationMethodCall("method"), ) obj.method.assert_called_once_with() def test_call_with_method_args(self): obj = self.build( - declarations.PostGenerationMethodCall('method', 'data'), + declarations.PostGenerationMethodCall("method", "data"), ) - obj.method.assert_called_once_with('data') + obj.method.assert_called_once_with("data") def test_call_with_passed_extracted_string(self): obj = self.build( - declarations.PostGenerationMethodCall('method'), - post='data', + declarations.PostGenerationMethodCall("method"), + post="data", ) - obj.method.assert_called_once_with('data') + obj.method.assert_called_once_with("data") def test_call_with_passed_extracted_int(self): obj = self.build( - declarations.PostGenerationMethodCall('method'), + declarations.PostGenerationMethodCall("method"), post=1, ) obj.method.assert_called_once_with(1) def test_call_with_passed_extracted_iterable(self): obj = self.build( - declarations.PostGenerationMethodCall('method'), + declarations.PostGenerationMethodCall("method"), post=(1, 2, 3), ) obj.method.assert_called_once_with((1, 2, 3)) def test_call_with_method_kwargs(self): obj = self.build( - declarations.PostGenerationMethodCall('method', data='data'), + declarations.PostGenerationMethodCall("method", data="data"), ) - obj.method.assert_called_once_with(data='data') + obj.method.assert_called_once_with(data="data") def test_call_with_passed_kwargs(self): obj = self.build( - declarations.PostGenerationMethodCall('method'), - post__data='other', + declarations.PostGenerationMethodCall("method"), + post__data="other", ) - obj.method.assert_called_once_with(data='other') + obj.method.assert_called_once_with(data="other") def test_multi_call_with_multi_method_args(self): with self.assertRaises(errors.InvalidDeclarationError): self.build( - declarations.PostGenerationMethodCall('method', 'arg1', 'arg2'), + declarations.PostGenerationMethodCall("method", "arg1", "arg2"), ) @@ -301,19 +301,19 @@ class Meta: @helpers.post_generation def a1(*args, **kwargs): - postgen_results.append('a1') + postgen_results.append("a1") @helpers.post_generation def zz(*args, **kwargs): - postgen_results.append('zz') + postgen_results.append("zz") @helpers.post_generation def aa(*args, **kwargs): - postgen_results.append('aa') + postgen_results.append("aa") postgen_names = Ordered._meta.post_declarations.sorted() - self.assertEqual(postgen_names, ['a', 'z', 'a1', 'zz', 'aa']) + self.assertEqual(postgen_names, ["a", "z", "a1", "zz", "aa"]) # Test generation happens in desired order Ordered() - self.assertEqual(postgen_results, ['a1', 'zz', 'aa']) + self.assertEqual(postgen_results, ["a1", "zz", "aa"]) diff --git a/tests/test_dev_experience.py b/tests/test_dev_experience.py index ada91e5d..92201974 100644 --- a/tests/test_dev_experience.py +++ b/tests/test_dev_experience.py @@ -8,8 +8,8 @@ import factory import factory.errors -Country = collections.namedtuple('Country', ['name', 'continent', 'capital_city']) -City = collections.namedtuple('City', ['name', 'population']) +Country = collections.namedtuple("Country", ["name", "continent", "capital_city"]) +City = collections.namedtuple("City", ["name", "population"]) class DeclarationTests(unittest.TestCase): @@ -20,7 +20,7 @@ class CountryFactory(factory.Factory): class Meta: model = Country - name = factory.Faker('country') + name = factory.Faker("country") continent = "Antarctica" # Error here: pointing the SubFactory to a model, not a factory. @@ -29,8 +29,8 @@ class Meta: with self.assertRaises(factory.errors.AssociatedClassError) as raised: CountryFactory() - self.assertIn('City', str(raised.exception)) - self.assertIn('Country', str(raised.exception)) + self.assertIn("City", str(raised.exception)) + self.assertIn("Country", str(raised.exception)) def test_subfactory_to_factorylike_model(self): """A helpful error message occurs when pointing a subfactory to a model. @@ -46,7 +46,7 @@ class CountryFactory(factory.Factory): class Meta: model = Country - name = factory.Faker('country') + name = factory.Faker("country") continent = "Antarctica" # Error here: pointing the SubFactory to a model, not a factory. @@ -55,5 +55,5 @@ class Meta: with self.assertRaises(factory.errors.AssociatedClassError) as raised: CountryFactory() - self.assertIn('CityModel', str(raised.exception)) - self.assertIn('Country', str(raised.exception)) + self.assertIn("CityModel", str(raised.exception)) + self.assertIn("Country", str(raised.exception)) diff --git a/tests/test_django.py b/tests/test_django.py index 2c38cafa..eea475cd 100644 --- a/tests/test_django.py +++ b/tests/test_django.py @@ -24,7 +24,7 @@ Image = None # Setup Django before importing Django models. -os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'tests.djapp.settings') +os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tests.djapp.settings") django.setup() from .djapp import models # noqa:E402 isort:skip @@ -35,11 +35,11 @@ def setUpModule(): django_test_utils.setup_test_environment() runner_state = django_test_utils.setup_databases(verbosity=0, interactive=False) - test_state['runner_state'] = runner_state + test_state["runner_state"] = runner_state def tearDownModule(): - django_test_utils.teardown_databases(test_state['runner_state'], verbosity=0) + django_test_utils.teardown_databases(test_state["runner_state"], verbosity=0) django_test_utils.teardown_test_environment() @@ -53,7 +53,7 @@ class Meta: class StandardFactoryWithPKField(factory.django.DjangoModelFactory): class Meta: model = models.StandardModel - django_get_or_create = ('pk',) + django_get_or_create = ("pk",) foo = factory.Sequence(lambda n: "foo%d" % n) pk = None @@ -64,15 +64,15 @@ class Meta: model = models.NonIntegerPk foo = factory.Sequence(lambda n: "foo%d" % n) - bar = '' + bar = "" class MultifieldModelFactory(factory.django.DjangoModelFactory): class Meta: model = models.MultifieldModel - django_get_or_create = ['slug'] + django_get_or_create = ["slug"] - text = factory.Faker('text') + text = factory.Faker("text") class AbstractBaseFactory(factory.django.DjangoModelFactory): @@ -98,7 +98,7 @@ class Meta: model = models.ConcreteGrandSon -PASSWORD = 's0_s3cr3t' +PASSWORD = "s0_s3cr3t" class WithPasswordFactory(factory.django.DjangoModelFactory): @@ -144,7 +144,7 @@ class Meta: class ModelTests(django_test.TestCase): - databases = {'default', 'replica'} + databases = {"default", "replica"} def test_unset_model(self): class UnsetModelFactory(factory.django.DjangoModelFactory): @@ -157,11 +157,11 @@ def test_cross_database(self): class OtherDBFactory(factory.django.DjangoModelFactory): class Meta: model = models.StandardModel - database = 'replica' + database = "replica" obj = OtherDBFactory() self.assertFalse(models.StandardModel.objects.exists()) - self.assertEqual(obj, models.StandardModel.objects.using('replica').get()) + self.assertEqual(obj, models.StandardModel.objects.using("replica").get()) class DjangoPkSequenceTestCase(django_test.TestCase): @@ -171,40 +171,40 @@ def setUp(self): def test_pk_first(self): std = StandardFactory.build() - self.assertEqual('foo0', std.foo) + self.assertEqual("foo0", std.foo) def test_pk_many(self): std1 = StandardFactory.build() std2 = StandardFactory.build() - self.assertEqual('foo0', std1.foo) - self.assertEqual('foo1', std2.foo) + self.assertEqual("foo0", std1.foo) + self.assertEqual("foo1", std2.foo) def test_pk_creation(self): std1 = StandardFactory.create() - self.assertEqual('foo0', std1.foo) + self.assertEqual("foo0", std1.foo) self.assertEqual(1, std1.pk) StandardFactory.reset_sequence() std2 = StandardFactory.create() - self.assertEqual('foo0', std2.foo) + self.assertEqual("foo0", std2.foo) self.assertEqual(2, std2.pk) def test_pk_force_value(self): std1 = StandardFactory.create(pk=10) - self.assertEqual('foo0', std1.foo) # sequence is unrelated to pk + self.assertEqual("foo0", std1.foo) # sequence is unrelated to pk self.assertEqual(10, std1.pk) StandardFactory.reset_sequence() std2 = StandardFactory.create() - self.assertEqual('foo0', std2.foo) + self.assertEqual("foo0", std2.foo) self.assertEqual(11, std2.pk) class DjangoGetOrCreateTests(django_test.TestCase): def test_simple_call(self): - obj1 = MultifieldModelFactory(slug='slug1') - obj2 = MultifieldModelFactory(slug='slug1') - MultifieldModelFactory(slug='alt') + obj1 = MultifieldModelFactory(slug="slug1") + obj2 = MultifieldModelFactory(slug="slug1") + MultifieldModelFactory(slug="alt") self.assertEqual(obj1, obj2) self.assertEqual( @@ -223,7 +223,7 @@ def test_missing_arg(self): def test_multicall(self): objs = MultifieldModelFactory.create_batch( 6, - slug=factory.Iterator(['main', 'alt']), + slug=factory.Iterator(["main", "alt"]), ) self.assertEqual(6, len(objs)) self.assertEqual(2, len(set(objs))) @@ -262,20 +262,20 @@ def setUp(self): def test_no_pk(self): std = StandardFactoryWithPKField() self.assertIsNotNone(std.pk) - self.assertEqual('foo0', std.foo) + self.assertEqual("foo0", std.foo) def test_force_pk(self): std = StandardFactoryWithPKField(pk=42) self.assertIsNotNone(std.pk) - self.assertEqual('foo0', std.foo) + self.assertEqual("foo0", std.foo) def test_reuse_pk(self): - std1 = StandardFactoryWithPKField(foo='bar') + std1 = StandardFactoryWithPKField(foo="bar") self.assertIsNotNone(std1.pk) - std2 = StandardFactoryWithPKField(pk=std1.pk, foo='blah') + std2 = StandardFactoryWithPKField(pk=std1.pk, foo="blah") self.assertEqual(std1.pk, std2.pk) - self.assertEqual('bar', std2.foo) + self.assertEqual("bar", std2.foo) class DjangoModelLoadingTestCase(django_test.TestCase): @@ -285,14 +285,14 @@ class DjangoModelLoadingTestCase(django_test.TestCase): def test_loading(self): class ExampleFactory(factory.django.DjangoModelFactory): class Meta: - model = 'djapp.StandardModel' + model = "djapp.StandardModel" self.assertEqual(models.StandardModel, ExampleFactory._meta.get_model_class()) def test_building(self): class ExampleFactory(factory.django.DjangoModelFactory): class Meta: - model = 'djapp.StandardModel' + model = "djapp.StandardModel" e = ExampleFactory.build() self.assertEqual(models.StandardModel, e.__class__) @@ -305,7 +305,7 @@ def test_inherited_loading(self): class ExampleFactory(factory.django.DjangoModelFactory): class Meta: - model = 'djapp.StandardModel' + model = "djapp.StandardModel" class Example2Factory(ExampleFactory): pass @@ -321,13 +321,13 @@ def test_inherited_loading_and_sequence(self): class ExampleFactory(factory.django.DjangoModelFactory): class Meta: - model = 'djapp.StandardModel' + model = "djapp.StandardModel" foo = factory.Sequence(lambda n: n) class Example2Factory(ExampleFactory): class Meta: - model = 'djapp.StandardSon' + model = "djapp.StandardSon" e1 = ExampleFactory.build() e2 = Example2Factory.build() @@ -347,33 +347,33 @@ def setUp(self): def test_first(self): nonint = NonIntegerPkFactory.build() - self.assertEqual('foo0', nonint.foo) + self.assertEqual("foo0", nonint.foo) def test_many(self): nonint1 = NonIntegerPkFactory.build() nonint2 = NonIntegerPkFactory.build() - self.assertEqual('foo0', nonint1.foo) - self.assertEqual('foo1', nonint2.foo) + self.assertEqual("foo0", nonint1.foo) + self.assertEqual("foo1", nonint2.foo) def test_creation(self): nonint1 = NonIntegerPkFactory.create() - self.assertEqual('foo0', nonint1.foo) - self.assertEqual('foo0', nonint1.pk) + self.assertEqual("foo0", nonint1.foo) + self.assertEqual("foo0", nonint1.pk) NonIntegerPkFactory.reset_sequence() nonint2 = NonIntegerPkFactory.build() - self.assertEqual('foo0', nonint2.foo) + self.assertEqual("foo0", nonint2.foo) def test_force_pk(self): - nonint1 = NonIntegerPkFactory.create(pk='foo10') - self.assertEqual('foo10', nonint1.foo) - self.assertEqual('foo10', nonint1.pk) + nonint1 = NonIntegerPkFactory.create(pk="foo10") + self.assertEqual("foo10", nonint1.foo) + self.assertEqual("foo10", nonint1.pk) NonIntegerPkFactory.reset_sequence() nonint2 = NonIntegerPkFactory.create() - self.assertEqual('foo0', nonint2.foo) - self.assertEqual('foo0', nonint2.pk) + self.assertEqual("foo0", nonint2.foo) + self.assertEqual("foo0", nonint2.pk) class DjangoAbstractBaseSequenceTestCase(django_test.TestCase): @@ -414,37 +414,37 @@ class PointedFactory(factory.django.DjangoModelFactory): class Meta: model = models.PointedModel - foo = 'foo' + foo = "foo" class PointerFactory(factory.django.DjangoModelFactory): class Meta: model = models.PointerModel - bar = 'bar' - pointed = factory.SubFactory(PointedFactory, foo='new_foo') + bar = "bar" + pointed = factory.SubFactory(PointedFactory, foo="new_foo") class PointedRelatedFactory(PointedFactory): pointer = factory.RelatedFactory( PointerFactory, - factory_related_name='pointed', + factory_related_name="pointed", ) class Meta: skip_postgeneration_save = True class PointerExtraFactory(PointerFactory): - pointed__foo = 'extra_new_foo' + pointed__foo = "extra_new_foo" class PointedRelatedExtraFactory(PointedRelatedFactory): - pointer__bar = 'extra_new_bar' + pointer__bar = "extra_new_bar" class PointedRelatedWithTraitFactory(PointedFactory): class Params: with_pointer = factory.Trait( pointer=factory.RelatedFactory( PointerFactory, - factory_related_name='pointed', - bar='with_trait', + factory_related_name="pointed", + bar="with_trait", ) ) @@ -461,54 +461,54 @@ class Meta: def test_create_pointed(self): pointed = self.PointedFactory() self.assertEqual(pointed, models.PointedModel.objects.get()) - self.assertEqual(pointed.foo, 'foo') + self.assertEqual(pointed.foo, "foo") def test_create_pointer(self): pointer = self.PointerFactory() self.assertEqual(pointer.pointed, models.PointedModel.objects.get()) - self.assertEqual(pointer.pointed.foo, 'new_foo') + self.assertEqual(pointer.pointed.foo, "new_foo") def test_create_pointer_with_deep_context(self): - pointer = self.PointerFactory(pointed__foo='new_new_foo') + pointer = self.PointerFactory(pointed__foo="new_new_foo") self.assertEqual(pointer, models.PointerModel.objects.get()) - self.assertEqual(pointer.bar, 'bar') + self.assertEqual(pointer.bar, "bar") self.assertEqual(pointer.pointed, models.PointedModel.objects.get()) - self.assertEqual(pointer.pointed.foo, 'new_new_foo') + self.assertEqual(pointer.pointed.foo, "new_new_foo") def test_create_pointed_related(self): pointed = self.PointedRelatedFactory() self.assertEqual(pointed, models.PointedModel.objects.get()) - self.assertEqual(pointed.foo, 'foo') + self.assertEqual(pointed.foo, "foo") self.assertEqual(pointed.pointer, models.PointerModel.objects.get()) - self.assertEqual(pointed.pointer.bar, 'bar') + self.assertEqual(pointed.pointer.bar, "bar") def test_create_pointed_related_with_deep_context(self): - pointed = self.PointedRelatedFactory(pointer__bar='new_new_bar') + pointed = self.PointedRelatedFactory(pointer__bar="new_new_bar") self.assertEqual(pointed, models.PointedModel.objects.get()) - self.assertEqual(pointed.foo, 'foo') + self.assertEqual(pointed.foo, "foo") self.assertEqual(pointed.pointer, models.PointerModel.objects.get()) - self.assertEqual(pointed.pointer.bar, 'new_new_bar') + self.assertEqual(pointed.pointer.bar, "new_new_bar") def test_create_pointer_extra(self): pointer = self.PointerExtraFactory() self.assertEqual(pointer, models.PointerModel.objects.get()) - self.assertEqual(pointer.bar, 'bar') + self.assertEqual(pointer.bar, "bar") self.assertEqual(pointer.pointed, models.PointedModel.objects.get()) - self.assertEqual(pointer.pointed.foo, 'extra_new_foo') + self.assertEqual(pointer.pointed.foo, "extra_new_foo") def test_create_pointed_related_extra(self): pointed = self.PointedRelatedExtraFactory() self.assertEqual(pointed, models.PointedModel.objects.get()) - self.assertEqual(pointed.foo, 'foo') + self.assertEqual(pointed.foo, "foo") self.assertEqual(pointed.pointer, models.PointerModel.objects.get()) - self.assertEqual(pointed.pointer.bar, 'extra_new_bar') + self.assertEqual(pointed.pointer.bar, "extra_new_bar") def test_create_pointed_related_with_trait(self): pointed = self.PointedRelatedWithTraitFactory(with_pointer=True) self.assertEqual(pointed, models.PointedModel.objects.get()) - self.assertEqual(pointed.foo, 'foo') + self.assertEqual(pointed.foo, "foo") self.assertEqual(pointed.pointer, models.PointerModel.objects.get()) - self.assertEqual(pointed.pointer.bar, 'with_trait') + self.assertEqual(pointed.pointer.bar, "with_trait") class DjangoPasswordTestCase(django_test.TestCase): @@ -517,7 +517,7 @@ def test_build(self): self.assertTrue(check_password(PASSWORD, u.pw)) def test_build_with_kwargs(self): - password = 'V3R¥.S€C®€T' + password = "V3R¥.S€C®€T" u = WithPasswordFactory.build(pw=password) self.assertTrue(check_password(password, u.pw)) @@ -536,37 +536,37 @@ def tearDown(self): def test_default_build(self): o = WithFileFactory.build() self.assertIsNone(o.pk) - self.assertEqual(b'', o.afile.read()) - self.assertEqual('example.dat', o.afile.name) + self.assertEqual(b"", o.afile.read()) + self.assertEqual("example.dat", o.afile.name) o.save() - self.assertEqual('django/example.dat', o.afile.name) + self.assertEqual("django/example.dat", o.afile.name) def test_default_create(self): o = WithFileFactory.create() self.assertIsNotNone(o.pk) with o.afile as f: - self.assertEqual(b'', f.read()) - self.assertEqual('django/example.dat', o.afile.name) + self.assertEqual(b"", f.read()) + self.assertEqual("django/example.dat", o.afile.name) def test_with_content(self): - o = WithFileFactory.build(afile__data='foo') + o = WithFileFactory.build(afile__data="foo") self.assertIsNone(o.pk) # Django only allocates the full path on save() o.save() with o.afile as f: - self.assertEqual(b'foo', f.read()) - self.assertEqual('django/example.dat', o.afile.name) + self.assertEqual(b"foo", f.read()) + self.assertEqual("django/example.dat", o.afile.name) def test_with_file(self): - with open(testdata.TESTFILE_PATH, 'rb') as f: + with open(testdata.TESTFILE_PATH, "rb") as f: o = WithFileFactory.build(afile__from_file=f) o.save() with o.afile as f: - self.assertEqual(b'example_data\n', f.read()) - self.assertEqual('django/example.data', o.afile.name) + self.assertEqual(b"example_data\n", f.read()) + self.assertEqual("django/example.data", o.afile.name) def test_with_path(self): o = WithFileFactory.build(afile__from_path=testdata.TESTFILE_PATH) @@ -576,21 +576,21 @@ def test_with_path(self): # Django only allocates the full path on save() o.save() f.seek(0) - self.assertEqual(b'example_data\n', f.read()) - self.assertEqual('django/example.data', o.afile.name) + self.assertEqual(b"example_data\n", f.read()) + self.assertEqual("django/example.data", o.afile.name) def test_with_file_empty_path(self): - with open(testdata.TESTFILE_PATH, 'rb') as f: + with open(testdata.TESTFILE_PATH, "rb") as f: o = WithFileFactory.build( afile__from_file=f, - afile__from_path='', + afile__from_path="", ) # Django only allocates the full path on save() o.save() with o.afile as f: - self.assertEqual(b'example_data\n', f.read()) - self.assertEqual('django/example.data', o.afile.name) + self.assertEqual(b"example_data\n", f.read()) + self.assertEqual("django/example.data", o.afile.name) def test_with_path_empty_file(self): o = WithFileFactory.build( @@ -603,20 +603,20 @@ def test_with_path_empty_file(self): # Django only allocates the full path on save() o.save() f.seek(0) - self.assertEqual(b'example_data\n', f.read()) - self.assertEqual('django/example.data', o.afile.name) + self.assertEqual(b"example_data\n", f.read()) + self.assertEqual("django/example.data", o.afile.name) def test_error_both_file_and_path(self): with self.assertRaises(ValueError): WithFileFactory.build( - afile__from_file='fakefile', + afile__from_file="fakefile", afile__from_path=testdata.TESTFILE_PATH, ) def test_override_filename_with_path(self): o = WithFileFactory.build( afile__from_path=testdata.TESTFILE_PATH, - afile__filename='example.foo', + afile__filename="example.foo", ) self.assertIsNone(o.pk) @@ -624,23 +624,23 @@ def test_override_filename_with_path(self): # Django only allocates the full path on save() o.save() f.seek(0) - self.assertEqual(b'example_data\n', f.read()) - self.assertEqual('django/example.foo', o.afile.name) + self.assertEqual(b"example_data\n", f.read()) + self.assertEqual("django/example.foo", o.afile.name) def test_existing_file(self): o1 = WithFileFactory.build(afile__from_path=testdata.TESTFILE_PATH) with o1.afile: o1.save() - self.assertEqual('django/example.data', o1.afile.name) + self.assertEqual("django/example.data", o1.afile.name) o2 = WithFileFactory.build(afile__from_file=o1.afile) self.assertIsNone(o2.pk) with o2.afile as f: o2.save() f.seek(0) - self.assertEqual(b'example_data\n', f.read()) - self.assertNotEqual('django/example.data', o2.afile.name) - self.assertRegex(o2.afile.name, r'django/example_\w+.data') + self.assertEqual(b"example_data\n", f.read()) + self.assertNotEqual("django/example.data", o2.afile.name) + self.assertRegex(o2.afile.name, r"django/example_\w+.data") def test_no_file(self): o = WithFileFactory.build(afile=None) @@ -656,11 +656,11 @@ class Meta: class Params: with_bar = factory.Trait( - foo='bar', + foo="bar", ) o = WithDefaultValueFactory() - self.assertEqual('', o.foo) + self.assertEqual("", o.foo) def test_pointing_with_traits_using_same_name(self): class PointedFactory(factory.django.DjangoModelFactory): @@ -669,7 +669,7 @@ class Meta: class Params: with_bar = factory.Trait( - foo='bar', + foo="bar", ) class PointerFactory(factory.django.DjangoModelFactory): @@ -680,13 +680,13 @@ class Meta: class Params: with_bar = factory.Trait( - bar='bar', + bar="bar", pointed__with_bar=True, ) o = PointerFactory(with_bar=True) - self.assertEqual('bar', o.bar) - self.assertEqual('bar', o.pointed.foo) + self.assertEqual("bar", o.bar) + self.assertEqual("bar", o.pointed.foo) class DjangoFakerTestCase(django_test.TestCase): @@ -695,7 +695,7 @@ class StandardModelFactory(factory.django.DjangoModelFactory): class Meta: model = models.StandardModel - foo = factory.Faker('pystr') + foo = factory.Faker("pystr") o1 = StandardModelFactory() o2 = StandardModelFactory() @@ -717,7 +717,7 @@ def test_default_build(self): self.assertEqual(100, o.animage.width) self.assertEqual(100, o.animage.height) - self.assertEqual('django/example.jpg', o.animage.name) + self.assertEqual("django/example.jpg", o.animage.name) def test_default_create(self): o = WithImageFactory.create() @@ -726,72 +726,72 @@ def test_default_create(self): self.assertEqual(100, o.animage.width) self.assertEqual(100, o.animage.height) - self.assertEqual('django/example.jpg', o.animage.name) + self.assertEqual("django/example.jpg", o.animage.name) def test_complex_create(self): o = WithImageFactory.create( size=10, - animage__filename=factory.Sequence(lambda n: 'img%d.jpg' % n), + animage__filename=factory.Sequence(lambda n: "img%d.jpg" % n), __sequence=42, - animage__width=factory.SelfAttribute('..size'), - animage__height=factory.SelfAttribute('width'), + animage__width=factory.SelfAttribute("..size"), + animage__height=factory.SelfAttribute("width"), ) self.assertIsNotNone(o.pk) - self.assertEqual('django/img42.jpg', o.animage.name) + self.assertEqual("django/img42.jpg", o.animage.name) def test_with_content(self): - o = WithImageFactory.build(animage__width=13, animage__color='red') + o = WithImageFactory.build(animage__width=13, animage__color="red") self.assertIsNone(o.pk) o.save() self.assertEqual(13, o.animage.width) self.assertEqual(13, o.animage.height) - self.assertEqual('django/example.jpg', o.animage.name) + self.assertEqual("django/example.jpg", o.animage.name) with Image.open(os.path.join(settings.MEDIA_ROOT, o.animage.name)) as i: colors = i.getcolors() # 169 pixels with rgb(254, 0, 0) self.assertEqual([(169, (254, 0, 0))], colors) - self.assertEqual('JPEG', i.format) + self.assertEqual("JPEG", i.format) def test_rgba_image(self): o = WithImageFactory.create( - animage__palette='RGBA', - animage__format='PNG', + animage__palette="RGBA", + animage__format="PNG", ) self.assertIsNotNone(o.pk) with Image.open(os.path.join(settings.MEDIA_ROOT, o.animage.name)) as i: - self.assertEqual('RGBA', i.mode) + self.assertEqual("RGBA", i.mode) def test_gif(self): o = WithImageFactory.build( animage__width=13, - animage__color='blue', - animage__format='GIF', + animage__color="blue", + animage__format="GIF", ) self.assertIsNone(o.pk) o.save() self.assertEqual(13, o.animage.width) self.assertEqual(13, o.animage.height) - self.assertEqual('django/example.jpg', o.animage.name) + self.assertEqual("django/example.jpg", o.animage.name) with Image.open(os.path.join(settings.MEDIA_ROOT, o.animage.name)) as i: - colors = i.convert('RGB').getcolors() + colors = i.convert("RGB").getcolors() # 169 pixels with rgb(0, 0, 255) self.assertEqual([(169, (0, 0, 255))], colors) - self.assertEqual('GIF', i.format) + self.assertEqual("GIF", i.format) def test_with_file(self): - with open(testdata.TESTIMAGE_PATH, 'rb') as f: + with open(testdata.TESTIMAGE_PATH, "rb") as f: o = WithImageFactory.build(animage__from_file=f) o.save() with o.animage as f: # Image file for a 42x42 green jpeg: 301 bytes long. self.assertEqual(301, len(f.read())) - self.assertEqual('django/example.jpeg', o.animage.name) + self.assertEqual("django/example.jpeg", o.animage.name) def test_with_path(self): o = WithImageFactory.build(animage__from_path=testdata.TESTIMAGE_PATH) @@ -801,20 +801,20 @@ def test_with_path(self): f.seek(0) # Image file for a 42x42 green jpeg: 301 bytes long. self.assertEqual(301, len(f.read())) - self.assertEqual('django/example.jpeg', o.animage.name) + self.assertEqual("django/example.jpeg", o.animage.name) def test_with_file_empty_path(self): - with open(testdata.TESTIMAGE_PATH, 'rb') as f: + with open(testdata.TESTIMAGE_PATH, "rb") as f: o = WithImageFactory.build( animage__from_file=f, - animage__from_path='', + animage__from_path="", ) o.save() with o.animage as f: # Image file for a 42x42 green jpeg: 301 bytes long. self.assertEqual(301, len(f.read())) - self.assertEqual('django/example.jpeg', o.animage.name) + self.assertEqual("django/example.jpeg", o.animage.name) def test_with_path_empty_file(self): o = WithImageFactory.build( @@ -827,19 +827,19 @@ def test_with_path_empty_file(self): f.seek(0) # Image file for a 42x42 green jpeg: 301 bytes long. self.assertEqual(301, len(f.read())) - self.assertEqual('django/example.jpeg', o.animage.name) + self.assertEqual("django/example.jpeg", o.animage.name) def test_error_both_file_and_path(self): with self.assertRaises(ValueError): WithImageFactory.build( - animage__from_file='fakefile', + animage__from_file="fakefile", animage__from_path=testdata.TESTIMAGE_PATH, ) def test_override_filename_with_path(self): o = WithImageFactory.build( animage__from_path=testdata.TESTIMAGE_PATH, - animage__filename='example.foo', + animage__filename="example.foo", ) self.assertIsNone(o.pk) with o.animage as f: @@ -847,7 +847,7 @@ def test_override_filename_with_path(self): f.seek(0) # Image file for a 42x42 green jpeg: 301 bytes long. self.assertEqual(301, len(f.read())) - self.assertEqual('django/example.foo', o.animage.name) + self.assertEqual("django/example.foo", o.animage.name) def test_existing_file(self): o1 = WithImageFactory.build(animage__from_path=testdata.TESTIMAGE_PATH) @@ -861,8 +861,8 @@ def test_existing_file(self): with o2.animage as f: # Image file for a 42x42 green jpeg: 301 bytes long. self.assertEqual(301, len(f.read())) - self.assertNotEqual('django/example.jpeg', o2.animage.name) - self.assertRegex(o2.animage.name, r'django/example_\w+.jpeg') + self.assertNotEqual("django/example.jpeg", o2.animage.name) + self.assertRegex(o2.animage.name, r"django/example_\w+.jpeg") def test_no_file(self): o = WithImageFactory.build(animage=None) @@ -870,9 +870,9 @@ def test_no_file(self): self.assertFalse(o.animage) def _img_test_func(self): - img = Image.new('RGB', (32, 32), 'blue') + img = Image.new("RGB", (32, 32), "blue") img_io = io.BytesIO() - img.save(img_io, format='JPEG') + img.save(img_io, format="JPEG") img_io.seek(0) return img_io @@ -880,7 +880,7 @@ def test_with_func(self): o = WithImageFactory.build(animage__from_func=self._img_test_func) self.assertIsNone(o.pk) i = Image.open(o.animage.file) - self.assertEqual('JPEG', i.format) + self.assertEqual("JPEG", i.format) self.assertEqual(32, i.width) self.assertEqual(32, i.height) @@ -1020,7 +1020,7 @@ def generate(cls): class PreventChainedSignalsTestCase(django_test.TestCase): def setUp(self): - self.post_save_mock = mock.Mock(side_effect=Exception('BOOM!')) + self.post_save_mock = mock.Mock(side_effect=Exception("BOOM!")) signals.post_save.connect(self.post_save_mock, models.PointedModel) def tearDown(self): @@ -1056,7 +1056,7 @@ class Meta: class DjangoCustomManagerTestCase(django_test.TestCase): def test_extra_args(self): # Our CustomManager will remove the 'arg=' argument. - WithCustomManagerFactory(arg='foo') + WithCustomManagerFactory(arg="foo") def test_with_manager_on_abstract(self): class ObjFactory(factory.django.DjangoModelFactory): @@ -1065,7 +1065,7 @@ class Meta: # Our CustomManager will remove the 'arg=' argument, # invalid for the actual model. - ObjFactory.create(arg='invalid') + ObjFactory.create(arg="invalid") class DjangoModelFactoryDuplicateSaveDeprecationTest(django_test.TestCase): diff --git a/tests/test_docs_internals.py b/tests/test_docs_internals.py index 04c5d748..276fbd18 100644 --- a/tests/test_docs_internals.py +++ b/tests/test_docs_internals.py @@ -52,7 +52,7 @@ def log(self, action, timestamp): class UserLog: - ACTIONS = ['create', 'update', 'disable'] + ACTIONS = ["create", "update", "disable"] def __init__(self, user, action, timestamp): self.user = user @@ -66,7 +66,7 @@ class UserLogFactory(factory.Factory): class Meta: model = UserLog - user = factory.SubFactory('test_docs_internals.UserFactory') + user = factory.SubFactory("test_docs_internals.UserFactory") timestamp = factory.fuzzy.FuzzyDateTime( datetime.datetime(2000, 1, 1, tzinfo=datetime.timezone.utc), ) @@ -87,17 +87,17 @@ class Params: enabled = True # Classic fields - username = factory.Faker('user_name') - full_name = factory.Faker('name') + username = factory.Faker("user_name") + full_name = factory.Faker("name") creation_date = factory.fuzzy.FuzzyDateTime( datetime.datetime(2000, 1, 1, tzinfo=datetime.timezone.utc), datetime.datetime(2015, 12, 31, 20, tzinfo=datetime.timezone.utc), ) # Conditional flags - is_active = factory.SelfAttribute('enabled') + is_active = factory.SelfAttribute("enabled") deactivation_date = factory.Maybe( - 'enabled', + "enabled", None, factory.fuzzy.FuzzyDateTime( datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) @@ -110,9 +110,9 @@ class Params: # Related logs creation_log = factory.RelatedFactory( UserLogFactory, - factory_related_name='user', - action='create', - timestamp=factory.SelfAttribute('user.creation_date'), + factory_related_name="user", + action="create", + timestamp=factory.SelfAttribute("user.creation_date"), ) @@ -128,6 +128,6 @@ def test_simple_usage(self): # We should have one log self.assertEqual(1, len(user.logs)) # And it should be a 'create' action linked to the user's creation_date - self.assertEqual('create', user.logs[0].action) + self.assertEqual("create", user.logs[0].action) self.assertEqual(user, user.logs[0].user) self.assertEqual(user.creation_date, user.logs[0].timestamp) diff --git a/tests/test_faker.py b/tests/test_faker.py index 1e94bfe4..f2a16708 100644 --- a/tests/test_faker.py +++ b/tests/test_faker.py @@ -49,8 +49,8 @@ def _setup_advanced_mock_faker(self, locale=None, **handlers): def test_simple_biased(self): self._setup_mock_faker(name="John Doe") - faker_field = factory.Faker('name') - self.assertEqual("John Doe", faker_field.evaluate(None, None, {'locale': None})) + faker_field = factory.Faker("name") + self.assertEqual("John Doe", faker_field.evaluate(None, None, {"locale": None})) def test_full_factory(self): class Profile: @@ -63,9 +63,9 @@ class ProfileFactory(factory.Factory): class Meta: model = Profile - first_name = factory.Faker('first_name') - last_name = factory.Faker('last_name', locale='fr_FR') - email = factory.Faker('email') + first_name = factory.Faker("first_name") + last_name = factory.Faker("last_name", locale="fr_FR") + email = factory.Faker("email") self._setup_mock_faker( first_name="John", @@ -76,13 +76,13 @@ class Meta: first_name="Jean", last_name="Valjean", email="jvaljean@exemple.fr", - locale='fr_FR', + locale="fr_FR", ) profile = ProfileFactory() self.assertEqual("John", profile.first_name) self.assertEqual("Valjean", profile.last_name) - self.assertEqual('john.doe@example.org', profile.email) + self.assertEqual("john.doe@example.org", profile.email) def test_override_locale(self): class Profile: @@ -94,22 +94,22 @@ class ProfileFactory(factory.Factory): class Meta: model = Profile - first_name = factory.Faker('first_name') - last_name = factory.Faker('last_name', locale='fr_FR') + first_name = factory.Faker("first_name") + last_name = factory.Faker("last_name", locale="fr_FR") self._setup_mock_faker(first_name="John", last_name="Doe") - self._setup_mock_faker(first_name="Jean", last_name="Valjean", locale='fr_FR') + self._setup_mock_faker(first_name="Jean", last_name="Valjean", locale="fr_FR") self._setup_mock_faker( first_name="Johannes", last_name="Brahms", - locale='de_DE', + locale="de_DE", ) profile = ProfileFactory() self.assertEqual("John", profile.first_name) self.assertEqual("Valjean", profile.last_name) - with factory.Faker.override_default_locale('de_DE'): + with factory.Faker.override_default_locale("de_DE"): profile = ProfileFactory() self.assertEqual("Johannes", profile.first_name) self.assertEqual("Valjean", profile.last_name) @@ -128,19 +128,19 @@ class FaceFactory(factory.Factory): class Meta: model = Face - smiley = factory.Faker('smiley') - french_smiley = factory.Faker('smiley', locale='fr_FR') + smiley = factory.Faker("smiley") + french_smiley = factory.Faker("smiley", locale="fr_FR") class SmileyProvider(faker.providers.BaseProvider): def smiley(self): - return ':)' + return ":)" class FrenchSmileyProvider(faker.providers.BaseProvider): def smiley(self): - return '(:' + return "(:" factory.Faker.add_provider(SmileyProvider) - factory.Faker.add_provider(FrenchSmileyProvider, 'fr_FR') + factory.Faker.add_provider(FrenchSmileyProvider, "fr_FR") face = FaceFactory() self.assertEqual(":)", face.smiley) @@ -148,7 +148,7 @@ def smiley(self): def test_faker_customization(self): """Factory declarations in Faker parameters should be accepted.""" - Trip = collections.namedtuple('Trip', ['departure', 'transfer', 'arrival']) + Trip = collections.namedtuple("Trip", ["departure", "transfer", "arrival"]) may_4th = datetime.date(1977, 5, 4) may_25th = datetime.date(1977, 5, 25) @@ -161,9 +161,9 @@ class Meta: departure = may_4th arrival = may_25th transfer = factory.Faker( - 'date_between_dates', - start_date=factory.SelfAttribute('..departure'), - end_date=factory.SelfAttribute('..arrival'), + "date_between_dates", + start_date=factory.SelfAttribute("..departure"), + end_date=factory.SelfAttribute("..arrival"), ) def fake_select_date(start_date, end_date): diff --git a/tests/test_fuzzy.py b/tests/test_fuzzy.py index 131132d2..4f7081be 100644 --- a/tests/test_fuzzy.py +++ b/tests/test_fuzzy.py @@ -36,7 +36,7 @@ def test_mock(self): d = fuzzy.FuzzyChoice(options) - with mock.patch('factory.random.randgen.choice', fake_choice): + with mock.patch("factory.random.randgen.choice", fake_choice): res = utils.evaluate_declaration(d) self.assertEqual(6, res) @@ -73,7 +73,7 @@ def __iter__(self): self.assertTrue(opts.unrolled) def test_getter(self): - options = [('a', 1), ('b', 2), ('c', 3)] + options = [("a", 1), ("b", 2), ("c", 3)] d = fuzzy.FuzzyChoice(options, getter=lambda x: x[1]) res = utils.evaluate_declaration(d) self.assertIn(res, [1, 2, 3]) @@ -97,7 +97,7 @@ def test_biased(self): fuzz = fuzzy.FuzzyInteger(2, 8) - with mock.patch('factory.random.randgen.randrange', fake_randrange): + with mock.patch("factory.random.randgen.randrange", fake_randrange): res = utils.evaluate_declaration(fuzz) self.assertEqual((2 + 8 + 1) * 1, res) @@ -107,7 +107,7 @@ def test_biased_high_only(self): fuzz = fuzzy.FuzzyInteger(8) - with mock.patch('factory.random.randgen.randrange', fake_randrange): + with mock.patch("factory.random.randgen.randrange", fake_randrange): res = utils.evaluate_declaration(fuzz) self.assertEqual((0 + 8 + 1) * 1, res) @@ -117,7 +117,7 @@ def test_biased_with_step(self): fuzz = fuzzy.FuzzyInteger(5, 8, 3) - with mock.patch('factory.random.randgen.randrange', fake_randrange): + with mock.patch("factory.random.randgen.randrange", fake_randrange): res = utils.evaluate_declaration(fuzz) self.assertEqual((5 + 8 + 1) * 3, res) @@ -130,7 +130,7 @@ def test_definition(self): for _i in range(20): res = utils.evaluate_declaration(fuzz) self.assertTrue( - decimal.Decimal('2.0') <= res <= decimal.Decimal('3.0'), + decimal.Decimal("2.0") <= res <= decimal.Decimal("3.0"), "value %d is not between 2.0 and 3.0" % res, ) @@ -138,7 +138,7 @@ def test_definition(self): for _i in range(20): res = utils.evaluate_declaration(fuzz) self.assertTrue( - decimal.Decimal('0.0') <= res <= decimal.Decimal('4.0'), + decimal.Decimal("0.0") <= res <= decimal.Decimal("4.0"), "value %d is not between 0.0 and 4.0" % res, ) @@ -146,7 +146,7 @@ def test_definition(self): for _i in range(20): res = utils.evaluate_declaration(fuzz) self.assertTrue( - decimal.Decimal('1.0') <= res <= decimal.Decimal('4.0'), + decimal.Decimal("1.0") <= res <= decimal.Decimal("4.0"), "value %d is not between 1.0 and 4.0" % res, ) self.assertTrue(res.as_tuple().exponent, -5) @@ -156,31 +156,31 @@ def test_biased(self): fuzz = fuzzy.FuzzyDecimal(2.0, 8.0) - with mock.patch('factory.random.randgen.uniform', fake_uniform): + with mock.patch("factory.random.randgen.uniform", fake_uniform): res = utils.evaluate_declaration(fuzz) - self.assertEqual(decimal.Decimal('10.0'), res) + self.assertEqual(decimal.Decimal("10.0"), res) def test_biased_high_only(self): fake_uniform = lambda low, high: low + high fuzz = fuzzy.FuzzyDecimal(8.0) - with mock.patch('factory.random.randgen.uniform', fake_uniform): + with mock.patch("factory.random.randgen.uniform", fake_uniform): res = utils.evaluate_declaration(fuzz) - self.assertEqual(decimal.Decimal('8.0'), res) + self.assertEqual(decimal.Decimal("8.0"), res) def test_precision(self): fake_uniform = lambda low, high: low + high + 0.001 fuzz = fuzzy.FuzzyDecimal(8.0, precision=3) - with mock.patch('factory.random.randgen.uniform', fake_uniform): + with mock.patch("factory.random.randgen.uniform", fake_uniform): res = utils.evaluate_declaration(fuzz) self.assertEqual( - decimal.Decimal('8.001').quantize(decimal.Decimal(10) ** -3), + decimal.Decimal("8.001").quantize(decimal.Decimal(10) ** -3), res, ) @@ -230,7 +230,7 @@ def test_biased(self): fuzz = fuzzy.FuzzyFloat(2.0, 8.0) - with mock.patch('factory.random.randgen.uniform', fake_uniform): + with mock.patch("factory.random.randgen.uniform", fake_uniform): res = utils.evaluate_declaration(fuzz) self.assertEqual(10.0, res) @@ -240,7 +240,7 @@ def test_biased_high_only(self): fuzz = fuzzy.FuzzyFloat(8.0) - with mock.patch('factory.random.randgen.uniform', fake_uniform): + with mock.patch("factory.random.randgen.uniform", fake_uniform): res = utils.evaluate_declaration(fuzz) self.assertEqual(8.0, res) @@ -250,7 +250,7 @@ def test_default_precision(self): fuzz = fuzzy.FuzzyFloat(8.0) - with mock.patch('factory.random.randgen.uniform', fake_uniform): + with mock.patch("factory.random.randgen.uniform", fake_uniform): res = utils.evaluate_declaration(fuzz) self.assertEqual(8.00000000000001, res) @@ -260,7 +260,7 @@ def test_precision(self): fuzz = fuzzy.FuzzyFloat(8.0, precision=4) - with mock.patch('factory.random.randgen.uniform', fake_uniform): + with mock.patch("factory.random.randgen.uniform", fake_uniform): res = utils.evaluate_declaration(fuzz) self.assertEqual(8.001, res) @@ -308,7 +308,7 @@ def test_biased(self): fake_randint = lambda low, high: (low + high) // 2 fuzz = fuzzy.FuzzyDate(self.jan1, self.jan31) - with mock.patch('factory.random.randgen.randint', fake_randint): + with mock.patch("factory.random.randgen.randint", fake_randint): res = utils.evaluate_declaration(fuzz) self.assertEqual(datetime.date(2013, 1, 16), res) @@ -319,7 +319,7 @@ def test_biased_partial(self): fuzz = fuzzy.FuzzyDate(self.jan1) fake_randint = lambda low, high: (low + high) // 2 - with mock.patch('factory.random.randgen.randint', fake_randint): + with mock.patch("factory.random.randgen.randint", fake_randint): res = utils.evaluate_declaration(fuzz) self.assertEqual(datetime.date(2013, 1, 2), res) @@ -432,7 +432,7 @@ def test_biased(self): fake_randint = lambda low, high: (low + high) // 2 fuzz = fuzzy.FuzzyNaiveDateTime(self.jan1, self.jan31) - with mock.patch('factory.random.randgen.randint', fake_randint): + with mock.patch("factory.random.randgen.randint", fake_randint): res = utils.evaluate_declaration(fuzz) self.assertEqual(datetime.datetime(2013, 1, 16), res) @@ -443,7 +443,7 @@ def test_biased_partial(self): fuzz = fuzzy.FuzzyNaiveDateTime(self.jan1) fake_randint = lambda low, high: (low + high) // 2 - with mock.patch('factory.random.randgen.randint', fake_randint): + with mock.patch("factory.random.randgen.randint", fake_randint): res = utils.evaluate_declaration(fuzz) self.assertEqual(datetime.datetime(2013, 1, 2), res) @@ -550,7 +550,7 @@ def test_biased(self): fake_randint = lambda low, high: (low + high) // 2 fuzz = fuzzy.FuzzyDateTime(self.jan1, self.jan31) - with mock.patch('factory.random.randgen.randint', fake_randint): + with mock.patch("factory.random.randgen.randint", fake_randint): res = utils.evaluate_declaration(fuzz) self.assertEqual( @@ -564,7 +564,7 @@ def test_biased_partial(self): fuzz = fuzzy.FuzzyDateTime(self.jan1) fake_randint = lambda low, high: (low + high) // 2 - with mock.patch('factory.random.randgen.randint', fake_randint): + with mock.patch("factory.random.randgen.randint", fake_randint): res = utils.evaluate_declaration(fuzz) self.assertEqual( @@ -575,12 +575,12 @@ def test_biased_partial(self): class FuzzyTextTestCase(unittest.TestCase): def test_unbiased(self): - chars = ['a', 'b', 'c'] - fuzz = fuzzy.FuzzyText(prefix='pre', suffix='post', chars=chars, length=12) + chars = ["a", "b", "c"] + fuzz = fuzzy.FuzzyText(prefix="pre", suffix="post", chars=chars, length=12) res = utils.evaluate_declaration(fuzz) - self.assertEqual('pre', res[:3]) - self.assertEqual('post', res[-4:]) + self.assertEqual("pre", res[:3]) + self.assertEqual("post", res[-4:]) self.assertEqual(3 + 12 + 4, len(res)) for char in res[3:-4]: @@ -589,18 +589,18 @@ def test_unbiased(self): def test_mock(self): fake_choice = lambda chars: chars[0] - chars = ['a', 'b', 'c'] - fuzz = fuzzy.FuzzyText(prefix='pre', suffix='post', chars=chars, length=4) - with mock.patch('factory.random.randgen.choice', fake_choice): + chars = ["a", "b", "c"] + fuzz = fuzzy.FuzzyText(prefix="pre", suffix="post", chars=chars, length=4) + with mock.patch("factory.random.randgen.choice", fake_choice): res = utils.evaluate_declaration(fuzz) - self.assertEqual('preaaaapost', res) + self.assertEqual("preaaaapost", res) def test_generator(self): def options(): - yield 'a' - yield 'b' - yield 'c' + yield "a" + yield "b" + yield "c" fuzz = fuzzy.FuzzyText(chars=options(), length=12) res = utils.evaluate_declaration(fuzz) @@ -608,7 +608,7 @@ def options(): self.assertEqual(12, len(res)) for char in res: - self.assertIn(char, ['a', 'b', 'c']) + self.assertIn(char, ["a", "b", "c"]) class FuzzyRandomTestCase(unittest.TestCase): @@ -633,7 +633,7 @@ def test_seeding_warning(self): fuzz = fuzzy.FuzzyDate(datetime.date(2013, 1, 1)) utils.evaluate_declaration(fuzz) self.assertEqual(1, len(w)) - self.assertIn('factory_boy/issues/331', str(w[-1].message)) + self.assertIn("factory_boy/issues/331", str(w[-1].message)) def test_reset_state(self): fuzz = fuzzy.FuzzyInteger(1, 1000) diff --git a/tests/test_helpers.py b/tests/test_helpers.py index 2c187448..4e01438e 100644 --- a/tests/test_helpers.py +++ b/tests/test_helpers.py @@ -14,39 +14,39 @@ def test_default_logger(self): stream1 = io.StringIO() stream2 = io.StringIO() - logger = logging.getLogger('factory.test') + logger = logging.getLogger("factory.test") h = logging.StreamHandler(stream1) h.setLevel(logging.INFO) logger.addHandler(h) # Non-debug: no text gets out logger.debug("Test") - self.assertEqual('', stream1.getvalue()) + self.assertEqual("", stream1.getvalue()) with helpers.debug(stream=stream2): # Debug: text goes to new stream only logger.debug("Test2") - self.assertEqual('', stream1.getvalue()) + self.assertEqual("", stream1.getvalue()) self.assertEqual("Test2\n", stream2.getvalue()) def test_alternate_logger(self): stream1 = io.StringIO() stream2 = io.StringIO() - l1 = logging.getLogger('factory.test') - l2 = logging.getLogger('factory.foo') + l1 = logging.getLogger("factory.test") + l2 = logging.getLogger("factory.foo") h = logging.StreamHandler(stream1) h.setLevel(logging.DEBUG) l2.addHandler(h) # Non-debug: no text gets out l1.debug("Test") - self.assertEqual('', stream1.getvalue()) + self.assertEqual("", stream1.getvalue()) l2.debug("Test") - self.assertEqual('', stream1.getvalue()) + self.assertEqual("", stream1.getvalue()) - with helpers.debug('factory.test', stream=stream2): + with helpers.debug("factory.test", stream=stream2): # Debug: text goes to new stream only l1.debug("Test2") l2.debug("Test3") @@ -63,6 +63,6 @@ class MyException(Exception): with helpers.debug(stream=stream): raise MyException except MyException: - logger = logging.getLogger('factory') + logger = logging.getLogger("factory") self.assertEqual(logger.level, logging.NOTSET) self.assertEqual(logger.handlers, []) diff --git a/tests/test_mongoengine.py b/tests/test_mongoengine.py index 591cd113..c33a016a 100644 --- a/tests/test_mongoengine.py +++ b/tests/test_mongoengine.py @@ -24,27 +24,27 @@ class AddressFactory(MongoEngineFactory): class Meta: model = Address - street = factory.Sequence(lambda n: 'street%d' % n) + street = factory.Sequence(lambda n: "street%d" % n) class PersonFactory(MongoEngineFactory): class Meta: model = Person - name = factory.Sequence(lambda n: 'name%d' % n) + name = factory.Sequence(lambda n: "name%d" % n) address = factory.SubFactory(AddressFactory) -SKIP_MONGODB = bool(os.environ.get('SKIP_MONGOENGINE') == '1') +SKIP_MONGODB = bool(os.environ.get("SKIP_MONGOENGINE") == "1") @unittest.skipIf(SKIP_MONGODB, "mongodb tests disabled.") class MongoEngineTestCase(unittest.TestCase): - db_name = os.environ.get('MONGO_DATABASE', 'factory_boy_test') - db_host = os.environ.get('MONGO_HOST', 'localhost') - db_port = int(os.environ.get('MONGO_PORT', '27017')) - server_timeout_ms = int(os.environ.get('MONGO_TIMEOUT', '300')) + db_name = os.environ.get("MONGO_DATABASE", "factory_boy_test") + db_host = os.environ.get("MONGO_HOST", "localhost") + db_port = int(os.environ.get("MONGO_PORT", "27017")) + server_timeout_ms = int(os.environ.get("MONGO_TIMEOUT", "300")) @classmethod def setUpClass(cls): @@ -66,12 +66,12 @@ def tearDownClass(cls): def test_build(self): std = PersonFactory.build() - self.assertEqual('name0', std.name) - self.assertEqual('street0', std.address.street) + self.assertEqual("name0", std.name) + self.assertEqual("street0", std.address.street) self.assertIsNone(std.id) def test_creation(self): std1 = PersonFactory.create() - self.assertEqual('name1', std1.name) - self.assertEqual('street1', std1.address.street) + self.assertEqual("name1", std1.name) + self.assertEqual("street1", std1.address.street) self.assertIsNotNone(std1.id) diff --git a/tests/test_using.py b/tests/test_using.py index 4d277db2..3d11d5ed 100644 --- a/tests/test_using.py +++ b/tests/test_using.py @@ -44,9 +44,9 @@ def as_dict(self): return {field: getattr(self, field) for field in self._fields} def __repr__(self): - return '%s(%s)' % ( + return "%s(%s)" % ( self.__class__.__name__, - ', '.join('%s=%r' % pair for pair in sorted(self.as_dict.items())), + ", ".join("%s=%r" % pair for pair in sorted(self.as_dict.items())), ) @@ -59,7 +59,7 @@ def create(cls, **kwargs): class FakeModelManager: def get_or_create(self, **kwargs): - defaults = kwargs.pop('defaults', {}) + defaults = kwargs.pop("defaults", {}) kwargs.update(defaults) instance = FakeModel.create(**kwargs) instance.id = 2 @@ -141,34 +141,34 @@ def test_build_batch(self): self.assertEqual(obj.four, None) def test_create(self): - obj = factory.create(FakeModel, foo='bar') + obj = factory.create(FakeModel, foo="bar") self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_create_custom_base(self): obj = factory.create( FakeModel, - foo='bar', + foo="bar", FACTORY_CLASS=factory.django.DjangoModelFactory, ) self.assertEqual(obj.id, 2) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_create_batch(self): - objs = factory.create_batch(FakeModel, 4, foo='bar') + objs = factory.create_batch(FakeModel, 4, foo="bar") self.assertEqual(4, len(objs)) self.assertEqual(4, len(set(objs))) for obj in objs: self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_create_batch_custom_base(self): objs = factory.create_batch( FakeModel, 4, - foo='bar', + foo="bar", FACTORY_CLASS=factory.django.DjangoModelFactory, ) @@ -177,74 +177,74 @@ def test_create_batch_custom_base(self): for obj in objs: self.assertEqual(obj.id, 2) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_stub(self): obj = factory.stub(TestObject, three=3) self.assertEqual(obj.three, 3) - self.assertFalse(hasattr(obj, 'two')) + self.assertFalse(hasattr(obj, "two")) def test_stub_batch(self): - objs = factory.stub_batch(FakeModel, 4, foo='bar') + objs = factory.stub_batch(FakeModel, 4, foo="bar") self.assertEqual(4, len(objs)) self.assertEqual(4, len(set(objs))) for obj in objs: - self.assertFalse(hasattr(obj, 'id')) - self.assertEqual(obj.foo, 'bar') + self.assertFalse(hasattr(obj, "id")) + self.assertEqual(obj.foo, "bar") def test_generate_build(self): - obj = factory.generate(FakeModel, factory.BUILD_STRATEGY, foo='bar') + obj = factory.generate(FakeModel, factory.BUILD_STRATEGY, foo="bar") self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_generate_create(self): - obj = factory.generate(FakeModel, factory.CREATE_STRATEGY, foo='bar') + obj = factory.generate(FakeModel, factory.CREATE_STRATEGY, foo="bar") self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_generate_create_custom_base(self): obj = factory.generate( FakeModel, factory.CREATE_STRATEGY, - foo='bar', + foo="bar", FACTORY_CLASS=factory.django.DjangoModelFactory, ) self.assertEqual(obj.id, 2) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_generate_stub(self): - obj = factory.generate(FakeModel, factory.STUB_STRATEGY, foo='bar') - self.assertFalse(hasattr(obj, 'id')) - self.assertEqual(obj.foo, 'bar') + obj = factory.generate(FakeModel, factory.STUB_STRATEGY, foo="bar") + self.assertFalse(hasattr(obj, "id")) + self.assertEqual(obj.foo, "bar") def test_generate_batch_build(self): - objs = factory.generate_batch(FakeModel, factory.BUILD_STRATEGY, 20, foo='bar') + objs = factory.generate_batch(FakeModel, factory.BUILD_STRATEGY, 20, foo="bar") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for obj in objs: self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_generate_batch_create(self): - objs = factory.generate_batch(FakeModel, factory.CREATE_STRATEGY, 20, foo='bar') + objs = factory.generate_batch(FakeModel, factory.CREATE_STRATEGY, 20, foo="bar") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for obj in objs: self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_generate_batch_create_custom_base(self): objs = factory.generate_batch( FakeModel, factory.CREATE_STRATEGY, 20, - foo='bar', + foo="bar", FACTORY_CLASS=factory.django.DjangoModelFactory, ) @@ -253,64 +253,64 @@ def test_generate_batch_create_custom_base(self): for obj in objs: self.assertEqual(obj.id, 2) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_generate_batch_stub(self): - objs = factory.generate_batch(FakeModel, factory.STUB_STRATEGY, 20, foo='bar') + objs = factory.generate_batch(FakeModel, factory.STUB_STRATEGY, 20, foo="bar") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for obj in objs: - self.assertFalse(hasattr(obj, 'id')) - self.assertEqual(obj.foo, 'bar') + self.assertFalse(hasattr(obj, "id")) + self.assertEqual(obj.foo, "bar") def test_simple_generate_build(self): - obj = factory.simple_generate(FakeModel, False, foo='bar') + obj = factory.simple_generate(FakeModel, False, foo="bar") self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_simple_generate_create(self): - obj = factory.simple_generate(FakeModel, True, foo='bar') + obj = factory.simple_generate(FakeModel, True, foo="bar") self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_simple_generate_create_custom_base(self): obj = factory.simple_generate( FakeModel, True, - foo='bar', + foo="bar", FACTORY_CLASS=factory.django.DjangoModelFactory, ) self.assertEqual(obj.id, 2) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_simple_generate_batch_build(self): - objs = factory.simple_generate_batch(FakeModel, False, 20, foo='bar') + objs = factory.simple_generate_batch(FakeModel, False, 20, foo="bar") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for obj in objs: self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_simple_generate_batch_create(self): - objs = factory.simple_generate_batch(FakeModel, True, 20, foo='bar') + objs = factory.simple_generate_batch(FakeModel, True, 20, foo="bar") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for obj in objs: self.assertEqual(obj.id, None) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_simple_generate_batch_create_custom_base(self): objs = factory.simple_generate_batch( FakeModel, True, 20, - foo='bar', + foo="bar", FACTORY_CLASS=factory.django.DjangoModelFactory, ) @@ -319,7 +319,7 @@ def test_simple_generate_batch_create_custom_base(self): for obj in objs: self.assertEqual(obj.id, 2) - self.assertEqual(obj.foo, 'bar') + self.assertEqual(obj.foo, "bar") def test_make_factory(self): fact = factory.make_factory( @@ -346,12 +346,12 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'one' + one = "one" two = factory.LazyAttribute(lambda o: o.one * 2) # Now, get a dict out of it obj = factory.build(dict, FACTORY_CLASS=TestObjectFactory) - self.assertEqual({'one': 'one', 'two': 'oneone'}, obj) + self.assertEqual({"one": "one", "two": "oneone"}, obj) class UsingFactoryTestCase(unittest.TestCase): @@ -360,50 +360,50 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'one' + one = "one" test_object = TestObjectFactory.build() - self.assertEqual(test_object.one, 'one') + self.assertEqual(test_object.one, "one") def test_inheriting_model_class(self): class TestObjectFactory(factory.Factory, TestObject): class Meta: model = TestObject - one = 'one' + one = "one" test_object = TestObjectFactory.build() - self.assertEqual(test_object.one, 'one') + self.assertEqual(test_object.one, "one") def test_abstract(self): class SomeAbstractFactory(factory.Factory): class Meta: abstract = True - one = 'one' + one = "one" class InheritedFactory(SomeAbstractFactory): class Meta: model = TestObject test_object = InheritedFactory.build() - self.assertEqual(test_object.one, 'one') + self.assertEqual(test_object.one, "one") def test_sequence(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.Sequence(lambda n: 'one%d' % n) - two = factory.Sequence(lambda n: 'two%d' % n) + one = factory.Sequence(lambda n: "one%d" % n) + two = factory.Sequence(lambda n: "two%d" % n) test_object0 = TestObjectFactory.build() - self.assertEqual(test_object0.one, 'one0') - self.assertEqual(test_object0.two, 'two0') + self.assertEqual(test_object0.one, "one0") + self.assertEqual(test_object0.two, "two0") test_object1 = TestObjectFactory.build() - self.assertEqual(test_object1.one, 'one1') - self.assertEqual(test_object1.two, 'two1') + self.assertEqual(test_object1.one, "one1") + self.assertEqual(test_object1.two, "two1") def test_sequence_custom_begin(self): class TestObjectFactory(factory.Factory): @@ -414,33 +414,33 @@ class Meta: def _setup_next_sequence(cls): return 42 - one = factory.Sequence(lambda n: 'one%d' % n) - two = factory.Sequence(lambda n: 'two%d' % n) + one = factory.Sequence(lambda n: "one%d" % n) + two = factory.Sequence(lambda n: "two%d" % n) test_object0 = TestObjectFactory.build() - self.assertEqual('one42', test_object0.one) - self.assertEqual('two42', test_object0.two) + self.assertEqual("one42", test_object0.one) + self.assertEqual("two42", test_object0.two) test_object1 = TestObjectFactory.build() - self.assertEqual('one43', test_object1.one) - self.assertEqual('two43', test_object1.two) + self.assertEqual("one43", test_object1.one) + self.assertEqual("two43", test_object1.two) def test_sequence_override(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.Sequence(lambda n: 'one%d' % n) + one = factory.Sequence(lambda n: "one%d" % n) o1 = TestObjectFactory() o2 = TestObjectFactory() o3 = TestObjectFactory(__sequence=42) o4 = TestObjectFactory() - self.assertEqual('one0', o1.one) - self.assertEqual('one1', o2.one) - self.assertEqual('one42', o3.one) - self.assertEqual('one2', o4.one) + self.assertEqual("one0", o1.one) + self.assertEqual("one1", o2.one) + self.assertEqual("one42", o3.one) + self.assertEqual("one2", o4.one) def test_custom_create(self): class TestModelFactory(factory.Factory): @@ -482,44 +482,44 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.Sequence(lambda n: 'one%d' % n) - two = factory.Sequence(lambda n: 'two%d' % n) + one = factory.Sequence(lambda n: "one%d" % n) + two = factory.Sequence(lambda n: "two%d" % n) objs = TestObjectFactory.build_batch(20) self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for i, obj in enumerate(objs): - self.assertEqual('one%d' % i, obj.one) - self.assertEqual('two%d' % i, obj.two) + self.assertEqual("one%d" % i, obj.one) + self.assertEqual("two%d" % i, obj.two) def test_lazy_attribute(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.LazyAttribute(lambda a: 'abc') - two = factory.LazyAttribute(lambda a: a.one + ' xyz') + one = factory.LazyAttribute(lambda a: "abc") + two = factory.LazyAttribute(lambda a: a.one + " xyz") test_object = TestObjectFactory.build() - self.assertEqual(test_object.one, 'abc') - self.assertEqual(test_object.two, 'abc xyz') + self.assertEqual(test_object.one, "abc") + self.assertEqual(test_object.two, "abc xyz") def test_lazy_attribute_sequence(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.LazyAttributeSequence(lambda a, n: 'abc%d' % n) - two = factory.LazyAttributeSequence(lambda a, n: a.one + ' xyz%d' % n) + one = factory.LazyAttributeSequence(lambda a, n: "abc%d" % n) + two = factory.LazyAttributeSequence(lambda a, n: a.one + " xyz%d" % n) test_object0 = TestObjectFactory.build() - self.assertEqual(test_object0.one, 'abc0') - self.assertEqual(test_object0.two, 'abc0 xyz0') + self.assertEqual(test_object0.one, "abc0") + self.assertEqual(test_object0.two, "abc0 xyz0") test_object1 = TestObjectFactory.build() - self.assertEqual(test_object1.one, 'abc1') - self.assertEqual(test_object1.two, 'abc1 xyz1') + self.assertEqual(test_object1.one, "abc1") + self.assertEqual(test_object1.two, "abc1 xyz1") def test_lazy_attribute_decorator(self): class TestObjectFactory(factory.Factory): @@ -528,10 +528,10 @@ class Meta: @factory.lazy_attribute def one(a): - return 'one' + return "one" test_object = TestObjectFactory.build() - self.assertEqual(test_object.one, 'one') + self.assertEqual(test_object.one, "one") def test_self_attribute(self): class TmpObj: @@ -541,11 +541,11 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'xx' - two = factory.SelfAttribute('one') + one = "xx" + two = factory.SelfAttribute("one") three = TmpObj() - four = factory.SelfAttribute('three.n') - five = factory.SelfAttribute('three.nnn', 5) + four = factory.SelfAttribute("three.n") + five = factory.SelfAttribute("three.nnn", 5) test_object = TestObjectFactory.build(one=1) self.assertEqual(1, test_object.two) @@ -562,7 +562,7 @@ class Meta: model = TestModel one = 3 - three = factory.SelfAttribute('..bar') + three = factory.SelfAttribute("..bar") class TestModel2Factory(FakeModelFactory): class Meta: @@ -581,10 +581,10 @@ class Meta: @factory.sequence def one(n): - return 'one%d' % n + return "one%d" % n test_object = TestObjectFactory.build() - self.assertEqual(test_object.one, 'one0') + self.assertEqual(test_object.one, "one0") def test_lazy_attribute_sequence_decorator(self): class TestObjectFactory(factory.Factory): @@ -593,42 +593,42 @@ class Meta: @factory.lazy_attribute_sequence def one(a, n): - return 'one%d' % n + return "one%d" % n @factory.lazy_attribute_sequence def two(a, n): - return a.one + ' two%d' % n + return a.one + " two%d" % n test_object = TestObjectFactory.build() - self.assertEqual(test_object.one, 'one0') - self.assertEqual(test_object.two, 'one0 two0') + self.assertEqual(test_object.one, "one0") + self.assertEqual(test_object.two, "one0 two0") def test_build_with_parameters(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.Sequence(lambda n: 'one%d' % n) - two = factory.Sequence(lambda n: 'two%d' % n) + one = factory.Sequence(lambda n: "one%d" % n) + two = factory.Sequence(lambda n: "two%d" % n) - test_object0 = TestObjectFactory.build(three='three') - self.assertEqual(test_object0.one, 'one0') - self.assertEqual(test_object0.two, 'two0') - self.assertEqual(test_object0.three, 'three') + test_object0 = TestObjectFactory.build(three="three") + self.assertEqual(test_object0.one, "one0") + self.assertEqual(test_object0.two, "two0") + self.assertEqual(test_object0.three, "three") - test_object1 = TestObjectFactory.build(one='other') - self.assertEqual(test_object1.one, 'other') - self.assertEqual(test_object1.two, 'two1') + test_object1 = TestObjectFactory.build(one="other") + self.assertEqual(test_object1.one, "other") + self.assertEqual(test_object1.two, "two1") def test_create(self): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" test_model = TestModelFactory.create() - self.assertEqual(test_model.one, 'one') + self.assertEqual(test_model.one, "one") self.assertTrue(test_model.id) def test_create_batch(self): @@ -636,7 +636,7 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" objs = TestModelFactory.create_batch(20, two=factory.Sequence(int)) @@ -644,7 +644,7 @@ class Meta: self.assertEqual(20, len(set(objs))) for i, obj in enumerate(objs): - self.assertEqual('one', obj.one) + self.assertEqual("one", obj.one) self.assertEqual(i, obj.two) self.assertTrue(obj.id) @@ -653,10 +653,10 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" test_model = TestModelFactory.generate(factory.BUILD_STRATEGY) - self.assertEqual(test_model.one, 'one') + self.assertEqual(test_model.one, "one") self.assertFalse(test_model.id) def test_generate_create(self): @@ -664,10 +664,10 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" test_model = TestModelFactory.generate(factory.CREATE_STRATEGY) - self.assertEqual(test_model.one, 'one') + self.assertEqual(test_model.one, "one") self.assertTrue(test_model.id) def test_generate_stub(self): @@ -675,27 +675,27 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" test_model = TestModelFactory.generate(factory.STUB_STRATEGY) - self.assertEqual(test_model.one, 'one') - self.assertFalse(hasattr(test_model, 'id')) + self.assertEqual(test_model.one, "one") + self.assertFalse(hasattr(test_model, "id")) def test_generate_batch_build(self): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" - objs = TestModelFactory.generate_batch(factory.BUILD_STRATEGY, 20, two='two') + objs = TestModelFactory.generate_batch(factory.BUILD_STRATEGY, 20, two="two") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for i, obj in enumerate(objs): - self.assertEqual('one', obj.one) - self.assertEqual('two', obj.two) + self.assertEqual("one", obj.one) + self.assertEqual("two", obj.two) self.assertFalse(obj.id) def test_generate_batch_create(self): @@ -703,16 +703,16 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" - objs = TestModelFactory.generate_batch(factory.CREATE_STRATEGY, 20, two='two') + objs = TestModelFactory.generate_batch(factory.CREATE_STRATEGY, 20, two="two") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for i, obj in enumerate(objs): - self.assertEqual('one', obj.one) - self.assertEqual('two', obj.two) + self.assertEqual("one", obj.one) + self.assertEqual("two", obj.two) self.assertTrue(obj.id) def test_generate_batch_stub(self): @@ -720,27 +720,27 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" - objs = TestModelFactory.generate_batch(factory.STUB_STRATEGY, 20, two='two') + objs = TestModelFactory.generate_batch(factory.STUB_STRATEGY, 20, two="two") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for i, obj in enumerate(objs): - self.assertEqual('one', obj.one) - self.assertEqual('two', obj.two) - self.assertFalse(hasattr(obj, 'id')) + self.assertEqual("one", obj.one) + self.assertEqual("two", obj.two) + self.assertFalse(hasattr(obj, "id")) def test_simple_generate_build(self): class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" test_model = TestModelFactory.simple_generate(False) - self.assertEqual(test_model.one, 'one') + self.assertEqual(test_model.one, "one") self.assertFalse(test_model.id) def test_simple_generate_create(self): @@ -748,10 +748,10 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" test_model = TestModelFactory.simple_generate(True) - self.assertEqual(test_model.one, 'one') + self.assertEqual(test_model.one, "one") self.assertTrue(test_model.id) def test_simple_generate_batch_build(self): @@ -759,16 +759,16 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" - objs = TestModelFactory.simple_generate_batch(False, 20, two='two') + objs = TestModelFactory.simple_generate_batch(False, 20, two="two") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for i, obj in enumerate(objs): - self.assertEqual('one', obj.one) - self.assertEqual('two', obj.two) + self.assertEqual("one", obj.one) + self.assertEqual("two", obj.two) self.assertFalse(obj.id) def test_simple_generate_batch_create(self): @@ -776,16 +776,16 @@ class TestModelFactory(FakeModelFactory): class Meta: model = TestModel - one = 'one' + one = "one" - objs = TestModelFactory.simple_generate_batch(True, 20, two='two') + objs = TestModelFactory.simple_generate_batch(True, 20, two="two") self.assertEqual(20, len(objs)) self.assertEqual(20, len(set(objs))) for i, obj in enumerate(objs): - self.assertEqual('one', obj.one) - self.assertEqual('two', obj.two) + self.assertEqual("one", obj.one) + self.assertEqual("two", obj.two) self.assertTrue(obj.id) def test_stub_batch(self): @@ -793,8 +793,8 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'one' - two = factory.LazyAttribute(lambda a: a.one + ' two') + one = "one" + two = factory.LazyAttribute(lambda a: a.one + " two") three = factory.Sequence(lambda n: int(n)) objs = TestObjectFactory.stub_batch( @@ -807,7 +807,7 @@ class Meta: for i, obj in enumerate(objs): self.assertEqual(str(i), obj.one) - self.assertEqual('%d two' % i, obj.two) + self.assertEqual("%d two" % i, obj.two) self.assertEqual(i, obj.three) def test_inheritance(self): @@ -815,21 +815,21 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'one' - two = factory.LazyAttribute(lambda a: a.one + ' two') + one = "one" + two = factory.LazyAttribute(lambda a: a.one + " two") class TestObjectFactory2(TestObjectFactory): class Meta: model = TestObject - three = 'three' - four = factory.LazyAttribute(lambda a: a.three + ' four') + three = "three" + four = factory.LazyAttribute(lambda a: a.three + " four") test_object = TestObjectFactory2.build() - self.assertEqual(test_object.one, 'one') - self.assertEqual(test_object.two, 'one two') - self.assertEqual(test_object.three, 'three') - self.assertEqual(test_object.four, 'three four') + self.assertEqual(test_object.one, "one") + self.assertEqual(test_object.two, "one two") + self.assertEqual(test_object.three, "three") + self.assertEqual(test_object.four, "three four") test_object_alt = TestObjectFactory.build() self.assertEqual(None, test_object_alt.three) @@ -841,13 +841,13 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'one' + one = "one" class TestObjectFactory2(TestObjectFactory): - one = 'two' + one = "two" test_object = TestObjectFactory2.build() - self.assertEqual('two', test_object.one) + self.assertEqual("two", test_object.one) def test_override_inherited_deep(self): """Overriding inherited declarations""" @@ -856,16 +856,16 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'one' + one = "one" class TestObjectFactory2(TestObjectFactory): - one = 'two' + one = "two" class TestObjectFactory3(TestObjectFactory2): pass test_object = TestObjectFactory3.build() - self.assertEqual('two', test_object.one) + self.assertEqual("two", test_object.one) def test_inheritance_and_sequences(self): """Sequence counters should be kept within an inheritance chain.""" @@ -951,41 +951,41 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'one' - two = factory.LazyAttribute(lambda a: a.one + ' two') + one = "one" + two = factory.LazyAttribute(lambda a: a.one + " two") class TestFactory(TestObjectFactory): - three = 'three' - four = factory.LazyAttribute(lambda a: a.three + ' four') + three = "three" + four = factory.LazyAttribute(lambda a: a.three + " four") test_object = TestFactory.build() - self.assertEqual(test_object.one, 'one') - self.assertEqual(test_object.two, 'one two') - self.assertEqual(test_object.three, 'three') - self.assertEqual(test_object.four, 'three four') + self.assertEqual(test_object.one, "one") + self.assertEqual(test_object.two, "one two") + self.assertEqual(test_object.three, "three") + self.assertEqual(test_object.four, "three four") def test_dual_inheritance(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = 'one' + one = "one" class TestOtherFactory(factory.Factory): class Meta: model = TestObject - two = 'two' - four = 'four' + two = "two" + four = "four" class TestFactory(TestObjectFactory, TestOtherFactory): - three = 'three' + three = "three" obj = TestFactory.build(two=2) - self.assertEqual('one', obj.one) + self.assertEqual("one", obj.one) self.assertEqual(2, obj.two) - self.assertEqual('three', obj.three) - self.assertEqual('four', obj.four) + self.assertEqual("three", obj.three) + self.assertEqual("four", obj.four) def test_class_method_accessible(self): class TestObjectFactory(factory.Factory): @@ -1018,7 +1018,7 @@ def __init__(self, *args, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - inline_args = ('x', 'y') + inline_args = ("x", "y") x = 1 y = 2 @@ -1027,7 +1027,7 @@ class Meta: obj = TestObjectFactory.build(x=42, z=5) self.assertEqual((42, 2), obj.args) - self.assertEqual({'z': 5, 't': 4}, obj.kwargs) + self.assertEqual({"z": 5, "t": 4}, obj.kwargs) def test_exclude(self): class TestObject: @@ -1038,7 +1038,7 @@ def __init__(self, *args, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - exclude = ('x', 'z') + exclude = ("x", "z") x = 1 y = 2 @@ -1047,7 +1047,7 @@ class Meta: obj = TestObjectFactory.build(x=42, z=5) self.assertEqual((), obj.args) - self.assertEqual({'y': 2, 't': 4}, obj.kwargs) + self.assertEqual({"y": 2, "t": 4}, obj.kwargs) def test_exclude_and_inline_args(self): class TestObject: @@ -1058,8 +1058,8 @@ def __init__(self, *args, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - exclude = ('x', 'z') - inline_args = ('y',) + exclude = ("x", "z") + inline_args = ("y",) x = 1 y = 2 @@ -1068,7 +1068,7 @@ class Meta: obj = TestObjectFactory.build(x=42, z=5) self.assertEqual((2,), obj.args) - self.assertEqual({'t': 4}, obj.kwargs) + self.assertEqual({"t": 4}, obj.kwargs) class NonKwargParametersTestCase(unittest.TestCase): @@ -1081,7 +1081,7 @@ def __init__(self, *args, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - inline_args = ('one', 'two') + inline_args = ("one", "two") one = 1 two = 2 @@ -1089,7 +1089,7 @@ class Meta: obj = TestObjectFactory.build() self.assertEqual((1, 2), obj.args) - self.assertEqual({'three': 3}, obj.kwargs) + self.assertEqual({"three": 3}, obj.kwargs) def test_create(self): class TestObject: @@ -1107,7 +1107,7 @@ def create(cls, *args, **kwargs): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - inline_args = ('one', 'two') + inline_args = ("one", "two") one = 1 two = 2 @@ -1119,7 +1119,7 @@ def _create(cls, model_class, *args, **kwargs): obj = TestObjectFactory.create() self.assertEqual((1, 2), obj.args) - self.assertEqual({'three': 3}, obj.kwargs) + self.assertEqual({"three": 3}, obj.kwargs) class KwargAdjustTestCase(unittest.TestCase): @@ -1137,11 +1137,11 @@ class Meta: @classmethod def _adjust_kwargs(cls, **kwargs): - kwargs['foo'] = len(kwargs) + kwargs["foo"] = len(kwargs) return kwargs obj = TestObjectFactory.build(x=1, y=2, z=3) - self.assertEqual({'x': 1, 'y': 2, 'z': 3, 'foo': 3}, obj.kwargs) + self.assertEqual({"x": 1, "y": 2, "z": 3, "foo": 3}, obj.kwargs) self.assertEqual((), obj.args) def test_rename(self): @@ -1152,7 +1152,7 @@ def __init__(self, attributes=None): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - rename = {'attributes_': 'attributes'} + rename = {"attributes_": "attributes"} attributes_ = 42 @@ -1168,12 +1168,12 @@ def __init__(self, attributes=None): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - rename = {'form_attributes': 'attributes'} + rename = {"form_attributes": "attributes"} try: TestObjectFactory() except KeyError: - self.fail('should not raise KeyError for missing renamed attributes') + self.fail("should not raise KeyError for missing renamed attributes") class MaybeTestCase(unittest.TestCase): @@ -1183,10 +1183,10 @@ class Meta: model = Dummy # Undeclared: key = None - both = factory.Maybe('key', 1, 2) - yes = factory.Maybe('key', 1) - no = factory.Maybe('key', no_declaration=2) - none = factory.Maybe('key') + both = factory.Maybe("key", 1, 2) + yes = factory.Maybe("key", 1) + no = factory.Maybe("key", no_declaration=2) + none = factory.Maybe("key") obj_default = DummyFactory.build() obj_true = DummyFactory.build(key=True) @@ -1207,14 +1207,14 @@ class Meta: # biggest = 'b' if .b > .a else 'a' biggest = factory.Maybe( factory.LazyAttribute(lambda o: o.a < o.b), - 'b', - 'a', + "b", + "a", ) # max_value = .b if .b > .a else .a = max(.a, .b) max_value = factory.Maybe( factory.LazyAttribute(lambda o: o.a < o.b), - factory.SelfAttribute('b'), - factory.SelfAttribute('a'), + factory.SelfAttribute("b"), + factory.SelfAttribute("a"), ) obj_ordered = DummyFactory.build(a=1, b=2) @@ -1222,15 +1222,15 @@ class Meta: obj_reverse = DummyFactory.build(a=5, b=4) self.assertEqual( - dict(a=1, b=2, biggest='b', max_value=2), + dict(a=1, b=2, biggest="b", max_value=2), obj_ordered.as_dict, ) self.assertEqual( - dict(a=3, b=3, biggest='a', max_value=3), + dict(a=3, b=3, biggest="a", max_value=3), obj_equal.as_dict, ) self.assertEqual( - dict(a=5, b=4, biggest='a', max_value=5), + dict(a=5, b=4, biggest="a", max_value=5), obj_reverse.as_dict, ) @@ -1258,8 +1258,8 @@ class Meta: model = Dummy value = 0 - square_it = factory.Maybe('square', square) - quintuple_it = factory.Maybe('quintuple', quintuple) + square_it = factory.Maybe("square", square) + quintuple_it = factory.Maybe("quintuple", quintuple) adjust_nums = factory.Maybe( factory.LazyAttribute(lambda o: o.value % 2 == 0), double, @@ -1490,7 +1490,7 @@ def test_traits_and_postgeneration(self): """ PRICES = {} - Pizza = collections.namedtuple('Pizza', ['style', 'toppings']) + Pizza = collections.namedtuple("Pizza", ["style", "toppings"]) class PizzaFactory(factory.Factory): class Meta: @@ -1498,13 +1498,13 @@ class Meta: class Params: fancy = factory.Trait( - toppings=['eggs', 'ham', 'extra_cheese'], + toppings=["eggs", "ham", "extra_cheese"], pricing__extra=10, ) pricing__extra = 0 - toppings = ['tomato', 'cheese'] - style = 'margharita' + toppings = ["tomato", "cheese"] + style = "margharita" @factory.post_generation def pricing(self, create, extracted, base_price=5, extra=0, **kwargs): @@ -1550,13 +1550,13 @@ class Meta: two = factory.SubFactory( TestModelFactory, - one=factory.Sequence(lambda n: 'x%dx' % n), - two=factory.LazyAttribute(lambda o: f'{o.one}{o.one}'), + one=factory.Sequence(lambda n: "x%dx" % n), + two=factory.LazyAttribute(lambda o: f"{o.one}{o.one}"), ) test_model = TestModel2Factory(one=42) - self.assertEqual('x0x', test_model.two.one) - self.assertEqual('x0xx0x', test_model.two.two) + self.assertEqual("x0x", test_model.two.one) + self.assertEqual("x0xx0x", test_model.two.two) def test_sub_factory_with_lazy_fields_access_factory_parent(self): class TestModel2(FakeModel): @@ -1572,14 +1572,14 @@ class TestModel2Factory(FakeModelFactory): class Meta: model = TestModel2 - one = 'parent' + one = "parent" child = factory.SubFactory( TestModelFactory, - one=factory.LazyAttribute(lambda o: '%s child' % o.factory_parent.one), + one=factory.LazyAttribute(lambda o: "%s child" % o.factory_parent.one), ) test_model = TestModel2Factory() - self.assertEqual('parent child', test_model.child.one) + self.assertEqual("parent child", test_model.child.one) def test_sub_factory_and_sequence(self): class TestObject: @@ -1633,16 +1633,16 @@ class Meta: self.assertEqual(wrapping.wrapped.four, 4) def test_sub_factory_deep_overrides(self): - Author = collections.namedtuple('Author', ['name', 'country']) - Book = collections.namedtuple('Book', ['title', 'author']) - Chapter = collections.namedtuple('Chapter', ['book', 'number']) + Author = collections.namedtuple("Author", ["name", "country"]) + Book = collections.namedtuple("Book", ["title", "author"]) + Chapter = collections.namedtuple("Chapter", ["book", "number"]) class AuthorFactory(factory.Factory): class Meta: model = Author name = "John" - country = 'XX' + country = "XX" class BookFactory(factory.Factory): class Meta: @@ -1657,10 +1657,10 @@ class Meta: book = factory.SubFactory(BookFactory) number = factory.Sequence(lambda n: n) - book__author__country = factory.LazyAttribute(lambda o: 'FR') + book__author__country = factory.LazyAttribute(lambda o: "FR") chapter = ChapterFactory() - self.assertEqual('FR', chapter.book.author.country) + self.assertEqual("FR", chapter.book.author.country) def test_nested_sub_factory(self): """Test nested sub-factories.""" @@ -1703,7 +1703,7 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - two = 'two' + two = "two" class WrappingTestObjectFactory(factory.Factory): class Meta: @@ -1730,7 +1730,7 @@ def test_nested_subfactory_with_override(self): # The test class class TestObject: - def __init__(self, two='one', wrapped=None): + def __init__(self, two="one", wrapped=None): self.two = two self.wrapped = wrapped @@ -1739,7 +1739,7 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - two = 'two' + two = "two" # Intermediary factory class WrappingTestObjectFactory(factory.Factory): @@ -1747,12 +1747,12 @@ class Meta: model = TestObject wrapped = factory.SubFactory(TestObjectFactory) - wrapped__two = 'three' + wrapped__two = "three" - obj = TestObject(two='four') + obj = TestObject(two="four") outer = WrappingTestObjectFactory(wrapped=obj) self.assertEqual(obj, outer.wrapped) - self.assertEqual('four', outer.wrapped.two) + self.assertEqual("four", outer.wrapped.two) def test_deep_nested_subfactory(self): counter = iter(range(100)) @@ -1767,22 +1767,22 @@ class LeafFactory(factory.Factory): class Meta: model = Node - label = 'leaf' + label = "leaf" class BranchFactory(factory.Factory): class Meta: model = Node - label = 'branch' + label = "branch" child = factory.SubFactory(LeafFactory) class TreeFactory(factory.Factory): class Meta: model = Node - label = 'tree' + label = "tree" child = factory.SubFactory(BranchFactory) - child__child__label = 'magic-leaf' + child__child__label = "magic-leaf" leaf = LeafFactory() # Magic corruption did happen here once: @@ -1793,17 +1793,17 @@ class Meta: mtree_2 = TreeFactory() self.assertEqual(0, mtree_1.child.child.id) - self.assertEqual('leaf', mtree_1.child.child.label) + self.assertEqual("leaf", mtree_1.child.child.label) self.assertEqual(1, mtree_1.child.id) - self.assertEqual('branch', mtree_1.child.label) + self.assertEqual("branch", mtree_1.child.label) self.assertEqual(2, mtree_1.id) - self.assertEqual('tree', mtree_1.label) + self.assertEqual("tree", mtree_1.label) self.assertEqual(3, mtree_2.child.child.id) - self.assertEqual('magic-leaf', mtree_2.child.child.label) + self.assertEqual("magic-leaf", mtree_2.child.child.label) self.assertEqual(4, mtree_2.child.id) - self.assertEqual('branch', mtree_2.child.label) + self.assertEqual("branch", mtree_2.child.label) self.assertEqual(5, mtree_2.id) - self.assertEqual('tree', mtree_2.label) + self.assertEqual("tree", mtree_2.label) def test_sub_factory_and_inheritance(self): """Test inheriting from a factory with subfactories, overriding.""" @@ -1817,7 +1817,7 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - two = 'two' + two = "two" class WrappingTestObjectFactory(factory.Factory): class Meta: @@ -2094,7 +2094,7 @@ def __init__(self, keys, instance): self.instance = instance def get_or_create(self, **kwargs): - defaults = kwargs.pop('defaults', {}) + defaults = kwargs.pop("defaults", {}) if kwargs == self.keys: return self.instance, False kwargs.update(defaults) @@ -2134,12 +2134,12 @@ def test_existing_instance(self): prev.id = 42 class MyFakeModel(BetterFakeModel): - objects = BetterFakeModelManager({'x': 1}, prev) + objects = BetterFakeModelManager({"x": 1}, prev) class MyFakeModelFactory(factory.django.DjangoModelFactory): class Meta: model = MyFakeModel - django_get_or_create = ('x',) + django_get_or_create = ("x",) x = 1 y = 4 @@ -2157,12 +2157,12 @@ def test_existing_instance_complex_key(self): prev.id = 42 class MyFakeModel(BetterFakeModel): - objects = BetterFakeModelManager({'x': 1, 'y': 2, 'z': 3}, prev) + objects = BetterFakeModelManager({"x": 1, "y": 2, "z": 3}, prev) class MyFakeModelFactory(factory.django.DjangoModelFactory): class Meta: model = MyFakeModel - django_get_or_create = ('x', 'y', 'z') + django_get_or_create = ("x", "y", "z") x = 1 y = 4 @@ -2180,12 +2180,12 @@ def test_new_instance(self): prev.id = 42 class MyFakeModel(BetterFakeModel): - objects = BetterFakeModelManager({'x': 1}, prev) + objects = BetterFakeModelManager({"x": 1}, prev) class MyFakeModelFactory(factory.django.DjangoModelFactory): class Meta: model = MyFakeModel - django_get_or_create = ('x',) + django_get_or_create = ("x",) x = 1 y = 4 @@ -2203,12 +2203,12 @@ def test_new_instance_complex_key(self): prev.id = 42 class MyFakeModel(BetterFakeModel): - objects = BetterFakeModelManager({'x': 1, 'y': 2, 'z': 3}, prev) + objects = BetterFakeModelManager({"x": 1, "y": 2, "z": 3}, prev) class MyFakeModelFactory(factory.django.DjangoModelFactory): class Meta: model = MyFakeModel - django_get_or_create = ('x', 'y', 'z') + django_get_or_create = ("x", "y", "z") x = 1 y = 4 @@ -2226,46 +2226,46 @@ class TestModelFactory(factory.django.DjangoModelFactory): class Meta: model = TestModel - a = factory.Sequence(lambda n: 'foo_%s' % n) + a = factory.Sequence(lambda n: "foo_%s" % n) o1 = TestModelFactory() o2 = TestModelFactory() - self.assertEqual('foo_0', o1.a) - self.assertEqual('foo_1', o2.a) + self.assertEqual("foo_0", o1.a) + self.assertEqual("foo_1", o2.a) o3 = TestModelFactory.build() o4 = TestModelFactory.build() - self.assertEqual('foo_2', o3.a) - self.assertEqual('foo_3', o4.a) + self.assertEqual("foo_2", o3.a) + self.assertEqual("foo_3", o4.a) def test_no_get_or_create(self): class TestModelFactory(factory.django.DjangoModelFactory): class Meta: model = TestModel - a = factory.Sequence(lambda n: 'foo_%s' % n) + a = factory.Sequence(lambda n: "foo_%s" % n) o = TestModelFactory() self.assertEqual(None, o._defaults) - self.assertEqual('foo_0', o.a) + self.assertEqual("foo_0", o.a) self.assertEqual(2, o.id) def test_get_or_create(self): class TestModelFactory(factory.django.DjangoModelFactory): class Meta: model = TestModel - django_get_or_create = ('a', 'b') + django_get_or_create = ("a", "b") - a = factory.Sequence(lambda n: 'foo_%s' % n) + a = factory.Sequence(lambda n: "foo_%s" % n) b = 2 c = 3 d = 4 o = TestModelFactory() - self.assertEqual({'c': 3, 'd': 4}, o._defaults) - self.assertEqual('foo_0', o.a) + self.assertEqual({"c": 3, "d": 4}, o._defaults) + self.assertEqual("foo_0", o.a) self.assertEqual(2, o.b) self.assertEqual(3, o.c) self.assertEqual(4, o.d) @@ -2277,16 +2277,16 @@ def test_full_get_or_create(self): class TestModelFactory(factory.django.DjangoModelFactory): class Meta: model = TestModel - django_get_or_create = ('a', 'b', 'c', 'd') + django_get_or_create = ("a", "b", "c", "d") - a = factory.Sequence(lambda n: 'foo_%s' % n) + a = factory.Sequence(lambda n: "foo_%s" % n) b = 2 c = 3 d = 4 o = TestModelFactory() self.assertEqual({}, o._defaults) - self.assertEqual('foo_0', o.a) + self.assertEqual("foo_0", o.a) self.assertEqual(2, o.b) self.assertEqual(3, o.c) self.assertEqual(4, o.d) @@ -2307,11 +2307,11 @@ def incr_one(self, _create, _increment): obj = TestObjectFactory.build() self.assertEqual(2, obj.one) - self.assertFalse(hasattr(obj, 'incr_one')) + self.assertFalse(hasattr(obj, "incr_one")) obj = TestObjectFactory.build(one=2) self.assertEqual(3, obj.one) - self.assertFalse(hasattr(obj, 'incr_one')) + self.assertFalse(hasattr(obj, "incr_one")) def test_post_generation_hook(self): class TestObjectFactory(factory.Factory): @@ -2333,7 +2333,7 @@ def _after_postgeneration(cls, obj, create, results): obj = TestObjectFactory.build() self.assertEqual(2, obj.one) self.assertFalse(obj.create) - self.assertEqual({'incr_one': 42}, obj.results) + self.assertEqual({"incr_one": 42}, obj.results) def test_post_generation_extraction(self): class TestObjectFactory(factory.Factory): @@ -2348,18 +2348,18 @@ def incr_one(self, _create, increment=1): obj = TestObjectFactory.build(incr_one=2) self.assertEqual(3, obj.one) - self.assertFalse(hasattr(obj, 'incr_one')) + self.assertFalse(hasattr(obj, "incr_one")) obj = TestObjectFactory.build(one=2, incr_one=2) self.assertEqual(4, obj.one) - self.assertFalse(hasattr(obj, 'incr_one')) + self.assertFalse(hasattr(obj, "incr_one")) def test_post_generation_extraction_lambda(self): def my_lambda(obj, create, extracted, **kwargs): self.assertTrue(isinstance(obj, TestObject)) self.assertFalse(create) self.assertEqual(extracted, 42) - self.assertEqual(kwargs, {'foo': 13}) + self.assertEqual(kwargs, {"foo": 13}) class TestObjectFactory(factory.Factory): class Meta: @@ -2378,7 +2378,7 @@ class Meta: @factory.post_generation def incr_one(self, _create, override, **extra): - multiplier = extra.get('multiplier', 1) + multiplier = extra.get("multiplier", 1) if override is None: override = 1 self.one += override * multiplier @@ -2416,28 +2416,28 @@ class Meta: one = 3 two = 2 - post_call = factory.PostGenerationMethodCall('call', one=1) + post_call = factory.PostGenerationMethodCall("call", one=1) obj = TestObjectFactory.build() self.assertEqual(3, obj.one) self.assertEqual(2, obj.two) - self.assertEqual(((), {'one': 1}), obj.extra) + self.assertEqual(((), {"one": 1}), obj.extra) obj = TestObjectFactory.build(post_call__one=2, post_call__two=3) self.assertEqual(3, obj.one) self.assertEqual(2, obj.two) - self.assertEqual(((), {'one': 2, 'two': 3}), obj.extra) + self.assertEqual(((), {"one": 2, "two": 3}), obj.extra) def test_post_generation_extraction_declaration(self): LIBRARY = {} - Book = collections.namedtuple('Book', ['author']) + Book = collections.namedtuple("Book", ["author"]) class BookFactory(factory.Factory): class Meta: model = Book - author = factory.Faker('name') + author = factory.Faker("name") register__reference = factory.Sequence(lambda n: n) @factory.post_generation @@ -2472,7 +2472,7 @@ class Meta: two = 2 three = factory.RelatedFactory( TestRelatedObjectFactory, - factory_related_name='obj', + factory_related_name="obj", ) obj = TestObjectFactory.build() @@ -2572,8 +2572,8 @@ class Meta: two = 2 three = factory.RelatedFactory( TestRelatedObjectFactory, - factory_related_name='obj', - two=factory.SelfAttribute('obj.two'), + factory_related_name="obj", + two=factory.SelfAttribute("obj.two"), ) obj = TestObjectFactory.build(two=4) @@ -2608,9 +2608,9 @@ class Params: two = 2 three = factory.RelatedFactory( TestRelatedObjectFactory, - factory_related_name='obj', + factory_related_name="obj", ) - three__two = factory.SelfAttribute('..blah') + three__two = factory.SelfAttribute("..blah") obj = TestObjectFactory.build() self.assertEqual(3, obj.one) @@ -2618,8 +2618,8 @@ class Params: self.assertEqual(1, obj.related.one) self.assertEqual(1, obj.related.two) - obj2 = TestObjectFactory.build(blah='blah') - self.assertEqual('blah', obj2.related.two) + obj2 = TestObjectFactory.build(blah="blah") + self.assertEqual("blah", obj2.related.two) class RelatedListFactoryTestCase(unittest.TestCase): @@ -2631,7 +2631,7 @@ def test_related_factory_list_of_varying_size(self): class TestRelatedObject: def __init__(self, obj=None, one=None, two=None): # Mock out the 'List of Related Objects' generated by RelatedFactoryList - if hasattr(obj, 'related_list'): + if hasattr(obj, "related_list"): obj.related_list.append(self) else: obj.related_list = [self] @@ -2656,7 +2656,7 @@ class Meta: # to creating "n" related objects for every parent object... three = factory.RelatedFactoryList( TestRelatedObjectFactoryList, - 'obj', + "obj", size=RELATED_LIST_SIZE, ) # Create 5 TestObjectFactories: Each with 1, 2, ... 5 related objs @@ -2701,7 +2701,7 @@ def test_related_factory_list_of_static_size(self): class TestRelatedObject: def __init__(self, obj=None, one=None, two=None): # Mock out the 'List of Related Objects' generated by RelatedFactoryList - if hasattr(obj, 'related_list'): + if hasattr(obj, "related_list"): obj.related_list.append(self) else: obj.related_list = [self] @@ -2725,7 +2725,7 @@ class Meta: two = 2 three = factory.RelatedFactoryList( TestRelatedObjectFactoryList, - 'obj', + "obj", size=RELATED_LIST_SIZE, ) @@ -2783,7 +2783,7 @@ class Meta: one = factory.RelatedFactory( TestRelatedObjectFactory, - factory_related_name='obj', + factory_related_name="obj", ) self.TestRelatedObject = TestRelatedObject @@ -2800,12 +2800,12 @@ def test_no_extraction(self): def test_passed_value(self): o = self.TestObjectFactory(one=42) self.assertEqual([], self.relateds) - self.assertFalse(hasattr(o, 'related')) + self.assertFalse(hasattr(o, "related")) def test_passed_none(self): o = self.TestObjectFactory(one=None) self.assertEqual([], self.relateds) - self.assertFalse(hasattr(o, 'related')) + self.assertFalse(hasattr(o, "related")) class CircularTestCase(unittest.TestCase): @@ -2833,9 +2833,9 @@ class RepeatableRandomSeedFakerTests(unittest.TestCase): def test_same_seed_is_used_between_fuzzy_and_faker_generators(self): class StudentFactory(factory.Factory): one = factory.fuzzy.FuzzyDecimal(4.0) - two = factory.Faker('name') - three = factory.Faker('name', locale='it') - four = factory.Faker('name') + two = factory.Faker("name") + three = factory.Faker("name", locale="it") + four = factory.Faker("name") class Meta: model = TestObject @@ -2886,43 +2886,43 @@ class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.Dict({'a': 1}) + one = factory.Dict({"a": 1}) o = TestObjectFactory() - self.assertEqual({'a': 1}, o.one) + self.assertEqual({"a": 1}, o.one) def test_sequence_dict(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.Dict({'a': factory.Sequence(lambda n: n + 2)}) + one = factory.Dict({"a": factory.Sequence(lambda n: n + 2)}) o1 = TestObjectFactory() o2 = TestObjectFactory() - self.assertEqual({'a': 2}, o1.one) - self.assertEqual({'a': 3}, o2.one) + self.assertEqual({"a": 2}, o1.one) + self.assertEqual({"a": 3}, o2.one) def test_dict_override(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.Dict({'a': 1}) + one = factory.Dict({"a": 1}) o = TestObjectFactory(one__a=2) - self.assertEqual({'a': 2}, o.one) + self.assertEqual({"a": 2}, o.one) def test_dict_extra_key(self): class TestObjectFactory(factory.Factory): class Meta: model = TestObject - one = factory.Dict({'a': 1}) + one = factory.Dict({"a": 1}) o = TestObjectFactory(one__b=2) - self.assertEqual({'a': 1, 'b': 2}, o.one) + self.assertEqual({"a": 1, "b": 2}, o.one) def test_dict_merged_fields(self): class TestObjectFactory(factory.Factory): @@ -2932,14 +2932,14 @@ class Meta: two = 13 one = factory.Dict( { - 'one': 1, - 'two': 2, - 'three': factory.SelfAttribute('two'), + "one": 1, + "two": 2, + "three": factory.SelfAttribute("two"), } ) o = TestObjectFactory(one__one=42) - self.assertEqual({'one': 42, 'two': 2, 'three': 2}, o.one) + self.assertEqual({"one": 42, "two": 2, "three": 2}, o.one) def test_nested_dicts(self): class TestObjectFactory(factory.Factory): @@ -2949,13 +2949,13 @@ class Meta: one = 1 two = factory.Dict( { - 'one': 3, - 'two': factory.SelfAttribute('one'), - 'three': factory.Dict( + "one": 3, + "two": factory.SelfAttribute("one"), + "three": factory.Dict( { - 'one': 5, - 'two': factory.SelfAttribute('..one'), - 'three': factory.SelfAttribute('...one'), + "one": 5, + "two": factory.SelfAttribute("..one"), + "three": factory.SelfAttribute("...one"), } ), } @@ -2965,12 +2965,12 @@ class Meta: self.assertEqual(1, o.one) self.assertEqual( { - 'one': 3, - 'two': 3, - 'three': { - 'one': 5, - 'two': 3, - 'three': 1, + "one": 3, + "two": 3, + "three": { + "one": 5, + "two": 3, + "three": 1, }, }, o.two, @@ -3047,7 +3047,7 @@ class Meta: model = TestObject two = 13 - one = factory.List([1, 2, factory.SelfAttribute('1')]) + one = factory.List([1, 2, factory.SelfAttribute("1")]) o = TestObjectFactory(one__0=42) self.assertEqual([42, 2, 2], o.one) @@ -3061,12 +3061,12 @@ class Meta: two = factory.List( [ 3, - factory.SelfAttribute('0'), + factory.SelfAttribute("0"), factory.List( [ 5, - factory.SelfAttribute('..0'), - factory.SelfAttribute('...one'), + factory.SelfAttribute("..0"), + factory.SelfAttribute("...one"), ] ), ] diff --git a/tests/test_utils.py b/tests/test_utils.py index 80e9c32c..6d8ab63d 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -9,7 +9,7 @@ class ImportObjectTestCase(unittest.TestCase): def test_datetime(self): - imported = utils.import_object('datetime', 'date') + imported = utils.import_object("datetime", "date") import datetime d = datetime.date @@ -17,44 +17,44 @@ def test_datetime(self): def test_unknown_attribute(self): with self.assertRaises(AttributeError): - utils.import_object('datetime', 'foo') + utils.import_object("datetime", "foo") def test_invalid_module(self): with self.assertRaises(ImportError): - utils.import_object('this-is-an-invalid-module', '__name__') + utils.import_object("this-is-an-invalid-module", "__name__") class LogPPrintTestCase(unittest.TestCase): def test_nothing(self): txt = str(utils.log_pprint()) - self.assertEqual('', txt) + self.assertEqual("", txt) def test_only_args(self): txt = str(utils.log_pprint((1, 2, 3))) - self.assertEqual('1, 2, 3', txt) + self.assertEqual("1, 2, 3", txt) def test_only_kwargs(self): - txt = str(utils.log_pprint(kwargs={'a': 1, 'b': 2})) - self.assertIn(txt, ['a=1, b=2', 'b=2, a=1']) + txt = str(utils.log_pprint(kwargs={"a": 1, "b": 2})) + self.assertIn(txt, ["a=1, b=2", "b=2, a=1"]) def test_bytes_args(self): - txt = str(utils.log_pprint((b'\xe1\xe2',))) + txt = str(utils.log_pprint((b"\xe1\xe2",))) expected = "b'\\xe1\\xe2'" self.assertEqual(expected, txt) def test_text_args(self): - txt = str(utils.log_pprint(('ŧêßŧ',))) + txt = str(utils.log_pprint(("ŧêßŧ",))) expected = "'ŧêßŧ'" self.assertEqual(expected, txt) def test_bytes_kwargs(self): - txt = str(utils.log_pprint(kwargs={'x': b'\xe1\xe2', 'y': b'\xe2\xe1'})) + txt = str(utils.log_pprint(kwargs={"x": b"\xe1\xe2", "y": b"\xe2\xe1"})) expected1 = "x=b'\\xe1\\xe2', y=b'\\xe2\\xe1'" expected2 = "y=b'\\xe2\\xe1', x=b'\\xe1\\xe2'" self.assertIn(txt, (expected1, expected2)) def test_text_kwargs(self): - txt = str(utils.log_pprint(kwargs={'x': 'ŧêßŧ', 'y': 'ŧßêŧ'})) + txt = str(utils.log_pprint(kwargs={"x": "ŧêßŧ", "y": "ŧßêŧ"})) expected1 = "x='ŧêßŧ', y='ŧßêŧ'" expected2 = "y='ŧßêŧ', x='ŧêßŧ'" self.assertIn(txt, (expected1, expected2)) diff --git a/tests/testdata/__init__.py b/tests/testdata/__init__.py index b0de791a..66966ccf 100644 --- a/tests/testdata/__init__.py +++ b/tests/testdata/__init__.py @@ -4,5 +4,5 @@ import os.path TESTDATA_ROOT = os.path.abspath(os.path.dirname(__file__)) -TESTFILE_PATH = os.path.join(TESTDATA_ROOT, 'example.data') -TESTIMAGE_PATH = os.path.join(TESTDATA_ROOT, 'example.jpeg') +TESTFILE_PATH = os.path.join(TESTDATA_ROOT, "example.data") +TESTIMAGE_PATH = os.path.join(TESTDATA_ROOT, "example.jpeg") diff --git a/tests/utils.py b/tests/utils.py index cf63ad21..5de6cfd4 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -12,7 +12,7 @@ def disable_warnings(fun): @functools.wraps(fun) def decorated(*args, **kwargs): with warnings.catch_warnings(): - warnings.simplefilter('ignore') + warnings.simplefilter("ignore") return fun(*args, **kwargs) return decorated @@ -46,7 +46,7 @@ def __init__(self, target_date, *target_modules, **kwargs): super().__init__(*target_modules, **kwargs) def _build_patcher(self, target_module): - module_datetime = getattr(target_module, 'datetime') + module_datetime = getattr(target_module, "datetime") return alter_time.mock_date_today(self.target_date, module_datetime) @@ -56,13 +56,13 @@ def __init__(self, target_dt, *target_modules, **kwargs): super().__init__(*target_modules, **kwargs) def _build_patcher(self, target_module): - module_datetime = getattr(target_module, 'datetime') + module_datetime = getattr(target_module, "datetime") return alter_time.mock_datetime_now(self.target_dt, module_datetime) def evaluate_declaration(declaration, force_sequence=None): - kwargs = {'attr': declaration} + kwargs = {"attr": declaration} if force_sequence is not None: - kwargs['__sequence'] = force_sequence + kwargs["__sequence"] = force_sequence - return factory.build(dict, **kwargs)['attr'] + return factory.build(dict, **kwargs)["attr"] From 083ec1923aa8e5144ae7f6aea2c352f665f08d4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Freitag?= Date: Fri, 2 Jul 2021 18:19:53 +0200 Subject: [PATCH 4/4] Boost line length to 120 --- MANIFEST.in | 2 +- docs/conf.py | 4 +-- .../generic_foreignkey/factories.py | 4 +-- factory/alchemy.py | 9 ++--- factory/base.py | 36 ++++++------------- factory/builder.py | 20 ++++------- factory/declarations.py | 23 +++--------- factory/django.py | 13 +++---- factory/fuzzy.py | 34 +++++------------- factory/utils.py | 3 +- pyproject.toml | 3 ++ tests/test_django.py | 16 ++------- tests/test_docs_internals.py | 6 ++-- 13 files changed, 47 insertions(+), 126 deletions(-) create mode 100644 pyproject.toml diff --git a/MANIFEST.in b/MANIFEST.in index c56cd9c7..8cfeeb36 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,5 +1,5 @@ include ChangeLog CODE_OF_CONDUCT.md CONTRIBUTING.rst CREDITS LICENSE README.rst -include Makefile tox.ini +include Makefile pyproject.toml tox.ini graft factory diff --git a/docs/conf.py b/docs/conf.py index 53e363ce..6fdc27d6 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -64,9 +64,7 @@ if "READTHEDOCS_VERSION" in os.environ: # Use the readthedocs version string in preference to our known version. - html_title = "{} {} documentation".format( - project, os.environ["READTHEDOCS_VERSION"] - ) + html_title = "{} {} documentation".format(project, os.environ["READTHEDOCS_VERSION"]) # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, diff --git a/examples/django_demo/generic_foreignkey/factories.py b/examples/django_demo/generic_foreignkey/factories.py index 460019c3..c1dbf7de 100644 --- a/examples/django_demo/generic_foreignkey/factories.py +++ b/examples/django_demo/generic_foreignkey/factories.py @@ -22,9 +22,7 @@ class Meta: class TaggedItemFactory(factory.django.DjangoModelFactory): object_id = factory.SelfAttribute("content_object.id") - content_type = factory.LazyAttribute( - lambda o: ContentType.objects.get_for_model(o.content_object) - ) + content_type = factory.LazyAttribute(lambda o: ContentType.objects.get_for_model(o.content_object)) class Meta: exclude = ["content_object"] diff --git a/factory/alchemy.py b/factory/alchemy.py index c879e8ce..1bc26424 100644 --- a/factory/alchemy.py +++ b/factory/alchemy.py @@ -57,8 +57,7 @@ def _get_or_create(cls, model_class, session, args, kwargs): if field not in kwargs: raise errors.FactoryError( "sqlalchemy_get_or_create - " - "Unable to find initialization value for '%s' in factory %s" - % (field, cls.__name__) + "Unable to find initialization value for '%s' in factory %s" % (field, cls.__name__) ) key_fields[field] = kwargs.pop(field) @@ -76,11 +75,7 @@ def _get_or_create(cls, model_class, session, args, kwargs): } if get_or_create_params: try: - obj = ( - session.query(model_class) - .filter_by(**get_or_create_params) - .one() - ) + obj = session.query(model_class).filter_by(**get_or_create_params).one() except NoResultFound: # Original params are not a valid lookup and triggered a create(), # that resulted in an IntegrityError. diff --git a/factory/base.py b/factory/base.py index 925dfd70..1062fc12 100644 --- a/factory/base.py +++ b/factory/base.py @@ -41,9 +41,7 @@ def __call__(cls, **kwargs): elif cls._meta.strategy == enums.STUB_STRATEGY: return cls.stub(**kwargs) else: - raise errors.UnknownStrategy( - "Unknown Meta.strategy: {}".format(cls._meta.strategy) - ) + raise errors.UnknownStrategy("Unknown Meta.strategy: {}".format(cls._meta.strategy)) def __new__(mcs, class_name, bases, attrs): """Record attributes as a pattern for later instance construction. @@ -193,9 +191,7 @@ def _fill_from_meta(self, meta, base_meta): } for option in self._build_default_options(): - assert not hasattr(self, option.name), ( - "Can't override field %s." % option.name - ) + assert not hasattr(self, option.name), "Can't override field %s." % option.name value = option.apply(meta, base_meta) meta_attrs.pop(option.name, None) setattr(self, option.name, value) @@ -203,13 +199,10 @@ def _fill_from_meta(self, meta, base_meta): if meta_attrs: # Some attributes in the Meta aren't allowed here raise TypeError( - "'class Meta' for %r got unknown attribute(s) %s" - % (self.factory, ",".join(sorted(meta_attrs.keys()))) + "'class Meta' for %r got unknown attribute(s) %s" % (self.factory, ",".join(sorted(meta_attrs.keys()))) ) - def contribute_to_class( - self, factory, meta=None, base_meta=None, base_factory=None, params=None - ): + def contribute_to_class(self, factory, meta=None, base_meta=None, base_factory=None, params=None): self.factory = factory self.base_factory = base_factory @@ -235,17 +228,13 @@ def contribute_to_class( self.base_declarations[k] = v if params is not None: - for k, v in utils.sort_ordered_objects( - vars(params).items(), getter=lambda item: item[1] - ): + for k, v in utils.sort_ordered_objects(vars(params).items(), getter=lambda item: item[1]): if not k.startswith("_"): self.parameters[k] = declarations.SimpleParameter.wrap(v) self._check_parameter_dependencies(self.parameters) - self.pre_declarations, self.post_declarations = builder.parse_declarations( - self.declarations - ) + self.pre_declarations, self.post_declarations = builder.parse_declarations(self.declarations) def _get_counter_reference(self): """Identify which factory should be used for a shared counter.""" @@ -311,7 +300,7 @@ def prepare_arguments(self, attributes): for k, v in kwargs.items() if k not in self.exclude and k not in self.parameters - and v is not declarations.SKIP + and v is not declarations.SKIP # fmt: skip } # 3. Rename fields @@ -373,21 +362,16 @@ def _check_parameter_dependencies(self, parameters): field_revdeps = parameter.get_revdeps(parameters) if not field_revdeps: continue - deep_revdeps[name] = set.union( - *(deep_revdeps[dep] for dep in field_revdeps) - ) + deep_revdeps[name] = set.union(*(deep_revdeps[dep] for dep in field_revdeps)) deep_revdeps[name] |= set(field_revdeps) for dep in field_revdeps: deps[dep].add(name) # Check for cyclical dependencies - cyclic = [ - name for name, field_deps in deep_revdeps.items() if name in field_deps - ] + cyclic = [name for name, field_deps in deep_revdeps.items() if name in field_deps] if cyclic: raise errors.CyclicDefinitionError( - "Cyclic definition detected on %r; Params around %s" - % (self.factory, ", ".join(cyclic)) + "Cyclic definition detected on %r; Params around %s" % (self.factory, ", ".join(cyclic)) ) return deps diff --git a/factory/builder.py b/factory/builder.py index 1eeafd4b..ab88ef53 100644 --- a/factory/builder.py +++ b/factory/builder.py @@ -78,7 +78,7 @@ def update(self, values): { self.join(root, sub): v for root in extra_context_keys - for sub, v in self.contexts[root].items() + for sub, v in self.contexts[root].items() # fmt: skip }, sorted(self.declarations), ) @@ -148,8 +148,7 @@ def parse_declarations(decls, base_pre=None, base_post=None): # Conflict: PostGenerationDeclaration with the same # name as a BaseDeclaration raise errors.InvalidDeclarationError( - "PostGenerationDeclaration %s=%r shadows declaration %r" - % (k, v, pre_declarations[k]) + "PostGenerationDeclaration %s=%r shadows declaration %r" % (k, v, pre_declarations[k]) ) extra_post[k] = v elif k in post_declarations: @@ -157,9 +156,7 @@ def parse_declarations(decls, base_pre=None, base_post=None): # Set it as `key__` magic_key = post_declarations.join(k, "") extra_post[magic_key] = v - elif k in pre_declarations and isinstance( - pre_declarations[k].declaration, declarations.Transformer - ): + elif k in pre_declarations and isinstance(pre_declarations[k].declaration, declarations.Transformer): extra_maybenonpost[k] = pre_declarations[k].declaration.function(v) else: extra_maybenonpost[k] = v @@ -214,8 +211,7 @@ def recurse(self, factory, declarations, force_sequence=None): if not issubclass(factory, base.BaseFactory): raise errors.AssociatedClassError( - "%r: Attempting to recursing into a non-factory object %r" - % (self, factory) + "%r: Attempting to recursing into a non-factory object %r" % (self, factory) ) builder = self.builder.recurse(factory._meta, declarations) return builder.build(parent_step=self, force_sequence=force_sequence) @@ -337,18 +333,14 @@ def __getattr__(self, name): """ if name in self.__pending: raise errors.CyclicDefinitionError( - "Cyclic lazy attribute definition for %r; cycle found in %r." - % (name, self.__pending) + "Cyclic lazy attribute definition for %r; cycle found in %r." % (name, self.__pending) ) elif name in self.__values: return self.__values[name] elif name in self.__declarations: declaration = self.__declarations[name] value = declaration.declaration - if ( - enums.get_builder_phase(value) - == enums.BuilderPhase.ATTRIBUTE_RESOLUTION - ): + if enums.get_builder_phase(value) == enums.BuilderPhase.ATTRIBUTE_RESOLUTION: self.__pending.append(name) try: value = value.evaluate_pre( diff --git a/factory/declarations.py b/factory/declarations.py index 817b51aa..be18cfd7 100644 --- a/factory/declarations.py +++ b/factory/declarations.py @@ -210,9 +210,7 @@ def __init__(self, iterator, cycle=True, getter=None): self.iterator = None if cycle: - self.iterator_builder = lambda: utils.ResetableIterator( - itertools.cycle(iterator) - ) + self.iterator_builder = lambda: utils.ResetableIterator(itertools.cycle(iterator)) else: self.iterator_builder = lambda: utils.ResetableIterator(iterator) @@ -305,10 +303,7 @@ def evaluate(self, instance, step, extra): # Strip the current instance from the chain chain = step.chain[1:] if self.strict and not chain: - raise TypeError( - "A ContainerAttribute in 'strict' mode can only be used " - "within a SubFactory." - ) + raise TypeError("A ContainerAttribute in 'strict' mode can only be used within a SubFactory.") return self.function(instance, chain) @@ -484,11 +479,7 @@ def __init__(self, decider, yes_declaration=SKIP, no_declaration=SKIP): if len(used_phases) > 1: raise TypeError(f"Inconsistent phases for {self!r}: {phases!r}") - self.FACTORY_BUILDER_PHASE = ( - used_phases.pop() - if used_phases - else enums.BuilderPhase.ATTRIBUTE_RESOLUTION - ) + self.FACTORY_BUILDER_PHASE = used_phases.pop() if used_phases else enums.BuilderPhase.ATTRIBUTE_RESOLUTION def evaluate_post(self, instance, step, overrides): """Handle post-generation declarations""" @@ -496,14 +487,10 @@ def evaluate_post(self, instance, step, overrides): if decider_phase == enums.BuilderPhase.ATTRIBUTE_RESOLUTION: # Note: we work on the *builder stub*, not on the actual instance. # This gives us access to all Params-level definitions. - choice = self.decider.evaluate_pre( - instance=step.stub, step=step, overrides=overrides - ) + choice = self.decider.evaluate_pre(instance=step.stub, step=step, overrides=overrides) else: assert decider_phase == enums.BuilderPhase.POST_INSTANTIATION - choice = self.decider.evaluate_post( - instance=instance, step=step, overrides={} - ) + choice = self.decider.evaluate_post(instance=instance, step=step, overrides={}) target = self.yes if choice else self.no if enums.get_builder_phase(target) == enums.BuilderPhase.POST_INSTANTIATION: diff --git a/factory/django.py b/factory/django.py index 6cd54ea4..1fbf4973 100644 --- a/factory/django.py +++ b/factory/django.py @@ -101,9 +101,7 @@ def _load_model_class(cls, definition): @classmethod def _get_manager(cls, model_class): if model_class is None: - raise errors.AssociatedClassError( - f"No model set on {cls.__module__}.{cls.__name__}.Meta" - ) + raise errors.AssociatedClassError(f"No model set on {cls.__module__}.{cls.__name__}.Meta") try: manager = model_class.objects @@ -129,18 +127,15 @@ def _get_or_create(cls, model_class, *args, **kwargs): manager = cls._get_manager(model_class) assert "defaults" not in cls._meta.django_get_or_create, ( - "'defaults' is a reserved keyword for get_or_create " - "(in %s._meta.django_get_or_create=%r)" - % (cls, cls._meta.django_get_or_create) - ) + "'defaults' is a reserved keyword for get_or_create (in %s._meta.django_get_or_create=%r)" + ) % (cls, cls._meta.django_get_or_create) key_fields = {} for field in cls._meta.django_get_or_create: if field not in kwargs: raise errors.FactoryError( "django_get_or_create - " - "Unable to find initialization value for '%s' in factory %s" - % (field, cls.__name__) + "Unable to find initialization value for '%s' in factory %s" % (field, cls.__name__) ) key_fields[field] = kwargs.pop(field) key_fields["defaults"] = kwargs diff --git a/factory/fuzzy.py b/factory/fuzzy.py index b7056d64..e792fa5c 100644 --- a/factory/fuzzy.py +++ b/factory/fuzzy.py @@ -168,18 +168,13 @@ def __init__(self, start_date, end_date=None): end_date = datetime.date.today() if start_date > end_date: - raise ValueError( - "FuzzyDate boundaries should have start <= end; got %r > %r." - % (start_date, end_date) - ) + raise ValueError("FuzzyDate boundaries should have start <= end; got %r > %r." % (start_date, end_date)) self.start_date = start_date.toordinal() self.end_date = end_date.toordinal() def fuzz(self): - return datetime.date.fromordinal( - random.randgen.randint(self.start_date, self.end_date) - ) + return datetime.date.fromordinal(random.randgen.randint(self.start_date, self.end_date)) class BaseFuzzyDateTime(BaseFuzzyAttribute): @@ -191,8 +186,7 @@ class BaseFuzzyDateTime(BaseFuzzyAttribute): def _check_bounds(self, start_dt, end_dt): if start_dt > end_dt: raise ValueError( - """%s boundaries should have start <= end, got %r > %r""" - % (self.__class__.__name__, start_dt, end_dt) + """%s boundaries should have start <= end, got %r > %r""" % (self.__class__.__name__, start_dt, end_dt) ) def _now(self): @@ -232,9 +226,7 @@ def __init__( def fuzz(self): delta = self.end_dt - self.start_dt - microseconds = delta.microseconds + 1000000 * ( - delta.seconds + (delta.days * 86400) - ) + microseconds = delta.microseconds + 1000000 * (delta.seconds + (delta.days * 86400)) offset = random.randgen.randint(0, microseconds) result = self.start_dt + datetime.timedelta(microseconds=offset) @@ -268,14 +260,9 @@ def _now(self): def _check_bounds(self, start_dt, end_dt): if start_dt.tzinfo is not None: - raise ValueError( - "FuzzyNaiveDateTime only handles naive datetimes, got start=%r" - % start_dt - ) + raise ValueError("FuzzyNaiveDateTime only handles naive datetimes, got start=%r" % start_dt) if end_dt.tzinfo is not None: - raise ValueError( - "FuzzyNaiveDateTime only handles naive datetimes, got end=%r" % end_dt - ) + raise ValueError("FuzzyNaiveDateTime only handles naive datetimes, got end=%r" % end_dt) super()._check_bounds(start_dt, end_dt) @@ -291,12 +278,7 @@ def _now(self): def _check_bounds(self, start_dt, end_dt): if start_dt.tzinfo is None: - raise ValueError( - "FuzzyDateTime requires timezone-aware datetimes, got start=%r" - % start_dt - ) + raise ValueError("FuzzyDateTime requires timezone-aware datetimes, got start=%r" % start_dt) if end_dt.tzinfo is None: - raise ValueError( - "FuzzyDateTime requires timezone-aware datetimes, got end=%r" % end_dt - ) + raise ValueError("FuzzyDateTime requires timezone-aware datetimes, got end=%r" % end_dt) super()._check_bounds(start_dt, end_dt) diff --git a/factory/utils.py b/factory/utils.py index f9daae79..8563f386 100644 --- a/factory/utils.py +++ b/factory/utils.py @@ -34,8 +34,7 @@ def __repr__(self): def __str__(self): return ", ".join( - [repr(arg) for arg in self.args] - + ["%s=%s" % (key, repr(value)) for key, value in self.kwargs.items()] + [repr(arg) for arg in self.args] + ["%s=%s" % (key, repr(value)) for key, value in self.kwargs.items()] ) diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..755d878e --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,3 @@ +[tool.black] +line-length = 120 +target-version = ['py36'] diff --git a/tests/test_django.py b/tests/test_django.py index eea475cd..b2dd0378 100644 --- a/tests/test_django.py +++ b/tests/test_django.py @@ -208,11 +208,7 @@ def test_simple_call(self): self.assertEqual(obj1, obj2) self.assertEqual( - list( - models.MultifieldModel.objects.order_by("slug").values_list( - "slug", flat=True - ) - ), + list(models.MultifieldModel.objects.order_by("slug").values_list("slug", flat=True)), ["alt", "slug1"], ) @@ -228,11 +224,7 @@ def test_multicall(self): self.assertEqual(6, len(objs)) self.assertEqual(2, len(set(objs))) self.assertEqual( - list( - models.MultifieldModel.objects.order_by("slug").values_list( - "slug", flat=True - ) - ), + list(models.MultifieldModel.objects.order_by("slug").values_list("slug", flat=True)), ["alt", "main"], ) @@ -916,9 +908,7 @@ def test_context_manager(self): def test_receiver_created_during_model_instantiation_is_not_lost(self): with factory.django.mute_signals(signals.post_save): - instance = WithSignalsFactory( - post_save_signal_receiver=self.handlers.created_during_instantiation - ) + instance = WithSignalsFactory(post_save_signal_receiver=self.handlers.created_during_instantiation) self.assertTrue(self.handlers.created_during_instantiation.called) self.handlers.created_during_instantiation.reset_mock() diff --git a/tests/test_docs_internals.py b/tests/test_docs_internals.py index 276fbd18..2b458438 100644 --- a/tests/test_docs_internals.py +++ b/tests/test_docs_internals.py @@ -100,10 +100,8 @@ class Params: "enabled", None, factory.fuzzy.FuzzyDateTime( - datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) - - datetime.timedelta(days=10), - datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) - - datetime.timedelta(days=1), + datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) - datetime.timedelta(days=10), + datetime.datetime.now().replace(tzinfo=datetime.timezone.utc) - datetime.timedelta(days=1), ), )