예제 #1
0
class AbstractUserFactory(DjangoModelFactory):
    """Abstract factory for creating users."""

    password = PostGenerationMethodCall("set_password", TEST_PASSWORD)
    username = Sequence(lambda n: "user%d" % n)
    first_name = Faker("first_name")
    last_name = Faker("last_name")
    # first_name = Faker('first_name_max_length_30')
    # last_name = Faker('last_name_max_length_30')
    email = Faker("ascii_safe_email")

    is_active = False
    is_staff = False
    is_superuser = False

    class Meta(object):
        """Meta options."""

        model = settings.AUTH_USER_MODEL
        django_get_or_create = ("username",)
        abstract = True

    @post_generation
    def groups(obj, created, extracted, **kwargs):
        """Create Group objects for the created User instance."""
        if created:
            # Create from 1 to 7 ``Group`` objects.
            amount = random.randint(1, 5)
            groups = LimitedGroupFactory.create_batch(amount)
            obj.groups.add(*groups)
예제 #2
0
class UserFactory(DjangoModelFactory):
    class Meta:
        model = User

    username = Sequence(lambda n: 'user%d' % n)
    password = PostGenerationMethodCall('set_password', 'test')
    email = LazyAttribute(lambda u: '*****@*****.**' % u.username)
예제 #3
0
파일: factories.py 프로젝트: pilam/pilam
class UserFactory(DjangoModelFactory):
    name = Faker('name_male')
    email = Faker('email')
    password = PostGenerationMethodCall('set_unusable_password')
    is_active = True
    class Meta:
        model = User
예제 #4
0
파일: factories.py 프로젝트: bigfang/horn
class UserFactory(BaseFactory):
    username = Sequence(lambda n: f'user{n}')
    email = Sequence(lambda n: f'user{n}@example.com')
    password = PostGenerationMethodCall('set_password', 'example')

    class Meta:
        model = User
예제 #5
0
class UserFactory(DjangoModelFactory):
    """Factory Boy factory for Improved User

    Generates a user with a default password of ``password!``.
    The user is active, but is not staff or a superuser.
    Any value can be overridden by passing in a value, as shown below.

    .. code:: python

        UserFactory(
            password='******',
            is_superuser=True,
        )
    """
    class Meta:
        """Configuration Options"""

        model = User

    email = Faker("email")
    password = PostGenerationMethodCall("set_password", "password!")
    full_name = Faker("name")
    short_name = Faker("first_name")
    is_active = True
    is_staff = False
    is_superuser = False
예제 #6
0
class UserFactory(DjangoModelFactory):
    username = Faker('uuid4')
    password = PostGenerationMethodCall('set_password', 'password')
    is_staff = False

    class Meta:
        model = User
예제 #7
0
class UserFactory(DjangoModelFactory):
    FACTORY_FOR = User

    username = Sequence(u'robot{0}'.format)
    email = Sequence(u'robot+test+{0}@edx.org'.format)
    password = PostGenerationMethodCall('set_password',
                                        'test')
    first_name = Sequence(u'Robot{0}'.format)
    last_name = 'Test'
    is_staff = False
    is_active = True
    is_superuser = False
    last_login = datetime(2012, 1, 1)
    date_joined = datetime(2011, 1, 1)

    @post_generation
    def profile(obj, create, extracted, **kwargs):
        if create:
            obj.save()
            return UserProfileFactory.create(user=obj, **kwargs)
        elif kwargs:
            raise Exception(
                "Cannot build a user profile without saving the user")
        else:
            return None
예제 #8
0
class UserFactory(BaseFactory):
    FACTORY_FOR = User

    username = Sequence(lambda n: "user{0}".format(n))
    email = Sequence(lambda n: "user{0}@example.com".format(n))
    password = PostGenerationMethodCall('set_password', 'example')
    active = True
예제 #9
0
 def create_users(self, num):
     # Create random users.
     # All users have the password 'codebuddies'.
     return [
         UserFactory(password=PostGenerationMethodCall(
             'set_password', 'codebuddies')) for _ in range(0, num)
     ]
예제 #10
0
class UserFactory(DjangoModelFactory):
    class Meta:
        model = User

    username = "******"
    email = "*****@*****.**"
    password = PostGenerationMethodCall("set_password", "123")
예제 #11
0
class UserFactory(DjangoModelFactory):
    """
    Factory for default Django User model. Calls full_clean before saving to
    ensure that generated User instance is valid.
    """
    class Meta:
        model = get_user_model()

    email = LazyFunction(faker.safe_email)
    first_name = LazyFunction(faker.first_name)
    last_name = LazyFunction(faker.last_name)
    password = PostGenerationMethodCall('set_password', 'password')

    @lazy_attribute
    def username(self):
        """
        Create a username from faker's profile generator, but ensure that it's
        not in the database before using it. This is a pre-full_clean check.

        Uses a simple single uniqueness check, cached against a set of already
        tried names. 200 max tries is on the username generation, not the round
        trip to the database - although that could be changed if required.

        Raises:
            RuntimeError: If a unique username can not be found after 200
                retries.
        """
        unique_usernames = unique_username()
        non_uniques = set()
        for _ in range(max_retries):
            username = next(unique_usernames)
            username_unique = (username not in non_uniques
                               and get_user_model().objects.filter(
                                   username=username).count() == 0)
            if username_unique:
                return username
            non_uniques.add(username)
        else:
            non_uniques_str = ', '.join(
                ['"{}"'.format(name) for name in non_uniques])
            message = (
                'Unique username not found after 200 tries. Unique values tried: {}'
            ).format(non_uniques_str)
            raise RuntimeError(message)

    @post_generation
    def z_full_clean(self, create, extracted, **kwargs):
        """
        Assert that created User is "clean" in Django's opinion if build
        strategy is happening.

        NOTE: function name is prefixed with 'z_' so that it runs after the
        'password' post generation function.

        Raises:
            ValidationError: If there are any invalid fields in the final User
                object.
        """
        if create:
            self.full_clean()
예제 #12
0
class UserFactory(BaseFactory):
    email = Sequence(lambda n: "user{0}@example.com".format(n))
    password = PostGenerationMethodCall('set_password', 'example')
    active = True

    class Meta:
        model = User
예제 #13
0
class UserFactory(DjangoModelFactory):
    class Meta:
        model = User

    username = '******'
    email = '*****@*****.**'
    password = PostGenerationMethodCall('set_password', '123')
예제 #14
0
class UserFactory(BaseFactory):
    class Meta:
        model = User

    email = Sequence(lambda n: 'user{0}@example.com'.format(n))
    password = PostGenerationMethodCall('set_password', 'password')
    first_name = "Joe"
    last_name = "Lock"
예제 #15
0
class UserFactory(DjangoModelFactory):
    class Meta:
        model = User

    username = Sequence(lambda n: u"User{0}".format(n, "%03d"))
    first_name = username
    last_name = u"Smith"
    password = PostGenerationMethodCall('set_password', 'frog')
예제 #16
0
class UserFactory(SQLAlchemyModelFactory):
    class Meta:
        model = User

    username = factory.LazyAttribute(lambda x: "sally" + faker.last_name())
    #uuid = factory.LazyAttribute(lambda x: str(uuid.uuid4()))
    email = factory.LazyAttribute(lambda x: faker.email())
    password = PostGenerationMethodCall('set_password', 'password')  #
예제 #17
0
class UserFactory(BaseFactory):
    id = Sequence(lambda n: n)
    username = Sequence(lambda n: 'user{0}'.format(n))
    email = Sequence(lambda n: 'user{0}@example.com'.format(n))
    password = PostGenerationMethodCall('set_password', 'example')

    class Meta:
        model = User
예제 #18
0
class UserFactory(DjangoModelFactory):
    class Meta:
        model = User
        django_get_or_create = ('username', )

    username = Sequence(lambda x: u'user %d' % x)
    is_superuser = True
    password = PostGenerationMethodCall('set_password', 'password')
예제 #19
0
class MeFactory(SQLAlchemyModelFactory):
    class Meta:
        model = User

    username = factory.LazyAttribute(lambda x: get_authable_username())
    #uuid = factory.LazyAttribute(lambda x: str(uuid.uuid4()))
    email = factory.LazyAttribute(lambda x: get_authable_email())
    password = PostGenerationMethodCall('set_password', 'password')
예제 #20
0
class UserFactory(DjangoModelFactory):
    class Meta:
        model = User

    username = Faker('email')
    password = PostGenerationMethodCall('set_password', 'qweqweqwe')
    email = LazyAttribute(lambda u: u.username)
    date_joined = LazyFunction(timezone.now)
예제 #21
0
class DemoUserFactory(DjangoModelFactory):
    username = Sequence(lambda n: "User %03d" % n)
    password = PostGenerationMethodCall("set_password", "password")
    is_staff = True
    is_active = True

    class Meta:
        model = get_user_model()
예제 #22
0
class UserFactory(SQLAlchemyModelFactory):
    FACTORY_SESSION = db.session
    FACTORY_FOR = User

    username = Sequence(lambda n: "user{0}".format(n))
    email = Sequence(lambda n: "user{0}@example.com".format(n))
    password = PostGenerationMethodCall("set_password", 'example')
    active = True
예제 #23
0
class UserFactory(DjangoModelFactory):
    username = Sequence(lambda n: "usr_%03d" % n)
    email = Sequence(lambda n: "*****@*****.**" % n)
    password = PostGenerationMethodCall('set_password', DEFAULT_USER_PASSWORD)
    is_active = True

    class Meta:
        model = 'auth.User'
예제 #24
0
class UserFactory(DjangoModelFactory):
    class Meta:
        model = User

    first_name = Faker('first_name')
    last_name = Faker('last_name')
    username = Faker('user_name')
    password = PostGenerationMethodCall('set_password', 'password')
    is_active = True
예제 #25
0
class UserFactory(DjangoModelFactory):
    name = Faker('name')
    email = Faker('email')
    password = PostGenerationMethodCall("set_password", "password")
    is_commerce = True
    id = str(uuid.uuid1())

    class Meta:
        model = User
예제 #26
0
class VoucherFactory(BaseFactory):
    """Voucher factory."""

    password = PostGenerationMethodCall("set_password", "example")

    class Meta:
        """Factory configuration."""

        model = Voucher
예제 #27
0
class UserWebFactory(DjangoModelFactory):
    username = Sequence(lambda n: 'user_name_%d' % n)
    email = Sequence(lambda n: '*****@*****.**' % n)
    password = PostGenerationMethodCall('set_password', 'seed')
    is_active = True
    is_superuser = False

    class Meta:
        model = getattr(settings, 'AUTH_USER_MODEL', 'auth.User')
예제 #28
0
class CommonUserFactory(django.DjangoModelFactory):
    class Meta:
        model = CommonUser

    first_name = Faker('first_name')
    last_name = Faker('last_name')
    email = Faker('email')
    password = PostGenerationMethodCall('set_password', 'password')
    phone_number = Faker('msisdn')
예제 #29
0
class UserFactory(DjangoModelFactory):

    email = '*****@*****.**'
    password = PostGenerationMethodCall('set_password', 'password')
    department = SubFactory(DepartmentFactory)
    is_active = True

    class Meta:
        model = User
예제 #30
0
class SimpleUserFactory(DjangoModelFactory):
    username = Faker("user_name")
    email = Faker("email")
    name = Faker("name")
    password = PostGenerationMethodCall('set_password', 'password')

    class Meta:
        model = get_user_model()
        django_get_or_create = ('username', )