resolve merge conflict

Author: Varun Rathore

firebase_admin/remote_config.py

@@ -16,12 +16,13 @@
 This module has required APIs for the clients to use Firebase Remote Config with python.
 """
 
-import json
+import asyncio
 import logging
-from typing import Dict, Optional, Literal, Union
+from typing import Dict, Optional, Literal, Union, Any
 from enum import Enum
 import re
 import hashlib
+import requests
 from firebase_admin import App, _http_client, _utils
 import firebase_admin
 
@@ -32,6 +33,7 @@
 _REMOTE_CONFIG_ATTRIBUTE = '_remoteconfig'
 MAX_CONDITION_RECURSION_DEPTH = 10
 ValueSource = Literal['default', 'remote', 'static']  # Define the ValueSource type
+
 class PercentConditionOperator(Enum):
     """Enum representing the available operators for percent conditions.
     """
@@ -62,19 +64,40 @@ class CustomSignalOperator(Enum):
     UNKNOWN = "UNKNOWN"
 
 class ServerTemplateData:
-    """Represents a Server Template Data class."""
+    """Parses, validates and encapsulates template data and metadata."""
     def __init__(self, etag, template_data):
         """Initializes a new ServerTemplateData instance.
 
         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']
+
+        self._etag = ''
+        if etag is not None and isinstance(etag, str):
+            self._etag = etag
 
     @property
     def parameters(self):
@@ -92,13 +115,9 @@ def version(self):
     def conditions(self):
         return self._conditions
 
-    @property
-    def parameter_groups(self):
-        return self._parameter_groups
-
 
 class ServerTemplate:
-    """Represents a Server Template with implementations for loading and evaluting the tempalte."""
+    """Represents a Server Template with implementations for loading and evaluting the template."""
     def __init__(self, app: App = None, default_config: Optional[Dict[str, str]] = None):
         """Initializes a ServerTemplate instance.
 
@@ -112,14 +131,18 @@ def __init__(self, app: App = None, default_config: Optional[Dict[str, str]] = N
         # This gets set when the template is
         # fetched from RC servers via the load API, or via the set API.
         self._cache = None
+        self._stringified_default_config: Dict[str, str] = {}
+
+        # RC stores all remote values as string, but it's more intuitive
+        # to declare default values with specific types, so this converts
+        # the external declaration to an internal string representation.
         if default_config is not None:
-            self._stringified_default_config = json.dumps(default_config)
-        else:
-            self._stringified_default_config = None
+            for key in default_config:
+                self._stringified_default_config[key] = str(default_config[key])
 
     async def load(self):
         """Fetches the server template and caches the data."""
-        self._cache = await self._rc_service.getServerTemplate()
+        self._cache = await self._rc_service.get_server_template()
 
     def evaluate(self, context: Optional[Dict[str, Union[str, int]]] = None) -> 'ServerConfig':
         """Evaluates the cached server template to produce a ServerConfig.
@@ -140,21 +163,20 @@ def evaluate(self, context: Optional[Dict[str, Union[str, int]]] = None) -> 'Ser
         config_values = {}
         # Initializes config Value objects with default values.
         if self._stringified_default_config is not None:
-            for key, value in json.loads(self._stringified_default_config).items():
+            for key, value in self._stringified_default_config.items():
                 config_values[key] = _Value('default', value)
         self._evaluator = _ConditionEvaluator(self._cache.conditions,
                                               self._cache.parameters, context,
                                               config_values)
         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:
@@ -202,20 +224,28 @@ def __init__(self, app):
                                                    base_url=remote_config_base_url,
                                                    headers=rc_headers, timeout=timeout)
 
-
-    def get_server_template(self):
+    async 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:
+            loop = asyncio.get_event_loop()
+            headers, template_data = await loop.run_in_executor(None,
+                                                                self._client.headers_and_body,
+                                                                'get', self._get_url())
+        except requests.exceptions.RequestException as error:
+            raise self._handle_remote_config_error(error)
+        else:
+            return ServerTemplateData(headers.get('etag'), template_data)
 
-    def _get_url_prefix(self):
-        # Returns project prefix for url, in the format of
-        # /v1/projects/${projectId}
-        return "/v1/projects/{0}".format(self._project_id)
+    def _get_url(self):
+        """Returns project prefix for url, in the format of /v1/projects/${projectId}"""
+        return "/v1/projects/{0}/namespaces/firebase-server/serverRemoteConfig".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:
@@ -587,7 +617,6 @@ def _compare_versions(self, version1, version2, predicate_fn) -> bool:
             logger.warning("Invalid semantic version format for comparison.")
             return False
 
-
 async def get_server_template(app: App = None, default_config: Optional[Dict[str, str]] = None):
     """Initializes a new ServerTemplate instance and fetches the server template.
 

tests/test_remote_config.py

@@ -13,12 +13,16 @@
 # limitations under the License.
 
 """Tests for firebase_admin.remote_config."""
+import json
 import uuid
+import pytest
 import firebase_admin
 from firebase_admin.remote_config import (
     PercentConditionOperator,
+    _REMOTE_CONFIG_ATTRIBUTE,
+    _RemoteConfigService,
     ServerTemplateData)
-from firebase_admin import remote_config
+from firebase_admin import remote_config, _utils
 from tests import testutils
 
 VERSION_INFO = {
@@ -258,7 +262,7 @@ def test_evaluate_return_conditional_values_honor_order(self):
 
     def test_evaluate_default_when_no_param(self):
         app = firebase_admin.get_app()
-        default_config = {'promo_enabled': False, 'promo_discount': 20,}
+        default_config = {'promo_enabled': False, 'promo_discount': '20',}
         template_data = SERVER_REMOTE_CONFIG_RESPONSE
         template_data['parameters'] = {}
         server_template = remote_config.init_server_template(
@@ -322,15 +326,15 @@ def test_evaluate_return_numeric_value(self):
         app = firebase_admin.get_app()
         template_data = SERVER_REMOTE_CONFIG_RESPONSE
         default_config = {
-            'dog_age': 12
+            'dog_age': '12'
         }
         server_template = remote_config.init_server_template(
             app=app,
             default_config=default_config,
             template_data=ServerTemplateData('etag', template_data)
         )
         server_config = server_template.evaluate()
-        assert server_config.get_int('dog_age') == 12
+        assert server_config.get_int('dog_age') == default_config.get('dog_age')
 
     def test_evaluate_return_boolean_value(self):
         app = firebase_admin.get_app()
@@ -745,3 +749,134 @@ def evaluate_random_assignments(self, condition, num_of_assignments, mock_app, d
                 eval_true_count += 1
 
         return eval_true_count
+
+
+class MockAdapter(testutils.MockAdapter):
+    """A Mock HTTP Adapter that Firebase Remote Config with ETag in header."""
+
+    ETAG = 'etag'
+
+    def __init__(self, data, status, recorder, etag=ETAG):
+        testutils.MockAdapter.__init__(self, data, status, recorder)
+        self._etag = etag
+
+    def send(self, request, **kwargs):
+        resp = super(MockAdapter, self).send(request, **kwargs)
+        resp.headers = {'etag': self._etag}
+        return resp
+
+
+class TestRemoteConfigService:
+    """Tests methods on _RemoteConfigService"""
+    @classmethod
+    def setup_class(cls):
+        cred = testutils.MockCredential()
+        firebase_admin.initialize_app(cred, {'projectId': 'project-id'})
+
+    @classmethod
+    def teardown_class(cls):
+        testutils.cleanup_apps()
+
+    @pytest.mark.asyncio
+    async def test_rc_instance_get_server_template(self):
+        recorder = []
+        response = json.dumps({
+            'parameters': {
+                'test_key': 'test_value'
+            },
+            'conditions': [],
+            'version': 'test'
+            })
+
+        rc_instance = _utils.get_app_service(firebase_admin.get_app(),
+                                             _REMOTE_CONFIG_ATTRIBUTE, _RemoteConfigService)
+        rc_instance._client.session.mount(
+            'https://firebaseremoteconfig.googleapis.com',
+            MockAdapter(response, 200, recorder))
+
+        template = await rc_instance.get_server_template()
+
+        assert template.parameters == dict(test_key="test_value")
+        assert str(template.version) == 'test'
+        assert str(template.etag) == 'etag'
+
+    @pytest.mark.asyncio
+    async def test_rc_instance_get_server_template_empty_params(self):
+        recorder = []
+        response = json.dumps({
+            'conditions': [],
+            'version': 'test'
+            })
+
+        rc_instance = _utils.get_app_service(firebase_admin.get_app(),
+                                             _REMOTE_CONFIG_ATTRIBUTE, _RemoteConfigService)
+        rc_instance._client.session.mount(
+            'https://firebaseremoteconfig.googleapis.com',
+            MockAdapter(response, 200, recorder))
+
+        template = await rc_instance.get_server_template()
+
+        assert template.parameters == {}
+        assert str(template.version) == 'test'
+        assert str(template.etag) == 'etag'
+
+
+class TestRemoteConfigModule:
+    """Tests methods on firebase_admin.remote_config"""
+    @classmethod
+    def setup_class(cls):
+        cred = testutils.MockCredential()
+        firebase_admin.initialize_app(cred, {'projectId': 'project-id'})
+
+    @classmethod
+    def teardown_class(cls):
+        testutils.cleanup_apps()
+
+    def test_init_server_template(self):
+        app = firebase_admin.get_app()
+        template_data = {
+            'conditions': [],
+            'parameters': {
+                'test_key': {
+                    'defaultValue': {'value': 'test_value'},
+                    'conditionalValues': {}
+                }
+            },
+            'version': '',
+        }
+
+        template = remote_config.init_server_template(
+            app=app,
+            default_config={'default_test': 'default_value'},
+            template_data=ServerTemplateData('etag', template_data)
+        )
+
+        config = template.evaluate()
+        assert config.get_string('test_key') == 'test_value'
+
+    @pytest.mark.asyncio
+    async def test_get_server_template(self):
+        app = firebase_admin.get_app()
+        rc_instance = _utils.get_app_service(app,
+                                             _REMOTE_CONFIG_ATTRIBUTE, _RemoteConfigService)
+
+        recorder = []
+        response = json.dumps({
+            'parameters': {
+                'test_key': {
+                    'defaultValue': {'value': 'test_value'},
+                    'conditionalValues': {}
+                }
+            },
+            'conditions': [],
+            'version': 'test'
+            })
+
+        rc_instance._client.session.mount(
+            'https://firebaseremoteconfig.googleapis.com',
+            MockAdapter(response, 200, recorder))
+
+        template = await remote_config.get_server_template(app=app)
+
+        config = template.evaluate()
+        assert config.get_string('test_key') == 'test_value'