Merge 565f667 into 49e1d65

book.go

@@ -36,6 +36,7 @@ type book struct {
 	failFast     bool
 	skipIncluded bool
 	runMatch     *regexp.Regexp
+	runSample    int
 	runnerErrs   map[string]error
 	beforeFuncs  []func() error
 	afterFuncs   []func() error

operator.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math/rand"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -781,7 +782,7 @@ func Load(pathp string, opts ...Option) (*operators, error) {
 
 	for p, o := range om {
 		if !bk.runMatch.MatchString(p) {
-			o.Debugf(yellow("Skip %s because it does not match RUNN_RUN\n"), p)
+			o.Debugf(yellow("Skip %s because it does not match %s\n"), p, bk.runMatch.String())
 			continue
 		}
 		if contains(skipPaths, p) {
@@ -790,6 +791,9 @@ func Load(pathp string, opts ...Option) (*operators, error) {
 		}
 		ops.ops = append(ops.ops, o)
 	}
+	if bk.runSample > 0 {
+		ops.ops = sample(ops.ops, bk.runSample)
+	}
 	return ops, nil
 }
 
@@ -814,6 +818,20 @@ func contains(s []string, e string) bool {
 	return false
 }
 
+func sample(ops []*operator, num int) []*operator {
+	rand.Seed(time.Now().UnixNano())
+	var sample []*operator
+	n := make([]*operator, len(ops))
+	copy(n, ops)
+
+	for i := 0; i < num; i++ {
+		idx := rand.Intn(len(n))
+		sample = append(sample, n[idx])
+		n = append(n[:idx], n[idx+1:]...)
+	}
+	return sample
+}
+
 func pop(s map[string]interface{}) (string, interface{}, bool) {
 	for k, v := range s {
 		delete(s, k)

operator_test.go

@@ -214,22 +214,32 @@ func TestLoad(t *testing.T) {
 	tests := []struct {
 		path     string
 		RUNN_RUN string
+		sample   int
 		want     int
 	}{
 		{
-			"testdata/book/**/*", "",
+			"testdata/book/**/*",
+			"",
+			0,
 			func() int {
 				e, _ := os.ReadDir("testdata/book/")
 				return len(e)
 			}(),
 		},
-		{"testdata/book/**/*", "initdb", 1},
-		{"testdata/book/**/*", "nonexistent", 0},
+		{"testdata/book/**/*", "initdb", 0, 1},
+		{"testdata/book/**/*", "nonexistent", 0, 0},
+		{"testdata/book/**/*", "", 3, 3},
 	}
 	for _, tt := range tests {
-
 		t.Setenv("RUNN_RUN", tt.RUNN_RUN)
-		ops, err := Load(tt.path, Runner("req", "https://api.github.com"), Runner("db", "sqlite://path/to/test.db"))
+		opts := []Option{
+			Runner("req", "https://api.github.com"),
+			Runner("db", "sqlite://path/to/test.db"),
+		}
+		if tt.sample > 0 {
+			opts = append(opts, RunSample(tt.sample))
+		}
+		ops, err := Load(tt.path, opts...)
 		if err != nil {
 			t.Fatal(err)
 		}

option.go

@@ -276,6 +276,17 @@ func RunMatch(m string) Option {
 	}
 }
 
+// RunSample - Run the specified number of runbooks at random.
+func RunSample(n int) Option {
+	return func(bk *book) error {
+		if n <= 0 {
+			return fmt.Errorf("sample must be greater than 0: %d", n)
+		}
+		bk.runSample = n
+		return nil
+	}
+}
+
 func included(included bool) Option {
 	return func(bk *book) error {
 		bk.included = included

option_test.go

@@ -292,7 +292,7 @@ func TestOptionIntarval(t *testing.T) {
 	}
 }
 
-func TestRunMatch(t *testing.T) {
+func TestOptionRunMatch(t *testing.T) {
 	tests := []struct {
 		match string
 	}{
@@ -310,3 +310,31 @@ func TestRunMatch(t *testing.T) {
 		}
 	}
 }
+
+func TestOptionRunSample(t *testing.T) {
+	tests := []struct {
+		sample  int
+		wantErr bool
+	}{
+		{1, false},
+		{3, false},
+		{0, true},
+		{-1, true},
+	}
+	for _, tt := range tests {
+		bk := newBook()
+		opt := RunSample(tt.sample)
+		if err := opt(bk); err != nil {
+			if !tt.wantErr {
+				t.Errorf("got error %v", err)
+			}
+			continue
+		}
+		if tt.wantErr {
+			t.Error("want error")
+		}
+		if bk.runSample != tt.sample {
+			t.Errorf("got %v\nwant %v", bk.runSample, tt.sample)
+		}
+	}
+}