schemathesis 4.0.0a8__tar.gz → 4.0.0a9__tar.gz

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/.github/workflows/build.yml

@@ -64,7 +64,7 @@ jobs:
         run: uvx --with="tox" --with="tox-gh-actions" --with="tox-uv" tox
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5.4.0
+        uses: codecov/codecov-action@v5.4.2
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
 

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.28.13
+        uses: github/codeql-action/init@v3.28.17
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -49,7 +49,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3.28.13
+        uses: github/codeql-action/autobuild@v3.28.17
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -63,4 +63,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.28.13
+        uses: github/codeql-action/analyze@v3.28.17

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/.pre-commit-config.yaml

@@ -32,12 +32,12 @@ repos:
         additional_dependencies: [types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.2
+    rev: v0.11.8
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.2
+    rev: v0.11.8
     hooks:
       - id: ruff
 

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.0.0-alpha.8...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.0.0-alpha.9...HEAD) - TBD
+
+## [4.0.0-alpha.9](https://github.com/schemathesis/schemathesis/compare/v4.0.0-alpha.8...v4.0.0-alpha.9) - 2025-05-06
+
+
+### :wrench: Changed
+
+- Support basic canonicalisation of regex patterns. For example, `[\\W\\w]` could be replaced with `.` in some scenarios.
+
+### :bug: Fixed
+
+- Missing reference resolution scope when serializing `multipart` payloads. [#2776](https://github.com/schemathesis/schemathesis/issues/2776)
+- Compatibility with hypothesis >= 6.131.4. [#2797](https://github.com/schemathesis/schemathesis/issues/2797)
+- Cover more nested `enum` values during the coverage phase.
+- Avoid extremely slow generation of large strings combined with `patterns` during the coverage phase.
+- Generate objects during the coverage phase even if `"type": "object"` is not present.
+- Generate empty strings in more cases during the coverage phase.
+- Generate nested `items` during the coverage phase.
+- Generate large arrays during the coverage phase.
 
 ## [4.0.0-alpha.8](https://github.com/schemathesis/schemathesis/compare/v4.0.0-alpha.7...v4.0.0-alpha.8) - 2025-04-05
 

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.0a8
+Version: 4.0.0a9
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/docs/reference/configuration.md

@@ -3,7 +3,7 @@
 This reference covers all the configuration options available in `schemathesis.toml`. The settings are organized into two main categories:
 
 - **Global**: These control CLI behavior, output formatting, and overall test execution. They are defined at the top level and affect the CLI invocation.
-- **Per-Project**: These let you customize configurations for individual API projects. If project-level settings are placed at the top level (without a `[project.<name>]` namespace), they are used as defaults for any tested project.
+- **Per-Project**: These let you customize configurations for individual API projects. If project-level settings are placed at the top level (without a `[[project]]` namespace), they are used as defaults for any tested project.
 
 ## Configuration Resolution
 
@@ -13,7 +13,7 @@ Schemathesis applies settings in the following hierarchy (from highest to lowest
 2. Operation-specific phase settings
 3. Global phase settings (e.g., `[phases.fuzzing]`)
 4. Operation-level settings (e.g., `[[operations]]`)
-5. Project-level settings (e.g., `[[projects]]`)
+5. Project-level settings (e.g., `[[project]]`)
 6. Global settings
 
 ## Environment Variable Substitution
@@ -93,6 +93,19 @@ parameters = { "path.user_id" = 42, "query.user_id" = 100 }
     suppress-health-check = ["too_slow", "data_too_large"]
     ```
 
+#### `seed`
+
+!!! note ""
+
+    **Type:** `Integer`  
+    **Default:** `null`  
+
+    Random seed for reproducible test runs. Setting the same seed value will result in the same sequence of generated test cases.
+
+    ```toml
+    seed = 42
+    ```
+
 #### `max-failures`
 
 !!! note ""
@@ -168,7 +181,7 @@ parameters = { "path.user_id" = 42, "query.user_id" = 100 }
 
 ### Output
 
-#### `output.sanitize`
+#### `output.sanitization.enabled`
 
 !!! note ""
 
@@ -178,22 +191,106 @@ parameters = { "path.user_id" = 42, "query.user_id" = 100 }
     Controls automatic sanitization of output data to obscure sensitive information.
 
     ```toml
-    [output]
-    sanitize = false
+    [output.sanitization]
+    enabled = false
+    ```
+
+#### `output.sanitization.keys-to-sanitize`
+
+!!! note ""
+
+    **Type**: `List[String]`  
+    **Default**: List of common sensitive keys (auth tokens, passwords, etc.)  
+
+    Specific keys that will be automatically sanitized in output data.
+
+    ```toml
+    [output.sanitization]
+    keys-to-sanitize = ["password", "token", "auth"]
+    ```
+
+#### `output.sanitization.sensitive-markers`
+
+!!! note ""
+
+    **Type**: `List[String]`  
+    **Default**: `["token", "key", "secret", "password", "auth", "session", "passwd", "credential"]`  
+
+    Substrings that indicate a key might contain sensitive information requiring sanitization.
+
+    ```toml
+    [output.sanitization]
+    sensitive-markers = ["secret", "auth", "key"]
+    ```
+
+#### `output.sanitization.replacement`
+
+!!! note ""
+
+    **Type**: `String`  
+    **Default**: `"[Filtered]"`  
+
+    The text used to replace sensitive data in output.
+
+    ```toml
+    [output.sanitization]
+    replacement = "***REDACTED***"
     ```
 
-#### `output.truncate`
+#### `output.truncation.enabled`
 
 !!! note ""
 
     **Type**: `Boolean`  
     **Default**: `true`  
 
-    Truncates long output in error messages for improved readability.
+    Controls whether large output data should be truncated.
+
+    ```toml
+    [output.truncation]
+    enabled = false
+    ```
+
+#### `output.truncation.max-payload-size`
+
+!!! note ""
+
+    **Type**: `Integer`  
+    **Default**: `512`  
+
+    Maximum size in bytes for payloads before truncation occurs.
 
     ```toml
-    [output]
-    truncate = false
+    [output.truncation]
+    max-payload-size = 1024
+    ```
+
+#### `output.truncation.max-lines`
+
+!!! note ""
+
+    **Type**: `Integer`  
+    **Default**: `10`  
+
+    Maximum number of lines to display for multi-line output.
+
+    ```toml
+    [output.truncation]
+    max-lines = 20
+    ```
+
+#### `output.truncation.max-width`
+
+!!! note ""
+
+    **Type**: `Integer`  
+    **Default**: `80`  
+
+    Maximum width in characters for each line before horizontal truncation.
+
+    ```toml
+    [output.truncation]
+    max-width = 100
     ```
 
 ## Project Settings
@@ -211,7 +308,7 @@ These settings can only be applied at the project level.
 
     ```toml
     # Optionally under a named project
-    # [[projects]]
+    # [[project]]
     base-url = "https://api.example.com"
     ```
 
@@ -229,7 +326,7 @@ These settings can only be applied at the project level.
     hooks = "myproject.tests.hooks"
     
     # Or project-specific hooks
-    # [[projects]]
+    # [[project]]
     # hooks = "myproject.payments.hooks"
     ```
 
@@ -329,6 +426,20 @@ These settings can only be applied at the project level.
     unexpected-methods = ["PATCH"]
     ```
 
+#### `phases.<phase>.checks`
+
+!!! note "" 
+
+    **Type**: `Object`  
+    **Default**: `{}`  
+
+    Phase-specific overrides for checks.
+
+    ```toml
+    [phases.coverage.checks]
+    not_a_server_error.enabled = false
+    ```
+
 ### Authentication
 
 #### `auth.basic`
@@ -625,20 +736,6 @@ The following settings control how Schemathesis generates test data for your API
     max-examples = 200
     ```
 
-#### `generation.seed`
-
-!!! note ""
-
-    **Type:** `Integer`  
-    **Default:** `null`  
-
-    Random seed for reproducible test runs. Setting the same seed value will result in the same sequence of generated test cases.
-
-    ```toml
-    [generation]
-    seed = 42
-    ```
-
 #### `generation.no-shrink`
 
 !!! note ""
@@ -681,6 +778,21 @@ The following settings control how Schemathesis generates test data for your API
     allow-x00 = false
     ```
 
+
+#### `generation.exclude-header-characters`
+
+!!! note ""
+
+    **Type:** `String`  
+    **Default:** `\r\n`  
+
+    All characters from the given strings will be excluded from generated header values.
+
+    ```toml
+    [generation]
+    exclude-header-characters = "\r\nABC"
+    ```
+
 #### `generation.codec`
 
 !!! note ""

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/docs/using/configuration.md

@@ -83,7 +83,7 @@ The basic setting corresponds to the `--auth` CLI option, while bearer tokens ca
 
 !!! tip "Operation-specific Authentication"
 
-    You can also override auth on the [per-operation basic](#operation-specific-authentication).
+    You can also override auth on the [per-operation basis](#operation-specific-authentication).
 
 ### OpenAPI Security Schemes
 
@@ -443,6 +443,8 @@ request-timeout = 5.0
 phases.fuzzing.generation.max-examples = 200 
 # Reduce examples for stateful tests
 phases.stateful.generation.max-examples = 30
+# Disable a check for examples tests
+phases.examples.checks.not_a_server_error.enabled = false
 ```
 ### Resolution Order for Phase-Operation Settings
 
@@ -540,10 +542,10 @@ Schemathesis lets you configure multiple API projects in one file—a handy feat
 
 ### Defining Projects
 
-Define projects in the `[[projects]]` section by matching the API's title:
+Define projects in `[[project]]` tables by matching the API's title:
 
 ```toml
-[[projects]]
+[[project]]
 # Projects are matched by the API schema's `info.title``
 title = "Payment Processing API"
 base-url = "https://payments.example.com"
@@ -556,14 +558,14 @@ Schemathesis checks the `info.title` field of the API schema to apply the corres
 Override global defaults with project-specific settings:
 
 ```toml
-[[projects]]
+[[project]]
 title = "Payment Processing API"
 base-url = "https://payments.example.com"
 workers = 4
 generation.max-examples = 200
 hooks = "test.config.hooks.example"
 
-[[projects]]
+[[project]]
 title = "User Management API"
 base-url = "https://users.example.com"
 workers = 2
@@ -574,15 +576,15 @@ workers = 2
 Customize operations within a project:
 
 ```toml
-[[projects]]
+[[project]]
 title = "Payment Processing API"
 
-[[projects.operations]]
+[[project.operations]]
 include-name = "POST /payments"
 generation.max-examples = 80
 headers = { "X-Idempotency-Key" = "${IDEMPOTENCY_KEY}" }
 
-[[projects.operations]]
+[[project.operations]]
 include-tag = "slow"
 request-timeout = 10.0
 ```
@@ -603,20 +605,20 @@ When using projects, settings are applied in this order:
 generation.max-examples = 50
 workers = 2
 
-[[projects]]
+[[project]]
 title = "Payment Processing API"
 base-url = "https://payments.example.com"
 generation.max-examples = 100
 
 # Operations for payments
-[[projects.operations]]
+[[project.operations]]
 include-name = "POST /payments"
 generation.max-examples = 200
 parameters = { amount = [10, 100, 1000] }
 checks.positive_data_acceptance.expected-statuses = [200, 201]
 
 # Users project settings
-[[projects]]
+[[project]]
 title = "User Management API"
 base-url = "https://users.example.com"
 ```

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.0.0-alpha.8"
+version = "4.0.0-alpha.9"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-4.0.0a8 → schemathesis-4.0.0a9}/src/schemathesis/generation/coverage.py

@@ -37,6 +37,8 @@ def json_recursive_strategy(strategy: st.SearchStrategy) -> st.SearchStrategy:
 
 
 BUFFER_SIZE = 8 * 1024
+NEGATIVE_MODE_MAX_LENGTH_WITH_PATTERN = 100
+NEGATIVE_MODE_MAX_ITEMS = 15
 FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(_replace_zero_with_nonzero)
 NUMERIC_STRATEGY: st.SearchStrategy = st.integers() | FLOAT_STRATEGY
 JSON_STRATEGY: st.SearchStrategy = st.recursive(
@@ -257,6 +259,9 @@ def _cover_positive_for_type(
     if ty == "object" or ty == "array":
         template_schema = _get_template_schema(schema, ty)
         template = ctx.generate_from_schema(template_schema)
+    elif "properties" in schema or "required" in schema:
+        template_schema = _get_template_schema(schema, "object")
+        template = ctx.generate_from_schema(template_schema)
     else:
         template = None
     if GenerationMode.POSITIVE in ctx.generation_modes:
@@ -295,6 +300,8 @@ def _cover_positive_for_type(
                 yield from _positive_array(ctx, schema, cast(list, template))
             elif ty == "object":
                 yield from _positive_object(ctx, schema, cast(dict, template))
+        elif "properties" in schema or "required" in schema:
+            yield from _positive_object(ctx, schema, cast(dict, template))
 
 
 @contextmanager
@@ -387,41 +394,58 @@ def cover_schema_iter(
                             yield value_
                             seen.add(k)
                 elif key == "minLength" and 0 < value < BUFFER_SIZE:
-                    with suppress(InvalidArgument):
-                        min_length = max_length = value - 1
-                        new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
-                        new_schema.setdefault("type", "string")
-                        if "pattern" in new_schema:
-                            new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
-                            if new_schema["pattern"] == schema["pattern"]:
-                                # Pattern wasn't updated, try to generate a valid value then shrink the string to the required length
-                                del new_schema["minLength"]
-                                del new_schema["maxLength"]
-                                value = ctx.generate_from_schema(new_schema)[:max_length]
-                            else:
-                                value = ctx.generate_from_schema(new_schema)
-                        else:
-                            value = ctx.generate_from_schema(new_schema)
+                    if value == 1:
+                        # In this case, the only possible negative string is an empty one
+                        # The `pattern` value may require an non-empty one and the generation will fail
+                        # However, it is fine to violate `pattern` here as it is negative string generation anyway
+                        value = ""
                         k = _to_hashable_key(value)
                         if k not in seen:
                             yield NegativeValue(
                                 value, description="String smaller than minLength", location=ctx.current_path
                             )
                             seen.add(k)
+                    else:
+                        with suppress(InvalidArgument):
+                            min_length = max_length = value - 1
+                            new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
+                            new_schema.setdefault("type", "string")
+                            if "pattern" in new_schema:
+                                new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
+                                if new_schema["pattern"] == schema["pattern"]:
+                                    # Pattern wasn't updated, try to generate a valid value then shrink the string to the required length
+                                    del new_schema["minLength"]
+                                    del new_schema["maxLength"]
+                                    value = ctx.generate_from_schema(new_schema)[:max_length]
+                                else:
+                                    value = ctx.generate_from_schema(new_schema)
+                            else:
+                                value = ctx.generate_from_schema(new_schema)
+                            k = _to_hashable_key(value)
+                            if k not in seen:
+                                yield NegativeValue(
+                                    value, description="String smaller than minLength", location=ctx.current_path
+                                )
+                                seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
                     try:
                         min_length = max_length = value + 1
                         new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
                         new_schema.setdefault("type", "string")
                         if "pattern" in new_schema:
-                            new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
-                            if new_schema["pattern"] == schema["pattern"]:
-                                # Pattern wasn't updated, try to generate a valid value then extend the string to the required length
-                                del new_schema["minLength"]
-                                del new_schema["maxLength"]
-                                value = ctx.generate_from_schema(new_schema).ljust(max_length, "0")
-                            else:
+                            if value > NEGATIVE_MODE_MAX_LENGTH_WITH_PATTERN:
+                                # Large `maxLength` value can be extremely slow to generate when combined with `pattern`
+                                del new_schema["pattern"]
                                 value = ctx.generate_from_schema(new_schema)
+                            else:
+                                new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
+                                if new_schema["pattern"] == schema["pattern"]:
+                                    # Pattern wasn't updated, try to generate a valid value then extend the string to the required length
+                                    del new_schema["minLength"]
+                                    del new_schema["maxLength"]
+                                    value = ctx.generate_from_schema(new_schema).ljust(max_length, "0")
+                                else:
+                                    value = ctx.generate_from_schema(new_schema)
                         else:
                             value = ctx.generate_from_schema(new_schema)
                         k = _to_hashable_key(value)
@@ -438,10 +462,22 @@ def cover_schema_iter(
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
                 elif key == "maxItems" and isinstance(value, int) and value < BUFFER_SIZE:
-                    try:
-                        # Force the array to have one more item than allowed
-                        new_schema = {**schema, "minItems": value + 1, "maxItems": value + 1, "type": "array"}
+                    if value > NEGATIVE_MODE_MAX_ITEMS:
+                        # It could be extremely slow to generate large arrays
+                        # Generate values up to the limit and reuse them to construct the final array
+                        new_schema = {
+                            **schema,
+                            "minItems": NEGATIVE_MODE_MAX_ITEMS,
+                            "maxItems": NEGATIVE_MODE_MAX_ITEMS,
+                            "type": "array",
+                        }
                         array_value = ctx.generate_from_schema(new_schema)
+                        # Extend the array to be of length value + 1 by repeating its own elements
+                        diff = value + 1 - len(array_value)
+                        if diff > 0:
+                            array_value += (
+                                array_value * (diff // len(array_value)) + array_value[: diff % len(array_value)]
+                            )
                         k = _to_hashable_key(array_value)
                         if k not in seen:
                             yield NegativeValue(
@@ -450,8 +486,21 @@ def cover_schema_iter(
                                 location=ctx.current_path,
                             )
                             seen.add(k)
-                    except (InvalidArgument, Unsatisfiable):
-                        pass
+                    else:
+                        try:
+                            # Force the array to have one more item than allowed
+                            new_schema = {**schema, "minItems": value + 1, "maxItems": value + 1, "type": "array"}
+                            array_value = ctx.generate_from_schema(new_schema)
+                            k = _to_hashable_key(array_value)
+                            if k not in seen:
+                                yield NegativeValue(
+                                    array_value,
+                                    description="Array with more items than allowed by maxItems",
+                                    location=ctx.current_path,
+                                )
+                                seen.add(k)
+                        except (InvalidArgument, Unsatisfiable):
+                            pass
                 elif key == "minItems" and isinstance(value, int) and value > 0:
                     try:
                         # Force the array to have one less item than the minimum
@@ -683,19 +732,22 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
 
     if example or examples or default:
         if example:
+            seen.add(_to_hashable_key(example))
             yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
+                seen.add(_to_hashable_key(example))
                 yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
         ):
+            seen.add(_to_hashable_key(default))
             yield PositiveValue(default, description="Default value")
     else:
         yield PositiveValue(template, description="Valid array")
-    seen.add(len(template))
+    seen.add(_to_hashable_key(template))
 
     # Boundary and near-boundary sizes
     min_items = schema.get("minItems")
@@ -706,19 +758,19 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
         # One item more than minimum if possible
         larger = min_items + 1
         if larger not in seen and (max_items is None or larger <= max_items):
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger}),
-                description="Near-boundary items array",
-            )
-            seen.add(larger)
+            value = ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Near-boundary items array")
 
     if max_items is not None:
         if max_items < BUFFER_SIZE and max_items not in seen:
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minItems": max_items}),
-                description="Maximum items array",
-            )
-            seen.add(max_items)
+            value = ctx.generate_from_schema({**schema, "minItems": max_items})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Maximum items array")
 
         # One item smaller than maximum if possible
         smaller = max_items - 1
@@ -728,11 +780,26 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
             and smaller not in seen
             and (min_items is None or smaller >= min_items)
         ):
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller}),
-                description="Near-boundary items array",
-            )
-            seen.add(smaller)
+            value = ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Near-boundary items array")
+
+    if "items" in schema and "enum" in schema["items"] and isinstance(schema["items"]["enum"], list) and max_items != 0:
+        # Ensure there is enough items to pass `minItems` if it is specified
+        length = min_items or 1
+        for variant in schema["items"]["enum"]:
+            value = [variant] * length
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Enum value from available for items array")
+    elif min_items is None and max_items is None and "items" in schema and isinstance(schema["items"], dict):
+        # Otherwise only an empty array is generated
+        sub_schema = schema["items"]
+        for item in cover_schema_iter(ctx, sub_schema):
+            yield PositiveValue([item.value], description=f"Single-item array: {item.description}")
 
 
 def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator[GeneratedValue, None, None]: