django-esi 8.0.0a4__py3-none-any.whl → 8.0.0b2__py3-none-any.whl

esi/tests/test_openapi.py

@@ -1,22 +1,27 @@
+import json
 import os
-from unittest import mock
 from unittest.mock import MagicMock, patch
 from django.test import TestCase
 from datetime import date, timedelta
 
 from esi.openapi_clients import ESIClientProvider
+from django.core.cache import cache
 from django.utils import timezone
+from esi.tests import NoSocketsTestCase
 from httpx import RequestError, HTTPStatusError
-from esi.exceptions import ESIErrorLimitException
+from esi.exceptions import ESIErrorLimitException, HTTPClientError, HTTPNotModified, ESIBucketLimitException, HTTPServerError
+from esi.rate_limiting import ESIRateLimits
 from esi import app_settings
 from esi import __title__, __url__, __version__
 import httpx
 
+from . import _generate_token
 from .. import openapi_clients as oc
 
 SPEC_PATH = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), "test_openapi.json"
 )
+MODULE_PATH_PLUGINS = 'esi.aiopenapi3.plugins'
 
 
 class TestClientFunctions(TestCase):
@@ -69,28 +74,80 @@ class TestClientFunctions(TestCase):
 
 
 class BuildUserAgentTests(TestCase):
-    app_name = "TestsApp"
+    app_name = "TestApp"
     app_ver = "1.2.3"
     app_url = "https://tests.pass"
 
     def test_build_user_agent_with_url(self):
         ua = oc._build_user_agent(self.app_name, self.app_ver, self.app_url)
+
+        expected_app_name = "TestApp"
+        expected_title = "DjangoEsi"
+
+        self.assertEqual(
+            (
+                f"{expected_app_name}/{self.app_ver} "
+                f"({app_settings.ESI_USER_CONTACT_EMAIL}{f'; +{self.app_url})'} "
+                f"{expected_title}/{__version__} (+{__url__})"
+            ),
+            ua
+        )
+
+    def test_enforce_pascal_case_for_ua_appname_with_space(self):
+        """
+        Test that the application name is converted to PascalCase in the User-Agent string when it contains spaces.
+
+        :return:
+        :rtype:
+        """
+
+        ua = oc._build_user_agent("test app", self.app_ver, self.app_url)
+
+        expected_app_name = "TestApp"
+        expected_title = "DjangoEsi"
+
+        self.assertEqual(
+            (
+                f"{expected_app_name}/{self.app_ver} "
+                f"({app_settings.ESI_USER_CONTACT_EMAIL}{f'; +{self.app_url})'} "
+                f"{expected_title}/{__version__} (+{__url__})"
+            ),
+            ua
+        )
+
+    def test_enforce_pascal_case_for_ua_appname_with_hyphen(self):
+        """
+        Test that the application name is converted to PascalCase in the User-Agent string when it contains hyphens.
+
+        :return:
+        :rtype:
+        """
+
+        ua = oc._build_user_agent("test-app", self.app_ver, self.app_url)
+
+        expected_app_name = "TestApp"
+        expected_title = "DjangoEsi"
+
         self.assertEqual(
             (
-                f"{self.app_name}/{self.app_ver} "
+                f"{expected_app_name}/{self.app_ver} "
                 f"({app_settings.ESI_USER_CONTACT_EMAIL}{f'; +{self.app_url})'} "
-                f"{__title__}/{__version__} (+{__url__})"
+                f"{expected_title}/{__version__} (+{__url__})"
             ),
             ua
         )
 
     def test_build_user_agent_without_url(self):
         ua = oc._build_user_agent(self.app_name, self.app_ver)
+
+        expected_app_name = "TestApp"
+        expected_title = "DjangoEsi"
+
         self.assertEqual(
             (
-                f"{self.app_name}/{self.app_ver} "
+                f"{expected_app_name}/{self.app_ver} "
                 f"({app_settings.ESI_USER_CONTACT_EMAIL}) "
-                f"{__title__}/{__version__} (+{__url__})"
+                f"{expected_title}/{__version__} (+{__url__})"
             ),
             ua
         )
@@ -123,6 +180,7 @@ class BaseEsiOperationTests(TestCase):
         ]
         self.fake_op.tags = ["test"]
         self.fake_op.operationId = "fake_op"
+        self.fake_op.extensions = {}
         self.api = MagicMock(app_name="TestApp")
         self.op = oc.BaseEsiOperation(
             ("GET", "/fake_op", self.fake_op, {}),
@@ -193,6 +251,19 @@ class EsiOperationTests(TestCase):
         self.op_mock.parameters = []
         self.op_mock.tags = ["tag"]
         self.op_mock.operationId = "opid"
+        self.op_mock.extensions = {}
+
+        self.op_mock_rate = MagicMock()
+        self.op_mock_rate.parameters = []
+        self.op_mock_rate.tags = ["tag"]
+        self.op_mock_rate.operationId = "opidRated"
+        self.op_mock_rate.extensions = {
+            "rate-limit": {
+                "group": "test-group",
+                "max-tokens": 100,
+                "window-size": "5m"
+            }
+        }
 
         self.api_mock = MagicMock()
         self.api_mock.app_name = "TestApp"
@@ -207,6 +278,16 @@ class EsiOperationTests(TestCase):
             self.api_mock
         )
 
+        self.op_rate_rated = oc.EsiOperation(
+            (
+                "GET",
+                "/url",
+                self.op_mock_rate,
+                {}
+            ),
+            self.api_mock
+        )
+
     @patch.object(oc.EsiOperation, "_make_request")
     def test_result_and_results(self, mock_make_request):
         data = {"data": "stuff"}
@@ -215,8 +296,37 @@ class EsiOperationTests(TestCase):
         data_resp = self.op(foo="bar").result()
         self.assertEqual(data, data_resp)
 
+    def test_esi_bucket_public(self):
+        op = self.op_rate_rated(foo="bar")
+        self.assertEqual(op.bucket.window, 300)
+        self.assertEqual(op.bucket.slug, "test-group")
+        self.assertEqual(op.bucket.limit, 100)
+
+    def test_esi_bucket_limit(self):
+        op = self.op_rate_rated(foo="bar")
+        ESIRateLimits.set_bucket(op.bucket, 0)
+
+        with self.assertRaises(ESIBucketLimitException):
+            op.result()
+
+class TestOpenapiClientProvider(NoSocketsTestCase):
+    def setUp(self):
+        self.app_name = "TestsApp"
+        self.app_ver = "1.2.3"
+        self.app_url = "https://tests.pass"
+        self.esi = ESIClientProvider(
+            ua_appname=self.app_name,
+            ua_url=self.app_url,
+            ua_version=self.app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Status"],
+            spec_file=SPEC_PATH
+        )
+        cache.clear()
 
-class TestOpenapiClientProvider(TestCase):
+    def test_str(self):
+        self.assertIn(self.esi._ua_appname, str(self.esi))
+        self.assertIn(self.esi._ua_version, str(self.esi))
 
     def test_compatibilitydate_date_to_string(self):
         testdate_1 = date(2024, 1, 1)
@@ -227,9 +337,38 @@ class TestOpenapiClientProvider(TestCase):
 
     @patch.object(httpx.Client, "send")
     def test_ua(self, send: MagicMock):
+        send.return_value = httpx.Response(
+            200,
+            json={
+                "players": 1234,
+                "server_version": "1234",
+                "start_time": "2029-09-19T11:02:08Z"
+            },
+            request=httpx.Request("GET", "test"),
+        )
+
+        status = self.esi.client.Status.GetStatus().result()
+        call_args, call_kwargs = send.call_args
+
+        expected_app_name = "TestsApp"
+        expected_title = 'DjangoEsi'
+
+        self.assertEqual(
+            call_args[0].headers["user-agent"],
+            (
+                f"{expected_app_name}/{self.app_ver} "
+                f"({app_settings.ESI_USER_CONTACT_EMAIL}{f'; +{self.app_url})'} "
+                f"{expected_title}/{__version__} (+{__url__})"
+            )
+        )
+        self.assertEqual(status.players, 1234)
+
+    @patch(MODULE_PATH_PLUGINS + '.settings.DEBUG', True)
+    def test_no_tag_no_op_debug(self):
         app_name = "TestsApp"
         app_ver = "1.2.3"
         app_url = "https://tests.pass"
+
         esi = ESIClientProvider(
             ua_appname=app_name,
             ua_url=app_url,
@@ -237,6 +376,87 @@ class TestOpenapiClientProvider(TestCase):
             compatibility_date="2020-01-01",
             spec_file=SPEC_PATH
         )
+        self.assertIsNotNone(esi.client.Status)
+        self.assertIsNotNone(esi.client.Status.GetStatus)
+
+    @patch(MODULE_PATH_PLUGINS + '.settings.DEBUG', True)
+    def test_tag_no_op_debug(self):
+        app_name = "TestsApp"
+        app_ver = "1.2.3"
+        app_url = "https://tests.pass"
+
+        esi = ESIClientProvider(
+            ua_appname=app_name,
+            ua_url=app_url,
+            ua_version=app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Status"],
+            spec_file=SPEC_PATH
+        )
+        self.assertIsNotNone(esi.client.Status)
+        self.assertIsNotNone(esi.client.Status.GetStatus)
+
+    @patch(MODULE_PATH_PLUGINS + '.settings.DEBUG', True)
+    def test_no_tag_op_debug(self):
+        app_name = "TestsApp"
+        app_ver = "1.2.3"
+        app_url = "https://tests.pass"
+
+        esi = ESIClientProvider(
+            ua_appname=app_name,
+            ua_url=app_url,
+            ua_version=app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Status"],
+            spec_file=SPEC_PATH
+        )
+        self.assertIsNotNone(esi.client.Status)
+        self.assertIsNotNone(esi.client.Status.GetStatus)
+
+
+    @patch(MODULE_PATH_PLUGINS + '.settings.DEBUG', False)
+    def test_no_tag_no_op_no_debug(self):
+        app_name = "TestsApp"
+        app_ver = "1.2.3"
+        app_url = "https://tests.pass"
+
+        with self.assertRaises(AttributeError):
+            esi = ESIClientProvider(
+                ua_appname=app_name,
+                ua_url=app_url,
+                ua_version=app_ver,
+                compatibility_date="2020-01-01",
+                spec_file=SPEC_PATH
+            )
+            esi.client
+
+    @patch.object(httpx.Client, "send")
+    def test_no_bucket(self, send: MagicMock):
+        self.esi = ESIClientProvider(
+            ua_appname=self.app_name,
+            ua_url=self.app_url,
+            ua_version=self.app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Universe"],
+            spec_file=SPEC_PATH
+        )
+
+        send.return_value = httpx.Response(
+            200,
+            json=[1,2,3,4],
+            request=httpx.Request("GET", "test"),
+        )
+
+        types = self.esi.client.Universe.GetUniverseTypes().result()
+        self.assertEqual(len(types), 4)
+
+    @patch.object(httpx.Client, "send")
+    def test_etag_hit_cached(self, send: MagicMock):
+        etag = "'123456789abcdef123456789abcdef'"
+
+        expires = (
+            timezone.now() + timedelta(minutes=5)
+        ).strftime('%a, %d %b %Y %H:%M:%S %Z')
 
         send.return_value = httpx.Response(
             200,
@@ -245,17 +465,291 @@ class TestOpenapiClientProvider(TestCase):
                 "server_version": "1234",
                 "start_time": "2029-09-19T11:02:08Z"
             },
-            request=httpx.Request("GET", "test"),
+            headers={
+                "etag": etag,
+                "expires": expires
+            },
+            request=httpx.Request(
+                "GET",
+                "test",
+            ),
         )
 
-        status = esi.client.Status.GetStatus().result()
-        call_args, call_kwargs = send.call_args
+        self.esi.client.Status.GetStatus().result()
+
+        with self.assertRaises(HTTPNotModified):
+            self.esi.client.Status.GetStatus().result()
+
+    @patch.object(httpx.Client, "send")
+    def test_etag_not_hit_cached(self, send: MagicMock):
+        etag = "'123456789abcdef123456789abcdef'"
+
+        expires = (
+            timezone.now() + timedelta(minutes=5)
+        ).strftime('%a, %d %b %Y %H:%M:%S %Z')
+
+        send.return_value = httpx.Response(
+            200,
+            json={
+                "players": 1234,
+                "server_version": "1234",
+                "start_time": "2029-09-19T11:02:08Z"
+            },
+            headers={
+                "etag": etag,
+                "expires": expires
+            },
+            request=httpx.Request(
+                "GET",
+                "test",
+            ),
+        )
+
+        self.esi.client.Status.GetStatus().result()
+
+        result = self.esi.client.Status.GetStatus().result(use_etag=False)
+        self.assertEqual(result.players, 1234)
+
+    @patch.object(httpx.Client, "send")
+    def test_force_refresh(self, send: MagicMock):
+        etag = "'123456789abcdef123456789abcdef'"
+
+        expires = (
+            timezone.now() + timedelta(minutes=5)
+        ).strftime('%a, %d %b %Y %H:%M:%S %Z')
+
+        send.return_value = httpx.Response(
+            200,
+            json={
+                "players": 1234,
+                "server_version": "1234",
+                "start_time": "2029-09-19T11:02:08Z"
+            },
+            headers={
+                "etag": etag,
+                "expires": expires
+            },
+            request=httpx.Request(
+                "GET",
+                "test",
+            ),
+        )
+
+        self.esi.client.Status.GetStatus().result()
+
+        result = self.esi.client.Status.GetStatus().result(force_refresh=True)
+        self.assertEqual(result.players, 1234)
+        self.assertEqual(send.call_count, 2)
+
+    @patch.object(httpx.Client, "send")
+    def test_404(self, send: MagicMock):
+        self.esi = ESIClientProvider(
+            ua_appname=self.app_name,
+            ua_url=self.app_url,
+            ua_version=self.app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Universe"],
+            spec_file=SPEC_PATH
+        )
+
+        send.return_value = httpx.Response(
+            404,
+            json={
+                "error": "error"
+            },
+            headers={
+                "X-RateLimit-Reset": "15",
+                "X-RateLimit-Remaining": "0"
+            },
+            request=httpx.Request(
+                "GET",
+                "/universe/types"
+            ),
+        )
+
+        with self.assertRaises(HTTPClientError):
+            self.esi.client.Universe.GetUniverseTypes().result()
+
+
+    @patch.object(httpx.Client, "send")
+    def test_420(self, send: MagicMock):
+        self.esi = ESIClientProvider(
+            ua_appname=self.app_name,
+            ua_url=self.app_url,
+            ua_version=self.app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Universe"],
+            spec_file=SPEC_PATH
+        )
+
+        send.return_value = httpx.Response(
+            420,
+            json={
+                "error": "error"
+            },
+            headers={
+                "X-RateLimit-Reset": "15",
+                "X-RateLimit-Remaining": "0"
+            },
+            request=httpx.Request(
+                "GET",
+                "/universe/types"
+            ),
+        )
+
+        with self.assertRaises(ESIErrorLimitException):
+            self.esi.client.Universe.GetUniverseTypes().result()
+
+        self.assertGreater(cache.get("esi_error_limit_reset"), 10)
+
+    @patch.object(httpx.Client, "send")
+    def test_420_past(self, send: MagicMock):
+        self.esi = ESIClientProvider(
+            ua_appname=self.app_name,
+            ua_url=self.app_url,
+            ua_version=self.app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Universe"],
+            spec_file=SPEC_PATH
+        )
+
+        send.return_value = httpx.Response(
+            420,
+            json={
+                "error": "error"
+            },
+            headers={
+                "X-RateLimit-Remaining": "0"
+            },
+            request=httpx.Request(
+                "GET",
+                "/universe/types"
+            ),
+        )
+
+        with self.assertRaises(ESIErrorLimitException):
+            self.esi.client.Universe.GetUniverseTypes().result()
+
+        self.assertIsNone(cache.get("esi_error_limit_reset"))
+
+    @patch.object(httpx.Client, "send")
+    def test_rate_bucket(self, send: MagicMock):
+        send.return_value = httpx.Response(
+            200,
+            json={
+                "players": 1234,
+                "server_version": "1234",
+                "start_time": "2029-09-19T11:02:08Z"
+            },
+            headers={
+                "x-ratelimit-group": "status",
+                "x-ratelimit-used": "2",
+                "x-ratelimit-remaining": "598",
+                "x-ratelimit-limit": "600/15m",
+            },
+            request=httpx.Request(
+                "GET",
+                "/status"
+            ),
+        )
+        self.esi.client.Status.GetStatus().result()
         self.assertEqual(
-            call_args[0].headers["user-agent"],
-            (
-                f"{app_name}/{app_ver} "
-                f"({app_settings.ESI_USER_CONTACT_EMAIL}{f'; +{app_url})'} "
-                f"{__title__}/{__version__} (+{__url__})"
-            )
+            ESIRateLimits.get_bucket(self.esi.client.Status.GetStatus().bucket),
+            598
         )
-        self.assertEqual(status.players, 1234)
+
+    @patch.object(httpx.Client, "send")
+    def test_server_error(self, send: MagicMock):
+        send.return_value = httpx.Response(
+            520,
+            json={
+                "error": "error"
+            },
+            headers={
+                "x-ratelimit-group": "status",
+                "x-ratelimit-used": "5",
+                "x-ratelimit-remaining": "595",
+                "x-ratelimit-limit": "600/15m",
+            },
+            request=httpx.Request(
+                "GET",
+                "/status"
+            ),
+        )
+        with self.assertRaises(HTTPServerError):
+            self.esi.client.Status.GetStatus().result()
+
+    def test_minified_op_not_found(self):
+        with self.assertRaises(AttributeError):
+            self.esi.client.Universe.GetUniverseTypes()
+
+    def test_minified_op_not_found(self):
+        self.esi = ESIClientProvider(
+            ua_appname=self.app_name,
+            ua_url=self.app_url,
+            ua_version=self.app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Universe"],
+            spec_file=SPEC_PATH
+        )
+
+        with self.assertRaises(AttributeError):
+            self.esi.client.Universe.GetUniverseAncestries()
+
+    def test_rate_bucket_found_in_spec(self):
+
+        op = self.esi.client.Status.GetStatus()
+
+        self.assertIsNotNone(op.bucket)
+        self.assertEqual(op.bucket.limit, 600)
+        self.assertEqual(op.bucket.slug, "status")
+        self.assertEqual(op.bucket.window, 900)
+
+    def test_rate_bucket_hit(self):
+        op = self.esi.client.Status.GetStatus()
+
+        ESIRateLimits.set_bucket(op.bucket, 0)
+
+        with self.assertRaises(ESIBucketLimitException):
+            op.result()
+
+    def test_global_limit_hit(self):
+        op = self.esi.client.Status.GetStatus()
+
+        cache.set("esi_error_limit_reset", 15, 15)
+
+        with self.assertRaises(ESIErrorLimitException):
+            op.result()
+
+    @patch.object(httpx.Client, "send")
+    def test_load_sync(self, send: MagicMock):
+        esi = ESIClientProvider(
+            ua_appname=self.app_name,
+            ua_url=self.app_url,
+            ua_version=self.app_ver,
+            compatibility_date="2020-01-01",
+            tags=["Status"]
+        )
+        cache.clear()
+        expires = (
+            timezone.now() + timedelta(minutes=5)
+        ).strftime('%a, %d %b %Y %H:%M:%S %Z')
+
+        spec = None
+        with open(SPEC_PATH) as f:
+            spec = json.load(f)
+
+        send.return_value = httpx.Response(
+            200,
+            json=spec,
+            headers={
+                "expires": expires
+            },
+            request=httpx.Request(
+                "GET",
+                "test",
+            ),
+        )
+
+        esi.client
+        self.assertIsNotNone(esi.client.Status)