soaptest 0.1.0__tar.gz

soaptest-0.1.0/.gitignore

@@ -0,0 +1,23 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Tools
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Virtualenvs
+.venv/
+venv/
+env/
+
+# Environment
+.env
+
+# Claude
+.claude

soaptest-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jaey8den
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

soaptest-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: soaptest
+Version: 0.1.0
+Summary: Make SOAP services testable from pytest — point at a WSDL, get callable Python.
+Project-URL: Homepage, https://github.com/jaey8den/soap-tester
+Project-URL: Repository, https://github.com/jaey8den/soap-tester
+Project-URL: Issues, https://github.com/jaey8den/soap-tester/issues
+Author-email: jaey8den <89349331+jaey8den@users.noreply.github.com>
+License: MIT
+License-File: LICENSE
+Keywords: pytest,soap,testing,wsdl,zeep
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Requires-Dist: lxml>=5.0
+Requires-Dist: zeep>=4.2
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# soaptest
+
+Make SOAP services testable from pytest. Point it at a WSDL, get callable Python.
+
+## 30-second example
+
+```bash
+pip install soaptest
+```
+
+```python
+from soaptest import Client
+
+client = Client.from_wsdl(
+    "http://www.dataaccess.com/webservicesserver/NumberConversion.wso?WSDL"
+)
+
+# Discover what's available
+print(client.describe())
+# NumberConversionSoap @ http://www.dataaccess.com/webservicesserver/NumberConversion.wso
+#   NumberToWords(ubiNum: nonNegativeInteger) -> string
+#   NumberToDollars(dNum: decimal) -> string
+
+# Call any operation by name
+result = client.NumberToWords(ubiNum=42)
+print(result)  # "forty two "
+```
+
+## Why
+
+SOAP testing today means SoapUI (a 200 MB GUI) or hand-rolling `requests` with raw XML.
+Neither fits naturally into a pytest suite.
+
+`soaptest` is a thin Pythonic layer on top of [zeep](https://docs.python-zeep.org/).
+It gives you WSDL discovery (`describe()`) and operation dispatch (`client.OpName(**kwargs)`)
+with zero boilerplate. You write plain pytest test functions; soaptest handles the SOAP.
+
+What it does not do yet: record/replay of responses, fault translation into typed Python
+exceptions, type stubs for operations, or a pytest fixture plugin. Those are on the
+[Roadmap](#roadmap). v0.1 is intentionally minimal — get the basics right first.
+
+## Installation
+
+```bash
+pip install soaptest
+```
+
+Python 3.9+ is required. `zeep`, `lxml`, and `httpx` are installed automatically.
+
+## Usage
+
+### Discover operations
+
+```python
+from soaptest import Client
+
+client = Client.from_wsdl("https://yourservice.example.com/service?WSDL")
+print(client.describe())      # pretty-printed operation list
+ops = client.operations       # list of Operation named-tuples
+```
+
+Each `Operation` has: `name`, `input_signature`, `output_signature`, `service`, `port`, `port_url`.
+
+### Call an operation
+
+```python
+result = client.SomeOperation(param1="value", param2=123)
+```
+
+`__getattr__` dispatches to the underlying zeep service. The return value is whatever
+zeep returns (usually a `zeep.objects.*` object or a plain Python scalar). No conversion
+in v0.1 — that's a future feature.
+
+Unknown operation names raise `AttributeError`, so `hasattr(client, "Op")` works.
+
+### CLI
+
+```bash
+soaptest http://www.dataaccess.com/webservicesserver/NumberConversion.wso?WSDL
+```
+
+Prints the operation catalog to stdout and exits.
+
+### In pytest
+
+```python
+import pytest
+from soaptest import Client
+
+WSDL = "https://yourservice.example.com/service?WSDL"
+
+@pytest.fixture(scope="session")
+def soap_client():
+    return Client.from_wsdl(WSDL)
+
+def test_something(soap_client):
+    result = soap_client.SomeOperation(param="value")
+    assert result.status == "OK"
+```
+
+## Roadmap
+
+v0.1 ships the discovery layer only. Planned for later releases:
+
+- **Fault translation** — map SOAP faults to a typed `SoapFault` Python exception
+- **pytest fixture plugin** — `@pytest.fixture` helpers and a `--wsdl` CLI option
+- **Type-stub generation** — emit `.pyi` stubs so IDEs can autocomplete operations
+- **Record/replay** — record live responses to YAML cassettes; replay offline
+
+## Contributing
+
+File a bug or feature request in the issue tracker. Pull requests are welcome once
+an issue is open. For major changes, open an issue first to discuss scope.
+
+## License
+
+MIT. See LICENSE.

soaptest-0.1.0/README.md

@@ -0,0 +1,117 @@
+# soaptest
+
+Make SOAP services testable from pytest. Point it at a WSDL, get callable Python.
+
+## 30-second example
+
+```bash
+pip install soaptest
+```
+
+```python
+from soaptest import Client
+
+client = Client.from_wsdl(
+    "http://www.dataaccess.com/webservicesserver/NumberConversion.wso?WSDL"
+)
+
+# Discover what's available
+print(client.describe())
+# NumberConversionSoap @ http://www.dataaccess.com/webservicesserver/NumberConversion.wso
+#   NumberToWords(ubiNum: nonNegativeInteger) -> string
+#   NumberToDollars(dNum: decimal) -> string
+
+# Call any operation by name
+result = client.NumberToWords(ubiNum=42)
+print(result)  # "forty two "
+```
+
+## Why
+
+SOAP testing today means SoapUI (a 200 MB GUI) or hand-rolling `requests` with raw XML.
+Neither fits naturally into a pytest suite.
+
+`soaptest` is a thin Pythonic layer on top of [zeep](https://docs.python-zeep.org/).
+It gives you WSDL discovery (`describe()`) and operation dispatch (`client.OpName(**kwargs)`)
+with zero boilerplate. You write plain pytest test functions; soaptest handles the SOAP.
+
+What it does not do yet: record/replay of responses, fault translation into typed Python
+exceptions, type stubs for operations, or a pytest fixture plugin. Those are on the
+[Roadmap](#roadmap). v0.1 is intentionally minimal — get the basics right first.
+
+## Installation
+
+```bash
+pip install soaptest
+```
+
+Python 3.9+ is required. `zeep`, `lxml`, and `httpx` are installed automatically.
+
+## Usage
+
+### Discover operations
+
+```python
+from soaptest import Client
+
+client = Client.from_wsdl("https://yourservice.example.com/service?WSDL")
+print(client.describe())      # pretty-printed operation list
+ops = client.operations       # list of Operation named-tuples
+```
+
+Each `Operation` has: `name`, `input_signature`, `output_signature`, `service`, `port`, `port_url`.
+
+### Call an operation
+
+```python
+result = client.SomeOperation(param1="value", param2=123)
+```
+
+`__getattr__` dispatches to the underlying zeep service. The return value is whatever
+zeep returns (usually a `zeep.objects.*` object or a plain Python scalar). No conversion
+in v0.1 — that's a future feature.
+
+Unknown operation names raise `AttributeError`, so `hasattr(client, "Op")` works.
+
+### CLI
+
+```bash
+soaptest http://www.dataaccess.com/webservicesserver/NumberConversion.wso?WSDL
+```
+
+Prints the operation catalog to stdout and exits.
+
+### In pytest
+
+```python
+import pytest
+from soaptest import Client
+
+WSDL = "https://yourservice.example.com/service?WSDL"
+
+@pytest.fixture(scope="session")
+def soap_client():
+    return Client.from_wsdl(WSDL)
+
+def test_something(soap_client):
+    result = soap_client.SomeOperation(param="value")
+    assert result.status == "OK"
+```
+
+## Roadmap
+
+v0.1 ships the discovery layer only. Planned for later releases:
+
+- **Fault translation** — map SOAP faults to a typed `SoapFault` Python exception
+- **pytest fixture plugin** — `@pytest.fixture` helpers and a `--wsdl` CLI option
+- **Type-stub generation** — emit `.pyi` stubs so IDEs can autocomplete operations
+- **Record/replay** — record live responses to YAML cassettes; replay offline
+
+## Contributing
+
+File a bug or feature request in the issue tracker. Pull requests are welcome once
+an issue is open. For major changes, open an issue first to discuss scope.
+
+## License
+
+MIT. See LICENSE.

soaptest-0.1.0/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "soaptest"
+version = "0.1.0"
+description = "Make SOAP services testable from pytest — point at a WSDL, get callable Python."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "jaey8den", email = "89349331+jaey8den@users.noreply.github.com" }]
+keywords = ["soap", "wsdl", "testing", "pytest", "zeep"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Testing",
+  "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = [
+  "zeep>=4.2",
+  "lxml>=5.0",
+  "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+  "ruff>=0.6",
+  "mypy>=1.10",
+]
+
+[project.scripts]
+soaptest = "soaptest.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/jaey8den/soap-tester"
+Repository = "https://github.com/jaey8den/soap-tester"
+Issues = "https://github.com/jaey8den/soap-tester/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/soaptest"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.mypy]
+strict = true
+python_version = "3.11"
+
+[[tool.mypy.overrides]]
+module = "zeep.*"
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+  "integration: marks tests that require network access to a live WSDL endpoint",
+]

soaptest-0.1.0/src/soaptest/__init__.py

@@ -0,0 +1,8 @@
+"""soaptest — make SOAP services testable from pytest."""
+
+from __future__ import annotations
+
+from soaptest.client import Client
+
+__all__ = ["Client"]
+__version__ = "0.1.0"

soaptest-0.1.0/src/soaptest/__main__.py

@@ -0,0 +1,26 @@
+"""CLI entry-point: ``soaptest <wsdl-url>`` prints the operation catalog."""
+
+from __future__ import annotations
+
+import sys
+
+
+def main() -> None:
+    """Print the operation catalog for a given WSDL URL."""
+    if len(sys.argv) < 2:  # noqa: PLR2004
+        print("Usage: soaptest <wsdl-url-or-path>", file=sys.stderr)
+        sys.exit(1)
+
+    from soaptest import Client  # local import keeps startup fast when --help is enough
+
+    url = sys.argv[1]
+    try:
+        client = Client.from_wsdl(url)
+        client.describe()
+    except Exception as exc:  # noqa: BLE001
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

soaptest-0.1.0/src/soaptest/client/__init__.py

@@ -0,0 +1,7 @@
+"""soaptest.client — re-exports the public Client class."""
+
+from __future__ import annotations
+
+from soaptest.client.client import Client
+
+__all__ = ["Client"]

soaptest-0.1.0/src/soaptest/client/client.py

@@ -0,0 +1,107 @@
+"""Client: thin Pythonic wrapper around zeep for SOAP service discovery and calling."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from soaptest.client.introspect import Operation, build_catalog, format_catalog
+
+
+class Client:
+    """A thin wrapper around a zeep client for a single WSDL.
+
+    Typical usage::
+
+        from soaptest import Client
+
+        client = Client.from_wsdl("http://example.com/service?WSDL")
+        print(client.describe())
+        result = client.SomeOperation(param="value")
+    """
+
+    def __init__(self, zeep_client: Any, catalog: list[Operation]) -> None:
+        # Store under mangled names so __getattr__ never intercepts them
+        self._zeep_client = zeep_client
+        self._catalog = catalog
+        self._catalog_index: dict[str, Operation] = {op.name: op for op in catalog}
+
+    # ------------------------------------------------------------------
+    # Construction
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def from_wsdl(cls, url: str) -> Client:
+        """Create a Client by loading a WSDL from *url* (http/https or file path).
+
+        Args:
+            url: URL or local file path to the WSDL document.
+
+        Returns:
+            A ready-to-use Client instance.
+        """
+        import zeep  # local import so zeep errors surface at call time, not module import
+
+        zeep_client: Any = zeep.Client(wsdl=url)  # type: ignore[no-untyped-call]
+        catalog = build_catalog(zeep_client)
+        return cls(zeep_client, catalog)
+
+    # ------------------------------------------------------------------
+    # Discovery
+    # ------------------------------------------------------------------
+
+    @property
+    def operations(self) -> list[Operation]:
+        """Read-only list of Operation named-tuples discovered from the WSDL."""
+        return list(self._catalog)
+
+    def describe(self) -> str:
+        """Return (and print) a formatted listing of all available operations.
+
+        The output groups operations by service/port::
+
+            NumberConversionSoap @ https://...
+              NumberToWords(ubiNum: nonNegativeInteger) -> string
+              NumberToDollars(dNum: decimal) -> string
+        """
+        text = format_catalog(self._catalog)
+        print(text)
+        return text
+
+    # ------------------------------------------------------------------
+    # Dynamic dispatch
+    # ------------------------------------------------------------------
+
+    def __getattr__(self, name: str) -> Any:
+        """Enable ``client.OperationName(**kwargs)`` for any catalogued operation.
+
+        Raises:
+            AttributeError: if *name* is not a known WSDL operation, so that
+                ``hasattr(client, name)`` works correctly.
+        """
+        # _catalog_index is set in __init__ via object.__setattr__-free assignment,
+        # so it IS in __dict__. But during pickling/copy Python may call __getattr__
+        # before __dict__ is fully restored — guard against that.
+        catalog_index = self.__dict__.get("_catalog_index", {})
+        if name not in catalog_index:
+            raise AttributeError(
+                f"{type(self).__name__!r} object has no attribute {name!r}. "
+                f"Available operations: {list(catalog_index)}"
+            )
+
+        service = self._zeep_client.service
+
+        def _call(**kwargs: Any) -> Any:
+            method = getattr(service, name)
+            return method(**kwargs)
+
+        _call.__name__ = name
+        _call.__qualname__ = f"Client.{name}"
+        return _call
+
+    # ------------------------------------------------------------------
+    # Representation
+    # ------------------------------------------------------------------
+
+    def __repr__(self) -> str:
+        n = len(self._catalog)
+        return f"<soaptest.Client operations={n}>"

soaptest-0.1.0/src/soaptest/client/introspect.py

@@ -0,0 +1,149 @@
+"""Operation catalog: walk zeep's WSDL bindings and build a structured list of operations.
+
+Note: `binding._operations` is technically a private zeep API. It is the only
+programmatic way to enumerate operations without parsing raw WSDL XML ourselves.
+TODO: revisit if zeep exposes a stable public introspection API in a future release.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from collections import defaultdict
+from typing import NamedTuple
+
+
+class Operation(NamedTuple):
+    """A single WSDL operation with its signatures and provenance."""
+
+    name: str
+    input_signature: str
+    output_signature: str
+    service: str
+    port: str
+    port_url: str
+
+
+def _format_element(element: object) -> str:
+    """Return a human-readable type string for a zeep WSDL element."""
+    try:
+        # zeep elements have a .type attribute whose name we can read
+        type_obj = getattr(element, "type", None)
+        if type_obj is not None:
+            qname = getattr(type_obj, "name", None)
+            if qname:
+                return str(qname)
+        # Fall back to the element's own name
+        name = getattr(element, "name", None)
+        if name:
+            return str(name)
+    except Exception:  # noqa: BLE001
+        pass
+    return "any"
+
+
+def _input_signature(op: object) -> str:
+    """Produce 'param: type, ...' from a zeep operation's input message."""
+    try:
+        op_input = getattr(op, "input", None)
+        body = getattr(op_input, "body", None)
+        if body is None:
+            return ""
+        elements = getattr(body, "type", body)
+        # zeep exposes elements as an iterable of (name, element) pairs
+        parts = getattr(elements, "elements", None)
+        if parts:
+            return ", ".join(f"{n}: {_format_element(e)}" for n, e in parts)
+        # Some operations have a flat type with no sub-elements (scalar input)
+        name = getattr(body, "name", None)
+        if name:
+            return f"{name}: {_format_element(body)}"
+    except (AttributeError, TypeError):
+        pass
+    return ""
+
+
+def _output_signature(op: object) -> str:
+    """Produce a type string from a zeep operation's output message."""
+    try:
+        op_output = getattr(op, "output", None)
+        body = getattr(op_output, "body", None)
+        if body is None:
+            return "any"
+        elements = getattr(body, "type", body)
+        parts = getattr(elements, "elements", None)
+        if parts:
+            pairs = list(parts)
+            if len(pairs) == 1:
+                return _format_element(pairs[0][1])
+            return ", ".join(f"{n}: {_format_element(e)}" for n, e in pairs)
+        return _format_element(body)
+    except (AttributeError, TypeError):
+        pass
+    return "any"
+
+
+def build_catalog(zeep_client: object) -> list[Operation]:
+    """Walk zeep_client.wsdl.services to build a list of Operation records."""
+    operations: list[Operation] = []
+
+    wsdl = getattr(zeep_client, "wsdl", None)
+    if wsdl is None:
+        return operations
+
+    services = getattr(wsdl, "services", {})
+    for service_name, service in services.items():
+        ports = getattr(service, "ports", {})
+        for port_name, port in ports.items():
+            binding = getattr(port, "binding", None)
+            if binding is None:
+                continue
+            # _operations: dict[str, zeep.wsdl.definitions.Operation]
+            # Private API — see module docstring.
+            raw_ops = getattr(binding, "_operations", {})
+            port_url: str = ""
+            with contextlib.suppress(AttributeError, TypeError):
+                port_url = str(port.binding_options.get("address", ""))
+            for op_name, op in raw_ops.items():
+                operations.append(
+                    Operation(
+                        name=str(op_name),
+                        input_signature=_input_signature(op),
+                        output_signature=_output_signature(op),
+                        service=str(service_name),
+                        port=str(port_name),
+                        port_url=port_url,
+                    )
+                )
+
+    return operations
+
+
+def format_catalog(operations: list[Operation]) -> str:
+    """Render the operation list as a human-readable multi-line string.
+
+    Output format::
+
+        ServiceName @ https://endpoint.example.com
+          OperationA(param: type) -> returnType
+          OperationB() -> returnType
+    """
+    if not operations:
+        return "(no operations found)"
+
+    # Group by (service, port) preserving insertion order
+    groups: dict[tuple[str, str, str], list[Operation]] = defaultdict(list)
+    for op in operations:
+        groups[(op.service, op.port, op.port_url)].append(op)
+
+    lines: list[str] = []
+    for (_service, port, url), ops in groups.items():
+        header = f"{port}"
+        if url:
+            header += f" @ {url}"
+        lines.append(header)
+        for op in ops:
+            sig = op.input_signature or ""
+            ret = op.output_signature or "any"
+            lines.append(f"  {op.name}({sig}) -> {ret}")
+
+    return "\n".join(lines)

soaptest-0.1.0/tests/conftest.py

@@ -0,0 +1,10 @@
+"""pytest configuration: register custom markers."""
+
+import pytest
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "integration: marks tests that require network access to a live WSDL endpoint",
+    )

soaptest-0.1.0/tests/test_discovery.py

@@ -0,0 +1,92 @@
+"""Integration tests against the public NumberConversion WSDL.
+
+Run all tests:       pytest
+Skip network tests:  pytest -m "not integration"
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from soaptest import Client
+
+WSDL = "http://www.dataaccess.com/webservicesserver/NumberConversion.wso?WSDL"
+
+
+@pytest.mark.integration
+def test_describe_lists_operations() -> None:
+    """describe() output must mention both known operations."""
+    client = Client.from_wsdl(WSDL)
+    output = client.describe()
+    assert "NumberToWords" in output
+    assert "NumberToDollars" in output
+
+
+@pytest.mark.integration
+def test_call_number_to_words() -> None:
+    """Calling NumberToWords(1234) should return a string containing 'thousand'."""
+    client = Client.from_wsdl(WSDL)
+    result = client.NumberToWords(ubiNum=1234)
+    assert "thousand" in str(result).lower()
+
+
+@pytest.mark.integration
+def test_operations_property_is_non_empty() -> None:
+    """client.operations must return at least the two known operations."""
+    client = Client.from_wsdl(WSDL)
+    names = [op.name for op in client.operations]
+    assert "NumberToWords" in names
+    assert "NumberToDollars" in names
+
+
+def test_getattr_raises_for_unknown_operation() -> None:
+    """Accessing a non-existent operation must raise AttributeError (not any other error)."""
+
+    class _FakeOp:
+        name = "FakeOp"
+        input_signature = ""
+        output_signature = "str"
+        service = "FakeSvc"
+        port = "FakePort"
+        port_url = ""
+
+    from soaptest.client.introspect import Operation
+
+    fake_op = Operation(
+        name="FakeOp",
+        input_signature="",
+        output_signature="str",
+        service="FakeSvc",
+        port="FakePort",
+        port_url="",
+    )
+
+    # Build a Client without touching the network
+    import unittest.mock as mock
+
+    fake_zeep = mock.MagicMock()
+    client = Client(fake_zeep, [fake_op])
+
+    with pytest.raises(AttributeError):
+        _ = client.NonExistentOperation
+
+
+def test_hasattr_returns_false_for_unknown_operation() -> None:
+    """hasattr() must return False (not raise) for unknown operations."""
+    import unittest.mock as mock
+
+    from soaptest.client.introspect import Operation
+
+    fake_op = Operation(
+        name="FakeOp",
+        input_signature="",
+        output_signature="str",
+        service="FakeSvc",
+        port="FakePort",
+        port_url="",
+    )
+    fake_zeep = mock.MagicMock()
+    client = Client(fake_zeep, [fake_op])
+
+    assert hasattr(client, "FakeOp") is True
+    assert hasattr(client, "DoesNotExist") is False