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

esi/tests/test_openapi.json

@@ -122,7 +122,12 @@
           }
         },
         "type": "object"
+      },
+      "UniverseTypesGet": {
+        "items": { "format": "int64", "type": "integer" },
+        "type": "array"
       }
+
     },
     "securitySchemes": {
       "OAuth2": {
@@ -217,6 +222,58 @@
   },
   "openapi": "3.1.0",
   "paths": {
+    "/universe/types": {
+      "get": {
+        "description": "Get a list of type ids\n\nThis route expires daily at 11:05",
+        "operationId": "GetUniverseTypes",
+        "parameters": [
+          {
+            "in": "query",
+            "name": "page",
+            "schema": {
+              "description": "Which page of results to return.",
+              "format": "int32",
+              "minimum": 1,
+              "type": "integer"
+            }
+          },
+          { "$ref": "#/components/parameters/AcceptLanguage" },
+          { "$ref": "#/components/parameters/IfNoneMatch" },
+          { "$ref": "#/components/parameters/CompatibilityDate" },
+          { "$ref": "#/components/parameters/Tenant" }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/UniverseTypesGet" }
+              }
+            },
+            "description": "OK",
+            "headers": {
+              "Cache-Control": { "$ref": "#/components/headers/CacheControl" },
+              "ETag": { "$ref": "#/components/headers/ETag" },
+              "Last-Modified": { "$ref": "#/components/headers/LastModified" },
+              "X-Pages": {
+                "description": "The total number of pages in the result set.",
+                "schema": { "format": "int64", "type": "integer" }
+              }
+            }
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/Error" }
+              }
+            },
+            "description": "Error"
+          }
+        },
+        "summary": "Get types",
+        "tags": ["Universe"],
+        "x-compatibility-date": "2020-01-01"
+      }
+    },
     "/status": {
       "get": {
         "description": "EVE Server status",
@@ -253,12 +310,18 @@
         "summary": "Retrieve the uptime and player counts",
         "tags": ["Status"],
         "x-cache-age": 30,
-        "x-compatibility-date": "2020-01-01"
+        "x-compatibility-date": "2020-01-01",
+        "x-rate-limit": {
+          "group": "status",
+          "max-tokens": 600,
+          "window-size": "15m"
+        }
       }
     }
   },
   "servers": [{ "url": "https://esi.evetech.net" }],
   "tags": [
-    { "name": "Status" }
+    { "name": "Status" },
+    { "name": "Universe" }
   ]
 }

esi/tests/test_openapi.py

@@ -1,5 +1,5 @@
+import json
 import os
-from unittest import mock
 from unittest.mock import MagicMock, patch
 from django.test import TestCase
 from datetime import date, timedelta
@@ -7,17 +7,21 @@ 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, HTTPNotModified
+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):
@@ -78,7 +82,7 @@ class BuildUserAgentTests(TestCase):
         ua = oc._build_user_agent(self.app_name, self.app_ver, self.app_url)
 
         expected_app_name = "TestApp"
-        expected_title = 'DjangoEsi'
+        expected_title = "DjangoEsi"
 
         self.assertEqual(
             (
@@ -100,7 +104,7 @@ class BuildUserAgentTests(TestCase):
         ua = oc._build_user_agent("test app", self.app_ver, self.app_url)
 
         expected_app_name = "TestApp"
-        expected_title = 'DjangoEsi'
+        expected_title = "DjangoEsi"
 
         self.assertEqual(
             (
@@ -122,7 +126,7 @@ class BuildUserAgentTests(TestCase):
         ua = oc._build_user_agent("test-app", self.app_ver, self.app_url)
 
         expected_app_name = "TestApp"
-        expected_title = 'DjangoEsi'
+        expected_title = "DjangoEsi"
 
         self.assertEqual(
             (
@@ -137,7 +141,7 @@ class BuildUserAgentTests(TestCase):
         ua = oc._build_user_agent(self.app_name, self.app_ver)
 
         expected_app_name = "TestApp"
-        expected_title = 'DjangoEsi'
+        expected_title = "DjangoEsi"
 
         self.assertEqual(
             (
@@ -176,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, {}),
@@ -246,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"
@@ -260,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"}
@@ -268,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)
 
-class TestOpenapiClientProvider(TestCase):
+    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()
+
+    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)
@@ -280,19 +337,6 @@ class TestOpenapiClientProvider(TestCase):
 
     @patch.object(httpx.Client, "send")
     def test_ua(self, send: MagicMock):
-        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
-        )
-        cache.clear()
-
         send.return_value = httpx.Response(
             200,
             json={
@@ -303,7 +347,7 @@ class TestOpenapiClientProvider(TestCase):
             request=httpx.Request("GET", "test"),
         )
 
-        status = esi.client.Status.GetStatus().result()
+        status = self.esi.client.Status.GetStatus().result()
         call_args, call_kwargs = send.call_args
 
         expected_app_name = "TestsApp"
@@ -312,19 +356,35 @@ class TestOpenapiClientProvider(TestCase):
         self.assertEqual(
             call_args[0].headers["user-agent"],
             (
-                f"{expected_app_name}/{app_ver} "
-                f"({app_settings.ESI_USER_CONTACT_EMAIL}{f'; +{app_url})'} "
+                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.object(httpx.Client, "send")
-    def test_etag_hit_cached(self, send: MagicMock):
+    @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"
-        etag = "'123456789abcdef123456789abcdef'"
+
+        esi = ESIClientProvider(
+            ua_appname=app_name,
+            ua_url=app_url,
+            ua_version=app_ver,
+            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,
@@ -333,7 +393,66 @@ class TestOpenapiClientProvider(TestCase):
             tags=["Status"],
             spec_file=SPEC_PATH
         )
-        cache.clear()
+        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)
@@ -356,26 +475,15 @@ class TestOpenapiClientProvider(TestCase):
             ),
         )
 
-        esi.client.Status.GetStatus().result()
+        self.esi.client.Status.GetStatus().result()
 
         with self.assertRaises(HTTPNotModified):
-            esi.client.Status.GetStatus().result()
+            self.esi.client.Status.GetStatus().result()
 
     @patch.object(httpx.Client, "send")
-    def test_etag_hit_external(self, send: MagicMock):
-        app_name = "TestsApp"
-        app_ver = "1.2.3"
-        app_url = "https://tests.pass"
+    def test_etag_not_hit_cached(self, send: MagicMock):
         etag = "'123456789abcdef123456789abcdef'"
-        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
-        )
-        cache.clear()
+
         expires = (
             timezone.now() + timedelta(minutes=5)
         ).strftime('%a, %d %b %Y %H:%M:%S %Z')
@@ -396,12 +504,27 @@ class TestOpenapiClientProvider(TestCase):
                 "test",
             ),
         )
-        esi.client.Status.GetStatus().result()
 
-        cache.delete(esi.client.Status.GetStatus()._cache_key())
+        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(
-            304,
+            200,
+            json={
+                "players": 1234,
+                "server_version": "1234",
+                "start_time": "2029-09-19T11:02:08Z"
+            },
             headers={
                 "etag": etag,
                 "expires": expires
@@ -411,5 +534,222 @@ class TestOpenapiClientProvider(TestCase):
                 "test",
             ),
         )
-        with self.assertRaises(HTTPNotModified):
-            esi.client.Status.GetStatus().result()
+
+        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(
+            ESIRateLimits.get_bucket(self.esi.client.Status.GetStatus().bucket),
+            598
+        )
+
+    @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)