Moar tests!

apigeeSync_suite_test.go

diff --git a/apigeeSync_suite_test.go b/apigeeSync_suite_test.go
index 93c70fb..ef8a1f6 100644
--- a/apigeeSync_suite_test.go
+++ b/apigeeSync_suite_test.go
@@ -21,12 +21,13 @@
 	tmpDir     string
 	testServer *httptest.Server
 	testRouter apid.Router
-	phase 	   int
 )
 
 const testScope = "bootstrap"
 
-var _ = BeforeSuite(func() {
+var _ = BeforeSuite(func(done Done) {
+	var phase int
+
 	apid.Initialize(factory.DefaultServicesFactory())
 
 	config := apid.Config()
@@ -50,7 +51,6 @@
 	config.Set(configConsumerKey, "XXXXXXX")
 	config.Set(configConsumerSecret, "YYYYYYY")
 
-
 	// mock upstream testServer
 	testRouter.HandleFunc("/accesstoken", func(w http.ResponseWriter, req *http.Request) {
 		defer GinkgoRecover()
@@ -261,6 +261,97 @@
 
 	}).Methods("GET")
 
+	// This is actually the first test :)
+	// Tests that entire bootstrap and set of sync operations work
+	apid.Events().ListenFunc(ApigeeSyncEventSelector, func(event apid.Event) {
+		defer GinkgoRecover()
+
+		if s, ok := event.(*common.Snapshot); ok {
+
+			Expect(s.SnapshotInfo).Should(Equal("snapinfo1"))
+
+			for _, t := range s.Tables {
+				switch t.Name {
+
+				case "edgex.apid_cluster":
+					Expect(t.Rows).To(HaveLen(1))
+					r := t.Rows[0]
+					var cs, id string
+					r.Get("_change_selector", &cs)
+					r.Get("id", &id)
+
+					Expect(cs).To(Equal("bootstrap"))
+					Expect(id).To(Equal("bootstrap"))
+
+				case "edgex.data_scope":
+					Expect(t.Rows).To(HaveLen(1))
+					r := t.Rows[0]
+
+					var cs, id, clusterID, env, org, scope string
+					r.Get("_change_selector", &cs)
+					r.Get("id", &id)
+					r.Get("apid_cluster_id", &clusterID)
+					r.Get("env", &env)
+					r.Get("org", &org)
+					r.Get("scope", &scope)
+
+					Expect(id).To(Equal("apid_config_scope_id_0"))
+					Expect(cs).To(Equal("apid_config_scope_id_0"))
+					Expect(clusterID).To(Equal("bootstrap"))
+					Expect(env).To(Equal("prod"))
+					Expect(org).To(Equal("att"))
+					Expect(scope).To(Equal("ert452"))
+
+				case "kms.api_product":
+					Expect(t.Rows).To(HaveLen(0))
+
+				default:
+					Fail("invalid table: " + t.Name)
+				}
+			}
+
+		} else if cl, ok := event.(*common.ChangeList); ok {
+
+			Expect(cl.LastSequence).To(Equal("lastSeq_01"))
+			Expect(cl.Changes).To(HaveLen(1))
+
+			c := cl.Changes[0]
+			Expect(c.Table).To(Equal("edgex.data_scope"))
+			Expect(c.Operation).To(Equal(common.Insert))
+
+			Expect(c.NewRow).ToNot(BeNil())
+
+			var id, clusterID, env, org, scope string
+			c.NewRow.Get("id", &id)
+			c.NewRow.Get("apid_cluster_id", &clusterID)
+			c.NewRow.Get("env", &env)
+			c.NewRow.Get("org", &org)
+			c.NewRow.Get("scope", &scope)
+
+			Expect(id).To(Equal("apid_config_scope_id_1"))
+			Expect(clusterID).To(Equal("bootstrap"))
+			Expect(env).To(Equal("prod"))
+			Expect(org).To(Equal("att"))
+			Expect(scope).To(Equal("ert452"))
+
+			events.ListenFunc(apid.EventDeliveredSelector, func(e apid.Event) {
+				defer GinkgoRecover()
+
+				// allow other handler to execute to insert last_sequence
+				time.Sleep(50 * time.Millisecond)
+				var seq string
+				err = getDB().
+					QueryRow("SELECT last_sequence FROM APID_CLUSTER LIMIT 1;").
+					Scan(&seq)
+
+				Expect(err).NotTo(HaveOccurred())
+				Expect(seq).To(Equal("lastSeq_01"))
+
+				close(done)
+			})
+		}
+	})
+
 	apid.InitializePlugins()
 })
 

apigee_sync.go

diff --git a/apigee_sync.go b/apigee_sync.go
index 1ffaa18..9f02e91 100644
--- a/apigee_sync.go
+++ b/apigee_sync.go
@@ -30,8 +30,8 @@
 
 		if ev, ok := ede.Event.(*common.ChangeList); ok {
 			lastSequence = ev.LastSequence
-			status := persistChange(lastSequence)
-			if status == false {
+			err := persistChange(lastSequence)
+			if err != nil {
 				log.Panic("Unable to update Sequence in DB")
 			}
 			changeFinished = true

data.go

diff --git a/data.go b/data.go
index ee245b6..90e40ce 100644
--- a/data.go
+++ b/data.go
@@ -220,35 +220,28 @@
  * Persist the last change Id each time a change has been successfully
  * processed by the plugin(s)
  */
-func persistChange(lastChange string) bool {
+func persistChange(lastChange string) error {
 
 	log.Debugf("persistChange: %s", lastChange)
 
 	db := getDB()
 
-	txn, err := db.Begin()
-	if err != nil {
-		log.Errorf("Unable to create Sqlite transaction: %v", err)
-		return false
-	}
-	prep, err := txn.Prepare("UPDATE APID_CLUSTER SET last_sequence=$1;")
+	stmt, err := db.Prepare("UPDATE APID_CLUSTER SET last_sequence=$1;")
 	if err != nil {
 		log.Errorf("UPDATE APID_CLUSTER Failed: %v", err)
-		return false
+		return err
 	}
-	defer prep.Close()
-	s := txn.Stmt(prep)
-	_, err = s.Exec(lastChange)
-	s.Close()
+	defer stmt.Close()
+
+	_, err = stmt.Exec(lastChange)
 	if err != nil {
 		log.Errorf("UPDATE DATA_SCOPE Failed: %v", err)
-		txn.Rollback()
-		return false
+		return err
 	}
 
-	log.Info("UPDATE DATA_SCOPE Success: (", lastChange, ")")
-	txn.Commit()
-	return true
+	log.Infof("UPDATE DATA_SCOPE Success: %s", lastChange)
+
+	return nil
 }
 
 func getApidInstanceInfo() (info apidInstanceInfo, err error) {