예제 #1
0
def test_field_from_model_supports_all_types():
    from django.db.models import fields
    not_supported = []
    blacklist = {
        'AutoField',
        'Field',
        'BigAutoField',
        'BinaryField',
        'FilePathField',
        'GenericIPAddressField',
        'IPAddressField',
        'NullBooleanField',
        'SlugField',
        'DurationField',
        'UUIDField'
    }
    field_type_names = [x for x in dir(fields) if x.endswith('Field') and x not in blacklist]

    for name in field_type_names:
        field_type = getattr(fields, name)
        try:
            Field.from_model(model=Foo, model_field=field_type())
        except AssertionError:  # pragma: no cover
            not_supported.append(name)

    assert not_supported == []
예제 #2
0
def test_email_field():
    assert Form(data=Data(foo=' 5  '),
                fields=[Field.email(name='foo')]).fields[0].errors == {
                    u'Enter a valid email address.'
                }
    assert Form(data=Data(foo='*****@*****.**'),
                fields=[Field.email(name='foo')]).is_valid()
예제 #3
0
def test_float_field():
    assert Form(data=Data(foo=' 7.3  '),
                fields=[Field.float(name='foo')]).fields[0].parsed_data == 7.3
    assert Form(data=Data(foo=' foo  '),
                fields=[Field.float(name='foo')]).fields[0].errors == {
                    "could not convert string to float: foo"
                }
예제 #4
0
def test_comma_separated_errors_on_parse():
    def raise_always_value_error(string_value, **_):
        raise ValueError('foo %s!' % string_value)

    def raise_always_validation_error(string_value, **_):
        raise ValidationError(
            ['foo %s!' % string_value,
             'bar %s!' % string_value])

    assert Form(data=Data(foo='5, 7'),
                fields=[
                    Field.comma_separated(
                        Field(name='foo', parse=raise_always_value_error))
                ]).fields[0].errors == {
                    u'Invalid value "5": foo 5!', u'Invalid value "7": foo 7!'
                }

    assert Form(data=Data(foo='5, 7'),
                fields=[
                    Field.comma_separated(
                        Field(name='foo', parse=raise_always_validation_error))
                ]).fields[0].errors == {
                    u'Invalid value "5": foo 5!', u'Invalid value "5": bar 5!',
                    u'Invalid value "7": foo 7!', u'Invalid value "7": bar 7!'
                }
예제 #5
0
def test_integer_field():
    assert Form(data=Data(foo=' 7  '),
                fields=[Field.integer(name='foo')]).fields[0].parsed_data == 7
    actual_errors = Form(data=Data(foo=' foo  '),
                         fields=[Field.integer(name='foo')]).fields[0].errors
    assert_one_error_and_matches_reg_exp(
        actual_errors, "invalid literal for int\(\) with base 10: u?'foo'")
예제 #6
0
파일: views.py 프로젝트: jlubcke/forum
    class LoginForm(Form):
        username = Field()
        password = Field.password()
        next = Field.hidden(initial=request.GET.get('next', '/'))

        def is_valid(self):
            if not super(LoginForm, self).is_valid():
                return False

            username = self.fields_by_name['username'].value
            password = self.fields_by_name['password'].value

            if username and password:
                user = User.objects.get(username=username)
                self.extra.user = user
                if authenticate(request=request,
                                username=username,
                                password=password):
                    return True

                try:
                    username = User.objects.get(username=username)
                    if b64encode(sha1(password.encode()).digest()).decode(
                    ) == user.password:
                        user.set_password(password)  # upgrade password
                        user.save()
                    authenticate(request=request,
                                 username=username,
                                 password=password)
                except User.DoesNotExist:
                    pass

            return False
예제 #7
0
def test_field_from_model_blank_handling():
    from django.db.models import CharField

    subject = Field.from_model(model=Foo, model_field=CharField(blank=False))
    assert True is subject.parse_empty_string_as_none

    subject = Field.from_model(model=Foo, model_field=CharField(blank=True))
    assert False is subject.parse_empty_string_as_none
예제 #8
0
def test_field_from_model_blank_handling():
    from django.db.models import CharField

    subject = Field.from_model(model=Foo, model_field=CharField(blank=False))
    assert True is subject.parse_empty_string_as_none

    subject = Field.from_model(model=Foo, model_field=CharField(blank=True))
    assert False is subject.parse_empty_string_as_none
예제 #9
0
파일: views.py 프로젝트: jlubcke/forum
 class ChangeSubscriptionForm(Form):
     choices = Field.radio(choices=['Subscribe', 'Unsubscribe'],
                           initial='Subscribe')
     passive = Field.boolean(
         display_name='Show only when unread',
         initial=subscription
         and subscription.subscription_type == 'passive')
     identifier = Field.hidden(initial=identifier_)
예제 #10
0
파일: views.py 프로젝트: jlubcke/forum
 class ResetPasswordForm(Form):
     reset_code = Field(
         is_valid=lambda parsed_data, **_:
         (parsed_data is not None, 'Invalid reset password code'),
         parse=parse)
     new_password = Field.password()
     confirm_password = Field.password(
         is_valid=lambda parsed_data, **_: (parsed_data == request.POST.get(
             'new_password'), 'Passwords do not match'))
예제 #11
0
def test_show():
    assert list(
        Form(data=Data(),
             fields=[Field(name='foo',
                           show=False)]).fields_by_name.keys()) == []
    assert list(
        Form(data=Data(),
             fields=[Field(name='foo', show=lambda form, field: False)
                     ]).fields_by_name.keys()) == []
예제 #12
0
class EditForm(Form):
    assetNumber = Field.text()
    assetSerial = Field.text()
    assetType = Field.choices(attr=None,
                              choices=Asset.objects.values('assetTypes__type'))
    model_number = Field.text()
    #location = Field.multi_choice(attr=None, choices=Location.objects.values_list('floor'))
    floor = Field.multi_choice_queryset(
        attr=None, choices=Asset.objects.only('locationInfo__floor'))
예제 #13
0
def test_comma_separated_errors_on_validation():
    assert Form(data=Data(foo='5, 7'),
                fields=[
                    Field.comma_separated(
                        Field(name='foo',
                              is_valid=lambda parsed_data, **_:
                              (False, 'foo %s!' % parsed_data)))
                ]).fields[0].errors == {
                    u'Invalid value "5": foo 5!', u'Invalid value "7": foo 7!'
                }
예제 #14
0
def test_phone_field():
    assert Form(
        data=Data(foo=' asdasd  '), fields=[Field.phone_number(name='foo')]
    ).fields[0].errors == {
        u'Please use format +<country code> (XX) XX XX. Example of US number: +1 (212) 123 4567 or +1 212 123 4567'
    }
    assert Form(data=Data(foo='+1 (212) 123 4567'),
                fields=[Field.phone_number(name='foo')]).is_valid()
    assert Form(data=Data(foo='+46 70 123 123'),
                fields=[Field.phone_number(name='foo')]).is_valid()
예제 #15
0
def test_field_from_model_many_to_many():
    Foo.objects.create(foo=2)
    Foo.objects.create(foo=3)
    Foo.objects.create(foo=5)
    choices = Field.from_model(FieldFromModelManyToManyTest, 'foo_many_to_many').choices
    assert isinstance(choices, QuerySet)
    assert set(choices) == set(Foo.objects.all())
예제 #16
0
def test_comma_separated_errors_on_validation():
    assert Form(
        data=dict(foo='5, 7'),
        fields=[Field.comma_separated(Field(name='foo', is_valid=lambda parsed_data, **_: (False, 'foo %s!' % parsed_data)))]).fields[0].errors == {
            u'Invalid value "5": foo 5!',
            u'Invalid value "7": foo 7!',
    }
예제 #17
0
def test_render_custom():
    sentinel = '!!custom!!'
    assert sentinel in Form(fields=[
        Field(name='foo',
              initial='not sentinel value',
              render_value=lambda form, field, value: sentinel),
    ]).table()
예제 #18
0
def test_boolean_initial_true():
    fields = [
        Field.boolean(name='foo', initial=True),
        Field(name='bar', required=False)
    ]

    form = Form(data=Data(), fields=fields)
    assert form.fields_by_name['foo'].value is True

    # If there are arguments, but not for key foo it means checkbox for foo has been unchecked.
    # Field foo should therefore be false.
    form = Form(data=Data(bar='baz', **{'-': '-'}), fields=fields)
    assert form.fields_by_name['foo'].value is False

    form = Form(data=Data(foo='on', bar='baz', **{'-': '-'}), fields=fields)
    assert form.fields_by_name['foo'].value is True
예제 #19
0
def test_render_datetime_iso():
    table = Form(fields=[
        Field.datetime(name='foo',
                       initial=datetime(2001, 2, 3, 12, 13, 14, 7777))
    ]).table()
    assert '2001-02-03 12:13:14' in table
    assert '7777' not in table
예제 #20
0
def test_field_from_model_foreign_key():
    Foo.objects.create(foo=2)
    Foo.objects.create(foo=3)
    Foo.objects.create(foo=5)
    choices = Field.from_model(FieldFromModelForeignKeyTest, 'foo_fk').choices
    assert isinstance(choices, QuerySet)
    assert set(choices) == set(Foo.objects.all())
예제 #21
0
def test_render_template_string():
    assert Form(data=Data(foo='7'),
                fields=[
                    Field(name='foo',
                          template=None,
                          template_string='{{ field.value }} {{ form.style }}')
                ]).compact() == '7 compact\n' + AVOID_EMPTY_FORM
예제 #22
0
def test_field_from_model_foreign_key():
    Foo.objects.create(foo=2)
    Foo.objects.create(foo=3)
    Foo.objects.create(foo=5)
    choices = Field.from_model(FieldFromModelForeignKeyTest, 'foo_fk').choices
    assert isinstance(choices, QuerySet)
    assert set(choices) == set(Foo.objects.all())
예제 #23
0
def test_render_datetime_iso():
    table = Form(fields=[
        Field.datetime(
            name='foo',
            initial=datetime(2001, 2, 3, 12, 13, 14, 7777))
    ]).table()
    assert '2001-02-03 12:13:14' in table
    assert '7777' not in table
예제 #24
0
def test_field_from_model_many_to_many():
    Foo.objects.create(foo=2)
    Foo.objects.create(foo=3)
    Foo.objects.create(foo=5)
    choices = Field.from_model(FieldFromModelManyToManyTest,
                               'foo_many_to_many').choices
    assert isinstance(choices, QuerySet)
    assert set(choices) == set(Foo.objects.all())
예제 #25
0
class MyTestForm(Form):
    party = Field.choice(choices=['ABC'], required=False)
    username = Field(is_valid=lambda form, field, parsed_data: (
        parsed_data.startswith(form.fields_by_name['party'].parsed_data.lower(
        ) + '_')
        if parsed_data is not None else None, 'Username must begin with "%s_"'
        % form.fields_by_name['party'].parsed_data))
    joined = Field.datetime(attr='contact__joined')
    a_date = Field.date()
    a_time = Field.time()
    staff = Field.boolean()
    admin = Field.boolean()
    manages = Field.multi_choice(choices=['DEF', 'KTH', 'LIU'], required=False)
    not_editable = Field.text(initial='Some non-editable text', editable=False)
예제 #26
0
def test_radio():
    choices = [
        'a',
        'b',
        'c',
    ]
    soup = BeautifulSoup(Form(data=Data(foo='a'), fields=[Field.radio(name='foo', choices=choices)]).validate().table())
    assert len(soup.find_all('input')) == len(choices) + 1  # +1 for AVOID_EMPTY_FORM
    assert [x.attrs['value'] for x in soup.find_all('input') if 'checked' in x.attrs] == ['a']
예제 #27
0
def test_comma_separated_errors_on_parse():
    def raise_always_value_error(string_value, **_):
        raise ValueError('foo %s!' % string_value)

    def raise_always_validation_error(string_value, **_):
        raise ValidationError(['foo %s!' % string_value, 'bar %s!' % string_value])

    assert Form(
        data=Data(foo='5, 7'),
        fields=[Field.comma_separated(Field(name='foo', parse=raise_always_value_error))]).validate().fields[0].errors == {
            u'Invalid value "5": foo 5!',
            u'Invalid value "7": foo 7!'}

    assert Form(
        data=Data(foo='5, 7'),
        fields=[Field.comma_separated(Field(name='foo', parse=raise_always_validation_error))]).validate().fields[0].errors == {
            u'Invalid value "5": foo 5!',
            u'Invalid value "5": bar 5!',
            u'Invalid value "7": foo 7!',
            u'Invalid value "7": bar 7!'}
예제 #28
0
def test_field_from_model_supports_all_types():
    from django.db.models import fields
    not_supported = []
    blacklist = {
        'AutoField', 'Field', 'BigAutoField', 'BinaryField', 'FilePathField',
        'GenericIPAddressField', 'IPAddressField', 'NullBooleanField',
        'SlugField', 'DurationField', 'UUIDField'
    }
    field_type_names = [
        x for x in dir(fields) if x.endswith('Field') and x not in blacklist
    ]

    for name in field_type_names:
        field_type = getattr(fields, name)
        try:
            Field.from_model(model=Foo, model_field=field_type())
        except AssertionError:  # pragma: no cover
            not_supported.append(name)

    assert not_supported == []
예제 #29
0
def test_boolean_initial_true():
    fields = [Field.boolean(name='foo', initial=True), Field(name='bar', required=False)]

    form = Form(data=Data(), fields=fields).validate()
    assert form.fields_by_name['foo'].value is True

    # If there are arguments, but not for key foo it means checkbox for foo has been unchecked.
    # Field foo should therefore be false.
    form = Form(data=Data(bar='baz'), fields=fields).validate()
    assert form.fields_by_name['foo'].value is False

    form = Form(data=Data(foo='on', bar='baz'), fields=fields).validate()
    assert form.fields_by_name['foo'].value is True
예제 #30
0
def test_radio():
    choices = [
        'a',
        'b',
        'c',
    ]
    soup = BeautifulSoup(
        Form(data=Data(foo='a'),
             fields=[Field.radio(name='foo', choices=choices)]).table())
    assert len(
        soup.find_all('input')) == len(choices) + 1  # +1 for AVOID_EMPTY_FORM
    assert [
        x.attrs['value'] for x in soup.find_all('input')
        if 'checked' in x.attrs
    ] == ['a']
예제 #31
0
def tri_form_example4(request, pk):
    def on_save(instance, form, **_):
        if request.user.contact.is_auditor and form.fields_by_name.audit_complete.value:
            instance.last_audit = datetime.now()
            instance.auditor = request.user
            instance.save()

    return edit_object(
        request=request,
        instance=Room.objects.get(pk=pk),
        on_save=on_save,
        form__extra_fields=[
            Field.boolean(
                name='audit_complete',
                attr=None,  # don't write "audit_complete" to the Room object
                show=request.user.contact.is_auditor,
            ),
            Field.heading(
                name='audit',
                after='description',
                show=request.user.contact.is_auditor or request.user.is_staff,
            ),
        ],
        form__field=dict(
            auditor_notes__show=request.user.is_staff
            or request.user.contact.is_auditor,
            auditor_notes__editable=request.user.contact.is_auditor,
            auditor__editable=False,
            auditor__show=request.user.is_staff,
            last_audit__editable=False,
            last_audit__show=request.user.is_staff,
            last_audit__container__attrs__class__audit=True,
            auditor__container__attrs__class__audit=True,
            auditor_notes__container__attrs__class__audit=True,
        ),
    )
예제 #32
0
def test_render_table():
    form = Form(data=Data(foo='!!!7!!!'),
                fields=[
                    Field(
                        name='foo',
                        input_container_css_classes={'###5###'},
                        label_container_css_classes={'$$$11$$$'},
                        help_text='^^^13^^^',
                        label='***17***',
                    )
                ])
    table = form.table()
    assert '!!!7!!!' in table
    assert '###5###' in table
    assert '$$$11$$$' in table
    assert '^^^13^^^' in table
    assert '***17***' in table
    assert '<tr' in table

    # Assert that table is the default
    assert table == "%s" % form
예제 #33
0
def tri_form_example3(request, pk):
    def on_save(instance, form, **_):
        if request.user.is_staff and form.fields_by_name.audit_complete.value:
            instance.last_audit = datetime.now()
            instance.auditor = request.user
            instance.save()

    return edit_object(
        request=request,
        instance=Room.objects.get(pk=pk),
        on_save=on_save,
        form__exclude=['auditor', 'last_audit'],
        form__extra_fields=[
            Field.boolean(
                name='audit_complete',
                attr=None,  # don't write "audit_complete" to the Room object
                show=request.user.is_staff,
            ),
        ],
        form__field__auditor_notes__show=request.user.is_staff,
    )
예제 #34
0
def test_hidden():
    soup = BeautifulSoup(Form(data=Data(foo='1'), fields=[Field.hidden(name='foo')]).validate().table())
    assert [(x.attrs['type'], x.attrs['value']) for x in soup.find_all('input')] == [('hidden', '1'), ('hidden', '-')]
예제 #35
0
def test_password():
    assert ' type="password" ' in Form(data=Data(foo='1'), fields=[Field.password(name='foo')]).validate().table()
예제 #36
0
def test_heading():
    assert '<th colspan="2">#foo#</th>' in Form(data={}, fields=[Field.heading(label='#foo#')]).validate().table()
예제 #37
0
def test_text_fields():
    assert '<input type="text" ' in Form(data={}, fields=[Field.text(name='foo')]).compact()
    assert '<textarea' in Form(data={}, fields=[Field.textarea(name='foo')]).compact()
예제 #38
0
def test_register_field_factory():
    register_field_factory(FooField, lambda **kwargs: 7)

    assert Field.from_model(RegisterFieldFactoryTest, 'foo') == 7
예제 #39
0
def test_multi_select_with_one_value_only():
    assert ['a'] == Form(data=Data(foo=['a']), fields=[Field.multi_choice(name='foo', choices=['a', 'b'])]).validate().fields[0].value_list
예제 #40
0
def test_multi_email():
    assert Form(data=Data(foo='[email protected], [email protected]'), fields=[Field.comma_separated(Field.email(name='foo'))]).is_valid()
예제 #41
0
def test_choices_from_query_set():
    user = User.objects.create(username='******')
    assert [x.pk for x in Form(fields=[Field.multi_choice_queryset(name='foo', model=User, choices=User.objects.all())]).validate().fields[0].choices] == [user.pk]
예제 #42
0
def test_float_field():
    assert Form(data=Data(foo=' 7.3  '), fields=[Field.float(name='foo')]).validate().fields[0].parsed_data == 7.3
    assert Form(data=Data(foo=' foo  '), fields=[Field.float(name='foo')]).validate().fields[0].errors == {"could not convert string to float: foo"}
예제 #43
0
def test_email_field():
    assert Form(data=Data(foo=' 5  '), fields=[Field.email(name='foo')]).validate().fields[0].errors == {u'Enter a valid email address.'}
    assert Form(data=Data(foo='*****@*****.**'), fields=[Field.email(name='foo')]).is_valid()
예제 #44
0
def test_integer_field():
    assert Form(data=Data(foo=' 7  '), fields=[Field.integer(name='foo')]).validate().fields[0].parsed_data == 7
    assert Form(data=Data(foo=' foo  '), fields=[Field.integer(name='foo')]).validate().fields[0].errors == {"invalid literal for int() with base 10: 'foo'"}
예제 #45
0
def test_info():
    form = Form(data={}, fields=[Field.info(value='#foo#')])
    assert form.is_valid()
    assert '#foo#' in form.table()
예제 #46
0
 class FooForm(Form):
     foo = Field(required=True)
     bar = Field(required=True)
     baz = Field.boolean(initial=True)
예제 #47
0
def test_multi_choice():
    soup = BeautifulSoup(Form(data=Data(foo=['0']), fields=[Field.multi_choice(name='foo', choices=['a'])]).validate().table())
    assert [x.attrs['multiple'] for x in soup.find_all('select')] == ['']
예제 #48
0
 class FooForm(Form):
     foo = Field.file(required=False)
예제 #49
0
def test_help_text_from_model():
    assert Form(data=Data(foo='1'), fields=[Field.from_model(model=Foo, field_name='foo')], model=Foo).validate().fields[0].help_text == 'foo_help_text'
예제 #50
0
def test_phone_field():
    assert Form(data=Data(foo=' asdasd  '), fields=[Field.phone_number(name='foo')]).validate().fields[0].errors == {u'Please use format +<country code> (XX) XX XX. Example of US number: +1 (212) 123 4567 or +1 212 123 4567'}
    assert Form(data=Data(foo='+1 (212) 123 4567'), fields=[Field.phone_number(name='foo')]).is_valid()
    assert Form(data=Data(foo='+46 70 123 123'), fields=[Field.phone_number(name='foo')]).is_valid()
예제 #51
0
def test_datetime_not_required():
    assert Form(fields=[
        Field.datetime(
            required=False,
            name='foo')
    ], data={'foo': ''}).is_valid()
예제 #52
0
파일: views.py 프로젝트: jlubcke/forum
 class ForgotPasswordForm(Form):
     username_or_email = Field(
         is_valid=lambda parsed_data, **_:
         (parsed_data is not None, 'Unknown username or email'),
         parse=parse)
예제 #53
0
def test_render_datetime_iso():
    assert '2001-02-03 12:13:14' in Form(fields=[
        Field.datetime(
            name='foo',
            initial=datetime(2001, 2, 3, 12, 13, 14))
    ]).validate().table()
예제 #54
0
파일: views.py 프로젝트: dhaggen/tri.form
 class MyForm(Form):
     foo = Field()
     bar = Field()
예제 #55
0
 class MyForm(Form):
     foo = Field(is_valid=lambda **_: (False, 'field error'))
예제 #56
0
def test_integer_field():
    assert Form(data=dict(foo=' 7  '), fields=[Field.integer(name='foo')]).fields[0].parsed_data == 7
    actual_errors = Form(data=dict(foo=' foo  '), fields=[Field.integer(name='foo')]).fields[0].errors
    assert_one_error_and_matches_reg_exp(actual_errors, "invalid literal for int\(\) with base 10: u?'foo'")
예제 #57
0
 class MyForm(Form):
     username = Field.choice_queryset(choices=User.objects.all(),
                                      extra__endpoint_attr='username')
예제 #58
0
def test_json_parsing():
    # NOTE: Parsing json input requires that any numbers that come in must avoid the string strip
    f = Form(data={'foo': 1}, fields=[Field.integer(name='foo', strip_input=False)])
    assert f.is_valid()
    assert f.fields_by_name['foo'].value == 1