vendor: Update vendor logic

vendor/github.com/onsi/ginkgo/.gitignore

@@ -4,4 +4,4 @@ tmp/**/*
 *.coverprofile
 .vscode
 .idea/
-*.log
+*.log

vendor/github.com/onsi/ginkgo/.travis.yml

@@ -1,10 +1,9 @@
 language: go
 go:
-  - 1.6.x
-  - 1.7.x
-  - 1.8.x
-  - 1.9.x
   - 1.10.x
+  - 1.11.x
+  - 1.12.x
+  - tip
 
 install:
   - go get -v -t ./...
@@ -13,4 +12,4 @@ install:
   - go install github.com/onsi/ginkgo/ginkgo
   - export PATH=$PATH:$HOME/gopath/bin
 
-script: $HOME/gopath/bin/ginkgo -r --randomizeAllSpecs --randomizeSuites --race --trace  && go vet
+script: $HOME/gopath/bin/ginkgo -r --randomizeAllSpecs --randomizeSuites --race --trace && go vet

vendor/github.com/onsi/ginkgo/CHANGELOG.md

@@ -1,3 +1,49 @@
+## 1.10.1
+
+## Fixes
+- stack backtrace: fix skipping (#600) [2a4c0bd]
+
+## 1.10.0
+
+## Fixes
+- stack backtrace: fix alignment and skipping [66915d6]
+- fix typo in documentation [8f97b93]
+
+## 1.9.0
+
+## Features
+- Option to print output into report, when tests have passed [0545415]
+
+## Fixes
+- Fixed typos in comments [0ecbc58]
+- gofmt code [a7f8bfb]
+- Simplify code [7454d00]
+- Simplify concatenation, incrementation and function assignment [4825557]
+- Avoid unnecessary conversions [9d9403c]
+- JUnit: include more detailed information about panic [19cca4b]
+- Print help to stdout when the user asks for help [4cb7441]
+
+
+## 1.8.0
+
+### New Features
+- allow config of the vet flag for `go test` (#562) [3cd45fa]
+- Support projects using go modules [d56ee76]
+
+### Fixes and Minor Improvements
+- chore(godoc): fixes typos in Measurement funcs [dbaca8e]
+- Optimize focus to avoid allocations [f493786]
+- Ensure generated test file names are underscored [505cc35]
+
+## 1.7.0
+
+### New Features
+- Add JustAfterEach (#484) [0d4f080]
+
+### Fixes
+- Correctly round suite time in junit reporter [2445fc1]
+- Avoid using -i argument to go test for Golang 1.10+ [46bbc26]
+
 ## 1.6.0
 
 ### New Features

vendor/github.com/onsi/ginkgo/config/config.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 )
 
-const VERSION = "1.6.0"
+const VERSION = "1.10.1"
 
 type GinkgoConfigType struct {
 	RandomSeed         int64
@@ -52,13 +52,14 @@ type DefaultReporterConfigType struct {
 	Succinct          bool
 	Verbose           bool
 	FullTrace         bool
+	ReportPassed      bool
 }
 
 var DefaultReporterConfig = DefaultReporterConfigType{}
 
 func processPrefix(prefix string) string {
 	if prefix != "" {
-		prefix = prefix + "."
+		prefix += "."
 	}
 	return prefix
 }
@@ -98,6 +99,7 @@ func Flags(flagSet *flag.FlagSet, prefix string, includeParallelFlags bool) {
 	flagSet.BoolVar(&(DefaultReporterConfig.Verbose), prefix+"v", false, "If set, default reporter print out all specs as they begin.")
 	flagSet.BoolVar(&(DefaultReporterConfig.Succinct), prefix+"succinct", false, "If set, default reporter prints out a very succinct report")
 	flagSet.BoolVar(&(DefaultReporterConfig.FullTrace), prefix+"trace", false, "If set, default reporter prints out the full stack trace when a failure occurs")
+	flagSet.BoolVar(&(DefaultReporterConfig.ReportPassed), prefix+"reportPassed", false, "If set, default reporter prints out captured output of passed tests.")
 }
 
 func BuildFlagArgs(prefix string, ginkgo GinkgoConfigType, reporter DefaultReporterConfigType) []string {
@@ -196,5 +198,9 @@ func BuildFlagArgs(prefix string, ginkgo GinkgoConfigType, reporter DefaultRepor
 		result = append(result, fmt.Sprintf("--%strace", prefix))
 	}
 
+	if reporter.ReportPassed {
+		result = append(result, fmt.Sprintf("--%sreportPassed", prefix))
+	}
+
 	return result
 }

vendor/github.com/onsi/ginkgo/ginkgo_dsl.go

@@ -283,7 +283,7 @@ func GinkgoRecover() {
 //BeforeEach, AfterEach, JustBeforeEach, It, and Measurement blocks.
 //
 //In addition you can nest Describe, Context and When blocks.  Describe, Context and When blocks are functionally
-//equivalent.  The difference is purely semantic -- you typical Describe the behavior of an object
+//equivalent.  The difference is purely semantic -- you typically Describe the behavior of an object
 //or method and, within that Describe, outline a number of Contexts and Whens.
 func Describe(text string, body func()) bool {
 	globalSuite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))
@@ -457,13 +457,13 @@ func FMeasure(text string, body interface{}, samples int) bool {
 	return true
 }
 
-//You can mark Maeasurements as pending using PMeasure
+//You can mark Measurements as pending using PMeasure
 func PMeasure(text string, _ ...interface{}) bool {
 	globalSuite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
 	return true
 }
 
-//You can mark Maeasurements as pending using XMeasure
+//You can mark Measurements as pending using XMeasure
 func XMeasure(text string, _ ...interface{}) bool {
 	globalSuite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
 	return true
@@ -499,7 +499,7 @@ func AfterSuite(body interface{}, timeout ...float64) bool {
 //until that node is done before running.
 //
 //SynchronizedBeforeSuite accomplishes this by taking *two* function arguments.  The first is only run on parallel node #1.  The second is
-//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)
+//run on all nodes, but *only* after the first function completes successfully.  Ginkgo also makes it possible to send data from the first function (on Node 1)
 //to the second function (on all the other nodes).
 //
 //The functions have the following signatures.  The first function (which only runs on node 1) has the signature:
@@ -590,6 +590,16 @@ func JustBeforeEach(body interface{}, timeout ...float64) bool {
 	return true
 }
 
+//JustAfterEach blocks are run after It blocks but *before* all AfterEach blocks.  For more details,
+//read the [documentation](http://onsi.github.io/ginkgo/#separating_creation_and_configuration_)
+//
+//Like It blocks, JustAfterEach blocks can be made asynchronous by providing a body function that accepts
+//a Done channel
+func JustAfterEach(body interface{}, timeout ...float64) bool {
+	globalSuite.PushJustAfterEachNode(body, codelocation.New(1), parseTimeout(timeout...))
+	return true
+}
+
 //AfterEach blocks are run after It blocks.   When multiple AfterEach blocks are defined in nested
 //Describe and Context blocks the innermost AfterEach blocks are run first.
 //

vendor/github.com/onsi/ginkgo/internal/codelocation/code_location.go

@@ -11,19 +11,35 @@ import (
 
 func New(skip int) types.CodeLocation {
 	_, file, line, _ := runtime.Caller(skip + 1)
-	stackTrace := PruneStack(string(debug.Stack()), skip)
+	stackTrace := PruneStack(string(debug.Stack()), skip+1)
 	return types.CodeLocation{FileName: file, LineNumber: line, FullStackTrace: stackTrace}
 }
 
+// PruneStack removes references to functions that are internal to Ginkgo
+// and the Go runtime from a stack string and a certain number of stack entries
+// at the beginning of the stack. The stack string has the format
+// as returned by runtime/debug.Stack. The leading goroutine information is
+// optional and always removed if present. Beware that runtime/debug.Stack
+// adds itself as first entry, so typically skip must be >= 1 to remove that
+// entry.
 func PruneStack(fullStackTrace string, skip int) string {
 	stack := strings.Split(fullStackTrace, "\n")
+	// Ensure that the even entries are the method names and the
+	// the odd entries the source code information.
+	if len(stack) > 0 && strings.HasPrefix(stack[0], "goroutine ") {
+		// Ignore "goroutine 29 [running]:" line.
+		stack = stack[1:]
+	}
+	// The "+1" is for skipping over the initial entry, which is
+	// runtime/debug.Stack() itself.
 	if len(stack) > 2*(skip+1) {
 		stack = stack[2*(skip+1):]
 	}
 	prunedStack := []string{}
 	re := regexp.MustCompile(`\/ginkgo\/|\/pkg\/testing\/|\/pkg\/runtime\/`)
 	for i := 0; i < len(stack)/2; i++ {
-		if !re.Match([]byte(stack[i*2])) {
+		// We filter out based on the source code file name.
+		if !re.Match([]byte(stack[i*2+1])) {
 			prunedStack = append(prunedStack, stack[i*2])
 			prunedStack = append(prunedStack, stack[i*2+1])
 		}

vendor/github.com/onsi/ginkgo/internal/leafnodes/benchmarker.go

@@ -17,7 +17,7 @@ type benchmarker struct {
 
 func newBenchmarker() *benchmarker {
 	return &benchmarker{
-		measurements: make(map[string]*types.SpecMeasurement, 0),
+		measurements: make(map[string]*types.SpecMeasurement),
 	}
 }
 

vendor/github.com/onsi/ginkgo/internal/leafnodes/setup_nodes.go

@@ -40,3 +40,9 @@ func NewJustBeforeEachNode(body interface{}, codeLocation types.CodeLocation, ti
 		runner: newRunner(body, codeLocation, timeout, failer, types.SpecComponentTypeJustBeforeEach, componentIndex),
 	}
 }
+
+func NewJustAfterEachNode(body interface{}, codeLocation types.CodeLocation, timeout time.Duration, failer *failer.Failer, componentIndex int) *SetupNode {
+	return &SetupNode{
+		runner: newRunner(body, codeLocation, timeout, failer, types.SpecComponentTypeJustAfterEach, componentIndex),
+	}
+}

vendor/github.com/onsi/ginkgo/internal/remote/aggregator.go

@@ -54,11 +54,11 @@ func NewAggregator(nodeCount int, result chan bool, config config.DefaultReporte
 		config:       config,
 		stenographer: stenographer,
 
-		suiteBeginnings: make(chan configAndSuite, 0),
-		beforeSuites:    make(chan *types.SetupSummary, 0),
-		afterSuites:     make(chan *types.SetupSummary, 0),
-		specCompletions: make(chan *types.SpecSummary, 0),
-		suiteEndings:    make(chan *types.SuiteSummary, 0),
+		suiteBeginnings: make(chan configAndSuite),
+		beforeSuites:    make(chan *types.SetupSummary),
+		afterSuites:     make(chan *types.SetupSummary),
+		specCompletions: make(chan *types.SpecSummary),
+		suiteEndings:    make(chan *types.SuiteSummary),
 	}
 
 	go aggregator.mux()
@@ -227,7 +227,7 @@ func (aggregator *Aggregator) registerSuiteEnding(suite *types.SuiteSummary) (fi
 	aggregatedSuiteSummary.SuiteSucceeded = true
 
 	for _, suiteSummary := range aggregator.aggregatedSuiteEndings {
-		if suiteSummary.SuiteSucceeded == false {
+		if !suiteSummary.SuiteSucceeded {
 			aggregatedSuiteSummary.SuiteSucceeded = false
 		}
 

vendor/github.com/onsi/ginkgo/internal/remote/server.go

@@ -213,7 +213,7 @@ func (server *Server) handleCounter(writer http.ResponseWriter, request *http.Re
 	c := spec_iterator.Counter{}
 	server.lock.Lock()
 	c.Index = server.counter
-	server.counter = server.counter + 1
+	server.counter++
 	server.lock.Unlock()
 
 	json.NewEncoder(writer).Encode(c)

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

@@ -107,11 +107,11 @@ func (spec *Spec) Summary(suiteID string) *types.SpecSummary {
 		NumberOfSamples:        spec.subject.Samples(),
 		ComponentTexts:         componentTexts,
 		ComponentCodeLocations: componentCodeLocations,
-		State:        spec.getState(),
-		RunTime:      runTime,
-		Failure:      spec.failure,
-		Measurements: spec.measurementsReport(),
-		SuiteID:      suiteID,
+		State:                  spec.getState(),
+		RunTime:                runTime,
+		Failure:                spec.failure,
+		Measurements:           spec.measurementsReport(),
+		SuiteID:                suiteID,
 	}
 }
 
@@ -161,6 +161,18 @@ func (spec *Spec) runSample(sample int, writer io.Writer) {
 	innerMostContainerIndexToUnwind := -1
 
 	defer func() {
+		for i := innerMostContainerIndexToUnwind; i >= 0; i-- {
+			container := spec.containers[i]
+			for _, justAfterEach := range container.SetupNodesOfType(types.SpecComponentTypeJustAfterEach) {
+				spec.announceSetupNode(writer, "JustAfterEach", container, justAfterEach)
+				justAfterEachState, justAfterEachFailure := justAfterEach.Run()
+				if justAfterEachState != types.SpecStatePassed && spec.state == types.SpecStatePassed {
+					spec.state = justAfterEachState
+					spec.failure = justAfterEachFailure
+				}
+			}
+		}
+
 		for i := innerMostContainerIndexToUnwind; i >= 0; i-- {
 			container := spec.containers[i]
 			for _, afterEach := range container.SetupNodesOfType(types.SpecComponentTypeAfterEach) {

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

@@ -7,14 +7,21 @@ import (
 )
 
 type Specs struct {
-	specs                []*Spec
+	specs []*Spec
+	names []string
+
 	hasProgrammaticFocus bool
 	RegexScansFilePath   bool
 }
 
 func NewSpecs(specs []*Spec) *Specs {
+	names := make([]string, len(specs))
+	for i, spec := range specs {
+		names[i] = spec.ConcatenatedString()
+	}
 	return &Specs{
 		specs: specs,
+		names: names,
 	}
 }
 
@@ -30,10 +37,13 @@ func (e *Specs) Shuffle(r *rand.Rand) {
 	sort.Sort(e)
 	permutation := r.Perm(len(e.specs))
 	shuffledSpecs := make([]*Spec, len(e.specs))
+	names := make([]string, len(e.specs))
 	for i, j := range permutation {
 		shuffledSpecs[i] = e.specs[j]
+		names[i] = e.names[j]
 	}
 	e.specs = shuffledSpecs
+	e.names = names
 }
 
 func (e *Specs) ApplyFocus(description string, focusString string, skipString string) {
@@ -64,34 +74,44 @@ func (e *Specs) applyProgrammaticFocus() {
 
 // toMatch returns a byte[] to be used by regex matchers.  When adding new behaviours to the matching function,
 // this is the place which we append to.
-func (e *Specs) toMatch(description string, spec *Spec) []byte {
+func (e *Specs) toMatch(description string, i int) []byte {
+	if i > len(e.names) {
+		return nil
+	}
 	if e.RegexScansFilePath {
 		return []byte(
 			description + " " +
-				spec.ConcatenatedString() + " " +
-				spec.subject.CodeLocation().FileName)
+				e.names[i] + " " +
+				e.specs[i].subject.CodeLocation().FileName)
 	} else {
 		return []byte(
 			description + " " +
-				spec.ConcatenatedString())
+				e.names[i])
 	}
 }
 
 func (e *Specs) applyRegExpFocusAndSkip(description string, focusString string, skipString string) {
-	for _, spec := range e.specs {
+	var focusFilter *regexp.Regexp
+	if focusString != "" {
+		focusFilter = regexp.MustCompile(focusString)
+	}
+	var skipFilter *regexp.Regexp
+	if skipString != "" {
+		skipFilter = regexp.MustCompile(skipString)
+	}
+
+	for i, spec := range e.specs {
 		matchesFocus := true
 		matchesSkip := false
 
-		toMatch := e.toMatch(description, spec)
+		toMatch := e.toMatch(description, i)
 
-		if focusString != "" {
-			focusFilter := regexp.MustCompile(focusString)
-			matchesFocus = focusFilter.Match([]byte(toMatch))
+		if focusFilter != nil {
+			matchesFocus = focusFilter.Match(toMatch)
 		}
 
-		if skipString != "" {
-			skipFilter := regexp.MustCompile(skipString)
-			matchesSkip = skipFilter.Match([]byte(toMatch))
+		if skipFilter != nil {
+			matchesSkip = skipFilter.Match(toMatch)
 		}
 
 		if !matchesFocus || matchesSkip {
@@ -115,9 +135,10 @@ func (e *Specs) Len() int {
 }
 
 func (e *Specs) Less(i, j int) bool {
-	return e.specs[i].ConcatenatedString() < e.specs[j].ConcatenatedString()
+	return e.names[i] < e.names[j]
 }
 
 func (e *Specs) Swap(i, j int) {
+	e.names[i], e.names[j] = e.names[j], e.names[i]
 	e.specs[i], e.specs[j] = e.specs[j], e.specs[i]
 }

vendor/github.com/onsi/ginkgo/internal/specrunner/spec_runner.go

@@ -300,7 +300,7 @@ func (runner *SpecRunner) reportSpecWillRun(summary *types.SpecSummary) {
 }
 
 func (runner *SpecRunner) reportSpecDidComplete(summary *types.SpecSummary, failed bool) {
-	if failed && len(summary.CapturedOutput) == 0 {
+	if len(summary.CapturedOutput) == 0 {
 		summary.CapturedOutput = string(runner.writer.Bytes())
 	}
 	for i := len(runner.reporters) - 1; i >= 1; i-- {

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

@@ -175,6 +175,13 @@ func (suite *Suite) PushJustBeforeEachNode(body interface{}, codeLocation types.
 	suite.currentContainer.PushSetupNode(leafnodes.NewJustBeforeEachNode(body, codeLocation, timeout, suite.failer, suite.containerIndex))
 }
 
+func (suite *Suite) PushJustAfterEachNode(body interface{}, codeLocation types.CodeLocation, timeout time.Duration) {
+	if suite.running {
+		suite.failer.Fail("You may only call JustAfterEach from within a Describe or Context", codeLocation)
+	}
+	suite.currentContainer.PushSetupNode(leafnodes.NewJustAfterEachNode(body, codeLocation, timeout, suite.failer, suite.containerIndex))
+}
+
 func (suite *Suite) PushAfterEachNode(body interface{}, codeLocation types.CodeLocation, timeout time.Duration) {
 	if suite.running {
 		suite.failer.Fail("You may only call AfterEach from within a Describe, Context or When", codeLocation)

vendor/github.com/onsi/ginkgo/reporters/default_reporter.go

@@ -62,6 +62,9 @@ func (reporter *DefaultReporter) SpecDidComplete(specSummary *types.SpecSummary)
 			reporter.stenographer.AnnounceSuccesfulSlowSpec(specSummary, reporter.config.Succinct)
 		} else {
 			reporter.stenographer.AnnounceSuccesfulSpec(specSummary)
+			if reporter.config.ReportPassed {
+				reporter.stenographer.AnnounceCapturedOutput(specSummary.CapturedOutput)
+			}
 		}
 	case types.SpecStatePending:
 		reporter.stenographer.AnnouncePendingSpec(specSummary, reporter.config.NoisyPendings && !reporter.config.Succinct)

vendor/github.com/onsi/ginkgo/reporters/junit_reporter.go

@@ -32,12 +32,17 @@ type JUnitTestSuite struct {
 type JUnitTestCase struct {
 	Name           string               `xml:"name,attr"`
 	ClassName      string               `xml:"classname,attr"`
+	PassedMessage  *JUnitPassedMessage  `xml:"passed,omitempty"`
 	FailureMessage *JUnitFailureMessage `xml:"failure,omitempty"`
 	Skipped        *JUnitSkipped        `xml:"skipped,omitempty"`
 	Time           float64              `xml:"time,attr"`
 	SystemOut      string               `xml:"system-out,omitempty"`
 }
 
+type JUnitPassedMessage struct {
+	Message string `xml:",chardata"`
+}
+
 type JUnitFailureMessage struct {
 	Type    string `xml:"type,attr"`
 	Message string `xml:",chardata"`
@@ -48,9 +53,10 @@ type JUnitSkipped struct {
 }
 
 type JUnitReporter struct {
-	suite         JUnitTestSuite
-	filename      string
-	testSuiteName string
+	suite          JUnitTestSuite
+	filename       string
+	testSuiteName  string
+	ReporterConfig config.DefaultReporterConfigType
 }
 
 //NewJUnitReporter creates a new JUnit XML reporter.  The XML will be stored in the passed in filename.
@@ -60,12 +66,13 @@ func NewJUnitReporter(filename string) *JUnitReporter {
 	}
 }
 
-func (reporter *JUnitReporter) SpecSuiteWillBegin(config config.GinkgoConfigType, summary *types.SuiteSummary) {
+func (reporter *JUnitReporter) SpecSuiteWillBegin(ginkgoConfig config.GinkgoConfigType, summary *types.SuiteSummary) {
 	reporter.suite = JUnitTestSuite{
 		Name:      summary.SuiteDescription,
 		TestCases: []JUnitTestCase{},
 	}
 	reporter.testSuiteName = summary.SuiteDescription
+	reporter.ReporterConfig = config.DefaultReporterConfig
 }
 
 func (reporter *JUnitReporter) SpecWillRun(specSummary *types.SpecSummary) {
@@ -105,11 +112,21 @@ func (reporter *JUnitReporter) SpecDidComplete(specSummary *types.SpecSummary) {
 		Name:      strings.Join(specSummary.ComponentTexts[1:], " "),
 		ClassName: reporter.testSuiteName,
 	}
+	if reporter.ReporterConfig.ReportPassed && specSummary.State == types.SpecStatePassed {
+		testCase.PassedMessage = &JUnitPassedMessage{
+			Message: specSummary.CapturedOutput,
+		}
+	}
 	if specSummary.State == types.SpecStateFailed || specSummary.State == types.SpecStateTimedOut || specSummary.State == types.SpecStatePanicked {
 		testCase.FailureMessage = &JUnitFailureMessage{
 			Type:    reporter.failureTypeForState(specSummary.State),
 			Message: failureMessage(specSummary.Failure),
 		}
+		if specSummary.State == types.SpecStatePanicked {
+			testCase.FailureMessage.Message += fmt.Sprintf("\n\nPanic: %s\n\nFull stack:\n%s",
+				specSummary.Failure.ForwardedPanic,
+				specSummary.Failure.Location.FullStackTrace)
+		}
 		testCase.SystemOut = specSummary.CapturedOutput
 	}
 	if specSummary.State == types.SpecStateSkipped || specSummary.State == types.SpecStatePending {
@@ -121,7 +138,7 @@ func (reporter *JUnitReporter) SpecDidComplete(specSummary *types.SpecSummary) {
 
 func (reporter *JUnitReporter) SpecSuiteDidEnd(summary *types.SuiteSummary) {
 	reporter.suite.Tests = summary.NumberOfSpecsThatWillBeRun
-	reporter.suite.Time = math.Trunc(summary.RunTime.Seconds() * 1000 / 1000)
+	reporter.suite.Time = math.Trunc(summary.RunTime.Seconds()*1000) / 1000
 	reporter.suite.Failures = summary.NumberOfFailedSpecs
 	reporter.suite.Errors = 0
 	file, err := os.Create(reporter.filename)

vendor/github.com/onsi/ginkgo/reporters/teamcity_reporter.go

@@ -22,8 +22,9 @@ const (
 )
 
 type TeamCityReporter struct {
-	writer        io.Writer
-	testSuiteName string
+	writer         io.Writer
+	testSuiteName  string
+	ReporterConfig config.DefaultReporterConfigType
 }
 
 func NewTeamCityReporter(writer io.Writer) *TeamCityReporter {
@@ -65,6 +66,10 @@ func (reporter *TeamCityReporter) SpecWillRun(specSummary *types.SpecSummary) {
 func (reporter *TeamCityReporter) SpecDidComplete(specSummary *types.SpecSummary) {
 	testName := escape(strings.Join(specSummary.ComponentTexts[1:], " "))
 
+	if reporter.ReporterConfig.ReportPassed && specSummary.State == types.SpecStatePassed {
+		details := escape(specSummary.CapturedOutput)
+		fmt.Fprintf(reporter.writer, "%s[testPassed name='%s' details='%s']", messageId, testName, details)
+	}
 	if specSummary.State == types.SpecStateFailed || specSummary.State == types.SpecStateTimedOut || specSummary.State == types.SpecStatePanicked {
 		message := escape(specSummary.Failure.ComponentCodeLocation.String())
 		details := escape(specSummary.Failure.Message)

vendor/github.com/onsi/ginkgo/types/types.go

@@ -17,7 +17,7 @@ each node does not deterministically know how many specs it will end up running.
 
 Unfortunately making such a change would break backward compatibility.
 
-Until Ginkgo 2.0 comes out we will continue to reuse this struct but populate unkown fields
+Until Ginkgo 2.0 comes out we will continue to reuse this struct but populate unknown fields
 with -1.
 */
 type SuiteSummary struct {
@@ -159,6 +159,7 @@ const (
 	SpecComponentTypeAfterSuite
 	SpecComponentTypeBeforeEach
 	SpecComponentTypeJustBeforeEach
+	SpecComponentTypeJustAfterEach
 	SpecComponentTypeAfterEach
 	SpecComponentTypeIt
 	SpecComponentTypeMeasure