test: add visitor tests for 20 untested visitor source files

Cover security (24 tests), odata (4), agent editor (4), REST (2),
settings (4), module (1), association (3), connection (2), business
events (1), enumeration (5), JSON structure (1), data transformer (1),
widgets (2), image collection (1), navigation (1), lint (4),
import/export mapping (2), move (2), misc queries (4), and database
connection (1).

Visitor test function count: 128 -> 197 (+69).

Author: retran

mdl/visitor/visitor_agenteditor_test.go

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package visitor
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+)
+
+func TestCreateModel(t *testing.T) {
+	input := `CREATE MODEL MyModule.GPT4 (
+		Provider: MxCloudGenAI,
+		Key: MyModule.APIKey,
+		DisplayName: 'GPT-4 Turbo'
+	);`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.CreateModelStmt)
+	if !ok {
+		t.Fatalf("Expected CreateModelStmt, got %T", prog.Statements[0])
+	}
+	if stmt.Name.Module != "MyModule" || stmt.Name.Name != "GPT4" {
+		t.Errorf("Expected MyModule.GPT4, got %s.%s", stmt.Name.Module, stmt.Name.Name)
+	}
+	if stmt.Provider != "MxCloudGenAI" {
+		t.Errorf("Got Provider %q", stmt.Provider)
+	}
+	if stmt.Key == nil || stmt.Key.Name != "APIKey" {
+		t.Error("Key mismatch")
+	}
+	if stmt.DisplayName != "GPT-4 Turbo" {
+		t.Errorf("Got DisplayName %q", stmt.DisplayName)
+	}
+}
+
+func TestCreateConsumedMCPService(t *testing.T) {
+	input := `CREATE CONSUMED MCP SERVICE MyModule.ToolService (
+		ProtocolVersion: v2025_03_26,
+		Version: '0.0.1',
+		ConnectionTimeoutSeconds: 30,
+		Documentation: 'MCP tool service'
+	);`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.CreateConsumedMCPServiceStmt)
+	if !ok {
+		t.Fatalf("Expected CreateConsumedMCPServiceStmt, got %T", prog.Statements[0])
+	}
+	if stmt.ProtocolVersion != "v2025_03_26" {
+		t.Errorf("Got ProtocolVersion %q", stmt.ProtocolVersion)
+	}
+	if stmt.Version != "0.0.1" {
+		t.Errorf("Got Version %q", stmt.Version)
+	}
+	if stmt.ConnectionTimeoutSeconds != 30 {
+		t.Errorf("Got ConnectionTimeoutSeconds %d", stmt.ConnectionTimeoutSeconds)
+	}
+	if stmt.InnerDocumentation != "MCP tool service" {
+		t.Errorf("Got InnerDocumentation %q", stmt.InnerDocumentation)
+	}
+}
+
+func TestCreateKnowledgeBase(t *testing.T) {
+	input := `CREATE KNOWLEDGE BASE MyModule.ProductKB (
+		Provider: MxCloudGenAI,
+		Key: MyModule.KBKey,
+		ModelDisplayName: 'Product Knowledge',
+		ModelName: 'product-embeddings'
+	);`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.CreateKnowledgeBaseStmt)
+	if !ok {
+		t.Fatalf("Expected CreateKnowledgeBaseStmt, got %T", prog.Statements[0])
+	}
+	if stmt.Provider != "MxCloudGenAI" {
+		t.Errorf("Got Provider %q", stmt.Provider)
+	}
+	if stmt.Key == nil || stmt.Key.Name != "KBKey" {
+		t.Error("Key mismatch")
+	}
+	if stmt.ModelDisplayName != "Product Knowledge" {
+		t.Errorf("Got ModelDisplayName %q", stmt.ModelDisplayName)
+	}
+}
+
+func TestCreateAgent_Basic(t *testing.T) {
+	input := `CREATE AGENT MyModule.OrderAgent (
+		UsageType: Task,
+		Model: MyModule.GPT4,
+		Entity: MyModule.OrderContext,
+		SystemPrompt: 'You are an order processing assistant.',
+		ToolChoice: auto,
+		MaxTokens: 4096,
+		Temperature: 0.7
+	);`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.CreateAgentStmt)
+	if !ok {
+		t.Fatalf("Expected CreateAgentStmt, got %T", prog.Statements[0])
+	}
+	if stmt.UsageType != "Task" {
+		t.Errorf("Got UsageType %q", stmt.UsageType)
+	}
+	if stmt.Model == nil || stmt.Model.Name != "GPT4" {
+		t.Error("Model mismatch")
+	}
+	if stmt.Entity == nil || stmt.Entity.Name != "OrderContext" {
+		t.Error("Entity mismatch")
+	}
+	if stmt.MaxTokens == nil || *stmt.MaxTokens != 4096 {
+		t.Error("MaxTokens mismatch")
+	}
+	if stmt.Temperature == nil || *stmt.Temperature != 0.7 {
+		t.Error("Temperature mismatch")
+	}
+	if stmt.ToolChoice != "auto" {
+		t.Errorf("Got ToolChoice %q", stmt.ToolChoice)
+	}
+}

mdl/visitor/visitor_association_test.go

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package visitor
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+)
+
+func TestCreateAssociation(t *testing.T) {
+	input := `CREATE ASSOCIATION MyModule.Order_Customer FROM MyModule.Order TO MyModule.Customer TYPE REFERENCE OWNER DEFAULT;`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.CreateAssociationStmt)
+	if !ok {
+		t.Fatalf("Expected CreateAssociationStmt, got %T", prog.Statements[0])
+	}
+	if stmt.Name.Module != "MyModule" || stmt.Name.Name != "Order_Customer" {
+		t.Errorf("Got name %s.%s", stmt.Name.Module, stmt.Name.Name)
+	}
+	if stmt.Parent.Name != "Order" {
+		t.Errorf("Got parent %s", stmt.Parent.Name)
+	}
+	if stmt.Child.Name != "Customer" {
+		t.Errorf("Got child %s", stmt.Child.Name)
+	}
+	if stmt.Type != ast.AssocReference {
+		t.Errorf("Expected Reference type, got %v", stmt.Type)
+	}
+}
+
+func TestCreateAssociation_ReferenceSet(t *testing.T) {
+	input := `CREATE ASSOCIATION MyModule.Order_Product FROM MyModule.Order TO MyModule.Product TYPE REFERENCE_SET OWNER BOTH;`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt := prog.Statements[0].(*ast.CreateAssociationStmt)
+	if stmt.Type != ast.AssocReferenceSet {
+		t.Errorf("Expected ReferenceSet, got %v", stmt.Type)
+	}
+	if stmt.Owner != ast.OwnerBoth {
+		t.Errorf("Expected OwnerBoth, got %v", stmt.Owner)
+	}
+}
+
+func TestAlterAssociation_SetOwner(t *testing.T) {
+	input := `ALTER ASSOCIATION MyModule.Order_Customer SET OWNER BOTH;`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.AlterAssociationStmt)
+	if !ok {
+		t.Fatalf("Expected AlterAssociationStmt, got %T", prog.Statements[0])
+	}
+	if stmt.Name.Name != "Order_Customer" {
+		t.Errorf("Got name %s", stmt.Name.Name)
+	}
+	if stmt.Owner != ast.OwnerBoth {
+		t.Errorf("Expected OwnerBoth, got %v", stmt.Owner)
+	}
+}

mdl/visitor/visitor_businessevents_test.go

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package visitor
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+)
+
+func TestCreateBusinessEventService(t *testing.T) {
+	input := `CREATE BUSINESS EVENT SERVICE MyModule.OrderEvents (
+		ServiceName: 'OrderService',
+		EventNamePrefix: 'com.example.orders'
+	) {
+		MESSAGE OrderCreated (OrderId: Long) PUBLISH ENTITY MyModule.Order;
+	};`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.CreateBusinessEventServiceStmt)
+	if !ok {
+		t.Fatalf("Expected CreateBusinessEventServiceStmt, got %T", prog.Statements[0])
+	}
+	if stmt.ServiceName != "OrderService" {
+		t.Errorf("Got ServiceName %q", stmt.ServiceName)
+	}
+	if stmt.EventNamePrefix != "com.example.orders" {
+		t.Errorf("Got EventNamePrefix %q", stmt.EventNamePrefix)
+	}
+	if len(stmt.Messages) != 1 {
+		t.Fatalf("Expected 1 message, got %d", len(stmt.Messages))
+	}
+	if stmt.Messages[0].MessageName != "OrderCreated" {
+		t.Errorf("Got MessageName %q", stmt.Messages[0].MessageName)
+	}
+	if stmt.Messages[0].Operation != "PUBLISH" {
+		t.Errorf("Got Operation %q", stmt.Messages[0].Operation)
+	}
+}

mdl/visitor/visitor_connection_test.go

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package visitor
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+)
+
+func TestConnect_Local(t *testing.T) {
+	input := `CONNECT LOCAL '/path/to/project';`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.ConnectStmt)
+	if !ok {
+		t.Fatalf("Expected ConnectStmt, got %T", prog.Statements[0])
+	}
+	if stmt.Path != "/path/to/project" {
+		t.Errorf("Expected /path/to/project, got %q", stmt.Path)
+	}
+}
+
+func TestDisconnect(t *testing.T) {
+	input := `DISCONNECT;`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	_, ok := prog.Statements[0].(*ast.DisconnectStmt)
+	if !ok {
+		t.Fatalf("Expected DisconnectStmt, got %T", prog.Statements[0])
+	}
+}

mdl/visitor/visitor_datatransformer_test.go

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package visitor
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+)
+
+func TestCreateDataTransformer(t *testing.T) {
+	input := `CREATE DATA TRANSFORMER MyModule.LatExtract SOURCE JSON '{"lat": 51.9}' {
+		JSLT '{ "latitude": .lat }';
+	};`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.CreateDataTransformerStmt)
+	if !ok {
+		t.Fatalf("Expected CreateDataTransformerStmt, got %T", prog.Statements[0])
+	}
+	if stmt.Name.Name != "LatExtract" {
+		t.Errorf("Got name %s", stmt.Name.Name)
+	}
+	if stmt.SourceType != "JSON" {
+		t.Errorf("Got SourceType %q", stmt.SourceType)
+	}
+	if len(stmt.Steps) != 1 {
+		t.Fatalf("Expected 1 step, got %d", len(stmt.Steps))
+	}
+	if stmt.Steps[0].Technology != "JSLT" {
+		t.Errorf("Got Technology %q", stmt.Steps[0].Technology)
+	}
+}

mdl/visitor/visitor_dbconnection_test.go

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package visitor
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+)
+
+func TestCreateDatabaseConnection(t *testing.T) {
+	input := `CREATE DATABASE CONNECTION MyModule.MyDB TYPE 'PostgreSQL' HOST 'localhost' PORT 5432 DATABASE 'mydb' USERNAME 'user' PASSWORD 'pass';`
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, e := range errs {
+			t.Errorf("Parse error: %v", e)
+		}
+		return
+	}
+	stmt, ok := prog.Statements[0].(*ast.CreateDatabaseConnectionStmt)
+	if !ok {
+		t.Fatalf("Expected CreateDatabaseConnectionStmt, got %T", prog.Statements[0])
+	}
+	if stmt.Name.Name != "MyDB" {
+		t.Errorf("Got name %s", stmt.Name.Name)
+	}
+	if stmt.DatabaseType != "PostgreSQL" {
+		t.Errorf("Got DatabaseType %q", stmt.DatabaseType)
+	}
+	if stmt.Host != "localhost" {
+		t.Errorf("Got Host %q", stmt.Host)
+	}
+	if stmt.Port != 5432 {
+		t.Errorf("Got Port %d", stmt.Port)
+	}
+	if stmt.UserName != "user" {
+		t.Errorf("Got UserName %q", stmt.UserName)
+	}
+}