How to use failureForLeafNodeWithMessage method of internal Package

Best Ginkgo code snippet using internal.failureForLeafNodeWithMessage

suite.go

Source:suite.go

...445			}446		}447	}448	if err != nil && !suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {449		suite.currentSpecReport.State, suite.currentSpecReport.Failure = types.SpecStateFailed, suite.failureForLeafNodeWithMessage(node, err.Error())450	}451	suite.currentSpecReport.EndTime = time.Now()452	suite.currentSpecReport.RunTime = suite.currentSpecReport.EndTime.Sub(suite.currentSpecReport.StartTime)453	suite.currentSpecReport.CapturedGinkgoWriterOutput = string(suite.writer.Bytes())454	suite.currentSpecReport.CapturedStdOutErr += suite.outputInterceptor.StopInterceptingAndReturnOutput()455	return456}457func (suite *Suite) runReportAfterSuiteNode(node Node, report types.Report) {458	suite.writer.Truncate()459	suite.outputInterceptor.StartInterceptingOutput()460	suite.currentSpecReport.StartTime = time.Now()461	if suite.config.ParallelTotal > 1 {462		aggregatedReport, err := suite.client.BlockUntilAggregatedNonprimaryProcsReport()463		if err != nil {464			suite.currentSpecReport.State, suite.currentSpecReport.Failure = types.SpecStateFailed, suite.failureForLeafNodeWithMessage(node, err.Error())465			return466		}467		report = report.Add(aggregatedReport)468	}469	node.Body = func() { node.ReportAfterSuiteBody(report) }470	suite.interruptHandler.SetInterruptPlaceholderMessage(formatter.Fiw(0, formatter.COLS,471		"{{yellow}}Ginkgo received an interrupt signal but is currently running a ReportAfterSuite node.  To avoid an invalid report the ReportAfterSuite node will not be interrupted.{{/}}\n\n{{bold}}The running ReportAfterSuite node is at:\n%s.{{/}}",472		node.CodeLocation,473	))474	suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, nil, "")475	suite.interruptHandler.ClearInterruptPlaceholderMessage()476	suite.currentSpecReport.EndTime = time.Now()477	suite.currentSpecReport.RunTime = suite.currentSpecReport.EndTime.Sub(suite.currentSpecReport.StartTime)478	suite.currentSpecReport.CapturedGinkgoWriterOutput = string(suite.writer.Bytes())479	suite.currentSpecReport.CapturedStdOutErr = suite.outputInterceptor.StopInterceptingAndReturnOutput()480	return481}482func (suite *Suite) runNode(node Node, interruptChannel chan interface{}, text string) (types.SpecState, types.Failure) {483	if node.NodeType.Is(types.NodeTypeCleanupAfterEach | types.NodeTypeCleanupAfterAll | types.NodeTypeCleanupAfterSuite) {484		suite.cleanupNodes = suite.cleanupNodes.WithoutNode(node)485	}486	suite.currentNode = node487	defer func() {488		suite.currentNode = Node{}489	}()490	if suite.config.EmitSpecProgress {491		if text == "" {492			text = "TOP-LEVEL"493		}494		s := fmt.Sprintf("[%s] %s\n  %s\n", node.NodeType.String(), text, node.CodeLocation.String())495		suite.writer.Write([]byte(s))496	}497	var failure types.Failure498	failure.FailureNodeType, failure.FailureNodeLocation = node.NodeType, node.CodeLocation499	if node.NodeType.Is(types.NodeTypeIt) || node.NodeType.Is(types.NodeTypesForSuiteLevelNodes) {500		failure.FailureNodeContext = types.FailureNodeIsLeafNode501	} else if node.NestingLevel <= 0 {502		failure.FailureNodeContext = types.FailureNodeAtTopLevel503	} else {504		failure.FailureNodeContext, failure.FailureNodeContainerIndex = types.FailureNodeInContainer, node.NestingLevel-1505	}506	outcomeC := make(chan types.SpecState)507	failureC := make(chan types.Failure)508	go func() {509		finished := false510		defer func() {511			if e := recover(); e != nil || !finished {512				suite.failer.Panic(types.NewCodeLocationWithStackTrace(2), e)513			}514			outcome, failureFromRun := suite.failer.Drain()515			outcomeC <- outcome516			failureC <- failureFromRun517		}()518		node.Body()519		finished = true520	}()521	select {522	case outcome := <-outcomeC:523		failureFromRun := <-failureC524		if outcome == types.SpecStatePassed {525			return outcome, types.Failure{}526		}527		failure.Message, failure.Location, failure.ForwardedPanic = failureFromRun.Message, failureFromRun.Location, failureFromRun.ForwardedPanic528		return outcome, failure529	case <-interruptChannel:530		failure.Message, failure.Location = suite.interruptHandler.InterruptMessageWithStackTraces(), node.CodeLocation531		return types.SpecStateInterrupted, failure532	}533}534func (suite *Suite) failureForLeafNodeWithMessage(node Node, message string) types.Failure {535	return types.Failure{536		Message:             message,537		Location:            node.CodeLocation,538		FailureNodeContext:  types.FailureNodeIsLeafNode,539		FailureNodeType:     node.NodeType,540		FailureNodeLocation: node.CodeLocation,541	}542}543func max(a, b int) int {544	if a > b {545		return a546	}547	return b548}...

group.go

Source:group.go

...113	if g.suite.interruptHandler.Status().Interrupted || g.suite.skipAll {114		return types.SpecStateSkipped, types.Failure{}115	}116	if !g.succeeded {117		return types.SpecStateSkipped, g.suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),118			"Spec skipped because an earlier spec in an ordered container failed")119	}120	beforeOncePairs := g.runOncePairs[spec.SubjectID()].withType(types.NodeTypeBeforeAll | types.NodeTypeBeforeEach | types.NodeTypeJustBeforeEach)121	for _, pair := range beforeOncePairs {122		if g.runOnceTracker[pair].Is(types.SpecStateSkipped) {123			return types.SpecStateSkipped, g.suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),124				fmt.Sprintf("Spec skipped because Skip() was called in %s", pair.nodeType))125		}126	}127	if g.suite.config.DryRun {128		return types.SpecStatePassed, types.Failure{}129	}130	return g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure131}132func (g *group) isLastSpecWithPair(specID uint, pair runOncePair) bool {133	lastSpecID := uint(0)134	for idx := range g.specs {135		if g.specs[idx].Skip {136			continue137		}138		sID := g.specs[idx].SubjectID()139		if g.runOncePairs[sID].hasRunOncePair(pair) {140			lastSpecID = sID141		}142	}143	return lastSpecID == specID144}145func (g *group) attemptSpec(isFinalAttempt bool, spec Spec) {146	interruptStatus := g.suite.interruptHandler.Status()147	pairs := g.runOncePairs[spec.SubjectID()]148	nodes := spec.Nodes.WithType(types.NodeTypeBeforeAll)149	nodes = append(nodes, spec.Nodes.WithType(types.NodeTypeBeforeEach)...).SortedByAscendingNestingLevel()150	nodes = append(nodes, spec.Nodes.WithType(types.NodeTypeJustBeforeEach).SortedByAscendingNestingLevel()...)151	nodes = append(nodes, spec.Nodes.FirstNodeWithType(types.NodeTypeIt))152	terminatingNode, terminatingPair := Node{}, runOncePair{}153	for _, node := range nodes {154		oncePair := pairs.runOncePairFor(node.ID)155		if !oncePair.isZero() && g.runOnceTracker[oncePair].Is(types.SpecStatePassed) {156			continue157		}158		g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure = g.suite.runNode(node, interruptStatus.Channel, spec.Nodes.BestTextFor(node))159		g.suite.currentSpecReport.RunTime = time.Since(g.suite.currentSpecReport.StartTime)160		if !oncePair.isZero() {161			g.runOnceTracker[oncePair] = g.suite.currentSpecReport.State162		}163		if g.suite.currentSpecReport.State != types.SpecStatePassed {164			terminatingNode, terminatingPair = node, oncePair165			break166		}167	}168	afterNodeWasRun := map[uint]bool{}169	includeDeferCleanups := false170	for {171		nodes := spec.Nodes.WithType(types.NodeTypeAfterEach)172		nodes = append(nodes, spec.Nodes.WithType(types.NodeTypeAfterAll)...).SortedByDescendingNestingLevel()173		nodes = append(spec.Nodes.WithType(types.NodeTypeJustAfterEach).SortedByDescendingNestingLevel(), nodes...)174		if !terminatingNode.IsZero() {175			nodes = nodes.WithinNestingLevel(terminatingNode.NestingLevel)176		}177		if includeDeferCleanups {178			nodes = append(nodes, g.suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterEach).Reverse()...)179			nodes = append(nodes, g.suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterAll).Reverse()...)180		}181		nodes = nodes.Filter(func(node Node) bool {182			if afterNodeWasRun[node.ID] {183				//this node has already been run on this attempt, don't rerun it184				return false185			}186			pair := runOncePair{}187			switch node.NodeType {188			case types.NodeTypeCleanupAfterEach, types.NodeTypeCleanupAfterAll:189				// check if we were generated in an AfterNode that has already run190				if afterNodeWasRun[node.NodeIDWhereCleanupWasGenerated] {191					return true // we were, so we should definitely run this cleanup now192				}193				// looks like this cleanup nodes was generated by a before node or it.194				// the run-once status of a cleanup node is governed by the run-once status of its generator195				pair = pairs.runOncePairFor(node.NodeIDWhereCleanupWasGenerated)196			default:197				pair = pairs.runOncePairFor(node.ID)198			}199			if pair.isZero() {200				// this node is not governed by any run-once policy, we should run it201				return true202			}203			// it's our last chance to run if we're the last spec for our oncePair204			isLastSpecWithPair := g.isLastSpecWithPair(spec.SubjectID(), pair)205			switch g.suite.currentSpecReport.State {206			case types.SpecStatePassed: //this attempt is passing...207				return isLastSpecWithPair //...we should run-once if we'this is our last chance208			case types.SpecStateSkipped: //the spec was skipped by the user...209				if isLastSpecWithPair {210					return true //...we're the last spec, so we should run the AfterNode211				}212				if !terminatingPair.isZero() && terminatingNode.NestingLevel == node.NestingLevel {213					return true //...or, a run-once node at our nesting level was skipped which means this is our last chance to run214				}215			case types.SpecStateFailed, types.SpecStatePanicked: // the spec has failed...216				if isFinalAttempt {217					return true //...if this was the last attempt then we're the last spec to run and so the AfterNode should run218				}219				if !terminatingPair.isZero() { // ...and it failed in a run-once.  which will be running again220					if node.NodeType.Is(types.NodeTypeCleanupAfterEach | types.NodeTypeCleanupAfterAll) {221						return terminatingNode.ID == node.NodeIDWhereCleanupWasGenerated // we should run this node if we're a clean-up generated by it222					} else {223						return terminatingNode.NestingLevel == node.NestingLevel // ...or if we're at the same nesting level224					}225				}226			case types.SpecStateInterrupted, types.SpecStateAborted: // ...we've been interrupted and/or aborted227				return true //...that means the test run is over and we should clean up the stack.  Run the AfterNode228			}229			return false230		})231		if len(nodes) == 0 && includeDeferCleanups {232			break233		}234		for _, node := range nodes {235			afterNodeWasRun[node.ID] = true236			state, failure := g.suite.runNode(node, g.suite.interruptHandler.Status().Channel, spec.Nodes.BestTextFor(node))237			g.suite.currentSpecReport.RunTime = time.Since(g.suite.currentSpecReport.StartTime)238			if g.suite.currentSpecReport.State == types.SpecStatePassed || state == types.SpecStateAborted {239				g.suite.currentSpecReport.State = state240				g.suite.currentSpecReport.Failure = failure241			}242		}243		includeDeferCleanups = true244	}245}246func (g *group) run(specs Specs) {247	g.specs = specs248	for _, spec := range g.specs {249		g.runOncePairs[spec.SubjectID()] = runOncePairsForSpec(spec)250	}251	for _, spec := range g.specs {252		g.suite.currentSpecReport = g.initialReportForSpec(spec)253		g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure = g.evaluateSkipStatus(spec)254		g.suite.reporter.WillRun(g.suite.currentSpecReport)255		g.suite.reportEach(spec, types.NodeTypeReportBeforeEach)256		skip := g.suite.config.DryRun || g.suite.currentSpecReport.State.Is(types.SpecStateFailureStates|types.SpecStateSkipped|types.SpecStatePending)257		g.suite.currentSpecReport.StartTime = time.Now()258		if !skip {259			maxAttempts := max(1, spec.FlakeAttempts())260			if g.suite.config.FlakeAttempts > 0 {261				maxAttempts = g.suite.config.FlakeAttempts262			}263			for attempt := 0; attempt < maxAttempts; attempt++ {264				g.suite.currentSpecReport.NumAttempts = attempt + 1265				g.suite.writer.Truncate()266				g.suite.outputInterceptor.StartInterceptingOutput()267				if attempt > 0 {268					fmt.Fprintf(g.suite.writer, "\nGinkgo: Attempt #%d Failed.  Retrying...\n", attempt)269				}270				g.attemptSpec(attempt == maxAttempts-1, spec)271				g.suite.currentSpecReport.EndTime = time.Now()272				g.suite.currentSpecReport.RunTime = g.suite.currentSpecReport.EndTime.Sub(g.suite.currentSpecReport.StartTime)273				g.suite.currentSpecReport.CapturedGinkgoWriterOutput += string(g.suite.writer.Bytes())274				g.suite.currentSpecReport.CapturedStdOutErr += g.suite.outputInterceptor.StopInterceptingAndReturnOutput()275				if g.suite.currentSpecReport.State.Is(types.SpecStatePassed | types.SpecStateSkipped | types.SpecStateAborted | types.SpecStateInterrupted) {276					break277				}278			}279		}280		g.suite.reportEach(spec, types.NodeTypeReportAfterEach)281		g.suite.processCurrentSpecReport()282		if g.suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {283			g.succeeded = false284		}285		g.suite.currentSpecReport = types.SpecReport{}286	}287}288func (g *group) oldRun(specs Specs) {289	var suite = g.suite290	nodeState := map[uint]types.SpecState{}291	groupSucceeded := true292	indexOfLastSpecContainingNodeID := func(id uint) int {293		lastIdx := -1294		for idx := range specs {295			if specs[idx].Nodes.ContainsNodeID(id) && !specs[idx].Skip {296				lastIdx = idx297			}298		}299		return lastIdx300	}301	for i, spec := range specs {302		suite.currentSpecReport = types.SpecReport{303			ContainerHierarchyTexts:     spec.Nodes.WithType(types.NodeTypeContainer).Texts(),304			ContainerHierarchyLocations: spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),305			ContainerHierarchyLabels:    spec.Nodes.WithType(types.NodeTypeContainer).Labels(),306			LeafNodeLocation:            spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,307			LeafNodeType:                types.NodeTypeIt,308			LeafNodeText:                spec.FirstNodeWithType(types.NodeTypeIt).Text,309			LeafNodeLabels:              []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),310			ParallelProcess:             suite.config.ParallelProcess,311			IsSerial:                    spec.Nodes.HasNodeMarkedSerial(),312			IsInOrderedContainer:        !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),313		}314		skip := spec.Skip315		if spec.Nodes.HasNodeMarkedPending() {316			skip = true317			suite.currentSpecReport.State = types.SpecStatePending318		} else {319			if suite.interruptHandler.Status().Interrupted || suite.skipAll {320				skip = true321			}322			if !groupSucceeded {323				skip = true324				suite.currentSpecReport.Failure = suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),325					"Spec skipped because an earlier spec in an ordered container failed")326			}327			for _, node := range spec.Nodes.WithType(types.NodeTypeBeforeAll) {328				if nodeState[node.ID] == types.SpecStateSkipped {329					skip = true330					suite.currentSpecReport.Failure = suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),331						"Spec skipped because Skip() was called in BeforeAll")332					break333				}334			}335			if skip {336				suite.currentSpecReport.State = types.SpecStateSkipped337			}338		}339		if suite.config.DryRun && !skip {340			skip = true341			suite.currentSpecReport.State = types.SpecStatePassed342		}343		suite.reporter.WillRun(suite.currentSpecReport)344		//send the spec report to any attached ReportBeforeEach blocks - this will update suite.currentSpecReport if failures occur in these blocks...

failureForLeafNodeWithMessage

Using AI Code Generation

1import (2type User struct {3}4func main() {5	user := User{6	}7	validate := validator.New()8	err := validate.Struct(user)9	if err != nil {10		fmt.Println(err.(validator.ValidationErrors)[0].FailureForLeafNodeWithMessage("failed"))11	}12}

failureForLeafNodeWithMessage

Using AI Code Generation

1import (2func main() {3	ginkgo.RunSpecs(t, "My Suite")4}5var _ = ginkgo.Describe("My Suite", func() {6	ginkgo.It("should do something", func() {7		gomega.Expect(true).To(gomega.BeTrue())8	})9})10import (11func main() {12	ginkgo.RunSpecs(t, "My Suite")13}14var _ = ginkgo.Describe("My Suite", func() {15	ginkgo.It("should do something", func() {16		gomega.Expect(true).To(gomega.BeTrue())17	})18})19import (

failureForLeafNodeWithMessage

Using AI Code Generation

1func (n *Node) failureForLeafNodeWithMessage(message string) {2    n.failureForLeafNode(message)3}4func (n *Node) failureForLeafNode(message string) {5}6func (n *Node) failureForLeafNode(message string) {7}8func (n *Node) failureForLeafNode(message string) {9}10func (n *Node) failureForLeafNode(message string) {11}12func (n *Node) failureForLeafNode(message string) {13}14func (n *Node) failureForLeafNode(message string) {15}16func (n *Node) failureForLeafNode(message string) {17}18func (n *Node) failureForLeafNode(message string) {19}20func (n *Node) failureForLeafNode(message string) {21}22func (n *Node) failureForLeafNode(message string) {23}24func (n *Node) failureForLeafNode(message string) {25}26func (n *Node) failureForLeafNode(message string) {27}28func (n *Node) failureForLeafNode(message string) {29}30func (n *Node) failureForLeafNode(message string) {31}32func (n *Node) failureForLeafNode(message string) {33}34func (n *Node) failureForLeafNode(message string) {35}

failureForLeafNodeWithMessage

Using AI Code Generation

1func main() {2    err = internal.failureForLeafNodeWithMessage("error message")3    fmt.Println(err)4}5func main() {6    err = internal.failureForLeafNodeWithMessage("error message")7    fmt.Println(err)8}9func main() {10    err = internal.failureForLeafNodeWithMessage("error message")11    fmt.Println(err)12}13func main() {14    err = internal.failureForLeafNodeWithMessage("error message")15    fmt.Println(err)16}17func main() {

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.