def __init__(self, message: str, source: object, target: type,
error: JSONDecodeError):
"""
Constructor.
:param message: the message of this error.
:param source: the object that was to be deserialized.
:param target: the type to which `source` was to be deserialized.
:param error: the wrapped `JSONDecodeError`.
"""
DeserializationError.__init__(self, message, source, target)
JSONDecodeError.__init__(self, message, error.doc, error.pos)
def __init__(self, file_name):
"""
Parameterized constructor with file_name parameter to instantiate class instance
:param file_name: path to the configuration file to instantiate class instance
:raise FileNotFoundError or JSONDecodeError in the file was not found
or can not be read as json dictionary
"""
self.file_name = file_name
# names of mandatory entities (1st level) in the configuration file
self._videos = "videos"
self._report_folder = "report_folder"
self._report_name = "report_name"
self._reference_video = "reference_video"
self._compressed_video = "compressed_video"
try:
with open(file_name, 'r') as config:
self._data = json.load(config)
except FileNotFoundError:
raise FileNotFoundError(
"{} is not found or the path is incorrect".format(
self.file_name))
except JSONDecodeError as json_exc:
raise JSONDecodeError(
"{} invalid json file".format(self.file_name), json_exc.doc,
json_exc.pos)
def decode(self,
s,
_w=WHITESPACE.match,
_ws=WHITESPACE_STR,
_ilcs=INLINE_COMMENT_STRING_START,
_ilc=INLINE_COMMENT.match,
_mlcs=MULTILINE_COMMENT_STRING_START,
_mlc=MULTILINE_COMMENT.match):
# pylint: disable=arguments-differ
idx = 0
try:
while True: # Handle comments and whitespaces
if s[idx] in _ws:
idx = _w(s, idx).end()
elif s[idx:].startswith(_ilcs):
idx = _ilc(s, idx).end()
elif s[idx:].startswith(_mlcs):
idx = _mlc(s, idx).end()
else:
break
except IndexError:
pass
obj, end = self.raw_decode(s, idx)
end = _w(s, end).end()
if end != len(s):
raise JSONDecodeError("Extra data", s, end)
return obj
def _receive_file(access, local_file_path):
with open(access) as f:
access = json.load(f)
http_method = http_method_func(access, 'GET')
auth_method = auth_method_obj(access)
verify = True
if access.get('disableSSLVerification'):
verify = False
r = http_method(access['url'],
auth=auth_method,
verify=verify,
timeout=DEFAULT_TIMEOUT)
r.raise_for_status()
try:
data = r.json()
except JSONDecodeError as e:
raise JSONDecodeError(
'Could not parse the http response as json object. Failed with the following message:\n'
.format(str(e)), e.doc, e.pos)
with open(local_file_path, 'w') as f:
json.dump(data, f)
def test_get_monitoring_locations_3_success_with_json_parse_error(self):
fake_first_url = self.fake_endpoint + '?limit=8&offset=0'
mock_response_a = mocki({'text': self.mock_json_good, 'status_code': 200}, spec=Response)
mock_payload_a = copy.deepcopy(self.mock_payload)
mock_payload_a['next'] = self.fake_endpoint + '?limit=8&offset=8'
when(mock_response_a).json().thenReturn(mock_payload_a)
mock_response_b = mocki({'text': self.mock_json_good, 'status_code': 200}, spec=Response)
mock_payload_b = copy.deepcopy(self.mock_payload)
mock_payload_b['next'] = self.fake_endpoint + '?limit=8&offset=16'
when(mock_response_b).json().thenRaise(JSONDecodeError('Bad JSON', 'Bad DOC', 0))
mock_response_c = mocki({'text': self.mock_json_good, 'status_code': 200}, spec=Response)
mock_payload_c = copy.deepcopy(self.mock_payload)
# mock_payload_c['next'] = None # this is the mock default value. It requires setting if the default changes.
when(mock_response_c).json().thenReturn(mock_payload_c)
when(self.mock_session).get(fake_first_url).thenReturn(mock_response_a)
when(self.mock_session).get(mock_payload_a['next']).thenReturn(mock_response_b)
when(self.mock_session).get(mock_payload_b['next']).thenReturn(mock_response_c)
extract = MockExtract(self.mock_session)
records = extract.get_monitoring_locations(self.fake_endpoint)
# the base URL is not called in this test. Extract.construct_url() adds the fetch limit in lieu of the default.
mockito.verify(self.mock_session, times=0).get(self.fake_endpoint)
# each of the batch request URLs is called once. One is the default but I like explicit indication.
mockito.verify(self.mock_session, times=1).get(extract.construct_url(self.fake_endpoint))
# this one will fail by mock conditions after called twice
mockito.verify(self.mock_session, times=2).get(mock_payload_a['next'])
mockito.verify(self.mock_session, times=1).get(mock_payload_b['next'])
self.assertEqual(2, len(records), 'there should be two mock records returned because of the middle fail')
def test_get_announcements_wrong_json_response_handling(
self, requests_session, get_used_options):
# wrong JSON structure
announcements = {
"type":
"notice",
"message":
"You are using an outdated version of Safety. Please upgrade to Safety version 1.2.3"
}
mock = Mock()
mock.status_code = HTTPStatus.OK.value
mock.json.return_value = announcements
requests_session.get.return_value = mock
self.assertEqual(safety.get_announcements('somekey', {}), [])
# JSONDecodeError
mock = Mock()
mock.status_code = HTTPStatus.OK.value
mock.json.side_effect = JSONDecodeError(msg='Expecting value',
doc='',
pos=0)
requests_session.get.return_value = mock
self.assertEqual(safety.get_announcements('somekey', {}), [])
def _parse_json(f, schemacls):
"""
:param f: file-like object to read json from
:param schemacls: the schema to parse the properties with
:return: a dictionary containing the validated object
:raises: JSONDecodeError if the JSON is malformed
"""
schema = schemacls()
try:
obj, errors = schema.loads(f.read())
if errors:
raise JSONDecodeError("schema validation failed {}".format(errors),
"", 0)
return obj
except ValueError as e:
raise JSONDecodeError("failed to decode JSON: {}".format(e), "", pos=0)
def from_json(self, json_form, overwrite_name=True):
"""
Load the table from a JSON string, of the form produced by toJSON(). Note
that if the overwrite_name parameter = True (the default), this will also
overwrite the table name.
Throws InvalidDataException id json_form is malformed
Args:
json_form: A JSON form of the Dictionary
Returns:
None
Throws:
InvalidDataException if json_form is malformed
"""
try:
record = loads(json_form)
except JSONDecodeError(msg):
raise InvalidDataException(msg)
if (type(record) != dict):
raise InvalidDataException(
f'JSON form of table must be a dictionary, not {type(record)}')
self._check_fields(record, {"name", "table"}, 'JSON form of table')
self.load_from_dictionary(record["table"])
if (overwrite_name):
self.name = record["name"]
def get_message_from_server(socket):
response = socket.recv(CONFIGS.CONFIG_PROJECT['DEFAULT_CONF'].get('MAX_PACKAGE_LENGTH'))
try:
response_decode = response.decode(CONFIGS.CONFIG_PROJECT['DEFAULT_CONF'].get('ENCODING'))
except:
raise JSONDecodeError('Ошибка декодирования')
return json.loads(response_decode)
async def test_request_json_decode_error(self, request_builder):
# Set up mocks
request_mock = AsyncMock(return_value=httpx.Response(request=Mock(), status_code=200, content=b"{}"))
request_builder._httpx_client.send = request_mock
# Run
with patch.object(Response, "json", side_effect=JSONDecodeError("", "", 0)), pytest.raises(JSONDecodeError):
await request_builder.foo.bar.retrieve(pk=1)
def test_deals_with_JSONDecodeError():
error_msg = 'ANY ERROR MESSAGE'
m = mock.Mock(status_code=200)
m.json.side_effect = JSONDecodeError(msg=error_msg, doc='', pos=0)
with mock.patch('robot.proxymonitor.proxytools.requests.get') as mock_get:
mock_get.return_value = m
response = proxytools.get_connection_info()
assert error_msg in response.get('status')
def api_request(url: str) -> dict:
r = requests.get(url=url, params={'address': 'Singapore'})
try:
return r.json()
except JSONDecodeError:
with open('JSONDecodeError.txt', 'w') as file:
file.write(r.text)
file.close()
raise JSONDecodeError()
def test_invoke_json_decode_error(self):
intent = self.intent
intent.implementation = error_intent
with patch('skill_sdk.routes.request', new=self.request), \
patch('skill_sdk.log.prepare_for_logging', side_effect=JSONDecodeError('', '', 0)), \
patch.object(skill_sdk.skill.Skill, '_intents', new={'TELEKOM_Demo_Intent': intent}):
from skill_sdk.routes import invoke
result = invoke()
self.assertEqual(result.status_code, 400)
def test_logging_error(self):
aiohttp.ClientResponse.json = AsyncMock(side_effect=JSONDecodeError('ERROR', '', 0))
async def test():
self.data = await self.handler.get_dorks()
with self.assertLogs(level='ERROR') as log:
self.loop.run_until_complete(test())
self.assertIn('Error getting dorks: ERROR: line 1 column 1 (char 0)', log.output[0])
def test_json_decode_error(self):
cache.clear()
requests.get = Mock(
side_effect=JSONDecodeError("Error in JSON format", "", 0))
res = movie_list(self.req, 'films', 'people')
self.assertEqual(res.content, b'Problem with the Movie API')
def test_update_with_json_decode_error(self, mock_session, mock_request):
"""Test updating feed raises exception."""
home_coordinates = (-31.0, 151.0)
mock_session.return_value.__enter__.return_value.send\
.side_effect = JSONDecodeError("", "", 0)
feed = GenericFeed(home_coordinates, None)
status, entries = feed.update()
assert status == UPDATE_ERROR
self.assertIsNone(entries)
def test_reports_error_when_json_unparseable(self, patch_config, mock_json,
config, timepoint):
patch_config.return_value = config
mock_json.side_effect = JSONDecodeError("", "", 0)
manifests = dm_utils.get_manifests(timepoint)
for session in manifests:
for scan in manifests[session]:
json_contents = manifests[session][scan]
assert "Error" in json_contents
def test_fetch_record_block_2_bad_json(self):
# ensure that the retries works and that if the JSON is bad that it only tries TWICE
self.assertEqual(self.extract.FETCH_TRIES_FOR_JSON, 2) # testing that it is reset between tests
mock_response_a = mocki({'text': 'bad JSON twice', 'status_code': 200}, spec=Response)
when(self.mock_session).get(self.fake_endpoint).thenReturn(mock_response_a)
when(mock_response_a).json().thenRaise(JSONDecodeError('', '', 0))
self.assertRaises(JSONDecodeError,
lambda: self.extract.fetch_record_block(self.fake_endpoint, self.mock_session))
mockito.verify(self.mock_session, times=self.extract.FETCH_TRIES_FOR_JSON).get(self.fake_endpoint)
def test_store_payments_registry_fake_json_decode_error(
self, shelve, json):
text = "test"
shelve.open.return_value.__enter__.return_value = dict()
json.loads.side_effect = JSONDecodeError("test", "test", 1)
store_payments_registry_fake(text)
self.assertEqual(shelve.open.call_count, 0)
self.assertEqual(shelve.open.return_value.__enter__.return_value,
dict())
def json_to_list(json_str: str) -> list:
"""
Transforms the json string into tree made up of dictionaries and list.
:param json_str: The json string to transform
:return: the list
"""
if not re.match(r'\s*\[', json_str):
raise JSONDecodeError(
"Unexpected character. For the root object to be a list the json string must start with",
json_str, 0)
return json.loads(json_str)
def bad_response_invalid_json():
"""Return a mock response with a 404 status code but with bad json."""
mock_response = mock.Mock(status_code=404, text='<No JSON!>')
mock_response.request = mock_request()
mock_response.json = Mock()
mock_response.json.side_effect = JSONDecodeError(
msg='no json',
doc='<no json>',
pos=0
)
return mock_response
def objectFromJSONText(text: str) -> Any:
"""
Convert JSON text into an object.
"""
try:
return loads(text)
except JSONDecodeError as e:
raise JSONDecodeError(
msg="{} in {!r}".format(e.msg, text),
doc=e.doc,
pos=e.pos,
)
def test_fetch_record_block_1_bad_json(self):
# ensure that the retries works and that if the JSON is bad the first time that it can succeed after
self.assertEqual(self.extract.FETCH_TRIES_FOR_JSON, 2) # testing that it is reset between tests
mock_response_a = mocki({'text': 'bad JSON once', 'status_code': 200}, spec=Response)
when(self.mock_session).get(self.fake_endpoint).thenReturn(mock_response_a)
when(mock_response_a).json().thenRaise(JSONDecodeError('', '', 0)).thenReturn(self.mock_json_payload)
json_response = self.extract.fetch_record_block(self.fake_endpoint, self.mock_session)
mockito.verify(self.mock_session, times=2).get(self.fake_endpoint)
self.assertEqual(self.mock_json_payload, json_response)
def get_private_key(designation, alternate_key_dir=None):
keyfiles = get_key_files(alternate_key_dir=alternate_key_dir)
for keyfile in keyfiles:
try:
with open(keyfile, 'r') as keyfile_object:
key_json = json.loads(keyfile_object.read())
return key_json[designation]
except OSError as exc:
raise OSError('Key directory may be empty', exc)
except JSONDecodeError:
raise JSONDecodeError('A problem occured with the key file')
def test_submit_data_error(self):
aiohttp.ClientResponse.json = AsyncMock(
side_effect=JSONDecodeError('ERROR', '', 0))
async def test():
self.result = await self.handler.submit_data(self.data)
with self.assertLogs(level='ERROR') as log:
self.loop.run_until_complete(test())
self.assertIn(
'Error submitting data: ERROR: line 1 column 1 (char 0) {}'.
format(self.data), log.output[0])
def objectFromJSONText(text: str) -> Any:
"""
Convert JSON text into an object.
"""
try:
return loads(text)
except JSONDecodeError as e:
raise JSONDecodeError(
msg=f"{e.msg} in {text!r}",
doc=e.doc,
pos=e.pos,
)
def __init__(self, dsp_config="", protein_seqs=None):
self.protein_seqs = protein_seqs
self.dsp_config = dsp_config
self.parameters = {}
config_filepath = ""
#read protein seqs from dataset if not input as parameter,
# parse DSP parameters from config file
if not isinstance(dsp_config, str) or dsp_config is None:
raise TypeError(
'JSON config file must be a filepath of type string, got type {}.'
.format(type(dsp_config)))
if os.path.isfile(self.dsp_config):
config_filepath = self.dsp_config
elif os.path.isfile(os.path.join('config', self.dsp_config)):
config_filepath = os.path.join('config', self.dsp_config)
else:
raise OSError('JSON config file not found at path: {}.'.format(
config_filepath))
try:
with open(config_filepath) as f:
self.parameters = json.load(f)
except:
raise JSONDecodeError(
'Error parsing config JSON file: {}.'.format(config_filepath))
#read protein seqs from dataset if not input as parameter
if (self.protein_seqs is None):
raise ValueError(
'Protein sequences input parameter cannot be empty or None.')
#reshape protein sequences to 2 dimensions
if (self.protein_seqs.ndim != 2):
try:
self.protein_seqs = self.protein_seqs.reshape((-1, 1))
except:
raise ValueError('Error reshaping input sequences.')
#set all DSP parameters
self.dsp_parameters = self.parameters["pyDSP"]
self.use_dsp = self.dsp_parameters[0]["use_dsp"]
self.spectrum = self.dsp_parameters[0]["spectrum"]
self.window_type = self.dsp_parameters[0]["window"]
self.window = self.dsp_parameters[0]["window"]
self.filter = self.dsp_parameters[0]["filter"]
self.convolution = self.dsp_parameters[0]["convolution"]
#pre-processing of encoded protein sequences
self.pre_processing()
#transform sequences into the various informational protein spectra
self.encode_seqs()
def test_fetch_record_block_2_bad_status(self):
# ensure that the retries works and that if the STATUS CODE is bad that it only tries TWICE
self.assertEqual(self.extract.FETCH_TRIES_FOR_STATUS_CODE, 2) # testing that it is reset between tests
mock_response_a = mocki({'text': 'bad status code twice', 'status_code': 300}, spec=Response)
when(mock_response_a).raise_for_status().thenRaise(HTTPError('http error msg', response=mock_response_a))
when(self.mock_session).get(self.fake_endpoint).thenReturn(mock_response_a)
when(mock_response_a).json().thenRaise(JSONDecodeError("shouldn't call this", 'place holder', 0))
# the HTTPError is captured by the tries and reported as a the parent RequestException indicating non-json error
self.assertRaises(RequestException,
lambda: self.extract.fetch_record_block(self.fake_endpoint, self.mock_session))
mockito.verify(self.mock_session, times=self.extract.FETCH_TRIES_FOR_STATUS_CODE).get(self.fake_endpoint)
def test_api_post_request_handles_json_errors(product, monkeypatch):
mocked_response = Mock(side_effect=JSONDecodeError("", "", 0))
monkeypatch.setattr("saleor.plugins.avatax.requests.post", mocked_response)
config = AvataxConfiguration(
username_or_account="test", password_or_license="test", use_sandbox=False,
)
url = "https://www.avatax.api.com/some-get-path"
response = api_post_request(url, {}, config)
assert mocked_response.called
assert response == {}
def test_from_value_dict_and_errors(self, mock_loads, mock_dumps):
mock_dumps.return_value = 'value'
mock_loads.side_effect = TypeError
Geometry.from_value({'dict': 'value'})
mock_dumps.assert_called_with({'dict': 'value'},
cls=GobTypeJSONEncoder)
mock_loads.side_effect = JSONDecodeError('msg', 'doc', 0)
Geometry.from_value({'dict': 'value'})
mock_dumps.assert_called_with({'dict': 'value'},
cls=GobTypeJSONEncoder)
