Feature/typesystem enhancement (#4)

* migrate from python3 sdk

* migrate from python3 sdk

Author: yufeiminds

docs/quick_start.rst

@@ -53,7 +53,7 @@ You can then use your keys to create a new client of uhost service:
                 'Type': 'CLOUD_SSD'
             }],
         })
-    except exc.UCloudException as e
+    except exc.UCloudException as e:
         print(e)
     else:
         print(resp)

examples/uhost/main.py

@@ -36,7 +36,7 @@ def main():
         'Memory': 1024,
         'Disks': [{
             'Size': image["ImageSize"],
-            'Type': 'CLOUD_NORMAL',
+            'Type': 'CLOUD_SSD',
             'IsBoot': 'True',
         }],
     })

tests/test_core/test_client.py

@@ -4,7 +4,7 @@
 import pytest
 import logging
 from ucloud.core.client import Client
-from ucloud.core.testing import env
+from ucloud.testing import env
 
 logger = logging.getLogger(__name__)
 

tests/test_core/test_schema.py

@@ -1,46 +1,131 @@
 # -*- coding: utf-8 -*-
 
 import logging
+import pytest
+from ucloud.core import exc
 from ucloud.core.typesystem import fields, schema
 
 logger = logging.getLogger(__name__)
 
 
-def test_array():
-    class TestSchema(schema.RequestSchema):
+def test_request_array():
+    class Schema(schema.RequestSchema):
         fields = {"IP": fields.List(fields.Str())}
 
-    ret = TestSchema().dumps({"IP": ["127.0.0.1"]})
-    assert ret.get("IP.0") == "127.0.0.1"
-    assert ret.get("IP") is None
-    assert ret.get("IP.1") is None
+    d = Schema().dumps({"IP": ["127.0.0.1"]})
+    assert d == {"IP.0": "127.0.0.1"}
+    d = Schema().dumps({})
+    assert d == {}
 
 
-def test_array_model():
-    class TestSchema(schema.RequestSchema):
+def test_request_array_with_default():
+    class Schema(schema.RequestSchema):
         fields = {"IP": fields.List(fields.Str(), default=["127.0.0.1"])}
 
-    class TestArrayModel(schema.RequestSchema):
-        fields = {"Interface": TestSchema()}
+    d = Schema().dumps({"IP": ["192.168.0.1"]})
+    assert d == {"IP.0": "192.168.0.1"}
+    d = Schema().dumps({})
+    assert d == {"IP.0": "127.0.0.1"}
 
-    class TestArrayModelArray(schema.RequestSchema):
-        fields = {"Interface": fields.List(TestSchema(), default=list)}
 
-    d = {"Interface": {"IP": ["127.0.0.1", "192.168.0.1"]}}
-    ret = TestArrayModel().dumps(d)
-    assert ret.get("Interface.IP.0") == "127.0.0.1"
-    assert ret.get("Interface.IP.1") == "192.168.0.1"
+def test_request_object_model():
+    class Schema(schema.RequestSchema):
+        fields = {"IP": fields.List(fields.Str())}
+
+    class NestedObjectSchema(schema.RequestSchema):
+        fields = {"Interface": Schema()}
+
+    d = NestedObjectSchema().dumps({"Interface": {"IP": ["127.0.0.1"]}})
+    assert d == {"Interface.IP.0": "127.0.0.1"}
+    with pytest.raises(exc.ValidationException):
+        NestedObjectSchema().dumps({"Interface": 1})
+
+
+def test_request_array_model_with_default():
+    class Schema(schema.RequestSchema):
+        fields = {"IP": fields.List(fields.Str())}
+
+    class NestedArraySchema(schema.RequestSchema):
+        fields = {
+            "Interface": fields.List(
+                Schema(default=lambda: "127.0.0.1"),
+                default=lambda: [{"IP": ["192.168.1.1"]}],
+            )
+        }
+
+    d = NestedArraySchema().dumps({})
+    assert d == {"Interface.0.IP.0": "192.168.1.1"}
+    d = {"Interface": [{"IP": ["127.0.0.1", "192.168.0.1"]}, {"IP": ["172.16.0.1"]}]}
+    d = NestedArraySchema().dumps(d)
+    assert d == {
+        "Interface.0.IP.0": "127.0.0.1",
+        "Interface.0.IP.1": "192.168.0.1",
+        "Interface.1.IP.0": "172.16.0.1",
+    }
+
+
+def test_response_array():
+    class Schema(schema.ResponseSchema):
+        fields = {"IP": fields.List(fields.Str())}
+
+    d = Schema().loads({})
+    assert d == {"IP": []}
+    d = Schema().loads({"IP": ["127.0.0.1"]})
+    assert d == {"IP": ["127.0.0.1"]}
+    with pytest.raises(exc.ValidationException):
+        Schema().loads({"IP": 1})
+
+
+def test_response_array_with_default():
+    class Schema(schema.ResponseSchema):
+        fields = {"IP": fields.List(fields.Str(), default=["127.0.0.1"])}
+
+    d = Schema().dumps({"IP": ["192.168.0.1"]})
+    assert d == {"IP": ["192.168.0.1"]}
+    d = Schema().dumps({})
+    assert d == {"IP": ["127.0.0.1"]}
+
+
+def test_response_object_model():
+    class Schema(schema.ResponseSchema):
+        fields = {"IP": fields.List(fields.Str())}
+
+    class NestedObjectSchema(schema.ResponseSchema):
+        fields = {"EIP": Schema()}
+
+    d = NestedObjectSchema().loads({"EIP": {"IP": ["127.0.0.1"]}})
+    assert d == {"EIP": {"IP": ["127.0.0.1"]}}
+    d = NestedObjectSchema().loads({})
+    assert d == {"EIP": {"IP": []}}
+
+
+def test_response_object_model_case_insensitive():
+    class Schema(schema.ResponseSchema):
+        fields = {"IP": fields.List(fields.Str())}
+
+    class NestedObjectSchema(schema.ResponseSchema):
+        fields = {"EIP": Schema()}
+
+    d = NestedObjectSchema().loads({"eip": {"Ip": ["127.0.0.1"]}})
+    assert d == {"EIP": {"IP": ["127.0.0.1"]}}
+
+
+def test_response_array_model_with_default():
+    class Schema(schema.ResponseSchema):
+        fields = {"IP": fields.List(fields.Str())}
+
+    class NestedArraySchema(schema.ResponseSchema):
+        fields = {
+            "Interface": fields.List(
+                Schema(default=lambda: {"IP": ["127.0.0.1"]}),
+                default=lambda: [{"IP": ["192.168.1.1"]}],
+            )
+        }
+
+    d = NestedArraySchema().dumps({})
+    assert d == {"Interface": [{"IP": ["192.168.1.1"]}]}
     d = {"Interface": [{"IP": ["127.0.0.1", "192.168.0.1"]}, {"IP": ["172.16.0.1"]}]}
-    ret = TestArrayModelArray().dumps(d)
-    assert ret.get("Interface.0.IP.0") == "127.0.0.1"
-    assert ret.get("Interface.0.IP.1") == "192.168.0.1"
-    assert ret.get("Interface.1.IP.0") == "172.16.0.1"
-    d = {}
-    ret = TestArrayModelArray().dumps(d)
-    assert ret.get("Interface") is None
-    d = {"Interface": [{"IP": None}]}
-    ret = TestArrayModelArray().dumps(d)
-    assert ret.get("Interface.0.IP.0") == "127.0.0.1"
-    d = {"Interface": [{}]}
-    ret = TestArrayModelArray().dumps(d)
-    assert ret.get("Interface.0.IP.0") == "127.0.0.1"
+    d = NestedArraySchema().dumps(d)
+    assert d == {
+        "Interface": [{"IP": ["127.0.0.1", "192.168.0.1"]}, {"IP": ["172.16.0.1"]}]
+    }

tests/test_services/conftest.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+import os
+import pytest
+from ucloud.client import Client
+
+
+@pytest.fixture(scope="session", autouse=True)
+def client():
+    return Client(
+        {
+            "region": os.getenv("UCLOUD_REGION"),
+            "project_id": os.getenv("UCLOUD_PROJECT_ID"),
+            "public_key": os.getenv("UCLOUD_PUBLIC_KEY"),
+            "private_key": os.getenv("UCLOUD_PRIVATE_KEY"),
+            "max_retries": 3,
+            "timeout": 60,
+        }
+    )
+
+
+@pytest.fixture(scope="module", autouse=True)
+def variables():
+    return {
+        "Region": "cn-bj2",
+        "Zone": "cn-bj2-05",
+        "ProjectId": os.getenv("UCLOUD_PROJECT_ID"),
+    }

tests/test_testing/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

tests/test_testing/test_utest.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from ucloud.testing import utest
+
+
+def test_value_at_path():
+    d = {
+        "Action": "DescribeEIPResponse",
+        "EIPSet": [
+            {
+                "Resource": {
+                    "ResourceID": "uhost-war3png3",
+                    "ResourceName": "eip-s1-bgp",
+                    "ResourceType": "uhost",
+                    "Zone": "cn-bj2-05",
+                }
+            }
+        ],
+        "RetCode": 0,
+        "TotalBandwidth": 6,
+        "TotalCount": 3,
+    }
+    assert utest.value_at_path(d, "EIPSet.0.Resource.ResourceID") == "uhost-war3png3"

ucloud/client.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+""" Code is generated by ucloud-model, DO NOT EDIT IT. """
 from ucloud.core import client
 
 
@@ -8,15 +9,10 @@ def __init__(self, config, transport=None, middleware=None):
         self._config = config
         super(Client, self).__init__(config, transport, middleware)
 
-    def umem(self):
-        from ucloud.services.umem.client import UMemClient
-
-        return UMemClient(self._config, self.transport, self.middleware, self.logger)
-
-    def unet(self):
-        from ucloud.services.unet.client import UNetClient
+    def pathx(self):
+        from ucloud.services.pathx.client import PathXClient
 
-        return UNetClient(self._config, self.transport, self.middleware, self.logger)
+        return PathXClient(self._config, self.transport, self.middleware, self.logger)
 
     def uaccount(self):
         from ucloud.services.uaccount.client import UAccountClient
@@ -25,25 +21,40 @@ def uaccount(self):
             self._config, self.transport, self.middleware, self.logger
         )
 
-    def udisk(self):
-        from ucloud.services.udisk.client import UDiskClient
+    def udb(self):
+        from ucloud.services.udb.client import UDBClient
 
-        return UDiskClient(self._config, self.transport, self.middleware, self.logger)
+        return UDBClient(self._config, self.transport, self.middleware, self.logger)
 
     def udpn(self):
         from ucloud.services.udpn.client import UDPNClient
 
         return UDPNClient(self._config, self.transport, self.middleware, self.logger)
 
+    def udisk(self):
+        from ucloud.services.udisk.client import UDiskClient
+
+        return UDiskClient(self._config, self.transport, self.middleware, self.logger)
+
     def uhost(self):
         from ucloud.services.uhost.client import UHostClient
 
         return UHostClient(self._config, self.transport, self.middleware, self.logger)
 
-    def pathx(self):
-        from ucloud.services.pathx.client import PathXClient
+    def ulb(self):
+        from ucloud.services.ulb.client import ULBClient
 
-        return PathXClient(self._config, self.transport, self.middleware, self.logger)
+        return ULBClient(self._config, self.transport, self.middleware, self.logger)
+
+    def umem(self):
+        from ucloud.services.umem.client import UMemClient
+
+        return UMemClient(self._config, self.transport, self.middleware, self.logger)
+
+    def unet(self):
+        from ucloud.services.unet.client import UNetClient
+
+        return UNetClient(self._config, self.transport, self.middleware, self.logger)
 
     def uphost(self):
         from ucloud.services.uphost.client import UPHostClient
@@ -54,13 +65,3 @@ def vpc(self):
         from ucloud.services.vpc.client import VPCClient
 
         return VPCClient(self._config, self.transport, self.middleware, self.logger)
-
-    def udb(self):
-        from ucloud.services.udb.client import UDBClient
-
-        return UDBClient(self._config, self.transport, self.middleware, self.logger)
-
-    def ulb(self):
-        from ucloud.services.ulb.client import ULBClient
-
-        return ULBClient(self._config, self.transport, self.middleware, self.logger)

ucloud/core/client/_client.py

@@ -93,10 +93,10 @@ def _build_http_request(self, args):
         return Request(
             url=self.config.base_url,
             method="post",
-            json=payload,
+            data=payload,
             headers={
                 "User-Agent": self._build_user_agent(),
-                "Content-Type": "application/json",
+                "Content-Type": "application/x-www-form-urlencoded",
             },
         )
 
@@ -106,3 +106,6 @@ def _build_user_agent(self):
             python_version=python_version, sdk_version=version.version
         ) + (self.config.user_agent or "")
         return user_agent
+
+    def __repr__(self):
+        return "<{}('{}')>".format(self.__class__.__name__, self.config.region)

ucloud/core/exc/_exc.py

@@ -26,6 +26,9 @@ def retryable(self):
     def __str__(self):
         return "{self.action} - {self.code}: {self.message}".format(self=self)
 
+    def json(self):
+        return {"RetCode": self.code, "Message": self.message, "Action": self.action}
+
 
 class RetryTimeoutException(UCloudException):
     pass