如何使用Factory_Boy创建管理员用户？

Question

我是Django的初学者,刚开始为我的项目做一些测试.我想要做的是用selenium构建一个功能测试,登录到Django Admin站点.

我首先按照本教程http://www.tdd-django-tutorial.com/tutorial/1/使用fixtures和dumpdata来为测试应用程序(创建新数据库)提供管理员帐户信息.这很好用.

然后我想看看我是否可以使用工厂男孩来替换灯具.工厂男孩通过在tests.py文件中实例化必要的对象来工作,这对我来说似乎更干净.不知怎的,我无法让这个工作,Factory_boy文档不太有用......

这是我的tests.py

from django.test import LiveServerTestCase
from django.contrib.auth.models import User
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import factory

class UserFactory(factory.Factory):
    FACTORY_FOR = User

    username = 'jeff'
    password = 'pass'
    is_superuser = True

class AdminTest(LiveServerTestCase):

    def setUp(self):
        self.browser = webdriver.Firefox()

    def tearDown(self):
        self.browser.quit()

    def test_if_admin_login_is_possible(self):
        jeff = UserFactory.create()

        # Jeff opens the browser and goes to the admin page
        self.browser = webdriver.Firefox()
        self.browser.get(self.live_server_url + '/admin/')

        # Jeff sees the familiar 'Django Administration' heading
        body = self.browser.find_element_by_tag_name('body')
        self.assertIn('Django administration', body.text)

        # Jeff types in his username and password and hits return
        username_field = self.browser.find_element_by_name('username')
        username_field.send_keys(jeff.username)
        password_field = self.browser.find_element_by_name('password')
        password_field.send_keys(jeff.password)
        password_field.send_keys(Keys.RETURN)

        # Jeff finds himself on the 'Site Administration' page
        body = self.browser.find_element_by_tag_name('body')
        self.assertIn('Site administration', body.text)

        self.fail('Fail...')

这无法以某种方式登录,因为它无法创建有效的管理员帐户.我怎么能用工厂男孩那样做？有可能或者我需要使用固定装置吗？

(在这篇文章中有些人建议使用固定装置,但工厂男孩没有出现:如何在django tests.py中创建管理员用户.我也尝试了在同一答案底部建议的解决方案:https:// stackoverflow. com/a/3495219/1539688.它对我不起作用......)

Answer 1

如果你继承factory.DjangoModelFactory它应该为你保存用户对象.请参阅PostGenerationMethodCall下的注释部分.然后你只需要做以下事情:

class UserFactory(factory.DjangoModelFactory):
    FACTORY_FOR = User

    email = 'admin@admin.com'
    username = 'admin'
    password = factory.PostGenerationMethodCall('set_password', 'adm1n')

    is_superuser = True
    is_staff = True
    is_active = True

Answer 2

我假设你正在研究http://www.tdd-django-tutorial.com教程,因为那也是我被困的地方.你现在可能已经想到了这一点,但是对于下一个人,这里有代码对我有用,诀窍是添加_prepare方法以确保密码被加密,并将所有标志设置为true(这是使用Django 1.5完成的. 1,如果您使用的是早期版本,请更改用户模型导入)

from django.test import LiveServerTestCase
from selenium import webdriver
from selenium.webdriver.common.keys import Keys

import factory
from django.contrib.auth import get_user_model
User = get_user_model()


class UserFactory(factory.DjangoModelFactory):
    FACTORY_FOR = User

    email = 'admin@admin.com'
    username = 'admin'
    password = 'adm1n'

    is_superuser = True
    is_staff = True
    is_active = True

    @classmethod
    def _prepare(cls, create, **kwargs):
        password = kwargs.pop('password', None)
        user = super(UserFactory, cls)._prepare(create, **kwargs)
        if password:
            user.set_password(password)
            if create:
                user.save()
        return user

class PollsTest(LiveServerTestCase):

    def setUp(self):
        self.browser = webdriver.Firefox()
        self.browser.implicitly_wait(3)
        self.user = UserFactory.create()


    def tearDown(self):
        self.browser.quit()

    def test_can_create_new_poll_via_admin_site(self):
        self.browser.get(self.live_server_url+'/admin/')

        body = self.browser.find_element_by_tag_name('body')
        self.assertIn('Django administration', body.text)

        username_field = self.browser.find_element_by_name('username')
        username_field.send_keys(self.user.username)

        password_field = self.browser.find_element_by_name('password')
        password_field.send_keys('adm1n')
        password_field.send_keys(Keys.ENTER)

        body = self.browser.find_element_by_tag_name('body')
        self.assertIn('Site administration', body.text)

        polls_links = self.browser.find_element_by_link_text('Polls')
        self.assertEqual(len(polls_links), 2)


        self.fail('Finish the test!')

Answer 3

创建管理员用户：

您可以添加 Params 声明，以灵活地快速创建管理员用户或普通用户。

https://factoryboy.readthedocs.io/en/latest/introduction.html?highlight=class%20Params#altering-a-factory-s-behaviour-parameters-and-traits

设置原始密码：

为了确保将密码参数设置为原始未加密值，您可以在 _create 类方法覆盖中初始保存后使用 Django 的 set_password 设置原始密码。

https://docs.djangoproject.com/en/2.1/ref/contrib/auth/#django.contrib.auth.models.User.set_password

class UserFactory(factory.django.DjangoModelFactory):
    first_name = factory.Faker('first_name')
    last_name = factory.Faker('last_name')
    username = factory.Sequence(lambda n: 'demo-user-%d' % n)
    is_staff = False
    is_superuser = False
    password = 'secret'

    @factory.lazy_attribute
    def email(self):
        return '%s@test.com' % self.username

    class Meta:
        model = User

    class Params: 
        # declare a trait that adds relevant parameters for admin users
        flag_is_superuser = factory.Trait(
            is_superuser=True,
            is_staff=True,
            username = factory.Sequence(lambda n: 'admin-%d' % n),
        )

    @classmethod
    def _create(cls, model_class, *args, **kwargs):
        password = kwargs.pop("password", None)
        obj = super(UserFactory, cls)._create(model_class, *args, **kwargs)
        # ensure the raw password gets set after the initial save
        obj.set_password(password)
        obj.save()
        return obj

用法：

# This admin user can log in as "admin-1", password "secret"
admin = UserFactory.create(flag_is_superuser=True)

# This regular user can log in as "userABC", password "secretABC"
user = UserFactory.create(username="userABC", password="secretABC")

使用 factory-boy v2.11.1 和 Django v1.11.6

Answer 4

我在创建用户时遇到了类似的问题。创建用户时，Django 会哈希密码，并且您使用 DjangoFactory 保存密码而不使用哈希值。登录时，Django 使用存储的哈希值 1 检查您发送的密码。在此步骤中，验证失败，因为您使用未哈希密码检查未哈希密码。这是我如何在代码中修复此问题的示例：

from django.contrib.auth.hashers import make_password
from factory import DjangoModelFactory, Sequence



class UserFactory(DjangoModelFactory):
    class Meta:
        model = User
        django_get_or_create = ('username', 'password')

    username = Sequence(lambda n: 'somename%s' % n)
    password = Sequence(lambda p: 'mysuperpass%s' % p)

    @classmethod
    def _create(cls, model_class, *args, **kwargs):
        """Override the default ``_create`` with our custom call."""
        kwargs['password'] = make_password(kwargs['password'])
        return super(UserFactory, cls)._create(model_class, *args, **kwargs)

我使用 Sequence 生成的密码并使用 Djangomake_password方法对其进行哈希处理。在测试中，您可以创建一个不带哈希值的 var，并使用该 var 创建一个用户。例子：

password = 'test123'
user = UserFactory(password=my_password)

Answer 5

我正在使用Django 1.11（我敢打赌它将在Django 2+中运行）和factory_boy 2.11.1。这很简单：

import factory
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User


class SuperUserFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = User

    first_name = factory.Faker('first_name')
    last_name = factory.Faker('last_name')
    username = factory.Faker('email')
    password = factory.LazyFunction(lambda: make_password('pi3.1415'))
    is_staff = True
    is_superuser = True

在此示例中，'pi3.1415'如果您希望使用其他密码，则所有用户都将对其进行相应的密码更改，或者甚至可以使用password = factory.Faker('password')它生成随机密码（但是，应该能够确定该密码。否则，将很难登录）。

创建超级用户的示例

>>> user = SuperUserFactory.create()
>>> user.username # the following output will be different in your case
amber60@hotmail.com

使用您的电子邮件地址user.username和密码'pi3.1415'登录管理员。

如果用户关联了反向外键怎么办？

很简单，假设您有一个模型Profile，该模型具有模型的外键User。然后，您必须添加以下类：

class Profile(models.Model):
    user = models.OneToOneField(User)
    visited = models.BooleanField(default=False)


# You need to set the foreign key dependency using factory.SubFactory
class ProfileFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Profile

    user = factory.SubFactory(UserFactory)


# use a RelatedFactory to refer to a reverse ForeignKey 
class SuperUserFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = User

    first_name = factory.Faker('first_name')
    last_name = factory.Faker('last_name')
    username = factory.Faker('email')
    password = factory.LazyFunction(lambda: make_password('pi3.1415'))
    is_staff = True
    is_superuser = True
    profile = factory.RelatedFactory(ProfileFactory, 'user', visited=True)

就是这样，在示例中使用相同的逻辑来创建您的超级用户。