Merge pull request #38 from diogoosorio/fix-seed-command-number-argument

Fix seed command unrecognized "number" argument

.gitignore

@@ -28,4 +28,7 @@ sdist/
 var/
 *.egg-info/
 .installed.cfg
-*.egg
+*.egg
+
+env/
+.idea

.travis.yml

@@ -4,13 +4,9 @@ python:
   - "3.4"
   - "3.5"
 env:
-  - DJANGO=1.7
   - DJANGO=1.8
   - DJANGO=1.9
-matrix:
-  exclude:
-   - python: "3.5"
-     env: DJANGO=1.7
+  - DJANGO=1.10
 install:
   - pip install -q Django==$DJANGO
   - pip install coverage
@@ -20,4 +16,4 @@ install:
 script:
   - python runtests.py
 after_success:
-  - coveralls
+  - coveralls

django_seed/guessers.py

@@ -1,30 +1,20 @@
-
-from django.db.models.fields import *
 from django.db.models import *
+from django.conf import settings
+from django.utils import timezone
 
-import django
 import random
 import re
 
 from .providers import Provider
 
-# use timezone aware datetimes if active
-try:
-    # import django settings
-    from django.conf import settings
-    # check if timezone is active
-    if getattr(settings, 'USE_TZ', False):
-        # make datetime timezone aware
-        from django.utils import timezone
-        _timezone_format = lambda value: timezone.make_aware(
-            value, timezone.get_current_timezone()
-        )
-    else:
-        # keep value as is
-        _timezone_format = lambda x: x
-except ImportError:
-    # django not available, keep value as is
-    _timezone_format = lambda x: x
+def _timezone_format(value):
+    """
+    Generates a timezone aware datetime if the 'USE_TZ' setting is enabled
+
+    :param value: The datetime value
+    :return: A locale aware datetime
+    """
+    return timezone.make_aware(value, timezone.get_current_timezone()) if getattr(settings, 'USE_TZ', False) else value
 
 
 class NameGuesser(object):
@@ -40,7 +30,7 @@ def guess_format(self, name):
         name = name.lower()
         faker = self.faker
         if re.findall(r'^is[_A-Z]', name): return lambda x:faker.boolean()
-        elif re.findall(r'(_a|A)t$', name): return lambda x:faker.date_time()
+        elif re.findall(r'(_a|A)t$', name): return lambda x: _timezone_format(faker.date_time())
 
         if name in ('first_name', 'firstname', 'first'): return lambda x: faker.first_name()
         if name in ('last_name', 'lastname', 'last'): return lambda x: faker.last_name()
@@ -75,11 +65,9 @@ def guess_format(self, field):
         faker = self.faker
         provider = self.provider
 
-        if django.VERSION[1] >= 8:
-            if isinstance(field, DurationField):
-                return lambda x: provider.duration()
-            if isinstance(field, UUIDField):
-                return lambda x: provider.uuid()
+
+        if isinstance(field, DurationField): return lambda x: provider.duration()
+        if isinstance(field, UUIDField): return lambda x: provider.uuid()
 
         if isinstance(field, BooleanField): return lambda x: faker.boolean()
         if isinstance(field, NullBooleanField): return lambda x: faker.null_boolean()

django_seed/management/commands/seed.py

@@ -18,6 +18,13 @@ class Command(AppCommand):
                     help='number of each model to seed'),
     ]
 
+    def add_arguments(self, parser):
+        super(Command, self).add_arguments(parser)
+
+        parser.add_argument('--number', nargs='?', type=int, default=10, const=10,
+                    help='number of each model to seed')
+
+
     def handle_app_config(self, app_config, **options):
         if app_config.models_module is None:
             raise SeederCommandError('You must provide an app to seed')
@@ -38,14 +45,11 @@ def handle_app_config(self, app_config, **options):
 
     def dependencies(self, model):
         dependencies = set()
-        if hasattr(model._meta, 'get_fields'):  # Django>=1.8
-            for field in model._meta.get_fields():
-                if field.many_to_one is True and field.concrete and field.blank is False:
-                    dependencies.add(field.related_model)
-        else:  # Django<=1.7
-            for field in model._meta.fields:
-                if isinstance(field, ForeignKey) and field.blank is False:
-                    dependencies.add(field.rel.to)
+
+        for field in model._meta.get_fields():
+            if field.many_to_one is True and field.concrete and field.blank is False:
+                dependencies.add(field.related_model)
+
         return dependencies
 
     def sorted_models(self, app_config):

django_seed/seeder.py

@@ -61,7 +61,7 @@ def guess_field_formatters(self, faker):
 
     def execute(self, using, inserted_entities):
         """
-        Execute the stages entities to inserte
+        Execute the stages entities to insert
         :param using:
         :param inserted_entities:
         """

django_seed/tests.py

@@ -1,27 +1,51 @@
+from contextlib import contextmanager
 from datetime import datetime
+
+from django.utils import timezone
 from faker import Faker
+
+from django_seed.guessers import NameGuesser, FieldTypeGuesser
 from django_seed.seeder import Seeder
 from django_seed.exceptions import SeederException, SeederCommandError
 from django_seed import Seed
 
 import random
-import django
 
 from django.db import models
+from django.conf import settings
+from django.core.management import call_command
+
 try:
     from django.utils.unittest import TestCase
 except:
     from django.test import TestCase
-from django.core.management import call_command
 
 
 fake = Faker()
 
+@contextmanager
+def django_setting(name, value):
+    """
+    Generator that mutates the django.settings object during the context of a test run.
+
+    :param name: The setting name to be affected
+    :param value: The setting value to be defined during the execution
+    :return:
+    """
+    original_value = getattr(settings, name)
+    setattr(settings, name, value)
+
+    try:
+        yield
+    finally:
+        setattr(settings, name, original_value)
+
 
 class Game(models.Model):
     title = models.CharField(max_length=200)
     slug = models.SlugField(max_length=200)
     description = models.TextField()
+    game_started = models.DateTimeField()
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
     updated_date = models.DateField()
@@ -57,13 +81,50 @@ class Action(models.Model):
     )
     name = models.CharField(max_length=4, choices=ACTIONS)
     executed_at = models.DateTimeField()
-    if django.VERSION[1] >= 8:
-        duration = models.DurationField()
-        uuid = models.UUIDField()
+    duration = models.DurationField()
+    uuid = models.UUIDField()
     actor = models.ForeignKey(Player,related_name='actions', null=False)
     target = models.ForeignKey(Player, related_name='enemy_actions+', null=True)
 
 
+class NameGuesserTestCase(TestCase):
+
+    def setUp(self):
+        self.instance = NameGuesser(fake)
+
+    def test_guess_format_timezone(self):
+        test_names = ('something_at', 'something_At', 'gameUpdated_At', 'game_created_at')
+
+        with django_setting('USE_TZ', True):
+            for name in test_names:
+                value = self.instance.guess_format(name)(datetime.now())
+                self.assertTrue(timezone.is_aware(value))
+
+        with django_setting('USE_TZ', False):
+            for name in test_names:
+                value = self.instance.guess_format(name)(datetime.now())
+                self.assertFalse(timezone.is_aware(value))
+
+
+
+class FieldTypeGuesserTestCase(TestCase):
+
+    def setUp(self):
+        self.instance = FieldTypeGuesser(fake)
+
+    def test_guess_with_datetime(self):
+        generator = self.instance.guess_format(models.DateTimeField())
+
+        with django_setting('USE_TZ', True):
+            value = generator(datetime.now())
+            self.assertTrue(timezone.is_aware(value))
+
+        with django_setting('USE_TZ', False):
+            value = generator(datetime.now())
+            self.assertFalse(timezone.is_aware(value))
+
+
+
 class SeederTestCase(TestCase):
 
     def test_population(self):
@@ -85,30 +146,6 @@ def title_fake(arg):
         })
         self.assertEqual(len(seeder.execute()[Game]), title_fake.count)
 
-    def test_timezone(self):
-        """test if datetime objects are created timezone aware
-        based on USE_TZ in settings.py
-        """
-        faker = fake
-        seeder = Seeder(faker)
-        try:
-            # import django settings
-            from django.conf import settings
-            from django.utils import timezone
-        except ImportError:
-            pass
-        # check if timezone is active
-        if not getattr(settings, 'USE_TZ', False):
-            setattr(settings, 'USE_TZ', True)
-            deactivate_tz = True
-        else:
-            deactivate_tz = False
-        seeder.add_entity(Game, 1)
-        game = Game.objects.get(pk=seeder.execute()[Game][0])
-        if deactivate_tz:
-            # reset timezone settings
-            setattr(settings, 'USE_TZ', False)
-        self.assertTrue(timezone.is_aware(game.created_at))
 
     def valid_player(self, player):
         p = player

requirements-test.txt

@@ -1,5 +1,5 @@
 django
-fake-factory
+Faker
 coverage
 django-nose
 nose

requirements.txt

@@ -1,2 +1,2 @@
 django
-fake-factory
+Faker

setup.py

@@ -56,8 +56,8 @@ def find_version(*file_paths):
     ],
     keywords='faker fixtures data test django seed',
     long_description=open('README.rst', 'r').read(),
-    install_requires=['django>=1.7','fake-factory>=0.5.0'],
-    tests_require=['django>=1.7','fake-factory>=0.5.0', 'coverage', 'django-nose'],
+    install_requires=['django>=1.8','Faker>=0.7.7'],
+    tests_require=['django>=1.8','fake-factory>=0.5.0', 'coverage', 'django-nose'],
     test_suite="runtests.runtests",
     zip_safe=False,
 )