Add simple testing infrastructure

vendor/github.com/onsi/ginkgo/internal/spec/index_computer.go

@@ -0,0 +1,55 @@
+package spec
+
+func ParallelizedIndexRange(length int, parallelTotal int, parallelNode int) (startIndex int, count int) {
+	if length == 0 {
+		return 0, 0
+	}
+
+	// We have more nodes than tests. Trivial case.
+	if parallelTotal >= length {
+		if parallelNode > length {
+			return 0, 0
+		} else {
+			return parallelNode - 1, 1
+		}
+	}
+
+	// This is the minimum amount of tests that a node will be required to run
+	minTestsPerNode := length / parallelTotal
+
+	// This is the maximum amount of tests that a node will be required to run
+	// The algorithm guarantees that this would be equal to at least the minimum amount
+	// and at most one more
+	maxTestsPerNode := minTestsPerNode
+	if length%parallelTotal != 0 {
+		maxTestsPerNode++
+	}
+
+	// Number of nodes that will have to run the maximum amount of tests per node
+	numMaxLoadNodes := length % parallelTotal
+
+	// Number of nodes that precede the current node and will have to run the maximum amount of tests per node
+	var numPrecedingMaxLoadNodes int
+	if parallelNode > numMaxLoadNodes {
+		numPrecedingMaxLoadNodes = numMaxLoadNodes
+	} else {
+		numPrecedingMaxLoadNodes = parallelNode - 1
+	}
+
+	// Number of nodes that precede the current node and will have to run the minimum amount of tests per node
+	var numPrecedingMinLoadNodes int
+	if parallelNode <= numMaxLoadNodes {
+		numPrecedingMinLoadNodes = 0
+	} else {
+		numPrecedingMinLoadNodes = parallelNode - numMaxLoadNodes - 1
+	}
+
+	// Evaluate the test start index and number of tests to run
+	startIndex = numPrecedingMaxLoadNodes*maxTestsPerNode + numPrecedingMinLoadNodes*minTestsPerNode
+	if parallelNode > numMaxLoadNodes {
+		count = minTestsPerNode
+	} else {
+		count = maxTestsPerNode
+	}
+	return
+}

vendor/github.com/onsi/ginkgo/internal/spec/spec.go

@@ -0,0 +1,197 @@
+package spec
+
+import (
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/onsi/ginkgo/internal/containernode"
+	"github.com/onsi/ginkgo/internal/leafnodes"
+	"github.com/onsi/ginkgo/types"
+)
+
+type Spec struct {
+	subject          leafnodes.SubjectNode
+	focused          bool
+	announceProgress bool
+
+	containers []*containernode.ContainerNode
+
+	state   types.SpecState
+	runTime time.Duration
+	failure types.SpecFailure
+}
+
+func New(subject leafnodes.SubjectNode, containers []*containernode.ContainerNode, announceProgress bool) *Spec {
+	spec := &Spec{
+		subject:          subject,
+		containers:       containers,
+		focused:          subject.Flag() == types.FlagTypeFocused,
+		announceProgress: announceProgress,
+	}
+
+	spec.processFlag(subject.Flag())
+	for i := len(containers) - 1; i >= 0; i-- {
+		spec.processFlag(containers[i].Flag())
+	}
+
+	return spec
+}
+
+func (spec *Spec) processFlag(flag types.FlagType) {
+	if flag == types.FlagTypeFocused {
+		spec.focused = true
+	} else if flag == types.FlagTypePending {
+		spec.state = types.SpecStatePending
+	}
+}
+
+func (spec *Spec) Skip() {
+	spec.state = types.SpecStateSkipped
+}
+
+func (spec *Spec) Failed() bool {
+	return spec.state == types.SpecStateFailed || spec.state == types.SpecStatePanicked || spec.state == types.SpecStateTimedOut
+}
+
+func (spec *Spec) Passed() bool {
+	return spec.state == types.SpecStatePassed
+}
+
+func (spec *Spec) Pending() bool {
+	return spec.state == types.SpecStatePending
+}
+
+func (spec *Spec) Skipped() bool {
+	return spec.state == types.SpecStateSkipped
+}
+
+func (spec *Spec) Focused() bool {
+	return spec.focused
+}
+
+func (spec *Spec) IsMeasurement() bool {
+	return spec.subject.Type() == types.SpecComponentTypeMeasure
+}
+
+func (spec *Spec) Summary(suiteID string) *types.SpecSummary {
+	componentTexts := make([]string, len(spec.containers)+1)
+	componentCodeLocations := make([]types.CodeLocation, len(spec.containers)+1)
+
+	for i, container := range spec.containers {
+		componentTexts[i] = container.Text()
+		componentCodeLocations[i] = container.CodeLocation()
+	}
+
+	componentTexts[len(spec.containers)] = spec.subject.Text()
+	componentCodeLocations[len(spec.containers)] = spec.subject.CodeLocation()
+
+	return &types.SpecSummary{
+		IsMeasurement:          spec.IsMeasurement(),
+		NumberOfSamples:        spec.subject.Samples(),
+		ComponentTexts:         componentTexts,
+		ComponentCodeLocations: componentCodeLocations,
+		State:        spec.state,
+		RunTime:      spec.runTime,
+		Failure:      spec.failure,
+		Measurements: spec.measurementsReport(),
+		SuiteID:      suiteID,
+	}
+}
+
+func (spec *Spec) ConcatenatedString() string {
+	s := ""
+	for _, container := range spec.containers {
+		s += container.Text() + " "
+	}
+
+	return s + spec.subject.Text()
+}
+
+func (spec *Spec) Run(writer io.Writer) {
+	startTime := time.Now()
+	defer func() {
+		spec.runTime = time.Since(startTime)
+	}()
+
+	for sample := 0; sample < spec.subject.Samples(); sample++ {
+		spec.runSample(sample, writer)
+
+		if spec.state != types.SpecStatePassed {
+			return
+		}
+	}
+}
+
+func (spec *Spec) runSample(sample int, writer io.Writer) {
+	spec.state = types.SpecStatePassed
+	spec.failure = types.SpecFailure{}
+	innerMostContainerIndexToUnwind := -1
+
+	defer func() {
+		for i := innerMostContainerIndexToUnwind; i >= 0; i-- {
+			container := spec.containers[i]
+			for _, afterEach := range container.SetupNodesOfType(types.SpecComponentTypeAfterEach) {
+				spec.announceSetupNode(writer, "AfterEach", container, afterEach)
+				afterEachState, afterEachFailure := afterEach.Run()
+				if afterEachState != types.SpecStatePassed && spec.state == types.SpecStatePassed {
+					spec.state = afterEachState
+					spec.failure = afterEachFailure
+				}
+			}
+		}
+	}()
+
+	for i, container := range spec.containers {
+		innerMostContainerIndexToUnwind = i
+		for _, beforeEach := range container.SetupNodesOfType(types.SpecComponentTypeBeforeEach) {
+			spec.announceSetupNode(writer, "BeforeEach", container, beforeEach)
+			spec.state, spec.failure = beforeEach.Run()
+			if spec.state != types.SpecStatePassed {
+				return
+			}
+		}
+	}
+
+	for _, container := range spec.containers {
+		for _, justBeforeEach := range container.SetupNodesOfType(types.SpecComponentTypeJustBeforeEach) {
+			spec.announceSetupNode(writer, "JustBeforeEach", container, justBeforeEach)
+			spec.state, spec.failure = justBeforeEach.Run()
+			if spec.state != types.SpecStatePassed {
+				return
+			}
+		}
+	}
+
+	spec.announceSubject(writer, spec.subject)
+	spec.state, spec.failure = spec.subject.Run()
+}
+
+func (spec *Spec) announceSetupNode(writer io.Writer, nodeType string, container *containernode.ContainerNode, setupNode leafnodes.BasicNode) {
+	if spec.announceProgress {
+		s := fmt.Sprintf("[%s] %s\n  %s\n", nodeType, container.Text(), setupNode.CodeLocation().String())
+		writer.Write([]byte(s))
+	}
+}
+
+func (spec *Spec) announceSubject(writer io.Writer, subject leafnodes.SubjectNode) {
+	if spec.announceProgress {
+		nodeType := ""
+		switch subject.Type() {
+		case types.SpecComponentTypeIt:
+			nodeType = "It"
+		case types.SpecComponentTypeMeasure:
+			nodeType = "Measure"
+		}
+		s := fmt.Sprintf("[%s] %s\n  %s\n", nodeType, subject.Text(), subject.CodeLocation().String())
+		writer.Write([]byte(s))
+	}
+}
+
+func (spec *Spec) measurementsReport() map[string]*types.SpecMeasurement {
+	if !spec.IsMeasurement() || spec.Failed() {
+		return map[string]*types.SpecMeasurement{}
+	}
+
+	return spec.subject.(*leafnodes.MeasureNode).MeasurementsReport()
+}

vendor/github.com/onsi/ginkgo/internal/spec/specs.go

@@ -0,0 +1,122 @@
+package spec
+
+import (
+	"math/rand"
+	"regexp"
+	"sort"
+)
+
+type Specs struct {
+	specs                 []*Spec
+	numberOfOriginalSpecs int
+	hasProgrammaticFocus  bool
+}
+
+func NewSpecs(specs []*Spec) *Specs {
+	return &Specs{
+		specs: specs,
+		numberOfOriginalSpecs: len(specs),
+	}
+}
+
+func (e *Specs) Specs() []*Spec {
+	return e.specs
+}
+
+func (e *Specs) NumberOfOriginalSpecs() int {
+	return e.numberOfOriginalSpecs
+}
+
+func (e *Specs) HasProgrammaticFocus() bool {
+	return e.hasProgrammaticFocus
+}
+
+func (e *Specs) Shuffle(r *rand.Rand) {
+	sort.Sort(e)
+	permutation := r.Perm(len(e.specs))
+	shuffledSpecs := make([]*Spec, len(e.specs))
+	for i, j := range permutation {
+		shuffledSpecs[i] = e.specs[j]
+	}
+	e.specs = shuffledSpecs
+}
+
+func (e *Specs) ApplyFocus(description string, focusString string, skipString string) {
+	if focusString == "" && skipString == "" {
+		e.applyProgrammaticFocus()
+	} else {
+		e.applyRegExpFocus(description, focusString, skipString)
+	}
+}
+
+func (e *Specs) applyProgrammaticFocus() {
+	e.hasProgrammaticFocus = false
+	for _, spec := range e.specs {
+		if spec.Focused() && !spec.Pending() {
+			e.hasProgrammaticFocus = true
+			break
+		}
+	}
+
+	if e.hasProgrammaticFocus {
+		for _, spec := range e.specs {
+			if !spec.Focused() {
+				spec.Skip()
+			}
+		}
+	}
+}
+
+func (e *Specs) applyRegExpFocus(description string, focusString string, skipString string) {
+	for _, spec := range e.specs {
+		matchesFocus := true
+		matchesSkip := false
+
+		toMatch := []byte(description + " " + spec.ConcatenatedString())
+
+		if focusString != "" {
+			focusFilter := regexp.MustCompile(focusString)
+			matchesFocus = focusFilter.Match([]byte(toMatch))
+		}
+
+		if skipString != "" {
+			skipFilter := regexp.MustCompile(skipString)
+			matchesSkip = skipFilter.Match([]byte(toMatch))
+		}
+
+		if !matchesFocus || matchesSkip {
+			spec.Skip()
+		}
+	}
+}
+
+func (e *Specs) SkipMeasurements() {
+	for _, spec := range e.specs {
+		if spec.IsMeasurement() {
+			spec.Skip()
+		}
+	}
+}
+
+func (e *Specs) TrimForParallelization(total int, node int) {
+	startIndex, count := ParallelizedIndexRange(len(e.specs), total, node)
+	if count == 0 {
+		e.specs = make([]*Spec, 0)
+	} else {
+		e.specs = e.specs[startIndex : startIndex+count]
+	}
+}
+
+//sort.Interface
+
+func (e *Specs) Len() int {
+	return len(e.specs)
+}
+
+func (e *Specs) Less(i, j int) bool {
+	return e.specs[i].ConcatenatedString() < e.specs[j].ConcatenatedString()
+}
+
+func (e *Specs) Swap(i, j int) {
+	e.specs[i], e.specs[j] = e.specs[j], e.specs[i]
+}