コード例 #1
0
def test_repr():
    """
    repr(AttrDict)
    """
    from attrdict.dictionary import AttrDict

    assert_equals(repr(AttrDict()), "AttrDict({})")
    assert_equals(repr(AttrDict({'foo': 'bar'})), "AttrDict({'foo': 'bar'})")
    assert_equals(repr(AttrDict({1: {
        'foo': 'bar'
    }})), "AttrDict({1: {'foo': 'bar'}})")
    assert_equals(repr(AttrDict({1: AttrDict({'foo': 'bar'})})),
                  "AttrDict({1: AttrDict({'foo': 'bar'})})")
コード例 #2
0
    def test_has_key():
        """
        The now-depricated has_keys method
        """
        from attrdict.dictionary import AttrDict

        assert_false(hasattr(AttrDict(), 'has_key'))
コード例 #3
0
    def test_has_key():
        """
        The now-depricated has_keys method
        """
        from attrdict.dictionary import AttrDict

        mapping = AttrDict(
            {'foo': 'bar', frozenset((1, 2, 3)): 'abc', 1: 2}
        )
        empty = AttrDict()

        assert_true(mapping.has_key('foo'))
        assert_false(empty.has_key('foo'))

        assert_true(mapping.has_key(frozenset((1, 2, 3))))
        assert_false(empty.has_key(frozenset((1, 2, 3))))

        assert_true(mapping.has_key(1))
        assert_false(empty.has_key(1))

        assert_false(mapping.has_key('banana'))
        assert_false(empty.has_key('banana'))
コード例 #4
0
def test_copy():
    """
    Make a dict copy of an AttrDict.
    """
    from attrdict.dictionary import AttrDict

    mapping_a = AttrDict({'foo': {'bar': 'baz'}})
    mapping_b = mapping_a.copy()
    mapping_c = mapping_b

    mapping_b['foo']['lorem'] = 'ipsum'

    assert_equals(mapping_a, mapping_b)
    assert_equals(mapping_b, mapping_c)
コード例 #5
0
def test_init():
    """
    Create a new AttrDict.
    """
    from attrdict.dictionary import AttrDict

    # empty
    assert_equals(AttrDict(), {})
    assert_equals(AttrDict(()), {})
    assert_equals(AttrDict({}), {})

    # with items
    assert_equals(AttrDict({'foo': 'bar'}), {'foo': 'bar'})
    assert_equals(AttrDict((('foo', 'bar'), )), {'foo': 'bar'})
    assert_equals(AttrDict(foo='bar'), {'foo': 'bar'})

    # non-overlapping
    assert_equals(AttrDict({}, foo='bar'), {'foo': 'bar'})
    assert_equals(AttrDict((), foo='bar'), {'foo': 'bar'})

    assert_equals(AttrDict({'alpha': 'bravo'}, foo='bar'), {
        'foo': 'bar',
        'alpha': 'bravo'
    })

    assert_equals(AttrDict((('alpha', 'bravo'), ), foo='bar'), {
        'foo': 'bar',
        'alpha': 'bravo'
    })

    # updating
    assert_equals(AttrDict({'alpha': 'bravo'}, foo='bar', alpha='beta'), {
        'foo': 'bar',
        'alpha': 'beta'
    })

    assert_equals(AttrDict((('alpha', 'bravo'), ('alpha', 'beta')), foo='bar'),
                  {
                      'foo': 'bar',
                      'alpha': 'beta'
                  })

    assert_equals(
        AttrDict((('alpha', 'bravo'), ('alpha', 'beta')), alpha='bravo'),
        {'alpha': 'bravo'})