Cache calls to external API services for one week (mozilla#4020)

Author: flodolo

pontoon/machinery/openai_service.py

@@ -2,19 +2,36 @@
 
 from openai import OpenAI
 
+from django.conf import settings
+from django.core.cache import cache
+
 from pontoon.base.models import Locale
-from pontoon.settings.base import OPENAI_API_KEY
+from pontoon.machinery.utils import (
+    get_machinery_service_cache_key,
+    set_machinery_service_cache_key,
+)
 
 
 class OpenAIService:
     def __init__(self):
-        if not OPENAI_API_KEY:
+        if not settings.OPENAI_API_KEY:
             raise ValueError("Missing OpenAI API key")
         self.client = OpenAI()
 
     def get_translation(
         self, english_text, translated_text, characteristic, target_language_name
     ):
+        cache_key = get_machinery_service_cache_key(
+            "openai_chatgpt",
+            english_text,
+            translated_text,
+            characteristic,
+            target_language_name,
+        )
+        cached = cache.get(cache_key)
+        if cached is not None:
+            return cached
+
         try:
             target_language = Locale.objects.get(name=target_language_name)
         except Locale.DoesNotExist:
@@ -94,4 +111,6 @@ def get_translation(
             top_p=1,  # Set top_p to 1 to consider the full distribution
         )
 
-        return response.choices[0].message.content.strip()
+        result = response.choices[0].message.content.strip()
+        set_machinery_service_cache_key(cache_key, result)
+        return result

pontoon/machinery/tests/conftest.py

@@ -15,3 +15,11 @@ def google_translate_api_key(settings):
     key = "2fffff"
     settings.GOOGLE_TRANSLATE_API_KEY = key
     return key
+
+
+@pytest.fixture
+def openai_api_key(settings):
+    """Set the settings.OPENAI_API_KEY for this test"""
+    key = "3fffff"
+    settings.OPENAI_API_KEY = key
+    return key

pontoon/machinery/tests/test_views.py

@@ -1,9 +1,13 @@
 import json
 import urllib.parse
 
+from unittest.mock import MagicMock, patch
+
 import pytest
+import requests
 import requests_mock
 
+from django.core.cache import cache
 from django.urls import reverse
 
 from pontoon.base.models import (
@@ -62,6 +66,62 @@ def test_view_microsoft_translator_bad_locale(member, ms_locale, ms_api_key):
     assert response.status_code == 401
 
 
+@pytest.mark.django_db
+def test_view_microsoft_translator_missing_api_key(member, ms_locale, settings):
+    settings.MICROSOFT_TRANSLATOR_API_KEY = ""
+    cache.clear()
+    url = reverse("pontoon.microsoft_translator")
+    response = member.client.get(
+        url, {"text": "text", "locale": ms_locale.ms_translator_code}
+    )
+    assert response.status_code == 400
+
+
+@pytest.mark.django_db
+def test_view_microsoft_translator_api_http_error(member, ms_locale, ms_api_key):
+    cache.clear()
+    url = reverse("pontoon.microsoft_translator")
+    with requests_mock.mock() as m:
+        m.post(
+            "https://api.cognitive.microsofttranslator.com/translate",
+            status_code=401,
+        )
+        response = member.client.get(
+            url, {"text": "text", "locale": ms_locale.ms_translator_code}
+        )
+    assert response.status_code == 401
+
+
+@pytest.mark.django_db
+def test_view_microsoft_translator_api_connection_error(member, ms_locale, ms_api_key):
+    cache.clear()
+    url = reverse("pontoon.microsoft_translator")
+    with requests_mock.mock() as m:
+        m.post(
+            "https://api.cognitive.microsofttranslator.com/translate",
+            exc=requests.exceptions.ConnectionError,
+        )
+        response = member.client.get(
+            url, {"text": "text", "locale": ms_locale.ms_translator_code}
+        )
+    assert response.status_code == 500
+
+
+@pytest.mark.django_db
+def test_view_microsoft_translator_api_error_in_response(member, ms_locale, ms_api_key):
+    cache.clear()
+    url = reverse("pontoon.microsoft_translator")
+    with requests_mock.mock() as m:
+        m.post(
+            "https://api.cognitive.microsofttranslator.com/translate",
+            json={"error": {"code": 400000, "message": "Bad request"}},
+        )
+        response = member.client.get(
+            url, {"text": "text", "locale": ms_locale.ms_translator_code}
+        )
+    assert response.status_code == 400
+
+
 @pytest.mark.django_db
 def test_view_google_translate_not_logged_in(
     client, google_translate_locale, google_translate_api_key
@@ -90,7 +150,6 @@ def test_view_google_translate(
 
     assert response.status_code == 200
     assert json.loads(response.content) == {
-        "status": True,
         "translation": "target",
     }
 
@@ -117,6 +176,146 @@ def test_view_google_translate_bad_locale(
     assert response.status_code == 400
 
 
+@pytest.mark.django_db
+def test_view_google_translate_missing_api_key(
+    member, google_translate_locale, settings
+):
+    settings.GOOGLE_TRANSLATE_API_KEY = ""
+    cache.clear()
+    url = reverse("pontoon.google_translate")
+    response = member.client.get(
+        url, {"text": "text", "locale": google_translate_locale.code}
+    )
+    assert response.status_code == 400
+
+
+@pytest.mark.django_db
+def test_view_google_translate_api_http_error(
+    member, google_translate_locale, google_translate_api_key
+):
+    cache.clear()
+    url = reverse("pontoon.google_translate")
+    with requests_mock.mock() as m:
+        m.post(
+            "https://translation.googleapis.com/language/translate/v2",
+            status_code=403,
+        )
+        response = member.client.get(
+            url, {"text": "text", "locale": google_translate_locale.code}
+        )
+    assert response.status_code == 403
+
+
+@pytest.mark.django_db
+def test_view_google_translate_api_connection_error(
+    member, google_translate_locale, google_translate_api_key
+):
+    cache.clear()
+    url = reverse("pontoon.google_translate")
+    with requests_mock.mock() as m:
+        m.post(
+            "https://translation.googleapis.com/language/translate/v2",
+            exc=requests.exceptions.ConnectionError,
+        )
+        response = member.client.get(
+            url, {"text": "text", "locale": google_translate_locale.code}
+        )
+    assert response.status_code == 500
+
+
+@pytest.mark.django_db
+def test_view_google_translate_api_unexpected_response(
+    member, google_translate_locale, google_translate_api_key
+):
+    cache.clear()
+    url = reverse("pontoon.google_translate")
+    with requests_mock.mock() as m:
+        m.post(
+            "https://translation.googleapis.com/language/translate/v2",
+            json={"unexpected": "response"},
+        )
+        response = member.client.get(
+            url, {"text": "text", "locale": google_translate_locale.code}
+        )
+    assert response.status_code == 400
+
+
+@pytest.mark.django_db
+def test_view_microsoft_translator_cache(member, ms_locale, ms_api_key):
+    url = reverse("pontoon.microsoft_translator")
+    cache.clear()
+
+    with requests_mock.mock() as m:
+        data = [{"translations": [{"text": "target"}]}]
+        m.post("https://api.cognitive.microsofttranslator.com/translate", json=data)
+
+        response1 = member.client.get(
+            url, {"text": "text", "locale": ms_locale.ms_translator_code}
+        )
+        assert len(m.request_history) == 1
+
+        # Second identical request should be served from cache
+        response2 = member.client.get(
+            url, {"text": "text", "locale": ms_locale.ms_translator_code}
+        )
+        assert len(m.request_history) == 1
+
+    assert json.loads(response1.content) == json.loads(response2.content)
+
+
+@pytest.mark.django_db
+def test_view_google_translate_cache(
+    member, google_translate_locale, google_translate_api_key
+):
+    url = reverse("pontoon.google_translate")
+    cache.clear()
+
+    with requests_mock.mock() as m:
+        data = {"data": {"translations": [{"translatedText": "target"}]}}
+        m.post("https://translation.googleapis.com/language/translate/v2", json=data)
+
+        response1 = member.client.get(
+            url, {"text": "text", "locale": google_translate_locale.code}
+        )
+        assert len(m.request_history) == 1
+
+        # Second identical request should be served from cache
+        response2 = member.client.get(
+            url, {"text": "text", "locale": google_translate_locale.code}
+        )
+        assert len(m.request_history) == 1
+
+    assert json.loads(response1.content) == json.loads(response2.content)
+
+
+@pytest.mark.django_db
+def test_view_gpt_transform_cache(member, locale_a, openai_api_key):
+    url = reverse("pontoon.gpt_transform")
+    cache.clear()
+
+    mock_response = MagicMock()
+    mock_response.choices[0].message.content = "  formal translation  "
+
+    with patch("pontoon.machinery.openai_service.OpenAI") as MockOpenAI:
+        MockOpenAI.return_value.chat.completions.create.return_value = mock_response
+
+        params = {
+            "english_text": "Hello",
+            "translated_text": "Hola",
+            "characteristic": "formal",
+            "locale": locale_a.name,
+        }
+
+        response1 = member.client.get(url, params)
+        assert MockOpenAI.return_value.chat.completions.create.call_count == 1
+
+        # Second identical request should be served from cache
+        response2 = member.client.get(url, params)
+        assert MockOpenAI.return_value.chat.completions.create.call_count == 1
+
+    assert json.loads(response1.content) == json.loads(response2.content)
+
+
 @pytest.mark.django_db
 def test_view_caighdean(client, entity_a):
     gd = Locale.objects.get(code="gd")