Auto init (#105)

Read the default options from the FIREBASE_CONFIG env var if options are not passed to initialize_app.

Author: avishalom

firebase_admin/__init__.py

@@ -14,6 +14,7 @@
 
 """Firebase Admin SDK for Python."""
 import datetime
+import json
 import os
 import threading
 
@@ -31,7 +32,9 @@
 _clock = datetime.datetime.utcnow
 
 _DEFAULT_APP_NAME = '[DEFAULT]'
-
+_FIREBASE_CONFIG_ENV_VAR = 'FIREBASE_CONFIG'
+_CONFIG_VALID_KEYS = ['databaseAuthVariableOverride', 'databaseURL', 'httpTimeout', 'projectId',
+                      'storageBucket']
 
 def initialize_app(credential=None, options=None, name=_DEFAULT_APP_NAME):
     """Initializes and returns a new App instance.
@@ -46,10 +49,14 @@ def initialize_app(credential=None, options=None, name=_DEFAULT_APP_NAME):
       credential: A credential object used to initialize the SDK (optional). If none is provided,
           Google Application Default Credentials are used.
       options: A dictionary of configuration options (optional). Supported options include
-          ``databaseURL``, ``storageBucket`` and ``httpTimeout``. If ``httpTimeout`` is not set,
-          HTTP connections initiated by client modules such as ``db`` will not time out.
+          ``databaseURL``, ``storageBucket``, ``projectId``, ``databaseAuthVariableOverride``
+          and ``httpTimeout``. If ``httpTimeout`` is not set, HTTP connections initiated by client
+          modules such as ``db`` will not time out.
+          If options are not provided an attempt is made to load the options from the environment.
+          This is done by looking up the ``FIREBASE_CONFIG`` environment variable. If the value of
+          the variable starts with ``"{"``, it is parsed as a JSON object. Otherwise it is treated
+          as a file name and the JSON content is read from the corresponding file.
       name: Name of the app (optional).
-
     Returns:
       App: A newly initialized instance of App.
 
@@ -145,7 +152,8 @@ class _AppOptions(object):
 
     def __init__(self, options):
         if options is None:
-            options = {}
+            options = self._load_from_environment()
+
         if not isinstance(options, dict):
             raise ValueError('Illegal Firebase app options type: {0}. Options '
                              'must be a dictionary.'.format(type(options)))
@@ -155,6 +163,30 @@ def get(self, key, default=None):
         """Returns the option identified by the provided key."""
         return self._options.get(key, default)
 
+    def _load_from_environment(self):
+        """Invoked when no options are passed to __init__, loads options from FIREBASE_CONFIG.
+
+        If the value of the FIREBASE_CONFIG environment variable starts with "{" an attempt is made
+        to parse it as a JSON object, otherwise it is assumed to be pointing to a JSON file.
+        """
+
+        config_file = os.getenv(_FIREBASE_CONFIG_ENV_VAR)
+        if not config_file:
+            return {}
+        if config_file.startswith('{'):
+            json_str = config_file
+        else:
+            try:
+                with open(config_file, 'r') as json_file:
+                    json_str = json_file.read()
+            except Exception as err:
+                raise ValueError('Unable to read file {}. {}'.format(config_file, err))
+        try:
+            json_data = json.loads(json_str)
+        except Exception as err:
+            raise ValueError('JSON string "{0}" is not valid json. {1}'.format(json_str, err))
+        return {k: v for k, v in json_data.items() if k in _CONFIG_VALID_KEYS}
+
 
 class App(object):
     """The entry point for Firebase Python SDK.

tests/data/firebase_config.json

@@ -0,0 +1,6 @@
+{
+  "databaseAuthVariableOverride": {"some_key": "some_val"},
+  "databaseURL": "https://hipster-chat.firebaseio.mock",
+  "projectId": "hipster-chat-mock",
+  "storageBucket": "hipster-chat.appspot.mock"
+}

tests/data/firebase_config_empty.json

@@ -0,0 +1 @@
+baaaaad

tests/data/firebase_config_invalid.json

@@ -0,0 +1,4 @@
+{
+  "databaseUrrrrL": "https://hipster-chat.firebaseio.mock",
+  "projectId": "hipster-chat-mock"
+}

tests/data/firebase_config_invalid_key.json

@@ -0,0 +1,4 @@
+{
+  "databaseURL": "https://hipster-chat.firebaseio.mock",
+  "projectId": "hipster-chat-mock"
+}

tests/data/firebase_config_partial.json

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 """Tests for firebase_admin.App."""
+from collections import namedtuple
 import os
 
 import pytest
@@ -22,10 +23,13 @@
 from firebase_admin import _utils
 from tests import testutils
 
-
 CREDENTIAL = credentials.Certificate(
     testutils.resource_filename('service_account.json'))
 GCLOUD_PROJECT = 'GCLOUD_PROJECT'
+CONFIG_JSON = firebase_admin._FIREBASE_CONFIG_ENV_VAR
+
+# This fixture will ignore the environment variable pointing to the default
+# configuration for the duration of the tests.
 
 class CredentialProvider(object):
     def init(self):
@@ -74,7 +78,6 @@ class AppService(object):
     def __init__(self, app):
         self._app = app
 
-
 @pytest.fixture(params=[Cert(), RefreshToken(), ExplicitAppDefault(), ImplicitAppDefault()],
                 ids=['cert', 'refreshtoken', 'explicit-appdefault', 'implicit-appdefault'])
 def app_credential(request):
@@ -90,6 +93,124 @@ def init_app(request):
     else:
         return firebase_admin.initialize_app(CREDENTIAL)
 
+@pytest.fixture(scope="function")
+def env_test_case(request):
+    config_old = set_config_env(request.param.config_json)
+    yield request.param
+    revert_config_env(config_old)
+
+
+EnvOptionsTestCase = namedtuple('EnvOptionsTestCase',
+                                'name, config_json, init_options, want_options')
+env_options_test_cases = [
+    EnvOptionsTestCase(name='Environment var not set, initialized with an empty options dict',
+                       config_json=None,
+                       init_options={},
+                       want_options={}),
+    EnvOptionsTestCase(name='Environment var empty, initialized with an empty options dict',
+                       config_json='',
+                       init_options={},
+                       want_options={}),
+    EnvOptionsTestCase(name='Environment var not set, initialized with no options dict',
+                       config_json=None,
+                       init_options=None,
+                       want_options={}),
+    EnvOptionsTestCase(name='Environment empty, initialized with no options dict',
+                       config_json='',
+                       init_options=None,
+                       want_options={}),
+    EnvOptionsTestCase(name='Environment var not set, initialized with options dict',
+                       config_json=None,
+                       init_options={'storageBucket': 'bucket1'},
+                       want_options={'storageBucket': 'bucket1'}),
+    EnvOptionsTestCase(name='Environment var set to file but ignored, initialized with options',
+                       config_json='firebase_config.json',
+                       init_options={'storageBucket': 'bucket1'},
+                       want_options={'storageBucket': 'bucket1'}),
+    EnvOptionsTestCase(name='Environment var set to json but ignored, initialized with options',
+                       config_json='{"storageBucket": "hipster-chat.appspot.mock"}',
+                       init_options={'storageBucket': 'bucket1'},
+                       want_options={'storageBucket': 'bucket1'}),
+    EnvOptionsTestCase(name='Environment var set to file, initialized with no options dict',
+                       config_json='firebase_config.json',
+                       init_options=None,
+                       want_options={'databaseAuthVariableOverride': {'some_key': 'some_val'},
+                                     'databaseURL': 'https://hipster-chat.firebaseio.mock',
+                                     'projectId': 'hipster-chat-mock',
+                                     'storageBucket': 'hipster-chat.appspot.mock'}),
+    EnvOptionsTestCase(name='Environment var set to json string, initialized with no options dict',
+                       config_json='{"databaseAuthVariableOverride": {"some_key": "some_val"}, ' +
+                       '"databaseURL": "https://hipster-chat.firebaseio.mock", ' +
+                       '"projectId": "hipster-chat-mock",' +
+                       '"storageBucket": "hipster-chat.appspot.mock"}',
+                       init_options=None,
+                       want_options={'databaseAuthVariableOverride': {'some_key': 'some_val'},
+                                     'databaseURL': 'https://hipster-chat.firebaseio.mock',
+                                     'projectId': 'hipster-chat-mock',
+                                     'storageBucket': 'hipster-chat.appspot.mock'}),
+    EnvOptionsTestCase(name='Invalid key in json file is ignored, the rest of the values are used',
+                       config_json='firebase_config_invalid_key.json',
+                       init_options=None,
+                       want_options={'projectId': 'hipster-chat-mock'}),
+    EnvOptionsTestCase(name='Invalid key in json file is ignored, the rest of the values are used',
+                       config_json='{"databaseUrrrrL": "https://hipster-chat.firebaseio.mock",' +
+                       '"projectId": "hipster-chat-mock"}',
+                       init_options=None,
+                       want_options={'projectId': 'hipster-chat-mock'}),
+    EnvOptionsTestCase(name='Environment var set to file but ignored, init empty options dict',
+                       config_json='firebase_config.json',
+                       init_options={},
+                       want_options={}),
+    EnvOptionsTestCase(name='Environment var set to string but ignored, init empty options dict',
+                       config_json='{"projectId": "hipster-chat-mock"}',
+                       init_options={},
+                       want_options={}),
+    EnvOptionsTestCase(name='Environment variable set to json file with some options set',
+                       config_json='firebase_config_partial.json',
+                       init_options=None,
+                       want_options={'databaseURL': 'https://hipster-chat.firebaseio.mock',
+                                     'projectId': 'hipster-chat-mock'}),
+    EnvOptionsTestCase(name='Environment variable set to json string with some options set',
+                       config_json='{"databaseURL": "https://hipster-chat.firebaseio.mock",' +
+                       '"projectId": "hipster-chat-mock"}',
+                       init_options=None,
+                       want_options={'databaseURL': 'https://hipster-chat.firebaseio.mock',
+                                     'projectId': 'hipster-chat-mock'}),
+    EnvOptionsTestCase(name='Environment var set to json file but ignored, init with options dict',
+                       config_json='firebase_config_partial.json',
+                       init_options={'projectId': 'pid1-mock',
+                                     'storageBucket': 'sb1-mock'},
+                       want_options={'projectId': 'pid1-mock',
+                                     'storageBucket': 'sb1-mock'}),
+    EnvOptionsTestCase(name='Environment var set to file but ignored, init with full options dict',
+                       config_json='firebase_config.json',
+                       init_options={'databaseAuthVariableOverride': 'davy1-mock',
+                                     'databaseURL': 'https://db1-mock',
+                                     'projectId': 'pid1-mock',
+                                     'storageBucket': 'sb1-.mock'},
+                       want_options={'databaseAuthVariableOverride': 'davy1-mock',
+                                     'databaseURL': 'https://db1-mock',
+                                     'projectId': 'pid1-mock',
+                                     'storageBucket': 'sb1-.mock'})]
+
+def set_config_env(config_json):
+    config_old = os.environ.get(CONFIG_JSON)
+    if config_json is not None:
+        if not config_json or config_json.startswith('{'):
+            os.environ[CONFIG_JSON] = config_json
+        else:
+            os.environ[CONFIG_JSON] = testutils.resource_filename(
+                config_json)
+    elif  os.environ.get(CONFIG_JSON) is not None:
+        del os.environ[CONFIG_JSON]
+    return config_old
+
+
+def revert_config_env(config_old):
+    if config_old is not None:
+        os.environ[CONFIG_JSON] = config_old
+    elif os.environ.get(CONFIG_JSON) is not None:
+        del os.environ[CONFIG_JSON]
 
 class TestFirebaseApp(object):
     """Test cases for App initialization and life cycle."""
@@ -140,6 +261,30 @@ def test_app_init_with_invalid_name(self, name):
         with pytest.raises(ValueError):
             firebase_admin.initialize_app(CREDENTIAL, name=name)
 
+
+    @pytest.mark.parametrize('bad_file_name', ['firebase_config_empty.json',
+                                               'firebase_config_invalid.json',
+                                               'no_such_file'])
+    def test_app_init_with_invalid_config_file(self, bad_file_name):
+        config_old = set_config_env(bad_file_name)
+        with pytest.raises(ValueError):
+            firebase_admin.initialize_app(CREDENTIAL)
+        revert_config_env(config_old)
+
+    def test_app_init_with_invalid_config_string(self):
+        config_old = set_config_env('{,,')
+        with pytest.raises(ValueError):
+            firebase_admin.initialize_app(CREDENTIAL)
+        revert_config_env(config_old)
+
+
+    @pytest.mark.parametrize('env_test_case', env_options_test_cases,
+                             ids=[x.name for x in env_options_test_cases],
+                             indirect=['env_test_case'])
+    def test_app_init_with_default_config(self, env_test_case):
+        app = firebase_admin.initialize_app(CREDENTIAL, options=env_test_case.init_options)
+        assert app.options._options == env_test_case.want_options
+
     def test_project_id_from_options(self, app_credential):
         app = firebase_admin.initialize_app(
             app_credential, options={'projectId': 'test-project'}, name='myApp')