ucloud-sdk-python3 0.11.81__py3-none-any.whl

ucloud/testing/driver/_scenario.py

@@ -0,0 +1,93 @@
+import functools
+
+from ucloud.testing.driver import _step
+
+
+class Scenario:
+    def __init__(self, spec, id_, title=None, owners=None):
+        self.id = id_
+        self.title = title
+        self.store = {}
+        self.errors = []
+        self.steps = []
+        self.spec = spec
+        self.owners = owners
+
+    def step(self, invoker, *args, **kwargs):
+        step = _step.Step(self, invoker, *args, **kwargs)
+        self.steps.append(step)
+        return step
+
+    def api(self, **step_kwargs):
+        def deco(fn):
+            step = self.step(fn, **step_kwargs)
+
+            @functools.wraps(fn)
+            def wrapped(*args, **kwargs):
+                return step.run_api(*args, **kwargs)
+
+            return wrapped
+
+        return deco
+
+    def func(self, **step_kwargs):
+        def deco(fn):
+            step = self.step(fn, **step_kwargs)
+
+            @functools.wraps(fn)
+            def wrapped(*args, **kwargs):
+                return step.run_func(*args, **kwargs)
+
+            return wrapped
+
+        return deco
+
+    @property
+    def status(self):
+        if all([item.status == "skipped" for item in self.steps]):
+            status = "skipped"
+        elif any([item.status == "failed" for item in self.steps]):
+            status = "failed"
+        else:
+            status = "passed"
+        return status
+
+    @property
+    def start_time(self):
+        times = [
+            item.start_time for item in self.steps if item.status != "skipped"
+        ]
+        return min(times) if times else 0
+
+    @property
+    def end_time(self):
+        times = [
+            item.end_time for item in self.steps if item.status != "skipped"
+        ]
+        return max(times) if times else 0
+
+    def json(self):
+        return {
+            "title": self.title,
+            "status": self.status,
+            "steps": [item.json() for item in self.steps],
+            "owners": self.owners,
+            "execution": {
+                "duration": self.end_time - self.start_time,
+                "start_time": self.start_time,
+                "end_time": self.end_time,
+            },
+            "passed_count": len(
+                [1 for item in self.steps if item.status == "passed"]
+            ),
+            "failed_count": len(
+                [1 for item in self.steps if item.status == "failed"]
+            ),
+            "skipped_count": len(
+                [1 for item in self.steps if item.status == "skipped"]
+            ),
+        }
+
+    def __call__(self, *args, **kwargs):
+        for step in self.steps:
+            step(step, *args, **kwargs)

ucloud/testing/driver/_specification.py

@@ -0,0 +1,57 @@
+from ucloud.testing.driver import _scenario
+
+
+class Specification:
+    def __init__(self):
+        self.scenarios = []
+
+    def scenario(self, id_, title="", owners=None):
+        scenario = _scenario.Scenario(self, id_, title, owners)
+        self.scenarios.append(scenario)
+        return scenario
+
+    @property
+    def status(self):
+        if all([item.status == "skipped" for item in self.scenarios]):
+            status = "skipped"
+        elif any([item.status == "failed" for item in self.scenarios]):
+            status = "failed"
+        else:
+            status = "passed"
+        return status
+
+    @property
+    def start_time(self):
+        times = [
+            item.start_time
+            for item in self.scenarios
+            if item.status != "skipped"
+        ]
+        return min(times) if times else 0
+
+    @property
+    def end_time(self):
+        times = [
+            item.end_time for item in self.scenarios if item.status != "skipped"
+        ]
+        return max(times) if times else 0
+
+    def json(self):
+        return {
+            "status": self.status,
+            "execution": {
+                "duration": self.end_time - self.start_time,
+                "start_time": self.start_time,
+                "end_time": self.end_time,
+            },
+            "scenarios": [item.json() for item in self.scenarios],
+            "passed_count": len(
+                [1 for item in self.scenarios if item.status == "passed"]
+            ),
+            "failed_count": len(
+                [1 for item in self.scenarios if item.status == "failed"]
+            ),
+            "skipped_count": len(
+                [1 for item in self.scenarios if item.status == "skipped"]
+            ),
+        }

ucloud/testing/driver/_step.py

@@ -0,0 +1,166 @@
+import logging
+import time
+import typing
+
+from ucloud.core.transport import http
+from ucloud.testing import exc, utest, op
+from ucloud.testing.exc import ValueNotFoundError, CompareError
+
+logger = logging.getLogger(__name__)
+
+
+class Step:
+    def __init__(
+        self,
+        scenario,
+        invoker,
+        max_retries: int = 0,
+        retry_interval: int = 0,
+        startup_delay: int = 0,
+        retry_for: typing.Tuple = (CompareError, ValueNotFoundError),
+        fast_fail: bool = False,
+        validators: typing.Callable[[dict], typing.List[typing.Tuple]] = None,
+        title: str = "",
+        **kwargs
+    ):
+        """Step is the test step in a test scenario
+        :param invoker: invoker is a callable function
+        :param max_retries: the maximum retry number by the `retry_for` exception,
+                            it will resolve the flaky testing case
+        :param retry_interval: the interval between twice retrying
+        :param retry_for: the exceptions to retrying
+        :param startup_delay: the delay seconds before any action execution
+        :param fast_fail: if fast fail is true, the test will fail when got
+                          unexpected exception
+        :return:
+        """
+        self.invoker = invoker
+        self.validators = validators or (lambda _: [])
+
+        self.max_retries = max_retries
+        self.retry_interval = retry_interval
+        self.retry_for = retry_for
+        self.startup_delay = startup_delay
+        self.fast_fail = fast_fail
+
+        self.start_time = 0
+        self.end_time = 0
+        self.status = "skipped"
+
+        self.title = title
+        self.type = "api"
+        self.errors = []
+
+        self.extras = kwargs
+        self.scenario = scenario
+        self.store = scenario.store
+        self.api_retries = []
+
+    def run_api(self, client, *args, **kwargs):
+        client.transport.middleware.response(self._handle_response, 0)
+        try:
+            result = self._run(
+                self._set_default_response, client, *args, **kwargs
+            )
+        except Exception as e:
+            raise e
+        finally:
+            client.transport.middleware.response_handlers.pop(0)
+        return result
+
+    def run_func(self, *args, **kwargs):
+        return self._run(None, *args, **kwargs)
+
+    def json(self):
+        return {
+            "title": self.title,
+            "type": self.type,
+            "status": self.status,
+            "execution": {
+                "max_retries": self.max_retries,
+                "retry_interval": self.retry_interval,
+                "startup_delay": self.startup_delay,
+                "fast_fail": self.fast_fail,
+                "duration": self.end_time - self.start_time,
+                "start_time": self.start_time,
+                "end_time": self.end_time,
+            },
+            "api_retries": self.api_retries,
+            "errors": list(set([str(e) for e in self.errors])),
+        }
+
+    def _handle_response(self, resp: http.Response):
+        req = resp.request.payload()
+        req.pop("Signature", None)
+
+        self.api_retries.append(
+            {
+                "request": req,
+                "response": resp.json(),
+                "request_uuid": resp.headers.get("X-UCLOUD-REQUEST-UUID"),
+                "request_time": resp.request.request_time,
+            }
+        )
+        return resp
+
+    def _set_default_response(self, result):
+        if result is None:
+            return result
+        result.setdefault("RetCode", 0)
+        if "action" in self.extras:
+            result["Action"] = "{}Response".format(self.extras["action"])
+        return result
+
+    def _run(self, invoke_callback=None, *args, **kwargs):
+        self.start_time = time.time()
+
+        try:
+            result = self._run_with_callback(invoke_callback, *args, **kwargs)
+        except Exception as e:
+            raise e
+        finally:
+            self.end_time = time.time()
+
+        return result
+
+    def _run_with_callback(self, invoke_callback=None, *args, **kwargs):
+        # wait for delay before startup
+        if self.startup_delay:
+            time.sleep(self.startup_delay)
+
+        for i in range(self.max_retries + 1):
+            self.errors.clear()
+
+            # invoke function to load result
+            try:
+                result = self.invoker(self, *args, **kwargs)
+            except Exception as e:
+                result = None
+                self.errors.append(e)
+            else:
+                invoke_callback and invoke_callback(result)
+
+                for validator in self.validators(self.store):
+                    try:
+                        op.check(
+                            validator[0],
+                            utest.value_at_path(result, validator[1]),
+                            validator[2],
+                        )
+                    except self.retry_for as e:
+                        self.errors.append(e)
+                    except Exception as e:
+                        self.errors.append(e)
+
+            # if got error, retrying or raise it
+            if self.errors:
+                if i == self.max_retries:
+                    self.status = "failed"
+                    raise exc.ValidateError(self.errors)
+
+                if self.retry_interval:
+                    time.sleep(self.retry_interval)
+                continue
+
+            self.status = "passed"
+            return result or None

ucloud/testing/env.py

@@ -0,0 +1,28 @@
+import os
+
+ACC_ENV_KEY = "USDKACC"
+ACC_SKIP_REASON = "skip test for non-acc environment"
+
+
+def get_skip_reason():
+    return ACC_SKIP_REASON
+
+
+def is_acc() -> bool:
+    """check test env is acceptance testing or not"""
+    return os.getenv(ACC_ENV_KEY)
+
+
+def is_ut() -> bool:
+    """check test env is unit testing or not"""
+    return not is_acc()
+
+
+def pre_check_env():
+    """pre check environment for testing
+
+    NOTE: system environment variables credential is required for test environment
+    """
+    assert os.getenv("UCLOUD_PUBLIC_KEY"), "invalid public key"
+    assert os.getenv("UCLOUD_PRIVATE_KEY"), "invalid private key"
+    assert os.getenv("UCLOUD_PROJECT_ID"), "invalid region"

ucloud/testing/exc.py

@@ -0,0 +1,18 @@
+class UTestError(Exception):
+    pass
+
+
+class ValidateError(UTestError):
+    def __init__(self, errors):
+        self.errors = errors
+
+    def __str__(self):
+        return str(self.errors)
+
+
+class ValueNotFoundError(UTestError):
+    pass
+
+
+class CompareError(UTestError):
+    pass

ucloud/testing/funcs.py

@@ -0,0 +1,68 @@
+import datetime
+import time
+
+
+def concat(*args):
+    """cancat strings
+
+    >>> concat(42, 'foo', 'bar')
+    '42foobar'
+    """
+    return "".join([str(s) for s in args])
+
+
+def concat_without_dot(args):
+    """replace blank
+
+    >>> concat_without_dot('42foo bar')
+    '42foobar'
+    """
+    return "".join([str(s) for s in args.split()])
+
+
+def search_value(array, origin_key, origin_value, dest_key):
+    """given origin key and value,search dest_value form array by dest_key
+
+    >>> d = [{"UHostId": "foo", "Name": "testing"}]
+    >>> search_value(d, "Name", "testing", "UHostId")
+    'foo'
+    """
+    arr = [i.get(dest_key, "") for i in array if i[origin_key] == origin_value]
+    if arr:
+        return arr[0]
+    return ""
+
+
+def timedelta(timestamp, value, typ="days"):
+    """given timestamp(10bit) and calculate relative delta time
+
+    >>> timedelta(0, 1, "days")
+    86400.0
+
+    :param timestamp: timestamp (round to second)
+    :param value: float, can as positive or negative
+    :param typ: days/hours
+    :return: timestamp
+    """
+    value = int(value)
+    dt = datetime.datetime.fromtimestamp(float(timestamp))
+    if typ == "days":
+        dt += datetime.timedelta(days=value)
+    elif typ == "hours":
+        dt += datetime.timedelta(hours=value)
+    return time.mktime(dt.timetuple())
+
+
+def get_timestamp(length=13):
+    """get current timestamp string
+
+    >>> len(str(int(get_timestamp(10))))
+    10
+
+    :param length: length of timestamp, can only between 0 and 16
+    :return:
+    """
+    if isinstance(length, int) and 0 < length < 17:
+        return int("{:.6f}".format(time.time()).replace(".", "")[:length])
+
+    raise ValueError("timestamp length can only between 0 and 16.")

ucloud/testing/mock.py

@@ -0,0 +1,28 @@
+import json
+import typing
+
+from ucloud.core.transport import Transport, Request, Response
+
+
+class MockedTransport(Transport):
+    def __init__(self):
+        super(MockedTransport, self).__init__()
+        self.transport_handlers = []
+        self.client_handler = []
+
+    def send(self, req: Request, **options: typing.Any) -> Response:
+        resp = Response(req.url, req.method)
+        for handler in self.transport_handlers:
+            resp = handler(req)
+
+        for handler in self.client_handler:
+            payload = handler(req.payload())
+            resp.content = json.dumps(payload).encode("utf-8")
+
+        return resp
+
+    def mock(self, handler: typing.Callable[[Request], Response]):
+        self.transport_handlers.append(handler)
+
+    def mock_data(self, handler: typing.Callable[[dict], dict]):
+        self.client_handler.append(handler)

ucloud/testing/op.py

@@ -0,0 +1,177 @@
+import re
+
+from ucloud.testing.exc import CompareError
+
+
+def eq(value, expected):
+    """value is equal to expected"""
+    assert value == expected
+
+
+def ne(value, expected):
+    """value is equal to expected"""
+    assert value != expected
+
+
+def gt(value, expected):
+    """value is greater than expected"""
+    assert float(value) > float(expected)
+
+
+def ge(value, expected):
+    """value is greater than or equal to expected"""
+    assert float(value) >= float(expected)
+
+
+def abs_eq(value, expected):
+    """value is approx equal to expected"""
+    assert round(float(value), 2) == round(float(expected), 2)
+
+
+def lt(value, expected):
+    """value is less than excepted"""
+    assert float(value) < float(expected)
+
+
+def le(value, expected):
+    """value is less than or equal to excepted"""
+    assert float(value) <= float(expected)
+
+
+def str_eq(value, expected):
+    """value is equal to excepted as string"""
+    assert str(value) == str(expected)
+
+
+def float_eq(value, expected):
+    """value is equal to excepted as float"""
+    assert round(float(value), 2) == round(float(expected), 2)
+
+
+def len_eq(value, expected):
+    """length of value is equal to excepted"""
+    assert isinstance(expected, int)
+    assert len(value) == expected
+
+
+def len_gt(value, expected):
+    """length of value is greater than excepted"""
+    assert isinstance(expected, int)
+    assert len(value) > expected
+
+
+def len_ge(value, expected):
+    """length of value is greater than or equal to excepted"""
+    assert isinstance(expected, int)
+    assert len(value) >= expected
+
+
+def len_lt(value, expected):
+    """length of value is less than excepted"""
+    assert isinstance(expected, int)
+    assert len(value) < expected
+
+
+def len_le(value, expected):
+    """length of value is less than or equal to excepted"""
+    assert isinstance(expected, int)
+    assert len(value) <= expected
+
+
+def contains(value, expected):
+    """value is contains expected"""
+    assert expected in value
+
+
+def contained_by(value, expected):
+    """value is contained by expected"""
+    assert value in expected
+
+
+def type_eq(value, expected):
+    assert isinstance(value, expected)
+
+
+def regex(value, expected):
+    assert isinstance(expected, str)
+    assert isinstance(value, str)
+    assert re.match(expected, value)
+
+
+def startswith(value, expected):
+    assert str(value).startswith(expected)
+
+
+def endswith(value, expected):
+    assert str(value).endswith(expected)
+
+
+def object_contains(value, expected):
+    assert str(expected) in str(value)
+
+
+def object_not_contains(value, expected):
+    assert str(expected) not in str(value)
+
+
+mapper = {
+    "eq": eq,
+    "equals": eq,
+    "==": eq,
+    "abs_eq": abs_eq,
+    "abs_equals": abs_eq,
+    "lt": lt,
+    "less_than": lt,
+    "le": le,
+    "less_than_or_equals": le,
+    "gt": gt,
+    "greater_than": gt,
+    "ge": ge,
+    "greater_than_or_equals": ge,
+    "ne": ne,
+    "not_equals": ne,
+    "str_eq": str_eq,
+    "string_equals": str_eq,
+    "float_eq": float_eq,
+    "float_equals": float_eq,
+    "len_eq": len_eq,
+    "length_equals": len_eq,
+    "count_eq": len_eq,
+    "len_gt": len_gt,
+    "count_gt": len_gt,
+    "length_greater_than": len_gt,
+    "count_greater_than": len_gt,
+    "len_ge": len_ge,
+    "count_ge": len_ge,
+    "length_greater_than_or_equals": len_ge,
+    "count_greater_than_or_equals": len_ge,
+    "len_lt": len_lt,
+    "count_lt": len_lt,
+    "length_less_than": len_lt,
+    "count_less_than": len_lt,
+    "len_le": len_le,
+    "count_le": len_le,
+    "length_less_than_or_equals": len_le,
+    "count_less_than_or_equals": len_le,
+    "contains": contains,
+    "contained_by": contained_by,
+    "type": type_eq,
+    "regex": regex,
+    "startswith": startswith,
+    "endswith": endswith,
+    "object_contains": object_contains,
+    "object_not_contains": object_not_contains,
+}
+
+
+def check(name, value, expected):
+    if name not in mapper:
+        raise CompareError("comparator {} is not found".format(name))
+
+    try:
+        return mapper.get(name)(value, expected)
+    except AssertionError as e:
+        msg = "assert error, expect {} {} {}, got error {}".format(
+            value, name, expected, e
+        )
+        raise CompareError(msg)