test: prefer installed mx in integration harness

The roundtrip test helpers previously preferred a repo-local
`reference/mxbuild/modeler/mx` (a developer convenience that was never
checked into CI images), then fell back to cached downloads, then to
`PATH`. On machines where CI installs `mx` via the system package
(current setup) the harness still walked the fallback chain and either
ran against a stale cached binary or a missing repo-local path, which
silently changed the Mendix version exercised by the tests.

Reorder `findMxBinary`:

    MX_BINARY env var -> PATH -> repo-local reference -> cached downloads

`PATH` now wins over repo-local so whatever version CI installs is what
the tests use. The cached-download fallback also stops returning the
lexicographically last match — `9.24.40.80973` sorted after `11.9.0`
and we ran integration tests on Mendix 9 by accident. Add
`newestVersionedPath` which parses each path's version segment into
`[major, minor, patch, build]` ints and picks the highest tuple.

Two `//go:build integration` tests cover the new helper:
- `TestNewestVersionedPath_PicksNewestNumericVersion` — version ordering
- `TestFindMxBinary_PrefersPathOverCachedDownloads` — PATH wins when
  both PATH and cache have `mx` present

Author: hjotha

mdl/executor/roundtrip_helpers_mx_test.go

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+
+//go:build integration
+
+package executor
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestNewestVersionedPath_PicksNewestNumericVersion(t *testing.T) {
+	t.Parallel()
+
+	paths := []string{
+		"/tmp/.mxcli/mxbuild/11.9.0/modeler/mx",
+		"/tmp/.mxcli/mxbuild/11.6.3/modeler/mx",
+		"/tmp/.mxcli/mxbuild/9.24.40.80973/modeler/mx",
+	}
+
+	got := newestVersionedPath(paths)
+	want := "/tmp/.mxcli/mxbuild/11.9.0/modeler/mx"
+	if got != want {
+		t.Fatalf("newestVersionedPath() = %q, want %q", got, want)
+	}
+}
+
+func TestFindMxBinary_PrefersPathOverCachedDownloads(t *testing.T) {
+	home := t.TempDir()
+	pathDir := filepath.Join(home, "bin")
+	if err := os.MkdirAll(pathDir, 0755); err != nil {
+		t.Fatalf("mkdir path dir: %v", err)
+	}
+
+	pathMx := filepath.Join(pathDir, "mx")
+	if err := os.WriteFile(pathMx, []byte("#!/bin/sh\nexit 0\n"), 0755); err != nil {
+		t.Fatalf("write PATH mx: %v", err)
+	}
+
+	for _, version := range []string{"11.9.0", "11.6.3", "9.24.40.80973"} {
+		cacheMx := filepath.Join(home, ".mxcli", "mxbuild", version, "modeler", "mx")
+		if err := os.MkdirAll(filepath.Dir(cacheMx), 0755); err != nil {
+			t.Fatalf("mkdir cache dir: %v", err)
+		}
+		if err := os.WriteFile(cacheMx, []byte("#!/bin/sh\nexit 0\n"), 0755); err != nil {
+			t.Fatalf("write cached mx: %v", err)
+		}
+	}
+
+	t.Setenv("HOME", home)
+	t.Setenv("PATH", pathDir)
+	t.Setenv("MX_BINARY", "")
+
+	if got := findMxBinary(); got != pathMx {
+		t.Fatalf("findMxBinary() = %q, want PATH binary %q", got, pathMx)
+	}
+}

mdl/executor/roundtrip_helpers_test.go

@@ -18,6 +18,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"testing"
 
@@ -132,8 +133,8 @@ func copyTestProject(t *testing.T) string {
 }
 
 // findMxBinary searches for the mx command in known locations.
-// Search order: MX_BINARY env var, reference/mxbuild/modeler/mx (repo-local),
-// ~/.mxcli/mxbuild/*/modeler/mx (cached downloads), PATH lookup.
+// Search order: MX_BINARY env var, PATH lookup, reference/mxbuild/modeler/mx
+// (repo-local), ~/.mxcli/mxbuild/*/modeler/mx (cached downloads, newest numeric version).
 func findMxBinary() string {
 	// 0. Explicit override via environment variable
 	if p := os.Getenv("MX_BINARY"); p != "" {
@@ -142,28 +143,104 @@ func findMxBinary() string {
 		}
 	}
 
-	// 1. Repo-local reference path
+	// 1. PATH lookup
+	if p, err := exec.LookPath("mx"); err == nil {
+		return p
+	}
+
+	// 2. Repo-local reference path
 	repoPath, err := filepath.Abs("../../reference/mxbuild/modeler/mx")
 	if err == nil {
 		if _, err := os.Stat(repoPath); err == nil {
 			return repoPath
 		}
 	}
 
-	// 2. Cached downloads (~/.mxcli/mxbuild/*/modeler/mx)
+	// 3. Cached downloads (~/.mxcli/mxbuild/*/modeler/mx)
 	if home, err := os.UserHomeDir(); err == nil {
 		pattern := filepath.Join(home, ".mxcli", "mxbuild", "*", "modeler", "mx")
 		if matches, _ := filepath.Glob(pattern); len(matches) > 0 {
-			return matches[len(matches)-1]
+			return newestVersionedPath(matches)
 		}
 	}
 
-	// 3. PATH lookup
-	if p, err := exec.LookPath("mx"); err == nil {
-		return p
+	return ""
+}
+
+func newestVersionedPath(paths []string) string {
+	var best string
+	var bestVersion []int
+	bestValid := false
+
+	for _, path := range paths {
+		versionParts, ok := parseVersionParts(versionFromPath(path))
+		switch {
+		case best == "":
+			best = path
+			bestVersion = versionParts
+			bestValid = ok
+		case ok && !bestValid:
+			best = path
+			bestVersion = versionParts
+			bestValid = true
+		case ok && bestValid:
+			if cmp := compareVersionParts(versionParts, bestVersion); cmp > 0 || (cmp == 0 && path > best) {
+				best = path
+				bestVersion = versionParts
+			}
+		case !ok && !bestValid && path > best:
+			best = path
+		}
 	}
 
-	return ""
+	return best
+}
+
+func versionFromPath(path string) string {
+	versionDir := filepath.Dir(filepath.Dir(path))
+	return filepath.Base(versionDir)
+}
+
+func parseVersionParts(version string) ([]int, bool) {
+	if version == "" {
+		return nil, false
+	}
+	parts := strings.Split(version, ".")
+	values := make([]int, 0, len(parts))
+	for _, part := range parts {
+		if part == "" {
+			return nil, false
+		}
+		value, err := strconv.Atoi(part)
+		if err != nil {
+			return nil, false
+		}
+		values = append(values, value)
+	}
+	return values, true
+}
+
+func compareVersionParts(left, right []int) int {
+	maxLen := len(left)
+	if len(right) > maxLen {
+		maxLen = len(right)
+	}
+	for i := 0; i < maxLen; i++ {
+		var l, r int
+		if i < len(left) {
+			l = left[i]
+		}
+		if i < len(right) {
+			r = right[i]
+		}
+		switch {
+		case l < r:
+			return -1
+		case l > r:
+			return 1
+		}
+	}
+	return 0
 }
 
 // copyFile copies a single file from src to dst.