Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use It method of ginkgo Package

Best Ginkgo code snippet using ginkgo.It

ginkgo_dsl.go

Source:ginkgo_dsl.go

...53//The interface by which Ginkgo receives *testing.T54type GinkgoTestingT interface {55	Fail()56}57//GinkgoRandomSeed returns the seed used to randomize spec execution order.  It is58//useful for seeding your own pseudorandom number generators (PRNGs) to ensure59//consistent executions from run to run, where your tests contain variability (for60//example, when selecting random test data).61func GinkgoRandomSeed() int64 {62	return config.GinkgoConfig.RandomSeed63}64//GinkgoParallelNode returns the parallel node number for the current ginkgo process65//The node number is 1-indexed66func GinkgoParallelNode() int {67	return config.GinkgoConfig.ParallelNode68}69//Some matcher libraries or legacy codebases require a *testing.T70//GinkgoT implements an interface analogous to *testing.T and can be used if71//the library in question accepts *testing.T through an interface72//73// For example, with testify:74// assert.Equal(GinkgoT(), 123, 123, "they should be equal")75//76// Or with gomock:77// gomock.NewController(GinkgoT())78//79// GinkgoT() takes an optional offset argument that can be used to get the80// correct line number associated with the failure.81func GinkgoT(optionalOffset ...int) GinkgoTInterface {82	offset := 383	if len(optionalOffset) > 0 {84		offset = optionalOffset[0]85	}86	return testingtproxy.New(GinkgoWriter, Fail, offset)87}88//The interface returned by GinkgoT().  This covers most of the methods89//in the testing package's T.90type GinkgoTInterface interface {91	Fail()92	Error(args ...interface{})93	Errorf(format string, args ...interface{})94	FailNow()95	Fatal(args ...interface{})96	Fatalf(format string, args ...interface{})97	Log(args ...interface{})98	Logf(format string, args ...interface{})99	Failed() bool100	Parallel()101	Skip(args ...interface{})102	Skipf(format string, args ...interface{})103	SkipNow()104	Skipped() bool105}106//Custom Ginkgo test reporters must implement the Reporter interface.107//108//The custom reporter is passed in a SuiteSummary when the suite begins and ends,109//and a SpecSummary just before a spec begins and just after a spec ends110type Reporter reporters.Reporter111//Asynchronous specs are given a channel of the Done type.  You must close or write to the channel112//to tell Ginkgo that your async test is done.113type Done chan<- interface{}114//GinkgoTestDescription represents the information about the current running test returned by CurrentGinkgoTestDescription115//	FullTestText: a concatenation of ComponentTexts and the TestText116//	ComponentTexts: a list of all texts for the Describes & Contexts leading up to the current test117//	TestText: the text in the actual It or Measure node118//	IsMeasurement: true if the current test is a measurement119//	FileName: the name of the file containing the current test120//	LineNumber: the line number for the current test121//	Failed: if the current test has failed, this will be true (useful in an AfterEach)122type GinkgoTestDescription struct {123	FullTestText   string124	ComponentTexts []string125	TestText       string126	IsMeasurement bool127	FileName   string128	LineNumber int129	Failed   bool130	Duration time.Duration131}132//CurrentGinkgoTestDescripton returns information about the current running test.133func CurrentGinkgoTestDescription() GinkgoTestDescription {134	summary, ok := globalSuite.CurrentRunningSpecSummary()135	if !ok {136		return GinkgoTestDescription{}137	}138	subjectCodeLocation := summary.ComponentCodeLocations[len(summary.ComponentCodeLocations)-1]139	return GinkgoTestDescription{140		ComponentTexts: summary.ComponentTexts[1:],141		FullTestText:   strings.Join(summary.ComponentTexts[1:], " "),142		TestText:       summary.ComponentTexts[len(summary.ComponentTexts)-1],143		IsMeasurement:  summary.IsMeasurement,144		FileName:       subjectCodeLocation.FileName,145		LineNumber:     subjectCodeLocation.LineNumber,146		Failed:         summary.HasFailureState(),147		Duration:       summary.RunTime,148	}149}150//Measurement tests receive a Benchmarker.151//152//You use the Time() function to time how long the passed in body function takes to run153//You use the RecordValue() function to track arbitrary numerical measurements.154//The RecordValueWithPrecision() function can be used alternatively to provide the unit155//and resolution of the numeric measurement.156//The optional info argument is passed to the test reporter and can be used to157// provide the measurement data to a custom reporter with context.158//159//See http://onsi.github.io/ginkgo/#benchmark_tests for more details160type Benchmarker interface {161	Time(name string, body func(), info ...interface{}) (elapsedTime time.Duration)162	RecordValue(name string, value float64, info ...interface{})163	RecordValueWithPrecision(name string, value float64, units string, precision int, info ...interface{})164}165//RunSpecs is the entry point for the Ginkgo test runner.166//You must call this within a Golang testing TestX(t *testing.T) function.167//168//To bootstrap a test suite you can use the Ginkgo CLI:169//170//	ginkgo bootstrap171func RunSpecs(t GinkgoTestingT, description string) bool {172	specReporters := []Reporter{buildDefaultReporter()}173	return RunSpecsWithCustomReporters(t, description, specReporters)174}175//To run your tests with Ginkgo's default reporter and your custom reporter(s), replace176//RunSpecs() with this method.177func RunSpecsWithDefaultAndCustomReporters(t GinkgoTestingT, description string, specReporters []Reporter) bool {178	specReporters = append(specReporters, buildDefaultReporter())179	return RunSpecsWithCustomReporters(t, description, specReporters)180}181//To run your tests with your custom reporter(s) (and *not* Ginkgo's default reporter), replace182//RunSpecs() with this method.  Note that parallel tests will not work correctly without the default reporter183func RunSpecsWithCustomReporters(t GinkgoTestingT, description string, specReporters []Reporter) bool {184	writer := GinkgoWriter.(*writer.Writer)185	writer.SetStream(config.DefaultReporterConfig.Verbose)186	reporters := make([]reporters.Reporter, len(specReporters))187	for i, reporter := range specReporters {188		reporters[i] = reporter189	}190	passed, hasFocusedTests := globalSuite.Run(t, description, reporters, writer, config.GinkgoConfig)191	if passed && hasFocusedTests && strings.TrimSpace(os.Getenv("GINKGO_EDITOR_INTEGRATION")) == "" {192		fmt.Println("PASS | FOCUSED")193		os.Exit(types.GINKGO_FOCUS_EXIT_CODE)194	}195	return passed196}197func buildDefaultReporter() Reporter {198	remoteReportingServer := config.GinkgoConfig.StreamHost199	if remoteReportingServer == "" {200		stenographer := stenographer.New(!config.DefaultReporterConfig.NoColor, config.GinkgoConfig.FlakeAttempts > 1, colorable.NewColorableStdout())201		return reporters.NewDefaultReporter(config.DefaultReporterConfig, stenographer)202	} else {203		debugFile := ""204		if config.GinkgoConfig.DebugParallel {205			debugFile = fmt.Sprintf("ginkgo-node-%d.log", config.GinkgoConfig.ParallelNode)206		}207		return remote.NewForwardingReporter(config.DefaultReporterConfig, remoteReportingServer, &http.Client{}, remote.NewOutputInterceptor(), GinkgoWriter.(*writer.Writer), debugFile)208	}209}210//Skip notifies Ginkgo that the current spec was skipped.211func Skip(message string, callerSkip ...int) {212	skip := 0213	if len(callerSkip) > 0 {214		skip = callerSkip[0]215	}216	globalFailer.Skip(message, codelocation.New(skip+1))217	panic(GINKGO_PANIC)218}219//Fail notifies Ginkgo that the current spec has failed. (Gomega will call Fail for you automatically when an assertion fails.)220func Fail(message string, callerSkip ...int) {221	skip := 0222	if len(callerSkip) > 0 {223		skip = callerSkip[0]224	}225	globalFailer.Fail(message, codelocation.New(skip+1))226	panic(GINKGO_PANIC)227}228//GinkgoRecover should be deferred at the top of any spawned goroutine that (may) call `Fail`229//Since Gomega assertions call fail, you should throw a `defer GinkgoRecover()` at the top of any goroutine that230//calls out to Gomega231//232//Here's why: Ginkgo's `Fail` method records the failure and then panics to prevent233//further assertions from running.  This panic must be recovered.  Ginkgo does this for you234//if the panic originates in a Ginkgo node (an It, BeforeEach, etc...)235//236//Unfortunately, if a panic originates on a goroutine *launched* from one of these nodes there's no237//way for Ginkgo to rescue the panic.  To do this, you must remember to `defer GinkgoRecover()` at the top of such a goroutine.238func GinkgoRecover() {239	e := recover()240	if e != nil {241		globalFailer.Panic(codelocation.New(1), e)242	}243}244//Describe blocks allow you to organize your specs.  A Describe block can contain any number of245//BeforeEach, AfterEach, JustBeforeEach, It, and Measurement blocks.246//247//In addition you can nest Describe, Context and When blocks.  Describe, Context and When blocks are functionally248//equivalent.  The difference is purely semantic -- you typical Describe the behavior of an object249//or method and, within that Describe, outline a number of Contexts and Whens.250func Describe(text string, body func()) bool {251	globalSuite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))252	return true253}254//You can focus the tests within a describe block using FDescribe255func FDescribe(text string, body func()) bool {256	globalSuite.PushContainerNode(text, body, types.FlagTypeFocused, codelocation.New(1))257	return true258}259//You can mark the tests within a describe block as pending using PDescribe260func PDescribe(text string, body func()) bool {261	globalSuite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))262	return true263}264//You can mark the tests within a describe block as pending using XDescribe265func XDescribe(text string, body func()) bool {266	globalSuite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))267	return true268}269//Context blocks allow you to organize your specs.  A Context block can contain any number of270//BeforeEach, AfterEach, JustBeforeEach, It, and Measurement blocks.271//272//In addition you can nest Describe, Context and When blocks.  Describe, Context and When blocks are functionally273//equivalent.  The difference is purely semantic -- you typical Describe the behavior of an object274//or method and, within that Describe, outline a number of Contexts and Whens.275func Context(text string, body func()) bool {276	globalSuite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))277	return true278}279//You can focus the tests within a describe block using FContext280func FContext(text string, body func()) bool {281	globalSuite.PushContainerNode(text, body, types.FlagTypeFocused, codelocation.New(1))282	return true283}284//You can mark the tests within a describe block as pending using PContext285func PContext(text string, body func()) bool {286	globalSuite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))287	return true288}289//You can mark the tests within a describe block as pending using XContext290func XContext(text string, body func()) bool {291	globalSuite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))292	return true293}294//When blocks allow you to organize your specs.  A When block can contain any number of295//BeforeEach, AfterEach, JustBeforeEach, It, and Measurement blocks.296//297//In addition you can nest Describe, Context and When blocks.  Describe, Context and When blocks are functionally298//equivalent.  The difference is purely semantic -- you typical Describe the behavior of an object299//or method and, within that Describe, outline a number of Contexts and Whens.300func When(text string, body func()) bool {301	globalSuite.PushContainerNode("when "+text, body, types.FlagTypeNone, codelocation.New(1))302	return true303}304//You can focus the tests within a describe block using FWhen305func FWhen(text string, body func()) bool {306	globalSuite.PushContainerNode("when "+text, body, types.FlagTypeFocused, codelocation.New(1))307	return true308}309//You can mark the tests within a describe block as pending using PWhen310func PWhen(text string, body func()) bool {311	globalSuite.PushContainerNode("when "+text, body, types.FlagTypePending, codelocation.New(1))312	return true313}314//You can mark the tests within a describe block as pending using XWhen315func XWhen(text string, body func()) bool {316	globalSuite.PushContainerNode("when "+text, body, types.FlagTypePending, codelocation.New(1))317	return true318}319//It blocks contain your test code and assertions.  You cannot nest any other Ginkgo blocks320//within an It block.321//322//Ginkgo will normally run It blocks synchronously.  To perform asynchronous tests, pass a323//function that accepts a Done channel.  When you do this, you can also provide an optional timeout.324func It(text string, body interface{}, timeout ...float64) bool {325	globalSuite.PushItNode(text, body, types.FlagTypeNone, codelocation.New(1), parseTimeout(timeout...))326	return true327}328//You can focus individual Its using FIt329func FIt(text string, body interface{}, timeout ...float64) bool {330	globalSuite.PushItNode(text, body, types.FlagTypeFocused, codelocation.New(1), parseTimeout(timeout...))331	return true332}333//You can mark Its as pending using PIt334func PIt(text string, _ ...interface{}) bool {335	globalSuite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)336	return true337}338//You can mark Its as pending using XIt339func XIt(text string, _ ...interface{}) bool {340	globalSuite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)341	return true342}343//Specify blocks are aliases for It blocks and allow for more natural wording in situations344//which "It" does not fit into a natural sentence flow. All the same protocols apply for Specify blocks345//which apply to It blocks.346func Specify(text string, body interface{}, timeout ...float64) bool {347	globalSuite.PushItNode(text, body, types.FlagTypeNone, codelocation.New(1), parseTimeout(timeout...))348	return true349}350//You can focus individual Specifys using FSpecify351func FSpecify(text string, body interface{}, timeout ...float64) bool {352	globalSuite.PushItNode(text, body, types.FlagTypeFocused, codelocation.New(1), parseTimeout(timeout...))353	return true354}355//You can mark Specifys as pending using PSpecify356func PSpecify(text string, is ...interface{}) bool {357	globalSuite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)358	return true359}360//You can mark Specifys as pending using XSpecify361func XSpecify(text string, is ...interface{}) bool {362	globalSuite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)363	return true364}365//By allows you to better document large Its.366//367//Generally you should try to keep your Its short and to the point.  This is not always possible, however,368//especially in the context of integration tests that capture a particular workflow.369//370//By allows you to document such flows.  By must be called within a runnable node (It, BeforeEach, Measure, etc...)371//By will simply log the passed in text to the GinkgoWriter.  If By is handed a function it will immediately run the function.372func By(text string, callbacks ...func()) {373	preamble := "\x1b[1mSTEP\x1b[0m"374	if config.DefaultReporterConfig.NoColor {375		preamble = "STEP"376	}377	fmt.Fprintln(GinkgoWriter, preamble+": "+text)378	if len(callbacks) == 1 {379		callbacks[0]()380	}381	if len(callbacks) > 1 {382		panic("just one callback per By, please")383	}384}385//Measure blocks run the passed in body function repeatedly (determined by the samples argument)386//and accumulate metrics provided to the Benchmarker by the body function.387//388//The body function must have the signature:389//	func(b Benchmarker)390func Measure(text string, body interface{}, samples int) bool {391	globalSuite.PushMeasureNode(text, body, types.FlagTypeNone, codelocation.New(1), samples)392	return true393}394//You can focus individual Measures using FMeasure395func FMeasure(text string, body interface{}, samples int) bool {396	globalSuite.PushMeasureNode(text, body, types.FlagTypeFocused, codelocation.New(1), samples)397	return true398}399//You can mark Maeasurements as pending using PMeasure400func PMeasure(text string, _ ...interface{}) bool {401	globalSuite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)402	return true403}404//You can mark Maeasurements as pending using XMeasure405func XMeasure(text string, _ ...interface{}) bool {406	globalSuite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)407	return true408}409//BeforeSuite blocks are run just once before any specs are run.  When running in parallel, each410//parallel node process will call BeforeSuite.411//412//BeforeSuite blocks can be made asynchronous by providing a body function that accepts a Done channel413//414//You may only register *one* BeforeSuite handler per test suite.  You typically do so in your bootstrap file at the top level.415func BeforeSuite(body interface{}, timeout ...float64) bool {416	globalSuite.SetBeforeSuiteNode(body, codelocation.New(1), parseTimeout(timeout...))417	return true418}419//AfterSuite blocks are *always* run after all the specs regardless of whether specs have passed or failed.420//Moreover, if Ginkgo receives an interrupt signal (^C) it will attempt to run the AfterSuite before exiting.421//422//When running in parallel, each parallel node process will call AfterSuite.423//424//AfterSuite blocks can be made asynchronous by providing a body function that accepts a Done channel425//426//You may only register *one* AfterSuite handler per test suite.  You typically do so in your bootstrap file at the top level.427func AfterSuite(body interface{}, timeout ...float64) bool {428	globalSuite.SetAfterSuiteNode(body, codelocation.New(1), parseTimeout(timeout...))429	return true430}431//SynchronizedBeforeSuite blocks are primarily meant to solve the problem of setting up singleton external resources shared across432//nodes when running tests in parallel.  For example, say you have a shared database that you can only start one instance of that433//must be used in your tests.  When running in parallel, only one node should set up the database and all other nodes should wait434//until that node is done before running.435//436//SynchronizedBeforeSuite accomplishes this by taking *two* function arguments.  The first is only run on parallel node #1.  The second is437//run on all nodes, but *only* after the first function completes succesfully.  Ginkgo also makes it possible to send data from the first function (on Node 1)438//to the second function (on all the other nodes).439//440//The functions have the following signatures.  The first function (which only runs on node 1) has the signature:441//442//	func() []byte443//444//or, to run asynchronously:445//446//	func(done Done) []byte447//448//The byte array returned by the first function is then passed to the second function, which has the signature:449//450//	func(data []byte)451//452//or, to run asynchronously:453//454//	func(data []byte, done Done)455//456//Here's a simple pseudo-code example that starts a shared database on Node 1 and shares the database's address with the other nodes:457//458//	var dbClient db.Client459//	var dbRunner db.Runner460//461//	var _ = SynchronizedBeforeSuite(func() []byte {462//		dbRunner = db.NewRunner()463//		err := dbRunner.Start()464//		Î©(err).ShouldNot(HaveOccurred())465//		return []byte(dbRunner.URL)466//	}, func(data []byte) {467//		dbClient = db.NewClient()468//		err := dbClient.Connect(string(data))469//		Î©(err).ShouldNot(HaveOccurred())470//	})471func SynchronizedBeforeSuite(node1Body interface{}, allNodesBody interface{}, timeout ...float64) bool {472	globalSuite.SetSynchronizedBeforeSuiteNode(473		node1Body,474		allNodesBody,475		codelocation.New(1),476		parseTimeout(timeout...),477	)478	return true479}480//SynchronizedAfterSuite blocks complement the SynchronizedBeforeSuite blocks in solving the problem of setting up481//external singleton resources shared across nodes when running tests in parallel.482//483//SynchronizedAfterSuite accomplishes this by taking *two* function arguments.  The first runs on all nodes.  The second runs only on parallel node #1484//and *only* after all other nodes have finished and exited.  This ensures that node 1, and any resources it is running, remain alive until485//all other nodes are finished.486//487//Both functions have the same signature: either func() or func(done Done) to run asynchronously.488//489//Here's a pseudo-code example that complements that given in SynchronizedBeforeSuite.  Here, SynchronizedAfterSuite is used to tear down the shared database490//only after all nodes have finished:491//492//	var _ = SynchronizedAfterSuite(func() {493//		dbClient.Cleanup()494//	}, func() {495//		dbRunner.Stop()496//	})497func SynchronizedAfterSuite(allNodesBody interface{}, node1Body interface{}, timeout ...float64) bool {498	globalSuite.SetSynchronizedAfterSuiteNode(499		allNodesBody,500		node1Body,501		codelocation.New(1),502		parseTimeout(timeout...),503	)504	return true505}506//BeforeEach blocks are run before It blocks.  When multiple BeforeEach blocks are defined in nested507//Describe and Context blocks the outermost BeforeEach blocks are run first.508//509//Like It blocks, BeforeEach blocks can be made asynchronous by providing a body function that accepts510//a Done channel511func BeforeEach(body interface{}, timeout ...float64) bool {512	globalSuite.PushBeforeEachNode(body, codelocation.New(1), parseTimeout(timeout...))513	return true514}515//JustBeforeEach blocks are run before It blocks but *after* all BeforeEach blocks.  For more details,516//read the [documentation](http://onsi.github.io/ginkgo/#separating_creation_and_configuration_)517//518//Like It blocks, BeforeEach blocks can be made asynchronous by providing a body function that accepts519//a Done channel520func JustBeforeEach(body interface{}, timeout ...float64) bool {521	globalSuite.PushJustBeforeEachNode(body, codelocation.New(1), parseTimeout(timeout...))522	return true523}524//JustAfterEach blocks are run after It blocks but *before* all AfterEach blocks.  For more details,525//read the [documentation](http://onsi.github.io/ginkgo/#separating_creation_and_configuration_)526//527//Like It blocks, JustAfterEach blocks can be made asynchronous by providing a body function that accepts528//a Done channel529func JustAfterEach(body interface{}, timeout ...float64) bool {530	globalSuite.PushJustAfterEachNode(body, codelocation.New(1), parseTimeout(timeout...))531	return true532}533//AfterEach blocks are run after It blocks.   When multiple AfterEach blocks are defined in nested534//Describe and Context blocks the innermost AfterEach blocks are run first.535//536//Like It blocks, AfterEach blocks can be made asynchronous by providing a body function that accepts537//a Done channel538func AfterEach(body interface{}, timeout ...float64) bool {539	globalSuite.PushAfterEachNode(body, codelocation.New(1), parseTimeout(timeout...))540	return true541}542func parseTimeout(timeout ...float64) time.Duration {543	if len(timeout) == 0 {544		return time.Duration(defaultTimeout * int64(time.Second))545	} else {546		return time.Duration(timeout[0] * float64(time.Second))547	}548}...

run_test.go

Source:run_test.go

...23		BeforeEach(func() {24			pathToTest = tmpPath("ginkgo")25			copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)26		})27		It("should run the tests in the working directory", func() {28			session := startGinkgo(pathToTest, "--noColor")29			Eventually(session).Should(gexec.Exit(0))30			output := string(session.Out.Contents())31			Î©(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))32			Î©(output).Should(ContainSubstring(strings.Repeat(denoter, 4)))33			Î©(output).Should(ContainSubstring("SUCCESS! -- 4 Passed"))34			Î©(output).Should(ContainSubstring("Test Suite Passed"))35		})36	})37	Context("when passed an explicit package to run", func() {38		BeforeEach(func() {39			pathToTest = tmpPath("ginkgo")40			copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)41		})42		It("should run the ginkgo style tests", func() {43			session := startGinkgo(tmpDir, "--noColor", pathToTest)44			Eventually(session).Should(gexec.Exit(0))45			output := string(session.Out.Contents())46			Î©(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))47			Î©(output).Should(ContainSubstring(strings.Repeat(denoter, 4)))48			Î©(output).Should(ContainSubstring("SUCCESS! -- 4 Passed"))49			Î©(output).Should(ContainSubstring("Test Suite Passed"))50		})51	})52	Context("when passed a number of packages to run", func() {53		BeforeEach(func() {54			pathToTest = tmpPath("ginkgo")55			otherPathToTest := tmpPath("other")56			copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)57			copyIn(fixturePath("more_ginkgo_tests"), otherPathToTest, false)58		})59		It("should run the ginkgo style tests", func() {60			session := startGinkgo(tmpDir, "--noColor", "--succinct=false", "ginkgo", "./other")61			Eventually(session).Should(gexec.Exit(0))62			output := string(session.Out.Contents())63			Î©(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))64			Î©(output).Should(ContainSubstring("Running Suite: More_ginkgo_tests Suite"))65			Î©(output).Should(ContainSubstring("Test Suite Passed"))66		})67	})68	Context("when passed a number of packages to run, some of which have focused tests", func() {69		BeforeEach(func() {70			pathToTest = tmpPath("ginkgo")71			otherPathToTest := tmpPath("other")72			focusedPathToTest := tmpPath("focused")73			copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)74			copyIn(fixturePath("more_ginkgo_tests"), otherPathToTest, false)75			copyIn(fixturePath("focused_fixture"), focusedPathToTest, false)76		})77		It("should exit with a status code of 2 and explain why", func() {78			session := startGinkgo(tmpDir, "--noColor", "--succinct=false", "-r")79			Eventually(session).Should(gexec.Exit(types.GINKGO_FOCUS_EXIT_CODE))80			output := string(session.Out.Contents())81			Î©(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))82			Î©(output).Should(ContainSubstring("Running Suite: More_ginkgo_tests Suite"))83			Î©(output).Should(ContainSubstring("Test Suite Passed"))84			Î©(output).Should(ContainSubstring("Detected Programmatic Focus - setting exit status to %d", types.GINKGO_FOCUS_EXIT_CODE))85		})86		Context("when the GINKGO_EDITOR_INTEGRATION environment variable is set", func() {87			BeforeEach(func() {88				os.Setenv("GINKGO_EDITOR_INTEGRATION", "true")89			})90			AfterEach(func() {91				os.Setenv("GINKGO_EDITOR_INTEGRATION", "")92			})93			It("should exit with a status code of 0 to allow a coverage file to be generated", func() {94				session := startGinkgo(tmpDir, "--noColor", "--succinct=false", "-r")95				Eventually(session).Should(gexec.Exit(0))96				output := string(session.Out.Contents())97				Î©(output).Should(ContainSubstring("Running Suite: Passing_ginkgo_tests Suite"))98				Î©(output).Should(ContainSubstring("Running Suite: More_ginkgo_tests Suite"))99				Î©(output).Should(ContainSubstring("Test Suite Passed"))100			})101		})102	})103	Context("when told to skipPackages", func() {104		BeforeEach(func() {105			pathToTest = tmpPath("ginkgo")106			otherPathToTest := tmpPath("other")107			focusedPathToTest := tmpPath("focused")108			copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)109			copyIn(fixturePath("more_ginkgo_tests"), otherPathToTest, false)110			copyIn(fixturePath("focused_fixture"), focusedPathToTest, false)111		})112		It("should skip packages that match the list", func() {113			session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused", "-r")114			Eventually(session).Should(gexec.Exit(0))115			output := string(session.Out.Contents())116			Î©(output).Should(ContainSubstring("Passing_ginkgo_tests Suite"))117			Î©(output).ShouldNot(ContainSubstring("More_ginkgo_tests Suite"))118			Î©(output).ShouldNot(ContainSubstring("Focused_fixture Suite"))119			Î©(output).Should(ContainSubstring("Test Suite Passed"))120		})121		Context("when all packages are skipped", func() {122			It("should not run anything, but still exit 0", func() {123				session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused,ginkgo", "-r")124				Eventually(session).Should(gexec.Exit(0))125				output := string(session.Out.Contents())126				Î©(output).Should(ContainSubstring("All tests skipped!"))127				Î©(output).ShouldNot(ContainSubstring("Passing_ginkgo_tests Suite"))128				Î©(output).ShouldNot(ContainSubstring("More_ginkgo_tests Suite"))129				Î©(output).ShouldNot(ContainSubstring("Focused_fixture Suite"))130				Î©(output).ShouldNot(ContainSubstring("Test Suite Passed"))131			})132		})133	})134	Context("when there are no tests to run", func() {135		It("should exit 1", func() {136			session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused", "-r")137			Eventually(session).Should(gexec.Exit(1))138			output := string(session.Err.Contents())139			Î©(output).Should(ContainSubstring("Found no test suites"))140		})141	})142	Context("when there are test files but `go test` reports there are no tests to run", func() {143		BeforeEach(func() {144			pathToTest = tmpPath("ginkgo")145			copyIn(fixturePath("no_test_fn"), pathToTest, false)146		})147		It("suggests running ginkgo bootstrap", func() {148			session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused", "-r")149			Eventually(session).Should(gexec.Exit(0))150			output := string(session.Err.Contents())151			Î©(output).Should(ContainSubstring(`Found no test suites, did you forget to run "ginkgo bootstrap"?`))152		})153		It("fails if told to requireSuite", func() {154			session := startGinkgo(tmpDir, "--noColor", "--skipPackage=other,focused", "-r", "-requireSuite")155			Eventually(session).Should(gexec.Exit(1))156			output := string(session.Err.Contents())157			Î©(output).Should(ContainSubstring(`Found no test suites, did you forget to run "ginkgo bootstrap"?`))158		})159	})160	Context("when told to randomizeSuites", func() {161		BeforeEach(func() {162			pathToTest = tmpPath("ginkgo")163			otherPathToTest := tmpPath("other")164			copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)165			copyIn(fixturePath("more_ginkgo_tests"), otherPathToTest, false)166		})167		It("should skip packages that match the regexp", func() {168			session := startGinkgo(tmpDir, "--noColor", "--randomizeSuites", "-r", "--seed=2")169			Eventually(session).Should(gexec.Exit(0))170			Î©(session).Should(gbytes.Say("More_ginkgo_tests Suite"))171			Î©(session).Should(gbytes.Say("Passing_ginkgo_tests Suite"))172			session = startGinkgo(tmpDir, "--noColor", "--randomizeSuites", "-r", "--seed=3")173			Eventually(session).Should(gexec.Exit(0))174			Î©(session).Should(gbytes.Say("Passing_ginkgo_tests Suite"))175			Î©(session).Should(gbytes.Say("More_ginkgo_tests Suite"))176		})177	})178	Context("when pointed at a package with xunit style tests", func() {179		BeforeEach(func() {180			pathToTest = tmpPath("xunit")181			copyIn(fixturePath("xunit_tests"), pathToTest, false)182		})183		It("should run the xunit style tests", func() {184			session := startGinkgo(pathToTest)185			Eventually(session).Should(gexec.Exit(0))186			output := string(session.Out.Contents())187			Î©(output).Should(ContainSubstring("--- PASS: TestAlwaysTrue"))188			Î©(output).Should(ContainSubstring("Test Suite Passed"))189		})190	})191	Context("when pointed at a package with no tests", func() {192		BeforeEach(func() {193			pathToTest = tmpPath("no_tests")194			copyIn(fixturePath("no_tests"), pathToTest, false)195		})196		It("should fail", func() {197			session := startGinkgo(pathToTest, "--noColor")198			Eventually(session).Should(gexec.Exit(1))199			Î©(session.Err.Contents()).Should(ContainSubstring("Found no test suites"))200		})201	})202	Context("when pointed at a package that fails to compile", func() {203		BeforeEach(func() {204			pathToTest = tmpPath("does_not_compile")205			copyIn(fixturePath("does_not_compile"), pathToTest, false)206		})207		It("should fail", func() {208			session := startGinkgo(pathToTest, "--noColor")209			Eventually(session).Should(gexec.Exit(1))210			output := string(session.Out.Contents())211			Î©(output).Should(ContainSubstring("Failed to compile"))212		})213	})214	Context("when running in parallel", func() {215		BeforeEach(func() {216			pathToTest = tmpPath("ginkgo")217			copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)218		})219		Context("with a specific number of -nodes", func() {220			It("should use the specified number of nodes", func() {221				session := startGinkgo(pathToTest, "--noColor", "-succinct", "-nodes=2")222				Eventually(session).Should(gexec.Exit(0))223				output := string(session.Out.Contents())224				Î©(output).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4 specs - 2 nodes [%s]{4} SUCCESS! \d+(\.\d+)?[muÂµ]s`, regexp.QuoteMeta(denoter)))225				Î©(output).Should(ContainSubstring("Test Suite Passed"))226			})227		})228		Context("with -p", func() {229			It("it should autocompute the number of nodes", func() {230				session := startGinkgo(pathToTest, "--noColor", "-succinct", "-p")231				Eventually(session).Should(gexec.Exit(0))232				output := string(session.Out.Contents())233				nodes := runtime.NumCPU()234				if nodes == 1 {235					Skip("Can't test parallel testings with 1 CPU")236				}237				if nodes > 4 {238					nodes = nodes - 1239				}240				Î©(output).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4 specs - %d nodes [%s]{4} SUCCESS! \d+(\.\d+)?[muÂµ]?s`, nodes, regexp.QuoteMeta(denoter)))241				Î©(output).Should(ContainSubstring("Test Suite Passed"))242			})243		})244	})245	Context("when running in parallel with -debug", func() {246		BeforeEach(func() {247			pathToTest = tmpPath("ginkgo")248			copyIn(fixturePath("debug_parallel_fixture"), pathToTest, false)249		})250		Context("without -v", func() {251			It("should emit node output to files on disk", func() {252				session := startGinkgo(pathToTest, "--nodes=2", "--debug")253				Eventually(session).Should(gexec.Exit(0))254				f0, err := ioutil.ReadFile(pathToTest + "/ginkgo-node-1.log")255				Î©(err).ShouldNot(HaveOccurred())256				f1, err := ioutil.ReadFile(pathToTest + "/ginkgo-node-2.log")257				Î©(err).ShouldNot(HaveOccurred())258				content := string(append(f0, f1...))259				for i := 0; i < 10; i += 1 {260					Î©(content).Should(ContainSubstring("StdOut %d\n", i))261					Î©(content).Should(ContainSubstring("GinkgoWriter %d\n", i))262				}263			})264		})265		Context("without -v", func() {266			It("should emit node output to files on disk, without duplicating the GinkgoWriter output", func() {267				session := startGinkgo(pathToTest, "--nodes=2", "--debug", "-v")268				Eventually(session).Should(gexec.Exit(0))269				f0, err := ioutil.ReadFile(pathToTest + "/ginkgo-node-1.log")270				Î©(err).ShouldNot(HaveOccurred())271				f1, err := ioutil.ReadFile(pathToTest + "/ginkgo-node-2.log")272				Î©(err).ShouldNot(HaveOccurred())273				content := string(append(f0, f1...))274				out := strings.Split(content, "GinkgoWriter 2")275				Î©(out).Should(HaveLen(2))276			})277		})278	})279	Context("when streaming in parallel", func() {280		BeforeEach(func() {281			pathToTest = tmpPath("ginkgo")282			copyIn(fixturePath("passing_ginkgo_tests"), pathToTest, false)283		})284		It("should print output in realtime", func() {285			session := startGinkgo(pathToTest, "--noColor", "-stream", "-nodes=2")286			Eventually(session).Should(gexec.Exit(0))287			output := string(session.Out.Contents())288			Î©(output).Should(ContainSubstring(`[1] Parallel test node 1/2.`))289			Î©(output).Should(ContainSubstring(`[2] Parallel test node 2/2.`))290			Î©(output).Should(ContainSubstring(`[1] SUCCESS!`))291			Î©(output).Should(ContainSubstring(`[2] SUCCESS!`))292			Î©(output).Should(ContainSubstring("Test Suite Passed"))293		})294	})295	Context("when running recursively", func() {296		BeforeEach(func() {297			passingTest := tmpPath("A")298			otherPassingTest := tmpPath("E")299			copyIn(fixturePath("passing_ginkgo_tests"), passingTest, false)300			copyIn(fixturePath("more_ginkgo_tests"), otherPassingTest, false)301		})302		Context("when all the tests pass", func() {303			Context("with the -r flag", func() {304				It("should run all the tests (in succinct mode) and succeed", func() {305					session := startGinkgo(tmpDir, "--noColor", "-r", ".")306					Eventually(session).Should(gexec.Exit(0))307					output := string(session.Out.Contents())308					outputLines := strings.Split(output, "\n")309					Î©(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muÂµ]s PASS`, regexp.QuoteMeta(denoter)))310					Î©(outputLines[1]).Should(MatchRegexp(`\[\d+\] More_ginkgo_tests Suite - 2/2 specs [%s]{2} SUCCESS! \d+(\.\d+)?[muÂµ]s PASS`, regexp.QuoteMeta(denoter)))311					Î©(output).Should(ContainSubstring("Test Suite Passed"))312				})313			})314			Context("with a trailing /...", func() {315				It("should run all the tests (in succinct mode) and succeed", func() {316					session := startGinkgo(tmpDir, "--noColor", "./...")317					Eventually(session).Should(gexec.Exit(0))318					output := string(session.Out.Contents())319					outputLines := strings.Split(output, "\n")320					Î©(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muÂµ]s PASS`, regexp.QuoteMeta(denoter)))321					Î©(outputLines[1]).Should(MatchRegexp(`\[\d+\] More_ginkgo_tests Suite - 2/2 specs [%s]{2} SUCCESS! \d+(\.\d+)?[muÂµ]s PASS`, regexp.QuoteMeta(denoter)))322					Î©(output).Should(ContainSubstring("Test Suite Passed"))323				})324			})325		})326		Context("when one of the packages has a failing tests", func() {327			BeforeEach(func() {328				failingTest := tmpPath("C")329				copyIn(fixturePath("failing_ginkgo_tests"), failingTest, false)330			})331			It("should fail and stop running tests", func() {332				session := startGinkgo(tmpDir, "--noColor", "-r")333				Eventually(session).Should(gexec.Exit(1))334				output := string(session.Out.Contents())335				outputLines := strings.Split(output, "\n")336				Î©(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muÂµ]s PASS`, regexp.QuoteMeta(denoter)))337				Î©(outputLines[1]).Should(MatchRegexp(`\[\d+\] Failing_ginkgo_tests Suite - 2/2 specs`))338				Î©(output).Should(ContainSubstring(fmt.Sprintf("%s Failure", denoter)))339				Î©(output).ShouldNot(ContainSubstring("More_ginkgo_tests Suite"))340				Î©(output).Should(ContainSubstring("Test Suite Failed"))341				Î©(output).Should(ContainSubstring("Summarizing 1 Failure:"))342				Î©(output).Should(ContainSubstring("[Fail] FailingGinkgoTests [It] should fail"))343			})344		})345		Context("when one of the packages fails to compile", func() {346			BeforeEach(func() {347				doesNotCompileTest := tmpPath("C")348				copyIn(fixturePath("does_not_compile"), doesNotCompileTest, false)349			})350			It("should fail and stop running tests", func() {351				session := startGinkgo(tmpDir, "--noColor", "-r")352				Eventually(session).Should(gexec.Exit(1))353				output := string(session.Out.Contents())354				outputLines := strings.Split(output, "\n")355				Î©(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muÂµ]s PASS`, regexp.QuoteMeta(denoter)))356				Î©(outputLines[1]).Should(ContainSubstring("Failed to compile C:"))357				Î©(output).ShouldNot(ContainSubstring("More_ginkgo_tests Suite"))358				Î©(output).Should(ContainSubstring("Test Suite Failed"))359			})360		})361		Context("when either is the case, but the keepGoing flag is set", func() {362			BeforeEach(func() {363				doesNotCompileTest := tmpPath("B")364				copyIn(fixturePath("does_not_compile"), doesNotCompileTest, false)365				failingTest := tmpPath("C")366				copyIn(fixturePath("failing_ginkgo_tests"), failingTest, false)367			})368			It("should soldier on", func() {369				session := startGinkgo(tmpDir, "--noColor", "-r", "-keepGoing")370				Eventually(session).Should(gexec.Exit(1))371				output := string(session.Out.Contents())372				outputLines := strings.Split(output, "\n")373				Î©(outputLines[0]).Should(MatchRegexp(`\[\d+\] Passing_ginkgo_tests Suite - 4/4 specs [%s]{4} SUCCESS! \d+(\.\d+)?[muÂµ]s PASS`, regexp.QuoteMeta(denoter)))374				Î©(outputLines[1]).Should(ContainSubstring("Failed to compile B:"))375				Î©(output).Should(MatchRegexp(`\[\d+\] Failing_ginkgo_tests Suite - 2/2 specs`))376				Î©(output).Should(ContainSubstring(fmt.Sprintf("%s Failure", denoter)))377				Î©(output).Should(MatchRegexp(`\[\d+\] More_ginkgo_tests Suite - 2/2 specs [%s]{2} SUCCESS! \d+(\.\d+)?[muÂµ]s PASS`, regexp.QuoteMeta(denoter)))378				Î©(output).Should(ContainSubstring("Test Suite Failed"))379			})380		})381	})382	Context("when told to keep going --untilItFails", func() {383		BeforeEach(func() {384			copyIn(fixturePath("eventually_failing"), tmpDir, false)385		})386		It("should keep rerunning the tests, until a failure occurs", func() {387			session := startGinkgo(tmpDir, "--untilItFails", "--noColor")388			Eventually(session).Should(gexec.Exit(1))389			Î©(session).Should(gbytes.Say("This was attempt #1"))390			Î©(session).Should(gbytes.Say("This was attempt #2"))391			Î©(session).Should(gbytes.Say("Tests failed on attempt #3"))392			//it should change the random seed between each test393			lines := strings.Split(string(session.Out.Contents()), "\n")394			randomSeeds := []string{}395			for _, line := range lines {396				if strings.Contains(line, "Random Seed:") {397					randomSeeds = append(randomSeeds, strings.Split(line, ": ")[1])398				}399			}400			Î©(randomSeeds[0]).ShouldNot(Equal(randomSeeds[1]))401			Î©(randomSeeds[1]).ShouldNot(Equal(randomSeeds[2]))...

session_test.go

Source:session_test.go

...22		session, err = Start(command, outWriter, errWriter)23		Î©(err).ShouldNot(HaveOccurred())24	})25	Context("running a command", func() {26		It("should start the process", func() {27			Î©(command.Process).ShouldNot(BeNil())28		})29		It("should wrap the process's stdout and stderr with gbytes buffers", func(done Done) {30			Eventually(session.Out).Should(Say("We've done the impossible, and that makes us mighty"))31			Eventually(session.Err).Should(Say("Ah, curse your sudden but inevitable betrayal!"))32			defer session.Out.CancelDetects()33			select {34			case <-session.Out.Detect("Can we maybe vote on the whole murdering people issue"):35				Eventually(session).Should(Exit(0))36			case <-session.Out.Detect("I swear by my pretty floral bonnet, I will end you."):37				Eventually(session).Should(Exit(1))38			case <-session.Out.Detect("My work's illegal, but at least it's honest."):39				Eventually(session).Should(Exit(2))40			}41			close(done)42		})43		It("should satisfy the gbytes.BufferProvider interface, passing Stdout", func() {44			Eventually(session).Should(Say("We've done the impossible, and that makes us mighty"))45			Eventually(session).Should(Exit())46		})47	})48	Describe("providing the exit code", func() {49		It("should provide the app's exit code", func() {50			Î©(session.ExitCode()).Should(Equal(-1))51			Eventually(session).Should(Exit())52			Î©(session.ExitCode()).Should(BeNumerically(">=", 0))53			Î©(session.ExitCode()).Should(BeNumerically("<", 3))54		})55	})56	Describe("wait", func() {57		It("should wait till the command exits", func() {58			Î©(session.ExitCode()).Should(Equal(-1))59			Î©(session.Wait().ExitCode()).Should(BeNumerically(">=", 0))60			Î©(session.Wait().ExitCode()).Should(BeNumerically("<", 3))61		})62	})63	Describe("exited", func() {64		It("should close when the command exits", func() {65			Eventually(session.Exited).Should(BeClosed())66			Î©(session.ExitCode()).ShouldNot(Equal(-1))67		})68	})69	Describe("kill", func() {70		It("should kill the command and don't wait for it to exit", func() {71			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)72			Î©(err).ShouldNot(HaveOccurred())73			session.Kill()74			Î©(session).ShouldNot(Exit(), "Should not exit immediately...")75			Eventually(session).Should(Exit(128 + 9))76		})77	})78	Describe("interrupt", func() {79		It("should interrupt the command", func() {80			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)81			Î©(err).ShouldNot(HaveOccurred())82			session.Interrupt()83			Î©(session).ShouldNot(Exit(), "Should not exit immediately...")84			Eventually(session).Should(Exit(128 + 2))85		})86	})87	Describe("terminate", func() {88		It("should terminate the command", func() {89			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)90			Î©(err).ShouldNot(HaveOccurred())91			session.Terminate()92			Î©(session).ShouldNot(Exit(), "Should not exit immediately...")93			Eventually(session).Should(Exit(128 + 15))94		})95	})96	Describe("signal", func() {97		It("should send the signal to the command", func() {98			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)99			Î©(err).ShouldNot(HaveOccurred())100			session.Signal(syscall.SIGABRT)101			Î©(session).ShouldNot(Exit(), "Should not exit immediately...")102			Eventually(session).Should(Exit(128 + 6))103		})104	})105	Context("tracking sessions", func() {106		BeforeEach(func() {107			KillAndWait()108		})109		Describe("kill", func() {110			It("should kill all the started sessions", func() {111				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)112				Î©(err).ShouldNot(HaveOccurred())113				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)114				Î©(err).ShouldNot(HaveOccurred())115				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)116				Î©(err).ShouldNot(HaveOccurred())117				Kill()118				Eventually(session1).Should(Exit(128 + 9))119				Eventually(session2).Should(Exit(128 + 9))120				Eventually(session3).Should(Exit(128 + 9))121			})122			It("should not wait for exit", func() {123				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)124				Î©(err).ShouldNot(HaveOccurred())125				Kill()126				Î©(session1).ShouldNot(Exit(), "Should not exit immediately...")127				Eventually(session1).Should(Exit(128 + 9))128			})129			It("should not track unstarted sessions", func() {130				_, err := Start(exec.Command("does not exist", "10000000"), GinkgoWriter, GinkgoWriter)131				Î©(err).Should(HaveOccurred())132				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)133				Î©(err).ShouldNot(HaveOccurred())134				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)135				Î©(err).ShouldNot(HaveOccurred())136				Kill()137				Eventually(session2).Should(Exit(128 + 9))138				Eventually(session3).Should(Exit(128 + 9))139			})140		})141		Describe("killAndWait", func() {142			It("should kill all the started sessions and wait for them to finish", func() {143				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)144				Î©(err).ShouldNot(HaveOccurred())145				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)146				Î©(err).ShouldNot(HaveOccurred())147				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)148				Î©(err).ShouldNot(HaveOccurred())149				KillAndWait()150				Î©(session1).Should(Exit(128+9), "Should have exited")151				Î©(session2).Should(Exit(128+9), "Should have exited")152				Î©(session3).Should(Exit(128+9), "Should have exited")153			})154		})155		Describe("terminate", func() {156			It("should terminate all the started sessions", func() {157				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)158				Î©(err).ShouldNot(HaveOccurred())159				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)160				Î©(err).ShouldNot(HaveOccurred())161				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)162				Î©(err).ShouldNot(HaveOccurred())163				Terminate()164				Eventually(session1).Should(Exit(128 + 15))165				Eventually(session2).Should(Exit(128 + 15))166				Eventually(session3).Should(Exit(128 + 15))167			})168			It("should not wait for exit", func() {169				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)170				Î©(err).ShouldNot(HaveOccurred())171				Terminate()172				Î©(session1).ShouldNot(Exit(), "Should not exit immediately...")173			})174		})175		Describe("terminateAndWait", func() {176			It("should terminate all the started sessions, and wait for them to exit", func() {177				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)178				Î©(err).ShouldNot(HaveOccurred())179				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)180				Î©(err).ShouldNot(HaveOccurred())181				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)182				Î©(err).ShouldNot(HaveOccurred())183				TerminateAndWait()184				Î©(session1).Should(Exit(128+15), "Should have exited")185				Î©(session2).Should(Exit(128+15), "Should have exited")186				Î©(session3).Should(Exit(128+15), "Should have exited")187			})188		})189		Describe("signal", func() {190			It("should signal all the started sessions", func() {191				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)192				Î©(err).ShouldNot(HaveOccurred())193				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)194				Î©(err).ShouldNot(HaveOccurred())195				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)196				Î©(err).ShouldNot(HaveOccurred())197				Signal(syscall.SIGABRT)198				Eventually(session1).Should(Exit(128 + 6))199				Eventually(session2).Should(Exit(128 + 6))200				Eventually(session3).Should(Exit(128 + 6))201			})202			It("should not wait", func() {203				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)204				Î©(err).ShouldNot(HaveOccurred())205				Signal(syscall.SIGABRT)206				Î©(session1).ShouldNot(Exit(), "Should not exit immediately...")207			})208		})209		Describe("interrupt", func() {210			It("should interrupt all the started sessions, and not wait", func() {211				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)212				Î©(err).ShouldNot(HaveOccurred())213				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)214				Î©(err).ShouldNot(HaveOccurred())215				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)216				Î©(err).ShouldNot(HaveOccurred())217				Interrupt()218				Eventually(session1).Should(Exit(128 + 2))219				Eventually(session2).Should(Exit(128 + 2))220				Eventually(session3).Should(Exit(128 + 2))221			})222			It("should not wait", func() {223				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)224				Î©(err).ShouldNot(HaveOccurred())225				Interrupt()226				Î©(session1).ShouldNot(Exit(), "Should not exit immediately...")227			})228		})229	})230	Context("when the command exits", func() {231		It("should close the buffers", func() {232			Eventually(session).Should(Exit())233			Î©(session.Out.Closed()).Should(BeTrue())234			Î©(session.Err.Closed()).Should(BeTrue())235			Î©(session.Out).Should(Say("We've done the impossible, and that makes us mighty"))236		})237		var So = It238		So("this means that eventually should short circuit", func() {239			t := time.Now()240			failures := InterceptGomegaFailures(func() {241				Eventually(session).Should(Say("blah blah blah blah blah"))242			})243			Î©(time.Since(t)).Should(BeNumerically("<=", 500*time.Millisecond))244			Î©(failures).Should(HaveLen(1))245		})246	})247	Context("when wrapping out and err", func() {248		BeforeEach(func() {249			outWriter = NewBuffer()250			errWriter = NewBuffer()251		})252		It("should route to both the provided writers and the gbytes buffers", func() {253			Eventually(session.Out).Should(Say("We've done the impossible, and that makes us mighty"))254			Eventually(session.Err).Should(Say("Ah, curse your sudden but inevitable betrayal!"))255			Î©(outWriter.Contents()).Should(ContainSubstring("We've done the impossible, and that makes us mighty"))256			Î©(errWriter.Contents()).Should(ContainSubstring("Ah, curse your sudden but inevitable betrayal!"))257			Eventually(session).Should(Exit())258			Î©(outWriter.Contents()).Should(Equal(session.Out.Contents()))259			Î©(errWriter.Contents()).Should(Equal(session.Err.Contents()))260		})261	})262	Describe("when the command fails to start", func() {263		It("should return an error", func() {264			_, err := Start(exec.Command("agklsjdfas"), nil, nil)265			Î©(err).Should(HaveOccurred())266		})267	})268})...

Using AI Code Generation

1import (2func main() {3	gomega.NewGomegaWithT(ginkgo.GinkgoT()).Expect(1).To(gomega.Equal(1))4	fmt.Println("Hello World!")5}6import (7func main() {8	gomega.NewGomegaWithT(ginkgo.GinkgoT()).Expect(1).To(gomega.Equal(1))9	fmt.Println("Hello World!")10}11import (12func main() {13	gomega.NewGomegaWithT(ginkgo.GinkgoT()).Expect(1).To(gomega.Equal(1))14	fmt.Println("Hello World!")15}16import (17func main() {18	gomega.NewGomegaWithT(ginkgo.GinkgoT()).Expect(1).To(gomega.Equal(1))19	fmt.Println("Hello World!")20}21import (22func main() {23	gomega.NewGomegaWithT(ginkgo.GinkgoT()).Expect(1).To(gomega.Equal(1))24	fmt.Println("Hello World!")25}26import (27func main() {28	gomega.NewGomegaWithT(ginkgo.GinkgoT()).Expect(1).To(gomega.Equal(1))29	fmt.Println("Hello World!")30}

Using AI Code Generation

1import (2func TestGinkgo(t *testing.T) {3    gomega.RegisterFailHandler(ginkgo.Fail)4    ginkgo.RunSpecs(t, "Ginkgo Suite")5}6var _ = ginkgo.Describe("Ginkgo", func() {7    ginkgo.It("should be able to use ginkgo", func() {8        fmt.Println("Hello World")9    })10})11import (12func TestGomega(t *testing.T) {13    gomega.RegisterFailHandler(ginkgo.Fail)14    ginkgo.RunSpecs(t, "Gomega Suite")15}16var _ = ginkgo.Describe("Gomega", func() {17    gomega.It("should be able to use gomega", func() {18        fmt.Println("Hello World")19    })20})21import (22func TestGomega(t *testing.T) {23    gomega.RegisterFailHandler(ginkgo.Fail)24    ginkgo.RunSpecs(t, "Gomega Suite")25}26var _ = ginkgo.Describe("Gomega", func() {27    gomega.It("should be able to use gomega", func() {28        fmt.Println("Hello World")29    })30})31import (32func TestGomega(t *testing.T) {33    gomega.RegisterFailHandler(ginkgo.Fail)34    ginkgo.RunSpecs(t, "Gomega Suite")35}36var _ = ginkgo.Describe("Gomega", func() {37    gomega.It("should be able to use gomega", func() {

Using AI Code Generation

1import (2func Test(t *testing.T) {3    gomega.RegisterFailHandler(ginkgo.Fail)4    ginkgo.RunSpecs(t, "My Suite")5}6var _ = ginkgo.Describe("My Suite", func() {7    ginkgo.It("should work", func() {8        fmt.Println("Hello World")9    })10})11import (12func Test(t *testing.T) {13    gomega.RegisterFailHandler(ginkgo.Fail)14    ginkgo.RunSpecs(t, "My Suite")15}16var _ = ginkgo.Describe("My Suite", func() {17    ginkgo.It("should work", func() {18        fmt.Println("Hello World")19    })20})21import (22func Test(t *testing.T) {23    gomega.RegisterFailHandler(ginkgo.Fail)24    ginkgo.RunSpecs(t, "My Suite")25}26var _ = ginkgo.Describe("My Suite", func() {27    ginkgo.It("should work", func() {28        fmt.Println("Hello World")29    })30})31import (32func Test(t *testing.T) {33    gomega.RegisterFailHandler(ginkgo.Fail)34    ginkgo.RunSpecs(t, "My Suite")35}36var _ = ginkgo.Describe("My Suite", func() {37    ginkgo.It("should work", func() {38        fmt.Println("Hello World")39    })40})

Using AI Code Generation

1import (2func main() {3    fmt.Println("Hello World")4    gomega.NewGomegaWithT(ginkgo.GinkgoT()).Expect(1).To(gomega.Equal(1))5}6import (7func main() {8    fmt.Println("Hello World")9    gomega.NewGomegaWithT(ginkgo.GinkgoT()).Expect(1).To(gomega.Equal(1))10}

Using AI Code Generation

1import (2func Test1(t *testing.T) {3	gomega.RegisterFailHandler(ginkgo.Fail)4	ginkgo.RunSpecs(t, "Test1")5}6var _ = ginkgo.Describe("Test1", func() {7	ginkgo.It("Test1", func() {8		fmt.Println("Test1")9	})10})11var _ = ginkgo.Describe("Test2", func() {12	ginkgo.It("Test2", func() {13		fmt.Println("Test2")14	})15})16var _ = ginkgo.Describe("Test3", func() {17	ginkgo.It("Test3", func() {18		fmt.Println("Test3")19	})20})21import (22func Test2(t *testing.T) {23	gomega.RegisterFailHandler(ginkgo.Fail)24	ginkgo.RunSpecs(t, "Test2")25}26var _ = ginkgo.Describe("Test4", func() {27	ginkgo.It("Test4", func() {28		fmt.Println("Test4")29	})30})31var _ = ginkgo.Describe("Test5", func() {32	ginkgo.It("Test5", func() {33		fmt.Println("Test5")34	})35})36var _ = ginkgo.Describe("Test6", func() {37	ginkgo.It("Test6", func() {38		fmt.Println("Test6")39	})40})41import (42func Test3(t *testing.T) {43	gomega.RegisterFailHandler(ginkgo.Fail)44	ginkgo.RunSpecs(t, "Test3")45}46var _ = ginkgo.Describe("Test7", func() {47	ginkgo.It("Test7

Using AI Code Generation

1ginkgo.It("should pass", func() {2    gomega.Expect(true).To(gomega.BeTrue())3})4ginkgo.It("should pass", func() {5    gomega.Expect(true).To(gomega.BeTrue())6})7ginkgo.It("should pass", func() {8    gomega.Expect(true).To(gomega.BeTrue())9})10ginkgo.It("should pass", func() {11    gomega.Expect(true).To(gomega.BeTrue())12})13ginkgo.It("should pass", func() {14    gomega.Expect(true).To(gomega.BeTrue())15})16ginkgo.It("should pass", func() {17    gomega.Expect(true).To(gomega.BeTrue())18})19ginkgo.It("should pass", func() {20    gomega.Expect(true).To(gomega.BeTrue())21})22ginkgo.It("should pass", func() {23    gomega.Expect(true).To(gomega.BeTrue())24})25ginkgo.It("should pass", func() {26    gomega.Expect(true).To(gomega.BeTrue())27})28ginkgo.It("should pass", func() {29    gomega.Expect(true).To(gomega.BeTrue())30})31ginkgo.It("should pass", func() {32    gomega.Expect(true).To(gomega.BeTrue())33})34ginkgo.It("should pass", func() {35    gomega.Expect(true).To(gomega.BeTrue())36})

Using AI Code Generation

1var _ = Describe("1", func() {2    Context("1", func() {3        It("1", func() {4            Expect(1).To(Equal(1))5        })6    })7})8var _ = Describe("2", func() {9    Context("2", func() {10        It("2", func() {11            Expect(2).To(Equal(2))12        })13    })14})15var _ = Describe("3", func() {16    Context("3", func() {17        It("3", func() {18            Expect(3).To(Equal(3))19        })20    })21})22var _ = Describe("4", func() {23    Context("4", func() {24        It("4", func() {25            Expect(4).To(Equal(4))26        })27    })28})29var _ = Describe("5", func() {30    Context("5", func() {31        It("5", func() {32            Expect(5).To(Equal(5))33        })34    })35})36var _ = Describe("6", func() {37    Context("6", func() {38        It("6", func() {39            Expect(6).To(Equal(6))40        })41    })42})43var _ = Describe("7", func() {44    Context("7", func() {45        It("7", func() {46            Expect(7).To(Equal(7))47        })48    })49})50var _ = Describe("8", func() {51    Context("8", func() {52        It("8", func() {53            Expect(8).To(Equal(8))54        })55    })56})57var _ = Describe("9", func() {58    Context("9", func() {

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello, playground")4	ginkgo.It("should be true", func() {5		gomega.Expect(true).To(gomega.BeTrue())6	})7}8import (9func main() {10	fmt.Println("Hello, playground")11	ginkgo.It("should be true", func() {12		gomega.Expect(true).To(gomega.BeTrue())13	})14}15import (16func main() {17	fmt.Println("Hello, playground")18	ginkgo.It("should be true", func() {19		gomega.Expect(true).To(gomega.BeTrue())20	})21}22import (23func main() {24	fmt.Println("Hello, playground")25	ginkgo.It("should be true", func() {26		gomega.Expect(true).To(gomega.BeTrue())27	})28}29import (30func main() {31	fmt.Println("Hello, playground")32	ginkgo.It("should be true", func() {33		gomega.Expect(true).To(gomega.BeTrue())34	})35}36import (37func main() {38	fmt.Println("Hello, playground")39	ginkgo.It("should be true", func() {40		gomega.Expect(true).To(gomega.BeTrue())41	})42}

Using AI Code Generation

1import (2func main() {3	g := ginkgo.NewGinkgo()4	g.It("should be able to add two numbers", func() {5		g.Expect(1 + 1).ToEqual(2)6	})7}8import (9type Ginkgo struct {10}11func NewGinkgo() *Ginkgo {12	return &Ginkgo{}13}14func (g *Ginkgo) It(description string, test func()) {15	fmt.Println("It", description)16	test()17}18func (g *Ginkgo) Expect(actual interface{}) *Expectation {19	return &Expectation{actual}20}21import (22type Expectation struct {23	actual interface{}24}25func (e *Expectation) ToEqual(expected interface{}) {26	if reflect.DeepEqual(e.actual, expected) {27		fmt.Println("Passed")28	} else {29		fmt.Println("Failed")30	}31}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.