Toolprovider: Mise

_tests/integration/toolprovider/asdf/install_error_test.go

@@ -32,7 +32,7 @@ func TestNoMatchingVersionError(t *testing.T) {
 
 	var installErr provider.ToolInstallError
 	require.ErrorAs(t, err, &installErr)
-	require.Equal(t, "nodejs", installErr.ToolName)
+	require.Equal(t, provider.ToolID("nodejs"), installErr.ToolName)
 	require.Equal(t, "22", installErr.RequestedVersion)
 	require.Contains(t, installErr.Error(), "no match for requested version 22")
 	require.Contains(t, installErr.Recommendation, "22:latest")
@@ -60,7 +60,7 @@ func TestNewToolPluginError(t *testing.T) {
 
 	var installErr provider.ToolInstallError
 	require.ErrorAs(t, err, &installErr)
-	require.Equal(t, "foo", installErr.ToolName)
+	require.Equal(t, provider.ToolID("foo"), installErr.ToolName)
 	require.Equal(t, "1.0.0", installErr.RequestedVersion)
 	require.Equal(t, installErr.Cause, "This tool integration (foo) is not tested or vetted by Bitrise.")
 	require.Equal(t, installErr.Recommendation, "If you want to use this tool anyway, look up its asdf plugin and provide it in the `plugin` field of the tool declaration. For example: `plugin: foo::https://github/url/to/asdf/plugin/repo.git`")

_tests/integration/toolprovider/mise/install_error_test.go

@@ -0,0 +1,37 @@
+//go:build linux_and_mac
+// +build linux_and_mac
+
+package mise
+
+import (
+	"testing"
+
+	"github.com/bitrise-io/bitrise/v2/toolprovider/mise"
+	"github.com/bitrise-io/bitrise/v2/toolprovider/provider"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNoMatchingVersionError(t *testing.T) {
+	miseInstallDir := t.TempDir()
+	miseDataDir := t.TempDir()
+	miseProvider, err := mise.NewToolProvider(miseInstallDir, miseDataDir)
+	require.NoError(t, err)
+
+	err = miseProvider.Bootstrap()
+	require.NoError(t, err)
+
+	request := provider.ToolRequest{
+		ToolName:           provider.ToolID("nodejs"),
+		UnparsedVersion:    "0.1.0",
+		ResolutionStrategy: provider.ResolutionStrategyStrict,
+	}
+	_, err = miseProvider.InstallTool(request)
+	require.Error(t, err)
+
+	var installErr provider.ToolInstallError
+	require.ErrorAs(t, err, &installErr)
+	require.Equal(t, provider.ToolID("nodejs"), installErr.ToolName)
+	require.Equal(t, "0.1.0", installErr.RequestedVersion)
+	require.Contains(t, installErr.Error(), "failed to install nodejs 0.1.0")
+	require.Contains(t, installErr.Cause, "no match for requested version 0.1.0")
+}

_tests/integration/toolprovider/mise/install_flutter_test.go

@@ -0,0 +1,46 @@
+//go:build linux_and_mac
+// +build linux_and_mac
+
+package mise
+
+import (
+	"testing"
+
+	"github.com/bitrise-io/bitrise/v2/toolprovider/mise"
+	"github.com/bitrise-io/bitrise/v2/toolprovider/provider"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAsdfInstallFlutter(t *testing.T) {
+	tests := []struct {
+		name               string
+		requestedVersion   string
+		resolutionStrategy provider.ResolutionStrategy
+		expectedVersion    string
+	}{
+		{"Install specific version", "3.32.1-stable", provider.ResolutionStrategyStrict, "3.32.1-stable"},
+	}
+
+	for _, tt := range tests {
+		miseInstallDir := t.TempDir()
+		miseDataDir := t.TempDir()
+		miseProvider, err := mise.NewToolProvider(miseInstallDir, miseDataDir)
+		require.NoError(t, err)
+
+		err = miseProvider.Bootstrap()
+		require.NoError(t, err)
+
+		t.Run(tt.name, func(t *testing.T) {
+			request := provider.ToolRequest{
+				ToolName:           "flutter",
+				UnparsedVersion:    tt.requestedVersion,
+				ResolutionStrategy: tt.resolutionStrategy,
+			}
+			result, err := miseProvider.InstallTool(request)
+			require.NoError(t, err)
+			require.Equal(t, provider.ToolID("flutter"), result.ToolName)
+			require.Equal(t, tt.expectedVersion, result.ConcreteVersion)
+			require.False(t, result.IsAlreadyInstalled)
+		})
+	}
+}

_tests/integration/toolprovider/mise/install_golang_test.go

@@ -0,0 +1,48 @@
+//go:build linux_and_mac
+// +build linux_and_mac
+
+package mise
+
+import (
+	"testing"
+
+	"github.com/bitrise-io/bitrise/v2/toolprovider/mise"
+	"github.com/bitrise-io/bitrise/v2/toolprovider/provider"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAsdfInstallGolangVersion(t *testing.T) {
+	tests := []struct {
+		name               string
+		requestedVersion   string
+		resolutionStrategy provider.ResolutionStrategy
+		expectedVersion    string
+	}{
+		{"Install specific version", "1.23.4", provider.ResolutionStrategyStrict, "1.23.4"},
+		{"Install partial major.minor version", "1.22", provider.ResolutionStrategyLatestInstalled, "1.22.12"},
+		{"Install partial major.minor version, latest released", "1.22", provider.ResolutionStrategyLatestReleased, "1.22.12"},
+	}
+
+	for _, tt := range tests {
+		miseInstallDir := t.TempDir()
+		miseDataDir := t.TempDir()
+		miseProvider, err := mise.NewToolProvider(miseInstallDir, miseDataDir)
+		require.NoError(t, err)
+
+		err = miseProvider.Bootstrap()
+		require.NoError(t, err)
+
+		t.Run(tt.name, func(t *testing.T) {
+			request := provider.ToolRequest{
+				ToolName:           "golang",
+				UnparsedVersion:    tt.requestedVersion,
+				ResolutionStrategy: tt.resolutionStrategy,
+			}
+			result, err := miseProvider.InstallTool(request)
+			require.NoError(t, err)
+			require.Equal(t, provider.ToolID("golang"), result.ToolName)
+			require.Equal(t, tt.expectedVersion, result.ConcreteVersion)
+			require.False(t, result.IsAlreadyInstalled)
+		})
+	}
+}

_tests/integration/toolprovider/mise/install_java_test.go

@@ -0,0 +1,66 @@
+package mise
+
+import (
+	"testing"
+
+	"github.com/bitrise-io/bitrise/v2/toolprovider/provider"
+	"github.com/bitrise-io/bitrise/v2/toolprovider/mise"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMiseInstallJavaVersion(t *testing.T) {
+	tests := []struct {
+		name               string
+		requestedVersion   string
+		resolutionStrategy provider.ResolutionStrategy
+		expectedVersion    string
+	}{
+		{
+			name:               "OpenJDK major version only",
+			requestedVersion:   "21",
+			resolutionStrategy: provider.ResolutionStrategyStrict,
+			expectedVersion:    "21.0.2",
+		},
+		{
+			name:               "OpenJDK major version only, latest released",
+			requestedVersion:   "17",
+			resolutionStrategy: provider.ResolutionStrategyLatestReleased,
+			expectedVersion:    "17.0.2",
+		},
+		{
+			name:               "Temurin major version only",
+			requestedVersion:   "temurin-22",
+			resolutionStrategy: provider.ResolutionStrategyLatestReleased,
+			expectedVersion:    "temurin-22.0.2+9",
+		},
+		{
+			name:               "Temurin exact version",
+			requestedVersion:   "temurin-18.0.2+9",
+			resolutionStrategy: provider.ResolutionStrategyStrict,
+			expectedVersion:    "temurin-18.0.2+9",
+		},
+	}
+
+	for _, tt := range tests {
+		miseInstallDir := t.TempDir()
+		miseDataDir := t.TempDir()
+		miseProvider, err := mise.NewToolProvider(miseInstallDir, miseDataDir)
+		require.NoError(t, err)
+
+		err = miseProvider.Bootstrap()
+		require.NoError(t, err)
+
+		t.Run(tt.name, func(t *testing.T) {
+			request := provider.ToolRequest{
+				ToolName:           provider.ToolID("java"),
+				UnparsedVersion:    tt.requestedVersion,
+				ResolutionStrategy: tt.resolutionStrategy,
+			}
+			result, err := miseProvider.InstallTool(request)
+			require.NoError(t, err)
+			require.Equal(t, provider.ToolID("java"), result.ToolName)
+			require.Equal(t, tt.expectedVersion, result.ConcreteVersion)
+			require.False(t, result.IsAlreadyInstalled)
+		})
+	}
+}

_tests/integration/toolprovider/mise/install_nodejs_test.go

@@ -0,0 +1,45 @@
+package mise
+
+import (
+	"testing"
+
+	"github.com/bitrise-io/bitrise/v2/toolprovider/provider"
+	"github.com/bitrise-io/bitrise/v2/toolprovider/mise"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMiseInstallNodeVersion(t *testing.T) {
+	tests := []struct {
+		name               string
+		requestedVersion   string
+		resolutionStrategy provider.ResolutionStrategy
+		expectedVersion    string
+	}{
+		{"Install specific version", "18.16.0", provider.ResolutionStrategyStrict, "18.16.0"},
+		{"Install partial major version", "18", provider.ResolutionStrategyLatestInstalled, "18.20.8"},
+		{"Install partial major.minor version", "18.10", provider.ResolutionStrategyLatestReleased, "18.10.0"},
+	}
+
+	for _, tt := range tests {
+		miseInstallDir := t.TempDir()
+		miseDataDir := t.TempDir()
+		miseProvider, err := mise.NewToolProvider(miseInstallDir, miseDataDir)
+		require.NoError(t, err)
+
+		err = miseProvider.Bootstrap()
+		require.NoError(t, err)
+
+		t.Run(tt.name, func(t *testing.T) {
+			request := provider.ToolRequest{
+				ToolName:           provider.ToolID("nodejs"),
+				UnparsedVersion:    tt.requestedVersion,
+				ResolutionStrategy: tt.resolutionStrategy,
+			}
+			result, err := miseProvider.InstallTool(request)
+			require.NoError(t, err)
+			require.Equal(t, provider.ToolID("nodejs"), result.ToolName)
+			require.Equal(t, tt.expectedVersion, result.ConcreteVersion)
+			require.False(t, result.IsAlreadyInstalled)
+		})
+	}
+}

_tests/integration/toolprovider_test.go

@@ -10,8 +10,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestToolProvider(t *testing.T) {
+func TestDefaultToolProvider(t *testing.T) {
 	cmd := command.New(binPath(), "run", "toolprovider_test", "--config", "toolprovider_test_bitrise.yml")
 	out, err := cmd.RunAndReturnTrimmedCombinedOutput()
 	require.NoError(t, err, out)
 }
+
+func TestMiseToolProvider(t *testing.T) {
+	cmd := command.New(binPath(), "run", "toolprovider_test", "--config", "toolprovider_test_mise_bitrise.yml")
+	out, err := cmd.RunAndReturnTrimmedCombinedOutput()
+	require.NoError(t, err, out)
+}

_tests/integration/toolprovider_test_mise_bitrise.yml

@@ -0,0 +1,15 @@
+format_version: "17"
+default_step_lib_source: https://github.com/bitrise-io/bitrise-steplib.git
+
+tools:
+  nodejs: 22:latest
+tool_config:
+  provider: mise
+
+workflows:
+  toolprovider_test:
+    steps:
+      - script@1:
+          title: Test activated tool
+          inputs:
+            - content: set -ex; node --version | grep -q "22"

_tests/integration/validate_test.go

@@ -75,6 +75,27 @@ tool_config:
   extra_plugins:
     empty-url-tool: ""
 `
+const miseToolConfigYML = `format_version: 11
+default_step_lib_source: https://github.com/bitrise-io/bitrise-steplib.git
+
+tools:
+  golang: "1.20.3"
+  nodejs: "20:latest"
+  ruby: "3.2:installed"
+
+tool_config:
+  provider: mise
+  extra_plugins:
+    flutter: "https://github.com/asdf-community/asdf-flutter.git"
+    custom-tool: "https://github.com/user/asdf-custom-tool.git"
+
+workflows:
+  test:
+    steps:
+    - script:
+        inputs:
+        - content: echo "hello"
+`
 const runtimeLimit = 1000 * time.Millisecond
 const runningTimeMsg = "test case too slow: %s is %s above limit"
 
@@ -272,6 +293,22 @@ func Test_InvalidToolConfigValidateTest(t *testing.T) {
 	require.Equal(t, true, elapsed < runtimeLimit, runningTimeMsg, elapsed, elapsed-runtimeLimit)
 }
 
+func Test_ValidMiseToolConfigValidateTest(t *testing.T) {
+	tmpDir := t.TempDir()
+	configPth := filepath.Join(tmpDir, "bitrise.yml")
+	require.NoError(t, fileutil.WriteStringToFile(configPth, miseToolConfigYML))
+
+	var out string
+	var err error
+	elapsed := withRunningTimeCheck(func() {
+		cmd := command.New(binPath(), "validate", "-c", configPth)
+		out, err = cmd.RunAndReturnTrimmedCombinedOutput()
+	})
+	require.NoError(t, err, out)
+	require.Equal(t, "Config is valid: \x1b[32;1mtrue\x1b[0m", out)
+	require.Equal(t, true, elapsed < runtimeLimit, runningTimeMsg, elapsed, elapsed-runtimeLimit)
+}
+
 func Test_SecretValidateTest(t *testing.T) {
 	tmpDir, err := pathutil.NormalizedOSTempDirPath("__validate_test__")
 	require.NoError(t, err)

toolprovider/asdf/asdf.go

@@ -81,7 +81,7 @@ func (a AsdfToolProvider) InstallTool(tool provider.ToolRequest) (provider.ToolI
 			if err != nil {
 				if errors.As(err, &nomatchErr) {
 					errorDetails := provider.ToolInstallError{
-						ToolName:         string(tool.ToolName),
+						ToolName:         tool.ToolName,
 						RequestedVersion: tool.UnparsedVersion,
 						Cause:            nomatchErr.Error(),
 						Recommendation:   fmt.Sprintf("You might want to use `%s:installed` or `%s:latest` to install the latest installed or latest released version of %s %s.", tool.UnparsedVersion, tool.UnparsedVersion, tool.ToolName, tool.UnparsedVersion),

toolprovider/asdf/install.go

@@ -18,7 +18,7 @@ func (a *AsdfToolProvider) installToolVersion(
 	out, err := a.ExecEnv.RunAsdf("install", string(toolName), versionString)
 	if err != nil {
 		return provider.ToolInstallError{
-			ToolName:         string(toolName),
+			ToolName:         toolName,
 			RequestedVersion: versionString,
 			Cause:            fmt.Sprintf("asdf install %s %s: %s", string(toolName), versionString, err),
 			RawOutput:        out,

toolprovider/asdf/install_plugin.go

@@ -34,15 +34,15 @@ func (a AsdfToolProvider) InstallPlugin(tool provider.ToolRequest) error {
 	if err != nil {
 		// E.g. parse error while resolving plugin source.
 		return provider.ToolInstallError{
-			ToolName:         string(tool.ToolName),
+			ToolName:         tool.ToolName,
 			RequestedVersion: tool.UnparsedVersion,
 			Cause:            fmt.Sprintf("Couldn't resolve plugin source: %s", err),
 			Recommendation:   "Review the syntax of the `plugin` field",
 		}
 	}
 	if plugin == nil {
 		return provider.ToolInstallError{
-			ToolName:         string(tool.ToolName),
+			ToolName:         tool.ToolName,
 			RequestedVersion: tool.UnparsedVersion,
 			Cause:            fmt.Sprintf("This tool integration (%s) is not tested or vetted by Bitrise.", tool.ToolName),
 			Recommendation:   fmt.Sprintf("If you want to use this tool anyway, look up its asdf plugin and provide it in the `plugin` field of the tool declaration. For example: `plugin: %s::https://github/url/to/asdf/plugin/repo.git`", tool.ToolName),