SF

Author: Ciro S. Costa

cast/cast.go

@@ -156,6 +156,37 @@ func ValidateEvent(event *Event) (isValid bool, err error) {
 	return
 }
 
+// ValidateEventStream makes sure that a given set of events (event stream)
+// is valid.
+//
+// A valid stream must:
+// - be ordered by time; and
+// - have valid events.
+func ValidateEventStream(eventStream []*Event) (isValid bool, err error) {
+	var (
+		lastTime float64
+		ev       *Event
+	)
+
+	for _, ev = range eventStream {
+		if ev.Time < lastTime {
+			err = errors.Errorf("events must be ordered by time")
+			return
+		}
+
+		_, err = ValidateEvent(ev)
+		if err != nil {
+			err = errors.Wrapf(err, "invalid event")
+			return
+		}
+
+		lastTime = ev.Time
+	}
+
+	isValid = true
+	return
+}
+
 // Validate makes sure that the supplied cast is valid.
 func Validate(cast *Cast) (isValid bool, err error) {
 	if cast == nil {
@@ -169,20 +200,10 @@ func Validate(cast *Cast) (isValid bool, err error) {
 		return
 	}
 
-	var lastTime float64
-	for _, ev := range cast.EventStream {
-		if ev.Time < lastTime {
-			err = errors.Errorf("events must be ordered by time")
-			return
-		}
-
-		_, err = ValidateEvent(ev)
-		if err != nil {
-			err = errors.Wrapf(err, "invalid event")
-			return
-		}
-
-		lastTime = ev.Time
+	_, err = ValidateEventStream(cast.EventStream)
+	if err != nil {
+		err = errors.Wrapf(err, "invalid event stream")
+		return
 	}
 
 	isValid = true

cast/cast_test.go

@@ -37,6 +37,18 @@ var (
 )
 
 var _ = Describe("Cast", func() {
+	Describe("Validate", func() {
+		Context("with a nil cast", func() {
+			It("fails", func() {
+				isValid, err := cast.Validate(nil)
+
+				Expect(err).NotTo(Succeed())
+				Expect(isValid).NotTo(BeTrue())
+			})
+		})
+
+	})
+
 	Describe("ValidateEvent", func() {
 		Context("with nil event", func() {
 			It("fails", func() {
@@ -140,94 +152,69 @@ var _ = Describe("Cast", func() {
 		})
 	})
 
-	Describe("Validate", func() {
-		Context("with a nil cast", func() {
-			It("fails", func() {
-				isValid, err := cast.Validate(nil)
-
-				Expect(err).NotTo(Succeed())
-				Expect(isValid).NotTo(BeTrue())
-			})
-		})
-
-		Context("with invalid header", func() {
+	Describe("ValidateEventStream", func() {
+		Context("with empty stream", func() {
 			var data = cast.Cast{
-				Header: cast.Header{
-					Version: 123,
-				},
+				Header:      validHeader,
+				EventStream: []*cast.Event{},
 			}
 
-			It("fails", func() {
+			It("is valid", func() {
 				isValid, err := cast.Validate(&data)
 
-				Expect(err).NotTo(Succeed())
-				Expect(isValid).NotTo(BeTrue())
+				Expect(err).To(Succeed())
+				Expect(isValid).To(BeTrue())
 			})
 		})
 
-		Context("regarding events", func() {
-			Context("having an empty list of them", func() {
-				var data = cast.Cast{
-					Header:      validHeader,
-					EventStream: []*cast.Event{},
-				}
-
-				It("is valid", func() {
-					isValid, err := cast.Validate(&data)
-
-					Expect(err).To(Succeed())
-					Expect(isValid).To(BeTrue())
-				})
-			})
-
-			It("fails if not sorted by time", func() {
-				var data = cast.Cast{
-					Header: validHeader,
-					EventStream: []*cast.Event{
-						&validEvent2,
-						&validEvent1,
-						&validEvent3,
-					},
-				}
+		It("fails if not sorted by time", func() {
+			var data = cast.Cast{
+				Header: validHeader,
+				EventStream: []*cast.Event{
+					&validEvent2,
+					&validEvent1,
+					&validEvent3,
+				},
+			}
 
-				isValid, err := cast.Validate(&data)
+			isValid, err := cast.Validate(&data)
 
-				Expect(err).NotTo(Succeed())
-				Expect(isValid).NotTo(BeTrue())
+			Expect(err).NotTo(Succeed())
+			Expect(isValid).NotTo(BeTrue())
 
-			})
+		})
 
-			It("succeeds if sorted and valid", func() {
-				var data = cast.Cast{
-					Header: validHeader,
-					EventStream: []*cast.Event{
-						&validEvent1,
-						&validEvent2,
-						&validEvent3,
-					},
-				}
+		It("succeeds if sorted and valid", func() {
+			var data = cast.Cast{
+				Header: validHeader,
+				EventStream: []*cast.Event{
+					&validEvent1,
+					&validEvent2,
+					&validEvent3,
+				},
+			}
 
-				isValid, err := cast.Validate(&data)
+			isValid, err := cast.Validate(&data)
 
-				Expect(err).To(Succeed())
-				Expect(isValid).To(BeTrue())
-			})
+			Expect(err).To(Succeed())
+			Expect(isValid).To(BeTrue())
+		})
 
-			It("fails if there's an invalid event", func() {
-				var data = cast.Cast{
-					Header: validHeader,
-					EventStream: []*cast.Event{
-						&validEvent1,
-						&invalidEvent4,
-					},
-				}
+		It("fails if there's an invalid event", func() {
+			var data = cast.Cast{
+				Header: validHeader,
+				EventStream: []*cast.Event{
+					&validEvent1,
+					&invalidEvent4,
+				},
+			}
 
-				isValid, err := cast.Validate(&data)
+			isValid, err := cast.Validate(&data)
 
-				Expect(err).NotTo(Succeed())
-				Expect(isValid).NotTo(BeTrue())
-			})
+			Expect(err).NotTo(Succeed())
+			Expect(isValid).NotTo(BeTrue())
 		})
+
 	})
 
 	Describe("Encode", func() {