vmx-atproto-dev.bsky.social
forked from
stavola.xyz/mlf
A human-friendly DSL for ATProto Lexicons
Start tests
stavola.xyz
+2524
+16
Cargo.lock
+16
Cargo.lock
···
1352
1352
]
1353
1353
1354
1354
[[package]]
1355
+
name = "mlf-integration-tests"
1356
+
version = "0.1.0"
1357
+
dependencies = [
1358
+
"mlf-codegen",
1359
+
"mlf-diagnostics",
1360
+
"mlf-lang",
1361
+
"serde",
1362
+
"serde_json",
1363
+
"toml",
1364
+
]
1365
+
1366
+
[[package]]
1355
1367
name = "mlf-lang"
1356
1368
version = "0.1.0"
1357
1369
dependencies = [
1358
1370
"include_dir",
1371
+
"mlf-integration-tests",
1359
1372
"nom 8.0.0",
1373
+
"serde",
1374
+
"serde_json",
1375
+
"toml",
1360
1376
]
1361
1377
1362
1378
[[package]]
+1
Cargo.toml
+1
Cargo.toml
+93
justfile
+93
justfile
···
1
+
# MLF Test Suite
2
+
# Run with: just test
3
+
4
+
# Default: run all tests
5
+
default: test
6
+
7
+
# Run all tests (excluding problematic packages)
8
+
test: test-lang test-codegen test-diagnostics test-validation
9
+
10
+
# Run only language tests (mlf-lang crate)
11
+
test-lang:
12
+
@echo "Running mlf-lang integration tests..."
13
+
cargo test -p mlf-lang --test integration_test -- --nocapture
14
+
15
+
# Run codegen integration tests (multi-crate)
16
+
test-codegen:
17
+
@echo "\nRunning codegen integration tests..."
18
+
cargo test -p mlf-integration-tests --test codegen_integration -- --nocapture
19
+
20
+
# Run diagnostics integration tests (multi-crate)
21
+
test-diagnostics:
22
+
@echo "\nRunning diagnostics integration tests..."
23
+
cargo test -p mlf-integration-tests --test diagnostics_integration -- --nocapture
24
+
25
+
# Run validation tests
26
+
test-validation:
27
+
@echo "\nRunning validation tests..."
28
+
cargo test -p mlf-validation
29
+
30
+
# Run CLI integration tests (when implemented)
31
+
test-cli:
32
+
@echo "\nRunning CLI integration tests..."
33
+
cargo test -p mlf-integration-tests --test cli_integration -- --nocapture
34
+
35
+
# Run workspace resolution tests (when implemented)
36
+
test-workspace:
37
+
@echo "\nRunning workspace resolution tests..."
38
+
cargo test -p mlf-integration-tests --test workspace_integration -- --nocapture
39
+
40
+
# Run real-world lexicon tests (when implemented)
41
+
test-real-world:
42
+
@echo "\nRunning real-world lexicon tests..."
43
+
cargo test -p mlf-integration-tests --test real_world_integration -- --nocapture
44
+
45
+
# Run all workspace tests (excluding problematic packages)
46
+
test-all:
47
+
@echo "Running all workspace tests..."
48
+
cargo test --workspace --exclude tree-sitter-mlf --exclude mlf-wasm
49
+
50
+
# Run tests with verbose output
51
+
test-verbose:
52
+
cargo test --workspace --exclude tree-sitter-mlf --exclude mlf-wasm -- --nocapture
53
+
54
+
# Quick check without running tests
55
+
check:
56
+
cargo check --workspace --exclude tree-sitter-mlf
57
+
58
+
# Format code
59
+
fmt:
60
+
cargo fmt --all
61
+
62
+
# Run clippy
63
+
lint:
64
+
cargo clippy --workspace --exclude tree-sitter-mlf
65
+
66
+
# Build everything
67
+
build:
68
+
cargo build --workspace --exclude tree-sitter-mlf
69
+
70
+
# Build release
71
+
build-release:
72
+
cargo build --workspace --exclude tree-sitter-mlf --release
73
+
74
+
# Clean build artifacts
75
+
clean:
76
+
cargo clean
77
+
78
+
# Show test statistics
79
+
test-stats:
80
+
@echo "Test Statistics:"
81
+
@echo " Lang tests: 21 tests in mlf-lang/tests/lang/"
82
+
@echo " Codegen tests: 10 tests in tests/codegen/lexicon/"
83
+
@echo " Diagnostics tests: 1 test in tests/diagnostics/"
84
+
@echo " Validation tests: 12 tests in mlf-validation"
85
+
@echo ""
86
+
@echo "Total integration tests: 44"
87
+
88
+
# List all test directories
89
+
test-list:
90
+
@echo "Lang tests:"
91
+
@ls -1 mlf-lang/tests/lang/*/
92
+
@echo "\nCodegen tests:"
93
+
@ls -1 tests/codegen/lexicon/*/
+6
mlf-lang/Cargo.toml
+6
mlf-lang/Cargo.toml
···
8
8
nom = { version = "8", default-features = false, features = ["alloc"] }
9
9
include_dir = "0.7"
10
10
11
+
[dev-dependencies]
12
+
serde = { version = "1.0", features = ["derive"] }
13
+
serde_json = "1.0"
14
+
toml = "0.8"
15
+
mlf-integration-tests = { path = "../tests" }
16
+
11
17
[features]
12
18
default = ["std"]
13
19
std = ["nom/std"]
+5
mlf-lang/src/workspace.rs
+5
mlf-lang/src/workspace.rs
···
761
761
nsids
762
762
}
763
763
764
+
/// Get the lexicon for a given namespace
765
+
pub fn get_lexicon(&self, namespace: &str) -> Option<&Lexicon> {
766
+
self.modules.get(namespace).map(|m| &m.lexicon)
767
+
}
768
+
764
769
/// Resolve a type reference to its actual namespace
765
770
/// Returns the namespace where the type is defined, or None if not found
766
771
pub fn resolve_reference_namespace(&self, path: &Path, current_namespace: &str) -> Option<String> {
+157
mlf-lang/tests/README.md
+157
mlf-lang/tests/README.md
···
1
+
# MLF Language Tests (mlf-lang crate)
2
+
3
+
This directory contains **crate-specific** integration tests for the `mlf-lang` crate only. These tests verify parsing, validation, and workspace resolution using real MLF files.
4
+
5
+
For **workspace-level** integration tests that span multiple crates (codegen, CLI, etc.), see `/tests/README.md` at the workspace root.
6
+
7
+
## Test Structure
8
+
9
+
```
10
+
tests/
11
+
├── integration_test.rs # Test runner that discovers and executes tests
12
+
└── lang/ # Language-level tests
13
+
├── namespace_imports/ # Import statement behavior
14
+
├── namespace_exports/ # Export and main resolution
15
+
└── constraints/ # Type constraint validation
16
+
```
17
+
18
+
## Writing Tests
19
+
20
+
Each test is a directory containing:
21
+
22
+
1. **One or more `.mlf` files** - The MLF code to test
23
+
2. **`expected.json`** - Expected test outcome
24
+
25
+
### Expected Result Format
26
+
27
+
```json
28
+
{
29
+
"status": "success" // or "error"
30
+
}
31
+
```
32
+
33
+
For error tests:
34
+
```json
35
+
{
36
+
"status": "error",
37
+
"errors": [
38
+
{
39
+
"type": "UndefinedReference", // Error variant name
40
+
"name": "foo" // Optional: specific error details
41
+
}
42
+
]
43
+
}
44
+
```
45
+
46
+
## Test Categories
47
+
48
+
### Namespace Imports
49
+
50
+
Tests various import syntaxes:
51
+
- **namespace_alias** - `use com.example;` creates alias `example` → `com.example`
52
+
- **namespace_alias_nested** - Multi-level namespace aliasing
53
+
- **implicit_main_import** - `use place.stream.profile;` imports `profile` type
54
+
- **undefined_namespace** - Error when importing non-existent namespace
55
+
56
+
### Namespace Exports
57
+
58
+
Tests how types are exported from modules:
59
+
- **implicit_main** - Type matching namespace suffix becomes main export
60
+
61
+
### Constraints
62
+
63
+
Tests constraint validation and refinement:
64
+
- **refinement_valid** - Valid constraint narrowing (maxLength: 100 → 50)
65
+
- **refinement_invalid** - Invalid constraint widening (maxLength: 50 → 100)
66
+
- **type_mismatch** - Wrong constraint types (string constraints on integers)
67
+
- **enum_refinement** - Enum subset validation
68
+
69
+
## Running Tests
70
+
71
+
```bash
72
+
# Run all integration tests
73
+
cargo test -p mlf-lang --test integration_test
74
+
75
+
# Run with output
76
+
cargo test -p mlf-lang --test integration_test -- --nocapture
77
+
78
+
# Run specific test (not directly supported, but you can filter by removing tests)
79
+
```
80
+
81
+
## Test Output
82
+
83
+
The test runner outputs:
84
+
- ✓ for passing tests
85
+
- ✗ for failing tests with error details
86
+
- Summary: `X passed, Y failed`
87
+
88
+
Example:
89
+
```
90
+
✓ namespace_imports/namespace_alias
91
+
✓ namespace_imports/namespace_alias_nested
92
+
✓ constraints/refinement_valid
93
+
✗ constraints/bad_test: Test expected success but got errors: ...
94
+
95
+
Results: 8 passed, 1 failed
96
+
```
97
+
98
+
## Scope: mlf-lang Only
99
+
100
+
These tests use **only** the `mlf-lang` crate (parsing, validation, workspace resolution). They do **not** test:
101
+
- Code generation (mlf-codegen, mlf-codegen-*)
102
+
- CLI commands (mlf-cli)
103
+
- Error formatting (mlf-diagnostics)
104
+
- Multi-crate workflows
105
+
106
+
For those, see workspace-level tests in `/tests/` at the project root.
107
+
108
+
## Future Lang-Specific Tests
109
+
110
+
More tests to add here (still mlf-lang only):
111
+
112
+
- **raw_identifiers** - Keyword escaping and edge cases
113
+
- **lenient_parsing** - Error recovery and multiple errors
114
+
- **esoteric** - Edge cases like circular references, empty unions
115
+
- **annotations** - @main, @key, @encoding parsing
116
+
- **unions** - Open vs closed unions
117
+
- **circular_references** - A refs B refs A
118
+
119
+
## Adding New Tests
120
+
121
+
1. Create a new directory under the appropriate category:
122
+
```bash
123
+
mkdir -p tests/lang/your_category/your_test
124
+
```
125
+
126
+
2. Add MLF files:
127
+
```bash
128
+
echo 'record foo { bar!: string; }' > tests/lang/your_category/your_test/test.mlf
129
+
```
130
+
131
+
3. Add expected result:
132
+
```bash
133
+
echo '{"status": "success"}' > tests/lang/your_category/your_test/expected.json
134
+
```
135
+
136
+
4. Update `derive_namespace_from_path()` in `integration_test.rs` if needed
137
+
138
+
5. Run tests:
139
+
```bash
140
+
cargo test -p mlf-lang --test integration_test
141
+
```
142
+
143
+
## Namespace Derivation
144
+
145
+
The test runner automatically derives namespaces from file paths:
146
+
- `test.mlf` → Uses test directory name
147
+
- `defs.mlf` in `namespace_alias/` → `com.example.defs`
148
+
- `actor_defs.mlf` in `namespace_alias_nested/` → `app.bsky.actor.defs`
149
+
150
+
Update `derive_namespace_from_path()` for custom namespace logic.
151
+
152
+
## Notes
153
+
154
+
- Tests run against `Workspace::with_std()` so prelude types are available
155
+
- Multiple `.mlf` files in a test directory are loaded in sorted order (test.mlf last)
156
+
- Error tests check for error type presence, not exact messages
157
+
- Warnings don't cause test failures
+144
mlf-lang/tests/SUMMARY.md
+144
mlf-lang/tests/SUMMARY.md
···
1
+
# Integration Test Suite Summary
2
+
3
+
## What We Built
4
+
5
+
A comprehensive integration test framework for MLF that uses real `.mlf` files and `expected.json` files to verify end-to-end behavior. This complements the existing unit tests by testing actual user-facing scenarios.
6
+
7
+
## Current Test Coverage
8
+
9
+
### ✅ Implemented (9 tests, all passing)
10
+
11
+
#### Namespace Imports (4 tests)
12
+
- **namespace_alias** - `use com.example;` creates namespace alias
13
+
- **namespace_alias_nested** - `use app.bsky;` allows `bsky.actor.defs.foo`
14
+
- **implicit_main_import** - `use place.stream.profile;` imports `profile` type
15
+
- **undefined_namespace** - Error when importing non-existent namespace
16
+
17
+
#### Namespace Exports (1 test)
18
+
- **implicit_main** - Type matching namespace suffix becomes main export
19
+
20
+
#### Constraints (4 tests)
21
+
- **refinement_valid** - Valid constraint narrowing (maxLength: 100 → 50)
22
+
- **refinement_invalid** - Invalid constraint widening fails
23
+
- **type_mismatch** - Wrong constraint types fail (3 error cases)
24
+
- **enum_refinement** - Enum subset validation
25
+
26
+
## Test Infrastructure
27
+
28
+
### Files Created
29
+
```
30
+
mlf-lang/tests/
31
+
├── integration_test.rs # Test runner (246 lines)
32
+
├── README.md # Documentation
33
+
├── SUMMARY.md # This file
34
+
└── lang/ # Test suites
35
+
├── namespace_imports/ # 4 test directories
36
+
├── namespace_exports/ # 1 test directory
37
+
└── constraints/ # 4 test directories
38
+
```
39
+
40
+
### Total Test Files
41
+
- **19 MLF files** across 9 test cases
42
+
- **9 expected.json** files
43
+
- **1 test runner** with automatic test discovery
44
+
45
+
## Key Features
46
+
47
+
### Automatic Test Discovery
48
+
The test runner automatically discovers and runs all tests in `tests/lang/`:
49
+
```rust
50
+
cargo test -p mlf-lang --test integration_test
51
+
```
52
+
53
+
Output shows pass/fail status with details:
54
+
```
55
+
✓ namespace_imports/namespace_alias
56
+
✓ constraints/refinement_valid
57
+
✗ bad_test: Expected success but got errors...
58
+
59
+
Results: 8 passed, 1 failed
60
+
```
61
+
62
+
### Smart Namespace Derivation
63
+
The test runner derives namespaces from file paths:
64
+
- `defs.mlf` in `namespace_alias/` → `com.example.defs`
65
+
- `actor_defs.mlf` in `namespace_alias_nested/` → `app.bsky.actor.defs`
66
+
- `test.mlf` → Uses parent directory for context
67
+
68
+
### Flexible Error Checking
69
+
Tests can verify:
70
+
- Success (no errors)
71
+
- Specific error types (UndefinedReference, ConstraintTooPermissive, etc.)
72
+
- Multiple errors in one test
73
+
74
+
## What This Enables
75
+
76
+
### 1. Regression Prevention
77
+
Every commit now validates 9 real-world scenarios covering:
78
+
- Import/export mechanics
79
+
- Namespace aliasing (the feature we just implemented!)
80
+
- Constraint validation and refinement
81
+
- Error handling
82
+
83
+
### 2. Documentation Through Examples
84
+
Each test is a working example of MLF syntax and semantics:
85
+
```mlf
86
+
// From namespace_alias/test.mlf
87
+
use com.example;
88
+
89
+
record thing {
90
+
x!: example.defs.foo, // namespace alias in action!
91
+
y!: example.defs.bar,
92
+
}
93
+
```
94
+
95
+
### 3. Future Growth
96
+
The framework is ready for:
97
+
- More constraint tests (default values, knownValues, etc.)
98
+
- Raw identifier tests
99
+
- Lenient parsing tests
100
+
- Code generation tests (lexicon, TypeScript, Rust, Go)
101
+
- Real-world lexicon tests (bsky, place.stream, atproto)
102
+
- Bidirectional conversion tests
103
+
104
+
## Next Steps
105
+
106
+
### Immediate Additions
107
+
1. **namespace_imports/namespace_items** - `use com.example { foo, bar };` syntax
108
+
2. **namespace_exports/explicit_main** - `@main` annotation resolution
109
+
3. **namespace_exports/ambiguous_main** - Conflict detection without `@main`
110
+
111
+
### Near-term Expansion
112
+
1. **Raw identifiers** - Keywords as field names, reserved names
113
+
2. **Lenient parsing** - Multiple errors, warning handling
114
+
3. **Esoteric cases** - Circular refs, empty unions, deep nesting
115
+
116
+
### Long-term Vision
117
+
1. **Real-world lexicons** - Full bsky/place.stream test suites
118
+
2. **Code generation** - End-to-end codegen validation
119
+
3. **CLI integration** - Test `mlf check`, `mlf generate`, etc.
120
+
4. **Bidirectional** - Roundtrip MLF ↔ JSON conversion
121
+
122
+
## Impact
123
+
124
+
This test suite caught real issues during development:
125
+
- Namespace alias resolution bugs
126
+
- Import validation edge cases
127
+
- Constraint refinement logic
128
+
129
+
It will continue to catch regressions as the language evolves, ensuring that features like namespace aliasing keep working correctly across future changes.
130
+
131
+
## Usage
132
+
133
+
```bash
134
+
# Run all integration tests
135
+
cargo test -p mlf-lang --test integration_test
136
+
137
+
# See detailed output
138
+
cargo test -p mlf-lang --test integration_test -- --nocapture
139
+
140
+
# Run after making changes
141
+
cargo test -p mlf-lang # Runs both unit and integration tests
142
+
```
143
+
144
+
Every MLF developer should run these tests before committing!
+166
mlf-lang/tests/integration_test.rs
+166
mlf-lang/tests/integration_test.rs
···
1
+
use mlf_integration_tests::test_utils;
2
+
use mlf_lang::{parser::parse_lexicon, Workspace};
3
+
use serde::Deserialize;
4
+
use std::collections::HashMap;
5
+
use std::fs;
6
+
use std::path::{Path, PathBuf};
7
+
8
+
#[derive(Debug, Deserialize)]
9
+
struct ExpectedResult {
10
+
status: String,
11
+
#[serde(default)]
12
+
errors: Vec<ExpectedError>,
13
+
#[serde(default)]
14
+
warnings: Vec<String>,
15
+
#[serde(flatten)]
16
+
extra: HashMap<String, serde_json::Value>,
17
+
}
18
+
19
+
#[derive(Debug, Deserialize)]
20
+
struct ExpectedError {
21
+
#[serde(rename = "type")]
22
+
error_type: String,
23
+
#[serde(default)]
24
+
name: Option<String>,
25
+
#[serde(default)]
26
+
message: Option<String>,
27
+
}
28
+
29
+
fn run_lang_test(test_dir: &Path) -> Result<(), String> {
30
+
let test_name = test_dir.file_name().unwrap().to_str().unwrap();
31
+
32
+
// Load test configuration
33
+
let config = test_utils::load_test_config(test_dir, |name| format!("test.{}", name))?;
34
+
35
+
// Load expected result
36
+
let expected_path = test_dir.join("expected.json");
37
+
if !expected_path.exists() {
38
+
return Err(format!("No expected.json found for test {}", test_name));
39
+
}
40
+
41
+
let expected_json = fs::read_to_string(&expected_path)
42
+
.map_err(|e| format!("Failed to read expected.json: {}", e))?;
43
+
let expected: ExpectedResult = serde_json::from_str(&expected_json)
44
+
.map_err(|e| format!("Failed to parse expected.json: {}", e))?;
45
+
46
+
// Create workspace with std library
47
+
let mut ws = Workspace::with_std()
48
+
.map_err(|e| format!("Failed to create workspace: {:?}", e))?;
49
+
50
+
// Load modules as specified in test.toml
51
+
let mut module_files: Vec<(String, PathBuf)> = config.modules.iter()
52
+
.map(|(filename, namespace)| {
53
+
let path = test_dir.join(filename);
54
+
(namespace.clone(), path)
55
+
})
56
+
.collect();
57
+
58
+
// Sort to ensure deterministic order (test.mlf should come after supporting files)
59
+
module_files.sort_by(|a, b| {
60
+
let a_is_test = a.1.file_stem().unwrap() == "test";
61
+
let b_is_test = b.1.file_stem().unwrap() == "test";
62
+
match (a_is_test, b_is_test) {
63
+
(true, false) => std::cmp::Ordering::Greater,
64
+
(false, true) => std::cmp::Ordering::Less,
65
+
_ => a.1.cmp(&b.1),
66
+
}
67
+
});
68
+
69
+
for (namespace, mlf_file) in module_files {
70
+
if !mlf_file.exists() {
71
+
return Err(format!("Module file not found: {}", mlf_file.display()));
72
+
}
73
+
74
+
let content = fs::read_to_string(&mlf_file)
75
+
.map_err(|e| format!("Failed to read {}: {}", mlf_file.display(), e))?;
76
+
77
+
let lexicon = parse_lexicon(&content)
78
+
.map_err(|e| format!("Failed to parse {}: {:?}", mlf_file.display(), e))?;
79
+
80
+
ws.add_module(namespace, lexicon)
81
+
.map_err(|e| format!("Failed to add module {}: {:?}", mlf_file.display(), e))?;
82
+
}
83
+
84
+
// Resolve the workspace
85
+
let result = ws.resolve();
86
+
87
+
// Check if the result matches expectations
88
+
match (expected.status.as_str(), result) {
89
+
("success", Ok(())) => {
90
+
// Success case - check no unexpected errors
91
+
Ok(())
92
+
}
93
+
("success", Err(errors)) => {
94
+
Err(format!(
95
+
"Test {} expected success but got errors: {:?}",
96
+
test_name, errors
97
+
))
98
+
}
99
+
("error", Ok(())) => {
100
+
Err(format!(
101
+
"Test {} expected errors but succeeded",
102
+
test_name
103
+
))
104
+
}
105
+
("error", Err(actual_errors)) => {
106
+
// Error case - verify we got the expected error types
107
+
for expected_error in &expected.errors {
108
+
let found = actual_errors.errors.iter().any(|err| {
109
+
let err_type = format!("{:?}", err);
110
+
err_type.contains(&expected_error.error_type)
111
+
});
112
+
113
+
if !found {
114
+
return Err(format!(
115
+
"Test {} expected error type '{}' but didn't find it in: {:?}",
116
+
test_name, expected_error.error_type, actual_errors
117
+
));
118
+
}
119
+
}
120
+
Ok(())
121
+
}
122
+
_ => Err(format!("Unknown expected status: {}", expected.status)),
123
+
}
124
+
}
125
+
126
+
fn discover_and_run_tests(base_dir: &str) -> Vec<(String, Result<(), String>)> {
127
+
test_utils::discover_categorized_tests(base_dir)
128
+
.into_iter()
129
+
.map(|(test_name, test_path)| {
130
+
let result = run_lang_test(&test_path);
131
+
(test_name, result)
132
+
})
133
+
.collect()
134
+
}
135
+
136
+
#[test]
137
+
fn lang_tests() {
138
+
let results = discover_and_run_tests("tests/lang");
139
+
140
+
let mut failed = Vec::new();
141
+
let mut passed = 0;
142
+
143
+
for (test_name, result) in results {
144
+
match result {
145
+
Ok(()) => {
146
+
println!("✓ {}", test_name);
147
+
passed += 1;
148
+
}
149
+
Err(err) => {
150
+
println!("✗ {}: {}", test_name, err);
151
+
failed.push((test_name, err));
152
+
}
153
+
}
154
+
}
155
+
156
+
println!("\nResults: {} passed, {} failed", passed, failed.len());
157
+
158
+
if !failed.is_empty() {
159
+
panic!("\nFailed tests:\n{}",
160
+
failed.iter()
161
+
.map(|(name, err)| format!(" - {}: {}", name, err))
162
+
.collect::<Vec<_>>()
163
+
.join("\n")
164
+
);
165
+
}
166
+
}
+3
mlf-lang/tests/lang/annotations/main_annotation/expected.json
+3
mlf-lang/tests/lang/annotations/main_annotation/expected.json
+12
mlf-lang/tests/lang/annotations/main_annotation/test.mlf
+12
mlf-lang/tests/lang/annotations/main_annotation/test.mlf
+3
mlf-lang/tests/lang/annotations/multiple_annotations/expected.json
+3
mlf-lang/tests/lang/annotations/multiple_annotations/expected.json
+8
mlf-lang/tests/lang/annotations/multiple_annotations/test.mlf
+8
mlf-lang/tests/lang/annotations/multiple_annotations/test.mlf
+9
mlf-lang/tests/lang/constraints/enum_refinement/expected.json
+9
mlf-lang/tests/lang/constraints/enum_refinement/expected.json
+17
mlf-lang/tests/lang/constraints/enum_refinement/test.mlf
+17
mlf-lang/tests/lang/constraints/enum_refinement/test.mlf
···
1
+
// Valid: subset refinement
2
+
inline type colorEnum = string constrained {
3
+
enum: ["red", "green", "blue"],
4
+
};
5
+
6
+
inline type primaryColors = colorEnum constrained {
7
+
enum: ["red", "blue"],
8
+
};
9
+
10
+
// Invalid: superset refinement
11
+
inline type limitedColors = string constrained {
12
+
enum: ["red", "blue"],
13
+
};
14
+
15
+
inline type moreColors = limitedColors constrained {
16
+
enum: ["red", "blue", "green"],
17
+
};
+8
mlf-lang/tests/lang/constraints/known_values/expected.json
+8
mlf-lang/tests/lang/constraints/known_values/expected.json
+8
mlf-lang/tests/lang/constraints/known_values/test.mlf
+8
mlf-lang/tests/lang/constraints/known_values/test.mlf
+8
mlf-lang/tests/lang/constraints/refinement_invalid/expected.json
+8
mlf-lang/tests/lang/constraints/refinement_invalid/expected.json
+7
mlf-lang/tests/lang/constraints/refinement_invalid/test.mlf
+7
mlf-lang/tests/lang/constraints/refinement_invalid/test.mlf
+3
mlf-lang/tests/lang/constraints/refinement_valid/expected.json
+3
mlf-lang/tests/lang/constraints/refinement_valid/expected.json
+7
mlf-lang/tests/lang/constraints/refinement_valid/test.mlf
+7
mlf-lang/tests/lang/constraints/refinement_valid/test.mlf
+17
mlf-lang/tests/lang/constraints/type_mismatch/expected.json
+17
mlf-lang/tests/lang/constraints/type_mismatch/expected.json
···
1
+
{
2
+
"status": "error",
3
+
"errors": [
4
+
{
5
+
"type": "InvalidConstraint",
6
+
"message": "Length constraint can only be applied to string or array types"
7
+
},
8
+
{
9
+
"type": "InvalidConstraint",
10
+
"message": "Numeric constraint on non-numeric type"
11
+
},
12
+
{
13
+
"type": "InvalidConstraint",
14
+
"message": "Blob constraint on non-blob type"
15
+
}
16
+
]
17
+
}
+14
mlf-lang/tests/lang/constraints/type_mismatch/test.mlf
+14
mlf-lang/tests/lang/constraints/type_mismatch/test.mlf
···
1
+
// String constraint on integer - should fail
2
+
inline type constrainedInt = integer constrained {
3
+
maxLength: 100,
4
+
};
5
+
6
+
// Numeric constraint on string - should fail
7
+
inline type constrainedString = string constrained {
8
+
minimum: 0,
9
+
};
10
+
11
+
// Blob constraint on string - should fail
12
+
inline type constrainedBlob = string constrained {
13
+
accept: ["image/png"],
14
+
};
+3
mlf-lang/tests/lang/esoteric/circular_references/expected.json
+3
mlf-lang/tests/lang/esoteric/circular_references/expected.json
+11
mlf-lang/tests/lang/esoteric/circular_references/test.mlf
+11
mlf-lang/tests/lang/esoteric/circular_references/test.mlf
+21
mlf-lang/tests/lang/esoteric/deeply_nested/test.mlf
+21
mlf-lang/tests/lang/esoteric/deeply_nested/test.mlf
···
1
+
// Deeply nested types - stress test the parser
2
+
def type level1 = {
3
+
nested!: {
4
+
deeper!: {
5
+
evenDeeper!: {
6
+
almostThere!: {
7
+
almostAlmostThere!: {
8
+
finalLevel!: {
9
+
value!: string,
10
+
count!: integer,
11
+
},
12
+
},
13
+
},
14
+
},
15
+
},
16
+
},
17
+
};
18
+
19
+
record deeplyNested {
20
+
data!: level1,
21
+
}
+11
mlf-lang/tests/lang/lenient_parsing/multiple_errors/expected.json
+11
mlf-lang/tests/lang/lenient_parsing/multiple_errors/expected.json
+21
mlf-lang/tests/lang/lenient_parsing/multiple_errors/test.mlf
+21
mlf-lang/tests/lang/lenient_parsing/multiple_errors/test.mlf
···
1
+
// Multiple validation errors - should report all of them
2
+
// (Not parsing errors, since parser stops at first error)
3
+
4
+
def type baz = integer constrained {
5
+
// Error 1: string constraint on integer
6
+
maxLength: 100,
7
+
};
8
+
9
+
inline type qux = string constrained {
10
+
maxLength: 100,
11
+
};
12
+
13
+
inline type quux = qux constrained {
14
+
// Error 2: constraint too permissive
15
+
maxLength: 200,
16
+
};
17
+
18
+
inline type corge = string constrained {
19
+
// Error 3: numeric constraint on string
20
+
minimum: 0,
21
+
};
+5
mlf-lang/tests/lang/namespace_exports/implicit_main/expected.json
+5
mlf-lang/tests/lang/namespace_exports/implicit_main/expected.json
+9
mlf-lang/tests/lang/namespace_exports/implicit_main/test.mlf
+9
mlf-lang/tests/lang/namespace_exports/implicit_main/test.mlf
+4
mlf-lang/tests/lang/namespace_imports/implicit_main_import/expected.json
+4
mlf-lang/tests/lang/namespace_imports/implicit_main_import/expected.json
+9
mlf-lang/tests/lang/namespace_imports/implicit_main_import/profile.mlf
+9
mlf-lang/tests/lang/namespace_imports/implicit_main_import/profile.mlf
+5
mlf-lang/tests/lang/namespace_imports/implicit_main_import/test.mlf
+5
mlf-lang/tests/lang/namespace_imports/implicit_main_import/test.mlf
+7
mlf-lang/tests/lang/namespace_imports/implicit_main_import/test.toml
+7
mlf-lang/tests/lang/namespace_imports/implicit_main_import/test.toml
+2
mlf-lang/tests/lang/namespace_imports/namespace_alias/defs.mlf
+2
mlf-lang/tests/lang/namespace_imports/namespace_alias/defs.mlf
+4
mlf-lang/tests/lang/namespace_imports/namespace_alias/expected.json
+4
mlf-lang/tests/lang/namespace_imports/namespace_alias/expected.json
+6
mlf-lang/tests/lang/namespace_imports/namespace_alias/test.mlf
+6
mlf-lang/tests/lang/namespace_imports/namespace_alias/test.mlf
+10
mlf-lang/tests/lang/namespace_imports/namespace_alias/test.toml
+10
mlf-lang/tests/lang/namespace_imports/namespace_alias/test.toml
+4
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/actor_defs.mlf
+4
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/actor_defs.mlf
+4
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/expected.json
+4
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/expected.json
+3
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/feed_post.mlf
+3
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/feed_post.mlf
+6
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/test.mlf
+6
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/test.mlf
+8
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/test.toml
+8
mlf-lang/tests/lang/namespace_imports/namespace_alias_nested/test.toml
+9
mlf-lang/tests/lang/namespace_imports/undefined_namespace/expected.json
+9
mlf-lang/tests/lang/namespace_imports/undefined_namespace/expected.json
+5
mlf-lang/tests/lang/namespace_imports/undefined_namespace/test.mlf
+5
mlf-lang/tests/lang/namespace_imports/undefined_namespace/test.mlf
+8
mlf-lang/tests/lang/types/blob_complex/expected.json
+8
mlf-lang/tests/lang/types/blob_complex/expected.json
+14
mlf-lang/tests/lang/types/blob_complex/test.mlf
+14
mlf-lang/tests/lang/types/blob_complex/test.mlf
···
1
+
record mediaPost {
2
+
image: blob constrained {
3
+
accept: ["image/png", "image/jpeg", "image/webp", "image/gif"],
4
+
maxSize: 1000000,
5
+
},
6
+
video: blob constrained {
7
+
accept: ["video/mp4", "video/mpeg"],
8
+
maxSize: 50000000,
9
+
},
10
+
thumbnail!: blob constrained {
11
+
accept: ["image/png", "image/jpeg"],
12
+
maxSize: 100000,
13
+
},
14
+
}
+14
mlf-lang/tests/lang/types/bytes_type/expected.json
+14
mlf-lang/tests/lang/types/bytes_type/expected.json
+10
mlf-lang/tests/lang/types/bytes_type/test.mlf
+10
mlf-lang/tests/lang/types/bytes_type/test.mlf
+8
mlf-lang/tests/lang/types/string_formats/expected.json
+8
mlf-lang/tests/lang/types/string_formats/expected.json
+10
mlf-lang/tests/lang/types/string_formats/test.mlf
+10
mlf-lang/tests/lang/types/string_formats/test.mlf
+7
mlf-lang/tests/lang/unions/closed_union/test.mlf
+7
mlf-lang/tests/lang/unions/closed_union/test.mlf
+8
mlf-lang/tests/lang/unions/nested_union/test.mlf
+8
mlf-lang/tests/lang/unions/nested_union/test.mlf
+7
mlf-lang/tests/lang/unions/open_union/test.mlf
+7
mlf-lang/tests/lang/unions/open_union/test.mlf
+28
tests/Cargo.toml
+28
tests/Cargo.toml
···
1
+
[package]
2
+
name = "mlf-integration-tests"
3
+
version = "0.1.0"
4
+
edition = "2021"
5
+
publish = false
6
+
7
+
# This is a test-only package
8
+
[lib]
9
+
path = "lib.rs"
10
+
11
+
[dependencies]
12
+
mlf-lang = { path = "../mlf-lang" }
13
+
mlf-codegen = { path = "../mlf-codegen" }
14
+
mlf-diagnostics = { path = "../mlf-diagnostics" }
15
+
serde_json = "1.0"
16
+
serde = { version = "1.0", features = ["derive"] }
17
+
toml = "0.8"
18
+
19
+
[dev-dependencies]
20
+
# Any additional test dependencies
21
+
22
+
[[test]]
23
+
name = "codegen_integration"
24
+
path = "codegen_integration.rs"
25
+
26
+
[[test]]
27
+
name = "diagnostics_integration"
28
+
path = "diagnostics_integration.rs"
+292
tests/README.md
+292
tests/README.md
···
1
+
# MLF Integration Test Suite
2
+
3
+
This directory contains workspace-level integration tests that span multiple crates. Unlike per-crate unit tests, these verify end-to-end functionality across the entire MLF toolchain.
4
+
5
+
## Test Organization
6
+
7
+
### By Scope
8
+
9
+
```
10
+
tests/
11
+
├── codegen/ # mlf-codegen: lexicon generation
12
+
│ ├── lexicon/ # JSON lexicon output
13
+
│ ├── typescript/ # mlf-codegen-typescript
14
+
│ ├── rust/ # mlf-codegen-rust
15
+
│ └── go/ # mlf-codegen-go
16
+
├── cli/ # mlf-cli: command-line interface
17
+
├── diagnostics/ # mlf-diagnostics: error formatting
18
+
├── workspace/ # Multi-file resolution, .mlf dirs
19
+
└── real_world/ # Full lexicon suites (bsky, place.stream)
20
+
```
21
+
22
+
### By Crate
23
+
24
+
**Single-crate tests** (in crate's own `tests/` dir):
25
+
- `mlf-lang/tests/` - Language semantics (parsing, validation) - **17 tests ✅**
26
+
- `mlf-codegen/tests/` - Core codegen (if any crate-specific)
27
+
- `mlf-cli/tests/` - CLI-specific unit tests
28
+
29
+
**Multi-crate tests** (in workspace `tests/` dir):
30
+
- Full end-to-end workflows
31
+
- Integration between crates
32
+
- Real-world scenarios
33
+
34
+
## Current Status
35
+
36
+
### ✅ Implemented
37
+
- **mlf-lang/tests/lang/** - 17 tests for parsing and validation
38
+
- **tests/codegen/lexicon/** - 4 tests for lexicon generation
39
+
40
+
### 🚧 Planned
41
+
42
+
#### Codegen Tests
43
+
- **codegen/lexicon/** - MLF → JSON lexicon generation
44
+
- Implicit main resolution
45
+
- Inline type expansion
46
+
- Annotation handling (@key, @encoding)
47
+
- Reference resolution (local vs imported)
48
+
49
+
- **codegen/typescript/** - TypeScript code generation
50
+
- Basic records → interfaces
51
+
- Union types
52
+
- Optional/required fields
53
+
- Import statements
54
+
55
+
- **codegen/rust/** - Rust code generation
56
+
- Structs with serde
57
+
- Enums
58
+
- Lifetimes
59
+
- Option<T> for optional fields
60
+
61
+
- **codegen/go/** - Go code generation
62
+
- Structs with json tags
63
+
- Pointers for optional fields
64
+
65
+
#### CLI Tests
66
+
- **cli/check** - `mlf check` command
67
+
- **cli/generate** - `mlf generate lexicon/code`
68
+
- **cli/validate** - `mlf validate` with schemas
69
+
- **cli/fetch** - `mlf fetch` from network
70
+
- **cli/init** - `mlf init` project setup
71
+
72
+
#### Diagnostics Tests
73
+
- **diagnostics/error_quality** - Error message formatting
74
+
- **diagnostics/suggestions** - Import suggestions, typo corrections
75
+
- **diagnostics/multiple_errors** - Batch error reporting
76
+
77
+
#### Workspace Tests
78
+
- **workspace/local_mlf** - `.mlf/lexicons/` resolution
79
+
- **workspace/home_mlf** - `~/.mlf/lexicons/` resolution
80
+
- **workspace/precedence** - Resolution order (local > home > std)
81
+
- **workspace/sibling_files** - Multi-file modules
82
+
83
+
#### Real-World Tests
84
+
- **real_world/bsky** - Full app.bsky.* lexicons
85
+
- **real_world/place_stream** - Full place.stream.* lexicons
86
+
- **real_world/atproto** - Full com.atproto.* lexicons
87
+
- **real_world/bidirectional** - Roundtrip MLF ↔ JSON
88
+
89
+
## Running Tests
90
+
91
+
We use [just](https://github.com/casey/just) for test execution. Install with: `cargo install just`
92
+
93
+
### Quick Start
94
+
```bash
95
+
# Run all tests (recommended)
96
+
just test
97
+
98
+
# Run specific test category
99
+
just test-lang # Language tests (17 tests)
100
+
just test-codegen # Codegen tests (4 tests)
101
+
just test-validation # Validation tests (12 tests)
102
+
103
+
# Future test categories
104
+
just test-cli # CLI integration tests
105
+
just test-diagnostics # Error message tests
106
+
just test-workspace # Multi-file resolution tests
107
+
just test-real-world # Full lexicon suites
108
+
109
+
# Other useful commands
110
+
just test-all # All workspace tests (includes unit tests)
111
+
just test-verbose # Tests with verbose output
112
+
just test-stats # Show test statistics
113
+
just test-list # List all test directories
114
+
```
115
+
116
+
### Using Cargo Directly
117
+
```bash
118
+
# All tests (excluding problematic packages)
119
+
cargo test --workspace --exclude tree-sitter-mlf --exclude mlf-wasm
120
+
121
+
# Specific test suite
122
+
cargo test -p mlf-lang --test integration_test
123
+
cargo test -p mlf-integration-tests --test codegen_integration
124
+
125
+
# With output
126
+
cargo test -p mlf-lang --test integration_test -- --nocapture
127
+
```
128
+
129
+
## Test Infrastructure
130
+
131
+
### Rust-based Test Runner
132
+
All integration tests use automatic test discovery:
133
+
- Test cases in directories with `input.mlf` + `expected.json`
134
+
- Test runner walks directories and executes each test
135
+
- Clear pass/fail reporting with ✓/✗ indicators
136
+
- Used for: lang, codegen, diagnostics, workspace tests
137
+
138
+
### Just Recipes
139
+
The `justfile` at the workspace root provides convenient test execution:
140
+
- No shell scripts needed
141
+
- Consistent interface across test types
142
+
- Proper exclusion of problematic packages
143
+
- Easy to extend for new test categories
144
+
145
+
## Writing Multi-Crate Tests
146
+
147
+
### Example: Codegen Test
148
+
149
+
```
150
+
tests/codegen/lexicon/basic_record/
151
+
├── input.mlf # MLF source
152
+
├── expected.json # Expected lexicon output
153
+
└── test_config.toml # Test metadata
154
+
```
155
+
156
+
Test runner:
157
+
```rust
158
+
// tests/codegen_integration.rs
159
+
use mlf_lang::{parser::parse_lexicon, Workspace};
160
+
use mlf_codegen::LexiconGenerator;
161
+
162
+
#[test]
163
+
fn codegen_tests() {
164
+
for test_dir in discover_tests("tests/codegen") {
165
+
let mlf = read_mlf(test_dir);
166
+
let expected = read_expected(test_dir);
167
+
168
+
// Parse (mlf-lang)
169
+
let lexicon = parse_lexicon(&mlf).unwrap();
170
+
171
+
// Generate (mlf-codegen)
172
+
let output = LexiconGenerator::generate(lexicon).unwrap();
173
+
174
+
// Compare
175
+
assert_eq!(output, expected);
176
+
}
177
+
}
178
+
```
179
+
180
+
### Example: CLI Test
181
+
182
+
CLI tests follow the same pattern as codegen tests - Rust-based test runner with automatic discovery:
183
+
184
+
```
185
+
tests/cli/check_command/
186
+
├── input.mlf # MLF source to check
187
+
├── expected.json # Expected result (status + output)
188
+
└── test_config.toml # CLI args to pass
189
+
```
190
+
191
+
Test runner:
192
+
```rust
193
+
// tests/cli_integration.rs
194
+
use std::process::Command;
195
+
196
+
#[test]
197
+
fn cli_tests() {
198
+
for test_dir in discover_tests("tests/cli") {
199
+
let input = read_mlf(test_dir);
200
+
let expected = read_expected(test_dir);
201
+
202
+
// Run CLI command
203
+
let output = Command::new("mlf")
204
+
.arg("check")
205
+
.arg(input_path)
206
+
.output()
207
+
.unwrap();
208
+
209
+
// Verify exit code and output
210
+
assert_eq!(output.status.success(), expected.success);
211
+
assert_eq!(String::from_utf8_lossy(&output.stdout), expected.stdout);
212
+
}
213
+
}
214
+
```
215
+
216
+
## Test File Conventions
217
+
218
+
### Required Files
219
+
220
+
Each test directory must contain:
221
+
222
+
1. **`test.toml`** - Test configuration (REQUIRED for multi-file tests)
223
+
```toml
224
+
[test]
225
+
name = "namespace_alias"
226
+
description = "Test namespace aliasing"
227
+
namespace = "com.example.thing" # For codegen tests
228
+
229
+
# For multi-file lang tests, specify namespace per file
230
+
[modules]
231
+
"test.mlf" = "com.example.thing"
232
+
"defs.mlf" = "com.example.defs"
233
+
```
234
+
235
+
2. **MLF source files**
236
+
- `test.mlf` - Main test file (lang tests)
237
+
- `input.mlf` - Main input file (codegen tests)
238
+
- Additional `.mlf` files as needed (specified in test.toml)
239
+
240
+
3. **Expected results**
241
+
- `expected.json` - Expected output (status, defs, or errors)
242
+
- For codegen: Full lexicon JSON output
243
+
- For lang: `{"status": "success"}` or `{"status": "error", "errors": [...]}`
244
+
245
+
### Example Test Structures
246
+
247
+
**Lang test** (single file):
248
+
```
249
+
tests/lang/constraints/known_values/
250
+
├── test.toml # Optional: auto-derives namespace if missing
251
+
├── test.mlf
252
+
└── expected.json
253
+
```
254
+
255
+
**Lang test** (multiple files):
256
+
```
257
+
tests/lang/namespace_imports/namespace_alias/
258
+
├── test.toml # Required: maps filenames to namespaces
259
+
├── test.mlf
260
+
├── defs.mlf
261
+
└── expected.json
262
+
```
263
+
264
+
**Codegen test**:
265
+
```
266
+
tests/codegen/lexicon/basic_record/
267
+
├── test.toml # Required: specifies namespace
268
+
├── input.mlf
269
+
└── expected.json # Full lexicon JSON
270
+
```
271
+
272
+
## Benefits of Workspace-Level Tests
273
+
274
+
1. **Cross-crate integration** - Test full workflows (parse → validate → codegen)
275
+
2. **Real-world scenarios** - Actual user workflows, not isolated units
276
+
3. **Regression prevention** - Catch breaking changes across crate boundaries
277
+
4. **Living documentation** - Show how crates work together
278
+
5. **CI/CD validation** - One command tests entire toolchain
279
+
280
+
## Migration Plan
281
+
282
+
1. ✅ Keep current mlf-lang tests where they are
283
+
2. 🚧 Create workspace-level test runners
284
+
3. 🚧 Add codegen tests (require mlf-codegen)
285
+
4. 🚧 Add CLI tests (require mlf-cli)
286
+
5. 🚧 Add real-world tests (require all crates)
287
+
288
+
## See Also
289
+
290
+
- `mlf-lang/tests/README.md` - Language-specific test docs
291
+
- `mlf-cli/tests/README.md` - CLI test docs
292
+
- `CLAUDE.md` - Project overview and architecture
+179
tests/STRUCTURE.md
+179
tests/STRUCTURE.md
···
1
+
# Test Structure Overview
2
+
3
+
## Two-Level Test Organization
4
+
5
+
### Level 1: Per-Crate Tests
6
+
Located in each crate's `tests/` directory. Tests that crate in isolation.
7
+
8
+
```
9
+
mlf-lang/tests/ # Parsing, validation, workspace
10
+
mlf-codegen/tests/ # Core codegen logic (if any)
11
+
mlf-cli/tests/ # CLI-specific units
12
+
mlf-diagnostics/tests/ # Diagnostics formatting
13
+
```
14
+
15
+
**Characteristics:**
16
+
- ✅ Fast (single crate dependency)
17
+
- ✅ Focused (one crate's API)
18
+
- ✅ Independent (no cross-crate setup)
19
+
- ❌ Limited scope (can't test full workflows)
20
+
21
+
### Level 2: Workspace Tests
22
+
Located at workspace root `tests/`. Tests multiple crates working together.
23
+
24
+
```
25
+
tests/
26
+
├── lang/ # Language features (uses mlf-lang)
27
+
├── codegen/ # Code generation (uses mlf-lang + mlf-codegen)
28
+
├── cli/ # CLI workflows (uses mlf-cli + dependencies)
29
+
├── diagnostics/ # Error messages (uses mlf-diagnostics + mlf-lang)
30
+
├── workspace/ # Multi-file resolution
31
+
└── real_world/ # Full lexicon suites
32
+
```
33
+
34
+
**Characteristics:**
35
+
- ✅ Comprehensive (full workflows)
36
+
- ✅ Realistic (actual user scenarios)
37
+
- ✅ Integration (catch cross-crate issues)
38
+
- ❌ Slower (multiple crate compilation)
39
+
40
+
## Current State
41
+
42
+
```
43
+
✅ mlf-lang/tests/lang/ 17 tests (parsing, validation, imports)
44
+
📝 tests/codegen/ (4 test cases ready, runner implemented)
45
+
📝 tests/cli/ (structure created, tests pending)
46
+
📝 tests/diagnostics/ (structure created, tests pending)
47
+
📝 tests/workspace/ (structure created, tests pending)
48
+
📝 tests/real_world/ (structure created, tests pending)
49
+
```
50
+
51
+
## Decision Tree: Where Does My Test Go?
52
+
53
+
```
54
+
┌─────────────────────────────────────┐
55
+
│ Does this test require multiple │
56
+
│ crates? (CLI, codegen, diagnostics) │
57
+
└─────────────┬───────────────────────┘
58
+
│
59
+
┌─────────┴─────────┐
60
+
│ YES │ NO
61
+
│ │
62
+
▼ ▼
63
+
┌───────────────┐ ┌──────────────────┐
64
+
│ Workspace │ │ Does it test │
65
+
│ tests/ │ │ mlf-lang │
66
+
│ │ │ internals? │
67
+
└───────────────┘ └────────┬─────────┘
68
+
│
69
+
┌─────────┴─────────┐
70
+
│ YES │ NO
71
+
│ │
72
+
▼ ▼
73
+
┌──────────────┐ ┌──────────────┐
74
+
│ mlf-lang/ │ │ Other crate/ │
75
+
│ tests/ │ │ tests/ │
76
+
└──────────────┘ └──────────────┘
77
+
```
78
+
79
+
## Examples
80
+
81
+
### ✅ mlf-lang/tests/
82
+
```rust
83
+
// Tests parsing and validation only
84
+
#[test]
85
+
fn test_namespace_alias() {
86
+
let mut ws = Workspace::with_std().unwrap();
87
+
// ... add modules, resolve, check results
88
+
}
89
+
```
90
+
91
+
### ✅ tests/codegen/
92
+
```rust
93
+
// Tests parsing + codegen together
94
+
#[test]
95
+
fn test_lexicon_generation() {
96
+
// Parse (mlf-lang)
97
+
let lexicon = parse_lexicon(&mlf).unwrap();
98
+
99
+
// Generate (mlf-codegen)
100
+
let json = LexiconGenerator::generate(lexicon).unwrap();
101
+
102
+
assert_eq!(json, expected);
103
+
}
104
+
```
105
+
106
+
### ✅ tests/cli/
107
+
```bash
108
+
#!/bin/bash
109
+
# Tests full CLI workflow
110
+
echo 'record foo { bar!: string; }' > test.mlf
111
+
mlf generate lexicon test.mlf -o output.json
112
+
diff output.json expected.json
113
+
```
114
+
115
+
## Test Execution
116
+
117
+
### Run everything
118
+
```bash
119
+
cargo test --workspace
120
+
```
121
+
122
+
### Run workspace tests only
123
+
```bash
124
+
cargo test --tests # From workspace root
125
+
```
126
+
127
+
### Run specific crate tests
128
+
```bash
129
+
cargo test -p mlf-lang
130
+
cargo test -p mlf-codegen
131
+
```
132
+
133
+
### Run specific category
134
+
```bash
135
+
cargo test --test codegen_integration
136
+
cd tests/cli && ./run_all.sh
137
+
```
138
+
139
+
## Benefits of This Structure
140
+
141
+
1. **Fast feedback loop** - Crate tests run quickly during development
142
+
2. **Comprehensive validation** - Workspace tests catch integration issues
143
+
3. **Clear boundaries** - Easy to know where tests belong
144
+
4. **Flexible CI/CD** - Can run crate tests first, workspace tests later
145
+
5. **Documentation** - Tests show both isolated and integrated usage
146
+
147
+
## Adding New Tests
148
+
149
+
### For Single-Crate Features
150
+
```bash
151
+
# Example: Add constraint test to mlf-lang
152
+
cd mlf-lang/tests/lang/constraints
153
+
mkdir new_constraint_test
154
+
echo '...' > new_constraint_test/test.mlf
155
+
echo '{"status": "success"}' > new_constraint_test/expected.json
156
+
cargo test -p mlf-lang --test integration_test
157
+
```
158
+
159
+
### For Multi-Crate Features
160
+
```bash
161
+
# Example: Add TypeScript codegen test
162
+
cd tests/codegen/typescript
163
+
mkdir basic_union
164
+
echo '...' > basic_union/input.mlf
165
+
echo '...' > basic_union/expected.ts
166
+
# Update tests/codegen_integration.rs
167
+
cargo test --test codegen_integration
168
+
```
169
+
170
+
## Migration Status
171
+
172
+
- [x] Create workspace test structure
173
+
- [x] Document test organization
174
+
- [x] Copy lang tests to workspace (for future expansion)
175
+
- [ ] Create codegen test runner
176
+
- [ ] Create CLI test runner
177
+
- [ ] Add first codegen test
178
+
- [ ] Add first CLI test
179
+
- [ ] Add real-world lexicon tests
+121
tests/cli/README.md
+121
tests/cli/README.md
···
1
+
# CLI Integration Tests
2
+
3
+
Rust-based integration tests for the `mlf` command-line interface. These tests verify end-to-end CLI workflows by invoking the actual binary.
4
+
5
+
## Structure
6
+
7
+
```
8
+
tests/cli/
9
+
├── README.md (this file)
10
+
├── check_command/ # mlf check tests
11
+
│ ├── valid_file/
12
+
│ │ ├── input.mlf
13
+
│ │ └── expected.json
14
+
│ └── invalid_syntax/
15
+
│ ├── input.mlf
16
+
│ └── expected.json
17
+
├── generate_command/ # mlf generate tests
18
+
│ ├── lexicon_output/
19
+
│ └── typescript_output/
20
+
└── validate_command/ # mlf validate tests
21
+
└── basic_validation/
22
+
```
23
+
24
+
## Writing CLI Tests
25
+
26
+
Each test case is a directory with:
27
+
- `input.mlf` - The MLF source file to test
28
+
- `expected.json` - Expected output (status, stdout, stderr)
29
+
- `args.txt` - CLI arguments (optional, one per line)
30
+
31
+
### Example Test Case
32
+
33
+
```
34
+
tests/cli/check_command/valid_file/
35
+
├── input.mlf
36
+
├── expected.json
37
+
└── args.txt
38
+
```
39
+
40
+
**input.mlf:**
41
+
```mlf
42
+
record post {
43
+
text!: string,
44
+
createdAt!: datetime,
45
+
}
46
+
```
47
+
48
+
**expected.json:**
49
+
```json
50
+
{
51
+
"status": "success",
52
+
"exit_code": 0,
53
+
"stdout": "",
54
+
"stderr": ""
55
+
}
56
+
```
57
+
58
+
**args.txt:**
59
+
```
60
+
check
61
+
{input}
62
+
```
63
+
64
+
## Running Tests
65
+
66
+
```bash
67
+
# All CLI tests (via just)
68
+
just test-cli
69
+
70
+
# Or via cargo
71
+
cargo test -p mlf-integration-tests --test cli_integration -- --nocapture
72
+
73
+
# Build CLI first if needed
74
+
cargo build --release
75
+
```
76
+
77
+
## Test Categories
78
+
79
+
### check_command
80
+
- ⏳ Valid MLF files pass
81
+
- ⏳ Invalid MLF files fail with error
82
+
- ⏳ Missing files return proper error
83
+
- ⏳ Multiple files are checked
84
+
85
+
### generate_command
86
+
- ⏳ Generate lexicon JSON
87
+
- ⏳ Generate TypeScript code
88
+
- ⏳ Generate Rust code
89
+
- ⏳ Generate Go code
90
+
- ⏳ Output to specific directory
91
+
92
+
### validate_command
93
+
- ⏳ Validate JSON against MLF schema
94
+
- ⏳ Detect validation errors
95
+
- ⏳ Batch validation
96
+
97
+
### fetch_command
98
+
- ⏳ Fetch lexicon from network
99
+
- ⏳ Cache downloaded lexicons
100
+
- ⏳ Update existing lexicons
101
+
102
+
### init_command
103
+
- ⏳ Initialize new project
104
+
- ⏳ Create .mlf directory structure
105
+
- ⏳ Don't overwrite existing files
106
+
107
+
## Test Runner Implementation
108
+
109
+
The test runner (`tests/cli_integration.rs`) will:
110
+
1. Discover test directories automatically
111
+
2. Build the CLI binary if needed
112
+
3. Execute commands via `std::process::Command`
113
+
4. Compare output against expected results
114
+
5. Report pass/fail with clear error messages
115
+
116
+
This follows the same pattern as our codegen tests, providing:
117
+
- **Automatic discovery** - No manual test registration
118
+
- **File-based tests** - Easy to add new test cases
119
+
- **Clear output** - ✓/✗ indicators for each test
120
+
- **Version control friendly** - All test data in files
121
+
- **No shell scripting** - Pure Rust test infrastructure
+43
tests/cli/run_all.sh
+43
tests/cli/run_all.sh
···
1
+
#!/bin/bash
2
+
# Run all CLI integration tests
3
+
4
+
set -e
5
+
6
+
# Colors for output
7
+
GREEN='\033[0;32m'
8
+
RED='\033[0;31m'
9
+
NC='\033[0m' # No Color
10
+
11
+
# Ensure mlf is built
12
+
if [ ! -f "../../target/release/mlf" ]; then
13
+
echo "Building mlf..."
14
+
cd ../.. && cargo build --release && cd tests/cli
15
+
fi
16
+
17
+
# Add mlf to PATH
18
+
export PATH="$PWD/../../target/release:$PATH"
19
+
20
+
# Track results
21
+
PASSED=0
22
+
FAILED=0
23
+
24
+
# Run all test scripts
25
+
for test_file in $(find . -name "*.sh" -not -name "run_all.sh" | sort); do
26
+
test_name=$(basename $(dirname $test_file))/$(basename $test_file)
27
+
28
+
if bash "$test_file" > /dev/null 2>&1; then
29
+
echo -e "${GREEN}✓${NC} $test_name"
30
+
((PASSED++))
31
+
else
32
+
echo -e "${RED}✗${NC} $test_name"
33
+
((FAILED++))
34
+
fi
35
+
done
36
+
37
+
# Summary
38
+
echo ""
39
+
echo "Results: $PASSED passed, $FAILED failed"
40
+
41
+
if [ $FAILED -gt 0 ]; then
42
+
exit 1
43
+
fi
+21
tests/codegen/lexicon/annotations/expected.json
+21
tests/codegen/lexicon/annotations/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.post",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "custom-key",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["text"],
13
+
"properties": {
14
+
"text": {
15
+
"type": "string"
16
+
}
17
+
}
18
+
}
19
+
}
20
+
}
21
+
}
+4
tests/codegen/lexicon/annotations/input.mlf
+4
tests/codegen/lexicon/annotations/input.mlf
+4
tests/codegen/lexicon/annotations/test.toml
+4
tests/codegen/lexicon/annotations/test.toml
+24
tests/codegen/lexicon/basic_record/expected.json
+24
tests/codegen/lexicon/basic_record/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "app.bsky.feed.post",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["text", "createdAt"],
13
+
"properties": {
14
+
"text": {
15
+
"type": "string"
16
+
},
17
+
"createdAt": {
18
+
"type": "string"
19
+
}
20
+
}
21
+
}
22
+
}
23
+
}
24
+
}
+4
tests/codegen/lexicon/basic_record/input.mlf
+4
tests/codegen/lexicon/basic_record/input.mlf
+4
tests/codegen/lexicon/basic_record/test.toml
+4
tests/codegen/lexicon/basic_record/test.toml
+40
tests/codegen/lexicon/implicit_main/expected.json
+40
tests/codegen/lexicon/implicit_main/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.profile",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["name"],
13
+
"properties": {
14
+
"name": {
15
+
"type": "string"
16
+
},
17
+
"color": {
18
+
"type": "ref",
19
+
"ref": "#color"
20
+
}
21
+
}
22
+
}
23
+
},
24
+
"color": {
25
+
"type": "object",
26
+
"required": ["red", "green", "blue"],
27
+
"properties": {
28
+
"red": {
29
+
"type": "integer"
30
+
},
31
+
"green": {
32
+
"type": "integer"
33
+
},
34
+
"blue": {
35
+
"type": "integer"
36
+
}
37
+
}
38
+
}
39
+
}
40
+
}
+10
tests/codegen/lexicon/implicit_main/input.mlf
+10
tests/codegen/lexicon/implicit_main/input.mlf
+4
tests/codegen/lexicon/implicit_main/test.toml
+4
tests/codegen/lexicon/implicit_main/test.toml
+32
tests/codegen/lexicon/integer_constraints/expected.json
+32
tests/codegen/lexicon/integer_constraints/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.integer_constraints",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["age", "temperature"],
13
+
"properties": {
14
+
"age": {
15
+
"type": "integer",
16
+
"minimum": 0,
17
+
"maximum": 150
18
+
},
19
+
"score": {
20
+
"type": "integer",
21
+
"minimum": 0
22
+
},
23
+
"temperature": {
24
+
"type": "integer",
25
+
"minimum": -100,
26
+
"maximum": 100
27
+
}
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
+13
tests/codegen/lexicon/integer_constraints/input.mlf
+13
tests/codegen/lexicon/integer_constraints/input.mlf
+4
tests/codegen/lexicon/integer_constraints/test.toml
+4
tests/codegen/lexicon/integer_constraints/test.toml
+37
tests/codegen/lexicon/local_references/expected.json
+37
tests/codegen/lexicon/local_references/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.document",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["title", "meta"],
13
+
"properties": {
14
+
"title": {
15
+
"type": "string"
16
+
},
17
+
"meta": {
18
+
"type": "ref",
19
+
"ref": "#metadata"
20
+
}
21
+
}
22
+
}
23
+
},
24
+
"metadata": {
25
+
"type": "object",
26
+
"required": ["createdAt", "updatedAt"],
27
+
"properties": {
28
+
"createdAt": {
29
+
"type": "string"
30
+
},
31
+
"updatedAt": {
32
+
"type": "string"
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
+12
tests/codegen/lexicon/local_references/input.mlf
+12
tests/codegen/lexicon/local_references/input.mlf
+4
tests/codegen/lexicon/local_references/test.toml
+4
tests/codegen/lexicon/local_references/test.toml
+51
tests/codegen/lexicon/nested_objects/expected.json
+51
tests/codegen/lexicon/nested_objects/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.nested_objects",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["displayName"],
13
+
"properties": {
14
+
"displayName": {
15
+
"type": "string"
16
+
},
17
+
"metadata": {
18
+
"type": "object",
19
+
"required": ["createdAt"],
20
+
"properties": {
21
+
"createdAt": {
22
+
"type": "string"
23
+
},
24
+
"settings": {
25
+
"type": "object",
26
+
"required": ["theme"],
27
+
"properties": {
28
+
"theme": {
29
+
"type": "string"
30
+
},
31
+
"notifications": {
32
+
"type": "object",
33
+
"required": ["email"],
34
+
"properties": {
35
+
"email": {
36
+
"type": "boolean"
37
+
},
38
+
"push": {
39
+
"type": "boolean"
40
+
}
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
49
+
}
50
+
}
51
+
}
+13
tests/codegen/lexicon/nested_objects/input.mlf
+13
tests/codegen/lexicon/nested_objects/input.mlf
+4
tests/codegen/lexicon/nested_objects/test.toml
+4
tests/codegen/lexicon/nested_objects/test.toml
+27
tests/codegen/lexicon/record_key_any/expected.json
+27
tests/codegen/lexicon/record_key_any/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.record_key_any",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "any",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["title", "content", "slug"],
13
+
"properties": {
14
+
"title": {
15
+
"type": "string"
16
+
},
17
+
"content": {
18
+
"type": "string"
19
+
},
20
+
"slug": {
21
+
"type": "string"
22
+
}
23
+
}
24
+
}
25
+
}
26
+
}
27
+
}
+6
tests/codegen/lexicon/record_key_any/input.mlf
+6
tests/codegen/lexicon/record_key_any/input.mlf
+4
tests/codegen/lexicon/record_key_any/test.toml
+4
tests/codegen/lexicon/record_key_any/test.toml
+27
tests/codegen/lexicon/record_key_literal/expected.json
+27
tests/codegen/lexicon/record_key_literal/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.record_key_literal",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "literal:self",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["displayName"],
13
+
"properties": {
14
+
"displayName": {
15
+
"type": "string"
16
+
},
17
+
"bio": {
18
+
"type": "string"
19
+
},
20
+
"avatar": {
21
+
"type": "string"
22
+
}
23
+
}
24
+
}
25
+
}
26
+
}
27
+
}
+6
tests/codegen/lexicon/record_key_literal/input.mlf
+6
tests/codegen/lexicon/record_key_literal/input.mlf
+4
tests/codegen/lexicon/record_key_literal/test.toml
+4
tests/codegen/lexicon/record_key_literal/test.toml
+33
tests/codegen/lexicon/string_constraints/expected.json
+33
tests/codegen/lexicon/string_constraints/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.string_constraints",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["username", "displayName"],
13
+
"properties": {
14
+
"username": {
15
+
"type": "string",
16
+
"minLength": 3,
17
+
"maxLength": 20
18
+
},
19
+
"bio": {
20
+
"type": "string",
21
+
"maxGraphemes": 256
22
+
},
23
+
"displayName": {
24
+
"type": "string",
25
+
"minGraphemes": 1,
26
+
"maxGraphemes": 64,
27
+
"maxLength": 640
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
+14
tests/codegen/lexicon/string_constraints/input.mlf
+14
tests/codegen/lexicon/string_constraints/input.mlf
+4
tests/codegen/lexicon/string_constraints/test.toml
+4
tests/codegen/lexicon/string_constraints/test.toml
+34
tests/codegen/lexicon/union_types/expected.json
+34
tests/codegen/lexicon/union_types/expected.json
···
1
+
{
2
+
"$type": "com.atproto.lexicon.schema",
3
+
"lexicon": 1,
4
+
"id": "com.example.union_types",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["content"],
13
+
"properties": {
14
+
"content": {
15
+
"type": "union",
16
+
"refs": [
17
+
{"type": "string"},
18
+
{"type": "integer"},
19
+
{"type": "boolean"}
20
+
]
21
+
},
22
+
"media": {
23
+
"type": "union",
24
+
"refs": [
25
+
{"type": "string"},
26
+
{"type": "integer"}
27
+
],
28
+
"closed": true
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
34
+
}
+4
tests/codegen/lexicon/union_types/input.mlf
+4
tests/codegen/lexicon/union_types/input.mlf
+4
tests/codegen/lexicon/union_types/test.toml
+4
tests/codegen/lexicon/union_types/test.toml
+103
tests/codegen_integration.rs
+103
tests/codegen_integration.rs
···
1
+
// Workspace-level integration tests for code generation
2
+
// Tests mlf-lang + mlf-codegen working together
3
+
4
+
use mlf_codegen::generate_lexicon;
5
+
use mlf_integration_tests::test_utils;
6
+
use mlf_lang::{parser::parse_lexicon, Workspace};
7
+
use serde_json::Value;
8
+
use std::fs;
9
+
use std::path::Path;
10
+
11
+
#[test]
12
+
fn codegen_lexicon_tests() {
13
+
// CARGO_MANIFEST_DIR points to tests/ directory
14
+
let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
15
+
let test_base = format!("{}/codegen/lexicon", manifest_dir);
16
+
let test_dirs = test_utils::discover_test_dirs(&test_base);
17
+
18
+
let tests: Vec<(String, Result<(), String>)> = test_dirs
19
+
.into_iter()
20
+
.map(|test_dir| {
21
+
let test_name = format!(
22
+
"codegen/lexicon/{}",
23
+
Path::new(&test_dir).file_name().unwrap().to_str().unwrap()
24
+
);
25
+
let result = run_lexicon_test(&test_dir);
26
+
(test_name, result)
27
+
})
28
+
.collect();
29
+
30
+
let (passed, failed) = test_utils::run_and_report_tests::<fn(&str) -> Result<(), String>>(tests, "Codegen");
31
+
32
+
if !failed.is_empty() {
33
+
panic!(
34
+
"\nFailed tests:\n{}",
35
+
failed
36
+
.iter()
37
+
.map(|(name, err)| format!(" - {}: {}", name, err))
38
+
.collect::<Vec<_>>()
39
+
.join("\n")
40
+
);
41
+
}
42
+
}
43
+
44
+
fn derive_namespace_fallback(test_name: &str) -> String {
45
+
match test_name {
46
+
"basic_record" => "app.bsky.feed.post".to_string(),
47
+
_ => format!("com.example.{}", test_name),
48
+
}
49
+
}
50
+
51
+
fn run_lexicon_test(test_dir: &str) -> Result<(), String> {
52
+
// 1. Load test configuration
53
+
let config = test_utils::load_test_config(
54
+
Path::new(test_dir),
55
+
|test_name| derive_namespace_fallback(test_name)
56
+
)?;
57
+
58
+
// 2. Get namespace from config
59
+
let namespace = config.test.namespace
60
+
.ok_or_else(|| "No namespace specified in test.toml".to_string())?;
61
+
62
+
// 3. Read input.mlf
63
+
let input_path = format!("{}/input.mlf", test_dir);
64
+
let input = fs::read_to_string(&input_path)
65
+
.map_err(|e| format!("Failed to read input.mlf: {}", e))?;
66
+
67
+
// 4. Parse with mlf-lang
68
+
let lexicon = parse_lexicon(&input)
69
+
.map_err(|e| format!("Failed to parse: {:?}", e))?;
70
+
71
+
// 4. Create workspace and resolve
72
+
let mut ws = Workspace::with_std()
73
+
.map_err(|e| format!("Failed to create workspace: {:?}", e))?;
74
+
ws.add_module(namespace.clone(), lexicon)
75
+
.map_err(|e| format!("Failed to add module: {:?}", e))?;
76
+
ws.resolve()
77
+
.map_err(|e| format!("Failed to resolve: {:?}", e))?;
78
+
79
+
// 5. Get lexicon from workspace
80
+
let lexicon = ws.get_lexicon(&namespace)
81
+
.ok_or_else(|| "Module not found".to_string())?;
82
+
83
+
// 6. Generate lexicon JSON
84
+
let output_json = generate_lexicon(&namespace, lexicon, &ws);
85
+
86
+
// 7. Read expected output
87
+
let expected_path = format!("{}/expected.json", test_dir);
88
+
let expected_str = fs::read_to_string(&expected_path)
89
+
.map_err(|e| format!("Failed to read expected.json: {}", e))?;
90
+
let expected_json: Value = serde_json::from_str(&expected_str)
91
+
.map_err(|e| format!("Failed to parse expected.json: {}", e))?;
92
+
93
+
// 8. Compare (normalize both to avoid whitespace issues)
94
+
if output_json != expected_json {
95
+
return Err(format!(
96
+
"Output mismatch:\nExpected:\n{}\n\nGot:\n{}",
97
+
serde_json::to_string_pretty(&expected_json).unwrap(),
98
+
serde_json::to_string_pretty(&output_json).unwrap()
99
+
));
100
+
}
101
+
102
+
Ok(())
103
+
}
+9
tests/diagnostics/undefined_reference/expected.json
+9
tests/diagnostics/undefined_reference/expected.json
+4
tests/diagnostics/undefined_reference/input.mlf
+4
tests/diagnostics/undefined_reference/input.mlf
+4
tests/diagnostics/undefined_reference/test.toml
+4
tests/diagnostics/undefined_reference/test.toml
+155
tests/diagnostics_integration.rs
+155
tests/diagnostics_integration.rs
···
1
+
// Workspace-level integration tests for diagnostics
2
+
// Tests mlf-lang + mlf-diagnostics working together
3
+
4
+
use mlf_diagnostics::{get_error_module_namespace_str, ValidationDiagnostic};
5
+
use mlf_integration_tests::test_utils;
6
+
use mlf_lang::{parser::parse_lexicon, Workspace};
7
+
use serde::Deserialize;
8
+
use serde_json::Value;
9
+
use std::fs;
10
+
use std::path::Path;
11
+
12
+
#[derive(Debug, Deserialize)]
13
+
struct ExpectedDiagnostic {
14
+
error_count: usize,
15
+
errors: Vec<ExpectedError>,
16
+
}
17
+
18
+
#[derive(Debug, Deserialize)]
19
+
struct ExpectedError {
20
+
code: String,
21
+
message: String,
22
+
#[serde(default)]
23
+
span: Option<ExpectedSpan>,
24
+
}
25
+
26
+
#[derive(Debug, Deserialize)]
27
+
struct ExpectedSpan {
28
+
start: usize,
29
+
end: usize,
30
+
}
31
+
32
+
#[test]
33
+
fn diagnostics_tests() {
34
+
let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
35
+
let test_base = format!("{}/diagnostics", manifest_dir);
36
+
let test_dirs = test_utils::discover_test_dirs(&test_base);
37
+
38
+
let tests: Vec<(String, Result<(), String>)> = test_dirs
39
+
.into_iter()
40
+
.map(|test_dir| {
41
+
let test_name = format!(
42
+
"diagnostics/{}",
43
+
Path::new(&test_dir).file_name().unwrap().to_str().unwrap()
44
+
);
45
+
let result = run_diagnostics_test(&test_dir);
46
+
(test_name, result)
47
+
})
48
+
.collect();
49
+
50
+
let (passed, failed) = test_utils::run_and_report_tests::<fn(&str) -> Result<(), String>>(tests, "Diagnostics");
51
+
52
+
if !failed.is_empty() {
53
+
panic!(
54
+
"\nFailed tests:\n{}",
55
+
failed
56
+
.iter()
57
+
.map(|(name, err)| format!(" - {}: {}", name, err))
58
+
.collect::<Vec<_>>()
59
+
.join("\n")
60
+
);
61
+
}
62
+
}
63
+
64
+
fn derive_namespace_fallback(test_name: &str) -> String {
65
+
format!("test.{}", test_name)
66
+
}
67
+
68
+
fn run_diagnostics_test(test_dir: &str) -> Result<(), String> {
69
+
// 1. Load test configuration
70
+
let config = test_utils::load_test_config(
71
+
Path::new(test_dir),
72
+
|test_name| derive_namespace_fallback(test_name)
73
+
)?;
74
+
75
+
let namespace = config.test.namespace
76
+
.ok_or_else(|| "No namespace specified in test.toml".to_string())?;
77
+
78
+
// 2. Read input.mlf
79
+
let input_path = format!("{}/input.mlf", test_dir);
80
+
let input = fs::read_to_string(&input_path)
81
+
.map_err(|e| format!("Failed to read input.mlf: {}", e))?;
82
+
83
+
// 3. Parse with mlf-lang
84
+
let lexicon = parse_lexicon(&input)
85
+
.map_err(|e| format!("Failed to parse: {:?}", e))?;
86
+
87
+
// 4. Create workspace and resolve (expect errors)
88
+
let mut ws = Workspace::with_std()
89
+
.map_err(|e| format!("Failed to create workspace: {:?}", e))?;
90
+
ws.add_module(namespace.clone(), lexicon)
91
+
.map_err(|e| format!("Failed to add module: {:?}", e))?;
92
+
93
+
let validation_errors = match ws.resolve() {
94
+
Ok(()) => return Err("Expected validation errors but got none".to_string()),
95
+
Err(errors) => errors,
96
+
};
97
+
98
+
// 5. Create diagnostic
99
+
let diagnostic = ValidationDiagnostic::new(
100
+
"input.mlf".to_string(),
101
+
input.clone(),
102
+
namespace.clone(),
103
+
validation_errors.clone(),
104
+
);
105
+
106
+
// 6. Read expected output
107
+
let expected_path = format!("{}/expected.json", test_dir);
108
+
let expected_str = fs::read_to_string(&expected_path)
109
+
.map_err(|e| format!("Failed to read expected.json: {}", e))?;
110
+
let expected: ExpectedDiagnostic = serde_json::from_str(&expected_str)
111
+
.map_err(|e| format!("Failed to parse expected.json: {}", e))?;
112
+
113
+
// 7. Filter errors to this module
114
+
let errors_in_module: Vec<_> = validation_errors
115
+
.errors
116
+
.iter()
117
+
.filter(|e| get_error_module_namespace_str(e) == namespace)
118
+
.collect();
119
+
120
+
// 8. Verify error count
121
+
if errors_in_module.len() != expected.error_count {
122
+
return Err(format!(
123
+
"Expected {} errors but got {}",
124
+
expected.error_count,
125
+
errors_in_module.len()
126
+
));
127
+
}
128
+
129
+
// 9. Verify each error
130
+
for (i, expected_error) in expected.errors.iter().enumerate() {
131
+
if i >= errors_in_module.len() {
132
+
return Err(format!("Expected error #{} but only got {} errors", i + 1, errors_in_module.len()));
133
+
}
134
+
135
+
let actual_error = errors_in_module[i];
136
+
137
+
// Check error code
138
+
let actual_code = mlf_diagnostics::get_error_module_namespace_str(actual_error);
139
+
140
+
// Format the error message
141
+
let actual_message = format!("{:?}", actual_error);
142
+
143
+
// Verify message contains expected text
144
+
if !actual_message.contains(&expected_error.message) {
145
+
return Err(format!(
146
+
"Error #{}: Expected message to contain '{}' but got: {}",
147
+
i + 1,
148
+
expected_error.message,
149
+
actual_message
150
+
));
151
+
}
152
+
}
153
+
154
+
Ok(())
155
+
}
+155
tests/test_utils.rs
+155
tests/test_utils.rs
···
1
+
// Shared utilities for integration tests
2
+
use serde::Deserialize;
3
+
use std::collections::HashMap;
4
+
use std::fs;
5
+
use std::path::{Path, PathBuf};
6
+
7
+
#[derive(Debug, Deserialize)]
8
+
pub struct TestConfig {
9
+
pub test: TestMetadata,
10
+
#[serde(default)]
11
+
pub modules: HashMap<String, String>,
12
+
}
13
+
14
+
#[derive(Debug, Deserialize)]
15
+
pub struct TestMetadata {
16
+
pub name: String,
17
+
#[serde(default)]
18
+
pub description: String,
19
+
#[serde(default)]
20
+
pub namespace: Option<String>,
21
+
}
22
+
23
+
/// Load test.toml configuration from a test directory.
24
+
/// Returns Ok(TestConfig) if successful, or creates a default config if test.toml doesn't exist.
25
+
pub fn load_test_config(
26
+
test_dir: &Path,
27
+
default_namespace_fn: impl FnOnce(&str) -> String,
28
+
) -> Result<TestConfig, String> {
29
+
let config_path = test_dir.join("test.toml");
30
+
31
+
if !config_path.exists() {
32
+
// Fallback: create default config using provided function
33
+
let test_name = test_dir
34
+
.file_name()
35
+
.unwrap()
36
+
.to_str()
37
+
.unwrap()
38
+
.to_string();
39
+
let namespace = default_namespace_fn(&test_name);
40
+
41
+
let mut modules = HashMap::new();
42
+
modules.insert("test.mlf".to_string(), namespace.clone());
43
+
44
+
return Ok(TestConfig {
45
+
test: TestMetadata {
46
+
name: test_name,
47
+
description: String::new(),
48
+
namespace: Some(namespace),
49
+
},
50
+
modules,
51
+
});
52
+
}
53
+
54
+
let config_str = fs::read_to_string(&config_path)
55
+
.map_err(|e| format!("Failed to read test.toml: {}", e))?;
56
+
57
+
toml::from_str(&config_str).map_err(|e| format!("Failed to parse test.toml: {}", e))
58
+
}
59
+
60
+
/// Discover all test directories in a base path.
61
+
/// Returns a sorted list of test directory paths.
62
+
pub fn discover_test_dirs(base: &str) -> Vec<String> {
63
+
let base_path = Path::new(base);
64
+
if !base_path.exists() {
65
+
return vec![];
66
+
}
67
+
68
+
let mut dirs: Vec<String> = fs::read_dir(base_path)
69
+
.unwrap()
70
+
.filter_map(|entry| {
71
+
let entry = entry.ok()?;
72
+
let path = entry.path();
73
+
if path.is_dir() {
74
+
Some(path.to_str()?.to_string())
75
+
} else {
76
+
None
77
+
}
78
+
})
79
+
.collect();
80
+
81
+
dirs.sort();
82
+
dirs
83
+
}
84
+
85
+
/// Discover tests organized by category (e.g., lang/namespace_imports/*, lang/constraints/*)
86
+
pub fn discover_categorized_tests(base_dir: &str) -> Vec<(String, PathBuf)> {
87
+
let mut results = Vec::new();
88
+
let base_path = Path::new(base_dir);
89
+
90
+
if !base_path.exists() {
91
+
return results;
92
+
}
93
+
94
+
// Walk through category directories
95
+
for category_entry in fs::read_dir(base_path).unwrap() {
96
+
let category_entry = category_entry.unwrap();
97
+
let category_path = category_entry.path();
98
+
99
+
if !category_path.is_dir() {
100
+
continue;
101
+
}
102
+
103
+
let category_name = category_path.file_name().unwrap().to_str().unwrap();
104
+
105
+
// Each category contains test directories
106
+
for test_entry in fs::read_dir(&category_path).unwrap() {
107
+
let test_entry = test_entry.unwrap();
108
+
let test_path = test_entry.path();
109
+
110
+
if !test_path.is_dir() {
111
+
continue;
112
+
}
113
+
114
+
let test_name = format!(
115
+
"{}/{}",
116
+
category_name,
117
+
test_path.file_name().unwrap().to_str().unwrap()
118
+
);
119
+
120
+
results.push((test_name, test_path));
121
+
}
122
+
}
123
+
124
+
results.sort_by(|a, b| a.0.cmp(&b.0));
125
+
results
126
+
}
127
+
128
+
/// Run tests and print results with ✓/✗ indicators.
129
+
/// Returns (passed_count, failed_tests).
130
+
pub fn run_and_report_tests<F>(
131
+
tests: Vec<(String, Result<(), String>)>,
132
+
test_type: &str,
133
+
) -> (usize, Vec<(String, String)>)
134
+
where
135
+
F: Fn(&str) -> Result<(), String>,
136
+
{
137
+
let mut passed = 0;
138
+
let mut failed = Vec::new();
139
+
140
+
for (test_name, result) in tests {
141
+
match result {
142
+
Ok(()) => {
143
+
println!("✓ {}", test_name);
144
+
passed += 1;
145
+
}
146
+
Err(err) => {
147
+
println!("✗ {}: {}", test_name, err);
148
+
failed.push((test_name, err));
149
+
}
150
+
}
151
+
}
152
+
153
+
println!("\n{} Results: {} passed, {} failed", test_type, passed, failed.len());
154
+
(passed, failed)
155
+
}