add test case

api.go

diff --git a/api.go b/api.go
index 3d4fe23..e757122 100644
--- a/api.go
+++ b/api.go
@@ -307,7 +307,7 @@
 			Env:            d.EnvID,
 			Scope:          a.getDeploymentScope(),
 			Revision:       d.Revision,
-			BlobId:         d.GWBlobID,
+			BlobId:         d.BlobID,
 			BlobURL:        d.BlobURL,
 			ResourceBlobId: d.BlobResourceID,
 			Created:        convertTime(d.Created),

api_test.go

diff --git a/api_test.go b/api_test.go
index aceb65d..9e89b7c 100644
--- a/api_test.go
+++ b/api_test.go
@@ -19,8 +19,11 @@
 	"net/http"
 	"net/url"
 
+	"crypto/rand"
+	"fmt"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
+	mathrand "math/rand"
 	"strconv"
 	"time"
 )
@@ -32,13 +35,14 @@
 var _ = Describe("api", func() {
 	Context("GET /deployments", func() {
 		var testCount int
+		var dummyDbMan *dummyDbManager
 		var testApiMan *apiManager
 
 		var _ = BeforeEach(func() {
 			testCount += 1
-			dbMan := &dummyDbMan{}
+			dummyDbMan = &dummyDbManager{}
 			testApiMan = &apiManager{
-				dbMan:               dbMan,
+				dbMan:               dummyDbMan,
 				deploymentsEndpoint: deploymentsEndpoint + strconv.Itoa(testCount),
 				blobEndpoint:        blobEndpointPath + strconv.Itoa(testCount) + "/{blobId}",
 				eTag:                int64(testCount * 10),
@@ -58,53 +62,166 @@
 			uri, err := url.Parse(testUrl)
 			Expect(err).Should(Succeed())
 			uri.Path = deploymentsEndpoint + strconv.Itoa(testCount)
-			log.Debug("uri string: " + uri.String())
-			log.Debug("port: " + config.GetString("api_port"))
 
+			// http get
 			res, err := http.Get(uri.String())
 			Expect(err).Should(Succeed())
 			defer res.Body.Close()
-
 			Expect(res.StatusCode).Should(Equal(http.StatusOK))
-
+			// parse response
 			var depRes ApiDeploymentResponse
 			body, err := ioutil.ReadAll(res.Body)
-			Expect(err).ShouldNot(HaveOccurred())
-			json.Unmarshal(body, &depRes)
-
+			Expect(err).Should(Succeed())
+			err = json.Unmarshal(body, &depRes)
+			Expect(err).Should(Succeed())
+			// verify response
 			Expect(len(depRes.ApiDeploymentsResponse)).To(Equal(0))
 			Expect(depRes.Kind).Should(Equal(kindCollection))
 			Expect(depRes.Self).Should(Equal(testUrl + deploymentsEndpoint + strconv.Itoa(testCount)))
 
 		})
+
+		It("should get correct config format", func() {
+			uri, err := url.Parse(testUrl)
+			Expect(err).Should(Succeed())
+			uri.Path = deploymentsEndpoint + strconv.Itoa(testCount)
+
+			// set test data
+			details := setTestDeployments(dummyDbMan, uri.String())
+
+			// http get
+			res, err := http.Get(uri.String())
+			Expect(err).Should(Succeed())
+			defer res.Body.Close()
+			Expect(res.StatusCode).Should(Equal(http.StatusOK))
+			// parse response
+			var depRes ApiDeploymentResponse
+			body, err := ioutil.ReadAll(res.Body)
+			Expect(err).Should(Succeed())
+			err = json.Unmarshal(body, &depRes)
+			Expect(err).Should(Succeed())
+			// verify response
+			Expect(depRes.Kind).Should(Equal(kindCollection))
+			Expect(depRes.Self).Should(Equal(uri.String()))
+			Expect(depRes.ApiDeploymentsResponse).Should(Equal(details))
+
+		})
+
+		It("should debounce requests", func(done Done) {
+			var in = make(chan interface{})
+			var out = make(chan []interface{})
+
+			go testApiMan.debounce(in, out, 3*time.Millisecond)
+
+			go func() {
+				defer GinkgoRecover()
+
+				received, ok := <-out
+				Expect(ok).To(BeTrue())
+				Expect(len(received)).To(Equal(2))
+
+				close(in)
+				received, ok = <-out
+				Expect(ok).To(BeFalse())
+
+				close(done)
+			}()
+
+			in <- "x"
+			in <- "y"
+		})
+
 	})
 })
 
-type dummyDbMan struct {
+func setTestDeployments(dummyDbMan *dummyDbManager, self string) []ApiDeploymentDetails {
+	deployments := make([]DataDeployment, 0)
+	details := make([]ApiDeploymentDetails, 0)
+	mathrand.Seed(time.Now().UnixNano())
+	count := mathrand.Intn(5) + 1
+
+	for i := 0; i < count; i++ {
+		dep := DataDeployment{
+			ID:             GenerateUUID(),
+			OrgID:          GenerateUUID(),
+			EnvID:          GenerateUUID(),
+			Type:           "virtual-host",
+			Name:           "vh-secure",
+			Revision:       "1",
+			BlobID:         GenerateUUID(),
+			GWBlobID:       GenerateUUID(),
+			BlobResourceID: GenerateUUID(),
+			Updated:        time.Now().Format(time.RFC3339),
+			UpdatedBy:      "haoming@google.com",
+			Created:        time.Now().Format(time.RFC3339),
+			CreatedBy:      "haoming@google.com",
+			BlobFSLocation: "BlobFSLocation",
+			BlobURL:        "http://localhost:6666/testBlobURL",
+		}
+
+		detail := ApiDeploymentDetails{
+			Self:           self + "/" + dep.ID,
+			Name:           dep.Name,
+			Type:           dep.Type,
+			Org:            dep.OrgID,
+			Env:            dep.EnvID,
+			Scope:          "",
+			Revision:       dep.Revision,
+			BlobId:         dep.BlobID,
+			BlobURL:        dep.BlobURL,
+			ResourceBlobId: dep.BlobResourceID,
+			Created:        dep.Created,
+			Updated:        dep.Updated,
+		}
+
+		deployments = append(deployments, dep)
+		details = append(details, detail)
+	}
+
+	dummyDbMan.readyDeployments = deployments
+	dummyDbMan.unreadyDeployments = deployments
+
+	return details
+}
+
+type dummyDbManager struct {
 	unreadyDeployments []DataDeployment
 	readyDeployments   []DataDeployment
 }
 
-func (d *dummyDbMan) setDbVersion(version string) {
+func (d *dummyDbManager) setDbVersion(version string) {
 
 }
 
-func (d *dummyDbMan) initDb() error {
+func (d *dummyDbManager) initDb() error {
 	return nil
 }
 
-func (d *dummyDbMan) getUnreadyDeployments() ([]DataDeployment, error) {
+func (d *dummyDbManager) getUnreadyDeployments() ([]DataDeployment, error) {
 	return d.unreadyDeployments, nil
 }
 
-func (d *dummyDbMan) getReadyDeployments() ([]DataDeployment, error) {
-	return nil, nil
+func (d *dummyDbManager) getReadyDeployments() ([]DataDeployment, error) {
+	return d.readyDeployments, nil
 }
 
-func (d *dummyDbMan) updateLocalFsLocation(string, string, string) error {
+func (d *dummyDbManager) updateLocalFsLocation(string, string, string) error {
 	return nil
 }
 
-func (d *dummyDbMan) getLocalFSLocation(string) (string, error) {
+func (d *dummyDbManager) getLocalFSLocation(string) (string, error) {
 	return "", nil
 }
+
+func GenerateUUID() string {
+
+	buff := make([]byte, 16)
+	numRead, err := rand.Read(buff)
+	if numRead != len(buff) || err != nil {
+		panic(err)
+	}
+	/* uuid v4 spec */
+	buff[6] = (buff[6] | 0x40) & 0x4F
+	buff[8] = (buff[8] | 0x80) & 0xBF
+	return fmt.Sprintf("%x-%x-%x-%x-%x", buff[0:4], buff[4:6], buff[6:8], buff[8:10], buff[10:])
+}