Cirrus: add vendor_check_task

* Make sure that all vendored dependencies are in sync with the code and
  the vendor.conf by running `make vendor` with a follow-up status check
  of the git tree.

* Vendor ginkgo and gomega to include the test dependencies.

Signed-off-by: Chris Evic <cevich@redhat.com>
Signed-off-by: Valentin Rothberg <rothberg@redhat.com>

1 files changed, 269 insertions, 0 deletions

diff --git a/vendor/github.com/onsi/ginkgo/internal/remote/server_test.go b/vendor/github.com/onsi/ginkgo/internal/remote/server_test.go
new file mode 100644
index 000000000..36bd00355
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/server_test.go
@@ -0,0 +1,269 @@
+package remote_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/internal/remote"
+	. "github.com/onsi/gomega"
+
+	"github.com/onsi/ginkgo/config"
+	"github.com/onsi/ginkgo/reporters"
+	"github.com/onsi/ginkgo/types"
+
+	"bytes"
+	"encoding/json"
+	"net/http"
+)
+
+var _ = Describe("Server", func() {
+	var (
+		server *Server
+	)
+
+	BeforeEach(func() {
+		var err error
+		server, err = NewServer(3)
+		Ω(err).ShouldNot(HaveOccurred())
+
+		server.Start()
+	})
+
+	AfterEach(func() {
+		server.Close()
+	})
+
+	Describe("Streaming endpoints", func() {
+		var (
+			reporterA, reporterB *reporters.FakeReporter
+			forwardingReporter   *ForwardingReporter
+
+			suiteSummary *types.SuiteSummary
+			setupSummary *types.SetupSummary
+			specSummary  *types.SpecSummary
+		)
+
+		BeforeEach(func() {
+			reporterA = reporters.NewFakeReporter()
+			reporterB = reporters.NewFakeReporter()
+
+			server.RegisterReporters(reporterA, reporterB)
+
+			forwardingReporter = NewForwardingReporter(config.DefaultReporterConfigType{}, server.Address(), &http.Client{}, &fakeOutputInterceptor{}, nil, "")
+
+			suiteSummary = &types.SuiteSummary{
+				SuiteDescription: "My Test Suite",
+			}
+
+			setupSummary = &types.SetupSummary{
+				State: types.SpecStatePassed,
+			}
+
+			specSummary = &types.SpecSummary{
+				ComponentTexts: []string{"My", "Spec"},
+				State:          types.SpecStatePassed,
+			}
+		})
+
+		It("should make its address available", func() {
+			Ω(server.Address()).Should(MatchRegexp(`http://127.0.0.1:\d{2,}`))
+		})
+
+		Describe("/SpecSuiteWillBegin", func() {
+			It("should decode and forward the Ginkgo config and suite summary", func(done Done) {
+				forwardingReporter.SpecSuiteWillBegin(config.GinkgoConfig, suiteSummary)
+				Ω(reporterA.Config).Should(Equal(config.GinkgoConfig))
+				Ω(reporterB.Config).Should(Equal(config.GinkgoConfig))
+				Ω(reporterA.BeginSummary).Should(Equal(suiteSummary))
+				Ω(reporterB.BeginSummary).Should(Equal(suiteSummary))
+				close(done)
+			})
+		})
+
+		Describe("/BeforeSuiteDidRun", func() {
+			It("should decode and forward the setup summary", func() {
+				forwardingReporter.BeforeSuiteDidRun(setupSummary)
+				Ω(reporterA.BeforeSuiteSummary).Should(Equal(setupSummary))
+				Ω(reporterB.BeforeSuiteSummary).Should(Equal(setupSummary))
+			})
+		})
+
+		Describe("/AfterSuiteDidRun", func() {
+			It("should decode and forward the setup summary", func() {
+				forwardingReporter.AfterSuiteDidRun(setupSummary)
+				Ω(reporterA.AfterSuiteSummary).Should(Equal(setupSummary))
+				Ω(reporterB.AfterSuiteSummary).Should(Equal(setupSummary))
+			})
+		})
+
+		Describe("/SpecWillRun", func() {
+			It("should decode and forward the spec summary", func(done Done) {
+				forwardingReporter.SpecWillRun(specSummary)
+				Ω(reporterA.SpecWillRunSummaries[0]).Should(Equal(specSummary))
+				Ω(reporterB.SpecWillRunSummaries[0]).Should(Equal(specSummary))
+				close(done)
+			})
+		})
+
+		Describe("/SpecDidComplete", func() {
+			It("should decode and forward the spec summary", func(done Done) {
+				forwardingReporter.SpecDidComplete(specSummary)
+				Ω(reporterA.SpecSummaries[0]).Should(Equal(specSummary))
+				Ω(reporterB.SpecSummaries[0]).Should(Equal(specSummary))
+				close(done)
+			})
+		})
+
+		Describe("/SpecSuiteDidEnd", func() {
+			It("should decode and forward the suite summary", func(done Done) {
+				forwardingReporter.SpecSuiteDidEnd(suiteSummary)
+				Ω(reporterA.EndSummary).Should(Equal(suiteSummary))
+				Ω(reporterB.EndSummary).Should(Equal(suiteSummary))
+				close(done)
+			})
+		})
+	})
+
+	Describe("Synchronization endpoints", func() {
+		Describe("GETting and POSTing BeforeSuiteState", func() {
+			getBeforeSuite := func() types.RemoteBeforeSuiteData {
+				resp, err := http.Get(server.Address() + "/BeforeSuiteState")
+				Ω(err).ShouldNot(HaveOccurred())
+				Ω(resp.StatusCode).Should(Equal(http.StatusOK))
+
+				r := types.RemoteBeforeSuiteData{}
+				decoder := json.NewDecoder(resp.Body)
+				err = decoder.Decode(&r)
+				Ω(err).ShouldNot(HaveOccurred())
+
+				return r
+			}
+
+			postBeforeSuite := func(r types.RemoteBeforeSuiteData) {
+				resp, err := http.Post(server.Address()+"/BeforeSuiteState", "application/json", bytes.NewReader(r.ToJSON()))
+				Ω(err).ShouldNot(HaveOccurred())
+				Ω(resp.StatusCode).Should(Equal(http.StatusOK))
+			}
+
+			Context("when the first node's Alive has not been registered yet", func() {
+				It("should return pending", func() {
+					state := getBeforeSuite()
+					Ω(state).Should(Equal(types.RemoteBeforeSuiteData{Data: nil, State: types.RemoteBeforeSuiteStatePending}))
+
+					state = getBeforeSuite()
+					Ω(state).Should(Equal(types.RemoteBeforeSuiteData{Data: nil, State: types.RemoteBeforeSuiteStatePending}))
+				})
+			})
+
+			Context("when the first node is Alive but has not responded yet", func() {
+				BeforeEach(func() {
+					server.RegisterAlive(1, func() bool {
+						return true
+					})
+				})
+
+				It("should return pending", func() {
+					state := getBeforeSuite()
+					Ω(state).Should(Equal(types.RemoteBeforeSuiteData{Data: nil, State: types.RemoteBeforeSuiteStatePending}))
+
+					state = getBeforeSuite()
+					Ω(state).Should(Equal(types.RemoteBeforeSuiteData{Data: nil, State: types.RemoteBeforeSuiteStatePending}))
+				})
+			})
+
+			Context("when the first node has responded", func() {
+				var state types.RemoteBeforeSuiteData
+				BeforeEach(func() {
+					server.RegisterAlive(1, func() bool {
+						return false
+					})
+
+					state = types.RemoteBeforeSuiteData{
+						Data:  []byte("my data"),
+						State: types.RemoteBeforeSuiteStatePassed,
+					}
+					postBeforeSuite(state)
+				})
+
+				It("should return the passed in state", func() {
+					returnedState := getBeforeSuite()
+					Ω(returnedState).Should(Equal(state))
+				})
+			})
+
+			Context("when the first node is no longer Alive and has not responded yet", func() {
+				BeforeEach(func() {
+					server.RegisterAlive(1, func() bool {
+						return false
+					})
+				})
+
+				It("should return disappeared", func() {
+					state := getBeforeSuite()
+					Ω(state).Should(Equal(types.RemoteBeforeSuiteData{Data: nil, State: types.RemoteBeforeSuiteStateDisappeared}))
+
+					state = getBeforeSuite()
+					Ω(state).Should(Equal(types.RemoteBeforeSuiteData{Data: nil, State: types.RemoteBeforeSuiteStateDisappeared}))
+				})
+			})
+		})
+
+		Describe("GETting RemoteAfterSuiteData", func() {
+			getRemoteAfterSuiteData := func() bool {
+				resp, err := http.Get(server.Address() + "/RemoteAfterSuiteData")
+				Ω(err).ShouldNot(HaveOccurred())
+				Ω(resp.StatusCode).Should(Equal(http.StatusOK))
+
+				a := types.RemoteAfterSuiteData{}
+				decoder := json.NewDecoder(resp.Body)
+				err = decoder.Decode(&a)
+				Ω(err).ShouldNot(HaveOccurred())
+
+				return a.CanRun
+			}
+
+			Context("when there are unregistered nodes", func() {
+				BeforeEach(func() {
+					server.RegisterAlive(2, func() bool {
+						return false
+					})
+				})
+
+				It("should return false", func() {
+					Ω(getRemoteAfterSuiteData()).Should(BeFalse())
+				})
+			})
+
+			Context("when all none-node-1 nodes are still running", func() {
+				BeforeEach(func() {
+					server.RegisterAlive(2, func() bool {
+						return true
+					})
+
+					server.RegisterAlive(3, func() bool {
+						return false
+					})
+				})
+
+				It("should return false", func() {
+					Ω(getRemoteAfterSuiteData()).Should(BeFalse())
+				})
+			})
+
+			Context("when all none-1 nodes are done", func() {
+				BeforeEach(func() {
+					server.RegisterAlive(2, func() bool {
+						return false
+					})
+
+					server.RegisterAlive(3, func() bool {
+						return false
+					})
+				})
+
+				It("should return true", func() {
+					Ω(getRemoteAfterSuiteData()).Should(BeTrue())
+				})
+
+			})
+		})
+	})
+})