def test_map_type(self):
obj = next(self.backend.items(BytesIO(JSON), ''))
self.assertTrue(isinstance(obj, dict))
obj = next(
self.backend.items(BytesIO(JSON),
'',
map_type=collections.OrderedDict))
self.assertTrue(isinstance(obj, collections.OrderedDict))
def test_kvitems_twodictlevels(self):
f = BytesIO(b'{"meta":{"view":{"columns":[{"id": -1}, {"id": -2}]}}}')
view = list(self.backend.kvitems(f, 'meta.view'))
self.assertEqual(1, len(view))
key, value = view[0]
self.assertEqual('columns', key)
self.assertEqual([{'id': -1}, {'id': -2}], value)
def test_utf8_split(self):
buf_size = JSON.index(b'\xd1') + 1
try:
events = list(
self.backend.basic_parse(BytesIO(JSON), buf_size=buf_size))
except UnicodeDecodeError:
self.fail('UnicodeDecodeError raised')
def test_object_builder(self):
builder = common.ObjectBuilder()
for event, value in basic_parse(BytesIO(JSON)):
builder.event(event, value)
self.assertEqual(
builder.value, {
'docs': [
{
'ñandú': None,
'string': 'строка - тест',
'null': None,
'boolean': False,
'true': True,
'integer': 0,
'double': Decimal('0.5'),
'exponent': 100,
'long': 10000000000,
},
{
'meta': [[1], {}],
},
{
'meta': {
'key': 'value'
},
},
{
'meta': None,
},
],
})
def test_parse(self):
events = common.parse(basic_parse(BytesIO(JSON)))
events = [
value for prefix, event, value in events
if prefix == 'docs.item.meta.item.item'
]
self.assertEqual(events, [1])
def test_invalid(self):
for json in INVALID_JSONS:
# Yajl1 doesn't complain about additional data after the end
# of a parsed object. Skipping this test.
if self.__class__.__name__ == 'YajlParse' and json == YAJL1_PASSING_INVALID:
continue
with self.assertRaises(common.JSONError) as cm:
list(self.backend.basic_parse(BytesIO(json)))
def test_multiple_values(self):
if not self.supports_multiple_values:
return
basic_parse = self.backend.basic_parse
items = lambda x, **kwargs: self.backend.items(x, '', **kwargs)
multiple_values = JSON + JSON + JSON
for func in (basic_parse, items):
generator = func(BytesIO(multiple_values))
self.assertRaises(common.JSONError, list, generator)
generator = func(BytesIO(multiple_values), multiple_values=False)
self.assertRaises(common.JSONError, list, generator)
generator = func(BytesIO(multiple_values), multiple_values=True)
result = list(generator)
if func == basic_parse:
self.assertEqual(result,
JSON_EVENTS + JSON_EVENTS + JSON_EVENTS)
else:
self.assertEqual(result,
[JSON_OBJECT, JSON_OBJECT, JSON_OBJECT])
def test_items(self):
events = basic_parse(BytesIO(JSON))
meta = list(common.items(common.parse(events), 'docs.item.meta'))
self.assertEqual(meta, [
[[1], {}],
{
'key': 'value'
},
None,
])
def test_kvitems_empty(self):
kvitems = list(self.backend.kvitems(BytesIO(JSON), 'docs'))
self.assertEqual([], kvitems)
def test_kvitems_different_underlying_types(self):
kvitems = list(self.backend.kvitems(BytesIO(JSON), 'docs.item.meta'))
self.assertEqual(JSON_KVITEMS_META, kvitems)
def test_items_twodictlevels(self):
f = BytesIO(b'{"meta":{"view":{"columns":[{"id": -1}, {"id": -2}]}}}')
ids = list(self.backend.items(f, 'meta.view.columns.item.id'))
self.assertEqual(2, len(ids))
self.assertListEqual([-2, -1], sorted(ids))
def test_api(self):
self.assertTrue(list(self.backend.items(BytesIO(JSON), '')))
self.assertTrue(list(self.backend.parse(BytesIO(JSON))))
def test_boundary_whitespace(self):
buf_size = JSON.index(b' ') + 1
events = list(
self.backend.basic_parse(BytesIO(JSON), buf_size=buf_size))
self.assertEqual(events, JSON_EVENTS)
def create_mock_open_users():
mock_open_users = mock_open()
mock_open_users.return_value = BytesIO(dummy.dummy_user_data)
return mock_open_users
def test_kvitems_toplevel(self):
kvitems = list(self.backend.kvitems(BytesIO(JSON), ''))
self.assertEqual(1, len(kvitems))
key, value = kvitems[0]
self.assertEqual('docs', key)
self.assertEqual(JSON_OBJECT['docs'], value)
def test_lazy(self):
# shouldn't fail since iterator is not exhausted
self.backend.basic_parse(BytesIO(INVALID_JSONS[0]))
self.assertTrue(True)
def test_surrogate_pairs(self):
event = next(self.backend.basic_parse(BytesIO(SURROGATE_PAIRS_JSON)))
parsed_string = event[1]
self.assertEqual(parsed_string, '💩')
def test_strings(self):
events = list(self.backend.basic_parse(BytesIO(STRINGS_JSON)))
strings = [value for event, value in events if event == 'string']
self.assertEqual(strings, ['', '"', '\\', '\\\\', '\b\f\n\r\t'])
self.assertTrue(('map_key', 'special\t') in events)
def test_scalar(self):
events = list(self.backend.basic_parse(BytesIO(SCALAR_JSON)))
self.assertEqual(events, [('number', 0)])
def test_basic_parse(self):
events = list(self.backend.basic_parse(BytesIO(JSON)))
self.assertEqual(events, JSON_EVENTS)
def test_scalar_builder(self):
builder = common.ObjectBuilder()
for event, value in basic_parse(BytesIO(SCALAR_JSON)):
builder.event(event, value)
self.assertEqual(builder.value, 0)
def create_mock_open_tickets():
mock_open_tickets = mock_open()
mock_open_tickets.return_value = BytesIO(dummy.dummy_ticket_data)
return mock_open_tickets
def test_numbers(self):
events = list(self.backend.basic_parse(BytesIO(NUMBERS_JSON)))
types = [type(value) for event, value in events if event == 'number']
self.assertEqual(types, [int, Decimal, Decimal])
def create_mock_open_organizations():
mock_open_organizations = mock_open()
mock_open_organizations.return_value = BytesIO(
dummy.dummy_organization_data)
return mock_open_organizations
def test_bytes(self):
l = Lexer(BytesIO(JSON))
self.assertEqual(next(l)[1], '{')
def test_incomplete(self):
for json in INCOMPLETE_JSONS:
with self.assertRaises(common.IncompleteJSONError):
list(self.backend.basic_parse(BytesIO(json)))
def _reader(self, json):
if type(json) == compat.bytetype:
return BytesIO(json)
return StringIO(json)
def test_kvitems(self):
kvitems = list(self.backend.kvitems(BytesIO(JSON), 'docs.item'))
self.assertEqual(JSON_KVITEMS, kvitems)
