Adding validation errors and test

Author: Pijush Chakraborty

firebase_admin/remote_config.py

@@ -17,7 +17,8 @@
 """
 
 import json
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
+import requests
 from firebase_admin import App, _http_client, _utils
 import firebase_admin
 
@@ -31,12 +32,41 @@ def __init__(self, etag, template_data):
         Args:
             etag: The string to be used for initialize the ETag property.
             template_data: The data to be parsed for getting the parameters and conditions.
+
+        Raises:
+            ValueError: If the template data is not valid.
         """
-        self._parameters = template_data['parameters']
-        self._conditions = template_data['conditions']
-        self._version = template_data['version']
-        self._parameter_groups = template_data['parameterGroups']
-        self._etag = etag
+        if 'parameters' in template_data:
+            if template_data['parameters'] is not None:
+                self._parameters = template_data['parameters']
+            else:
+                raise ValueError('Remote Config parameters must be a non-null object')
+        else:
+            self._parameters = {}
+
+        if 'conditions' in template_data:
+            if template_data['conditions'] is not None:
+                self._conditions = template_data['conditions']
+            else:
+                raise ValueError('Remote Config conditions must be a non-null object')
+        else:
+            self._conditions = []
+
+        self._version = ''
+        if 'version' in template_data:
+            self._version = template_data['version']
+
+        if 'parameterGroups' in template_data:
+            if template_data['parameterGroups'] is not None:
+                self._parameter_groups = template_data['parameterGroups']
+            else:
+                raise ValueError('Remote Config parameterGroups must be a non-null object')
+        else:
+            self.parameter_groups = {}
+
+        self._etag = ''
+        if etag is not None and isinstance(etag, str):
+            self._etag = etag
 
     @property
     def parameters(self):
@@ -90,14 +120,13 @@ def evaluate(self, context):
         self._evaluator = _ConditionEvaluator(self._cache.conditions, context)
         return ServerConfig(config_values=self._evaluator.evaluate())
 
-    def set(self, template):
+    def set(self, template: ServerTemplateData):
         """Updates the cache to store the given template is of type ServerTemplateData.
 
         Args:
           template: An object of type ServerTemplateData to be cached.
         """
-        if isinstance(template, ServerTemplateData):
-            self._cache = template
+        self._cache = template
 
 
 class ServerConfig:
@@ -140,21 +169,27 @@ def __init__(self, app):
                                                    base_url=remote_config_base_url,
                                                    headers=rc_headers, timeout=timeout)
 
-
     def get_server_template(self):
         """Requests for a server template and converts the response to an instance of
         ServerTemplateData for storing the template parameters and conditions."""
         url_prefix = self._get_url_prefix()
-        headers, response_json = self._client.headers_and_body('get',
-                                                               url=url_prefix+'/namespaces/ \
-                                                               firebase-server/serverRemoteConfig')
-        return ServerTemplateData(headers.get('ETag'), response_json)
+        try:
+            headers, response_json = self._client.headers_and_body(
+                'get', url=url_prefix+'/namespaces/firebase-server/serverRemoteConfig')
+        except requests.exceptions.RequestException as error:
+            raise self._handle_remote_config_error(error)
+        else:
+            return ServerTemplateData(headers.get('etag'), response_json)
 
     def _get_url_prefix(self):
-        # Returns project prefix for url, in the format of
-        # /v1/projects/${projectId}
+        """Returns project prefix for url, in the format of /v1/projects/${projectId}"""
         return "/v1/projects/{0}".format(self._project_id)
 
+    @classmethod
+    def _handle_remote_config_error(cls, error: Any):
+        """Handles errors received from the Cloud Functions API."""
+        return _utils.handle_platform_error_from_requests(error)
+
 
 class _ConditionEvaluator:
     """Internal class that facilitates sending requests to the Firebase Remote

tests/test_remote_config.py

@@ -31,30 +31,49 @@ def __init__(self, data, status, recorder, etag=ETAG):
 
     def send(self, request, **kwargs):
         resp = super(MockAdapter, self).send(request, **kwargs)
-        resp.headers = {'ETag': self._etag}
+        resp.headers = {'etag': self._etag}
         return resp
 
 
 class TestGetServerTemplate:
     _DEFAULT_APP = firebase_admin.initialize_app(testutils.MockCredential(), name='no_project_id')
     _RC_INSTANCE = _utils.get_app_service(_DEFAULT_APP,
                                           _REMOTE_CONFIG_ATTRIBUTE, _RemoteConfigService)
-    _DEFAULT_RESPONSE = json.dumps({
-        'parameters': {
-            'test_key': 'test_value'
-        },
-        'conditions': {},
-        'parameterGroups': {},
-        'version': 'test'
-        })
 
     def test_rc_instance_get_server_template(self):
         recorder = []
+        response = json.dumps({
+            'parameters': {
+                'test_key': 'test_value'
+            },
+            'conditions': [],
+            'parameterGroups': {},
+            'version': 'test'
+            })
         self._RC_INSTANCE._client.session.mount(
             'https://firebaseremoteconfig.googleapis.com',
-            MockAdapter(self._DEFAULT_RESPONSE, 200, recorder))
+            MockAdapter(response, 200, recorder))
 
         template = self._RC_INSTANCE.get_server_template()
 
         assert template.parameters == dict(test_key="test_value")
         assert str(template.version) == 'test'
+        assert str(template.etag) == '0'
+
+    def test_rc_instance_get_server_template_empty_params(self):
+        recorder = []
+        response = json.dumps({
+            'conditions': [],
+            'parameterGroups': {},
+            'version': 'test'
+            })
+
+        self._RC_INSTANCE._client.session.mount(
+            'https://firebaseremoteconfig.googleapis.com',
+            MockAdapter(response, 200, recorder))
+
+        template = self._RC_INSTANCE.get_server_template()
+
+        assert template.parameters == {}
+        assert str(template.version) == 'test'
+        assert str(template.etag) == '0'