[lightapi/python]: change BasicConnector to allow 404 to be optionally treated as errors

 problem: BasicConnector always treats 404 as success, requiring caller to perform extra validation with 404 is undesirable
solution: treat 404 as error by default and add flag to optionally treat it as success

Author: Jaguar0625

lightapi/python/symbollightapi/connector/BasicConnector.py

@@ -15,7 +15,7 @@ def __init__(self, endpoint):
 		self.endpoint = endpoint
 		self.timeout_seconds = None
 
-	async def _dispatch(self, action, url_path, property_name, **kwargs):
+	async def _dispatch(self, action, url_path, property_name, not_found_as_error, **kwargs):
 		try:
 			timeout = ClientTimeout(total=self.timeout_seconds)
 			async with ClientSession(timeout=timeout) as session:
@@ -25,7 +25,7 @@ async def _dispatch(self, action, url_path, property_name, **kwargs):
 					except (client_exceptions.ContentTypeError, json.decoder.JSONDecodeError) as ex:
 						raise NodeException from ex
 
-					if 400 <= response.status and 404 != response.status:
+					if 400 <= response.status and (404 != response.status or not_found_as_error):
 						error_message = f'HTTP request failed with code {response.status}'
 						for key in ('code', 'message'):
 							if key in response_json:
@@ -37,30 +37,30 @@ async def _dispatch(self, action, url_path, property_name, **kwargs):
 		except (asyncio.TimeoutError, client_exceptions.ClientConnectorError) as ex:
 			raise NodeException from ex
 
-	async def get(self, url_path, property_name=None):
+	async def get(self, url_path, property_name=None, not_found_as_error=True):
 		"""
 		Initiates a GET to the specified path and returns the desired property.
 		Raises NodeException on connection or content failure.
 		"""
 
-		return await self._dispatch('get', url_path, property_name)
+		return await self._dispatch('get', url_path, property_name, not_found_as_error)
 
-	async def post(self, url_path, request_payload, property_name=None):
+	async def post(self, url_path, request_payload, property_name=None, not_found_as_error=True):
 		"""
 		Initiates a POST to the specified path and returns the desired property.
 		Raises NodeException on connection or content failure.
 		"""
 
-		return await self._dispatch('post', url_path, property_name, data=json.dumps(request_payload), headers={
+		return await self._dispatch('post', url_path, property_name, not_found_as_error, data=json.dumps(request_payload), headers={
 			'Content-Type': 'application/json'
 		})
 
-	async def put(self, url_path, request_payload, property_name=None):
+	async def put(self, url_path, request_payload, property_name=None, not_found_as_error=True):
 		"""
 		Initiates a PUT to the specified path and returns the desired property.
 		Raises NodeException on connection or content failure.
 		"""
 
-		return await self._dispatch('put', url_path, property_name, data=json.dumps(request_payload), headers={
+		return await self._dispatch('put', url_path, property_name, not_found_as_error, data=json.dumps(request_payload), headers={
 			'Content-Type': 'application/json'
 		})

lightapi/python/symbollightapi/connector/NemConnector.py

@@ -80,9 +80,6 @@ async def block_headers(self, height):
 
 		url_path = 'block/at/public'
 		block = await self.post(url_path, {'height': height})
-		if 'transactions' not in block:
-			raise RuntimeError(f'node returned invalid data: {block}')
-
 		del block['transactions']
 		return block
 

lightapi/python/symbollightapi/connector/SymbolConnector.py

@@ -144,7 +144,7 @@ async def peers(self):
 	async def account_links(self, account_id):
 		"""Gets account links for a specified account."""
 
-		json_response = await self.get(f'accounts/{account_id}')
+		json_response = await self.get(f'accounts/{account_id}', not_found_as_error=False)
 		if _is_not_found(json_response):
 			return LinkedPublicKeys()
 
@@ -177,7 +177,7 @@ def _parse_links(json_supplemental_public_keys):
 	async def account_multisig(self, address):
 		"""Gets multisig information about an account."""
 
-		json_response = await self.get(f'account/{address}/multisig')
+		json_response = await self.get(f'account/{address}/multisig', not_found_as_error=False)
 		if _is_not_found(json_response):
 			return MultisigInfo(0, 0, [], [])
 

lightapi/python/tests/connector/test_BasicConnector.py

@@ -32,11 +32,24 @@ async def echo_put(self, request):
 
 		async def status_code(self, request):
 			status_code = int(request.match_info['status_code'])
+			return await self._handle_status_code_request(request, status_code, 'get')
 
+		async def status_code_post(self, request):
+			request_json = await request.json()
+			status_code = request_json['status_code']
+			return await self._handle_status_code_request(request, status_code, 'post')
+
+		async def status_code_put(self, request):
+			request_json = await request.json()
+			status_code = request_json['status_code']
+			return await self._handle_status_code_request(request, status_code, 'put')
+
+		async def _handle_status_code_request(self, request, status_code, action):
 			response_json = {
 				'code': 'SomeCode',
 				'message': 'some message',
-				'status': status_code
+				'status': status_code,
+				'action': action
 			}
 
 			if self.omit_error_description:
@@ -69,6 +82,8 @@ async def _process(self, request, response_body, status_code=200):
 	app.router.add_post('/echo/post', mock_server.echo_post)
 	app.router.add_put('/echo/put', mock_server.echo_put)
 	app.router.add_get(r'/status/{status_code}', mock_server.status_code)
+	app.router.add_post(r'/status', mock_server.status_code_post)
+	app.router.add_put(r'/status', mock_server.status_code_put)
 	server = await aiohttp_client(app)  # pylint: disable=redefined-outer-name
 
 	server.mock = mock_server
@@ -250,7 +265,7 @@ async def test_can_handle_stopped_node_put():
 # endregion
 
 
-# region error handling - HTTP error code
+# region error handling - HTTP error code (general)
 
 async def _assert_can_propagate_status_code_result(server, status_code):  # pylint: disable=redefined-outer-name
 	# Arrange:
@@ -260,7 +275,7 @@ async def _assert_can_propagate_status_code_result(server, status_code):  # pyli
 	response_json = await connector.get(f'status/{status_code}')
 
 	# Assert:
-	assert {'code': 'SomeCode', 'message': 'some message', 'status': status_code} == response_json
+	assert {'code': 'SomeCode', 'message': 'some message', 'status': status_code, 'action': 'get'} == response_json
 
 
 async def _assert_can_propagate_status_code_failure_result(server, status_code):  # pylint: disable=redefined-outer-name
@@ -284,12 +299,12 @@ async def _assert_can_propagate_status_code_failure_result_with_message(server,
 
 
 async def test_can_propagate_http_success_results(server):  # pylint: disable=redefined-outer-name
-	for status_code in (200, 202, 300, 404):
+	for status_code in (200, 202, 300):
 		await _assert_can_propagate_status_code_result(server, status_code)
 
 
 async def test_can_propagate_http_failure_results(server):  # pylint: disable=redefined-outer-name
-	for status_code in (400, 401, 500, 501):
+	for status_code in (400, 401, 404, 500, 501):
 		await _assert_can_propagate_status_code_failure_result(server, status_code)
 
 
@@ -298,3 +313,74 @@ async def test_can_propagate_http_failure_results_with_message(server):  # pylin
 		await _assert_can_propagate_status_code_failure_result_with_message(server, status_code)
 
 # endregion
+
+
+# region error handling - HTTP error code (404)
+
+async def _assert_can_handle_http_failure_404_as_error_by_default(server, action, url_path, **kwargs):
+	# pylint: disable=redefined-outer-name
+	# Arrange:
+	connector = BasicConnector(server.make_url(''))
+
+	# Act + Assert:
+	with pytest.raises(NodeException, match='HTTP request failed with code 404\nSomeCode\nsome message'):
+		await getattr(connector, action)(url_path, **kwargs)
+
+
+async def _assert_can_handle_http_failure_404_as_explicit_error(server, action, url_path, **kwargs):  # pylint: disable=redefined-outer-name
+	# Arrange:
+	connector = BasicConnector(server.make_url(''))
+
+	# Act + Assert:
+	with pytest.raises(NodeException, match='HTTP request failed with code 404\nSomeCode\nsome message'):
+		await getattr(connector, action)(url_path, not_found_as_error=True, **kwargs)
+
+
+async def _assert_can_handle_http_failure_404_as_explicit_non_error(server, action, url_path, **kwargs):
+	# pylint: disable=redefined-outer-name
+	# Arrange:
+	connector = BasicConnector(server.make_url(''))
+
+	# Act:
+	response_json = await getattr(connector, action)(url_path, not_found_as_error=False, **kwargs)
+
+	# Assert:
+	assert {'code': 'SomeCode', 'message': 'some message', 'status': 404, 'action': action} == response_json
+
+
+async def test_can_handle_http_failure_404_as_error_by_default_get(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_error_by_default(server, 'get', 'status/404')
+
+
+async def test_can_handle_http_failure_404_as_error_by_default_post(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_error_by_default(server, 'post', 'status', request_payload={'status_code': 404})
+
+
+async def test_can_handle_http_failure_404_as_error_by_default_put(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_error_by_default(server, 'put', 'status', request_payload={'status_code': 404})
+
+
+async def test_can_handle_http_failure_404_as_explicit_error_get(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_explicit_error(server, 'get', 'status/404')
+
+
+async def test_can_handle_http_failure_404_as_explicit_error_post(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_explicit_error(server, 'post', 'status', request_payload={'status_code': 404})
+
+
+async def test_can_handle_http_failure_404_as_explicit_error_put(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_explicit_error(server, 'put', 'status', request_payload={'status_code': 404})
+
+
+async def test_can_handle_http_failure_404_as_explicit_non_error_get(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_explicit_non_error(server, 'get', 'status/404')
+
+
+async def test_can_handle_http_failure_404_as_explicit_non_error_post(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_explicit_non_error(server, 'post', 'status', request_payload={'status_code': 404})
+
+
+async def test_can_handle_http_failure_404_as_explicit_non_error_put(server):  # pylint: disable=redefined-outer-name
+	await _assert_can_handle_http_failure_404_as_explicit_non_error(server, 'put', 'status', request_payload={'status_code': 404})
+
+# endregion

lightapi/python/tests/connector/test_NemConnector.py

@@ -202,10 +202,6 @@ async def block_at(self, request):
 				'transactions': []
 			}
 
-			# make returned data invalid
-			if 0xDEAD == request_json['height']:
-				del block['transactions']
-
 			return await self._process(request, block)
 
 		async def node_info(self, request):
@@ -349,15 +345,6 @@ async def test_can_get_block_headers(server):  # pylint: disable=redefined-outer
 	assert {'type': 1, 'signer': PUBLIC_KEYS[0], 'timeStamp': 201000} == headers
 	assert [f'{server.make_url("")}/block/at/public'] == server.mock.urls
 
-
-async def test_cannot_get_block_headers_when_server_returns_invalid_data(server):  # pylint: disable=redefined-outer-name
-	# Arrange:
-	connector = NemConnector(server.make_url(''))
-
-	# Act + Assert:
-	with pytest.raises(RuntimeError):
-		await connector.block_headers(0xDEAD)
-
 # endregion