Refactor language management in TxNative

Author: Konstantinos Bairaktaris

tests/native/core/test_cds.py

@@ -202,7 +202,7 @@ def test_fetch_translations(self, patched_logger):
             responses.GET, cds_host + '/content/fr', status=404
         )
 
-        resp = cds_handler.fetch_translations()
+        resp = cds_handler.fetch_translations('el')
         assert resp == {
             'el': (True, {
                 'key1': {
@@ -212,6 +212,9 @@ def test_fetch_translations(self, patched_logger):
                     'string': 'key2_el'
                 },
             }),
+        }
+        resp = cds_handler.fetch_translations('en')
+        assert resp == {
             'en': (True, {
                 'key1': {
                     'string': 'key1_en'
@@ -220,58 +223,16 @@ def test_fetch_translations(self, patched_logger):
                     'string': 'key2_en'
                 },
             }),
-            'fr': (False, {})  # that is due to the error status in response
         }
-
-        responses.reset()
-
-        # test fetch_languages fails with connection error
-        responses.add(responses.GET, cds_host + '/languages', status=500)
-        resp = cds_handler.fetch_translations()
-        assert resp == {}
-
-        patched_logger.error.assert_called_with(
-            'Error retrieving languages from CDS: UnknownError '
-            '(`500 Server Error: Internal Server Error for url: '
-            'https://some.host/languages`)'
-        )
-        responses.reset()
-        patched_logger.reset_mock()
-
-        # test language code
-        responses.add(
-            responses.GET, cds_host + '/content/el',
-            json={
-                'data': {
-                    'key1': {
-                        'string': 'key1_el'
-                    },
-                    'key2': {
-                        'string': 'key2_el'
-                    },
-                },
-                'meta': {
-                    "some_key": "some_value"
-                }
-            }, status=200
-        )
-
-        resp = cds_handler.fetch_translations(language_code='el')
+        resp = cds_handler.fetch_translations('fr')
         assert resp == {
-            'el': (True, {
-                'key1': {
-                    'string': 'key1_el'
-                },
-                'key2': {
-                    'string': 'key2_el'
-                },
-            })
+            'fr': (False, {})  # that is due to the error status in response
         }
+
         responses.reset()
-        assert patched_logger.error.call_count == 0
 
         # test connection_error
-        resp = cds_handler.fetch_translations(language_code='el')
+        resp = cds_handler.fetch_translations('el')
         patched_logger.error.assert_called_with(
             'Error retrieving translations from CDS: ConnectionError'
         )
@@ -331,7 +292,7 @@ def test_fetch_translations_etags_management(self, patched_logger):
             status=304
         )
 
-        resp = cds_handler.fetch_translations()
+        resp = cds_handler.fetch_translations('el')
         assert resp == {
             'el': (True, {
                 'key1': {
@@ -341,7 +302,6 @@ def test_fetch_translations_etags_management(self, patched_logger):
                     'string': 'key2_el'
                 },
             }),
-            'en': (False, {})
         }
         assert cds_handler.etags.get('el') == 'some_unique_tag_is_here'
 

tests/native/core/test_core.py

@@ -195,6 +195,7 @@ def test_push_strings_reaches_cds_handler(self, mock_push_strings):
     def test_fetch_translations_reaches_cds_handler_and_cache(self, mock_cds,
                                                               mock_cache):
         mytx = self._get_tx()
+        mytx.remote_languages = [{'code': "el"}]
         mytx.fetch_translations()
         assert mock_cds.call_count == 1
         assert mock_cache.call_count > 0

tests/native/core/test_init.py

@@ -12,5 +12,5 @@ def test_init_uses_given_params(self):
                   missing_policy=PseudoTranslationPolicy())
         assert _tx._cds_handler.token == 'mytoken'
         assert _tx._cds_handler.host == 'myhost'
-        assert _tx._languages == ['lang1', 'lang2']
+        assert _tx.hardcoded_language_codes == ['lang1', 'lang2']
         assert isinstance(_tx._missing_policy, PseudoTranslationPolicy)

transifex/native/cds.py

@@ -118,7 +118,7 @@ def fetch_languages(self):
 
         return languages
 
-    def fetch_translations(self, language_code=None):
+    def fetch_translations(self, language_code):
         """Fetch all translations for the given organization/project/(resource)
         associated with the current token. Returns a tuple of refresh flag and
         a dictionary of the fetched translations per language.
@@ -133,61 +133,53 @@ def fetch_translations(self, language_code=None):
 
         translations = {}
 
-        if not language_code:
-            languages = [lang['code'] for lang in self.fetch_languages()]
-        else:
-            languages = [language_code]
-
-        for language_code in set(languages) & \
-                set(self.configured_language_codes):
-
-            try:
-                last_response_status = 202
-                while last_response_status == 202:
-                    response = requests.get(
-                        (self.host +
-                         cds_url.format(language_code=language_code)),
-                        headers=self._get_headers(
-                            etag=self.etags.get(language_code)
-                        )
+        try:
+            last_response_status = 202
+            while last_response_status == 202:
+                response = requests.get(
+                    (self.host +
+                     cds_url.format(language_code=language_code)),
+                    headers=self._get_headers(
+                        etag=self.etags.get(language_code)
                     )
-                    last_response_status = response.status_code
+                )
+                last_response_status = response.status_code
 
-                if not response.ok:
-                    logger.error(
-                        'Error retrieving translations from CDS: `{}`'.format(
-                            response.reason
-                        )
-                    )
-                    response.raise_for_status()
-
-                # etags indicate that no translation have been updated
-                if response.status_code == 304:
-                    translations[language_code] = (False, {})
-                else:
-                    self.etags.set(
-                        language_code, response.headers.get('ETag', ''))
-                    json_content = response.json()
-                    translations[language_code] = (
-                        True, json_content['data']
+            if not response.ok:
+                logger.error(
+                    'Error retrieving translations from CDS: `{}`'.format(
+                        response.reason
                     )
+                )
+                response.raise_for_status()
 
-            except (KeyError, ValueError):
-                # Compatibility with python2.7 where `JSONDecodeError` doesn't
-                # exist
-                logger.error('Error retrieving translations from CDS: '
-                             'Malformed response')  # pragma no cover
-                translations[language_code] = (False, {})  # pragma no cover
-            except requests.ConnectionError:
-                logger.error(
-                    'Error retrieving translations from CDS: ConnectionError')
-                translations[language_code] = (False, {})
-            except Exception as e:
-                logger.error(
-                    'Error retrieving translations from CDS: UnknownError '
-                    '(`{}`)'.format(str(e))
-                )  # pragma no cover
+            # etags indicate that no translation have been updated
+            if response.status_code == 304:
                 translations[language_code] = (False, {})
+            else:
+                self.etags.set(
+                    language_code, response.headers.get('ETag', ''))
+                json_content = response.json()
+                translations[language_code] = (
+                    True, json_content['data']
+                )
+
+        except (KeyError, ValueError):
+            # Compatibility with python2.7 where `JSONDecodeError` doesn't
+            # exist
+            logger.error('Error retrieving translations from CDS: '
+                         'Malformed response')  # pragma no cover
+            translations[language_code] = (False, {})  # pragma no cover
+        except requests.ConnectionError:
+            logger.error(
+                'Error retrieving translations from CDS: ConnectionError')
+            translations[language_code] = (False, {})
+        except Exception as e:
+            logger.error(
+                'Error retrieving translations from CDS: UnknownError '
+                '(`{}`)'.format(str(e))
+            )  # pragma no cover
+            translations[language_code] = (False, {})
 
         return translations
 

transifex/native/core.py

@@ -15,15 +15,21 @@ class TxNative(object):
     behavior."""
 
     def __init__(self, **kwargs):
-        self._languages = []
+        self.source_language_code = None
+        self.current_language_code = None
+        self.hardcoded_language_codes = None
+        self.remote_languages = None
+
         self._missing_policy = SourceStringPolicy()
         self._cds_handler = CDSHandler()
         self._cache = MemoryCache()
         self._error_policy = SourceStringErrorPolicy()
 
         self.setup(**kwargs)
 
-    def setup(self, languages=None, token=None, secret=None, cds_host=None,
+    def setup(self,
+              source_language=None, current_language=None, languages=None,
+              token=None, secret=None, cds_host=None,
               missing_policy=None, error_policy=None):
         """Create an instance of the core framework class.
 
@@ -41,18 +47,41 @@ def setup(self, languages=None, token=None, secret=None, cds_host=None,
         :param AbstractErrorPolicy error_policy: an optional policy
             to determine how to handle rendering errors
         """
+        if source_language is not None:
+            self.source_language_code = source_language
+        if current_language is not None:
+            self.current_language_code = current_language
         if languages is not None:
-            self._languages = languages
+            self.hardcoded_language_codes = languages
         if missing_policy is not None:
             self._missing_policy = missing_policy
         if error_policy is not None:
             self._error_policy = error_policy
 
-        self._cds_handler.setup(configured_languages=languages,
-                                token=token,
+        self._cds_handler.setup(token=token,
                                 secret=secret,
                                 host=cds_host)
 
+    def fetch_languages(self, force=False):
+        if self.remote_languages is None or force:
+            self.remote_languages = self._cds_handler.fetch_languages()
+
+        if self.hardcoded_language_codes is not None:
+            return [language
+                    for language in self.remote_languages
+                    if language['code'] in self.hardcoded_language_codes]
+        else:
+            return self.remote_languages
+
+    def fetch_translations(self, language_code=None, force=False):
+        """Fetch fresh content from the CDS."""
+        if language_code is None:
+            for language in self.fetch_languages():
+                self.fetch_translations(language['code'], force=force)
+        else:
+            translations = self._cds_handler.fetch_translations(language_code)
+            self._cache.update(translations)
+
     def translate(
         self, source_string, language_code, is_source=False,
         _context=None, escape=True, params=None
@@ -133,10 +162,6 @@ def render_translation(self, translation_template, params, source_string,
                 escape=escape, params=params,
             )
 
-    def fetch_translations(self):
-        """Fetch fresh content from the CDS."""
-        self._cache.update(self._cds_handler.fetch_translations())
-
     def push_source_strings(self, strings, purge=False):
         """Push the given source strings to the CDS.