swaggerforge 0.1.0__tar.gz → 0.2.0__tar.gz

{swaggerforge-0.1.0/src/swaggerforge.egg-info → swaggerforge-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swaggerforge
-Version: 0.1.0
+Version: 0.2.0
 Summary: Automatic pytest test generation from OpenAPI (Swagger) specifications
 Author: Viktor Pylypenko
 License-Expression: MIT
@@ -10,14 +10,16 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0
 Requires-Dist: prance>=23.6.21.0
-Requires-Dist: openapi-core>=0.18
 Requires-Dist: openapi-spec-validator>=0.7
 Requires-Dist: jinja2>=3.0
 Requires-Dist: requests>=2.28
 Requires-Dist: jsonschema>=4.0
+Requires-Dist: tomli>=2.0; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: pytest>=9.0; extra == "dev"
 Requires-Dist: flake8>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=7.0; extra == "dev"
+Requires-Dist: tox>=4.0; extra == "dev"
 Dynamic: license-file
 
 # SwaggerForge
@@ -45,6 +47,7 @@ established test-design techniques.
   - **Boolean coverage** >>> exercises both `true` and `false` for boolean fields
 - Deterministic output: the same specification always produces identical tests
 - Generated files use session-scoped pytest fixtures and run with no manual edits
+- Optional `swaggerforge.toml` config file for project-level defaults
 
 ## Requirements
 
@@ -75,11 +78,36 @@ pytest tests_generated
 
 ### Options
 
-| Option     | Description                                        | Default            |
-|------------|----------------------------------------------------|--------------------|
-| `--spec`   | Path to the OpenAPI specification (JSON or YAML)   | *(required)*       |
-| `--url`    | Base URL of the API under test                     | *(required)*       |
-| `--output` | Directory for the generated test files             | `tests_generated`  |
+| Option     | Description                                        | Default                           |
+|------------|----------------------------------------------------|-----------------------------------|
+| `--spec`   | Path to the OpenAPI specification (JSON or YAML)   | *(required)*                      |
+| `--url`    | Base URL of the API under test                     | *(required unless in config)*     |
+| `--output` | Directory for the generated test files             | `tests_generated`                 |
+| `--config` | Path to a configuration file                       | `./swaggerforge.toml` if present  |
+
+## Configuration
+
+Options that stay the same across runs can be kept in a `swaggerforge.toml`
+file instead of being passed on the command line. The file is picked up
+automatically from the directory where the tool is run, or an explicit path
+can be given with `--config`.
+
+```toml
+# swaggerforge.toml
+base_url = "http://localhost:8080"
+output_dir = "tests_generated"
+timeout = 30
+```
+
+| Key          | Type    | Effect                                                        |
+|--------------|---------|---------------------------------------------------------------|
+| `base_url`   | string  | Base URL of the API; makes `--url` optional                   |
+| `output_dir` | string  | Directory for generated files                                 |
+| `timeout`    | integer | Embeds `timeout=<n>` into every generated HTTP request call   |
+
+Values given on the command line always take precedence over the config file.
+Without a `timeout`, generated tests place no time limit on requests -
+setting one makes test runs fail fast when the API is unreachable.
 
 ## How it works
 

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/README.md

@@ -23,6 +23,7 @@ established test-design techniques.
   - **Boolean coverage** >>> exercises both `true` and `false` for boolean fields
 - Deterministic output: the same specification always produces identical tests
 - Generated files use session-scoped pytest fixtures and run with no manual edits
+- Optional `swaggerforge.toml` config file for project-level defaults
 
 ## Requirements
 
@@ -53,11 +54,36 @@ pytest tests_generated
 
 ### Options
 
-| Option     | Description                                        | Default            |
-|------------|----------------------------------------------------|--------------------|
-| `--spec`   | Path to the OpenAPI specification (JSON or YAML)   | *(required)*       |
-| `--url`    | Base URL of the API under test                     | *(required)*       |
-| `--output` | Directory for the generated test files             | `tests_generated`  |
+| Option     | Description                                        | Default                           |
+|------------|----------------------------------------------------|-----------------------------------|
+| `--spec`   | Path to the OpenAPI specification (JSON or YAML)   | *(required)*                      |
+| `--url`    | Base URL of the API under test                     | *(required unless in config)*     |
+| `--output` | Directory for the generated test files             | `tests_generated`                 |
+| `--config` | Path to a configuration file                       | `./swaggerforge.toml` if present  |
+
+## Configuration
+
+Options that stay the same across runs can be kept in a `swaggerforge.toml`
+file instead of being passed on the command line. The file is picked up
+automatically from the directory where the tool is run, or an explicit path
+can be given with `--config`.
+
+```toml
+# swaggerforge.toml
+base_url = "http://localhost:8080"
+output_dir = "tests_generated"
+timeout = 30
+```
+
+| Key          | Type    | Effect                                                        |
+|--------------|---------|---------------------------------------------------------------|
+| `base_url`   | string  | Base URL of the API; makes `--url` optional                   |
+| `output_dir` | string  | Directory for generated files                                 |
+| `timeout`    | integer | Embeds `timeout=<n>` into every generated HTTP request call   |
+
+Values given on the command line always take precedence over the config file.
+Without a `timeout`, generated tests place no time limit on requests -
+setting one makes test runs fail fast when the API is unreachable.
 
 ## How it works
 

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swaggerforge"
-version = "0.1.0"
+version = "0.2.0"
 description = "Automatic pytest test generation from OpenAPI (Swagger) specifications"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -16,11 +16,11 @@ keywords = ["openapi", "swagger", "pytest", "test generation", "api testing"]
 dependencies = [
     "click>=8.0",
     "prance>=23.6.21.0",
-    "openapi-core>=0.18",
     "openapi-spec-validator>=0.7",
     "jinja2>=3.0",
     "requests>=2.28",
     "jsonschema>=4.0",
+    'tomli>=2.0; python_version < "3.11"',
 ]
 
 [project.scripts]
@@ -38,4 +38,4 @@ addopts = "--import-mode=importlib"
 testpaths = ["tests"]
 
 [project.optional-dependencies]
-dev = ["pytest>=9.0", "flake8>=7.0"]
+dev = ["pytest>=9.0", "flake8>=7.0", "pytest-cov>=7.0", "tox>=4.0"]

swaggerforge-0.2.0/src/swaggerforge/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for running SwaggerForge as a module (python -m swaggerforge)."""
+from swaggerforge.cli import main
+
+if __name__ == "__main__":
+    main()

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/src/swaggerforge/cli.py

@@ -1,6 +1,7 @@
 """Command-line interface for SwaggerForge."""
 
 import click
+from swaggerforge.config import load_config, ConfigError
 from swaggerforge.validator import load_and_validate, SpecValidationError
 from swaggerforge.parser import parse_spec, SpecParseError
 from swaggerforge.generator import generate_scenarios
@@ -23,17 +24,39 @@ def main():
 )
 @click.option(
     "--url",
-    required=True,
-    help="Base URL of the API to be tested.",
+    default=None,
+    help="Base URL of the API to be tested. "
+         "Required unless base_url is set in the config file.",
 )
 @click.option(
     "--output",
-    default="tests_generated",
+    default=None,
     type=click.Path(),
-    help="Directory where generated test files will be written.",
+    help="Directory where generated test files will be written "
+         "[default: tests_generated].",
 )
-def generate(spec, url, output):
+@click.option(
+    "--config",
+    "config_path",
+    default=None,
+    type=click.Path(),
+    help="Path to a swaggerforge.toml config file "
+         "[default: ./swaggerforge.toml if present].",
+)
+def generate(spec, url, output, config_path):
     """Generate pytest test files from an OpenAPI specification."""
+    try:
+        config = load_config(config_path)
+    except ConfigError as error:
+        raise click.ClickException(str(error))
+
+    url = url or config.base_url
+    if url is None:
+        raise click.ClickException(
+            "No base URL given: pass --url or set base_url in swaggerforge.toml."
+        )
+    output = output or config.output_dir or "tests_generated"
+
     click.echo(f"Reading specification: {spec}")
 
     try:
@@ -56,7 +79,7 @@ def generate(spec, url, output):
     click.echo(f"Generated {len(scenarios)} test scenarios.")
 
     try:
-        written = write_test_files(scenarios, url, output)
+        written = write_test_files(scenarios, url, output, config.timeout)
     except OSError as error:
         raise click.ClickException(
             f"Could not write test files to '{output}': {error}"

swaggerforge-0.2.0/src/swaggerforge/config.py

@@ -0,0 +1,102 @@
+"""Loading of user configuration from a swaggerforge.toml file.
+
+This module reads optional user configuration for the generator. An
+explicitly given path must exist and parse; an auto-discovered file
+(./swaggerforge.toml in the working directory) may be absent, in which
+case an empty configuration is returned.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+try:
+    import tomllib  # Python 3.11+
+except ModuleNotFoundError:
+    import tomli as tomllib  # Python 3.10 backport
+
+DEFAULT_CONFIG_FILENAME = "swaggerforge.toml"
+
+_KNOWN_KEYS = {
+    "timeout": int,
+    "output_dir": str,
+    "base_url": str,
+}
+
+
+class ConfigError(Exception):
+    """Raised when a config file is missing (if explicitly requested) or invalid."""
+
+
+@dataclass
+class Config:
+    """User configuration loaded from swaggerforge.toml.
+
+    A field value of None means the setting was not present in the file.
+    """
+    timeout: int | None = None
+    output_dir: str | None = None
+    base_url: str | None = None
+
+
+def load_config(config_path=None):
+    """Load configuration from a swaggerforge.toml file.
+
+    Args:
+        config_path: Explicit path to a config file. If given, the file
+            must exist and parse; otherwise ./swaggerforge.toml is
+            auto-discovered, and its absence yields an empty Config.
+
+    Returns:
+        A Config object with values from the file, or an empty Config
+        when no file was found during auto-discovery.
+
+    Raises:
+        ConfigError: If an explicitly given file is missing, if any file
+            contains invalid TOML, or if it contains unknown keys or
+            values of the wrong type.
+    """
+    if config_path is not None:
+        path = Path(config_path)
+        if not path.is_file():
+            raise ConfigError(f"Config file not found: '{config_path}'")
+    else:
+        path = Path(DEFAULT_CONFIG_FILENAME)
+        if not path.is_file():
+            return Config()
+
+    try:
+        raw = path.read_bytes()
+        # utf-8-sig strips a leading UTF-8 BOM if present (common on
+        # Windows) and is identical to utf-8 otherwise.
+        data = tomllib.loads(raw.decode("utf-8-sig"))
+    except tomllib.TOMLDecodeError as error:
+        raise ConfigError(f"Invalid config file '{path}': {error}")
+    except UnicodeDecodeError:
+        raise ConfigError(
+            f"Invalid config file '{path}': not valid UTF-8 "
+            f"(TOML files must be UTF-8 encoded; on Windows, beware that "
+            f"PowerShell redirection may create UTF-16 files)"
+        )
+
+    return _validate(data, path)
+
+
+def _validate(data, path):
+    """Check keys and value types, returning a populated Config."""
+    unknown = set(data) - set(_KNOWN_KEYS)
+    if unknown:
+        names = ", ".join(sorted(unknown))
+        raise ConfigError(f"Unknown key(s) in config file '{path}': {names}")
+
+    for key, expected_type in _KNOWN_KEYS.items():
+        if key not in data:
+            continue
+        value = data[key]
+        # bool is a subclass of int in Python; reject it for timeout.
+        if isinstance(value, bool) or not isinstance(value, expected_type):
+            raise ConfigError(
+                f"Invalid value for '{key}' in config file '{path}': "
+                f"expected {expected_type.__name__}, got {type(value).__name__}"
+            )
+
+    return Config(**data)

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/src/swaggerforge/output.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from swaggerforge.template import render_test_file
 
 
-def write_test_files(scenarios, base_url, output_dir):
+def write_test_files(scenarios, base_url, output_dir, timeout=None):
     """Group scenarios by tag, render them, and write one file per tag.
 
     Args:
@@ -32,7 +32,7 @@ def write_test_files(scenarios, base_url, output_dir):
     for tag in sorted(grouped):
         filename = f"test_{_sanitize(tag)}.py"
         file_path = output_path / filename
-        content = render_test_file(filename, base_url, grouped[tag])
+        content = render_test_file(filename, base_url, grouped[tag], timeout)
         file_path.write_text(content, encoding="utf-8")
         written.append(str(file_path))
 

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/src/swaggerforge/template.py

@@ -17,19 +17,21 @@ _env = Environment(
 )
 
 
-def render_test_file(filename, base_url, scenarios):
+def render_test_file(filename, base_url, scenarios, timeout=None):
     """Render a list of scenarios into the text of a pytest test file.
 
     Args:
         filename: The name of the file being generated (e.g. 'test_pet.py').
         base_url: The base URL of the API under test.
         scenarios: A list of TestScenario objects for one resource tag.
+        timeout: Optional request timeout in seconds; when given, it is
+            embedded into every generated HTTP call.
 
     Returns:
         The rendered file content as a string.
     """
     template = _env.get_template("test_file.py.j2")
-    rendered_scenarios = [_prepare_scenario(s) for s in scenarios]
+    rendered_scenarios = [_prepare_scenario(s, timeout) for s in scenarios]
     return template.render(
         filename=filename,
         base_url=base_url,
@@ -37,12 +39,12 @@ def render_test_file(filename, base_url, scenarios):
     )
 
 
-def _prepare_scenario(scenario):
+def _prepare_scenario(scenario, timeout=None):
     """Pre-compute all values the template needs for one scenario."""
     return {
         "function_name": build_function_name(scenario),
         "docstring": scenario.description,
-        "request_call": build_request_call(scenario),
+        "request_call": build_request_call(scenario, timeout),
         "expected_status": _status_codes_literal(scenario),
         "response_schema": _response_schema_literal(scenario),
     }
@@ -81,16 +83,19 @@ def _path_to_identifier(method, path):
     return f"{method}_{cleaned}"
 
 
-def build_request_call(scenario):
+def build_request_call(scenario, timeout=None):
     """Assemble the full requests.<method>(...) call as a string."""
     endpoint = scenario.endpoint
     url = _build_url(endpoint.path, scenario.path_params)
 
     parts = [f'f"{{base_url}}{url}"']
+    parts.append("headers=headers")
     if scenario.query_params:
         parts.append(f"params={scenario.query_params!r}")
     if scenario.request_body is not None:
         parts.append(f"json={scenario.request_body!r}")
+    if timeout is not None:
+        parts.append(f"timeout={timeout}")
 
     args = ", ".join(parts)
     return f"requests.{endpoint.method}({args})"

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/src/swaggerforge/templates/test_file.py.j2

@@ -11,9 +11,14 @@ import jsonschema
 def base_url():
     return "{{ base_url }}"
 
+
+@pytest.fixture(scope="session")
+def headers():
+    return {"Content-Type": "application/json"}
+
 {% for scenario in scenarios %}
 
-def {{ scenario.function_name }}(base_url):
+def {{ scenario.function_name }}(base_url, headers):
     """{{ scenario.docstring }}"""
     response = {{ scenario.request_call }}
     assert response.status_code in {{ scenario.expected_status }}

{swaggerforge-0.1.0 → swaggerforge-0.2.0/src/swaggerforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swaggerforge
-Version: 0.1.0
+Version: 0.2.0
 Summary: Automatic pytest test generation from OpenAPI (Swagger) specifications
 Author: Viktor Pylypenko
 License-Expression: MIT
@@ -10,14 +10,16 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0
 Requires-Dist: prance>=23.6.21.0
-Requires-Dist: openapi-core>=0.18
 Requires-Dist: openapi-spec-validator>=0.7
 Requires-Dist: jinja2>=3.0
 Requires-Dist: requests>=2.28
 Requires-Dist: jsonschema>=4.0
+Requires-Dist: tomli>=2.0; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: pytest>=9.0; extra == "dev"
 Requires-Dist: flake8>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=7.0; extra == "dev"
+Requires-Dist: tox>=4.0; extra == "dev"
 Dynamic: license-file
 
 # SwaggerForge
@@ -45,6 +47,7 @@ established test-design techniques.
   - **Boolean coverage** >>> exercises both `true` and `false` for boolean fields
 - Deterministic output: the same specification always produces identical tests
 - Generated files use session-scoped pytest fixtures and run with no manual edits
+- Optional `swaggerforge.toml` config file for project-level defaults
 
 ## Requirements
 
@@ -75,11 +78,36 @@ pytest tests_generated
 
 ### Options
 
-| Option     | Description                                        | Default            |
-|------------|----------------------------------------------------|--------------------|
-| `--spec`   | Path to the OpenAPI specification (JSON or YAML)   | *(required)*       |
-| `--url`    | Base URL of the API under test                     | *(required)*       |
-| `--output` | Directory for the generated test files             | `tests_generated`  |
+| Option     | Description                                        | Default                           |
+|------------|----------------------------------------------------|-----------------------------------|
+| `--spec`   | Path to the OpenAPI specification (JSON or YAML)   | *(required)*                      |
+| `--url`    | Base URL of the API under test                     | *(required unless in config)*     |
+| `--output` | Directory for the generated test files             | `tests_generated`                 |
+| `--config` | Path to a configuration file                       | `./swaggerforge.toml` if present  |
+
+## Configuration
+
+Options that stay the same across runs can be kept in a `swaggerforge.toml`
+file instead of being passed on the command line. The file is picked up
+automatically from the directory where the tool is run, or an explicit path
+can be given with `--config`.
+
+```toml
+# swaggerforge.toml
+base_url = "http://localhost:8080"
+output_dir = "tests_generated"
+timeout = 30
+```
+
+| Key          | Type    | Effect                                                        |
+|--------------|---------|---------------------------------------------------------------|
+| `base_url`   | string  | Base URL of the API; makes `--url` optional                   |
+| `output_dir` | string  | Directory for generated files                                 |
+| `timeout`    | integer | Embeds `timeout=<n>` into every generated HTTP request call   |
+
+Values given on the command line always take precedence over the config file.
+Without a `timeout`, generated tests place no time limit on requests -
+setting one makes test runs fail fast when the API is unreachable.
 
 ## How it works
 

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/src/swaggerforge.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/swaggerforge/__init__.py
 src/swaggerforge/__main__.py
 src/swaggerforge/cli.py
+src/swaggerforge/config.py
 src/swaggerforge/generator.py
 src/swaggerforge/models.py
 src/swaggerforge/output.py
@@ -17,6 +18,7 @@ src/swaggerforge.egg-info/entry_points.txt
 src/swaggerforge.egg-info/requires.txt
 src/swaggerforge.egg-info/top_level.txt
 src/swaggerforge/templates/test_file.py.j2
+tests/test_config.py
 tests/test_generator.py
 tests/test_output.py
 tests/test_parser.py

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/src/swaggerforge.egg-info/requires.txt

@@ -1,11 +1,15 @@
 click>=8.0
 prance>=23.6.21.0
-openapi-core>=0.18
 openapi-spec-validator>=0.7
 jinja2>=3.0
 requests>=2.28
 jsonschema>=4.0
 
+[:python_version < "3.11"]
+tomli>=2.0
+
 [dev]
 pytest>=9.0
 flake8>=7.0
+pytest-cov>=7.0
+tox>=4.0

swaggerforge-0.2.0/tests/test_config.py

@@ -0,0 +1,120 @@
+"""Tests for the config module."""
+
+import pytest
+
+from swaggerforge.config import Config, ConfigError, load_config
+
+
+VALID_TOML = """\
+timeout = 30
+output_dir = "my_tests"
+base_url = "http://localhost:8080"
+"""
+
+
+def test_load_explicit_valid_file(tmp_path):
+    """An explicitly given, valid config file is loaded fully."""
+    config_file = tmp_path / "custom.toml"
+    config_file.write_text(VALID_TOML, encoding="utf-8")
+
+    config = load_config(str(config_file))
+
+    assert config.timeout == 30
+    assert config.output_dir == "my_tests"
+    assert config.base_url == "http://localhost:8080"
+
+
+def test_load_explicit_missing_file_raises(tmp_path):
+    """An explicitly given path that does not exist is an error."""
+    missing = tmp_path / "nope.toml"
+
+    with pytest.raises(ConfigError):
+        load_config(str(missing))
+
+
+def test_load_explicit_malformed_file_raises(tmp_path):
+    """An explicitly given file with invalid TOML is an error."""
+    config_file = tmp_path / "broken.toml"
+    config_file.write_text("]] this is not toml [[", encoding="utf-8")
+
+    with pytest.raises(ConfigError):
+        load_config(str(config_file))
+
+
+def test_autodiscovery_finds_file_in_cwd(tmp_path, monkeypatch):
+    """Without an explicit path, ./swaggerforge.toml is discovered."""
+    (tmp_path / "swaggerforge.toml").write_text(VALID_TOML, encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+
+    config = load_config()
+
+    assert config.timeout == 30
+    assert config.output_dir == "my_tests"
+    assert config.base_url == "http://localhost:8080"
+
+
+def test_autodiscovery_absent_returns_empty_config(tmp_path, monkeypatch):
+    """No explicit path and no discoverable file yields an empty config."""
+    monkeypatch.chdir(tmp_path)
+
+    config = load_config()
+
+    assert config == Config()
+
+
+def test_autodiscovery_malformed_raises(tmp_path, monkeypatch):
+    """A discovered file that exists but is invalid TOML is an error."""
+    (tmp_path / "swaggerforge.toml").write_text("]] broken [[", encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(ConfigError):
+        load_config()
+
+
+def test_partial_config_leaves_other_fields_none(tmp_path):
+    """Keys absent from the file stay None (unset)."""
+    config_file = tmp_path / "partial.toml"
+    config_file.write_text("timeout = 10\n", encoding="utf-8")
+
+    config = load_config(str(config_file))
+
+    assert config.timeout == 10
+    assert config.output_dir is None
+    assert config.base_url is None
+
+
+def test_unknown_key_raises(tmp_path):
+    """An unrecognized key (e.g. a typo) is an error, not silently ignored."""
+    config_file = tmp_path / "typo.toml"
+    config_file.write_text("timout = 10\n", encoding="utf-8")
+
+    with pytest.raises(ConfigError):
+        load_config(str(config_file))
+
+
+def test_wrong_value_type_raises(tmp_path):
+    """A value of the wrong type (string where int expected) is an error."""
+    config_file = tmp_path / "badtype.toml"
+    config_file.write_text('timeout = "thirty"\n', encoding="utf-8")
+
+    with pytest.raises(ConfigError):
+        load_config(str(config_file))
+
+
+def test_non_utf8_file_raises_config_error(tmp_path):
+    """A config file that is not valid UTF-8 is a ConfigError, not a crash."""
+    config_file = tmp_path / "utf16.toml"
+    config_file.write_text("timeout = 30\n", encoding="utf-16")
+
+    with pytest.raises(ConfigError):
+        load_config(str(config_file))
+
+
+def test_utf8_bom_file_is_tolerated(tmp_path):
+    """A UTF-8 file with a BOM (common on Windows) loads normally."""
+    config_file = tmp_path / "bom.toml"
+    config_file.write_text("timeout = 30\n", encoding="utf-8-sig")
+
+    config = load_config(str(config_file))
+
+    assert config.timeout == 30

{swaggerforge-0.1.0 → swaggerforge-0.2.0}/tests/test_template.py

@@ -71,3 +71,27 @@ def test_rendered_file_has_no_duplicate_functions():
     assert len(function_names) == len(set(function_names)), (
         "Rendered file contains duplicate function definitions"
     )
+
+
+def test_build_request_call_without_timeout_unchanged():
+    """Without a timeout, the call contains no timeout argument."""
+    scenarios = _scenarios_for_tag("pet")
+    call = build_request_call(scenarios[0])
+    assert "timeout" not in call
+
+
+def test_build_request_call_with_timeout():
+    """With a timeout, the call ends with a timeout keyword argument."""
+    scenarios = _scenarios_for_tag("pet")
+    call = build_request_call(scenarios[0], timeout=30)
+    assert "timeout=30" in call
+
+
+def test_render_test_file_threads_timeout():
+    """A timeout given to render_test_file appears in every request call."""
+    scenarios = _scenarios_for_tag("pet")
+    rendered = render_test_file(
+        "test_pet.py", "http://localhost:8080", scenarios, timeout=15
+    )
+    compile(rendered, "test_pet.py", "exec")
+    assert rendered.count("timeout=15") == len(scenarios)