Exemple #1
0
 def test_dumps_list_impostors(self):
     to_dumps = {
         'a': 'Hello',
         'a': 'Hello',
         'b': 'Goodbye',
         'b2': 'I-try-to-be-a-list',
         'l': {
             'desc1': '1',
             'desc2': '2',
             'foo': [{
                 'bar': ['1', '2'],
                 'bar33': 'haha',
             }],
             'foo_33': {
                 'bar': ['muhaha'],
             },
         },
     }
     dumped = nvp.dumps(to_dumps, convention=nvp.CONVENTION_UNDERSCORE)
     dumped = sorted(dumped.split('&'))
     expected = sorted(urlencode({
         'a': 'Hello',
         'a': 'Hello',
         'b': 'Goodbye',
         'b2': 'I-try-to-be-a-list',
         'l_desc1': '1',
         'l_desc2': '2',
         'l_foo_0_bar0': '1',
         'l_foo_0_bar1': '2',
         'l_foo_0_bar33': 'haha',
         'l_foo_33_bar0': 'muhaha',
     }).split('&'))
     self.assertEqual(dumped, expected)
Exemple #2
0
    def test_dumps_with_value_filter(self):
        def value_filter(value):
            return value * 10

        to_dump = dict(a=1, b=2, c=3)
        expected = 'a=10&b=20&c=30'.split('&')
        dumped = nvp.dumps(to_dump, value_filter=value_filter)
        dumped = sorted(dumped.split('&'))
        self.assertEqual(expected, dumped)
Exemple #3
0
    def test_dumps_with_key_filter(self):
        def key_to_upper(key):
            return key.upper()

        to_dump = dict(a=1, b='2', c='3')
        expected = 'A=1&B=2&C=3'.split('&')
        dumped = nvp.dumps(to_dump, key_filter=key_to_upper)
        dumped = sorted(dumped.split('&'))
        self.assertEqual(expected, dumped)
Exemple #4
0
    def test_dumps(self):
        """Test encoding all decoded data source values using nvp.dumps."""
        decoded = self.data_source['decoded']
        encoded = self.data_source['encoded']

        for name, obj in decoded.iteritems():
            encoded_obj = encoded[name]
            for convention in nvp.CONVENTIONS:
                to_match = encoded_obj[convention]
                value = nvp.dumps(obj, convention=convention)
                self.assertEqual(value, to_match)
Exemple #5
0
    def test_load(self):
        value = {
            'foo': 'hello',
            'list': [
                'hello',
                'world',
            ],
        }
        encoded_value = nvp.dumps(value)

        fp = StringIO()
        fp.write(encoded_value)
        fp.seek(0)
        loaded_value = nvp.load(fp)
        fp.close()

        self.assertEqual(loaded_value, value)
Exemple #6
0
    def test_dump(self):
        value = {
            'foo': [
                {
                    'hello': 'again',
                    'one': 'two',
                    'alist': [1, 2, 3, 4],
                },
            ],
            'simple': 'Hello world',
        }

        encoded_value = nvp.dumps(value)

        fp = StringIO()
        nvp.dump(value, fp)
        fp.seek(0)
        written_encoded_value = fp.read()
        fp.close()

        self.assertEqual(written_encoded_value, encoded_value)
        'FIRSTNAME': ['Robert'],
        'MIDDLENAME': ['Herbert'],
        'LASTNAME': ['Moore'],
    },
}

cbracket = nvp.util.CONVENTION_BRACKET
cparentheses = nvp.util.CONVENTION_PARENTHESES
cundersore = nvp.util.CONVENTION_UNDERSCORE

# Dictionary containing encoded values
ENCODED = {}
for name, dictionary in DECODED.iteritems():
    ENCODED[name] = {}
    for c in nvp.CONVENTIONS:
        ENCODED[name][c] = nvp.dumps(dictionary, convention=c)

# The data source to be JSON encoded
DATA = {
    'decoded': DECODED,
    'encoded': ENCODED,
}


def main():
    encoded_data = json.dumps(DATA, sort_keys=True, indent=4)
    path = os.path.abspath(os.path.join(__file__, DATA_FILENAME))
    with open(path, 'w') as f:
        f.write(encoded_data)

if __name__ == '__main__':
Exemple #8
0
 def encode(self, convention=None):
     convention = convention if convention else self.NVP_CONVENTION
     return nvp.dumps(util.ensure_unicode(self),
                      key_filter=self.encode_key_filter,
                      value_filter=self.encode_value_filter,
                      convention=convention)