Merge pull request #16 from DataDog/anmarchenko/minitest_support

[SDTEST-2446] Minitest support

Author: anmarchenko

README.md

@@ -6,7 +6,7 @@ You need it when Test Impact Analysis shrinks the test workload but CI still lau
 
 Currently supported languages and frameworks:
 
-- Ruby (RSpec)
+- Ruby (RSpec, Minitest)
 
 ## Installation
 
@@ -115,7 +115,7 @@ In CI‑node mode, DDTest also fans out across local CPUs on that node and furth
 | CLI flag            | Environment variable                          |    Default | What it does                                                                                                          |
 | ------------------- | --------------------------------------------- | ---------: | --------------------------------------------------------------------------------------------------------------------- |
 | `--platform`        | `DD_TEST_OPTIMIZATION_RUNNER_PLATFORM`        |     `ruby` | Language/platform (currently supported values: `ruby`).                                                               |
-| `--framework`       | `DD_TEST_OPTIMIZATION_RUNNER_FRAMEWORK`       |    `rspec` | Test framework (currently supported values: `rspec`).                                                                 |
+| `--framework`       | `DD_TEST_OPTIMIZATION_RUNNER_FRAMEWORK`       |    `rspec` | Test framework (currently supported values: `rspec`, `minitest`).                                                     |
 | `--min-parallelism` | `DD_TEST_OPTIMIZATION_RUNNER_MIN_PARALLELISM` | vCPU count | Minimum workers to use for the split.                                                                                 |
 | `--max-parallelism` | `DD_TEST_OPTIMIZATION_RUNNER_MAX_PARALLELISM` | vCPU count | Maximum workers to use for the split.                                                                                 |
 | `--ci-node`         | `DD_TEST_OPTIMIZATION_RUNNER_CI_NODE`         | `-1` (off) | Restrict this run to the slice assigned to node **N** (0‑indexed). Also parallelizes within the node across its CPUs. |
@@ -202,6 +202,21 @@ matrix={"include":[{"ci_node_index":0},{"ci_node_index":1},{"ci_node_index":2}]}
 
 You can cat it to `$GITHUB_OUTPUT` to make it available for the test job.
 
+### Minitest support in non-rails projects
+
+We use `bundle exec rake test` command when we don't detect `rails` command to run tests.
+This command doesn't have a built in way to pass the list of files to execute, so we pass
+them as a space-separated list of files in `TEST_FILES` environment variable.
+
+You need to use this environment variable in your project to integrate your tests with
+`ddtest run`. Example when using `Rake::TestTask`:
+
+```ruby
+Rake::TestTask.new(:test) do |test|
+  test.test_files = ENV["TEST_FILES"] ? ENV["TEST_FILES"].split : ["test/**/*.rb"]
+end
+```
+
 ## Development
 
 ### Prerequisites

internal/constants/constants.go

@@ -11,5 +11,8 @@ var SkippablePercentageOutputPath = filepath.Join(PlanDirectory, "skippable-perc
 var ParallelRunnersOutputPath = filepath.Join(PlanDirectory, "parallel-runners.txt")
 var TestsSplitDir = filepath.Join(PlanDirectory, "tests-split")
 
+// Platform specific output file paths
+var RubyEnvOutputPath = filepath.Join(PlanDirectory, "ruby_env.json")
+
 // Executor constants
 const NodeIndexPlaceholder = "{{nodeIndex}}"

internal/framework/framework.go

@@ -1,9 +1,15 @@
 package framework
 
 import (
+	"encoding/json"
+	"log/slog"
+	"os"
+	"os/exec"
 	"path/filepath"
+	"time"
 
 	"github.com/DataDog/ddtest/internal/constants"
+	"github.com/DataDog/ddtest/internal/ext"
 	"github.com/DataDog/ddtest/internal/testoptimization"
 )
 
@@ -14,3 +20,62 @@ type Framework interface {
 	DiscoverTests() ([]testoptimization.Test, error)
 	RunTests(testFiles []string, envMap map[string]string) error
 }
+
+// cleanupDiscoveryFile removes the discovery file, ignoring "not exists" errors
+func cleanupDiscoveryFile(filePath string) {
+	if err := os.Remove(filePath); err != nil && !os.IsNotExist(err) {
+		slog.Warn("Warning: Failed to delete existing discovery file", "filePath", filePath, "error", err)
+	}
+}
+
+// applyEnvMap sets environment variables from envMap onto the command
+func applyEnvMap(cmd *exec.Cmd, envMap map[string]string) {
+	if len(envMap) > 0 {
+		cmd.Env = os.Environ()
+		for key, value := range envMap {
+			cmd.Env = append(cmd.Env, key+"="+value)
+		}
+	}
+}
+
+// executeDiscoveryCommand runs the discovery command and logs timing
+func executeDiscoveryCommand(executor ext.CommandExecutor, cmd *exec.Cmd, frameworkName string) ([]byte, error) {
+	slog.Debug("Starting test discovery...", "framework", frameworkName)
+	startTime := time.Now()
+
+	output, err := executor.CombinedOutput(cmd)
+	if err != nil {
+		slog.Error("Failed to run test discovery", "framework", frameworkName, "output", string(output))
+		return nil, err
+	}
+
+	duration := time.Since(startTime)
+	slog.Debug("Finished test discovery", "framework", frameworkName, "duration", duration)
+
+	return output, nil
+}
+
+// parseDiscoveryFile reads and parses the test discovery JSON file
+func parseDiscoveryFile(filePath string) ([]testoptimization.Test, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		slog.Error("Error opening JSON file", "error", err)
+		return nil, err
+	}
+	defer func() {
+		_ = file.Close()
+	}()
+
+	var tests []testoptimization.Test
+	decoder := json.NewDecoder(file)
+	for decoder.More() {
+		var test testoptimization.Test
+		if err := decoder.Decode(&test); err != nil {
+			slog.Error("Error parsing JSON", "error", err)
+			return nil, err
+		}
+		tests = append(tests, test)
+	}
+
+	return tests, nil
+}

internal/framework/minitest.go

@@ -0,0 +1,136 @@
+package framework
+
+import (
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/DataDog/ddtest/internal/ext"
+	"github.com/DataDog/ddtest/internal/testoptimization"
+)
+
+type Minitest struct {
+	executor ext.CommandExecutor
+}
+
+func NewMinitest() *Minitest {
+	return &Minitest{
+		executor: &ext.DefaultCommandExecutor{},
+	}
+}
+
+func (m *Minitest) Name() string {
+	return "minitest"
+}
+
+func (m *Minitest) DiscoverTests() ([]testoptimization.Test, error) {
+	cleanupDiscoveryFile(TestsDiscoveryFilePath)
+
+	cmd := m.createDiscoveryCommand()
+	_, err := executeDiscoveryCommand(m.executor, cmd, m.Name())
+	if err != nil {
+		return nil, err
+	}
+
+	tests, err := parseDiscoveryFile(TestsDiscoveryFilePath)
+	if err != nil {
+		return nil, err
+	}
+
+	slog.Debug("Parsed Minitest report", "tests", len(tests))
+	return tests, nil
+}
+
+func (m *Minitest) RunTests(testFiles []string, envMap map[string]string) error {
+	command, args, isRails := m.getMinitestCommand()
+
+	// Add test files if provided
+	if len(testFiles) > 0 {
+		if isRails {
+			// Rails test accepts files as command-line arguments
+			args = append(args, testFiles...)
+		} else {
+			// Rake test requires TEST_FILES environment variable
+			if envMap == nil {
+				envMap = make(map[string]string)
+			}
+			envMap["TEST_FILES"] = strings.Join(testFiles, " ")
+		}
+	}
+
+	// no-dd-sa:go-security/command-injection
+	cmd := exec.Command(command, args...)
+
+	applyEnvMap(cmd, envMap)
+
+	return m.executor.Run(cmd)
+}
+
+// isRailsApplication determines if the current project is a Rails application
+func (m *Minitest) isRailsApplication() bool {
+	// Check if rails gem is installed
+	// no-dd-sa:go-security/command-injection
+	cmd := exec.Command("bundle", "show", "rails")
+	output, err := m.executor.CombinedOutput(cmd)
+	if err != nil {
+		slog.Debug("Not a Rails application: bundle show rails failed", "output", string(output), "error", err)
+		return false
+	}
+
+	// Verify the output is a valid filepath that exists
+	railsPath := strings.TrimSpace(string(output))
+	if railsPath == "" {
+		slog.Debug("Not a Rails application: bundle show rails returned empty output")
+		return false
+	}
+	if _, err := os.Stat(railsPath); err != nil {
+		slog.Debug("Not a Rails application: rails gem path does not exist", "path", railsPath, "error", err)
+		return false
+	}
+
+	// Check if rails command works
+	// no-dd-sa:go-security/command-injection
+	cmd = exec.Command("bundle", "exec", "rails", "version")
+	output, err = m.executor.CombinedOutput(cmd)
+	if err != nil {
+		slog.Debug("Not a Rails application: bundle exec rails version failed", "output", string(output), "error", err)
+		return false
+	}
+
+	// Verify the output starts with "Rails <version>"
+	versionOutput := strings.TrimSpace(string(output))
+	if !strings.HasPrefix(versionOutput, "Rails ") {
+		slog.Debug("Not a Rails application: rails version output does not start with 'Rails '", "output", versionOutput)
+		return false
+	}
+
+	slog.Debug("Detected Rails application", "version_output", versionOutput)
+	return true
+}
+
+// getMinitestCommand determines whether to use rails test or rake test
+// Returns: command, args, isRails
+func (m *Minitest) getMinitestCommand() (string, []string, bool) {
+	isRails := m.isRailsApplication()
+	if isRails {
+		slog.Info("Found Ruby on Rails. Using bundle exec rails test for Minitest commands")
+		return "bundle", []string{"exec", "rails", "test"}, true
+	}
+
+	slog.Info("No Ruby on Rails found. Using bundle exec rake test for Minitest commands")
+	return "bundle", []string{"exec", "rake", "test"}, false
+}
+
+func (m *Minitest) createDiscoveryCommand() *exec.Cmd {
+	command, args, _ := m.getMinitestCommand()
+
+	// no-dd-sa:go-security/command-injection
+	cmd := exec.Command(command, args...)
+	cmd.Env = append(
+		os.Environ(),
+		"DD_TEST_OPTIMIZATION_DISCOVERY_ENABLED=1",
+		"DD_TEST_OPTIMIZATION_DISCOVERY_FILE="+TestsDiscoveryFilePath,
+	)
+	return cmd
+}