robotframework-openapitools 1.0.0b3__py3-none-any.whl → 1.0.0b5__py3-none-any.whl

OpenApiLibCore/value_utils.py

@@ -1,17 +1,13 @@
 # mypy: disable-error-code=no-any-return
 """Utility module with functions to handle OpenAPI value types and restrictions."""
 
-import base64
-import datetime
 from copy import deepcopy
-from random import choice, randint, uniform
-from typing import Any, Callable, Iterable, Mapping, cast, overload
-
-import faker
-import rstr
-from robot.api import logger
+from random import choice
+from typing import Any, Iterable, cast, overload
 
 from OpenApiLibCore.annotations import JSON
+from OpenApiLibCore.localized_faker import FAKE
+from OpenApiLibCore.models import ResolvedSchemaObjectTypes
 
 
 class Ignore:
@@ -33,77 +29,6 @@ IGNORE = Ignore()
 UNSET = UnSet()
 
 
-class LocalizedFaker:
-    """Class to support setting a locale post-init."""
-
-    # pylint: disable=missing-function-docstring
-    def __init__(self) -> None:
-        self.fake = faker.Faker()
-
-    def set_locale(self, locale: str | list[str]) -> None:
-        """Update the fake attribute with a Faker instance with the provided locale."""
-        self.fake = faker.Faker(locale)
-
-    @property
-    def date(self) -> Callable[[], str]:
-        return self.fake.date
-
-    @property
-    def date_time(self) -> Callable[[], datetime.datetime]:
-        return self.fake.date_time
-
-    @property
-    def password(self) -> Callable[[], str]:
-        return self.fake.password
-
-    @property
-    def binary(self) -> Callable[[], bytes]:
-        return self.fake.binary
-
-    @property
-    def email(self) -> Callable[[], str]:
-        return self.fake.safe_email
-
-    @property
-    def uuid(self) -> Callable[[], str]:
-        return self.fake.uuid4
-
-    @property
-    def uri(self) -> Callable[[], str]:
-        return self.fake.uri
-
-    @property
-    def url(self) -> Callable[[], str]:
-        return self.fake.url
-
-    @property
-    def hostname(self) -> Callable[[], str]:
-        return self.fake.hostname
-
-    @property
-    def ipv4(self) -> Callable[[], str]:
-        return self.fake.ipv4
-
-    @property
-    def ipv6(self) -> Callable[[], str]:
-        return self.fake.ipv6
-
-    @property
-    def name(self) -> Callable[[], str]:
-        return self.fake.name
-
-    @property
-    def text(self) -> Callable[[], str]:
-        return self.fake.text
-
-    @property
-    def description(self) -> Callable[[], str]:
-        return self.fake.text
-
-
-FAKE = LocalizedFaker()
-
-
 def json_type_name_of_python_type(python_type: Any) -> str:
     """Return the JSON type name for supported Python types."""
     if python_type == str:
@@ -142,215 +67,53 @@ def python_type_by_json_type_name(type_name: str) -> type:
     raise ValueError(f"No Python type mapping for JSON type '{type_name}' available.")
 
 
-def get_valid_value(value_schema: Mapping[str, Any]) -> JSON:
-    """Return a random value that is valid under the provided value_schema."""
-    value_schema = deepcopy(value_schema)
-
-    if value_schema.get("types"):
-        value_schema = choice(value_schema["types"])
-
-    if (from_const := value_schema.get("const")) is not None:
-        return from_const
-    if from_enum := value_schema.get("enum"):
-        return choice(from_enum)
-
-    value_type = value_schema["type"]
-
-    if value_type == "null":
-        return None
-    if value_type == "boolean":
-        return FAKE.fake.boolean()
-    if value_type == "integer":
-        return get_random_int(value_schema=value_schema)
-    if value_type == "number":
-        return get_random_float(value_schema=value_schema)
-    if value_type == "string":
-        return get_random_string(value_schema=value_schema)
-    if value_type == "array":
-        return get_random_array(value_schema=value_schema)
-    raise NotImplementedError(f"Type '{value_type}' is currently not supported")
-
-
 def get_invalid_value(
-    value_schema: Mapping[str, Any],
-    current_value: Any,
-    values_from_constraint: Iterable[Any] = tuple(),
+    value_schema: ResolvedSchemaObjectTypes,
+    current_value: JSON,
+    values_from_constraint: Iterable[JSON] = tuple(),
 ) -> JSON | Ignore:
     """Return a random value that violates the provided value_schema."""
-    value_schema = deepcopy(value_schema)
-
-    if value_schemas := value_schema.get("types"):
-        if len(value_schemas) > 1:
-            value_schemas = [
-                schema for schema in value_schemas if schema["type"] != "null"
-            ]
-        value_schema = choice(value_schemas)
-
-    invalid_value: Any = None
-    value_type = value_schema["type"]
+    invalid_values: list[JSON | Ignore] = []
+    value_type = value_schema.type
 
     if not isinstance(current_value, python_type_by_json_type_name(value_type)):
-        current_value = get_valid_value(value_schema=value_schema)
+        current_value = value_schema.get_valid_value()
 
-    if (
-        values_from_constraint
-        and (
-            invalid_value := get_invalid_value_from_constraint(
+    if values_from_constraint:
+        try:
+            return get_invalid_value_from_constraint(
                 values_from_constraint=list(values_from_constraint),
                 value_type=value_type,
             )
-        )
-        is not None
-    ):
-        return invalid_value
-    # If an enum is possible, combine the values from the enum to invalidate the value
-    if enum_values := value_schema.get("enum"):
-        if (
-            invalid_value := get_invalid_value_from_enum(
-                values=enum_values, value_type=value_type
-            )
-        ) is not None:
-            return invalid_value
+        except ValueError:
+            pass
+
+    # For schemas with a const or enum, add invalidated values from those
+    try:
+        invalid_value = value_schema.get_invalid_value_from_const_or_enum()
+        invalid_values.append(invalid_value)
+    except ValueError:
+        pass
+
     # Violate min / max values or length if possible
-    if (
-        invalid_value := get_value_out_of_bounds(
-            value_schema=value_schema, current_value=current_value
+    try:
+        values_out_of_bounds = value_schema.get_values_out_of_bounds(
+            current_value=current_value  # type: ignore[arg-type]
         )
-    ) is not None:
-        return invalid_value
+        invalid_values += values_out_of_bounds
+    except ValueError:
+        pass
+
     # No value constraints or min / max ranges to violate, so change the data type
     if value_type == "string":
         # Since int / float / bool can always be cast to sting, change
         # the string to a nested object.
         # An array gets exploded in query strings, "null" is then often invalid
-        return [{"invalid": [None, False]}, "null", None, True]
-    logger.debug(f"property type changed from {value_type} to random string")
-    return FAKE.uuid()
-
-
-def get_random_int(value_schema: Mapping[str, Any]) -> int:
-    """Generate a random int within the min/max range of the schema, if specified."""
-    # Use int32 integers if "format" does not specify int64
-    property_format = value_schema.get("format", "int32")
-    if property_format == "int64":
-        min_int = -9223372036854775808
-        max_int = 9223372036854775807
-    else:
-        min_int = -2147483648
-        max_int = 2147483647
-    # OAS 3.0: exclusiveMinimum/Maximum is a bool in combination with minimum/maximum
-    # OAS 3.1: exclusiveMinimum/Maximum is an integer
-    minimum = value_schema.get("minimum", min_int)
-    maximum = value_schema.get("maximum", max_int)
-    if (exclusive_minimum := value_schema.get("exclusiveMinimum")) is not None:
-        if isinstance(exclusive_minimum, bool):
-            if exclusive_minimum:
-                minimum += 1
-        else:
-            minimum = exclusive_minimum + 1
-    if (exclusive_maximum := value_schema.get("exclusiveMaximum")) is not None:
-        if isinstance(exclusive_maximum, bool):
-            if exclusive_maximum:
-                maximum -= 1
-        else:
-            maximum = exclusive_maximum - 1
-    return randint(minimum, maximum)
-
-
-def get_random_float(value_schema: Mapping[str, Any]) -> float:
-    """Generate a random float within the min/max range of the schema, if specified."""
-    # Python floats are already double precision, so no check for "format"
-    minimum = value_schema.get("minimum")
-    maximum = value_schema.get("maximum")
-    if minimum is None:
-        if maximum is None:
-            minimum = -1.0
-            maximum = 1.0
-        else:
-            minimum = maximum - 1.0
+        invalid_values.append([{"invalid": [None, False]}, "null", None, True])
     else:
-        if maximum is None:
-            maximum = minimum + 1.0
-        if maximum < minimum:
-            raise ValueError(f"maximum of {maximum} is less than minimum of {minimum}")
-
-    # For simplicity's sake, exclude both boundaries if one boundary is exclusive
-    exclude_boundaries = False
-
-    exclusive_minimum = value_schema.get("exclusiveMinimum", False)
-    exclusive_maximum = value_schema.get("exclusiveMaximum", False)
-    # OAS 3.0: exclusiveMinimum/Maximum is a bool in combination with minimum/maximum
-    # OAS 3.1: exclusiveMinimum/Maximum is an integer or number
-    if not isinstance(exclusive_minimum, bool):
-        exclude_boundaries = True
-        minimum = exclusive_minimum
-    else:
-        exclude_boundaries = exclusive_minimum
-    if not isinstance(exclusive_maximum, bool):
-        exclude_boundaries = True
-        maximum = exclusive_maximum
-    else:
-        exclude_boundaries = exclusive_minimum or exclusive_maximum
-
-    if exclude_boundaries and minimum == maximum:
-        raise ValueError(
-            f"maximum of {maximum} is equal to minimum of {minimum} and "
-            f"exclusiveMinimum or exclusiveMaximum is specified"
-        )
+        invalid_values.append(FAKE.uuid())
 
-    while exclude_boundaries:
-        result = uniform(minimum, maximum)
-        if minimum < result < maximum:  # pragma: no cover
-            return result
-    return uniform(minimum, maximum)
-
-
-def get_random_string(value_schema: Mapping[str, Any]) -> bytes | str:
-    """Generate a random string within the min/max length in the schema, if specified."""
-    # if a pattern is provided, format and min/max length can be ignored
-    if pattern := value_schema.get("pattern"):
-        return rstr.xeger(pattern)
-    minimum = value_schema.get("minLength", 0)
-    maximum = value_schema.get("maxLength", 36)
-    maximum = max(minimum, maximum)
-    format_ = value_schema.get("format", "uuid")
-    # byte is a special case due to the required encoding
-    if format_ == "byte":
-        data = FAKE.uuid()
-        return base64.b64encode(data.encode("utf-8"))
-    value = fake_string(string_format=format_)
-    while len(value) < minimum:
-        # use fake.name() to ensure the returned string uses the provided locale
-        value = value + FAKE.name()
-    if len(value) > maximum:
-        value = value[:maximum]
-    return value
-
-
-def fake_string(string_format: str) -> str:
-    """
-    Generate a random string based on the provided format if the format is supported.
-    """
-    # format names may contain -, which is invalid in Python naming
-    string_format = string_format.replace("-", "_")
-    fake_generator = getattr(FAKE, string_format, FAKE.uuid)
-    value: str = fake_generator()
-    if isinstance(value, datetime.datetime):
-        return value.strftime("%Y-%m-%dT%H:%M:%SZ")
-    return value
-
-
-def get_random_array(value_schema: Mapping[str, Any]) -> list[JSON]:
-    """Generate a list with random elements as specified by the schema."""
-    minimum = value_schema.get("minItems", 0)
-    maximum = value_schema.get("maxItems", 1)
-    maximum = max(minimum, maximum)
-    items_schema = value_schema["items"]
-    value = []
-    for _ in range(maximum):
-        item_value = get_valid_value(items_schema)
-        value.append(item_value)
-    return value
+    return choice(invalid_values)
 
 
 def get_invalid_value_from_constraint(
@@ -368,12 +131,14 @@ def get_invalid_value_from_constraint(
     # if the value is forced True or False, return the opposite to invalidate
     if len(values_from_constraint) == 1 and value_type == "boolean":
         return not values_from_constraint[0]
-    # for unsupported types or empty constraints lists return None
+    # for unsupported types or empty constraints lists raise a ValueError
     if (
         value_type not in ["string", "integer", "number", "array", "object"]
         or not values_from_constraint
     ):
-        return None
+        raise ValueError(
+            f"Cannot get invalid value for {value_type} from {values_from_constraint}"
+        )
 
     values_from_constraint = deepcopy(values_from_constraint)
     # for objects, keep the keys intact but update the values
@@ -416,8 +181,9 @@ def get_invalid_value_from_constraint(
 
     str_or_bytes_list = cast(list[str] | list[bytes], values_from_constraint)
     invalid_value = get_invalid_str_or_bytes(values_from_constraint=str_or_bytes_list)
-    # None for empty string
-    return invalid_value if invalid_value else None
+    if not invalid_value:
+        raise ValueError("Value invalidation yielded an empty string.")
+    return invalid_value
 
 
 def get_invalid_int_or_number(values_from_constraint: list[int | float]) -> int | float:
@@ -431,11 +197,15 @@ def get_invalid_int_or_number(values_from_constraint: list[int | float]) -> int
 
 
 @overload
-def get_invalid_str_or_bytes(values_from_constraint: list[str]) -> str: ...
+def get_invalid_str_or_bytes(
+    values_from_constraint: list[str],
+) -> str: ...  # pragma: no cover
 
 
 @overload
-def get_invalid_str_or_bytes(values_from_constraint: list[bytes]) -> bytes: ...
+def get_invalid_str_or_bytes(
+    values_from_constraint: list[bytes],
+) -> bytes: ...  # pragma: no cover
 
 
 def get_invalid_str_or_bytes(values_from_constraint: list[Any]) -> Any:
@@ -444,85 +214,3 @@ def get_invalid_str_or_bytes(values_from_constraint: list[Any]) -> Any:
     for value in invalid_values:
         invalid_value = invalid_value + value
     return invalid_value
-
-
-def get_invalid_value_from_enum(values: list[Any], value_type: str) -> JSON:
-    """Return a value not in the enum by combining the enum values."""
-    if value_type == "string":
-        invalid_value: Any = ""
-    elif value_type in ["integer", "number"]:
-        invalid_value = 0
-    elif value_type == "array":
-        invalid_value = []
-    elif value_type == "object":
-        # force creation of a new object since we will be modifying it
-        invalid_value = {**values[0]}
-    else:
-        logger.warn(f"Cannot invalidate enum value with type {value_type}")
-        return None
-    for value in values:
-        # repeat each addition to ensure single-item enums are invalidated
-        if value_type in ["integer", "number"]:
-            invalid_value += abs(value) + abs(value)
-        if value_type == "string":
-            invalid_value += value + value
-        if value_type == "array":
-            invalid_value.extend(value)
-            invalid_value.extend(value)
-        # objects are a special case, since they must be of the same type / class
-        # invalid_value.update(value) will end up with the last value in the list,
-        # which is a valid value, so another approach is needed
-        if value_type == "object":
-            for key in invalid_value.keys():
-                invalid_value[key] = value.get(key)
-                if invalid_value not in values:
-                    return invalid_value
-    return invalid_value
-
-
-def get_value_out_of_bounds(
-    value_schema: Mapping[str, Any], current_value: JSON
-) -> JSON:
-    """
-    Return a value just outside the value or length range if specified in the
-    provided schema, otherwise None is returned.
-    """
-    value_type = value_schema["type"]
-
-    if value_type in ["integer", "number"]:
-        if (minimum := value_schema.get("minimum")) is not None:
-            if value_schema.get("exclusiveMinimum") is True:
-                return minimum
-            return minimum - 1
-        if (maximum := value_schema.get("maximum")) is not None:
-            if value_schema.get("exclusiveMaximum") is True:
-                return maximum
-            return maximum + 1
-        # In OAS 3.1 exclusveMinimum/Maximum are no longer boolean but instead integer
-        # or number and minimum/maximum should not be used with exclusiveMinimum/Maximum
-        if (exclusive_minimum := value_schema.get("exclusiveMinimum")) is not None:
-            return exclusive_minimum
-        if (exclusive_maximum := value_schema.get("exclusiveMaximum")) is not None:
-            return exclusive_maximum
-    if value_type == "array":
-        current_list = cast(list[JSON], current_value)
-        if minimum := value_schema.get("minItems", 0) > 0:
-            return current_list[0 : minimum - 1]
-        if (maximum := value_schema.get("maxItems")) is not None:
-            invalid_value = current_list if current_list else ["x"]
-            while len(invalid_value) <= maximum:
-                invalid_value.append(choice(invalid_value))  # pyright: ignore[reportArgumentType]
-            return invalid_value  # type: ignore[unused-ignore]
-    if value_type == "string":
-        current_string = cast(str, current_value)
-        # if there is a minimum length, send 1 character less
-        if minimum := value_schema.get("minLength", 0):
-            return current_string[0 : minimum - 1]
-        # if there is a maximum length, send 1 character more
-        if maximum := value_schema.get("maxLength"):
-            invalid_string_value = current_string if current_string else "x"
-            # add random characters from the current value to prevent adding new characters
-            while len(invalid_string_value) <= maximum:
-                invalid_string_value += choice(invalid_string_value)
-            return invalid_string_value
-    return None

openapi_libgen/__init__.py

@@ -1,46 +0,0 @@
-from pathlib import Path
-from typing import Any
-
-from jinja2 import Environment, FileSystemLoader
-
-from openapi_libgen.spec_parser import get_keyword_data
-
-HERE = Path(__file__).parent.resolve()
-INIT_TEMPLATE_PATH = HERE / "templates/__init__.jinja"
-LIBRARY_TEMPLATE_PATH = HERE / "templates/library.jinja"
-
-
-def generate(
-    openapi_spec: dict[str, Any],
-    output_folder: Path,
-    library_name: str,
-    module_name: str,
-) -> str:
-    keyword_data = get_keyword_data(openapi_spec=openapi_spec)
-
-    library_folder = output_folder / library_name
-    library_folder.mkdir(parents=True, exist_ok=True)
-
-    environment = Environment(loader=FileSystemLoader(f"{HERE}/templates/"))
-
-    init_template = environment.get_template("__init__.jinja")
-    init_path = library_folder / "__init__.py"
-    init_content = init_template.render(
-        library_name=library_name,
-        module_name=module_name,
-    )
-    with open(init_path, mode="w", encoding="utf-8") as init_file:
-        init_file.write(init_content)
-        print(f"{init_path} created")
-
-    library_template = environment.get_template("library.jinja")
-    module_path = library_folder / f"{module_name}.py"
-    library_content = library_template.render(
-        library_name=library_name,
-        keywords=keyword_data,
-    )
-    with open(module_path, mode="w", encoding="utf-8") as library_file:
-        library_file.write(library_content)
-        print(f"{module_path} created")
-
-    return f"Generating {library_name} at {output_folder.resolve().as_posix()}/{module_name}"

openapi_libgen/command_line.py

@@ -1,9 +1,7 @@
 import argparse
 from pathlib import Path
 
-from prance import ResolvingParser
-
-import openapi_libgen
+from openapi_libgen import generator
 from openapi_libgen.parsing_utils import remove_unsafe_characters_from_string
 
 parser = argparse.ArgumentParser(
@@ -27,24 +25,14 @@ def get_class_and_module_name_from_string(string: str) -> tuple[str, str]:
 
 
 def main() -> None:
-    def recursion_limit_handler(
-        limit: int, refstring: str, recursions: object
-    ) -> object:  # pylint: disable=unused-argument
-        return args.recursion_default
-
     if not (source := args.source):
         source = input("Please provide a source for the generation: ")
 
-    parser = ResolvingParser(
-        source,
-        backend="openapi-spec-validator",
+    spec = generator.load_openapi_spec(
+        source=source,
         recursion_limit=args.recursion_limit,
-        recursion_limit_handler=recursion_limit_handler,
-    )
-    assert parser.specification is not None, (
-        "Source was loaded, but no specification was present after parsing."
+        recursion_default=args.recursion_default,
     )
-    spec = parser.specification
 
     if not (destination := args.destination):
         destination = input(
@@ -57,7 +45,7 @@ def main() -> None:
             args.name
         )
     else:
-        default_name = spec["info"]["title"]
+        default_name = spec.info.title
 
         default_library_name, default_module_name = (
             get_class_and_module_name_from_string(default_name)
@@ -79,8 +67,8 @@ def main() -> None:
                 default_module_name,
             )
 
-    openapi_libgen.generate(
-        openapi_spec=spec,
+    generator.generate(
+        openapi_object=spec,
         output_folder=path,
         library_name=safe_library_name,
         module_name=safe_module_name,

openapi_libgen/generator.py

@@ -0,0 +1,84 @@
+import sys
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader
+from prance import ResolvingParser
+
+from openapi_libgen.spec_parser import get_keyword_data
+from OpenApiLibCore.models import OpenApiObject
+
+HERE = Path(__file__).parent.resolve()
+INIT_TEMPLATE_PATH = HERE / "templates/__init__.jinja"
+LIBRARY_TEMPLATE_PATH = HERE / "templates/library.jinja"
+
+
+def load_openapi_spec(
+    source: str, recursion_limit: int, recursion_default: object
+) -> OpenApiObject:
+    def recursion_limit_handler(
+        limit: int, refstring: str, recursions: object
+    ) -> object:  # pylint: disable=unused-argument
+        return recursion_default  # pragma: no cover
+
+    parser = ResolvingParser(
+        source,
+        backend="openapi-spec-validator",
+        recursion_limit=recursion_limit,
+        recursion_limit_handler=recursion_limit_handler,
+    )
+    assert parser.specification is not None, (
+        "Source was loaded, but no specification was present after parsing."
+    )
+    openapi_object = OpenApiObject.model_validate(parser.specification)
+    return openapi_object
+
+
+def generate(
+    openapi_object: OpenApiObject,
+    output_folder: Path,
+    library_name: str,
+    module_name: str,
+) -> str:
+    keyword_data = get_keyword_data(openapi_object=openapi_object)
+
+    library_folder = output_folder / library_name
+    library_folder.mkdir(parents=True, exist_ok=True)
+
+    environment = Environment(loader=FileSystemLoader(f"{HERE}/templates/"))
+
+    init_template = environment.get_template("__init__.jinja")
+    init_path = library_folder / "__init__.py"
+    init_content = init_template.render(
+        library_name=library_name,
+        module_name=module_name,
+    )
+    with open(init_path, mode="w", encoding="utf-8") as init_file:
+        init_file.write(init_content)
+        print(f"{init_path} created")
+
+    library_template = environment.get_template("library.jinja")
+    module_path = library_folder / f"{module_name}.py"
+    library_content = library_template.render(
+        library_name=library_name,
+        keywords=keyword_data,
+    )
+    with open(module_path, mode="w", encoding="utf-8") as library_file:
+        library_file.write(library_content)
+        print(f"{module_path} created")
+
+    return f"Generated {library_name} at {output_folder.resolve().as_posix()}/{module_name}"
+
+
+if __name__ == "__main__":  # pragma: no cover
+    source = sys.argv[1]
+    destination = Path(sys.argv[2])
+    library_name = sys.argv[3]
+    module_name = sys.argv[4]
+    spec = load_openapi_spec(source=source, recursion_limit=1, recursion_default={})
+
+    result_string = generate(
+        openapi_object=spec,
+        output_folder=destination,
+        library_name=library_name,
+        module_name=module_name,
+    )

openapi_libgen/parsing_utils.py

@@ -8,16 +8,20 @@ def remove_unsafe_characters_from_string(string: str) -> str:
         string_iterator = iter(string)
         capitalize_next_character = False
 
-        for character in string_iterator:
-            if character.isalpha():
-                yield character
-                break
+        # The first character must be A-z or _
+        first_character = next(string_iterator, "_")
+        if first_character.isalpha() or first_character == "_":
+            yield first_character
+        elif first_character.isnumeric():
+            yield "_" + first_character
 
         for character in string_iterator:
             if character.isalnum():
                 if capitalize_next_character:
                     capitalize_next_character = False
-                yield character
+                    yield character.upper()
+                else:
+                    yield character
 
             elif not capitalize_next_character:
                 capitalize_next_character = True