Feature/enhance django support

.gitignore

@@ -10,3 +10,6 @@
 *.egg-info/*
 docs/_build/*
 dist/*
+venv/*
+.eggs/*
+build/*

django_faker/__init__.py

@@ -9,7 +9,6 @@
 __version__ = '0.2.1'
 
 class Faker(object):
-
     instance = None
     populators = {}
     generators = {}
@@ -21,10 +20,8 @@ def __new__(cls, *args, **kwargs):
         return cls.instance
 
     def __init__(self):
-#        assert False, "Cannot create a instance of Faker"
         pass
 
-
     @staticmethod
     def getCodename(locale=None, providers=None):
         """
@@ -43,68 +40,41 @@ def getCodename(locale=None, providers=None):
 
         return codename
 
-
     @classmethod
     def getGenerator(cls, locale=None, providers=None, codename=None):
         """
         use a codename to cache generators
         """
-
         codename = codename or cls.getCodename(locale, providers)
 
         if codename not in cls.generators:
             from faker import Faker as FakerGenerator
-            # initialize with faker.generator.Generator instance
-            # and remember in cache
-            cls.generators[codename] = FakerGenerator( locale, providers )
-            cls.generators[codename].seed( cls.generators[codename].randomInt() )
+            generator = FakerGenerator(locale=locale)
+            if providers:
+                for provider in providers:
+                    generator.add_provider(provider)
+            cls.generators[codename] = generator
+            FakerGenerator.seed()
 
         return cls.generators[codename]
 
-
-
     @classmethod
     def getPopulator(cls, locale=None, providers=None):
         """
-
         uses:
-
             from django_faker import Faker
             pop = Faker.getPopulator()
-
+            
             from myapp import models
             pop.addEntity(models.MyModel, 10)
             pop.addEntity(models.MyOtherModel, 10)
             pop.execute()
-
-            pop = Faker.getPopulator('it_IT')
-
-            pop.addEntity(models.MyModel, 10)
-            pop.addEntity(models.MyOtherModel, 10)
-            pop.execute()
-
         """
-
         codename = cls.getCodename(locale, providers)
 
         if codename not in cls.populators:
-
-            generator = cls.generators.get(codename,  None) or cls.getGenerator(codename=codename)
-
+            generator = cls.generators.get(codename, None) or cls.getGenerator(codename=codename)
             from django_faker import populator
+            cls.populators[codename] = populator.Populator(generator)
 
-            cls.populators[codename] = populator.Populator( generator )
-
-        return cls.populators[codename]
-
-#        if not cls.populator:
-#            cls.populator= populators.Populator(
-#            # initialize with faker.generator.Generator instance
-#            FakerGenerator(
-#
-#                getattr(settings,'FAKER_LOCALE', getattr(settings,'LANGUAGE_CODE', locale)),
-#
-#                getattr(settings,'FAKER_PROVIDERS', providers)
-#            )
-#        )
-
+        return cls.populators[codename]

django_faker/guessers.py

@@ -15,17 +15,17 @@ def guessFormat(self, name):
         name = name.lower()
         generator = self.generator
         if re.findall(r'^is[_A-Z]', name): return lambda x:generator.boolean()
-        if re.findall(r'(_a|A)t$', name): return lambda x:generator.dateTime()
+        if re.findall(r'(_a|A)t$', name): return lambda x:generator.date_time()
 
-        if name in ('first_name','firstname'): return lambda x: generator.firstName()
-        if name in ('last_name','lastname'): return lambda x: generator.lastName()
+        if name in ('first_name','firstname'): return lambda x: generator.first_name()
+        if name in ('last_name','lastname'): return lambda x: generator.last_name()
 
-        if name in ('username','login','nickname'): return lambda x:generator.userName()
+        if name in ('username','login','nickname'): return lambda x:generator.user_name()
         if name in ('email','email_address'): return lambda x:generator.email()
-        if name in ('phone_number','phonenumber','phone'): return lambda x:generator.phoneNumber()
+        if name in ('phone_number','phonenumber','phone'): return lambda x:generator.phone_number()
         if name == 'address' : return lambda x:generator.address()
         if name == 'city' : return lambda x: generator.city()
-        if name == 'streetaddress' : return lambda x: generator.streetaddress()
+        if name == 'streetaddress' : return lambda x: generator.street_address()
         if name in ('postcode','zipcode'): return lambda x: generator.postcode()
         if name == 'state' : return lambda x: generator.state()
         if name == 'country' : return lambda x: generator.country()

django_faker/populator.py

@@ -1,8 +1,8 @@
 import random
 from django_faker.guessers import Name
 from django.db.models.fields import *
-from django.db.models import ForeignKey, ManyToManyField, OneToOneField, ImageField
-
+from django.db.models import ForeignKey, ManyToManyField, OneToOneField, ImageField, DurationField
+from datetime import timedelta
 
 class FieldTypeGuesser(object):
 
@@ -18,19 +18,21 @@ def guessFormat(self, field):
         if isinstance(field, BooleanField): return lambda x: generator.boolean()
         if isinstance(field, NullBooleanField): return lambda x: generator.nullBoolean()
         if isinstance(field, DecimalField): return lambda x: generator.pydecimal(rightDigits=field.decimal_places)
-        if isinstance(field, SmallIntegerField): return lambda x: generator.randomInt(0,65535)
-        if isinstance(field, IntegerField): return lambda x: generator.randomInt(0,4294967295)
-        if isinstance(field, BigIntegerField): return lambda x: generator.randomInt(0,18446744073709551615)
+        if isinstance(field, SmallIntegerField): return lambda x: generator.random_int(0,65535)
+        if isinstance(field, IntegerField): return lambda x: generator.random_int(0,4294967295)
+        if isinstance(field, BigIntegerField): return lambda x: generator.random_int(0,18446744073709551615)
         if isinstance(field, FloatField): return lambda x: generator.pyfloat()
         if isinstance(field, CharField):
             if field.choices:
-                return lambda x: generator.randomElement(field.choices)[0]
+                return lambda x: generator.random_element(field.choices)[0]
             return lambda x: generator.text(field.max_length) if field.max_length >= 5 else generator.word()
         if isinstance(field, TextField): return lambda x: generator.text()
 
         if isinstance(field, DateTimeField): return lambda x: generator.dateTime()
         if isinstance(field, DateField): return lambda x: generator.date()
         if isinstance(field, TimeField): return lambda x: generator.time()
+        if isinstance(field, DurationField): return lambda x: timedelta(seconds=generator.random_int(60, 86400))
+
 
         if isinstance(field, URLField): return lambda x: generator.uri()
         if isinstance(field, SlugField): return lambda x: generator.slug()
@@ -62,7 +64,7 @@ def guessFieldFormatters(self, generator):
         #            yield field.name, getattr(self, field.name)
             fieldName = field.name
             if isinstance(field, (ForeignKey,ManyToManyField,OneToOneField)):
-                relatedModel = field.rel.to
+                relatedModel = field.remote_field.model
 
                 def build_relation(inserted):
                     if relatedModel in inserted and inserted[relatedModel]:

django_faker/tests.py

@@ -2,13 +2,16 @@
 from django_faker.populator import Populator
 from django_faker import Faker as DjangoFaker
 
+import django
 from django.db import models
-from django.utils import unittest
+import unittest
+from unittest import skipIf
 from django.template import Context, TemplateSyntaxError
 from django.template import Template
 
 fake = Faker()
 
+
 class Game(models.Model):
 
     title= models.CharField(max_length=200)
@@ -26,8 +29,13 @@ class Player(models.Model):
     nickname= models.CharField(max_length=100)
     score= models.BigIntegerField()
     last_login_at= models.DateTimeField()
+    game= models.ForeignKey(Game, on_delete=models.CASCADE)
+
 
-    game= models.ForeignKey(Game)
+class GamePlayTime(models.Model):
+    game = models.ForeignKey(Game, on_delete=models.CASCADE)
+    player = models.ForeignKey(Player, on_delete=models.CASCADE)
+    duration = models.DurationField()
 
 
 class Action(models.Model):
@@ -46,9 +54,26 @@ class Action(models.Model):
     name= models.CharField(max_length=4, choices=ACTIONS)
     executed_at= models.DateTimeField()
 
-    actor= models.ForeignKey(Player,related_name='actions', null=True)
-    target= models.ForeignKey(Player, related_name='enemy_actions+', null=True)
+    actor= models.ForeignKey(Player, on_delete=models.CASCADE, related_name='actions', null=True)
+    target= models.ForeignKey(Player, on_delete=models.CASCADE, related_name='enemy_actions+', null=True)
+
+class TestDurationField(unittest.TestCase):
+    def testGamePlayTime(self):
+        generator = fake
+
+        populator = Populator(generator)
+        populator.addEntity(Game, 10)
+        populator.addEntity(Player, 10, {
+            'game': lambda x: Game.objects.order_by('?').first()
+        })
+        populator.addEntity(GamePlayTime, 10, {
+            'game': lambda x: Game.objects.order_by('?').first(),
+            'player': lambda x: Player.objects.order_by('?').first()
+        })
+
+        insertedPks = populator.execute()
 
+        self.assertEqual(len(insertedPks[GamePlayTime]), 10)
 
 class PopulatorTestCase(unittest.TestCase):
 
@@ -83,7 +108,7 @@ def testFormatter(self):
 
         populator.addEntity(Game,5)
         populator.addEntity(Player, 10, {
-            'score': lambda x: fake.randomInt(0,1000),
+            'score': lambda x: fake.random_int(0,1000),
             'nickname': lambda x: fake.email()
         })
         populator.addEntity(Action,30)
@@ -96,6 +121,7 @@ def testFormatter(self):
         self.assertTrue( any([0 <= p.score <= 1000 and '@' in p.nickname for p in Player.objects.all() ]) )
 
 
+@skipIf(django.VERSION >= (2, 0), "Template tags not supported in Django 2.0+")
 class TemplateTagsTestCase(unittest.TestCase):
 
     @staticmethod
@@ -151,7 +177,7 @@ def testOrFakeFilterTag(self):
     def testFullXmlContact(self):
         self.assertTrue(self.render("""<?xml version="1.0" encoding="UTF-8"?>
 <contacts>
-    {% fake 'randomInt' 10 20 as times %}
+    {% fake 'random_int' 10 20 as times %}
     {% for i in 10|get_range %}
     <contact firstName="{% fake 'firstName' %}" lastName="{% fake 'lastName' %}" email="{% fake 'email' %}"/>
         <phone number="{% fake 'phoneNumber' %}"/>

runtests.py

@@ -2,6 +2,7 @@
 import sys
 
 from django.conf import settings
+import django
 
 def configure():
 
@@ -22,6 +23,7 @@ def configure():
         SITE_ID=1,
         SECRET_KEY=fake.sha1(),
     )
+    django.setup()
 
 if not settings.configured: configure()