示例#1
0
    def test_over_set_flat(self):
        wanted = {u'x': 123, u'y': None}

        pairs = ((u's_x', u'123'), (u's_z', u'nope'))
        el = self.new_element()
        el.set_flat(pairs)
        eq_(el.value, wanted)
示例#2
0
    def test_full_set_flat(self):
        wanted = {u'x': 101, u'y': 102}
        pairs = ((u's_x', u'101'), (u's_y', u'102'))

        el = self.new_element()
        el.set_flat(pairs)
        eq_(el.value, wanted)
示例#3
0
def test_nested_dict_as_unicode():
    schema = Dict.of(
        Dict.named(u'd').of(Integer.named(u'x').using(default=10)))
    el = schema.from_defaults()

    eq_(el.value, {u'd': {u'x': 10}})
    eq_(el.u, u"{u'd': {u'x': u'10'}}")
示例#4
0
    def test_full_set_flat(self):
        wanted = {u'x': 101, u'y': 102}
        pairs = ((u's_x', u'101'), (u's_y', u'102'))

        el = self.new_element()
        el.set_flat(pairs)
        eq_(el.value, wanted)
示例#5
0
def setup_package():
    from flatland.schema import base
    eq_(base.Element.__bases__, (base._BaseElement, ))

    import flatland.out.genshi
    flatland.out.genshi.install_element_mixin()
    assert len(base.Element.__bases__) == 2
示例#6
0
    def test_over_set_flat(self):
        wanted = {u'x': 123, u'y': None}

        pairs = ((u's_x', u'123'), (u's_z', u'nope'))
        el = self.new_element()
        el.set_flat(pairs)
        eq_(el.value, wanted)
示例#7
0
def test_nested_dict_as_unicode():
    schema = Dict.of(Dict.named(u'd').of(
        Integer.named(u'x').using(default=10)))
    el = schema.from_defaults()

    eq_(el.value, {u'd': {u'x': 10}})
    eq_(el.u, u"{u'd': {u'x': u'10'}}")
示例#8
0
文件: __init__.py 项目: dag/flatland
def setup_package():
    from flatland.schema import base
    eq_(base.Element.__bases__, (base._BaseElement,))

    import flatland.out.genshi
    flatland.out.genshi.install_element_mixin()
    assert len(base.Element.__bases__) == 2
示例#9
0
def test_set_flat_linear():
    pairs = [(u'l_0_i', 1), (u'l_1_i', 2), (u'l_2_i', 3)]

    schema = List.named(u'l').of(Integer.named(u'i'))
    el = schema.from_flat(pairs)

    eq_(len(el), len(pairs))
    eq_(el.value, list(pair[1] for pair in pairs))
示例#10
0
def test_set_flat_miss():
    pairs = [(u'l_galump', u'3'), (u'l_snorgle', u'4')]

    schema = List.named(u'l').of(Integer.named(u'i'))
    el = schema.from_flat(pairs)

    eq_(len(el), 0)
    eq_(el.value, [])
示例#11
0
def test_set_flat_linear():
    pairs = [(u'l_0_i', 1), (u'l_1_i', 2), (u'l_2_i', 3)]

    schema = List.named(u'l').of(Integer.named(u'i'))
    el = schema.from_flat(pairs)

    eq_(len(el), len(pairs))
    eq_(el.value, list(pair[1] for pair in pairs))
示例#12
0
def test_set_flat_miss():
    pairs = [(u'l_galump', u'3'), (u'l_snorgle', u'4')]

    schema = List.named(u'l').of(Integer.named(u'i'))
    el = schema.from_flat(pairs)

    eq_(len(el), 0)
    eq_(el.value, [])
示例#13
0
def teardown_package():
    from flatland.schema import base

    assert len(base.Element.__bases__) == 2

    import flatland.out.genshi
    flatland.out.genshi.uninstall_element_mixin()
    eq_(base.Element.__bases__, (base._BaseElement, ))
示例#14
0
 def test_descent(self):
     schema = Dict.of(Integer).using(
         descent_validators=[self.validator('1', True)])
     el = schema()
     assert not el.validate()
     eq_(self.canary, ['1'])
     assert el.valid
     assert not el.all_valid
示例#15
0
 def test_descent(self):
     schema = Dict.of(Integer).using(
         descent_validators=[self.validator('1', True)])
     el = schema()
     assert not el.validate()
     eq_(self.canary, ['1'])
     assert el.valid
     assert not el.all_valid
示例#16
0
def test_url_canonicalizer_default():
    v = URLCanonicalizer()
    el = scalar(u'http://localhost/#foo')
    eq_(el.value, u'http://localhost/#foo')

    assert v.validate(el, None)
    eq_(el.value, u'http://localhost/')
    assert not el.errors
示例#17
0
def test_path():
    schema = Dict.named(u'root').of(
        String.named(u'element'),
        Dict.named(u'dict').of(String.named(u'dict_element')))
    element = schema()

    eq_(list(element.find_one([u'dict', u'dict_element']).path),
        [element, element[u'dict'], element[u'dict'][u'dict_element']])
示例#18
0
def test_url_canonicalizer_want_all():
    v = URLCanonicalizer(discard_parts=())
    el = scalar(u'http://*****:*****@there/path#fragment')
    eq_(el.value, u'http://*****:*****@there/path#fragment')

    assert v.validate(el, None)
    eq_(el.value, u'http://*****:*****@there/path#fragment')
    assert not el.errors
示例#19
0
文件: __init__.py 项目: dag/flatland
def teardown_package():
    from flatland.schema import base

    assert len(base.Element.__bases__) == 2

    import flatland.out.genshi
    flatland.out.genshi.uninstall_element_mixin()
    eq_(base.Element.__bases__, (base._BaseElement,))
示例#20
0
def test_url_canonicalizer_default():
    v = URLCanonicalizer()
    el = scalar('http://localhost/#foo')
    eq_(el.value, 'http://localhost/#foo')

    assert v.validate(el, None)
    eq_(el.value, 'http://localhost/')
    assert not el.errors
示例#21
0
def test_path():
    schema = Dict.named('root').of(
        String.named('element'),
        Dict.named('dict').of(String.named('dict_element')))
    element = schema()

    eq_(list(element.el(['dict', 'dict_element']).path),
        [element, element['dict'], element['dict']['dict_element']])
示例#22
0
def test_url_canonicalizer_want_all():
    v = URLCanonicalizer(discard_parts=())
    el = scalar('http://*****:*****@there/path#fragment')
    eq_(el.value, 'http://*****:*****@there/path#fragment')

    assert v.validate(el, None)
    eq_(el.value, 'http://*****:*****@there/path#fragment')
    assert not el.errors
示例#23
0
    def test_set_default(self):
        wanted = {u'x': 11, u'y': 12}
        schema = self.new_schema()
        schema.default = wanted

        el = schema()
        el.set_default()
        eq_(el.value, wanted)
示例#24
0
    def test_set_default(self):
        wanted = {u'x': 11, u'y': 12}
        schema = self.new_schema()
        schema.default = wanted

        el = schema()
        el.set_default()
        eq_(el.value, wanted)
示例#25
0
    def same_(source, kw):
        el = schema(source)

        sliced = el.slice(**kw)
        wanted = dict(keyslice_pairs(el.value.items(), **kw))

        eq_(sliced, wanted)
        eq_(set(type(_) for _ in sliced.keys()),
            set(type(_) for _ in wanted.keys()))
示例#26
0
def test_http_validator_default():
    v = HTTPURLValidator(forbidden_part='X')
    el = scalar('http://there/path#fragment')
    assert v.validate(el, None)
    assert not el.errors

    el = scalar('http://*****:*****@there/path#fragment')
    not v.validate(el, None)
    eq_(el.errors, ['X'])
示例#27
0
    def same_(source, kw):
        el = schema(source)

        sliced = el.slice(**kw)
        wanted = dict(keyslice_pairs(el.value.items(), **kw))

        eq_(sliced, wanted)
        eq_(set(type(_) for _ in sliced.keys()),
            set(type(_) for _ in wanted.keys()))
示例#28
0
    def test_regular(self):
        schema = (Dict.of(Integer).using(
            validators=[self.validator('1', True)]))
        el = schema()

        assert not el.validate()
        eq_(self.canary, ['1'])
        assert el.valid
        assert not el.all_valid
示例#29
0
    def test_regular(self):
        schema = (Dict.of(Integer).
                  using(validators=[self.validator('1', True)]))
        el = schema()

        assert not el.validate()
        eq_(self.canary, ['1'])
        assert el.valid
        assert not el.all_valid
示例#30
0
def validate_element_set(type_, raw, value, uni, schema_opts={},
                         set_return=None):
    if set_return is None:
        set_return = value is not None
    element = type_(**schema_opts)
    eq_(element.set(raw), set_return)
    eq_(element.value, value)
    eq_(element.u, uni)
    eq_(unicode(element), uni)
    eq_(element.__nonzero__(), bool(uni and value))
示例#31
0
def test_map_equal():
    v = MapEqual('x', 'y',
                         transform=lambda el: el.value.upper(),
                         unequal='%(labels)s/%(last_label)s')
    el = form(dict(x='a', y='A'))
    assert v.validate(el, None)

    el = form(dict(x='a', y='B'))
    assert not v.validate(el, None)
    eq_(el.errors, ['x/y'])
示例#32
0
def validate_element_set(type_, raw, value, uni, schema_opts={},
                         set_return=None):
    if set_return is None:
        set_return = value is not None
    element = type_(**schema_opts)
    eq_(element.set(raw), set_return)
    eq_(element.value, value)
    eq_(element.u, uni)
    eq_(unicode(element), uni)
    eq_(element.__nonzero__(), bool(uni and value))
示例#33
0
    def test_half_set(self):
        wanted = {u'x': 123, u'y': None}

        el = self.new_element()
        el.set({u'x': 123})
        eq_(el.value, wanted)

        el = self.new_element()
        el.set([(u'x', 123)])
        eq_(el.value, wanted)
示例#34
0
def test_map_equal():
    v = MapEqual('x', 'y',
                         transform=lambda el: el.value.upper(),
                         unequal='%(labels)s/%(last_label)s')
    el = form(dict(x='a', y='A'))
    assert v.validate(el, None)

    el = form(dict(x='a', y='B'))
    assert not v.validate(el, None)
    eq_(el.errors, ['x/y'])
示例#35
0
def test_straight_parse():
    form = SimpleForm1.from_flat(REQUEST_DATA)
    eq_(set(form.flatten()), set(((u'fname', u'FN'),
                                  (u'surname', u'SN'),
                                  (u'age', u'99'))))

    eq_(form.value, dict(fname=u'FN',
                         surname=u'SN',
                         age=99,
                         snacks=[]))
示例#36
0
def test_url_validator_schemes():
    v = URLValidator(allowed_schemes=(), blocked_scheme='X')
    el = scalar('http://*****:*****@there/path#fragment')
    assert not v.validate(el, None)
    eq_(el.errors, ['X'])

    v = URLValidator(allowed_schemes=('https',), blocked_scheme='X')
    el = scalar('http://*****:*****@there/path#fragment')
    assert not v.validate(el, None)
    eq_(el.errors, ['X'])
示例#37
0
 def test_paired3(self):
     schema = (Dict.of(
         Integer.using(validators=[self.validator('2', True)])).using(
             descent_validators=[self.validator('1', True)],
             validators=[self.validator('3', True)]))
     el = schema()
     assert el.validate()
     eq_(self.canary, ['1', '2', '3'])
     assert el.valid
     assert el.all_valid
示例#38
0
def test_set_flat_pruned():
    sub = String.named(u's')
    pairs = [(u's', u'val0'), (u's', u''), (u's', u'val1'), (u's', u'')]
    wanted = [u'val0', u'val1']

    for schema in Array.of(sub), Array.of(sub).using(prune_empty=True):
        el = schema.from_flat(pairs)

        eq_(len(el), len(wanted))
        eq_(el.value, wanted)
示例#39
0
def test_set_flat_pruned():
    sub = String.named(u's')
    pairs = [(u's', u'val0'), (u's', ''), (u's', u'val1'), (u's', u'')]
    wanted = [u'val0', u'val1']

    for schema in Array.of(sub), Array.of(sub).using(prune_empty=True):
        el = schema.from_flat(pairs)

        eq_(len(el), len(wanted))
        eq_(el.value, wanted)
示例#40
0
def test_url_validator_schemes():
    v = URLValidator(allowed_schemes=(), blocked_scheme='X')
    el = scalar(u'http://*****:*****@there/path#fragment')
    assert not v.validate(el, None)
    eq_(el.errors, [u'X'])

    v = URLValidator(allowed_schemes=('https', ), blocked_scheme='X')
    el = scalar(u'http://*****:*****@there/path#fragment')
    assert not v.validate(el, None)
    eq_(el.errors, [u'X'])
示例#41
0
    def test_half_set(self):
        wanted = {u'x': 123, u'y': None}

        el = self.new_element()
        el.set({u'x': 123})
        eq_(el.value, wanted)

        el = self.new_element()
        el.set([(u'x', 123)])
        eq_(el.value, wanted)
示例#42
0
 def test_shortcircuit_up(self):
     schema = (Dict.of(
         Integer.using(validators=[self.validator('2', True)])).using(
             descent_validators=[self.validator('1', True)],
             validators=[self.validator('3', SkipAll)]))
     el = schema()
     assert el.validate()
     eq_(self.canary, ['1', '2', '3'])
     assert el.valid
     assert el.all_valid
示例#43
0
    def test_set_default_from_children(self):
        el = self.new_element()
        el.set_default()

        wanted = {
            u'x':
            self.x_default if self.x_default is not Unspecified else None,
            u'y':
            self.y_default if self.y_default is not Unspecified else None,
        }
        eq_(el.value, wanted)
示例#44
0
    def test_set_default_from_children(self):
        el = self.new_element()
        el.set_default()

        wanted = {
            u'x': self.x_default if self.x_default is not Unspecified
                                 else None,
            u'y': self.y_default if self.y_default is not Unspecified
                                 else None,
            }
        eq_(el.value, wanted)
示例#45
0
def test_values_equal_two():
    v = ValuesEqual('x', 'y')
    el = form(dict(x='a', y='a', z='a'))
    assert v.validate(el, None)

    el = form(dict(x='a', y='b', z='c'))
    assert not v.validate(el, None)
    eq_(el.errors, ['x and y do not match.'])

    el = form(dict(x='a'))
    assert not v.validate(el, None)
    eq_(el.errors, ['x and y do not match.'])
示例#46
0
 def test_shortcircuit_up(self):
     schema = (
         Dict.of(
             Integer.using(validators=[self.validator('2', True)])).
         using(
             descent_validators=[self.validator('1', True)],
             validators=[self.validator('3', SkipAll)]))
     el = schema()
     assert el.validate()
     eq_(self.canary, ['1', '2', '3'])
     assert el.valid
     assert el.all_valid
示例#47
0
def test_values_equal_three():
    v = ValuesEqual(u'x', u'y', u'z')
    el = form(dict(x=u'a', y=u'a', z=u'a'))
    assert v.validate(el, None)

    el = form(dict(x=u'a', y=u'b', z=u'c'))
    assert not v.validate(el, None)
    eq_(el.errors, [u'x, y and z do not match.'])

    el = form(dict(x=u'a'))
    assert not v.validate(el, None)
    eq_(el.errors, [u'x, y and z do not match.'])
示例#48
0
def test_values_equal_three():
    v = ValuesEqual('x', 'y', 'z')
    el = form(dict(x='a', y='a', z='a'))
    assert v.validate(el, None)

    el = form(dict(x='a', y='b', z='c'))
    assert not v.validate(el, None)
    eq_(el.errors, ['x, y and z do not match.'])

    el = form(dict(x='a'))
    assert not v.validate(el, None)
    eq_(el.errors, ['x, y and z do not match.'])
示例#49
0
 def test_shortcircuit_down_false(self):
     schema = (Dict.of(
         Integer.named(u'i').using(
             validators=[self.validator('2', True)])).using(
                 descent_validators=[self.validator('1', SkipAllFalse)],
                 validators=[self.validator('3', True)]))
     el = schema()
     assert not el.validate()
     eq_(self.canary, ['1', '3'])
     assert not el.valid
     assert not el.all_valid
     assert el[u'i'].valid is Unevaluated
示例#50
0
 def test_paired3(self):
     schema = (
         Dict.of(
             Integer.using(validators=[self.validator('2', True)])).
         using(
             descent_validators=[self.validator('1', True)],
             validators=[self.validator('3', True)]))
     el = schema()
     assert el.validate()
     eq_(self.canary, ['1', '2', '3'])
     assert el.valid
     assert el.all_valid
示例#51
0
文件: _util.py 项目: dag/flatland
def test_chunk_assertion_blocks_1():
   input = """
foo
bar
:: test
thing
thing
:: eq
thing thing
:: endtest
"""
   eq_(chunk_assertion_blocks(input),
       [[1, '1', 'thing thing', 'thing thing']])
示例#52
0
def test_chunk_assertion_blocks_1():
    input = """
foo
bar
:: test
thing
thing
:: eq
thing thing
:: endtest
"""
    eq_(chunk_assertion_blocks(input),
        [[1, '1', 'thing thing', 'thing thing']])
示例#53
0
def test_http_validator_default():
    v = HTTPURLValidator(forbidden_part='X')
    el = scalar(u'http://there/path#fragment')
    assert v.validate(el, None)
    assert not el.errors

    el = scalar(u'http://*****:*****@there/path#fragment')
    not v.validate(el, None)
    eq_(el.errors, [u'X'])

    el = scalar('www.example.com')
    not v.validate(el, None)
    eq_(el.errors, ['test is not a valid URL.'])
示例#54
0
 def test_shortcircuit_down_false(self):
     schema = (
         Dict.of(
             Integer.named(u'i').using(
                 validators=[self.validator('2', True)])).
         using(descent_validators=[self.validator('1', SkipAllFalse)],
               validators=[self.validator('3', True)]))
     el = schema()
     assert not el.validate()
     eq_(self.canary, ['1', '3'])
     assert not el.valid
     assert not el.all_valid
     assert el[u'i'].valid is Unevaluated
示例#55
0
文件: test_base.py 项目: dag/flatland
def test_message_buckets():
    el = Element()

    el.add_error('error')
    eq_(el.errors, ['error'])
    el.add_error('error')
    eq_(el.errors, ['error'])
    el.add_error('error2')
    eq_(el.errors, ['error', 'error2'])

    el.add_warning('warning')
    eq_(el.warnings, ['warning'])
    el.add_warning('warning')
    eq_(el.warnings, ['warning'])
示例#56
0
def test_scalar_assignments_are_independent():
    element = Scalar()

    assert not element.u
    assert not element.value
    element.u = u'abc'
    assert element.value is None

    element = Scalar()
    assert not element.u
    assert not element.value
    element.value = u'abc'
    eq_(element.u, u'')
    eq_(element.value, u'abc')
示例#57
0
def test_message_buckets():
    el = Element()

    el.add_error('error')
    eq_(el.errors, ['error'])
    el.add_error('error')
    eq_(el.errors, ['error'])
    el.add_error('error2')
    eq_(el.errors, ['error', 'error2'])

    el.add_warning('warning')
    eq_(el.warnings, ['warning'])
    el.add_warning('warning')
    eq_(el.warnings, ['warning'])
示例#58
0
def test_scalar_assignments_are_independent():
    element = Scalar()

    assert not element.u
    assert not element.value
    element.u = u'abc'
    assert element.value is None

    element = Scalar()
    assert not element.u
    assert not element.value
    element.value = u'abc'
    eq_(element.u, u'')
    eq_(element.value, u'abc')
示例#59
0
    def test_scalar_set_flat(self):
        wanted = {u'x': None, u'y': None}
        pairs = ((u's', u'xxx'),)

        el = self.new_element()

        canary = []
        def setter(self, value):
            canary.append(value)
            return type(el).set(self, value)

        el.set = setter.__get__(el, type(el))
        el.set_flat(pairs)
        eq_(el.value, wanted)
        assert canary == []
示例#60
0
def test_strong_receiver():
    sentinel = []

    def received(**kw):
        sentinel.append(kw)
    fn_id = id(received)

    sig = Signal()
    sig.connect(received, weak=False)
    del received

    assert not sentinel
    sig.send()
    assert sentinel
    eq_([id(fn) for fn in sig.receivers.values()], [fn_id])