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)