Add non-200 non-error response code tests

Author: ZachOrr

firebase_admin/messaging.py

@@ -453,10 +453,17 @@ def _message_data(self, message, dry_run):
         return data
 
     def _postproc(self, resp, body):
-        if resp.status == 200:
-            return json.loads(body.decode())
-        else:
-            raise Exception('unexpected response')
+        if resp.status is not 200:
+            data = {}
+            try:
+                parsed_body = json.loads(body.decode())
+                if isinstance(parsed_body, dict):
+                    data = parsed_body
+            except ValueError:
+                pass
+            code, msg = _MessagingService._parse_fcm_error(data, body, resp.status)
+            raise ApiCallError(code, msg)
+        return json.loads(body.decode())
 
     def _handle_fcm_error(self, error):
         """Handles errors received from the FCM API."""
@@ -468,8 +475,9 @@ def _handle_fcm_error(self, error):
         except ValueError:
             pass
 
-        raise _MessagingService._parse_fcm_error(
-            data, error.response.content, error.response.status_code, error)
+        code, msg = _MessagingService._parse_fcm_error(
+            data, error.response.content, error.response.status_code)
+        raise ApiCallError(code, msg, error)
 
     def _handle_iid_error(self, error):
         """Handles errors received from the Instance ID API."""
@@ -502,10 +510,12 @@ def _parse_batch_error(self, error):
                 data = parsed_body
         except ValueError:
             pass
-        return _MessagingService._parse_fcm_error(data, error.content, error.resp.status, error)
+
+        code, msg = _MessagingService._parse_fcm_error(data, error.content, error.resp.status)
+        return ApiCallError(code, msg, error)
 
     @classmethod
-    def _parse_fcm_error(cls, data, content, status_code, error):
+    def _parse_fcm_error(cls, data, content, status_code):
         """Parses an error response from the FCM API to a ApiCallError."""
         error_dict = data.get('error', {})
         server_code = None
@@ -521,5 +531,4 @@ def _parse_fcm_error(cls, data, content, status_code, error):
         if not msg:
             msg = 'Unexpected HTTP response with status: {0}; body: {1}'.format(
                 status_code, content.decode())
-
-        return ApiCallError(code, msg, error)
+        return code, msg

tests/test_messaging.py

@@ -1418,6 +1418,72 @@ def test_send_all(self):
         assert all([r.success for r in batch_response.responses])
         assert not any([r.exception for r in batch_response.responses])
 
+    def test_send_all_non_error_non_200(self):
+        success_payload = json.dumps({'name': 'message-id'})
+        error_payload = json.dumps({})
+        _ = self._instrument_batch_messaging_service(
+            payload=self._batch_payload([(200, success_payload), (202, error_payload)]))
+        msg = messaging.Message(topic='foo')
+        with pytest.raises(messaging.ApiCallError) as excinfo:
+            messaging.send_all([msg, msg], dry_run=True)
+        assert str(excinfo.value) == 'Unexpected HTTP response with status: 202; body: {}\r\n'
+        assert str(excinfo.value.code) == messaging._MessagingService.UNKNOWN_ERROR
+
+    def test_send_all_non_error_non_200_detailed_error(self):
+        success_payload = json.dumps({'name': 'message-id'})
+        error_payload = json.dumps({
+            'error': {
+                'status': 'INVALID_ARGUMENT',
+                'message': 'test error'
+            }
+        })
+        _ = self._instrument_batch_messaging_service(
+            payload=self._batch_payload([(200, success_payload), (202, error_payload)]))
+        msg = messaging.Message(topic='foo')
+        with pytest.raises(messaging.ApiCallError) as excinfo:
+            batch_response = messaging.send_all([msg, msg], dry_run=True)
+        assert str(excinfo.value) == 'test error'
+        assert str(excinfo.value.code) == 'invalid-argument'
+
+    def test_send_all_non_error_non_200_canonical_error_code(self):
+        success_payload = json.dumps({'name': 'message-id'})
+        error_payload = json.dumps({
+            'error': {
+                'status': 'NOT_FOUND',
+                'message': 'test error'
+            }
+        })
+        _ = self._instrument_batch_messaging_service(
+            payload=self._batch_payload([(200, success_payload), (202, error_payload)]))
+        msg = messaging.Message(topic='foo')
+        with pytest.raises(messaging.ApiCallError) as excinfo:
+            messaging.send_all([msg, msg], dry_run=True)
+        expected = 'send_all messages must not contain more than 100 messages.'
+        assert str(excinfo.value) == 'test error'
+        assert str(excinfo.value.code) == 'registration-token-not-registered'
+
+    def test_send_all_non_error_non_200_fcm_error_code(self):
+        success_payload = json.dumps({'name': 'message-id'})
+        error_payload = json.dumps({
+            'error': {
+                'status': 'INVALID_ARGUMENT',
+                'message': 'test error',
+                'details': [
+                    {
+                        '@type': 'type.googleapis.com/google.firebase.fcm.v1.FcmError',
+                        'errorCode': 'UNREGISTERED',
+                    },
+                ],
+            }
+        })
+        _ = self._instrument_batch_messaging_service(
+            payload=self._batch_payload([(200, success_payload), (202, error_payload)]))
+        msg = messaging.Message(topic='foo')
+        with pytest.raises(messaging.ApiCallError) as excinfo:
+            messaging.send_all([msg, msg], dry_run=True)
+        assert str(excinfo.value) == 'test error'
+        assert str(excinfo.value.code) == 'registration-token-not-registered'
+
     @pytest.mark.parametrize('status', HTTP_ERRORS)
     def test_send_all_detailed_error(self, status):
         success_payload = json.dumps({'name': 'message-id'})
@@ -1599,6 +1665,72 @@ def test_send_multicast(self):
         assert all([r.success for r in batch_response.responses])
         assert not any([r.exception for r in batch_response.responses])
 
+    def test_send_multicast_non_error_non_200(self):
+        success_payload = json.dumps({'name': 'message-id'})
+        error_payload = json.dumps({})
+        _ = self._instrument_batch_messaging_service(
+            payload=self._batch_payload([(200, success_payload), (202, error_payload)]))
+        msg = messaging.MulticastMessage(tokens=['foo', 'foo'])
+        with pytest.raises(messaging.ApiCallError) as excinfo:
+            messaging.send_multicast(msg, dry_run=True)
+        expected = 'Unexpected HTTP response with status: 202; body: {}\r\n'
+        assert str(excinfo.value) == expected
+        assert str(excinfo.value.code) == messaging._MessagingService.UNKNOWN_ERROR
+
+    def test_send_multicast_non_error_non_200_detailed_error(self):
+        success_payload = json.dumps({'name': 'message-id'})
+        error_payload = json.dumps({
+            'error': {
+                'status': 'INVALID_ARGUMENT',
+                'message': 'test error'
+            }
+        })
+        _ = self._instrument_batch_messaging_service(
+            payload=self._batch_payload([(200, success_payload), (202, error_payload)]))
+        msg = messaging.MulticastMessage(tokens=['foo', 'foo'])
+        with pytest.raises(messaging.ApiCallError) as excinfo:
+            batch_response = messaging.send_multicast(msg, dry_run=True)
+        assert str(excinfo.value) == 'test error'
+        assert str(excinfo.value.code) == 'invalid-argument'
+
+    def test_send_multicast_non_error_non_200_canonical_error_code(self):
+        success_payload = json.dumps({'name': 'message-id'})
+        error_payload = json.dumps({
+            'error': {
+                'status': 'NOT_FOUND',
+                'message': 'test error'
+            }
+        })
+        _ = self._instrument_batch_messaging_service(
+            payload=self._batch_payload([(200, success_payload), (202, error_payload)]))
+        msg = messaging.MulticastMessage(tokens=['foo', 'foo'])
+        with pytest.raises(messaging.ApiCallError) as excinfo:
+            messaging.send_multicast(msg, dry_run=True)
+        assert str(excinfo.value) == 'test error'
+        assert str(excinfo.value.code) == 'registration-token-not-registered'
+
+    def test_send_multicast_non_error_non_200_fcm_error_code(self):
+        success_payload = json.dumps({'name': 'message-id'})
+        error_payload = json.dumps({
+            'error': {
+                'status': 'INVALID_ARGUMENT',
+                'message': 'test error',
+                'details': [
+                    {
+                        '@type': 'type.googleapis.com/google.firebase.fcm.v1.FcmError',
+                        'errorCode': 'UNREGISTERED',
+                    },
+                ],
+            }
+        })
+        _ = self._instrument_batch_messaging_service(
+            payload=self._batch_payload([(200, success_payload), (202, error_payload)]))
+        msg = messaging.MulticastMessage(tokens=['foo', 'foo'])
+        with pytest.raises(messaging.ApiCallError) as excinfo:
+            messaging.send_multicast(msg, dry_run=True)
+        assert str(excinfo.value) == 'test error'
+        assert str(excinfo.value.code) == 'registration-token-not-registered'
+
     @pytest.mark.parametrize('status', HTTP_ERRORS)
     def test_send_multicast_detailed_error(self, status):
         success_payload = json.dumps({'name': 'message-id'})