Fix test_deserialization

Author: EspenHa

samples/openapi3/client/petstore/python-lazyImports/tests/test_deserialization.py

@@ -291,7 +291,7 @@ def test_deserialize_animal(self):
         self.assertTrue(isinstance(deserialized, petstore_api.Cat))
         self.assertEqual(deserialized.class_name, "Cat")
         self.assertEqual(deserialized.declawed, True)
-        self.assertEqual(deserialized.to_json(), '{"className": "Cat", "color": "red", "declawed": true}')
+        self.assertEqual(json.loads(deserialized.to_json()), {"className": "Cat", "color": "red", "declawed": True})
 
         # test from json
         json_str = '{"className": "Cat", "color": "red", "declawed": true}'
@@ -305,7 +305,7 @@ def test_deserialize_animal(self):
 
         self.assertEqual(deserialized.class_name, "Cat")
         self.assertEqual(deserialized.declawed, True)
-        self.assertEqual(deserialized.to_json(), '{"className": "Cat", "color": "red", "declawed": true}')
+        self.assertEqual(json.loads(deserialized.to_json()), {"className": "Cat", "color": "red", "declawed": True})
 
     def test_deserialize_content_type(self):
 

samples/openapi3/client/petstore/python-pydantic-v1/tests/test_http_signature.py

@@ -10,26 +10,43 @@
 $ pytest
 """
 
-from datetime import timedelta
+from collections import namedtuple
+from datetime import datetime, timedelta
 import base64
+import json
 import os
 import re
+import shutil
+from typing import Union
 import unittest
-from urllib.parse import urlparse
+from urllib.parse import urlencode, urlparse
 
 from Crypto.Hash import SHA256, SHA512
 from Crypto.PublicKey import ECC, RSA
+from Crypto.Hash.SHA512 import SHA512Hash
+from Crypto.Hash.SHA256 import SHA256Hash
 from Crypto.Signature import pkcs1_15, pss, DSS
 
 import petstore_api
 #from petstore_api.models import Category, Tag, Pet
 from petstore_api.api.pet_api import PetApi
 from petstore_api import Configuration, signing
+from petstore_api.rest import (
+    RESTClientObject,
+    RESTResponse
+)
+
+from petstore_api.exceptions import (
+    ApiException,
+    ApiValueError,
+    ApiTypeError,
+)
 
 from .util import id_gen
 
 import urllib3
 
+from unittest.mock import patch
 
 HOST = 'http://localhost/v2'
 
@@ -59,7 +76,7 @@ def __init__(self, *arg, **kwargs):
     def __eq__(self, other):
         return self._read == other._read and self._connect == other._connect and self.total == other.total
 
-class MockPoolManager(object):
+class MockPoolManager(urllib3.PoolManager):
     def __init__(self, tc):
         self._tc = tc
         self._reqs = []
@@ -69,9 +86,9 @@ def expect_request(self, *args, **kwargs):
 
     def set_signing_config(self, signing_cfg):
         self.signing_cfg = signing_cfg
-        self._tc.assertIsNotNone(self.signing_cfg)
+        assert self.signing_cfg is not None
         self.pubkey = self.signing_cfg.get_public_key()
-        self._tc.assertIsNotNone(self.pubkey)
+        assert self.pubkey is not None
 
     def request(self, *actual_request_target, **actual_request_headers_and_body):
         self._tc.assertTrue(len(self._reqs) > 0)
@@ -114,13 +131,13 @@ def _validate_authorization_header(self, request_target, actual_headers, authori
         # Extract (created)
         r1 = re.compile(r'created=([0-9]+)')
         m1 = r1.search(authorization_header)
-        self._tc.assertIsNotNone(m1)
+        assert m1 is not None
         created = m1.group(1)
 
         # Extract list of signed headers
         r1 = re.compile(r'headers="([^"]+)"')
         m1 = r1.search(authorization_header)
-        self._tc.assertIsNotNone(m1)
+        assert m1 is not None
         headers = m1.group(1).split(' ')
         signed_headers_list = []
         for h in headers:
@@ -132,25 +149,26 @@ def _validate_authorization_header(self, request_target, actual_headers, authori
                 signed_headers_list.append((h, "{0} {1}".format(request_target[0].lower(), target_path)))
             else:
                 value = next((v for k, v in actual_headers.items() if k.lower() == h), None)
-                self._tc.assertIsNotNone(value)
+                assert value is not None
                 signed_headers_list.append((h, value))
         header_items = [
             "{0}: {1}".format(key.lower(), value) for key, value in signed_headers_list]
         string_to_sign = "\n".join(header_items)
-        digest = None
+        digest: Union[SHA512Hash, SHA256Hash]
         if self.signing_cfg.hash_algorithm == signing.HASH_SHA512:
             digest = SHA512.new()
         elif self.signing_cfg.hash_algorithm == signing.HASH_SHA256:
             digest = SHA256.new()
         else:
             self._tc.fail("Unsupported hash algorithm: {0}".format(self.signing_cfg.hash_algorithm))
+
         digest.update(string_to_sign.encode())
         b64_body_digest = base64.b64encode(digest.digest()).decode()
 
         # Extract the signature
         r2 = re.compile(r'signature="([^"]+)"')
         m2 = r2.search(authorization_header)
-        self._tc.assertIsNotNone(m2)
+        assert m2 is not None
         b64_signature = m2.group(1)
         signature = base64.b64decode(b64_signature)
         # Build the message
@@ -180,6 +198,12 @@ def _validate_authorization_header(self, request_target, actual_headers, authori
             self._tc.fail("Unsupported signing algorithm: {0}".format(signing_alg))
 
 class PetApiTests(unittest.TestCase):
+    rsa_key_path: str
+    rsa4096_key_path: str
+    ec_p521_key_path: str
+    pet: petstore_api.Pet
+    test_file_dir: str
+    private_key_passphrase: str
 
     @classmethod
     def setUpClass(cls):
@@ -198,19 +222,19 @@ def tearDownClass(cls):
 
     @classmethod
     def setUpModels(cls):
-        cls.category = petstore_api.Category(name="dog")
-        cls.category.id = id_gen()
-        cls.tag = petstore_api.Tag()
-        cls.tag.id = id_gen()
-        cls.tag.name = "python-pet-tag"
+        category = petstore_api.Category(name="dog")
+        category.id = id_gen()
+        tag = petstore_api.Tag()
+        tag.id = id_gen()
+        tag.name = "python-pet-tag"
         cls.pet = petstore_api.Pet(
             name="hello kity",
-            photo_urls=["http://foo.bar.com/1", "http://foo.bar.com/2"]
+            photoUrls=["http://foo.bar.com/1", "http://foo.bar.com/2"]
         )
         cls.pet.id = id_gen()
         cls.pet.status = "sold"
-        cls.pet.category = cls.category
-        cls.pet.tags = [cls.tag]
+        cls.pet.category = category
+        cls.pet.tags = [tag]
 
     @classmethod
     def setUpFiles(cls):
@@ -229,6 +253,8 @@ def setUpFiles(cls):
             with open(cls.rsa_key_path, 'w') as f:
                 f.write(RSA_TEST_PRIVATE_KEY)
 
+        key: Union[RSA.RsaKey, ECC.EccKey]
+
         if not os.path.exists(cls.rsa4096_key_path):
             key = RSA.generate(4096)
             private_key = key.export_key(
@@ -240,13 +266,17 @@ def setUpFiles(cls):
 
         if not os.path.exists(cls.ec_p521_key_path):
             key = ECC.generate(curve='P-521')
-            private_key = key.export_key(
+            pkey = key.export_key(
                 format='PEM',
                 passphrase=cls.private_key_passphrase,
                 use_pkcs8=True,
                 protection='PBKDF2WithHMAC-SHA1AndAES128-CBC'
             )
-            with open(cls.ec_p521_key_path, "wt") as f:
+            if isinstance(pkey, str):
+                private_key = pkey.encode("ascii")
+            else:
+                private_key = pkey
+            with open(cls.ec_p521_key_path, "wb") as f:
                 f.write(private_key)
 
     def test_valid_http_signature(self):
@@ -449,7 +479,7 @@ def test_invalid_configuration(self):
             signing_cfg = signing.HttpSigningConfiguration(
                 key_id="my-key-id",
                 private_key_path=self.ec_p521_key_path,
-                signing_scheme=None
+                signing_scheme=None  # type: ignore
             )
         self.assertTrue(re.match('Unsupported security scheme', str(cm.exception)),
             'Exception message: {0}'.format(str(cm.exception)))

samples/openapi3/client/petstore/python/tests/test_deserialization.py

@@ -291,7 +291,7 @@ def test_deserialize_animal(self):
         self.assertTrue(isinstance(deserialized, petstore_api.Cat))
         self.assertEqual(deserialized.class_name, "Cat")
         self.assertEqual(deserialized.declawed, True)
-        self.assertEqual(deserialized.to_json(), '{"className": "Cat", "color": "red", "declawed": true}')
+        self.assertEqual(json.loads(deserialized.to_json()), {"className": "Cat", "color": "red", "declawed": True})
 
         # test from json
         json_str = '{"className": "Cat", "color": "red", "declawed": true}'
@@ -305,7 +305,7 @@ def test_deserialize_animal(self):
 
         self.assertEqual(deserialized.class_name, "Cat")
         self.assertEqual(deserialized.declawed, True)
-        self.assertEqual(deserialized.to_json(), '{"className": "Cat", "color": "red", "declawed": true}')
+        self.assertEqual(json.loads(deserialized.to_json()), {"className": "Cat", "color": "red", "declawed": True})
 
     def test_deserialize_content_type(self):