Skip to content

LCORE-2400: tests for exclusiveMinimum and anyOf #1834

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
tisnik merged 1 commit into from
Jun 2, 2026
Merged

LCORE-2400: tests for exclusiveMinimum and anyOf #1834

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
101 changes: 101 additions & 0 deletions tests/unit/utils/test_schema_dumper.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -90,6 +90,107 @@ def test_recursive_recurse_into_subdicts() -> None:
assert result is not original


def test_exclusive_minimum_handling_positive_value() -> None:
"""Test how minimum integer value description is transformed by recursive_update function."""
original = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "exclusiveMinimum": 100},
},
}
expected = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "minimum": 100},
},
}

# perform the update
result = recursive_update(original)

# non-empty dict with known content should be returned
assert result == expected

# ensure a new dict is returned, not the same object
assert result is not original


def test_exclusive_minimum_handling_zero_value() -> None:
"""Test how minimum integer value description is transformed by recursive_update function."""
original = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "exclusiveMinimum": 0},
},
}
expected = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "minimum": 0},
},
}

# perform the update
result = recursive_update(original)

# non-empty dict with known content should be returned
assert result == expected

# ensure a new dict is returned, not the same object
assert result is not original


def test_exclusive_minimum_handling_negative_value() -> None:
"""Test how minimum integer value description is transformed by recursive_update function."""
original = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "exclusiveMinimum": -100},
},
}
expected = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "minimum": -100},
},
}

# perform the update
result = recursive_update(original)

# non-empty dict with known content should be returned
assert result == expected

# ensure a new dict is returned, not the same object
assert result is not original

Comment on lines +93 to +172

@coderabbitai coderabbitai Bot Jun 2, 2026

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Consider using pytest.mark.parametrize to reduce code duplication.

The three exclusiveMinimum tests differ only by the test value (100, 0, -100). You can consolidate them into a single parametrized test to improve maintainability and make it easier to add more test cases.

♻️ Proposed refactor using parametrization 
-def test_exclusive_minimum_handling_positive_value() -> None:
-    """Test how minimum integer value description is transformed by recursive_update function."""
-    original = {
-        "type": "object",
-        "properties": {
-            "name": {"type": "string"},
-            "age": {"type": "integer", "exclusiveMinimum": 100},
-        },
-    }
-    expected = {
-        "type": "object",
-        "properties": {
-            "name": {"type": "string"},
-            "age": {"type": "integer", "minimum": 100},
-        },
-    }
-
-    # perform the update
-    result = recursive_update(original)
-
-    # non-empty dict with known content should be returned
-    assert result == expected
-
-    # ensure a new dict is returned, not the same object
-    assert result is not original
-
-
-def test_exclusive_minimum_handling_zero_value() -> None:
-    """Test how minimum integer value description is transformed by recursive_update function."""
-    original = {
-        "type": "object",
-        "properties": {
-            "name": {"type": "string"},
-            "age": {"type": "integer", "exclusiveMinimum": 0},
-        },
-    }
-    expected = {
-        "type": "object",
-        "properties": {
-            "name": {"type": "string"},
-            "age": {"type": "integer", "minimum": 0},
-        },
-    }
-
-    # perform the update
-    result = recursive_update(original)
-
-    # non-empty dict with known content should be returned
-    assert result == expected
-
-    # ensure a new dict is returned, not the same object
-    assert result is not original
-
-
-def test_exclusive_minimum_handling_negative_value() -> None:
-    """Test how minimum integer value description is transformed by recursive_update function."""
+import pytest
+
+@pytest.mark.parametrize("test_value", [100, 0, -100])
+def test_exclusive_minimum_handling(test_value: int) -> None:
+    """Test how exclusiveMinimum is transformed to minimum by recursive_update function."""
     original = {
         "type": "object",
         "properties": {
             "name": {"type": "string"},
-            "age": {"type": "integer", "exclusiveMinimum": -100},
+            "age": {"type": "integer", "exclusiveMinimum": test_value},
         },
     }
     expected = {
         "type": "object",
         "properties": {
             "name": {"type": "string"},
-            "age": {"type": "integer", "minimum": -100},
+            "age": {"type": "integer", "minimum": test_value},
         },
     }
 
     # perform the update
     result = recursive_update(original)
 
     # non-empty dict with known content should be returned
     assert result == expected
 
     # ensure a new dict is returned, not the same object
     assert result is not original
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
def test_exclusive_minimum_handling_positive_value() -> None:
"""Test how minimum integer value description is transformed by recursive_update function."""
original = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "exclusiveMinimum": 100},
},
}
expected = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "minimum": 100},
},
}
# perform the update
result = recursive_update(original)
# non-empty dict with known content should be returned
assert result == expected
# ensure a new dict is returned, not the same object
assert result is not original
def test_exclusive_minimum_handling_zero_value() -> None:
"""Test how minimum integer value description is transformed by recursive_update function."""
original = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "exclusiveMinimum": 0},
},
}
expected = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "minimum": 0},
},
}
# perform the update
result = recursive_update(original)
# non-empty dict with known content should be returned
assert result == expected
# ensure a new dict is returned, not the same object
assert result is not original
def test_exclusive_minimum_handling_negative_value() -> None:
"""Test how minimum integer value description is transformed by recursive_update function."""
original = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "exclusiveMinimum": -100},
},
}
expected = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "minimum": -100},
},
}
# perform the update
result = recursive_update(original)
# non-empty dict with known content should be returned
assert result == expected
# ensure a new dict is returned, not the same object
assert result is not original
`@pytest.mark.parametrize`("test_value", [100, 0, -100])
def test_exclusive_minimum_handling(test_value: int) -> None:
"""Test how exclusiveMinimum is transformed to minimum by recursive_update function."""
original = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "exclusiveMinimum": test_value},
},
}
expected = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer", "minimum": test_value},
},
}
# perform the update
result = recursive_update(original)
# non-empty dict with known content should be returned
assert result == expected
# ensure a new dict is returned, not the same object
assert result is not original
🤖 Prompt for AI Agents 
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/unit/utils/test_schema_dumper.py` around lines 93 - 172, Combine the
three tests test_exclusive_minimum_handling_positive_value,
test_exclusive_minimum_handling_zero_value, and
test_exclusive_minimum_handling_negative_value into a single
pytest.mark.parametrize test that iterates over the exclusiveMinimum values
(100, 0, -100); for each value construct the same original dict with "age":
{"type": "integer", "exclusiveMinimum": value}, call recursive_update(original),
and assert the result equals the expected dict where exclusiveMinimum is
replaced by "minimum": value and that the returned dict is not the same object
as original; keep referencing recursive_update and the "age"/"exclusiveMinimum"
keys to locate code to change.

⚠️ Potential issue | 🟠 Major | 🏗️ Heavy lift

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Verify the recursive_update implementation and its handling of exclusiveMinimum

# Find and display the recursive_update function implementation
ast-grep --pattern $'def recursive_update($$$) $BODY'

# Search for any documentation or comments about exclusiveMinimum handling
rg -n -C5 'exclusiveMinimum' --type=py

# Search for usage of recursive_update to understand the transformation context
rg -n -C3 'recursive_update\(' --type=py -g '!**/test/**'

Repository: lightspeed-core/lightspeed-stack

Length of output: 9608

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Show recursive_update implementation and the exclusiveMinimum handling area
nl -ba src/utils/schema_dumper.py | sed -n '1,120p'

# Show any other references to exclusiveMinimum / minimum in this file
rg -n "exclusiveMinimum|\"minimum\"|exclusiveMinimum" src/utils/schema_dumper.py

Repository: lightspeed-core/lightspeed-stack

Length of output: 119

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Show recursive_update implementation and the exclusiveMinimum handling area
cat -n src/utils/schema_dumper.py | sed -n '1,140p'

# Show any other references to exclusiveMinimum / minimum in this file
rg -n "exclusiveMinimum|\"minimum\"" src/utils/schema_dumper.py

Repository: lightspeed-core/lightspeed-stack

Length of output: 3512

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Find all references to exclusiveMinimum/exclusiveMaximum across repo (tests + src)
rg -n --hidden --no-ignore-vcs "exclusiveMinimum|exclusiveMaximum" .

Repository: lightspeed-core/lightspeed-stack

Length of output: 2434

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Inspect around the first occurrence of exclusiveMinimum in docs/openapi.json
# (line numbers from rg output)
sed -n '11440,11490p' docs/openapi.json

Repository: lightspeed-core/lightspeed-stack

Length of output: 2745

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Find the Configuration model definition and relevant fields/constraints
rg -n "class Configuration" -S src models || true
rg -n "approval_timeout_seconds|approval_retention_days" -S . || true

# Show the file(s) containing the model constraints (best-effort)
fd -a -t f "config.py" .
fd -a -t f -g "*models*config*" .

Repository: lightspeed-core/lightspeed-stack

Length of output: 6836

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Show more context around one of the exclusiveMinimum occurrences in docs/openapi.json
sed -n '11455,11505p' docs/openapi.json

# Also check whether a "minimum" appears near that same snippet
rg -n '"approval_timeout_seconds"' -n docs/openapi.json | head -n 5

Repository: lightspeed-core/lightspeed-stack

Length of output: 2735

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Check if minimum exists near the approval_timeout_seconds exclusiveMinimum occurrence
rg -n -C2 '"approval_timeout_seconds"' docs/openapi.json

# Find any "minimum" within the surrounding area
rg -n -C5 '"exclusiveMinimum": 0\.0' docs/openapi.json | head -n 80

Repository: lightspeed-core/lightspeed-stack

Length of output: 4848

🌐 Web query:

OpenAPI 3.0 exclusiveMinimum boolean or number semantics

💡 Result:

In OpenAPI 3.0, the exclusiveMinimum and exclusiveMaximum keywords are defined as boolean values [1][2]. To use them correctly in OpenAPI 3.0: - exclusiveMinimum: true indicates that the value must be strictly greater than the value specified by minimum [1][3]. - If exclusiveMinimum is false or omitted, the constraint is inclusive, meaning the value must be greater than or equal to minimum [1][3]. This behavior differs significantly from OpenAPI 3.1, where exclusiveMinimum and exclusiveMaximum are defined as numbers rather than booleans [2][4][5]. In OpenAPI 3.1, these fields replace the separate minimum/maximum keywords to specify the exclusive boundary directly (e.g., exclusiveMinimum: 0 means the value must be greater than 0) [4][5]. If you are working with OpenAPI 3.0, you must continue to use both minimum (to set the threshold) and exclusiveMinimum: true (to change the behavior to exclusive) [1][5]. Using a number for exclusiveMinimum in an OpenAPI 3.0 document will often cause validation errors in tools that strictly adhere to the 3.0 specification [2][5].

Citations:

🏁 Script executed:

#!/bin/bash
set -euo pipefail
cat -n tests/unit/utils/test_schema_dumper.py | sed -n '160,230p'

Repository: lightspeed-core/lightspeed-stack

Length of output: 1476

Fix exclusiveMinimum transformation to preserve strict bounds in OpenAPI/JSON Schema

  • src/utils/schema_dumper.py replaces exclusiveMinimum with minimum (recursive_update: new["minimum"] = value) without applying OpenAPI 3.0’s exclusiveMinimum: true flag or adjusting the numeric boundary, which changes validation semantics from strict (> N) to inclusive (>= N).
  • The expectations in tests/unit/utils/test_schema_dumper.py (lines 93-172) encode this direct mapping (exclusiveMinimum: X → minimum: X), locking in the semantic mismatch.
  • The three exclusiveMinimum tests (100/0/-100) are nearly identical; parametrize to remove duplication.
  • test_anyof_with_null_transformed_to_nullable (lines 174-192) is missing the assert result is not original immutability assertion present in the other tests.
🤖 Prompt for AI Agents 
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/unit/utils/test_schema_dumper.py` around lines 93 - 172, The tests
reveal that recursive_update improperly converts exclusiveMinimum to a plain
minimum, losing strictness; update src/utils/schema_dumper.py so
recursive_update preserves OpenAPI semantics (for OpenAPI 3.0 produce "minimum":
value and "exclusiveMinimum": True or otherwise represent the strict bound
correctly rather than dropping exclusivity), then update
tests/unit/utils/test_schema_dumper.py to: parametrize the three
exclusiveMinimum cases into a single test that asserts the transformed schema
preserves exclusivity per the chosen representation and that result is a new
dict (use recursive_update in the test); also add the missing immutability
assertion (assert result is not original) to
test_anyof_with_null_transformed_to_nullable.


def test_anyof_with_null_transformed_to_nullable() -> None:
"""Test how the de-facto Optional type is transformed."""
original = {
"anyOf": [
{"type": "string"},
{"type": "null"},
]
}
expected = {
"type": "string",
"nullable": True,
}

# perform the update
result = recursive_update(original)

# non-empty dict with known content should be returned
assert result == expected

Comment on lines +174 to +192

@coderabbitai coderabbitai Bot Jun 2, 2026

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Add missing immutability assertion.

Unlike the other tests in this file (lines 117, 144, 171), this test is missing the assertion assert result is not original to verify that recursive_update returns a new dictionary rather than mutating the original. This check is part of the expected API contract.

📝 Proposed fix 
     # non-empty dict with known content should be returned
     assert result == expected
+
+    # ensure a new dict is returned, not the same object
+    assert result is not original
🤖 Prompt for AI Agents 
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/unit/utils/test_schema_dumper.py` around lines 174 - 192, Add the
missing immutability assertion to the
test_anyof_with_null_transformed_to_nullable test: after calling
recursive_update(original) and before comparing contents, assert that result is
not original to ensure recursive_update returns a new dict rather than mutating
the input; update the test function
(test_anyof_with_null_transformed_to_nullable) to include this assertion using
the existing variable names result and original.


def test_handles_none_values() -> None:
"""None values should be preserved."""
original = {"key": None}
Expand Down
Loading