Skip to content

docs: add manual test case documentation for all MDL command areas#386

Draft
retran wants to merge 1 commit intomendixlabs:mainfrom
retran:test-case-docs-clean
Draft

docs: add manual test case documentation for all MDL command areas#386
retran wants to merge 1 commit intomendixlabs:mainfrom
retran:test-case-docs-clean

Conversation

@retran
Copy link
Copy Markdown
Contributor

@retran retran commented Apr 29, 2026

Summary

Adds comprehensive manual test case documentation covering all 19 MDL command areas. Each file specifies inputs, expected outputs, and edge cases — no result annotations or bug references (those belong in session reports).

Also adds AGENT-TESTING.md — shared instructions for AI agents executing these tests (REPL / terminator convention, -c flag usage, tmpdir workflow, result reporting format).

Files (20)

  • docs/15-testing/AGENT-TESTING.md — agent execution guide
  • 19 test case files (entity, enumeration, microflow, nanoflow, page, integration, security, navigation-settings, organization, workflow, catalog, tooling, cli-commands, sql-integration, session, mapping, business-event, image-collection, agent-editor)

Test Coverage

1007 test cases total across all areas. Doc cleanup removed 37 result annotations and fixed syntax errors discovered during execution.


Execution Report (2026-04-30 + 2026-05-01)

Build: v0.7.0-368-g5a109a0e (rebased on main 59ab2bb)
Project: EnquiriesManagement (Mendix 11.8.0, 281 entities)

Aggregate Results

# Test File Total Pass Fail Skip
01 Entity 88 76 5 7
02 Enumeration 27 22 1 4
03 Microflow 62 51 3 8
04 Nanoflow 52 48 3 1
05 Page 62 44 10 8
06 Integration 72 56 6 10
07 Security 55 46 5 4
08 Navigation/Settings 60 53 3 4
09 Organization 57 47 4 6
10 Workflow 68 36 6 26
11 Catalog 42 36 4 2
12 Tooling 86 56 12 18
13 CLI Commands 67 21 5 41
14 SQL Integration 110 0 0 110
15 Session 29 16 12 1
16 Mapping 38 17 1 20
17 Business Event 30 18 5 7
18 Image Collection 30 17 4 9
19 Agent/Model/KB/MCP 63 37 3 23
Auth & Marketplace 15 11 4 0
TOTAL 1007 706 73 228

Runnable pass rate: 706/779 = 91%
Blocked/skipped: 309 (Docker 133 + SQL 110 + prereqs 66)

Issues Filed (62 total)

Critical:

High:

Medium (18): #388, #391, #395, #401, #402, #414, #416, #417, #418, #419, #470, #472, #473, #476, #477, #478, #479

Enhancement (5): #464, #465, #466, #467, #471

Closed (5): #423 (invalid), #426, #439, #440, #442 (duplicates)

Failed Tests (91)

Click to expand full failure list
File Test Description Bug
01 10.7 DELETE_IF_NO_REFERENCES not stored
01 11.1 ALTER: CASCADE vs DELETE_CASCADE #388
01 18.2 Association roundtrip keyword mismatch #388
01 19.2 CATALOG.ASSOCIATIONS missing #419
01 21.5 Invalid OQL accepted #417
02 4.3.1 Ambiguous drop silently picks first #391
03 3.19 Import mapping source keyword conflict
03 7.2 Java action entity type param
03 11.3 Grant non-existent role garbled msg
04 2.10 Excluded nanoflow missing in DESCRIBE
04 4.5–4.7 Non-existent call targets accepted #395
04 9.3 RENAME creates duplicate
05 4.3 SHOW WIDGETS LIKE broken #418
05 11.1 ALTER SET Placeholder not found #414
05 11.11 Columns not addressable #414
05 12.1–12.2 ALTER SNIPPET namespace error #402
05 14.1 UPDATE WIDGETS no Caption #416
05 15.2 Snippet roundtrip bindings lost
05 16.2 Snippet parameter syntax
06 3.1 OData Headers parse error
06 17.3 Non-existent client accepted #417
06 22.1 Published REST SIGSEGV #420
06 22.4 Duplicate REST created #401
06 29.1 REST operations parse error
06 36.2 JSON multiline $$ broken
07 16.4, 27.3 XPath GRANT empty rule #422
07 23.1 Security update timeout
07 25.2 Phantom access rule #399
07 20.3 Test doc issue
08 8.6 JavaVersion no validation
08 12.4, 16.5 Phantom constant accepted
09 9.x, 7.2, 10.5, 12.3 SHOW STRUCTURE no folders
10 3.5 Parallel split parse error
10 5.26 INSERT BOUNDARY not in grammar
10 5.27 DROP BOUNDARY PANIC #421
10 6.1 Roundtrip caption lost
10 8.5, 8.10 Silent ambiguity / no validation
11 1.3, 1.5, 11.2, 12.4 Catalog gaps
12 1.9–1.10 RENAME MODULE #473
12 4.2 LINT filter broken
12 10.1–10.2, 12.5 SHOW LANGUAGES missing
12 9.3, 9.9–9.10 DESCRIBE STYLING broken
12 8.3–8.4 CONTRACT wrong path
13 4.1–4.2 eval missing arg handling
13 9.3 widget init -p flag
13 14.1 LSP no response
15 3.1–3.2 STATUS not in grammar #470
15 5.1–5.3, 11.5, 12.2–12.3 SET not implemented #471
15 8.2 HELP topic fails
15 10.1–10.2 Multi-step STATUS blocks #470
15 11.6 Recursive EXECUTE SCRIPT #472
16 1.4/3.4 Non-existent module no error
17 4.5–4.8 Reserved keyword attrs #476
17 8.6 Empty messages rejected
18 3.6–3.7 CREATE OR REPLACE broken #477
19 MCP dash parsed as subtraction
19 DESCRIBE quote style
19 Verbose error message
Auth 7.1b, 7.5 Exit 0 on auth error #428
Auth 8.4 Search ignores query #479
Auth Marketplace exit 0 after logout #428

Skipped Tests (309)

Click to expand skip breakdown
Category Count Reason
Docker 133 mxbuild Linux ELF on macOS
SQL Integration 110 Needs Docker + DB containers
Workflow prereqs 26 Activity types absent; blocked by parse failures
Agent/KB/MCP prereqs 29 No existing objects in test project
CLI Commands 41 Docker/TTY/auth requirements
Tooling 22 No git repo, complex setup
Mapping 20 Data transformers need 11.9+
Business Event 16 Blocked by CREATE parse failure
Image Collection 13 Blocked by create-or-replace bug
Integration 10 OpenAPI files; write guards
Page 8 Wireframe not implemented
Microflow 8 No JS actions; stress
Entity 7 Covered in session 2; stress
Organization 6 Studio Pro cross-check needed
Enumeration 4
Security 4 Stress/boundary
Navigation 4 REPL-only; stress
Catalog 2 Fresh build state needed
Session 1 Stress test

Key Findings

  1. REPL / terminator — write operations use / on own line (SQL*Plus convention). All "REPL-blocked" tests resolved.
  2. No input validation — many commands accept non-existent references without error.
  3. Exit code 0 on error — pervasive, breaks set -e and CI.
  4. DESCRIBE not roundtrippable — workflow/integration outputs need prefix adjustment.
  5. Marketplace search broken — query parameter ignored.

Remaining

  • M4 Docker (133): fix test projects in Studio Pro
  • SQL Integration (110): Linux + DB containers
  • Squash commits before merge

@github-actions
Copy link
Copy Markdown

AI Code Review

What Looks Good

  • The PR adds comprehensive manual test case documentation for all MDL command areas as described, with no code changes (documentation-only).
  • Each document follows the established structure from existing nanoflow test cases (numbered scenarios, MDL code blocks, expected results, failure modes, boundary/stress tests, coverage matrices, and manual test report templates).
  • The documentation covers areas that correspond to implemented features per the "Current Implementation Status" section (e.g., agent-editor, business-event, catalog, workflow, etc.), so it is not re-documenting already-shipped features as new but rather providing test documentation for existing functionality.
  • The structure is consistent and ready for QA use as stated, with clear setup instructions and test project coverage matrices.
  • No overlap with existing proposals (the proposals directory is empty) or duplication of code implementations (since no code is changed).
  • The documentation correctly uses MDL syntax patterns (colon for property definitions, qualified names, standard CRUD verbs) consistent with existing examples, and does not misuse AS in non-mapping contexts.

Recommendation

Approve the PR. The documentation is valuable for manual testing and QA processes, adheres to contribution guidelines, and introduces no risks since it contains no code changes.


Automated review via OpenRouter (Nemotron Super 120B) — workflow source

@retran retran force-pushed the test-case-docs-clean branch 2 times, most recently from c361ed9 to 1b98697 Compare April 29, 2026 20:46
@github-actions
Copy link
Copy Markdown

AI Code Review

What Looks Good

This PR adds comprehensive manual test case documentation for all MDL command areas, which is a valuable contribution for quality assurance and testing. The documentation is well-organized by feature area (agents, business events, catalog, CLI commands, etc.) and includes:

  • Clear preconditions, steps, expected results, and cleanup instructions for each test case
  • Coverage of both read and write operations (with appropriate warnings about destructive tests)
  • Roundtrip testing validation (CREATE → DESCRIBE → CREATE from output)
  • Failure mode testing and boundary/stress tests
  • Cross-module reference validation
  • Proper version-specific considerations noted where applicable

The test cases appear to align with features marked as "Implemented" in CLAUDE.md (e.g., AI agent documents, business event services), and the documentation correctly references module requirements (like AgentEditorCommons for agents) and version constraints.

The structure follows the project's documentation conventions, placing test documentation in the appropriate docs/15-testing/ directory. The PR explicitly states that expectations were corrected to match actual mxcli behavior observed during testing, showing this documentation was validated against real implementation.

Recommendation

Approve this PR. The documentation adds significant value for manual testing and QA processes without introducing any code changes or violating project guidelines. It properly covers implemented features and provides actionable test cases for both AI agents and human testers. No changes are needed.


Automated review via OpenRouter (Nemotron Super 120B) — workflow source

@github-actions
Copy link
Copy Markdown

github-actions Bot commented May 1, 2026

AI Code Review

Review Summary

This PR adds comprehensive manual test case documentation for all MDL command areas. It consists entirely of new documentation files (no code changes) covering:

  • Testing methodology and workflows (AGENT-TESTING.md)
  • Domain-specific test cases for:
    • Agent/Editor functionality
    • Business event services
    • Catalog & code navigation
    • And 15 other MDL feature areas

The documentation includes prerequisites, execution methods, verification patterns, and detailed test case templates.

Checklist Analysis

Overlap & duplication:

  • ✅ No code duplication (pure documentation)
  • ✅ Documents existing functionality, not new features
  • ✅ References existing doctest files appropriately

MDL syntax design:

  • ❌ Not applicable (no MDL syntax changes)

Full-stack consistency:

  • ❌ Not applicable (no MDL features added)

Test coverage:

  • ⚠️ Documentation describes manual tests but doesn't add automated test files
  • However, this is acceptable as the PR explicitly states it's for manual test case documentation

Security & robustness:

  • ✅ Documentation only - no security implications

Scope & atomicity:

  • ✅ Single concern: manual test documentation for MDL command areas
  • ✅ All changes are related to this single purpose

Code quality:

  • ✅ Documentation appears accurate and well-structured
  • ✅ No inconsistencies with actual implementation observed

Bugs & correctness:

  • ✅ Documentation only - no logic errors possible
  • ✅ Includes sections on handling known failures and verification patterns

Minor Issues

  1. Process adherence: The PR doesn't reference an associated issue, which goes against the contribution guideline to "File an issue first". While less critical for documentation, substantial additions like this (18 files) should ideally have tracking.

  2. PR reference consistency: Some documentation files reference PR feat: full nanoflow support — CREATE, DROP, SHOW, DESCRIBE, DIFF, MERMAID, security, and agentic skill #301 but link to pull/386, which may cause confusion.

What Looks Good

  • Excellent coverage of manual testing procedures with clear workflows
  • Comprehensive verification patterns and result reporting templates
  • Well-organized by test domain with appropriate enrichment guidance
  • Practical instructions for environment setup, test execution, and cleanup
  • Includes stress testing, boundary conditions, and failure mode guidance
  • Provides templates for consistent test reporting

Recommendation

Approve

This documentation will significantly improve the quality and consistency of manual testing for the mxcli tool. While it would have been ideal to reference an associated issue per contribution guidelines, the value of this comprehensive testing documentation outweighs this minor process concern, especially since it supports existing implementation work (referencing PR #301). The documentation is accurate, well-structured, and directly addresses a need for standardized manual testing procedures.


Automated review via OpenRouter (Nemotron Super 120B) — workflow source

@retran retran force-pushed the test-case-docs-clean branch 2 times, most recently from 26b9a38 to 5448cb5 Compare May 1, 2026 11:48
@github-actions
Copy link
Copy Markdown

github-actions Bot commented May 1, 2026

AI Code Review

Okay, I need to review this pull request that adds manual test case documentation for all MDL command areas. The PR includes several new files in the docs/15-testing/ directory, each containing test cases for different MDL features.

First, let me understand what the PR is about. It's adding comprehensive manual test case documentation covering all MDL command areas. There are 18 test documents with 663 test cases total. The PR shows new files like AGENT-TESTING.md, agent-editor-test-cases.md, business-event-test-cases.md, catalog-test-cases.md, and others.

Now, I need to review this against the checklist provided in CLAUDE.md. Let me go through the checklist items one by one.

Overlap & duplication

  • Check proposals list: The PR body doesn't mention any proposals, and the context says "Proposals in repo: No proposals directory." So no overlap with proposals.
  • Check if diff introduces code that duplicates existing implementations: This PR is adding documentation/test cases, not code. So no code duplication.
  • Check doctype test files: The context lists existing doctype test files (01-domain-model-examples.mdl, etc.). These new test case documents are in docs/15-testing/, which seems to be a new directory for manual test documentation, not replacing the existing doctype tests. The PR says these are for manual testing by AI agents or human QA, while the existing ones might be for automated tests. So likely no duplication.
  • Flag if PR re-documents already-shipped features as new: The PR is adding test documentation, not feature documentation. It's describing how to test existing features, not documenting new features. So this shouldn't be an issue.

MDL syntax design (for new or modified MDL syntax)

The PR is adding test cases, not modifying MDL syntax itself. The test cases include examples of MDL statements, but they're not introducing new syntax. Let me check if any of the test cases show non-compliant syntax.

Looking at the agent-editor-test-cases.md file, I see examples like:

create agent MyModule.ChatAgent (
  UsageType: chat,
  Description: 'A helpful chat agent',
  Model: MyModule.GPT4o,
  Entity: MyModule.ChatContext,
  Variables: 'userInput',
  MaxTokens: 4096,
  ToolChoice: auto,
  Temperature: 0.7,
  TopP: 0.9,
  SystemPrompt: $$You are a helpful assistant.$$,
  UserPrompt: $$Answer the user's question: {userInput}$$
);

This follows the property format (Key: value) with colon separators. The AS keyword isn't used here, but I see in other parts like:

tool FetchData {
  ToolType: microflow,
  Document: MyModule.ACT_FetchData,
  Enabled: true,
  Description: 'Fetches data from the database'
}

This seems to be using a block syntax for tools, which might be specific to agent definitions. I need to check if this follows MDL design guidelines.

According to the guidelines: "Property lists use ( Key: value, ... ) format with colon separators, one per line" and "Colon for property definitions (Key: value), AS for name-to-name mappings".

In the agent examples, I see:

  • Properties like UsageType: chat (good, colon for property definition)
  • But then there are blocks like:
    tool FetchData {
      ToolType: microflow,
      ...
    }
    

This is a nested block syntax. Is this allowed in MDL? The guidelines mention "Property lists use ( Key: value, ... ) format", but this seems to be using a different syntax for complex properties.

Looking at the business-event-test-cases.md, I see:

create business event service MyModule.OrderEvents
  event_name_prefix 'com.example.order'
  message OrderCreated (
    OrderId: Long,
    CustomerName: String,
    Total: Decimal
  ) publish entity MyModule.OrderCreatedEvent
/

Here, I see:

  • event_name_prefix 'com.example.order' (no colon, just space)
  • message OrderCreated (...) publish entity ... (this seems to be a different structure)

This might be problematic. Let me check the guidelines again.

The guidelines say: "Property lists use ( Key: value, ... ) format with colon separators, one per line"

In the business event example:

  • event_name_prefix 'com.example.order' - this doesn't use the (Key: value) format; it's just Key value
  • Similarly, message OrderCreated (...) publish entity ... doesn't follow the property list format

This could be a violation of the MDL syntax design guidelines.

Also, in the agent examples, I see:

SystemPrompt: $$You are a helpful assistant.$$

This uses colon, which is good for property definition.

But then:

tool FetchData {
  ToolType: microflow,
  ...
}

This is a block, not a property list in parentheses.

Let me check if there are any AS usages that might be incorrectly flagged.

In the agent examples, I don't see AS being used for name mapping. I see things like:

Model: MyModule.GPT4o,

which is a property definition (Key: value), not a name mapping.

The guidelines say: "do not flag AS in mapping contexts as a syntax violation" - so if AS is used for renaming (like old AS new), it's okay, but if used elsewhere, it's not.

I don't see AS in the examples provided, so probably okay.

But the main concern is whether the syntax shown in the test cases follows the MDL design guidelines.

Let me look at the MDL_QUICK_REFERENCE.md mentioned in the guidelines to see what the standard patterns are.

Since I don't have the actual file, I'll rely on the guidelines provided in CLAUDE.md.

The guidelines state:

  • Property lists use ( Key: value, ... ) format with colon separators, one per line
  • Colon for property definitions (Key: value), AS for name-to-name mappings

In the business event test cases:

create business event service MyModule.OrderEvents
  event_name_prefix 'com.example.order'
  message OrderCreated (
    OrderId: Long,
    CustomerName: String,
    Total: Decimal
  ) publish entity MyModule.OrderCreatedEvent
/

This doesn't follow the property list format. It should probably be something like:

create business event service MyModule.OrderEvents (
  event_name_prefix: 'com.example.order',
  message: OrderCreated (
    OrderId: Long,
    CustomerName: String,
    Total: Decimal
  ) publish entity: MyModule.OrderCreatedEvent
)

But I'm not sure if that's valid MDL. The test cases are showing what they believe is correct syntax, but it might not comply with the guidelines.

Similarly, in the agent test cases:

create agent MyModule.ChatAgent (
  UsageType: chat,
  Description: 'A helpful chat agent',
  Model: MyModule.GPT4o,
  Entity: MyModule.ChatContext,
  Variables: 'userInput',
  MaxTokens: 4096,
  ToolChoice: auto,
  Temperature: 0.7,
  TopP: 0.9,
  SystemPrompt: $$You are a helpful assistant.$$,
  UserPrompt: $$Answer the user's question: {userInput}$$
);

This part follows the property list format correctly with colons.

But then:

tool FetchData {
  ToolType: microflow,
  Document: MyModule.ACT_FetchData,
  Enabled: true,
  Description: 'Fetches data from the database'
}

This is a block syntax, not a property list.

Perhaps for complex properties like tools, MCP services, and knowledge bases, a different syntax is used. But the guidelines don't mention exceptions for block syntax.

The guidelines say: "Property lists use ( Key: value, ... ) format" - implying that all property definitions should follow this format.

Having a block like tool FetchData { ... } inside the agent definition might not be following the property list format.

Let me check if there are similar patterns in existing MDL.

Since I don't have access to the actual MDL implementation, I have to go by the guidelines.

The guidelines also say: "Statement reads as English — a business analyst understands the statement on first reading"

The agent example reads reasonably well: "create agent MyModule.ChatAgent with UsageType: chat, Description: 'A helpful chat agent', etc."

But the tool block might be less English-like.

Another guideline: "No keyword overloading — each keyword has one consistent meaning"

I don't see obvious keyword overloading in the examples.

"Diff-friendly — adding one property produces a one-line diff"

In the property list format, adding a property would be one line. In the block format, adding a property to a tool block would also be one line inside the block.

But the issue is whether the block syntax itself complies with the guidelines.

Let me look at the business event example more carefully.

In business-event-test-cases.md, section 3.1:

describe business event service MyModule.OrderEvents

Expected output:

create business event service MyModule.OrderEvents
  event_name_prefix 'com.example.order'
  message OrderCreated (
    OrderId: Long,
    CustomerName: String,
    Total: Decimal
  ) publish entity MyModule.OrderCreatedEvent
/

The trailing / is interesting. It looks like it's using a syntax similar to SQL terminators or something.

In the CREATE BUSINESS EVENT SERVICE examples (section 4), I see:

create business event service MyModule.OrderEvents
  event_name_prefix 'com.example.order'
  message OrderCreated (
    OrderId: Long,
    Description: String
  ) publish entity MyModule.OrderCreatedEvent;

Here it ends with a semicolon, not a slash.

In the describe output, it has a slash at the end.

This inconsistency might be a problem.

Also, notice that in the describe output, there's no colon after event_name_prefix or after the message definition.

Whereas in the agent create examples, they use colons for properties.

This suggests that different MDL statement types might have different syntaxes, which could violate the guideline of consistent property format.

The guidelines say: "consistent property format (Key: value) for property definitions"

But in the business event examples, it's not using (Key: value) at all for the top-level properties; it's using Key value without colon or parentheses.

Let me check if there are any examples that use the correct format.

In the agent create examples, they do use:

create agent MyModule.ChatAgent (
  UsageType: chat,
  Description: 'A helpful chat agent',
  ...
);

So for agents, it follows the property list format.

For business events, it doesn't.

This inconsistency would violate the "consistent property format" guideline.

Moreover, the guideline says: "Property lists use ( Key: value, ... ) format with colon separators, one per line"

In the business event case, it's not using parentheses at all for the property list.

So this appears to be a syntax design issue in the test cases themselves, meaning the test cases are documenting non-compliant syntax.

But wait, the PR is adding test cases, not implementing the syntax. So if the test cases show incorrect syntax, that's a problem because they're supposed to be testing the correct behavior.

However, it's possible that the MDL syntax for business events actually does use this format, and the guidelines I'm reading are general but there are exceptions.

Let me look for clarification in the CLAUDE.md.

In the "MDL Syntax Quick Reference" section, it says: "Full syntax tables for all MDL statements [...] are in [docs/01-project/MDL_QUICK_REFERENCE.md]"

Since I don't have that file, I have to infer.

But the guidelines in CLAUDE.md under "Syntax design for MDL features" are pretty clear.

Another approach: look at the existing doctype test files mentioned in the context.

The context lists: 01-domain-model-examples.mdl, 02-microflow-examples.mdl, etc.

If I could see one of those, I could check the syntax.

But since I can't, I'll have to rely on the guidelines.

Let me check if there are any mentions of specific syntax in the CLAUDE.md.

In the "Key Concepts" section, I don't see specific MDL syntax examples.

In the "Public API Pattern" and "High-Level Fluent API" sections, it's about Go code, not MDL.

In the "Code Style Guidelines", it's about Go code.

So I need to stick to the "Syntax design for MDL features" checklist item.

The checklist says:

  • Follows standard patterns — uses create/alter/drop/show/describe, not custom verbs
  • Reads as English — a business analyst understands the statement on first reading
  • Qualified names — uses Module.Element everywhere, no implicit module context
  • Property format — uses ( key: value, ... ) with colon separators, one per line
  • LLM-friendly — one example is sufficient for an LLM to generate correct variants
  • Diff-friendly — adding one property is a one-line diff
  • Consistent with existing MDL patterns

Now, looking at the business event example from the test case:

create business event service MyModule.OrderEvents
  event_name_prefix 'com.example.order'
  message OrderCreated (
    OrderId: Long,
    CustomerName: String,
    Total: Decimal
  ) publish entity MyModule.OrderCreatedEvent

Let's evaluate against the checklist:

  • Uses standard verbs: create, business event service — "business event service" might be considered a custom verb phrase, but it's a noun phrase. The verb is "create", which is standard.
  • Reads as English: "create business event service MyModule.OrderEvents with event_name_prefix 'com.example.order' and message OrderCreated (...)" — somewhat English-like but a bit awkward.
  • Qualified names: Uses Module.OrderEvents, Module.OrderCreatedEvent — good.
  • Property format: Here's the issue. It's not using ( key: value, ... ) format. Instead, it's:
    • event_name_prefix 'com.example.order' (no colon, no parentheses)
    • message OrderCreated (...) publish entity ... (complex structure without clear property format)
  • LLM-friendly: Not sure, but the inconsistent format might make it hard for LLMs.
  • Diff-friendly: If we wanted to add another property, where would it go? It's not clear.
  • Consistent with existing MDL patterns: Without seeing existing patterns, hard to say, but the agent examples use a different format.

In contrast, the agent example:

create agent MyModule.ChatAgent (
  UsageType: chat,
  Description: 'A helpful chat agent',
  Model: MyModule.GPT4o,
  Entity: MyModule.ChatContext,
  Variables: 'userInput',
  MaxTokens: 4096,
  ToolChoice: auto,
  Temperature: 0.7,
  TopP: 0.9,
  SystemPrompt: $$You are a helpful assistant.$$,
  UserPrompt: $$Answer the user's question: {userInput}$$
);

This follows:

  • Property format: ( Key: value, ... ) with colon separators, one per line — yes.
  • Diff-friendly: adding one property is one line — yes.
  • Reads as English: "create agent MyModule.ChatAgent with UsageType chat, Description 'A helpful chat agent', ..." — yes.
  • Qualified names: yes.

So the agent syntax seems compliant, but the business event syntax does not.

This suggests that the test cases for business events are documenting non-compliant syntax, which would be a problem.

However, it's possible that the business event syntax is correct and the guidelines allow for variations, but the guidelines seem pretty strict about the property format.

Let me check if there are other examples in the PR.

In the mapping-test-cases.md (not shown in the diff, but mentioned in the PR body), there might be examples.

But since I don't have that file, I'll focus on what's visible.

Another place: in the agent-editor-test-cases.md, for the tool blocks, it uses:

tool FetchData {
  ToolType: microflow,
  Document: MyModule.ACT_FetchData,
  Enabled: true,
  Description: 'Fetches data from the database'
}

This is not using the property list format for the tool definition itself. It's using a block.

Whereas for the agent properties, it is using the property list format.

So within the same statement, there are mixed syntaxes.

This likely violates the "consistent property format" guideline.

Now, for the PR review, since this is about test documentation, if the test cases are showing incorrect syntax, that's a moderate issue because it could mislead users or testers.

But the PR is for adding test documentation, not for changing the syntax. So if the syntax is actually correct in the implementation, then the test cases are fine, but if the syntax is incorrect, then the test cases are wrong.

Given that the PR has a note: "All expectations corrected to match actual mxcli behavior observed during testing", this suggests that the test cases were written based on what mxcli actually does, so if mxcli accepts this syntax, then it might be correct.

But the guidelines are supposed to govern the syntax design, so if mxcli's syntax doesn't follow the guidelines, that's a problem with the implementation, not just the test cases.

However, for the purpose of this PR review, I need to check if the PR as submitted follows the checklist.

The checklist item for MDL syntax design is only relevant if the diff adds or modifies MDL syntax. This diff is adding test cases/documentation, not changing the syntax itself. So technically, this checklist item might not apply directly.

But the checklist says: "If the diff adds or modifies MDL syntax (grammar rules, keywords, statement types), check:"

Since this diff doesn't add or modify MDL syntax (it's just documentation), this section might not be applicable.

However, the test cases include MDL syntax examples, so if those examples are incorrect, it could be an issue for the documentation.

But the documentation is about how to test, not about the syntax specification.

Let me see the PR description: "Comprehensive manual test case documentation covering all MDL command areas."

So it's documentation for testing, not for the language specification.

Therefore,


Automated review via OpenRouter (Nemotron Super 120B) — workflow source

@github-actions
Copy link
Copy Markdown

github-actions Bot commented May 1, 2026

AI Code Review

Recommendation: Approve

This PR adds comprehensive manual test case documentation for all MDL command areas (19 documents, 663 test cases) without modifying any code or MDL syntax. It provides valuable testing resources for contributors and maintainers.

Why this is acceptable:

  • Pure documentation: Only adds markdown files under docs/15-testing/ - no code changes, no grammar modifications, no AST/executor/LSP impacts
  • Follows contribution process: Documents existing functionality (tested against v0.7.0-257-ga07e7e0) rather than documenting new features as shipped
  • Addresses overlap concerns:
    • No proposals directory exists (no duplication risk)
    • Doesn't re-document shipped features as new (documents test procedures for existing features)
    • Doesn't introduce code that duplicates existing implementations
  • Test coverage section not triggered:
    • Adds no new packages/executor commands requiring automated tests
    • Doesn't add/modify MDL syntax (so no requirement for mdl-examples/doctype-tests/ examples)
    • Manual test documentation is appropriate supplement to automated test suite
  • Quality observations:
    • Well-structured documentation following existing patterns
    • Clear execution methods, verification patterns, and enrichment guidance
    • Properly separates read-only vs write-test workflows
    • Includes known limitations and pitfalls section
    • References actual test results (534/663 pass rate) and filed bugs (16 confirmed issues)

What looks good:

  • Excellent test session workflow documentation covering preparation, execution, reporting, and cleanup
  • Detailed execution methods (non-interactive, script files, REPL via tmux, Docker-dependent, auth-required)
  • Smart enrichment patterns for test projects requiring missing features
  • Verification patterns including roundtrip tests, count-based checks, and crash detection
  • Clear handling of known failures vs new regressions
  • Comprehensive coverage across 19 MDL areas (entities to agent/editor)
  • Practical examples showing preconditions, steps, expected results
  • Proper scoping (single concern: test documentation)

No issues found:

  • Zero critical/moderate/minor issues identified
  • No checklist violations apply to documentation-only PR
  • No syntax design concerns (no MDL changes)
  • No full-stack consistency concerns (no new features)
  • No security risks (no code changes)
  • Proper scope and atomicity (single documentation concern)
  • No code quality issues (documentation follows project patterns)

This documentation will significantly improve testing effectiveness for both AI agents and human contributors. The PR adds value without risks.

Approved - no changes requested.


Automated review via OpenRouter (Nemotron Super 120B) — workflow source

@retran retran force-pushed the test-case-docs-clean branch from 5448cb5 to 0aefb76 Compare May 1, 2026 12:24
@github-actions
Copy link
Copy Markdown

github-actions Bot commented May 1, 2026

AI Code Review

Review Summary

This PR adds comprehensive manual test case documentation for all MDL command areas (18 documents, 663 test cases). It's purely documentation with no code changes.

What Looks Good

  • Comprehensive coverage: Documents all MDL domains (entities, microflows, pages, security, workflows, etc.) with clear test structure (preconditions, steps, expected results, cleanup)
  • Excellent methodology: Includes detailed execution methods (non-interactive, script files, REPL via tmux, Docker-dependent tests), verification patterns, and enrichment instructions
  • Practical guidance: Covers prerequisites, workflow, result reporting, known limitations, and stress testing
  • Non-duplicative: Focuses on manual/testing scenarios that complement existing automated doctype tests in mdl-examples/doctype-tests/
  • Well-structured: Consistent formatting, clear tables, and actionable instructions for testers

Recommendation

Approve - This documentation significantly improves the project's testability and contributor experience. It follows the project's documentation standards and provides valuable manual testing guidance without overlapping with existing automated test coverage.

Note: As a documentation-only PR, it doesn't trigger code-related checklist items (grammar, AST, executor, backend, LSP, etc.). The manual test cases appropriately complement existing automated tests rather than duplicating them.


Automated review via OpenRouter (Nemotron Super 120B) — workflow source

@retran retran force-pushed the test-case-docs-clean branch from 0aefb76 to 5a7d92f Compare May 1, 2026 12:45
@github-actions
Copy link
Copy Markdown

github-actions Bot commented May 1, 2026

AI Code Review

Okay, I need to review this pull request for the mxcli project. The PR is about adding manual test case documentation for all MDL command areas. Let me look at the details.

The PR body says it's a comprehensive manual test case documentation covering all MDL command areas with 18 test documents and 663 test cases total. It includes a coverage table showing different areas like Entities & Associations, Enumerations, Microflows, etc., with the number of tests in each. The test execution results show a pass rate of 534/663 (80.5%) and 16 confirmed bugs filed.

Now, I need to review this against the checklist provided in CLAUDE.md. The checklist has several sections: Overlap & duplication, MDL syntax design, Full-stack consistency, Test coverage, Security & robustness, Scope & atomicity, Code quality, and Bugs & correctness.

Since this PR is about documentation (adding test case documents), I should focus on whether this documentation is appropriate and doesn't introduce any issues.

First, checking for Overlap & duplication:

  • The PR is adding test case documentation in docs/15-testing/ directory. Looking at the diff, it's adding new files like AGENT-TESTING.md, agent-editor-test-cases.md, business-event-test-cases.md, catalog-test-cases.md, etc.
  • The checklist says to check if the PR re-documents already-shipped features as new. This seems to be new documentation for manual testing, not re-documenting existing features. The test cases are for manual execution, so it's likely new content.
  • I should check if there are existing test documents that might overlap. The PR mentions 18 test documents covering various areas, and from the diff, I see files like entity-test-cases.md, enumeration-test-cases.md, etc., which seem to be new additions.

Next, MDL syntax design: This PR is about documentation, not adding or modifying MDL syntax. So this section might not apply directly. The checklist for MDL syntax design is for when the diff adds or modifies MDL syntax (grammar rules, keywords, statement types). Since this is documentation, there shouldn't be any MDL syntax changes in the diff.

Full-stack consistency: Similarly, this is about documentation, not adding MDL features, so the full-stack consistency checks (grammar, AST, visitor, etc.) don't apply.

Test coverage: The checklist says new packages should have test files, new executor commands should have MDL examples in mdl-examples/doctype-tests/. But this PR is about manual test documentation, not automated tests. The documentation itself is the test cases for manual execution. The checklist item about "New executor commands should have MDL examples in mdl-examples/doctype-tests/" might not be relevant here because this is documentation, not code.

However, I should check if the documentation is accurate and follows the project's guidelines. The PR body mentions that "All expectations corrected to match actual mxcli behavior observed during testing," which suggests they've aligned the test expectations with current behavior.

Security & robustness: Documentation shouldn't introduce security issues, but I should ensure that the test documentation doesn't suggest unsafe practices. For example, in the AGENT-TESTING.md, there are sections about working with test fixture copies, which correctly advise against running write operations on the original test project. That seems good.

Scope & atomicity: The PR is scoped to adding test documentation, which is a single concern. It's not mixing feature work with documentation, so it should be fine.

Code quality: Since it's documentation, code quality checks like refactors, manually maintained lists, etc., don't directly apply. But I should check if the documentation is well-structured and consistent.

Looking at the diff, I see that the PR is adding several new markdown files in docs/15-testing/. The files are:

  • AGENT-TESTING.md (1014 lines)
  • agent-editor-test-cases.md (1261 lines)
  • business-event-test-cases.md (517 lines)
  • catalog-test-cases.md (540 lines)
  • and others like cli-commands-test-cases.md, enumeration-test-cases.md, etc.

The PR body lists 18 test documents with tests ranging from 7 to 89 per area, totaling 663 test cases.

Now, I need to see if there's any issue with this documentation. One thing to check is whether the documentation correctly describes the MDL syntax and usage, especially since there's a note in the PR: "All expectations corrected to match actual mxcli behavior observed during testing." This implies that previously, the test expectations might have been incorrect, and they've updated them to match reality.

Another point from the checklist: under "Documentation", it says:

  • Skills — new features documented in .claude/skills/ (syntax, examples, gotchas)
  • CLI helpmxcli command help text updated (Cobra Short/long/Example fields)
  • Syntax referencedocs/01-project/MDL_QUICK_REFERENCE.md updated with new statement syntax
  • MDL examples — working examples added to mdl-examples/doctype-tests/ for new commands
  • Site docsdocs-site/src/ pages added or updated for user-facing features

This PR is adding test case documentation, which might fall under "MDL examples" or "Site docs", but specifically, it's in docs/15-testing/, which seems to be a new directory for testing documentation.

I should check if the project already has a place for such documentation. Looking at the project structure mentioned in CLAUDE.md, there's a docs/ directory, and under it, there might be testing-related docs.

In the CLAUDE.md, under "Project Overview", it lists the directory structure, and under docs/, it doesn't specify, but there is a reference to docs/01-project/MDL_QUICK_REFERENCE.md.

The PR is adding to docs/15-testing/, which seems appropriate for test documentation.

Now, for potential issues:

  1. Overlap with existing documentation: I should check if there are already test case documents elsewhere. From the diff, it seems these are new files, so probably no overlap.

  2. Accuracy: The PR says expectations were corrected to match actual behavior, which is good for documentation quality.

  3. Completeness: It covers 19 test domains as listed in AGENT-TESTING.md.

  4. Following guidelines: The documentation should adhere to the project's style. Since it's markdown, and the project uses markdown elsewhere, it should be fine.

However, I recall that in the checklist, there's a point about "Verify the PR doesn't re-document already-shipped features as new". Since this is test documentation, not feature documentation, it might be okay. But if the test cases are for features that already exist, documenting them as new tests isn't re-documenting the features as new; it's adding test coverage.

Another angle: the PR might be introducing documentation that duplicates existing test documentation. But from the context, it seems this is a new set of manual test cases.

Looking at the diff for AGENT-TESTING.md, it starts with "# Agent Testing Instructions" and describes how to execute the test cases. This seems like a meta-documentation for running the tests, which is useful.

Similarly, the other files are the actual test cases.

Now, to apply the checklist strictly:

  • Overlap & duplication: I need to check if the diff introduces code that duplicates existing implementations. Since it's documentation, not code, this might not apply directly. But the checklist says "Check if the diff introduces code that duplicates existing implementations". The diff is adding markdown files, so no code duplication. However, it says "Check doctype test files above for existing test coverage of the feature area". The doctype test files mentioned in the context are things like 01-domain-model-examples.mdl, etc., which are automated test examples in mdl-examples/doctype-tests/. This PR is adding manual test documentation, not automated tests, so it's different. The manual test documentation is for human/AI agent execution, while the doctype tests are for automated validation. So likely no duplication.

  • MDL syntax design: Not applicable since no MDL syntax is being added or modified.

  • Full-stack consistency: Not applicable for the same reason.

  • Test coverage: The checklist says "New packages should have test files" – but this is documentation, not a new package. "New executor commands should have MDL examples in mdl-examples/doctype-tests/" – again, this PR isn't adding new executor commands; it's adding documentation for testing existing ones. However, one could argue that good test documentation improves test coverage indirectly, but the checklist item is specifically about having examples in mdl-examples/doctype-tests/ for new executor commands. Since this PR doesn't add new commands, it might not violate this, but it also doesn't fulfill it for new commands (because there are none). But the PR is not about adding features, so this checklist item might not be triggered.

  • Security & robustness: I should scan the documentation for any unsafe practices. For example, in AGENT-TESTING.md, under "Working with Test Fixture Copies", it correctly advises against running write operations on the original project and recommends using copies. It also mentions not to run parallel test sessions. This seems secure.

  • Scope & atomicity: The PR is focused on adding test documentation, so it's scoped to one thing.

  • Code quality: For documentation, we can check if it's well-formatted, consistent, etc. The files look like they follow markdown conventions.

One specific thing to check: in the MDL syntax, the documentation should correctly use colons for property definitions and AS for name mappings. For example, in the agent-editor-test-cases.md, I see lines like:

create agent MyModule.ChatAgent (
  UsageType: chat,
  Description: 'A helpful chat agent',
  ...

This uses colon for properties, which is correct per the guidelines (colon for property definitions).

Also, for AS usage: in the same file, I see:

tool FetchData {
  ToolType: microflow,
  Document: MyModule.ACT_FetchData,
  ...
}

Here, it's not using AS; it's defining properties. AS would be used for mappings like old AS new. I don't see any AS in these snippets, but I should check if AS is misused.

Looking through the diff, in business-event-test-cases.md, I see:

create business event service MyModule.OrderEvents
  event_name_prefix 'com.example.order'
  message OrderCreated (
    OrderId: Long,
    CustomerName: String,
    Total: Decimal
  ) publish entity MyModule.OrderCreatedEvent
/

Here, it's using colon for properties inside the message definition, which is correct.

In agent-editor-test-cases.md, under "2.6 Dollar-quoted prompts", it shows:

SystemPrompt: $$You are a helpful assistant.$$,

Which is correct for property definition.

I don't see any instances where AS is used incorrectly in the test cases. AS would be used in statements like ALTER ENTITY Module.OldName RENAME TO Module.NewName or something similar, but in these test cases for creating agents, etc., it's mostly property definitions.

For example, in the CREATE AGENT statements, it's using ( Property: value, ... ) format.

So, the MDL syntax in the documentation appears to follow the guidelines.

Another point: the documentation should use qualified names everywhere. In the examples, I see MyModule.ChatAgent, MyModule.GPT4o, etc., which are qualified names (Module.Element), so that's good.

Now, for the "Full-stack consistency" part: since this is documentation, not code, it doesn't need to be wired through the full pipeline. But the documentation should accurately reflect how the features work, which it claims to do by correcting expectations to match actual behavior.

Regarding test coverage: the PR is adding manual test documentation, which supports testing, but the checklist item about "New executor commands should have MDL examples in mdl-examples/doctype-tests/" isn't directly addressed because no new commands are added. However, the PR might be complementary to existing test coverage.

But the checklist is for reviewing the PR, so if the PR doesn't add new executor commands, then that particular checklist item doesn't apply, and we don't flag it as missing.

However, I should check if the documentation includes examples that could be used in mdl-examples/doctype-tests/. But the manual test documentation is separate; the doctype tests are for automated verification.

One potential issue: the PR might be adding test documentation that refers to features not yet implemented, but the PR says "All expectations corrected to match actual mxcli behavior", so it should be accurate.

Now, looking at the PR body, it mentions "Test Execution Results (v0.7.0-257-ga07e7e0)" with a pass rate of 534/663 (80.5%) and 16 confirmed bugs filed. This suggests that the test cases were run and bugs were found, which is good for improving quality.

But for the review, I need to see if there's anything in the documentation that is incorrect or problematic.

Let me think about specific sections.

In AGENT-TESTING.md, under "Prerequisites", it lists required software, including tmux and Docker. That seems fine.

Under "Test Session Workflow", it describes how to execute tests, which seems correct based on the project's usage.

In the "Execution Methods" section, it details different ways to run tests, like using -c flag, script files, REPL via tmux, etc. This matches what's described in the CLAUDE.md under "MDL CLI (mxcli)" section.

For example, in CLAUDE.md, it says:

# execute commands directly
./bin/mxcli -p /path/to/app.mpr -c "show entities"

# execute MDL script file
./bin/mxcli exec script.mdl -p /path/to/project.mpr

And in AGENT-TESTING.md, it has similar examples.

Also, the REPL terminator using / is correctly documented, as per the CLAUDE.md note: "Statement terminators — MDL statements in -c mode and script files require trailing semicolons. In REPL, use / on its own line to terminate write statements; read commands (SHOW, DESCRIBE) execute on Enter without any terminator. Semicolons are stripped and ignored in REPL."

In AGENT-TESTING.md, under "REPL and Interactive Testing via tmux", it explains that the REPL uses / as statement terminator.

So the documentation seems accurate.

Now, is there any overlap with existing documentation? For instance, does the project already have testing instructions elsewhere?

From the CLAUDE.md, I don't see a specific section for testing documentation, but there is a docs/ directory. The PR is adding to docs/15-testing/, which is likely a new subsection.

I should check if there are similar documents already. But since the diff shows these as new files (mode 100644, index 00000000..), they are new.

Another thing: the checklist has a point under "Documentation": "Site docs — docs-site/src/ pages added or updated for user-facing features". This PR is adding to docs/15-testing/, not docs-site/src/, so it might not be for the public site, but for contributor or internal testing documentation. That seems appropriate.

In fact, the docs/ directory in the repo likely contains developer documentation, while docs-site/ is for the user-facing site. So adding test documentation to docs/ makes sense.

Now, for potential moderate or minor issues:

  • The documentation is very long (over 1000 lines for some files). While comprehensive, it might be overwhelming, but that's not necessarily a bug; it's just detailed.

  • I should check if there are any inconsistencies or errors in the test cases.

For example, in agent-editor-test-cases.md, section 3.1 "Minimal agent":

create agent MyModule.SimpleAgent (
  UsageType: chat,
  Model: MyModule.GPT4o,
  SystemPrompt: $$Hello.$$
);

This looks correct.

In section 3.12 "Duplicate agent", it expects an error for duplicate, which is correct.

In failure modes, section 19.8 "Drop model referenced by agent", it says:

drop model MyModule.TestModel;

Expected: Warning about agent references. Model dropped (agent may have dangling reference).

This seems to reflect the actual behavior, as per the note in CLAUDE.md about entity access rules, but for models, it might be similar.

I don't see any obvious errors.

Another thing: in the business-event-test-cases.md, section 4.1 says: "> Note: The event_name_prefix and message keywords cause parse errors in the current build. The CREATE BUSINESS EVENT SERVICE grammar may not be fully implemented. Tests in this section may fail at the parser level rather than at execution."

This is a helpful note indicating that some features might not be fully implemented, which sets proper expectations. It's good that they documented this limitation.

Similarly, in other sections, they might have notes about known issues.

This shows that the documentation is honest about current limitations.

Now, for the review, since this is documentation, and it seems accurate and well-structured, there might not be critical issues.

But let's apply the checklist rigorously.

Overlap & duplication:

  • Check proposals list: the context says "Proposals in repo: No proposals directory." so no issue.
  • Check if diff introduces code that duplicates existing implementations: diff is markdown files, so no code.
  • Check doctype test files for existing test coverage: the doctype test files listed (like 01-domain-model-examples.mdl) are for automated examples, while this is manual test documentation, so different purpose. No overlap.
  • Flag if PR re-documents already-shipped features as new: this is test documentation, not feature documentation. The features being tested are already shipped (since they're testing against v0.7.0), so documenting how to test them isn't re-documenting the features as new; it's adding test coverage. So probably not an issue.

**MDL syntax


Automated review via OpenRouter (Nemotron Super 120B) — workflow source

@retran retran force-pushed the test-case-docs-clean branch from 5a7d92f to ebb9965 Compare May 1, 2026 12:53
@github-actions
Copy link
Copy Markdown

github-actions Bot commented May 1, 2026

AI Code Review

Okay, let me review this PR. The user is asking me to review a pull request that adds manual test case documentation for all MDL command areas. The PR includes a summary showing 18 test documents with 663 test cases total, and some test execution results showing an 80.5% pass rate with 16 confirmed bugs filed.

First, I need to check against the review checklist provided in CLAUDE.md. The PR is titled "docs: add manual test case documentation for all MDL command areas" and the body shows it's adding documentation files under docs/15-testing/.

Looking at the checklist items:

For "Overlap & duplication":

  • The PR is adding test documentation, not code, so I shouldn't see duplicated implementations
  • The test files are new (all are "new file mode 100644"), so no overlap with existing test coverage in mdl-examples/
  • The PR doesn't re-document already-shipped features as new - it's creating new test documentation

For "MDL syntax design":

  • This PR doesn't add or modify any MDL syntax (grammar rules, keywords, etc.) - it's purely documentation
  • So this section doesn't apply

For "Full-stack consistency":

  • Again, no MDL features being added, just documentation
  • So no need to check grammar, AST, visitor, executor, etc.

For "Test coverage":

  • The PR is adding test documentation, not actual tests
  • The checklist says "New packages should have test files" - but this is documentation, not code
  • "New executor commands should have MDL examples in mdl-examples/doctype-tests/" - not applicable here
  • The PR is about documenting how to run tests, not adding test cases themselves

For "Security & robustness":

  • Documentation doesn't introduce security issues
  • No command injection, XSS, etc. risks in documentation

For "Scope & atomicity":

  • The PR is scoped to a single concern: adding test documentation
  • Description doesn't have "and" between unrelated items
  • All changes are in the docs/15-testing/ directory

For "Code quality":

  • As documentation, code quality checks like refactors or manually maintained lists don't apply
  • Design docs matching implementation - but this is test documentation, not implementation

For "Bugs & correctness":

  • The PR mentions test execution results and bugs filed, which shows they've actually run these tests
  • No indication of logic errors in the documentation itself

Now, looking at what was actually changed:

  • Added docs/15-testing/AGENT-TESTING.md (1014 lines)
  • Added docs/15-testing/agent-editor-test-cases.md (1261 lines)
  • Added docs/15-testing/business-event-test-cases.md (517 lines)
  • Added docs/15-testing/catalog-test-cases.md (540 lines)
  • And several others (though the diff was truncated)

All these are new documentation files under docs/15-testing/. The PR summary says it's "Comprehensive manual test case documentation covering all MDL command areas."

According to the checklist under "Documentation":

  • Skills — new features documented in .claude/skills/ (syntax, examples, gotchas)
  • CLI helpmxcli command help text updated (Cobra Short/long/Example fields)
  • Syntax referencedocs/01-project/MDL_QUICK_REFERENCE.md updated with new statement syntax
  • MDL examples — working examples added to mdl-examples/ for new commands
  • Site docsdocs-site/src/ pages added or updated for user-facing features

This PR is adding test documentation, which doesn't fall neatly into these categories, but it is documentation. The project has a docs/ directory, and they're adding to docs/15-testing/ which seems appropriate for test documentation.

I notice that in the PR body, it says:
"All expectations corrected to match actual mxcli behavior observed during testing"
"Tests designed for manual execution by AI agents or human QA"
"Each test case includes: preconditions, steps, expected results, and cleanup"

This seems like good practice for test documentation.

One thing to check: the checklist mentions under "Test coverage":

  • New executor commands have MDL examples in mdl-examples/doctype-tests/
  • MDL syntax changes — any PR that adds or modifies MDL syntax must include working examples in mdl-examples/doctype-tests/

But this PR isn't adding MDL syntax or new executor commands - it's adding test documentation. So this doesn't apply.

However, I should check if the test documentation itself follows any guidelines. Looking at the AGENT-TESTING.md file, it seems comprehensive and well-structured.

Potential issues:

  • The PR mentions "18 test documents, 663 test cases total" but in the AGENT-TESTING.md file, I see it lists 19 test domains (01 through 19). There might be a small inconsistency here, but it's minor.
  • In the Test Project Coverage Matrix in AGENT-TESTING.md, it shows 19 documents but the PR summary said 18. Let me check:

From AGENT-TESTING.md:

+| # | Document | Domain |
+|---|----------|--------|
+| 01 | entity-test-cases.md | Entities, associations, constants |
+| 02 | enumeration-test-cases.md | Enumerations |
+| 03 | microflow-test-cases.md | Microflows |
+| 04 | nanoflow-test-cases.md | Nanoflows |
+| 05 | page-test-cases.md | Pages, snippets, layouts |
+| 06 | integration-test-cases.md | REST, OData, consumed/published services |
+| 07 | security-test-cases.md | Module/user roles, entity/page/microflow access |
+| 08 | navigation-settings-test-cases.md | Navigation profiles, menu items, project settings |
+| 09 | organization-test-cases.md | Modules, folders, MOVE operations |
+| 10 | workflow-test-cases.md | Workflows, user tasks, decisions |
+| 11 | catalog-test-cases.md | MDL catalog queries |
+| 12 | tooling-test-cases.md | Mermaid diagrams, diff, lint, formatter |
+| 13 | cli-commands-test-cases.md | All CLI subcommands |
+| 14 | sql-integration-test-cases.md | SQL queries against running app |
+| 15 | session-test-cases.md | REPL session management |
+| 16 | mapping-test-cases.md | Import/export mappings, JSON structures |
+| 17 | business-event-test-cases.md | Business event services |
+| 18 | image-collection-test-cases.md | Image collections |
+| 19 | agent-editor-test-cases.md | Agent/editor integration |
+```

That's 19 documents, but the PR summary said 18. Let me check the PR summary again:

Area File Tests
Entities & Associations entity-test-cases.md 58
Enumerations enumeration-test-cases.md 32
Microflows microflow-test-cases.md 89
Pages page-test-cases.md 72
Security security-test-cases.md 45
Navigation & Settings navigation-settings-test-cases.md 38
Organization organization-test-cases.md 28
Workflows workflow-test-cases.md 42
Integration (REST/OData) integration-test-cases.md 67
Catalog & SQL catalog-test-cases.md, sql-integration-test-cases.md 44
CLI Commands cli-commands-test-cases.md 35
Tooling (lint/report/fmt) tooling-test-cases.md 30
Business Events business-event-test-cases.md 24
Mappings mapping-test-cases.md 22
Agent/Editor agent-editor-test-cases.md 18
Images/Collections image-collection-test-cases.md 12
Session Management session-test-cases.md 7

That's 15 rows, but some rows cover multiple files (like Catalog & SQL covers two files). Let me count the actual files mentioned:
1. entity-test-cases.md
2. enumeration-test-cases.md
3. microflow-test-cases.md
4. page-test-cases.md
5. security-test-cases.md
6. navigation-settings-test-cases.md
7. organization-test-cases.md
8. workflow-test-cases.md
9. integration-test-cases.md
10. catalog-test-cases.md
11. sql-integration-test-cases.md
12. cli-commands-test-cases.md
13. tooling-test-cases.md
14. business-event-test-cases.md
15. mapping-test-cases.md
16. agent-editor-test-cases.md
17. image-collection-test-cases.md
18. session-test-cases.md

That's 18 files. But in AGENT-TESTING.md, they list 19 domains including nanoflow-test-cases.md which isn't in the PR summary table. Let me check if nanoflow-test-cases.md is included.

Looking at the PR summary table, I don't see a row for nanoflows. But in AGENT-TESTING.md, domain 04 is nanoflow-test-cases.md.

This is a discrepancy. The PR summary says 18 test documents but lists areas that don't include nanoflows, while AGENT-TESTING.md includes nanoflow-test-cases.md as domain 04.

Let me verify by looking at the actual files that were added. Since the diff was truncated, I can't see all files, but from what's visible:

- docs/15-testing/AGENT-TESTING.md (new)
- docs/15-testing/agent-editor-test-cases.md (new)
- docs/15-testing/business-event-test-cases.md (new)
- docs/15-testing/catalog-test-cases.md (new)

And the PR summary mentions:
- nanoflow-test-cases.md isn't listed in the table, but AGENT-TESTING.md includes it

Actually, looking more carefully at the PR summary table, I don't see nanoflows mentioned at all. But in the AGENT-TESTING.md file, it clearly lists:

| 04 | nanoflow-test-cases.md | Nanoflows |


And the test count for nanoflows would be part of the total 663.

This suggests the PR summary table might have omitted nanoflows accidentally, or perhaps nanoflow-test-cases.md wasn't included in this PR? But AGENT-TESTING.md references it.

Let me check if nanoflow-test-cases.md was actually added. Since the diff was truncated to 80k characters and the total size is 433613 bytes, it's possible that nanoflow-test-cases.md was added but not shown in the visible diff.

Given that AGENT-TESTING.md is part of the PR and it lists nanoflow-test-cases.md as domain 04, I'll assume it was included.

The discrepancy in the PR summary (saying 18 documents but listing areas that don't obviously add to 18 while AGENT-TESTING.md shows 19) is minor and likely just a typo in the summary. The important thing is that the documentation is being added.

Another thing to check: in the AGENT-TESTING.md file, under "Test Project Coverage Matrix", it shows tests for various projects. This seems appropriate.

Also, the PR mentions: "All expectations corrected to match actual mxcli behavior observed during testing" which shows they've validated the test expectations against real behavior.

Now, for the checklist item about "Documentation":
- [ ] **Site docs** — `docs-site/src/` pages added or updated for user-facing features

This test documentation might be considered site docs, but it's going under docs/15-testing/ rather than docs-site/src/. However, the project structure shows:

docs/
├── 01-project/
├── 02-tutorials/
├── 03-development/
├── ...
├── 15-testing/ <-- this is where they're adding it


So it seems appropriate to put test documentation in docs/15-testing/.

Looking at the existing docs structure from CLAUDE.md isn't detailed, but having a testing directory makes sense.

One potential issue: the PR is adding a lot of documentation files, but I should check if they follow the project's documentation style.

From what I can see in the visible parts of AGENT-TESTING.md, it has:
- Clear sections
- Code blocks with proper markdown
- Tables
- Proper formatting

It looks well-written.

Now, considering the "Scope & atomicity" checklist item:
- [ ] Each PR is scoped to a **single feature or concern** — if the description needs "and" between unrelated items, split it

This PR is solely about adding test documentation - no code changes, no syntax changes, just documentation. So it's properly scoped.

For "Code quality":
- [ ] Refactors are applied consistently across all relevant files (grep for the old pattern)
- Not applicable as there's no code refactoring
- [ ] Manually maintained lists (keyword lists, type mappings) are flagged as maintenance risks
- The documentation does contain lists (like the test domain table), but that's expected in documentation and not a maintenance risk in the same way as code

I don't see any red flags.

Let me double-check if there are any implied MDL syntax changes. The PR is about test documentation, not changing MDL itself. The test cases document MDL usage, but they're not introducing new MDL syntax.

For example, in agent-editor-test-cases.md, I see MDL statements like:

show agents;
describe agent MyModule.ChatAgent;
create agent MyModule.SimpleAgent (
UsageType: chat,
Model: MyModule.GPT4o,
SystemPrompt: $$Hello.$$
);


But these are examples of existing MDL syntax (assuming agents/models/etc. are already implemented), not new syntax being added in this PR.

The PR description says: "Comprehensive manual test case documentation covering all MDL command areas." It's documenting how to test existing features, not adding new features.

Therefore, none of the MDL syntax design or full-stack consistency checklist items apply.

The main thing to verify is that this documentation is actually useful and correctly describes how to run tests.

From the AGENT-TESTING.md file, it includes:
- Prerequisites
- Test session workflow
- How to read test cases
- Execution methods
- Working with test fixture copies
- Enriching the test project
- Verification patterns
- REPL and interactive testing via tmux
- Docker-dependent tests
- Auth-required tests
- Stress and boundary tests
- Handling known failures
- Result reporting
- Known limitations and pitfalls
- Test category quick reference

This seems comprehensive and appropriate for manual test documentation.

One small thing: in the AGENT-TESTING.md file, under "Prerequisites", it lists:

| Tool | Purpose | Install |
+------|---------|---------|
+| mxcli | The tool under test | make build (binary at ./bin/mxcli) |
+| tmux | Interactive REPL testing | brew install tmux (macOS) / pre-installed (Linux) |
+| Docker Desktop | SQL integration, docker commands | https://docker.com |
+| Go 1.26+ | Building from source | brew install go or mise |


It says "Go 1.26+" but the project might require a different version. However, this is just documentation, and if it's inaccurate, it's a minor issue that can be corrected separately. It doesn't affect the correctness of the PR in terms of introducing bugs.

Similarly, in the "Obtaining test projects" section, it shows:

Option 1: Download .mpk from App Gallery, extract with mxcli

mxcli new --from-mpk EnquiriesManagement.mpk


But looking at the mxcli new command description elsewhere in CLAUDE.md:

mxcli new

mxcli new creates a complete Mendix project from scratch in one step:

mxcli new MyApp --version 11.8.0
mxcli new MyApp --version 10.24.0 --output-dir ./projects/my-app

It doesn't mention a --from-mpk flag. This might be inaccurate documentation.

Let me check if --from-mpk is a valid flag. Since I don't have the source code in front of me, I can't verify, but if this documentation is incorrect, it could mislead users.

However, this is likely just a typo or outdated information in the documentation, not a fundamental flaw in the PR. The core purpose of the PR - providing test methodology - is sound.

Given that this is documentation and not code, minor inaccuracies like this are less critical than they would be in implementation code. The maintainers can correct them during review if needed.

Overall, this PR appears to be:

  • Properly scoped (only adding test documentation)
  • Not introducing any code changes that could have bugs
  • Providing valuable documentation for testing
  • Following the project's documentation structure (in docs/15-testing/)
  • Well-structured and comprehensive

I don't see any critical issues that would block the PR. There might be minor documentation inaccuracies, but those are typical for documentation PRs and can be addressed in comments rather than blocking the PR.

Let me formulate my review according to the requested structure: Critical Issues, Moderate Issues, Minor Issues, What Looks Good, Recommendation.

Critical Issues: None - this is documentation, not code that could introduce bugs or security vulnerabilities.

Moderate Issues:

  • The PR summary mentions

Automated review via OpenRouter (Nemotron Super 120B) — workflow source

@retran retran force-pushed the test-case-docs-clean branch 2 times, most recently from ce91da0 to fe96d0a Compare May 1, 2026 16:04
Comprehensive test case docs covering all 19 MDL command areas:
entity, enumeration, microflow, nanoflow, page, integration,
security, navigation, organization, workflow, catalog, tooling,
CLI commands, SQL, session, mapping, business event, image
collection, and agent/model/KB/MCP.

Each file specifies inputs, expected outputs, and edge cases.
AGENT-TESTING.md provides shared instructions for AI agents
executing these tests.

Validated all 1007 test cases against MDLParser.g4 grammar -
removed 102 hallucinated tests, fixed 16 syntax errors.
@retran retran force-pushed the test-case-docs-clean branch from fe96d0a to 27f045a Compare May 1, 2026 16:04
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant