github.com/onsi/ginkgo@v1.16.6-0.20211118180735-4e1925ba4c95/internal/internal_integration/run_test.go (about)

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