484 lines
18 KiB
Go
484 lines
18 KiB
Go
package integration_test
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"regexp"
|
|
"runtime"
|
|
"strings"
|
|
|
|
. "github.com/onsi/ginkgo"
|
|
"github.com/onsi/ginkgo/types"
|
|
. "github.com/onsi/gomega"
|
|
"github.com/onsi/gomega/gbytes"
|
|
"github.com/onsi/gomega/gexec"
|
|
)
|
|
|
|
var _ = Describe("Running Specs", func() {
|
|
var pathToTest string
|
|
|
|
isWindows := (runtime.GOOS == "windows")
|
|
denoter := "•"
|
|
|
|
if isWindows {
|
|
denoter = "+"
|
|
}
|
|
|
|
Context("when pointed at the current directory", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)
|
|
})
|
|
|
|
It("should run the tests in the working directory", func() {
|
|
session := startGinkgo(pathToTest, "--noColor")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring(strings.Repeat(denoter, 4)))
|
|
Ω(output).Should(ContainSubstring("SUCCESS! -- 4 Passed"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
|
|
Context("when passed an explicit package to run", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)
|
|
})
|
|
|
|
It("should run the ginkgo style tests", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", pathToTest)
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring(strings.Repeat(denoter, 4)))
|
|
Ω(output).Should(ContainSubstring("SUCCESS! -- 4 Passed"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
|
|
Context("when passed a number of packages to run", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
otherPathToTest := tmpPath("other")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)
|
|
copyIn(fixturePath("more_ginkgo_tests"), otherPathToTest, false)
|
|
})
|
|
|
|
It("should run the ginkgo style tests", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--succinct=false", "ginkgo", "./other")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring("Running Suite: More_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
|
|
Context("when passed a number of packages to run, some of which have focused tests", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
otherPathToTest := tmpPath("other")
|
|
focusedPathToTest := tmpPath("focused")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)
|
|
copyIn(fixturePath("more_ginkgo_tests"), otherPathToTest, false)
|
|
copyIn(fixturePath("focused_fixture"), focusedPathToTest, false)
|
|
})
|
|
|
|
It("should exit with a status code of 2 and explain why", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--succinct=false", "-r")
|
|
Eventually(session).Should(gexec.Exit(types.GINKGO_FOCUS_EXIT_CODE))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring("Running Suite: More_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
Ω(output).Should(ContainSubstring("Detected Programmatic Focus - setting exit status to %d", types.GINKGO_FOCUS_EXIT_CODE))
|
|
})
|
|
|
|
Context("when the GINKGO_EDITOR_INTEGRATION environment variable is set", func() {
|
|
BeforeEach(func() {
|
|
os.Setenv("GINKGO_EDITOR_INTEGRATION", "true")
|
|
})
|
|
AfterEach(func() {
|
|
os.Setenv("GINKGO_EDITOR_INTEGRATION", "")
|
|
})
|
|
It("should exit with a status code of 0 to allow a coverage file to be generated", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--succinct=false", "-r")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring("Running Suite: More_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
})
|
|
|
|
Context("when told to skipPackages", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
otherPathToTest := tmpPath("other")
|
|
focusedPathToTest := tmpPath("focused")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)
|
|
copyIn(fixturePath("more_ginkgo_tests"), otherPathToTest, false)
|
|
copyIn(fixturePath("focused_fixture"), focusedPathToTest, false)
|
|
})
|
|
|
|
It("should skip packages that match the list", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused", "-r")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("Passing_ginkgo_tests Suite"))
|
|
Ω(output).ShouldNot(ContainSubstring("More_ginkgo_tests Suite"))
|
|
Ω(output).ShouldNot(ContainSubstring("Focused_fixture Suite"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
|
|
Context("when all packages are skipped", func() {
|
|
It("should not run anything, but still exit 0", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused,ginkgo", "-r")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("All tests skipped!"))
|
|
Ω(output).ShouldNot(ContainSubstring("Passing_ginkgo_tests Suite"))
|
|
Ω(output).ShouldNot(ContainSubstring("More_ginkgo_tests Suite"))
|
|
Ω(output).ShouldNot(ContainSubstring("Focused_fixture Suite"))
|
|
Ω(output).ShouldNot(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
})
|
|
|
|
Context("when there are no tests to run", func() {
|
|
It("should exit 1", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused", "-r")
|
|
Eventually(session).Should(gexec.Exit(1))
|
|
output := string(session.Err.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("Found no test suites"))
|
|
})
|
|
})
|
|
|
|
Context("when there are test files but `go test` reports there are no tests to run", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
copyIn(fixturePath("no_test_fn"), pathToTest, false)
|
|
})
|
|
|
|
It("suggests running ginkgo bootstrap", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused", "-r")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Err.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring(`Found no test suites, did you forget to run "ginkgo bootstrap"?`))
|
|
})
|
|
|
|
It("fails if told to requireSuite", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused", "-r", "-requireSuite")
|
|
Eventually(session).Should(gexec.Exit(1))
|
|
output := string(session.Err.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring(`Found no test suites, did you forget to run "ginkgo bootstrap"?`))
|
|
})
|
|
})
|
|
|
|
Context("when told to randomizeSuites", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
otherPathToTest := tmpPath("other")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)
|
|
copyIn(fixturePath("more_ginkgo_tests"), otherPathToTest, false)
|
|
})
|
|
|
|
It("should skip packages that match the regexp", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "--randomizeSuites", "-r", "--seed=2")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
|
|
Ω(session).Should(gbytes.Say("More_ginkgo_tests Suite"))
|
|
Ω(session).Should(gbytes.Say("Passing_ginkgo_tests Suite"))
|
|
|
|
session = startGinkgo(tmpDir, "--noColor", "--randomizeSuites", "-r", "--seed=3")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
|
|
Ω(session).Should(gbytes.Say("Passing_ginkgo_tests Suite"))
|
|
Ω(session).Should(gbytes.Say("More_ginkgo_tests Suite"))
|
|
})
|
|
})
|
|
|
|
Context("when pointed at a package with xunit style tests", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("xunit")
|
|
copyIn(fixturePath("xunit_tests"), pathToTest, false)
|
|
})
|
|
|
|
It("should run the xunit style tests", func() {
|
|
session := startGinkgo(pathToTest)
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("--- PASS: TestAlwaysTrue"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
|
|
Context("when pointed at a package with no tests", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("no_tests")
|
|
copyIn(fixturePath("no_tests"), pathToTest, false)
|
|
})
|
|
|
|
It("should fail", func() {
|
|
session := startGinkgo(pathToTest, "--noColor")
|
|
Eventually(session).Should(gexec.Exit(1))
|
|
|
|
Ω(session.Err.Contents()).Should(ContainSubstring("Found no test suites"))
|
|
})
|
|
})
|
|
|
|
Context("when pointed at a package that fails to compile", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("does_not_compile")
|
|
copyIn(fixturePath("does_not_compile"), pathToTest, false)
|
|
})
|
|
|
|
It("should fail", func() {
|
|
session := startGinkgo(pathToTest, "--noColor")
|
|
Eventually(session).Should(gexec.Exit(1))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring("Failed to compile"))
|
|
})
|
|
})
|
|
|
|
Context("when running in parallel", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)
|
|
})
|
|
|
|
Context("with a specific number of -nodes", func() {
|
|
It("should use the specified number of nodes", func() {
|
|
session := startGinkgo(pathToTest, "--noColor", "-succinct", "-nodes=2")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4 specs - 2 nodes [%s]{4} SUCCESS! \d+(\.\d+)?[muµ]s`, regexp.QuoteMeta(denoter)))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
|
|
Context("with -p", func() {
|
|
It("it should autocompute the number of nodes", func() {
|
|
session := startGinkgo(pathToTest, "--noColor", "-succinct", "-p")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
nodes := runtime.NumCPU()
|
|
if nodes == 1 {
|
|
Skip("Can't test parallel testings with 1 CPU")
|
|
}
|
|
if nodes > 4 {
|
|
nodes = nodes - 1
|
|
}
|
|
Ω(output).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4 specs - %d nodes [%s]{4} SUCCESS! \d+(\.\d+)?[muµ]?s`, nodes, regexp.QuoteMeta(denoter)))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
})
|
|
|
|
Context("when running in parallel with -debug", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
copyIn(fixturePath("debug_parallel_fixture"), pathToTest, false)
|
|
})
|
|
|
|
Context("without -v", func() {
|
|
It("should emit node output to files on disk", func() {
|
|
session := startGinkgo(pathToTest, "--nodes=2", "--debug")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
|
|
f0, err := ioutil.ReadFile(pathToTest + "/ginkgo-node-1.log")
|
|
Ω(err).ShouldNot(HaveOccurred())
|
|
f1, err := ioutil.ReadFile(pathToTest + "/ginkgo-node-2.log")
|
|
Ω(err).ShouldNot(HaveOccurred())
|
|
content := string(append(f0, f1...))
|
|
|
|
for i := 0; i < 10; i += 1 {
|
|
Ω(content).Should(ContainSubstring("StdOut %d\n", i))
|
|
Ω(content).Should(ContainSubstring("GinkgoWriter %d\n", i))
|
|
}
|
|
})
|
|
})
|
|
|
|
Context("without -v", func() {
|
|
It("should emit node output to files on disk, without duplicating the GinkgoWriter output", func() {
|
|
session := startGinkgo(pathToTest, "--nodes=2", "--debug", "-v")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
|
|
f0, err := ioutil.ReadFile(pathToTest + "/ginkgo-node-1.log")
|
|
Ω(err).ShouldNot(HaveOccurred())
|
|
f1, err := ioutil.ReadFile(pathToTest + "/ginkgo-node-2.log")
|
|
Ω(err).ShouldNot(HaveOccurred())
|
|
content := string(append(f0, f1...))
|
|
|
|
out := strings.Split(content, "GinkgoWriter 2")
|
|
Ω(out).Should(HaveLen(2))
|
|
})
|
|
})
|
|
})
|
|
|
|
Context("when streaming in parallel", func() {
|
|
BeforeEach(func() {
|
|
pathToTest = tmpPath("ginkgo")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)
|
|
})
|
|
|
|
It("should print output in realtime", func() {
|
|
session := startGinkgo(pathToTest, "--noColor", "-stream", "-nodes=2")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
Ω(output).Should(ContainSubstring(`[1] Parallel test node 1/2.`))
|
|
Ω(output).Should(ContainSubstring(`[2] Parallel test node 2/2.`))
|
|
Ω(output).Should(ContainSubstring(`[1] SUCCESS!`))
|
|
Ω(output).Should(ContainSubstring(`[2] SUCCESS!`))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
|
|
Context("when running recursively", func() {
|
|
BeforeEach(func() {
|
|
passingTest := tmpPath("A")
|
|
otherPassingTest := tmpPath("E")
|
|
copyIn(fixturePath("passing_ginkgo_tests"), passingTest, false)
|
|
copyIn(fixturePath("more_ginkgo_tests"), otherPassingTest, false)
|
|
})
|
|
|
|
Context("when all the tests pass", func() {
|
|
Context("with the -r flag", func() {
|
|
It("should run all the tests (in succinct mode) and succeed", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "-r", ".")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
outputLines := strings.Split(output, "\n")
|
|
Ω(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muµ]s PASS`, regexp.QuoteMeta(denoter)))
|
|
Ω(outputLines[1]).Should(MatchRegexp(`\[\d+\] More_ginkgo_tests Suite - 2/2 specs [%s]{2} SUCCESS! \d+(\.\d+)?[muµ]s PASS`, regexp.QuoteMeta(denoter)))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
Context("with a trailing /...", func() {
|
|
It("should run all the tests (in succinct mode) and succeed", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "./...")
|
|
Eventually(session).Should(gexec.Exit(0))
|
|
output := string(session.Out.Contents())
|
|
|
|
outputLines := strings.Split(output, "\n")
|
|
Ω(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muµ]s PASS`, regexp.QuoteMeta(denoter)))
|
|
Ω(outputLines[1]).Should(MatchRegexp(`\[\d+\] More_ginkgo_tests Suite - 2/2 specs [%s]{2} SUCCESS! \d+(\.\d+)?[muµ]s PASS`, regexp.QuoteMeta(denoter)))
|
|
Ω(output).Should(ContainSubstring("Test Suite Passed"))
|
|
})
|
|
})
|
|
})
|
|
|
|
Context("when one of the packages has a failing tests", func() {
|
|
BeforeEach(func() {
|
|
failingTest := tmpPath("C")
|
|
copyIn(fixturePath("failing_ginkgo_tests"), failingTest, false)
|
|
})
|
|
|
|
It("should fail and stop running tests", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "-r")
|
|
Eventually(session).Should(gexec.Exit(1))
|
|
output := string(session.Out.Contents())
|
|
|
|
outputLines := strings.Split(output, "\n")
|
|
Ω(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muµ]s PASS`, regexp.QuoteMeta(denoter)))
|
|
Ω(outputLines[1]).Should(MatchRegexp(`\[\d+\] Failing_ginkgo_tests Suite - 2/2 specs`))
|
|
Ω(output).Should(ContainSubstring(fmt.Sprintf("%s Failure", denoter)))
|
|
Ω(output).ShouldNot(ContainSubstring("More_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Failed"))
|
|
|
|
Ω(output).Should(ContainSubstring("Summarizing 1 Failure:"))
|
|
Ω(output).Should(ContainSubstring("[Fail] FailingGinkgoTests [It] should fail"))
|
|
})
|
|
})
|
|
|
|
Context("when one of the packages fails to compile", func() {
|
|
BeforeEach(func() {
|
|
doesNotCompileTest := tmpPath("C")
|
|
copyIn(fixturePath("does_not_compile"), doesNotCompileTest, false)
|
|
})
|
|
|
|
It("should fail and stop running tests", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "-r")
|
|
Eventually(session).Should(gexec.Exit(1))
|
|
output := string(session.Out.Contents())
|
|
|
|
outputLines := strings.Split(output, "\n")
|
|
Ω(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muµ]s PASS`, regexp.QuoteMeta(denoter)))
|
|
Ω(outputLines[1]).Should(ContainSubstring("Failed to compile C:"))
|
|
Ω(output).ShouldNot(ContainSubstring("More_ginkgo_tests Suite"))
|
|
Ω(output).Should(ContainSubstring("Test Suite Failed"))
|
|
})
|
|
})
|
|
|
|
Context("when either is the case, but the keepGoing flag is set", func() {
|
|
BeforeEach(func() {
|
|
doesNotCompileTest := tmpPath("B")
|
|
copyIn(fixturePath("does_not_compile"), doesNotCompileTest, false)
|
|
|
|
failingTest := tmpPath("C")
|
|
copyIn(fixturePath("failing_ginkgo_tests"), failingTest, false)
|
|
})
|
|
|
|
It("should soldier on", func() {
|
|
session := startGinkgo(tmpDir, "--noColor", "-r", "-keepGoing")
|
|
Eventually(session).Should(gexec.Exit(1))
|
|
output := string(session.Out.Contents())
|
|
|
|
outputLines := strings.Split(output, "\n")
|
|
Ω(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muµ]s PASS`, regexp.QuoteMeta(denoter)))
|
|
Ω(outputLines[1]).Should(ContainSubstring("Failed to compile B:"))
|
|
Ω(output).Should(MatchRegexp(`\[\d+\] Failing_ginkgo_tests Suite - 2/2 specs`))
|
|
Ω(output).Should(ContainSubstring(fmt.Sprintf("%s Failure", denoter)))
|
|
Ω(output).Should(MatchRegexp(`\[\d+\] More_ginkgo_tests Suite - 2/2 specs [%s]{2} SUCCESS! \d+(\.\d+)?[muµ]s PASS`, regexp.QuoteMeta(denoter)))
|
|
Ω(output).Should(ContainSubstring("Test Suite Failed"))
|
|
})
|
|
})
|
|
})
|
|
|
|
Context("when told to keep going --untilItFails", func() {
|
|
BeforeEach(func() {
|
|
copyIn(fixturePath("eventually_failing"), tmpDir, false)
|
|
})
|
|
|
|
It("should keep rerunning the tests, until a failure occurs", func() {
|
|
session := startGinkgo(tmpDir, "--untilItFails", "--noColor")
|
|
Eventually(session).Should(gexec.Exit(1))
|
|
Ω(session).Should(gbytes.Say("This was attempt #1"))
|
|
Ω(session).Should(gbytes.Say("This was attempt #2"))
|
|
Ω(session).Should(gbytes.Say("Tests failed on attempt #3"))
|
|
|
|
//it should change the random seed between each test
|
|
lines := strings.Split(string(session.Out.Contents()), "\n")
|
|
randomSeeds := []string{}
|
|
for _, line := range lines {
|
|
if strings.Contains(line, "Random Seed:") {
|
|
randomSeeds = append(randomSeeds, strings.Split(line, ": ")[1])
|
|
}
|
|
}
|
|
Ω(randomSeeds[0]).ShouldNot(Equal(randomSeeds[1]))
|
|
Ω(randomSeeds[1]).ShouldNot(Equal(randomSeeds[2]))
|
|
Ω(randomSeeds[0]).ShouldNot(Equal(randomSeeds[2]))
|
|
})
|
|
})
|
|
})
|