1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
package internal_integration_test
import (
"time"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/ginkgo/v2/internal/test_helpers"
. "github.com/onsi/gomega"
"github.com/onsi/ginkgo/v2/types"
)
var _ = Describe("Running Tests in Series - the happy path", func() {
BeforeEach(func() {
success, hPF := RunFixture("happy-path run suite", func() {
BeforeSuite(rt.T("before-suite", func() {
time.Sleep(10 * time.Millisecond)
writer.Write([]byte("before-suite\n"))
outputInterceptor.AppendInterceptedOutput("output-intercepted-in-before-suite")
}))
AfterSuite(rt.T("after-suite", func() {
time.Sleep(20 * time.Millisecond)
outputInterceptor.AppendInterceptedOutput("output-intercepted-in-after-suite")
}))
Describe("top-level-container", func() {
JustBeforeEach(rt.T("just-before-each"))
BeforeEach(rt.T("before-each", func() {
writer.Write([]byte("before-each\n"))
}))
AfterEach(rt.T("after-each"))
AfterEach(rt.T("after-each-2"))
JustAfterEach(rt.T("just-after-each"))
It("A", rt.T("A", func() {
time.Sleep(10 * time.Millisecond)
}))
It("B", rt.T("B", func() {
time.Sleep(20 * time.Millisecond)
}))
Describe("nested-container", func() {
JustBeforeEach(rt.T("nested-just-before-each"))
BeforeEach(rt.T("nested-before-each"))
AfterEach(rt.T("nested-after-each"))
JustAfterEach(rt.T("nested-just-after-each"))
JustAfterEach(rt.T("nested-just-after-each-2"))
It("C", rt.T("C", func() {
writer.Write([]byte("C\n"))
outputInterceptor.AppendInterceptedOutput("output-intercepted-in-C")
}))
It("D", rt.T("D"))
})
JustBeforeEach(rt.T("outer-just-before-each"))
BeforeEach(rt.T("outer-before-each"))
AfterEach(rt.T("outer-after-each"))
JustAfterEach(rt.T("outer-just-after-each"))
})
})
Ω(success).Should(BeTrue())
Ω(hPF).Should(BeFalse())
})
It("runs all the test nodes in the expected order", func() {
Ω(rt).Should(HaveTracked(
"before-suite",
"before-each", "outer-before-each", "just-before-each", "outer-just-before-each", "A", "just-after-each", "outer-just-after-each", "after-each", "after-each-2", "outer-after-each",
"before-each", "outer-before-each", "just-before-each", "outer-just-before-each", "B", "just-after-each", "outer-just-after-each", "after-each", "after-each-2", "outer-after-each",
"before-each", "outer-before-each", "nested-before-each", "just-before-each", "outer-just-before-each", "nested-just-before-each", "C", "nested-just-after-each", "nested-just-after-each-2", "just-after-each", "outer-just-after-each", "nested-after-each", "after-each", "after-each-2", "outer-after-each",
"before-each", "outer-before-each", "nested-before-each", "just-before-each", "outer-just-before-each", "nested-just-before-each", "D", "nested-just-after-each", "nested-just-after-each-2", "just-after-each", "outer-just-after-each", "nested-after-each", "after-each", "after-each-2", "outer-after-each",
"after-suite",
))
})
Describe("reporting", func() {
It("reports the suite summary correctly when starting", func() {
Ω(reporter.Begin).Should(SatisfyAll(
HaveField("SuitePath", "/path/to/suite"),
HaveField("SuiteDescription", "happy-path run suite"),
HaveField("SuiteSucceeded", BeFalse()),
HaveField("PreRunStats.TotalSpecs", 4),
HaveField("PreRunStats.SpecsThatWillRun", 4),
))
})
It("reports the suite summary correctly when complete", func() {
Ω(reporter.End).Should(SatisfyAll(
HaveField("SuitePath", "/path/to/suite"),
HaveField("SuiteDescription", "happy-path run suite"),
HaveField("SuiteSucceeded", BeTrue()),
HaveField("RunTime", BeNumerically(">=", time.Millisecond*(10+20+10+20))),
HaveField("PreRunStats.TotalSpecs", 4),
HaveField("PreRunStats.SpecsThatWillRun", 4),
))
Ω(reporter.End.SpecReports.WithLeafNodeType(types.NodeTypeIt).CountWithState(types.SpecStatePassed)).Should(Equal(4))
})
It("reports the correct suite node summaries", func() {
Ω(reporter.Did.FindByLeafNodeType(types.NodeTypeBeforeSuite)).Should(SatisfyAll(
HaveField("LeafNodeType", types.NodeTypeBeforeSuite),
HaveField("State", types.SpecStatePassed),
HaveField("RunTime", BeNumerically(">=", 10*time.Millisecond)),
HaveField("Failure", BeZero()),
HaveField("CapturedGinkgoWriterOutput", "before-suite\n"),
HaveField("CapturedStdOutErr", "output-intercepted-in-before-suite"),
HaveField("ParallelProcess", 1),
))
beforeSuiteReport := reporter.Did.FindByLeafNodeType(types.NodeTypeBeforeSuite)
Ω(beforeSuiteReport.EndTime.Sub(beforeSuiteReport.StartTime)).Should(BeNumerically("~", beforeSuiteReport.RunTime))
Ω(reporter.Did.FindByLeafNodeType(types.NodeTypeAfterSuite)).Should(SatisfyAll(
HaveField("LeafNodeType", types.NodeTypeAfterSuite),
HaveField("State", types.SpecStatePassed),
HaveField("RunTime", BeNumerically(">=", 20*time.Millisecond)),
HaveField("Failure", BeZero()),
HaveField("CapturedGinkgoWriterOutput", BeZero()),
HaveField("CapturedStdOutErr", "output-intercepted-in-after-suite"),
HaveField("ParallelProcess", 1),
))
afterSuiteReport := reporter.Did.FindByLeafNodeType(types.NodeTypeAfterSuite)
Ω(afterSuiteReport.EndTime.Sub(afterSuiteReport.StartTime)).Should(BeNumerically("~", afterSuiteReport.RunTime))
})
It("reports about each just before it runs", func() {
Ω(reporter.Will.Names()).Should(Equal([]string{"A", "B", "C", "D"}))
})
It("reports about each test after it completes", func() {
Ω(reporter.Did.Names()).Should(Equal([]string{"A", "B", "C", "D"}))
Ω(reporter.Did.WithState(types.SpecStatePassed).Names()).Should(Equal([]string{"A", "B", "C", "D"}))
//spot-check
Ω(reporter.Did.Find("C")).Should(SatisfyAll(
HaveField("LeafNodeType", types.NodeTypeIt),
HaveField("LeafNodeText", "C"),
HaveField("ContainerHierarchyTexts", []string{"top-level-container", "nested-container"}),
HaveField("State", types.SpecStatePassed),
HaveField("Failure", BeZero()),
HaveField("NumAttempts", 1),
HaveField("CapturedGinkgoWriterOutput", "before-each\nC\n"),
HaveField("CapturedStdOutErr", "output-intercepted-in-C"),
HaveField("ParallelProcess", 1),
HaveField("RunningInParallel", false),
))
})
It("computes start times, end times, and run times", func() {
Ω(reporter.Did.Find("A").RunTime).Should(BeNumerically(">=", 10*time.Millisecond))
Ω(reporter.Did.Find("B").RunTime).Should(BeNumerically(">=", 20*time.Millisecond))
reportA := reporter.Did.Find("A")
Ω(reportA.EndTime.Sub(reportA.StartTime)).Should(BeNumerically("~", reportA.RunTime))
})
})
})
|
