feat(formula): add onTest callback

cmd/llar/internal/make.go

@@ -68,13 +68,7 @@ func runMake(cmd *cobra.Command, args []string) error {
 		makeOutput = abs
 	}
 
-	matrix := formula.Matrix{
-		Require: map[string][]string{
-			"os":   {runtime.GOOS},
-			"arch": {runtime.GOARCH},
-		},
-	}
-	matrixStr := matrix.Combinations()[0]
+	matrixStr := hostMatrixCombo()
 
 	// Set up remote formula store (always needed for deps)
 	remoteStore, err := newRemoteStore()
@@ -83,7 +77,7 @@ func runMake(cmd *cobra.Command, args []string) error {
 	}
 
 	if !isLocal {
-		return buildModule(ctx, remoteStore, pattern, version, matrixStr)
+		return buildModule(ctx, remoteStore, pattern, version, matrixStr, false)
 	}
 
 	// Resolve local pattern
@@ -109,15 +103,30 @@ func runMake(cmd *cobra.Command, args []string) error {
 		if ver == "" {
 			ver = version // global @version from arg
 		}
-		if err := buildModule(ctx, store, m.Path, ver, matrixStr); err != nil {
+		if err := buildModule(ctx, store, m.Path, ver, matrixStr, false); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-// buildModule loads and builds a single module.
-func buildModule(ctx context.Context, store repo.Store, modPath, version, matrixStr string) error {
+// hostMatrixCombo returns the matrix combination for the current host
+// (os+arch). It is used by both `llar make` and `llar test` to select
+// the default build variant when the user does not specify one.
+func hostMatrixCombo() string {
+	matrix := formula.Matrix{
+		Require: map[string][]string{
+			"os":   {runtime.GOOS},
+			"arch": {runtime.GOARCH},
+		},
+	}
+	return matrix.Combinations()[0]
+}
+
+// buildModule loads and builds a single module. When runTest is true, the
+// builder also runs each module's onTest hook after onBuild succeeds and
+// bypasses the build cache.
+func buildModule(ctx context.Context, store repo.Store, modPath, version, matrixStr string, runTest bool) error {
 	mods, err := modules.Load(ctx, module.Version{Path: modPath, Version: version}, modules.Options{
 		FormulaStore: store,
 	})
@@ -151,6 +160,7 @@ func buildModule(ctx context.Context, store repo.Store, modPath, version, matrix
 	buildOpts := build.Options{
 		Store:     store,
 		MatrixStr: matrixStr,
+		RunTest:   runTest,
 	}
 	if makeOutput != "" {
 		tmpDir, err := os.MkdirTemp("", "llar-make-*")

cmd/llar/internal/make_test.go

@@ -702,7 +702,7 @@ func TestBuildModule_SilentSuccess(t *testing.T) {
 	r, w, _ := os.Pipe()
 	os.Stdout = w
 
-	err := buildModule(context.Background(), store, "test/liba", "1.0.0", matrixStr)
+	err := buildModule(context.Background(), store, "test/liba", "1.0.0", matrixStr, false)
 
 	w.Close()
 	os.Stdout = old

cmd/llar/internal/test.go

@@ -0,0 +1,84 @@
+package internal
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/goplus/llar/internal/formula/repo"
+	"github.com/goplus/llar/internal/modules/modlocal"
+	"github.com/spf13/cobra"
+)
+
+var testVerbose bool
+
+var testCmd = &cobra.Command{
+	Use:   "test [module@version]",
+	Short: "Build a module and run its onTest hook",
+	Long: `Test builds a module the same way as 'llar make', then executes
+the module's onTest callback on the freshly-built artifacts.
+
+The build cache is bypassed for test runs so onTest always executes against
+a fresh build. Test runs do not update the cache either, so normal builds
+remain cacheable.`,
+	Args: cobra.ExactArgs(1),
+	RunE: runTest,
+}
+
+func init() {
+	testCmd.Flags().BoolVarP(&testVerbose, "verbose", "v", false, "Enable verbose build/test output")
+	rootCmd.AddCommand(testCmd)
+}
+
+func runTest(cmd *cobra.Command, args []string) error {
+	pattern, version, isLocal, err := parseModuleArg(args[0])
+	if err != nil {
+		return err
+	}
+
+	ctx := context.Background()
+
+	// Reuse the verbose-redirection logic in buildModule by toggling the
+	// shared makeVerbose flag for the duration of the test run.
+	savedVerbose := makeVerbose
+	makeVerbose = testVerbose
+	defer func() { makeVerbose = savedVerbose }()
+
+	matrixStr := hostMatrixCombo()
+
+	remoteStore, err := newRemoteStore()
+	if err != nil {
+		return err
+	}
+
+	if !isLocal {
+		return buildModule(ctx, remoteStore, pattern, version, matrixStr, true)
+	}
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	localMods, err := modlocal.Resolve(cwd, pattern)
+	if err != nil {
+		return err
+	}
+
+	locals := make(map[string]string, len(localMods))
+	for _, m := range localMods {
+		locals[m.Path] = m.Dir
+	}
+	store := repo.NewOverlayStore(remoteStore, locals)
+
+	for _, m := range localMods {
+		ver := m.Version
+		if ver == "" {
+			ver = version
+		}
+		if err := buildModule(ctx, store, m.Path, ver, matrixStr, true); err != nil {
+			return err
+		}
+	}
+	return nil
+}

formula/classfile.go

@@ -22,6 +22,7 @@ type ModuleF struct {
 
 	fOnRequire func(proj *Project, deps *ModuleDeps)
 	fOnBuild   func(ctx *Context, proj *Project, out *BuildResult)
+	fOnTest    func(ctx *Context, proj *Project, out *BuildResult)
 
 	modPath    string
 	modFromVer string
@@ -198,6 +199,13 @@ func (p *ModuleF) OnBuild(f func(ctx *Context, proj *Project, out *BuildResult))
 	p.fOnBuild = f
 }
 
+// OnTest event is used to run post-build verification for a project.
+// It fires after OnBuild has completed successfully, reusing the same build
+// context so tests can locate built artifacts via ctx.OutputDir.
+func (p *ModuleF) OnTest(f func(ctx *Context, proj *Project, out *BuildResult)) {
+	p.fOnTest = f
+}
+
 // -----------------------------------------------------------------------------
 
 // Gopt_ModuleF_Main is main entry of this classfile.

internal/build/build.go

@@ -20,8 +20,9 @@ import (
 type Builder struct {
 	store        repo.Store
 	matrix       string
+	runTest      bool
 	workspaceDir string
-	newRepo func(repoPath string) (vcs.Repo, error) // defaults to vcs.NewRepo
+	newRepo      func(repoPath string) (vcs.Repo, error) // defaults to vcs.NewRepo
 }
 
 type Result struct {
@@ -32,6 +33,7 @@ type Result struct {
 type Options struct {
 	Store        repo.Store
 	MatrixStr    string
+	RunTest      bool
 	WorkspaceDir string
 }
 
@@ -61,6 +63,7 @@ func NewBuilder(opts Options) (*Builder, error) {
 	return &Builder{
 		store:        opts.Store,
 		matrix:       opts.MatrixStr,
+		runTest:      opts.RunTest,
 		workspaceDir: workspaceDir,
 		newRepo:      vcs.NewRepo,
 	}, nil
@@ -187,12 +190,16 @@ func (b *Builder) Build(ctx context.Context, targets []*modules.Module) ([]Resul
 		}
 		defer unlock()
 
-		// Check cache
-		cache, err := b.loadCache(mod.Path)
-		if err == nil {
-			if entry, ok := cache.get(mod.Version, b.matrix); ok {
-				dir, _ := b.installDir(mod.Path, mod.Version)
-				return Result{Metadata: entry.Metadata, OutputDir: dir}, nil
+		// When runTest is requested, bypass the build cache so onTest
+		// cannot be skipped by a cached build hit.
+		var cache *buildCache
+		if !b.runTest {
+			cache, err = b.loadCache(mod.Path)
+			if err == nil {
+				if entry, ok := cache.get(mod.Version, b.matrix); ok {
+					dir, _ := b.installDir(mod.Path, mod.Version)
+					return Result{Metadata: entry.Metadata, OutputDir: dir}, nil
+				}
 			}
 		}
 
@@ -246,16 +253,29 @@ func (b *Builder) Build(ctx context.Context, targets []*modules.Module) ([]Resul
 			return Result{}, errors.Join(out.Errs()...)
 		}
 
-		// Save to cache
-		if cache == nil {
-			cache = &buildCache{}
+		// Run onTest inline right after onBuild succeeds, reusing the
+		// same build context so tests see the just-built artifacts.
+		if b.runTest && mod.OnTest != nil {
+			var testOut classfile.BuildResult
+			mod.OnTest(buildContext, project, &testOut)
+			if len(testOut.Errs()) > 0 {
+				return Result{}, fmt.Errorf("onTest failed for %s@%s: %w", mod.Path, mod.Version, errors.Join(testOut.Errs()...))
+			}
 		}
-		cache.set(mod.Version, b.matrix, &buildEntry{
-			Metadata:  out.Metadata(),
-			BuildTime: time.Now(),
-		})
-		if err := b.saveCache(mod.Path, cache); err != nil {
-			return Result{}, err
+
+		// Save to cache (skipped when runTest to keep the cache stable
+		// for normal, non-test builds).
+		if !b.runTest {
+			if cache == nil {
+				cache = &buildCache{}
+			}
+			cache.set(mod.Version, b.matrix, &buildEntry{
+				Metadata:  out.Metadata(),
+				BuildTime: time.Now(),
+			})
+			if err := b.saveCache(mod.Path, cache); err != nil {
+				return Result{}, err
+			}
 		}
 
 		return Result{Metadata: out.Metadata(), OutputDir: installDir}, nil