commit verification with dolt_tests

go/cmd/dolt/cli/arg_parser_helpers.go

@@ -61,6 +61,7 @@ func CreateCommitArgParser(supportsBranchFlag bool) *argparser.ArgParser {
 	ap.SupportsFlag(UpperCaseAllFlag, "A", "Adds all tables and databases (including new tables) in the working set to the staged set.")
 	ap.SupportsFlag(AmendFlag, "", "Amend previous commit")
 	ap.SupportsOptionalString(SignFlag, "S", "key-id", "Sign the commit using GPG. If no key-id is provided the key-id is taken from 'user.signingkey' the in the configuration")
+	ap.SupportsFlag(SkipVerificationFlag, "", "Skip commit verification")
 	if supportsBranchFlag {
 		ap.SupportsString(BranchParam, "", "branch", "Commit to the specified branch instead of the current branch.")
 	}
@@ -96,6 +97,7 @@ func CreateMergeArgParser() *argparser.ArgParser {
 	ap.SupportsFlag(NoCommitFlag, "", "Perform the merge and stop just before creating a merge commit. Note this will not prevent a fast-forward merge; use the --no-ff arg together with the --no-commit arg to prevent both fast-forwards and merge commits.")
 	ap.SupportsFlag(NoEditFlag, "", "Use an auto-generated commit message when creating a merge commit. The default for interactive CLI sessions is to open an editor.")
 	ap.SupportsString(AuthorParam, "", "author", "Specify an explicit author using the standard A U Thor {{.LessThan}}author@example.com{{.GreaterThan}} format.")
+	ap.SupportsFlag(SkipVerificationFlag, "", "Skip commit verification before merge")
 
 	return ap
 }
@@ -116,6 +118,7 @@ func CreateRebaseArgParser() *argparser.ArgParser {
 	ap.SupportsFlag(AbortParam, "", "Abort an interactive rebase and return the working set to the pre-rebase state")
 	ap.SupportsFlag(ContinueFlag, "", "Continue an interactive rebase after adjusting the rebase plan")
 	ap.SupportsFlag(InteractiveFlag, "i", "Start an interactive rebase")
+	ap.SupportsFlag(SkipVerificationFlag, "", "Skip commit verification before rebase")
 	return ap
 }
 
@@ -190,6 +193,7 @@ func CreateCherryPickArgParser() *argparser.ArgParser {
 	ap.SupportsFlag(AllowEmptyFlag, "", "Allow empty commits to be cherry-picked. "+
 		"Note that use of this option only keeps commits that were initially empty. "+
 		"Commits which become empty, due to a previous commit, will cause cherry-pick to fail.")
+	ap.SupportsFlag(SkipVerificationFlag, "", "Skip commit verification before cherry-pick")
 	ap.TooManyArgsErrorFunc = func(receivedArgs []string) error {
 		return errors.New("cherry-picking multiple commits is not supported yet.")
 	}
@@ -227,6 +231,7 @@ func CreatePullArgParser() *argparser.ArgParser {
 	ap.SupportsString(UserFlag, "", "user", "User name to use when authenticating with the remote. Gets password from the environment variable {{.EmphasisLeft}}DOLT_REMOTE_PASSWORD{{.EmphasisRight}}.")
 	ap.SupportsFlag(PruneFlag, "p", "After fetching, remove any remote-tracking references that don't exist on the remote.")
 	ap.SupportsFlag(SilentFlag, "", "Suppress progress information.")
+	ap.SupportsFlag(SkipVerificationFlag, "", "Skip commit verification before merge")
 	return ap
 }
 

go/cmd/dolt/cli/flags.go

@@ -78,6 +78,7 @@ const (
 	SilentFlag           = "silent"
 	SingleBranchFlag     = "single-branch"
 	SkipEmptyFlag        = "skip-empty"
+	SkipVerificationFlag = "skip-verification"
 	SoftResetParam       = "soft"
 	SquashParam          = "squash"
 	StagedFlag           = "staged"

go/cmd/dolt/commands/commit.go

@@ -266,6 +266,10 @@ func constructParametrizedDoltCommitQuery(msg string, apr *argparser.ArgParseRes
 		writeToBuffer("--skip-empty")
 	}
 
+	if apr.Contains(cli.SkipVerificationFlag) {
+		writeToBuffer("--skip-verification")
+	}
+
 	cfgSign := cliCtx.Config().GetStringOrDefault("sqlserver.global.gpgsign", "")
 	if apr.Contains(cli.SignFlag) || strings.ToLower(cfgSign) == "true" {
 		writeToBuffer("--gpg-sign")

go/cmd/dolt/commands/merge.go

@@ -318,6 +318,10 @@ func constructInterpolatedDoltMergeQuery(apr *argparser.ArgParseResults, cliCtx
 		params = append(params, msg)
 	}
 
+	if apr.Contains(cli.SkipVerificationFlag) {
+		writeToBuffer("--skip-verification", false)
+	}
+
 	if !apr.Contains(cli.AbortParam) && !apr.Contains(cli.SquashParam) {
 		writeToBuffer("?", true)
 		params = append(params, apr.Arg(0))

go/libraries/doltcore/cherry_pick/cherry_pick.go

@@ -52,6 +52,9 @@ type CherryPickOptions struct {
 	// and Dolt cherry-pick implementations, the default action is to fail when an empty commit is specified. In Git
 	// and Dolt rebase implementations, the default action is to keep commits that start off as empty.
 	EmptyCommitHandling doltdb.EmptyCommitHandling
+
+	// SkipVerification controls whether test validation should be skipped before creating commits.
+	SkipVerification bool
 }
 
 // NewCherryPickOptions creates a new CherryPickOptions instance, filled out with default values for cherry-pick.
@@ -61,6 +64,7 @@ func NewCherryPickOptions() CherryPickOptions {
 		CommitMessage:              "",
 		CommitBecomesEmptyHandling: doltdb.ErrorOnEmptyCommit,
 		EmptyCommitHandling:        doltdb.ErrorOnEmptyCommit,
+		SkipVerification:           false,
 	}
 }
 
@@ -159,9 +163,10 @@ func CreateCommitStagedPropsFromCherryPickOptions(ctx *sql.Context, options Cher
 	}
 
 	commitProps := actions.CommitStagedProps{
-		Date:  originalMeta.Time(),
-		Name:  originalMeta.Name,
-		Email: originalMeta.Email,
+		Date:             originalMeta.Time(),
+		Name:             originalMeta.Name,
+		Email:            originalMeta.Email,
+		SkipVerification: options.SkipVerification,
 	}
 
 	if options.CommitMessage != "" {

go/libraries/doltcore/doltdb/workingset.go

@@ -75,6 +75,8 @@ type RebaseState struct {
 	// rebasingStarted is true once the rebase plan has been started to execute. Once rebasingStarted is true, the
 	// value in lastAttemptedStep has been initialized and is valid to read.
 	rebasingStarted bool
+	// skipVerification indicates whether test validation should be skipped during rebase operations.
+	skipVerification bool
 }
 
 // Branch returns the name of the branch being actively rebased. This is the branch that will be updated to point
@@ -120,6 +122,10 @@ func (rs RebaseState) WithRebasingStarted(rebasingStarted bool) *RebaseState {
 	return &rs
 }
 
+func (rs RebaseState) SkipVerification() bool {
+	return rs.skipVerification
+}
+
 type MergeState struct {
 	// the source commit
 	commit *Commit
@@ -322,13 +328,14 @@ func (ws WorkingSet) StartMerge(commit *Commit, commitSpecStr string) *WorkingSe
 // the branch that is being rebased, and |previousRoot| is root value of the branch being rebased. The HEAD and STAGED
 // root values of the branch being rebased must match |previousRoot|; WORKING may be a different root value, but ONLY
 // if it contains only ignored tables.
-func (ws WorkingSet) StartRebase(ctx *sql.Context, ontoCommit *Commit, branch string, previousRoot RootValue, commitBecomesEmptyHandling EmptyCommitHandling, emptyCommitHandling EmptyCommitHandling) (*WorkingSet, error) {
+func (ws WorkingSet) StartRebase(ctx *sql.Context, ontoCommit *Commit, branch string, previousRoot RootValue, commitBecomesEmptyHandling EmptyCommitHandling, emptyCommitHandling EmptyCommitHandling, skipVerification bool) (*WorkingSet, error) {
 	ws.rebaseState = &RebaseState{
 		ontoCommit:                 ontoCommit,
 		preRebaseWorking:           previousRoot,
 		branch:                     branch,
 		commitBecomesEmptyHandling: commitBecomesEmptyHandling,
 		emptyCommitHandling:        emptyCommitHandling,
+		skipVerification:           skipVerification,
 	}
 
 	ontoRoot, err := ontoCommit.GetRootValue(ctx)
@@ -549,6 +556,7 @@ func newWorkingSet(ctx context.Context, name string, vrw types.ValueReadWriter,
 			emptyCommitHandling:        EmptyCommitHandling(dsws.RebaseState.EmptyCommitHandling(ctx)),
 			lastAttemptedStep:          dsws.RebaseState.LastAttemptedStep(ctx),
 			rebasingStarted:            dsws.RebaseState.RebasingStarted(ctx),
+			skipVerification:           dsws.RebaseState.SkipVerification(ctx),
 		}
 	}
 
@@ -646,7 +654,7 @@ func (ws *WorkingSet) writeValues(ctx context.Context, db *DoltDB, meta *datas.W
 
 		rebaseState = datas.NewRebaseState(preRebaseWorking.TargetHash(), dCommit.Addr(), ws.rebaseState.branch,
 			uint8(ws.rebaseState.commitBecomesEmptyHandling), uint8(ws.rebaseState.emptyCommitHandling),
-			ws.rebaseState.lastAttemptedStep, ws.rebaseState.rebasingStarted)
+			ws.rebaseState.lastAttemptedStep, ws.rebaseState.rebasingStarted, ws.rebaseState.skipVerification)
 	}
 
 	return &datas.WorkingSetSpec{

go/libraries/doltcore/env/actions/commit.go

@@ -15,8 +15,12 @@
 package actions
 
 import (
+	"fmt"
+	"io"
+	"strings"
 	"time"
 
+	gms "github.com/dolthub/go-mysql-server"
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/diff"
@@ -25,14 +29,42 @@ import (
 )
 
 type CommitStagedProps struct {
-	Message    string
-	Date       time.Time
-	AllowEmpty bool
-	SkipEmpty  bool
-	Amend      bool
-	Force      bool
-	Name       string
-	Email      string
+	Message          string
+	Date             time.Time
+	AllowEmpty       bool
+	SkipEmpty        bool
+	Amend            bool
+	Force            bool
+	Name             string
+	Email            string
+	SkipVerification bool
+}
+
+const (
+	// System variable name, defined here to avoid circular imports
+	DoltCommitVerificationGroups = "dolt_commit_verification_groups"
+)
+
+// GetCommitRunTestGroups returns the test groups to run for commit operations
+// Returns empty slice if no tests should be run, ["*"] if all tests should be run,
+// or specific group names if only those groups should be run
+func GetCommitRunTestGroups() []string {
+	_, val, ok := sql.SystemVariables.GetGlobal(DoltCommitVerificationGroups)
+	if !ok {
+		return nil
+	}
+	if stringVal, ok := val.(string); ok && stringVal != "" {
+		if stringVal == "*" {
+			return []string{"*"}
+		}
+		// Split by comma and trim whitespace
+		groups := strings.Split(stringVal, ",")
+		for i, group := range groups {
+			groups[i] = strings.TrimSpace(group)
+		}
+		return groups
+	}
+	return nil
 }
 
 // GetCommitStaged returns a new pending commit with the roots and commit properties given.
@@ -114,10 +146,78 @@ func GetCommitStaged(
 		}
 	}
 
+	if !props.SkipVerification {
+		testGroups := GetCommitRunTestGroups()
+		if len(testGroups) > 0 {
+			err := runCommitVerification(ctx, testGroups)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
 	meta, err := datas.NewCommitMetaWithUserTS(props.Name, props.Email, props.Message, props.Date)
 	if err != nil {
 		return nil, err
 	}
 
 	return db.NewPendingCommit(ctx, roots, mergeParents, props.Amend, meta)
 }
+
+func runCommitVerification(ctx *sql.Context, testGroups []string) error {
+	type sessionInterface interface {
+		sql.Session
+		GenericProvider() sql.MutableDatabaseProvider
+	}
+
+	session, ok := ctx.Session.(sessionInterface)
+	if !ok {
+		return fmt.Errorf("session does not provide database provider interface")
+	}
+
+	provider := session.GenericProvider()
+	engine := gms.NewDefault(provider)
+
+	return runTestsUsingDtablefunctions(ctx, engine, testGroups)
+}
+
+// runTestsUsingDtablefunctions runs tests using the dtablefunctions package against the staged root
+func runTestsUsingDtablefunctions(ctx *sql.Context, engine *gms.Engine, testGroups []string) error {
+	if len(testGroups) == 0 {
+		return nil
+	}
+
+	var allFailures []string
+
+	for _, group := range testGroups {
+		query := fmt.Sprintf("SELECT * FROM dolt_test_run('%s')", group)
+		_, iter, _, err := engine.Query(ctx, query)
+		if err != nil {
+			return fmt.Errorf("failed to run dolt_test_run for group %s: %w", group, err)
+		}
+
+		for {
+			row, rErr := iter.Next(ctx)
+			if rErr == io.EOF {
+				break
+			}
+			if rErr != nil {
+				return fmt.Errorf("error reading test results: %w", rErr)
+			}
+
+			// Extract status (column 3)
+			status := fmt.Sprintf("%v", row[3])
+			if status != "PASS" {
+				testName := fmt.Sprintf("%v", row[0])
+				message := fmt.Sprintf("%v", row[4])
+				allFailures = append(allFailures, fmt.Sprintf("%s (%s)", testName, message))
+			}
+		}
+	}
+
+	if len(allFailures) > 0 {
+		return fmt.Errorf("commit verification failed: %s", strings.Join(allFailures, ", "))
+	}
+
+	return nil
+}