text: Title: Provide some basic Django Auth Factories (User, Group, Permission...)
  Body: #### The problem
  Any project who uses `django.contrib.auth` and/or `django.contrib.contenttypes` now has to create the factories for User, Group, Permission, ContentType for using them in his tests, right?
  Why we do not provide related Factories for them as they are very basic models... 
  
  #### Proposed solution
  Something similar to:
  ```
  import factory
  import factory.fuzzy
  from django.contrib.auth import get_user_model
  from django.contrib.auth.models import Group, Permission
  from django.contrib.contenttypes.models import ContentType
  from factory.django import DjangoModelFactory
  
  class ContentTypeFactory(factory.django.DjangoModelFactory):
      class Meta:
          model = ContentType
          django_get_or_create = ('app_label', 'model')
  
      app_label = factory.Faker("word")
      model = factory.Faker("word")
  
  
  class PermissionFactory(DjangoModelFactory):
      class Meta:
          model = Permission
          django_get_or_create = ("name",)
  
      name = factory.Faker("name")
      content_type = factory.SubFactory(ContentTypeFactory)
  
  
  class GroupFactory(DjangoModelFactory):
      class Meta:
          model = Group
          django_get_or_create = ("name",)
  
      name = factory.Faker("name")
  
  
  class UserFactory(DjangoModelFactory):
  
      username = factory.Faker("user_name")
      email = factory.Faker("email")
      password = factory.Faker("password")
  
      is_active = True
      is_staff = False
      is_superuser = False
  
      class Meta:
          model = get_user_model()
          django_get_or_create = ("username",)
  
      @classmethod
      def _create(cls, model_class, *args, **kwargs):
          """Override the default ``_create`` with our custom call."""
          manager = cls._get_manager(model_class)
          # Some support to generate auth users.... 
          if kwargs.get("is_superuser"):
              return manager.create_superuser(*args, **kwargs)
          return manager.create_user(*args, **kwargs)
  
      @factory.post_generation
      def groups(self, create, extracted, **kwargs):
          if not create:
              # Simple build, do nothing.
              return
  
          if extracted:
              # A list of groups were passed in, use them
              for group in extracted:
                  self.groups.add(Group.objects.get_or_create(name=group)[0])
  
      @factory.post_generation
      def user_permissions(self, create, extracted, **kwargs):
  
          if not create:
              # Simple build, do nothing.
              return
  
          if extracted:
              # A list of tuple (ModelClass, "my_permission")
              for model, permission in extracted:
                  content_type = ContentType.objects.get_for_model(model)
                  self.user_permissions.add(
                      Permission.objects.get_or_create(
                          codename=permission, content_type=content_type
                      )[0]
                  )
  ```
  #### Extra notes
  Please, notice this is only a draft... I have to refine them :) 
  If could be interesting I can set up a PR draft :) 
  
  
  