coreason-meta-engineering 0.1.0

Rust port of the CoReason Agentic Forge & AST Manipulation Layer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

# Copyright (c) 2026 CoReason, Inc
#
# This software is proprietary and dual-licensed
# Licensed under the Prosperity Public License 3.0 (the "License")
# A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
# For details, see the LICENSE file
# Commercial use beyond a 30-day trial requires a separate license
#
# Source Code: <https://github.com/CoReason-AI/coreason-meta-engineering>


import pytest

from coreason_meta_engineering.topological_validator import (
    TopologicalBoundaryViolation,
    TopologicalValidator,
)

# --- Tests for topological_validator.py ---


def test_topological_boundary_violation_exception() -> None:
    exc = TopologicalBoundaryViolation(node_type="Call:eval", line=42, details="eval is bad")
    assert exc.node_type == "Call:eval"
    assert exc.line == 42
    assert exc.details == "eval is bad"
    assert "TopologicalBoundaryViolation at line 42: Forbidden node 'Call:eval' detected. eval is bad" in str(exc)


def test_topological_validator_syntax_error() -> None:
    validator = TopologicalValidator()
    # Invalid Python syntax (unclosed parentheses)
    code = "def func("
    report = validator.validate(code)
    assert report.valid is False
    assert len(report.violations) == 1
    assert report.violations[0]["type"] == "SyntaxError"
    assert report.violations[0]["line"] == 1
    assert len(report.violations[0]["details"]) > 0


def test_topological_validator_valid_code() -> None:
    validator = TopologicalValidator()
    code = "def hello_world():\n    print('Hello World')\n    return 42\n"
    report = validator.validate(code)
    assert report.valid is True
    assert len(report.violations) == 0
    assert report.nodes_scanned > 0


def test_topological_validator_forbidden_import_statement() -> None:
    validator = TopologicalValidator()

    # ast.Import checking (e.g. Import:subprocess)
    code_import = "import subprocess"
    report = validator.validate(code_import)
    assert report.valid is False
    assert any(v["type"] == "Import:subprocess" for v in report.violations)

    # ast.ImportFrom checking (e.g. Import:subprocess)
    code_import_from = "from subprocess import Popen"
    report_from = validator.validate(code_import_from)
    assert report_from.valid is False
    assert any(v["type"] == "Import:subprocess" for v in report_from.violations)


def test_topological_validator_forbidden_calls() -> None:
    validator = TopologicalValidator()

    # Call:eval
    code_eval = "eval('1 + 1')"
    report_eval = validator.validate(code_eval)
    assert report_eval.valid is False
    assert any(v["type"] == "Call:eval" for v in report_eval.violations)

    # Call:exec
    code_exec = "exec('x = 1')"
    report_exec = validator.validate(code_exec)
    assert report_exec.valid is False
    assert any(v["type"] == "Call:exec" for v in report_exec.violations)

    # Call:compile
    code_compile = "compile('x = 1', 'file.py', 'exec')"
    report_compile = validator.validate(code_compile)
    assert report_compile.valid is False
    assert any(v["type"] == "Call:compile" for v in report_compile.violations)

    # Call:__import__
    code_import_func = "__import__('os')"
    report_import = validator.validate(code_import_func)
    assert report_import.valid is False
    assert any(v["type"] == "Call:__import__" for v in report_import.violations)

    # Call:open
    code_open = "open('file.txt', 'r')"
    report_open = validator.validate(code_open)
    assert report_open.valid is False
    assert any(v["type"] == "Call:open" for v in report_open.violations)


def test_topological_validator_forbidden_attributes() -> None:
    validator = TopologicalValidator()

    # Attribute:write
    code_write = "f.write('hello')"
    report_write = validator.validate(code_write)
    assert report_write.valid is False
    assert any(v["type"] == "Attribute:write" for v in report_write.violations)

    # Attribute:writelines
    code_writelines = "f.writelines(['hello'])"
    report_writelines = validator.validate(code_writelines)
    assert report_writelines.valid is False
    assert any(v["type"] == "Attribute:writelines" for v in report_writelines.violations)


def test_topological_validator_strict_validation() -> None:
    validator = TopologicalValidator()

    # Valid code in strict mode should just return report
    valid_code = "x = 5"
    report = validator.validate_strict(valid_code)
    assert report.valid is True

    # Invalid code in strict mode should raise TopologicalBoundaryViolation
    invalid_code = "import subprocess"
    with pytest.raises(TopologicalBoundaryViolation) as exc_info:
        validator.validate_strict(invalid_code)

    assert exc_info.value.node_type == "Import:subprocess"
    assert exc_info.value.line == 1