Base structure for configuration

Author: sharpner

config.go

@@ -1,20 +1,86 @@
 package redkeep
 
-//
-//
-//
-//
-//
-//
+import (
+	"encoding/json"
+	"errors"
+
+	validator "gopkg.in/go-playground/validator.v8"
+)
+
+//Configuration for red keep
+type Configuration struct {
+	Mongo   Mongo   `json:"mongo" validate:"required"`
+	Watches []Watch `json:"watches" validate:"required,gt=0,dive"`
+}
+
+//Mongo is a config struct that changes the way the client
+//connects.
+//ConnectionURI should be a string identifying your cluster
+//if you have to slaves and one master it would be like
+//slave-01:27018,slave-02:27018,master:27018
+//where slave-01 is either a hostname or an ip
 type Mongo struct {
-	ListenDatabase string
-	ConnectionURL  string
+	ConnectionURI string `json:"connectionURI" validate:"required,gt=0"`
 }
 
+//Watch defines one watch that redkeep will do for you
 type Watch struct {
+	TrackCollection       string            `json:"trackCollection" validate:"required,gt=0"`
+	TrackFields           []string          `json:"trackFields" validate:"required,eq=1,dive,min=1"`
+	TargetCollection      string            `json:"targetCollection" validate:"required,min=1"`
+	TargetNormalizedField string            `json:"targetNormalizedField" validate:"required,min=1"`
+	TriggerReference      string            `json:"triggerReference" validate:"required,min=1"`
+	BehaviourSettings     BehaviourSettings `json:"behaviourSettings"`
 }
 
-type Configuration struct {
-	Mongo   Mongo   `json:"mongo"`
-	Watches []Watch `json:"watches"`
+//BehaviourSettings can define how one specific
+//watch handles special cases
+type BehaviourSettings struct {
+	CascadeDelete bool `json:"cascadeDelete"`
+}
+
+//NewConfiguration loads a configuration from data
+//if it is not valid json, it will return an error
+func NewConfiguration(configData []byte) (*Configuration, error) {
+	var config Configuration
+	err := json.Unmarshal(configData, &config)
+	if err != nil {
+		return nil, err
+	}
+
+	validate := validator.New(&validator.Config{TagName: "validate"})
+	err = validate.Struct(config)
+
+	if err != nil {
+		return nil, getValidationError(err.(validator.ValidationErrors))
+	}
+
+	return &config, err
+}
+
+func getValidationError(allErrors validator.ValidationErrors) error {
+	for _, e := range allErrors {
+		switch e.Field {
+		case "Watches":
+			return errors.New("Please add atleast one entry in watches")
+		case "ConnectionURI":
+			return errors.New("Mongo configuration must be defined")
+		case "TargetCollection":
+			return errors.New("TargetCollection must not be empty")
+		case "TriggerReference":
+			return errors.New("TriggerReference must not be empty")
+		case "TrackCollection":
+			return errors.New("TrackCollection must not be empty")
+		case "TrackFields":
+			fallthrough
+		case "TrackFields[0]":
+			return errors.New("TrackFields must exactly have one non-empty field, more are currently not supported")
+		case "TargetNormalizedField":
+			return errors.New("TargetNormalizedField must not be empty")
+		default:
+			return allErrors
+		}
+	}
+
+	return errors.New("Something went wrong")
 }

config_test.go

@@ -0,0 +1,123 @@
+package redkeep_test
+
+import (
+	"io/ioutil"
+	"strings"
+
+	. "github.com/manyminds/redkeep"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var mongoMissingConfig = `
+{
+  "watches": [ 
+    {
+      "trackCollection": "live.user",
+      "trackFields": ["username"], 
+      "targetCollection": "live.comment",
+      "targetNormalizedField": "normalizedUser",
+      "triggerReference": "user",
+      "behaviourSettings": {
+        "cascadeDelete": false
+      }
+    }
+  ]
+}`
+
+var watchesMissingConfig = `
+{
+  "mongo": { 
+    "connectionURI": "localhost:30000,localhost:30001,localhost:30002"
+  }, 
+  "watches": [ 
+  ]
+}
+`
+
+var emptyConfig = `
+	{
+	}
+`
+
+var templateForTestsConfig = `
+{
+  "mongo": { 
+    "connectionURI": "localhost:30000,localhost:30001,localhost:30002"
+  }, 
+  "watches": [ 
+    {
+      "trackCollection": "xAx",
+      "trackFields": ["xBx"], 
+      "targetCollection": "xCx",
+      "targetNormalizedField": "xDx",
+      "triggerReference": "xEx"
+    }
+  ]
+}`
+
+var _ = Describe("Config Testsuite", func() {
+	Context("it will load and validate a config file", func() {
+		It("will error with an empty config", func() {
+			_, err := NewConfiguration([]byte(emptyConfig))
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("will error with missing mongo key", func() {
+			_, err := NewConfiguration([]byte(mongoMissingConfig))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("Mongo configuration must be defined"))
+		})
+
+		It("will error with missing watches entries", func() {
+			_, err := NewConfiguration([]byte(watchesMissingConfig))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("Please add atleast one entry in watches"))
+		})
+
+		It("will error with correct data but empty trackCollection", func() {
+			_, err := NewConfiguration([]byte(strings.Replace(templateForTestsConfig, "xAx", "", 1)))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("TrackCollection must not be empty"))
+		})
+
+		It("will error with correct data but empty targetCollection", func() {
+			_, err := NewConfiguration([]byte(strings.Replace(templateForTestsConfig, "xCx", "", 1)))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("TargetCollection must not be empty"))
+		})
+
+		It("will error with correct data but empty targetNormalizedField", func() {
+			_, err := NewConfiguration([]byte(strings.Replace(templateForTestsConfig, "xDx", "", 1)))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("TargetNormalizedField must not be empty"))
+		})
+
+		It("will error with correct data but empty triggerReference", func() {
+			_, err := NewConfiguration([]byte(strings.Replace(templateForTestsConfig, "xEx", "", 1)))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("TriggerReference must not be empty"))
+		})
+
+		It("will error with correct data but empty trigger", func() {
+			_, err := NewConfiguration([]byte(strings.Replace(templateForTestsConfig, "xBx", "", 1)))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("TrackFields must exactly have one non-empty field, more are currently not supported"))
+		})
+
+		It("will error with correct data but multiple trackFields", func() {
+			_, err := NewConfiguration([]byte(strings.Replace(templateForTestsConfig, `xBx"`, `", "xXx"`, 1)))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("TrackFields must exactly have one non-empty field, more are currently not supported"))
+		})
+
+		It("will load correctly", func() {
+			file, err := ioutil.ReadFile("./example-configuration.json")
+			Expect(err).ToNot(HaveOccurred())
+
+			_, err = NewConfiguration(file)
+			Expect(err).ToNot(HaveOccurred())
+		})
+	})
+})

example-configuration.json

@@ -0,0 +1,17 @@
+{
+  "mongo": { 
+    "connectionURI": "localhost:30000,localhost:30001,localhost:30002"
+  }, 
+  "watches": [ 
+    {
+      "trackCollection": "live.user",
+      "trackFields": ["username"], 
+      "targetCollection": "live.comment",
+      "targetNormalizedField": "normalizedUser",
+      "triggerReference": "user",
+      "behaviourSettings": {
+        "cascadeDelete": false
+      }
+    }
+  ]
+}

tail.go

@@ -144,7 +144,7 @@ func (t TailAgent) Tail(quit chan bool) error {
 
 func (t *TailAgent) connect() error {
 	if !t.isConnected {
-		session, err := mgo.Dial(t.config.Mongo.ConnectionURL)
+		session, err := mgo.Dial(t.config.Mongo.ConnectionURI)
 
 		if err != nil {
 			log.Println(err)

tail_test.go

@@ -49,10 +49,10 @@ var _ = Describe("Tail", func() {
 	})
 
 	Context("Test basic connectivity", func() {
-		It("should connect to master", func() {
+		PIt("should connect to master", func() {
 			config := Configuration{
 				Mongo: Mongo{
-					ConnectionURL: "localhost:30002,localhost:30001,localhost:30000",
+					ConnectionURI: "localhost:30002,localhost:30001,localhost:30000",
 				},
 			}
 			running := make(chan bool)