django-fobi 0.19.9

path/to/sample_textarea/fobi_form_elements.py

单个表单元素插件通过其UID进行注册。

必需的导入。

from django import forms
from fobi.base import FormFieldPlugin, form_element_plugin_registry
from path.to.sample_textarea.forms import SampleTextareaForm

定义示例文本区域插件。

class SampleTextareaPlugin(FormFieldPlugin):
    """Sample textarea plugin."""

    uid = "sample_textarea"
    name = "Sample Textarea"
    form = SampleTextareaForm
    group = "Samples" # Group to which the plugin belongs to

    def get_form_field_instances(self,
                                 request=None,
                                 form_entry=None,
                                 form_element_entries=None,
                                 **kwargs):
        kwargs = {
            'required': self.data.required,
            'label': self.data.label,
            'initial': self.data.initial,
            'widget': forms.widgets.Textarea(attrs={})
        }

        return [(self.data.name, forms.CharField, kwargs),]

注册SampleTextareaPlugin插件。

form_element_plugin_registry.register(SampleTextareaPlugin)

请注意，如果您想定义一个纯展示元素，请使用fobi.base.FormElementPlugin进行子类化，而不是使用fobi.base.FormFieldPlugin。以内容插件（fobi.contrib.plugins.form_elements.content）的源代码为例。

例如，captcha和honeypot字段作为表单元素实现（子类化fobi.base.FormElementPlugin）。db_store表单处理插件不会保存这些元素的表单数据。如果您想保存表单元素数据，请从fobi.base.FormFieldPlugin继承。

隐藏表单元素插件，也应该将 is_hidden 属性设置为 True。默认情况下，它被设置为 False。这使得隐藏的表单元素在编辑模式下使用 django.forms.widgets.TextInput 小部件进行渲染。在视图模式下，将使用您在表单元素插件中指定的原始小部件。

可能会有这样的情况，当您需要在表单成功提交后对数据进行额外处理。在这种情况下，您需要在插件中定义一个 submit_plugin_form_data 方法，它接受以下参数

• form_entry (fobi.models.FormEntry)：正在提交的表单条目。

• request (django.http.HttpRequest)：Django HTTP 请求。

• form (django.forms.Form)：表单对象（一个有效的对象，其中包含 cleaned_data 属性）。

• form_element_entries (fobi.models.FormElementEntry)：给定 form_entry 的表单元素条目。

• (**)kwargs：其他参数。

示例（来自 fobi.contrib.plugins.form_elements.fields.file）

def submit_plugin_form_data(self,
                            form_entry,
                            request,
                            form,
                            form_element_entries=None,
                            **kwargs):
    """Submit plugin form data."""
    # Get the file path
    file_path = form.cleaned_data.get(self.data.name, None)
    if file_path:
        # Handle the upload
        saved_file = handle_uploaded_file(FILES_UPLOAD_DIR, file_path)
        # Overwrite ``cleaned_data`` of the ``form`` with path to moved
        # file.
        form.cleaned_data[self.data.name] = "{0}{1}".format(
            settings.MEDIA_URL, saved_file
        )

    # It's critically important to return the ``form`` with updated
    # ``cleaned_data``
    return form

在下面的示例中，原始表单正在被修改。如果您不想修改原始表单，请不要返回任何内容。

查看文件表单元素插件（fobi.contrib.plugins.form_elements.fields.file）以获取完整的示例。

path/to/sample_textarea/forms.py

为什么要有另一个文件来定义表单？只是为了保持代码干净和整洁，尽管您可以在 fobi_form_elements.py 模块中完美地定义所有插件表单，但它建议将其分开。

请注意，forms.py 不是一个自动发现的文件模式。您应该将所有表单元素插件注册在名为 fobi_form_elements.py 的模块中。

必需的导入。

from django import forms
from fobi.base import BasePluginForm

为 SampleTextareaPlugin 表单元素插件定义的表单。

class SampleTextareaForm(forms.Form, BasePluginForm):
    """Sample textarea form."""

    plugin_data_fields = [
        ("name", ""),
        ("label", ""),
        ("initial", ""),
        ("required", False)
    ]

    name = forms.CharField(label="Name", required=True)
    label = forms.CharField(label="Label", required=True)
    initial = forms.CharField(label="Initial", required=False)
    required = forms.BooleanField(label="Required", required=False)

请注意，尽管代码中没有检查，但对于表单字段插件，以下字段应该在插件表单（BasePluginForm）和表单插件（FormFieldPlugin）中存在

• name

在某些情况下，您可能想在数据保存之前对数据进行一些操作。为此，引入了 save_plugin_data 方法。

请参见以下 示例。

def save_plugin_data(self, request=None):
    """Saving the plugin data and moving the file."""
    file_path = self.cleaned_data.get('file', None)
    if file_path:
        saved_image = handle_uploaded_file(IMAGES_UPLOAD_DIR, file_path)
        self.cleaned_data['file'] = saved_image

path/to/sample_textarea/widgets.py

必需的导入。

from fobi.base import FormElementPluginWidget

定义基本插件小部件。

class BaseSampleTextareaPluginWidget(FormElementPluginWidget):
    """Base sample textarea plugin widget."""

    # Same as ``uid`` value of the ``SampleTextareaPlugin``.
    plugin_uid = "sample_textarea"

path/to/sample_layout/fobi_form_elements.py

在注册表中注册（在某些模块中，这些模块肯定会加载；在主题模块中这样做很方便）。

必需的导入。

from fobi.base import form_element_plugin_widget_registry
from path.to.sample_textarea.widgets import BaseSampleTextareaPluginWidget

定义特定于主题的插件。

class SampleTextareaPluginWidget(BaseSampleTextareaPluginWidget):
    """Sample textarea plugin widget."""

    theme_uid = 'bootstrap3' # Theme for which the widget is loaded
    media_js = [
        'sample_layout/js/fobi.plugins.form_elements.sample_textarea.js',
    ]
    media_css = [
        'sample_layout/css/fobi.plugins.form_elements.sample_textarea.css',
    ]

注册小部件。

form_element_plugin_widget_registry.register(SampleTextareaPluginWidget)

表单元素插件最终步骤

现在，一切都准备好了，请确保将您的插件模块添加到 INSTALLED_APPS。

INSTALLED_APPS = (
    # ...
    'path.to.sample_textarea',
    # ...
)

之后，转到终端并输入以下命令。

./manage.py fobi_sync_plugins

如果您的 HTTP 服务器正在运行，您将能够在编辑表单界面中看到新的插件。

仪表板 URL： http://127.0.0.1:8000/fobi/

请注意，您必须登录才能使用仪表板。如果您的新的插件没有出现，将 Django 的本地设置模块中的 FOBI_DEBUG 设置为 True，重新运行您的代码并检查控制台以获取错误通知。

path/to/sample_mail/fobi_form_handlers.py

通过其 UID 注册单个表单处理器插件。

必需的导入。

import json
from django.core.mail import send_mail
from fobi.base import FormHandlerPlugin, form_handler_plugin_registry
from path.to.sample_mail.forms import SampleMailForm

定义 Sample 邮件处理器插件。

class SampleMailHandlerPlugin(FormHandlerPlugin):
    """Sample mail handler plugin."""

    uid = "sample_mail"
    name = _("Sample mail")
    form = SampleMailForm

    def run(self, form_entry, request, form, form_element_entries=None):
        """To be executed by handler."""
        send_mail(
            self.data.subject,
            json.dumps(form.cleaned_data),
            self.data.from_email,
            [self.data.to_email],
            fail_silently=True
        )

注册插件

form_handler_plugin_registry.register(SampleMailHandlerPlugin)

某些表单处理器可配置，而另一些则不可配置。为了以用户友好的方式显示表单处理器设置，有时需要引入 plugin_data_repr 方法。其最简单的实现方式如下

def plugin_data_repr(self):
    """Human readable representation of plugin data.

    :return string:
    """
    return self.data.__dict__

path/to/sample_mail/forms.py

如果插件可配置，则具有配置数据。单个表单可以具有任意数量的相同插件。想象一下，您想要为不同的用户组分配不同的主题和附加正文文本。然后，您可以给表单分配两个表单处理器 mail 插件。当然，多次保存提交的表单数据是没有意义的，但这取决于用户。因此，如果插件可配置，则应有一个表单。

为什么要为定义表单创建另一个文件？只是为了保持代码的整洁和简洁，尽管您可以在模块 fobi_form_handlers.py 中完全定义所有插件表单，但建议将其分开。

请注意，forms.py 不是一个自动发现的文件模式。所有表单处理器插件都应在名为 fobi_form_handlers.py 的模块中注册。

必需的导入。

from django import forms
from django.utils.translation import gettext_lazy as _
from fobi.base import BasePluginForm

定义 Sample 邮件处理器插件的表单。

class MailForm(forms.Form, BasePluginForm):
    """Mail form."""

    plugin_data_fields = [
        ("from_name", ""),
        ("from_email", ""),
        ("to_name", ""),
        ("to_email", ""),
        ("subject", ""),
        ("body", ""),
    ]

    from_name = forms.CharField(label=_("From name"), required=True)
    from_email = forms.EmailField(label=_("From email"), required=True)
    to_name = forms.CharField(label=_("To name"), required=True)
    to_email = forms.EmailField(label=_("To email"), required=True)
    subject = forms.CharField(label=_("Subject"), required=True)
    body = forms.CharField(
        label=_("Body"),
        required=False,
        widget=forms.widgets.Textarea
    )

在插件被处理之后，其所有数据都可用在 plugin_instance.data 容器中（例如，plugin_instance.data.subject 或 plugin_instance.data.from_name）。

优先执行顺序

某些表单处理器应该在其他表单处理器之前执行。一个很好的例子是表单的“邮件”和“db_save”表单处理器的组合。在“db_save”执行之后，“邮件”插件执行会导致表单数据提交失败。这就是为什么可以通过 FOBI_FORM_HANDLER_PLUGINS_EXECUTION_ORDER 设置变量来优先排序。

如果没有指定或留空，表单处理器插件将按发现顺序运行。所有未列入 FORM_HANDLER_PLUGINS_EXECUTION_ORDER 的表单处理器插件将在此列表中提及的插件之后运行。

FORM_HANDLER_PLUGINS_EXECUTION_ORDER = (
    'http_repost',
    'mail',
    # The 'db_store' is left out intentionally, since it should
    # be the last plugin to be executed.
)

表单处理器插件自定义操作

默认情况下，单个表单处理器插件至少有一个“删除”操作。如果插件可配置，则还有一个“编辑”操作。

对于您的某些插件，您可能想注册一个自定义操作。例如，“db_store”插件有一个，用于显示包含保存表单数据的表单的列表页面的链接。

在这种情况下，在您的表单处理器插件中定义一个 custom_actions 方法。该方法应返回一个三元组列表。在每个三元组中，第一个值是 URL，第二个值是标题，第三个值是 URL 的图标。

以下示例取自“db_store”插件。

def custom_actions(self):
    """Adding a link to view the saved form entries.

    :return iterable:
    """
    return (
        (
            reverse('fobi.contrib.plugins.form_handlers.db_store.view_saved_form_data_entries'),
            _("View entries"),
            'glyphicon glyphicon-list'
        ),
    )

表单处理器插件最后步骤

不要忘记将表单处理器插件模块添加到 INSTALLED_APPS 中。

INSTALLED_APPS = (
    # ...
    'path.to.sample_mail',
    # ...
)

之后，转到终端并输入以下命令。

./manage.py fobi_sync_plugins

如果您的 HTTP 服务器正在运行，您将能够在编辑表单界面中看到新的插件。

path/to/sample_importer/fobi_form_importers.py

单个表单导入插件通过其 UID 进行注册。

必需的导入。

from django.utils.translation import gettext_lazy as _
from fobi.form_importers import BaseFormImporter, form_importer_plugin_registry
from fobi.contrib.plugins.form_elements import fields
from path.to.sample_importer.views import SampleImporterWizardView

定义 Sample 导入插件。

class SampleImporterPlugin(FormHandlerPlugin):
    """Sample importer plugin."""

    uid = 'sample_importer'
    name = _("Sample importer")
    wizard = SampleImporterWizardView
    templates = [
        'sample_importer/0.html',
        'sample_importer/1.html',
    ]

    # field_type (at importer): uid (django-fobi)
    fields_mapping = {
        # Implemented
        'email': fields.email.UID,
        'text': fields.text.UID,
        'number': fields.integer.UID,
        'dropdown': fields.select.UID,
        'date': fields.date.UID,
        'url': fields.url.UID,
        'radio': fields.radio.UID,

        # Transformed into something else
        'address': fields.text.UID,
        'zip': fields.text.UID,
        'phone': fields.text.UID,
    }

    # Django standard: remote
    field_properties_mapping = {
        'label': 'name',
        'name': 'tag',
        'help_text': 'helptext',
        'initial': 'default',
        'required': 'req',
        'choices': 'choices',
    }

    field_type_prop_name = 'field_type'
    position_prop_name = 'order'

    def extract_field_properties(self, field_data):
        field_properties = {}
        for prop, val in self.field_properties_mapping.items():
            if val in field_data:
                if 'choices' == val:
                    field_properties[prop] = "\n".join(field_data[val])
                else:
                    field_properties[prop] = field_data[val]
        return field_properties


form_importer_plugin_registry.register(SampleImporter)

path/to/sample_importer/forms.py

如上所述，表单导入以向导的形式实现。表单是向导步骤。

必需的导入。

from django import forms
from django.utils.translation import gettext_lazy as _
from sample_service_api import sample_api  # Just an imaginary API client

定义 Sample 导入插件的表单。

class SampleImporterStep1Form(forms.Form):
    """First form the the wizard."""

    api_key = forms.CharField(required=True)


class SampleImporterStep2Form(forms.Form):
    """Second form of the wizard."""

    list_id = forms.ChoiceField(required=True, choices=[])

    def __init__(self, *args, **kwargs):
        self._api_key = None

        if 'api_key' in kwargs:
            self._api_key = kwargs.pop('api_key', None)

        super(SampleImporterStep2Form, self).__init__(*args, **kwargs)

        if self._api_key:
            client = sample_api.Api(self._api_key)
            lists = client.lists.list()
            choices = [(l['id'], l['name']) for l in lists['data']]
            self.fields['list_id'].choices = choices

path/to/sample_importer/views.py

向导视图。

必需的导入。

from sample_service_api import sample_api  # Just an imaginary API client

from django.shortcuts import redirect
from django.urls import reverse
from django.contrib import messages
from django.utils.translation import gettext_lazy as _

# For django LTE 1.8 import from `django.contrib.formtools.wizard.views`
from formtools.wizard.views import SessionWizardView

from path.to.sample_importer.forms import (
    SampleImporterStep1Form,
    SampleImporterStep2Form,
)

定义 Sample 导入插件的向导视图。

class SampleImporterWizardView(SessionWizardView):
    """Sample importer wizard view."""

    form_list = [SampleImporterStep1Form, SampleImporterStep2Form]

    def get_form_kwargs(self, step):
        """Get form kwargs (to be used internally)."""
        if '1' == step:
            data = self.get_cleaned_data_for_step('0') or {}
            api_key = data.get('api_key', None)
            return {'api_key': api_key}
        return {}

    def done(self, form_list, **kwargs):
        """After all forms are submitted."""
        # Merging cleaned data into one dict
        cleaned_data = {}
        for form in form_list:
            cleaned_data.update(form.cleaned_data)

        # Connecting to sample client API
        client = sample_client.Api(cleaned_data['api_key'])

        # Fetching the form data
        form_data = client.lists.merge_vars(
            id={'list_id': cleaned_data['list_id']}
        )

        # We need the first form only
        try:
            form_data = form_data['data'][0]
        except Exception as err:
            messages.warning(
                self.request,
                _('Selected form could not be imported due errors.')
            )
            return redirect(reverse('fobi.dashboard'))

        # Actually, import the form
        form_entry = self._form_importer.import_data(
            {'name': form_data['name'], 'user': self.request.user},
            form_data['merge_vars']
        )

        redirect_url = reverse(
            'fobi.edit_form_entry',
            kwargs={'form_entry_id': form_entry.pk}
        )

        messages.info(
            self.request,
            _('Form {0} imported successfully.').format(form_data['name'])
        )

        return redirect("{0}".format(redirect_url))

表单导入插件最终步骤

不要忘记将表单导入插件模块添加到 INSTALLED_APPS。

INSTALLED_APPS = (
    # ...
    'path.to.sample_importer',
    # ...
)

之后，转到终端并输入以下命令。

./manage.py fobi_sync_plugins

如果您的 HTTP 服务器正在运行，您将能够在仪表板表单界面（在所有捆绑主题中实现）中看到新插件。

目录结构

override_simple_theme/
├── static
│   └── override_simple_theme
│       ├── css
│       │   └── override-simple-theme.css
│       └── js
│           └── override-simple-theme.js
│
├── templates
│   └── override_simple_theme
│       ├── snippets
│       │   └── form_ajax.html
│       └── base_view.html
├── __init__.py
└── fobi_themes.py # Where themes are defined and registered

fobi_themes.py

覆盖“simple”主题。

__all__ = ('MySimpleTheme',)

from fobi.base import theme_registry

from fobi.contrib.themes.simple.fobi_themes import SimpleTheme

class MySimpleTheme(SimpleTheme):
    """My simple theme, inherited from `SimpleTheme` theme."""

    html_classes = ['my-simple-theme',]
    base_view_template = 'override_simple_theme/base_view.html'
    form_ajax = 'override_simple_theme/snippets/form_ajax.html'

注册覆盖的主题。请注意，将 force 参数设置为 True 是很重要的，以便覆盖原始主题。强制只能应用一次（对于覆盖的元素）。

theme_registry.register(MySimpleTheme, force=True)

templates/override_simple_theme/base_view.html

{% extends "simple/base_view.html" %}

{% load static %}

{% block stylesheets %}
<link
  href="{% static 'override_simple_theme/css/override-simple-theme.css' %}"
  rel="stylesheet" media="all" />
{% endblock stylesheets %}

{% block main-wrapper %}
<div id="sidebar">
  <h2>It's easy to override a theme!</h2>
</div>

{{ block.super }}
{% endblock main-wrapper %}

templates/override_simple_theme/snippets/form_ajax.html

{% extends "fobi/generic/snippets/form_ajax.html" %}

{% block form_html_class %}basic-grey{% endblock %}

base.py

定义表单元素插件。

from django.utils.translation import gettext_lazy as _

from rest_framework.fields import EmailField

from fobi.base import IntegrationFormFieldPlugin
from fobi.contrib.apps.drf_integration import UID as INTEGRATE_WITH_UID
from fobi.contrib.apps.drf_integration.base import (
    DRFIntegrationFormElementPluginProcessor,
    DRFSubmitPluginFormDataMixin,
)
from fobi.contrib.apps.drf_integration.form_elements.fields.email import UID


class EmailInputPlugin(IntegrationFormFieldPlugin,
                       DRFSubmitPluginFormDataMixin):
    """EmailField plugin."""

    uid = UID
    integrate_with = INTEGRATE_WITH_UID
    name = _("Decimal")
    group = _("Fields")

    def get_custom_field_instances(self,
                                   form_element_plugin,
                                   request=None,
                                   form_entry=None,
                                   form_element_entries=None,
                                   **kwargs):
        """Get form field instances."""
        field_kwargs = {
            'required': form_element_plugin.data.required,
            'initial': form_element_plugin.data.initial,
            'label': form_element_plugin.data.label,
            'help_text': form_element_plugin.data.help_text,
            'max_length': form_element_plugin.data.max_length,
        }
        return [
            DRFIntegrationFormElementPluginProcessor(
                field_class=EmailField,
                field_kwargs=field_kwargs
            )
        ]

fobi_integration_form_elements.py

注册插件。注意名称模式 fobi_integration_form_elements。

from fobi.base import integration_form_element_plugin_registry
from .base import EmailInputPlugin

integration_form_element_plugin_registry.register(EmailInputPlugin)

之后不要忘记在 INSTALLED_APPS 中列出您的插件。

base.py

定义表单处理器插件。

import logging
from mimetypes import guess_type
import os

from django.conf import settings
from django.utils.translation import gettext_lazy as _

from fobi.base import IntegrationFormHandlerPlugin
from fobi.helpers import extract_file_path

from fobi.contrib.apps.drf_integration import UID as INTEGRATE_WITH_UID
from fobi.contrib.apps.drf_integration.base import get_processed_serializer_data

from . import UID


class MailHandlerPlugin(IntegrationFormHandlerPlugin):
    """Mail handler form handler plugin.

    Can be used only once per form.
    """

    uid = UID
    name = _("Mail")
    integrate_with = INTEGRATE_WITH_UID

    def run(self,
            form_handler_plugin,
            form_entry,
            request,
            form_element_entries=None,
            **kwargs):
        """Run."""
        base_url = form_handler_plugin.get_base_url(request)

        serializer = kwargs['serializer']

        # Clean up the values, leave our content fields and empty values.
        field_name_to_label_map, cleaned_data = get_processed_serializer_data(
            serializer,
            form_element_entries
        )

        rendered_data = form_handler_plugin.get_rendered_data(
            serializer.validated_data,
            field_name_to_label_map,
            base_url
        )

        files = self._prepare_files(request, serializer)

        form_handler_plugin.send_email(rendered_data, files)

    def _prepare_files(self, request, serializer):
        """Prepares the files for being attached to the mail message."""
        files = {}

        def process_path(file_path, imf):
            """Processes the file path and the file."""
            if file_path:
                file_path = file_path.replace(
                    settings.MEDIA_URL,
                    os.path.join(settings.MEDIA_ROOT, '')
                )
                mime_type = guess_type(imf.name)
                files[field_name] = (
                    imf.name,
                    ''.join([c for c in imf.chunks()]),
                    mime_type[0] if mime_type else ''
                )

        for field_name, imf in request.FILES.items():
            try:
                file_path = serializer.validated_data.get(field_name, '')
                process_path(file_path, imf)
            except Exception as err:
                file_path = extract_file_path(imf.name)
                process_path(file_path, imf)

        return files

fobi_integration_form_handlers.py

注册插件。注意名称模式 fobi_integration_form_handlers。

from fobi.base import integration_form_handler_plugin_registry
from .base import MailHandlerPlugin

integration_form_handler_plugin_registry.register(MailHandlerPlugin)

之后不要忘记在 INSTALLED_APPS 中列出您的插件。

字段

带星号（*）的字段属于文本元素。可以为文本元素提供 动态初始值。

• 布尔（复选框）

• 复选框多选

• 日期

• 日期下拉（年、月、日选择下拉框）

• 日期时间

• 十进制数

• 持续时间

• Email*

• Email重复*

• 文件

• 浮点数

• 隐藏*

• 隐藏模型对象

• 输入

• 整数

• IP地址*

• 空布尔值

• 密码*

• 单选按钮选择（单选按钮）

• 范围选择

• 正则表达式

• 下拉选择（下拉框）

• 选择模型对象（下拉框）

• 多选下拉（下拉框）

• 多选模型对象（下拉框）

• 多选最大值（下拉框）

• 滑块

• 别名*

• 文本*

• 文本区域*

• 时间

• URL*

内容/展示

内容插件是展示插件，可以使您的表单看起来更完整、内容更丰富。

• 内容图片：插入图片。

• 内容图片URL：插入图片URL。

• 内容Markdown：添加Markdown文本。

• 内容富文本：添加富文本（基于 django-ckeditor 包）。

• 内容文本：添加文本。

• 内容视频：添加嵌入YouTube或Vimeo视频。

安全

• CAPTCHA：CAPTCHA集成，需要 django-simple-captcha 包。

• ReCAPTCHA：CAPTCHA集成，需要 django-recaptcha 包。

• 隐形ReCAPTCHA：Google隐形ReCAPTCHA集成，无额外依赖。

• 蜜罐： 反垃圾邮件蜜罐 字段。

MPTT字段

• 选择MPTT模型对象（下拉框）

• 选择多个MPTT模型对象（下拉菜单）

测试

测试插件仅用于开发目的。

• 假数据：仅用于开发目的。

设置ChromeDriver

1. 下载并安装与您的浏览器匹配的ChromeDriver版本

   pip install get-chromedriver-py
   get-chromedriver-py

2. 在CHROME_DRIVER_EXECUTABLE_PATH设置中指定您的ChromeDriver的完整路径。例如：

   from chromedriver_py import binary_path as CHROME_DRIVER_EXECUTABLE_PATH

之后，您的Selenium测试将正常工作。

设置Firefox 47

1. 从这里下载Firefox 47，并将其解压缩到/usr/lib/firefox47/

2. 在FIREFOX_BIN_PATH设置中指定您的Firefox的完整路径。例如：

   FIREFOX_BIN_PATH = '/usr/lib/firefox47/firefox'

   如果您设置为使用系统Firefox，请删除或取消注释FIREFOX_BIN_PATH设置。

之后，您的Selenium测试将正常工作。

设置无头Firefox

1. 安装用于在无头模式下启动Firefox的xvfb包。

   sudo apt-get install xvfb

2. 使用无头Firefox运行测试。

   ./scripts/runtests.sh

   或者使用无头Firefox运行tox测试。

   ./scripts/tox.sh

   或者使用无头Firefox运行特定的tox测试。

   ./scripts/tox.sh -e py36-django111

设置PhantomJS

您还可以以无头模式运行测试（更快）。为此，您需要PhantomJS。

1. 安装PhantomJS及其依赖项。

   curl -sL https://deb.nodesource.com/setup_6.x -o nodesource_setup.sh
   sudo bash nodesource_setup.sh
   sudo apt-get install nodejs
   sudo apt-get install build-essential libssl-dev
   sudo npm -g install phantomjs-prebuilt

2. 指定PHANTOM_JS_EXECUTABLE_PATH设置。例如：

   PHANTOM_JS_EXECUTABLE_PATH = ""

   如果您想使用Firefox进行测试，请删除或取消注释PHANTOM_JS_EXECUTABLE_PATH设置。

仪表板

创建表单

查看/编辑表单

表单元素

[1.3]

编辑表单 - 表单元素选项卡激活，尚未添加元素

[1.4]

编辑表单 - 表单元素选项卡激活，添加表单元素菜单

[1.5]

编辑表单 - 添加表单元素（URL插件）

[1.6]

编辑表单 - 表单元素选项卡激活，包含表单元素

表单处理器

[1.7]

编辑表单 - 表单处理器选项卡激活，尚未添加处理器

[1.8]

编辑表单 - 表单处理器选项卡激活，添加表单处理器菜单

[1.9]

编辑表单 - 添加表单处理器（邮件插件）

[1.10]

编辑表单 - 表单处理器选项卡激活，包含表单处理器

[1.11]

编辑表单 - 表单属性选项卡激活

[1.12]

查看表单

[1.13]

查看表单 - 表单提交（感谢页面）

[1.14]

编辑表单 - 添加表单元素（视频插件）

[1.15]

编辑表单 - 添加表单元素（布尔插件）

[1.16]

编辑表单

[1.17]

查看表单