func (r *SpecBuilder) BuildSpecs(args []string, additionalArgs []string) {
r.commandFlags.computeNodes()
suites, _ := findSuites(args, r.commandFlags.Recurse, r.commandFlags.SkipPackage, false)
if len(suites) == 0 {
complainAndQuit("Found no test suites")
}
passed := true
for _, suite := range suites {
runner := testrunner.New(suite, 1, false, r.commandFlags.Race, r.commandFlags.Cover, r.commandFlags.Tags, nil)
fmt.Printf("Compiling %s...\n", suite.PackageName)
path, _ := filepath.Abs(filepath.Join(suite.Path, fmt.Sprintf("%s.test", suite.PackageName)))
err := runner.CompileTo(path)
if err != nil {
fmt.Println(err.Error())
passed = false
} else {
fmt.Printf(" compiled %s.test\n", suite.PackageName)
}
runner.CleanUp()
}
if passed {
os.Exit(0)
}
os.Exit(1)
}
func makeAndRegisterTestRunner(suite *testsuite.TestSuite) *testrunner.TestRunner {
runnerLock.Lock()
defer runnerLock.Unlock()
runner := testrunner.New(suite, numCPU, parallelStream, race, cover)
activeRunners = append(activeRunners, runner)
return runner
}
func (w *SpecWatcher) runnersForSuites(suites []testsuite.TestSuite, additionalArgs []string) []*testrunner.TestRunner {
runners := []*testrunner.TestRunner{}
for _, suite := range suites {
runners = append(runners, testrunner.New(suite, w.commandFlags.NumCPU, w.commandFlags.ParallelStream, w.commandFlags.Race, w.commandFlags.Cover, w.commandFlags.Tags, additionalArgs))
}
return runners
}
func (w *SpecWatcher) RunSuite(suite *testsuite.TestSuite, additionalArgs []string) {
runner := testrunner.New(suite, w.commandFlags.NumCPU, w.commandFlags.ParallelStream, w.commandFlags.Race, w.commandFlags.Cover, additionalArgs)
err := runner.Compile()
if err != nil {
fmt.Print(err.Error())
}
suitePassed := (err == nil) && runner.Run()
w.notifier.SendSuiteCompletionNotification(suite, suitePassed)
runner.CleanUp()
}
func (w *SpecWatcher) RunSuite(suite *testsuite.TestSuite, additionalArgs []string) {
w.UpdateSeed()
runner := testrunner.New(suite, w.commandFlags.NumCPU, w.commandFlags.ParallelStream, w.commandFlags.Race, w.commandFlags.Cover, w.commandFlags.Tags, additionalArgs)
err := runner.Compile()
if err != nil {
fmt.Print(err.Error())
}
runResult := testrunner.FailingRunResult()
if err == nil {
runResult = runner.Run()
}
w.notifier.SendSuiteCompletionNotification(suite, runResult.Passed)
runner.CleanUp()
}
func (r *SpecRunner) RunSpecs(args []string, additionalArgs []string) {
r.commandFlags.computeNodes()
r.notifier.VerifyNotificationsAreAvailable()
suites, skippedPackages := findSuites(args, r.commandFlags.Recurse, r.commandFlags.SkipPackage, true)
if len(skippedPackages) > 0 {
fmt.Println("Will skip:")
for _, skippedPackage := range skippedPackages {
fmt.Println(" " + skippedPackage)
}
}
if len(skippedPackages) > 0 && len(suites) == 0 {
fmt.Println("All tests skipped! Exiting...")
os.Exit(0)
}
if len(suites) == 0 {
complainAndQuit("Found no test suites")
}
r.ComputeSuccinctMode(len(suites))
t := time.Now()
runners := []*testrunner.TestRunner{}
for _, suite := range suites {
runners = append(runners, testrunner.New(suite, r.commandFlags.NumCPU, r.commandFlags.ParallelStream, r.commandFlags.Race, r.commandFlags.Cover, r.commandFlags.CoverPkg, r.commandFlags.Tags, r.commandFlags.GCFlags, additionalArgs))
}
numSuites := 0
runResult := testrunner.PassingRunResult()
if r.commandFlags.UntilItFails {
iteration := 0
for {
r.UpdateSeed()
randomizedRunners := r.randomizeOrder(runners)
runResult, numSuites = r.suiteRunner.RunSuites(randomizedRunners, r.commandFlags.NumCompilers, r.commandFlags.KeepGoing, nil)
iteration++
if r.interruptHandler.WasInterrupted() {
break
}
if runResult.Passed {
fmt.Printf("\nAll tests passed...\nWill keep running them until they fail.\nThis was attempt #%d\n%s\n", iteration, orcMessage(iteration))
} else {
fmt.Printf("\nTests failed on attempt #%d\n\n", iteration)
break
}
}
} else {
randomizedRunners := r.randomizeOrder(runners)
runResult, numSuites = r.suiteRunner.RunSuites(randomizedRunners, r.commandFlags.NumCompilers, r.commandFlags.KeepGoing, nil)
}
for _, runner := range runners {
runner.CleanUp()
}
fmt.Printf("\nGinkgo ran %d %s in %s\n", numSuites, pluralizedWord("suite", "suites", numSuites), time.Since(t))
if runResult.Passed {
if runResult.HasProgrammaticFocus {
fmt.Printf("Test Suite Passed\n")
fmt.Printf("Detected Programmatic Focus - setting exit status to %d\n", types.GINKGO_FOCUS_EXIT_CODE)
os.Exit(types.GINKGO_FOCUS_EXIT_CODE)
} else {
fmt.Printf("Test Suite Passed\n")
os.Exit(0)
}
} else {
fmt.Printf("Test Suite Failed\n")
os.Exit(1)
}
}
func (r *SpecRunner) RunSuites(suites []*testsuite.TestSuite, additionalArgs []string) (testrunner.RunResult, int) {
runResult := testrunner.PassingRunResult()
suiteCompilers := make([]*compiler, len(suites))
for i, suite := range suites {
runner := testrunner.New(suite, r.commandFlags.NumCPU, r.commandFlags.ParallelStream, r.commandFlags.Race, r.commandFlags.Cover, r.commandFlags.Tags, additionalArgs)
suiteCompilers[i] = &compiler{
runner: runner,
compilationError: make(chan error, 1),
}
}
compilerChannel := make(chan *compiler)
numCompilers := runtime.NumCPU()
for i := 0; i < numCompilers; i++ {
go func() {
for compiler := range compilerChannel {
compiler.compile()
}
}()
}
go func() {
for _, compiler := range suiteCompilers {
compilerChannel <- compiler
}
close(compilerChannel)
}()
numSuitesThatRan := 0
suitesThatFailed := []*testsuite.TestSuite{}
for i, suite := range suites {
if r.interruptHandler.WasInterrupted() {
break
}
compilationError := <-suiteCompilers[i].compilationError
if compilationError != nil {
fmt.Print(compilationError.Error())
}
numSuitesThatRan++
suiteRunResult := testrunner.FailingRunResult()
if compilationError == nil {
suiteRunResult = suiteCompilers[i].runner.Run()
}
r.notifier.SendSuiteCompletionNotification(suite, suiteRunResult.Passed)
runResult = runResult.Merge(suiteRunResult)
if !suiteRunResult.Passed {
suitesThatFailed = append(suitesThatFailed, suite)
if !r.commandFlags.KeepGoing {
break
}
}
if i < len(suites)-1 && !config.DefaultReporterConfig.Succinct {
fmt.Println("")
}
}
for i := range suites {
suiteCompilers[i].runner.CleanUp()
}
if r.commandFlags.KeepGoing && !runResult.Passed {
r.listFailedSuites(suitesThatFailed)
}
return runResult, numSuitesThatRan
}
return &s
}
var _ = Describe("TestRunner", func() {
It("should pass through go opts", func() {
//var opts map[string]interface{}
opts := map[string]interface{}{
"asmflags": strAddr("a"),
"pkgdir": strAddr("b"),
"gcflags": strAddr("c"),
"covermode": strAddr(""),
"coverpkg": strAddr(""),
"cover": boolAddr(false),
"blockprofilerate": intAddr(100),
}
tr := testrunner.New(testsuite.TestSuite{}, 1, false, opts, []string{})
args := tr.BuildArgs(".")
Ω(args).Should(Equal([]string{
"test",
"-c",
"-i",
"-o",
".",
"",
"-blockprofilerate=100",
"-asmflags=a",
"-pkgdir=b",
"-gcflags=c",
}))
})
func (r *SpecRunner) RunSuites(suites []*testsuite.TestSuite, additionalArgs []string) bool {
passed := true
suiteCompilers := make([]*compiler, len(suites))
for i, suite := range suites {
runner := testrunner.New(suite, r.commandFlags.NumCPU, r.commandFlags.ParallelStream, r.commandFlags.Race, r.commandFlags.Cover, additionalArgs)
suiteCompilers[i] = &compiler{
runner: runner,
compilationError: make(chan error, 1),
}
}
compilerChannel := make(chan *compiler)
numCompilers := runtime.NumCPU()
for i := 0; i < numCompilers; i++ {
go func() {
for compiler := range compilerChannel {
compiler.compile()
}
}()
}
go func() {
for _, compiler := range suiteCompilers {
compilerChannel <- compiler
}
close(compilerChannel)
}()
suitesThatFailed := []*testsuite.TestSuite{}
for i, suite := range suites {
if r.interruptHandler.WasInterrupted() {
break
}
compilationError := <-suiteCompilers[i].compilationError
if compilationError != nil {
fmt.Print(compilationError.Error())
}
suitePassed := (compilationError == nil) && suiteCompilers[i].runner.Run()
r.notifier.SendSuiteCompletionNotification(suite, suitePassed)
if !suitePassed {
passed = false
suitesThatFailed = append(suitesThatFailed, suite)
if !r.commandFlags.KeepGoing {
break
}
}
if i < len(suites)-1 && !config.DefaultReporterConfig.Succinct {
fmt.Println("")
}
}
for i := range suites {
suiteCompilers[i].runner.CleanUp()
}
if r.commandFlags.KeepGoing && !passed {
fmt.Println("There were failures detected in the following suites:")
for _, suite := range suitesThatFailed {
fmt.Printf("\t%s\n", suite.PackageName)
}
}
return passed
}