diff --git a/tests/src/catalog/cloudant/CloudantBindingTests.scala b/tests/src/catalog/cloudant/CloudantBindingTests.scala
index 21dc64f..175bbb0 100644
--- a/tests/src/catalog/cloudant/CloudantBindingTests.scala
+++ b/tests/src/catalog/cloudant/CloudantBindingTests.scala
@@ -20,7 +20,6 @@
 import org.scalatest.junit.JUnitRunner
 
 import catalog.CloudantUtil
-import common.JsHelpers
 import common.TestHelpers
 import common.Wsk
 import common.WskProps
@@ -32,8 +31,7 @@
 @RunWith(classOf[JUnitRunner])
 class CloudantBindingTests extends FlatSpec
     with TestHelpers
-    with WskTestHelpers
-    with JsHelpers {
+    with WskTestHelpers {
 
     val wskprops = WskProps()
     val wsk = new Wsk
diff --git a/tests/src/catalog/cloudant/CloudantDatabaseActionsTests.scala b/tests/src/catalog/cloudant/CloudantDatabaseActionsTests.scala
new file mode 100644
index 0000000..a9e8325
--- /dev/null
+++ b/tests/src/catalog/cloudant/CloudantDatabaseActionsTests.scala
@@ -0,0 +1,1714 @@
+/*
+ * Copyright 2017 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package catalog.cloudant
+
+import java.util.Date
+
+import catalog.CloudantUtil
+import catalog.CloudantUtil._
+
+import common._
+import org.junit.runner.RunWith
+import org.scalatest.FlatSpec
+import org.scalatest.junit.JUnitRunner
+import spray.json.DefaultJsonProtocol.StringJsonFormat
+import spray.json.DefaultJsonProtocol.ByteJsonFormat
+import spray.json.{JsArray, JsBoolean, JsNumber, JsObject, JsString, pimpAny, pimpString}
+
+@RunWith(classOf[JUnitRunner])
+class CloudantDatabaseActionsTests extends FlatSpec
+    with TestHelpers
+    with WskTestHelpers {
+
+    val wskprops = WskProps()
+    val wsk = new Wsk
+
+    val credential = CloudantUtil.Credential.makeFromVCAPFile("cloudantNoSQLDB", this.getClass.getSimpleName)
+
+    behavior of "Cloudant database actions"
+
+
+    it should """create cloudant document""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                val doc = CloudantUtil.createDocParameterForWhisk().get("doc").getAsString
+                val docJSObj = doc.parseJson.asJsObject
+
+                println("Invoking the create-document action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-document",
+                    Map("doc" -> docJSObj))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        activation.response.result.get.fields.get("id") shouldBe defined
+                }
+                val getResponse = CloudantUtil.getDocument(credential, "testId")
+                Some(JsString(getResponse.get("date").getAsString)) shouldBe docJSObj.fields.get("date")
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """read cloudant document""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test doc
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                println("Invoking the read-document action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/read-document",
+                    Map(
+                        "docid" -> response.get("id").getAsString.toJson,
+                        "params" -> JsObject("revs_info" -> JsBoolean(true))))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        activation.response.result.get.fields.get("date") shouldBe defined
+                        activation.response.result.get.fields.get("_rev") shouldBe defined
+                        activation.response.result.get.fields.get("_revs_info") shouldBe defined
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """read cloudant document with undefined docid""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                println("Invoking the read-document action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/read-document"))
+                    {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("docid is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """update cloudant document""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test doc
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                val docJSObj = doc.parseJson.asJsObject
+                val updatedDoc = JsObject(docJSObj.fields
+                        + ("_rev" -> JsString(response.get("rev").getAsString))
+                        + ("updated" -> JsBoolean(true)))
+
+                println("Invoking the update-document action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/update-document",
+                    Map("doc" -> updatedDoc))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        activation.response.result.get.fields.get("id") shouldBe defined
+                        activation.response.result.get.fields.get("rev") shouldBe defined
+                }
+                val getResponse = CloudantUtil.getDocument(credential, "testId")
+                getResponse.get("updated").getAsBoolean shouldBe true
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """update cloudant document with missing revision""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test doc
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                val docJSObj = doc.parseJson.asJsObject
+                val updatedDoc = JsObject(docJSObj.fields + ("updated" -> JsBoolean(true)))
+
+                println("Invoking the update-document action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/update-document",
+                    Map("doc" -> updatedDoc))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("doc and doc._rev are required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """delete cloudant document""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test doc
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                println("Invoking the delete-document action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-document",
+                    Map("docid" -> response.get("id").getAsString.toJson,
+                        "docrev" -> response.get("rev").getAsString.toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        activation.response.result.get.fields.get("id") shouldBe defined
+                        activation.response.result.get.fields.get("rev") shouldBe defined
+                }
+                //Assert that document does not exist
+                val getResponse = getDocument(credential, response.get("id").getAsString)
+                getResponse.get("error").getAsString shouldBe "not_found"
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """delete cloudant document with undefined docid""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test doc
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                println("Invoking the delete-document action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-document",
+                    Map("docrev" -> response.get("rev").getAsString.toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("docid is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """list cloudant documents""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test doc
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                val docJSObj = doc.parseJson.asJsObject
+                println("Invoking the list-documents action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/list-documents",
+                    Map("doc" -> docJSObj))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        result.fields.get("total_rows") shouldBe Some(JsNumber("1"))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """list cloudant documents with undefined host""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test doc
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                val docJSObj = doc.parseJson.asJsObject
+                println("Invoking the list-documents action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/list-documents",
+                    Map("doc" -> docJSObj))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("cloudant account host is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """list all cloudant design documents""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create design doc
+                val designDoc = CloudantUtil.createDesignFromFile(CloudantUtil.INDEX_DDOC_PATH)
+                val response = CloudantUtil.createIndex(credential, designDoc.toString)
+                response.get("result").getAsString shouldBe "created"
+
+                println("Invoking the list-design-documents action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/list-design-documents",
+                    Map("includedocs" -> "true".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        val rows = result.fields("rows").asInstanceOf[JsArray].elements(0).asJsObject
+                        rows.fields.get("doc") shouldBe defined
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """list all cloudant design documents with undefined dbname""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson))
+                }
+
+                println("Invoking the list-design-documents action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/list-design-documents",
+                    Map("includedocs" -> "true".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("dbname is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """create cloudant query index""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test design index doc
+                val indexDesignDoc = CloudantUtil.createDesignFromFile(INDEX_DDOC_PATH).toString
+                val indexDocJSObj = indexDesignDoc.parseJson.asJsObject
+
+                println("Invoking the create-query-index action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-query-index",
+                    Map("index" -> indexDocJSObj))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        result.fields.get("result") shouldBe Some(JsString("created"))
+                        val docResponse = CloudantUtil.getDocument(credential, "_design/test-query-index")
+                        docResponse.get("views").toString should include ("test-query-index")
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """create cloudant query index with undefined index""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                println("Invoking the create-query-index action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-query-index")) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("index is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """list cloudant query indexes""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test design index doc
+                val indexDesignDoc = CloudantUtil.createDesignFromFile(INDEX_DDOC_PATH).toString
+                val response = CloudantUtil.createDocument(credential, indexDesignDoc)
+                response.get("ok").getAsString shouldBe "true"
+
+                println("Invoking the list-query-indexes action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/list-query-indexes")) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        val indexes = result.fields("indexes").asInstanceOf[JsArray].elements(0).asJsObject
+                        indexes.fields.get("name") shouldBe Some(JsString("_all_docs"))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """list cloudant query indexes with incorrect dbname""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.substring(1).toJson))
+                }
+
+                println("Invoking the list-query-indexes action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/list-query-indexes")) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        activation.response.result.get.fields.get("error") shouldBe defined
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant exec query find""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                val docJSObj = doc.parseJson.asJsObject
+                println("Invoking the exec-query-find action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/exec-query-find",
+                    Map("query" -> JsObject("selector" -> JsObject("_id" -> JsObject("$gt" -> JsNumber(0))))))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        val docs = result.fields("docs").asInstanceOf[JsArray].elements(0).asJsObject
+                        docs.fields.get("date") shouldBe docJSObj.fields.get("date")
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant exec query search""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test document for search query
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                //Create test design doc
+                val designDoc = CloudantUtil.createDesignFromFile(VIEW_AND_SEARCH_DDOC_PATH).toString
+                val getResponse = CloudantUtil.createDocument(credential, designDoc)
+                getResponse.get("ok").getAsString shouldBe "true"
+
+                //Create search query
+                val needle = new Date().toString.substring(0, 2) + '*'
+                println("Invoking the exec-query-search action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/exec-query-search",
+                    Map("search" -> JsObject("q" -> s"date:$needle".toJson),
+                        "docid" -> "test_design".toJson,
+                        "indexname" -> "test_search".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        result.fields.get("bookmark") shouldBe defined
+                        val rows = result.fields("rows").asInstanceOf[JsArray].elements(0).asJsObject
+                        rows.fields.get("id") shouldBe Some(JsString("testId"))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant exec query search with undefined search""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test document for search query
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                //Create test design doc
+                val designDoc = CloudantUtil.createDesignFromFile(VIEW_AND_SEARCH_DDOC_PATH).toString
+                val getResponse = CloudantUtil.createDocument(credential, designDoc)
+                getResponse.get("ok").getAsString shouldBe "true"
+
+                //Create search query
+                println("Invoking the exec-query-search action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/exec-query-search",
+                    Map("docid" -> "test_design".toJson,
+                        "indexname" -> "test_search".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("search query is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant exec query view""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test document for search query
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                //Create test design doc
+                val designDoc = CloudantUtil.createDesignFromFile(VIEW_AND_SEARCH_DDOC_PATH).toString
+                val getResponse = CloudantUtil.createDocument(credential, designDoc)
+                getResponse.get("ok").getAsString shouldBe "true"
+
+                //Create search query
+                println("Invoking the exec-query-view action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/exec-query-view",
+                    Map("docid" -> "test_design".toJson,
+                        "viewname" -> "test_view".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        val rows = result.fields("rows").asInstanceOf[JsArray].elements(0).asJsObject
+                        rows.fields.get("key") shouldBe Some(JsString("testId"))
+                        rows.fields.get("value") shouldBe Some(JsNumber(1))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant exec query view with undefined viewname""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test document for search query
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                //Create test design doc
+                val designDoc = CloudantUtil.createDesignFromFile(VIEW_AND_SEARCH_DDOC_PATH).toString
+                val getResponse = CloudantUtil.createDocument(credential, designDoc)
+                getResponse.get("ok").getAsString shouldBe "true"
+
+                //Create search query
+                println("Invoking the exec-query-view action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/exec-query-view",
+                    Map("docid" -> "test_design".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("viewname is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant delete query index""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test index
+                val index = CloudantUtil.createDesignFromFile(CloudantUtil.INDEX_DDOC_PATH)
+                val response = CloudantUtil.createIndex(credential, index.toString)
+                response.get("result").getAsString shouldBe "created"
+                val id = response.get("id").getAsString
+
+                println("Invoking the delete-query-index action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-query-index",
+                    Map("docid" -> id.toJson,
+                        "indexname" -> index.get("name").getAsString.toJson,
+                        "indextype" -> "json".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        result.fields.get("ok") shouldBe Some(JsBoolean(true))
+                }
+                val getResponse = getDocument(credential, id)
+                getResponse.get("error").getAsString shouldBe "not_found"
+                getResponse.get("reason").getAsString shouldBe "deleted"
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant delete query index with undefined indextype""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test index
+                val index = CloudantUtil.createDesignFromFile(CloudantUtil.INDEX_DDOC_PATH)
+                val response = CloudantUtil.createIndex(credential, index.toString)
+                response.get("result").getAsString shouldBe "created"
+                val id = response.get("id").getAsString
+
+                println("Invoking the delete-query-index action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-query-index",
+                    Map("docid" -> id.toJson,
+                        "indexname" -> index.get("name").getAsString.toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("indextype is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant delete view""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                //Create test index
+                val view = CloudantUtil.createDesignFromFile(VIEW_AND_SEARCH_DDOC_PATH)
+                val response = CloudantUtil.createDocument(credential, view.toString)
+                response.get("ok").getAsString shouldBe "true"
+                val id = response.get("id").getAsString
+
+                println("Invoking the delete-view action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-view",
+                    Map("docid" -> id.toJson,
+                        "viewname" -> "test_view".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        result.fields.get("ok") shouldBe Some(JsBoolean(true))
+                }
+                //Assert that view is deleted
+                val getResponse = getDocument(credential, id)
+                getResponse.get("views").toString shouldBe "{}"
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant delete view with undefined docic""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                println("Invoking the delete-view action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-view",
+                    Map("viewname" -> "test_view".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("docid is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant create bulk documents""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                val numDocs = 5
+                val docsArray = CloudantUtil.createDocumentArray(numDocs).toString
+                val docsJsArray = docsArray.parseJson.asInstanceOf[JsArray]
+
+                println("Invoking the manage-bulk-documents.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/manage-bulk-documents",
+                    Map("docs" -> JsObject("docs" -> docsJsArray)))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        for (i <- 1 to numDocs) {
+                            val response = CloudantUtil.getDocument(credential, s"testId$i")
+                            val doc = result.fields("docs").asInstanceOf[JsArray].elements(i-1).asJsObject
+                            Some(JsString(response.get("_rev").getAsString)) shouldBe doc.fields.get("rev")
+                        }
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant update bulk documents""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                val numDocs = 5
+                val bulkDocs = CloudantUtil.createDocumentArray(numDocs)
+                //Create test docs for updating
+                val responses = CloudantUtil.bulkDocuments(credential, bulkDocs)
+                val updateDocsArray = CloudantUtil.updateDocsWithOnlyIdAndRev(responses).toString
+                val updatedDocsJsArray = updateDocsArray.parseJson.asInstanceOf[JsArray]
+
+                println("Invoking the manage-bulk-documents.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/manage-bulk-documents",
+                    Map("docs" -> JsObject("docs" -> updatedDocsJsArray)))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        for (i <- 1 to numDocs) {
+                            val response = CloudantUtil.getDocument(credential, s"testId$i")
+                            val doc = result.fields("docs").asInstanceOf[JsArray].elements(i-1).asJsObject
+                            Some(JsString(response.get("_rev").getAsString)) shouldBe doc.fields.get("rev")
+                        }
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant update bulk documents with malformed JSON params""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                val numDocs = 5
+                val bulkDocs = CloudantUtil.createDocumentArray(numDocs)
+                //Create test docs for updating
+                val responses = CloudantUtil.bulkDocuments(credential, bulkDocs)
+                val updateDocsArray = CloudantUtil.updateDocsWithOnlyIdAndRev(responses).toString
+                val updatedDocsJsArray = updateDocsArray.parseJson.asInstanceOf[JsArray]
+
+                println("Invoking the manage-bulk-documents.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/manage-bulk-documents",
+                    Map("docs" -> updatedDocsJsArray))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        activation.response.result.get.fields.get("error") shouldBe defined
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant delete bulk documents""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                val numDocs = 5
+                val bulkDocs = CloudantUtil.createDocumentArray(numDocs)
+                //Create test docs for updating
+                val responses = CloudantUtil.bulkDocuments(credential, bulkDocs)
+                //Update document array with deleted field
+                val deleteDocsArray = CloudantUtil.addDeletedPropertyToDocs(responses).toString
+                val deleteddDocsJsArray = deleteDocsArray.parseJson.asInstanceOf[JsArray]
+
+                println("Invoking the manage-bulk-documents.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/manage-bulk-documents",
+                    Map("docs" -> JsObject("docs" -> deleteddDocsJsArray)))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        for (i <- 1 to numDocs) {
+                            val response = CloudantUtil.getDocument(credential, s"testId$i")
+                            response.get("error").getAsString shouldBe "not_found"
+                            response.get("reason").getAsString shouldBe "deleted"
+                        }
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """cloudant delete bulk documents with undefined password""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+                val numDocs = 5
+                val bulkDocs = CloudantUtil.createDocumentArray(numDocs)
+                //Create test docs for updating
+                val responses = CloudantUtil.bulkDocuments(credential, bulkDocs)
+                //Update document array with deleted field
+                val deleteDocsArray = CloudantUtil.addDeletedPropertyToDocs(responses).toString
+                val deleteddDocsJsArray = deleteDocsArray.parseJson.asInstanceOf[JsArray]
+
+                println("Invoking the manage-bulk-documents.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/manage-bulk-documents",
+                    Map("docs" -> JsObject("docs" -> deleteddDocsJsArray)))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("cloudant account password is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """read changes feed""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                val doc = CloudantUtil.createDocParameterForWhisk().get("doc").getAsString
+                val docJSObj = doc.parseJson.asJsObject
+
+                println("Invoking the read-changes-feed action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/read-changes-feed",
+                    Map("doc" -> docJSObj))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        result.fields.get("last_seq") shouldBe defined
+                        result.fields.get("pending") shouldBe Some(JsNumber("0"))
+                        result.fields("results").asInstanceOf[JsArray].elements.size shouldBe 0
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """read changes feed with undefined dbname""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson))
+                }
+
+                val doc = CloudantUtil.createDocParameterForWhisk().get("doc").getAsString
+                val docJSObj = doc.parseJson.asJsObject
+
+                println("Invoking the read-changes-feed action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/read-changes-feed",
+                    Map("doc" -> docJSObj))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("dbname is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """create attachment""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                //Create test document
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                //Get attachment text file
+                val attachFile = CloudantUtil.ATTACHMENT_FILE_PATH
+                val attachmentData = CloudantUtil.readFile(attachFile).trim()
+
+                println("Invoking the create-attachment action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-attachment",
+                    Map("docid" -> response.get("id").getAsString.toJson,
+                        "docrev" -> response.get("rev").getAsString.toJson,
+                        "attachment" -> attachmentData.toJson,
+                        "attachmentname" -> attachFile.getName.toJson,
+                        "contenttype" -> "text/plain".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        activation.response.result.get.fields.get("id") shouldBe defined
+                        activation.response.result.get.fields.get("rev") shouldBe defined
+                }
+                val getResponse = CloudantUtil.getDocument(credential, "testId")
+                getResponse.get("_attachments").getAsJsonObject().has(attachFile.getName()) shouldBe true
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """create attachment with undefined attachment""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                //Create test document
+                val doc = CloudantUtil.createDocParameterForWhisk.get("doc").getAsString
+                val response = CloudantUtil.createDocument(credential, doc)
+                response.get("ok").getAsString shouldBe "true"
+
+                //Get attachment text file
+                val attachFile = CloudantUtil.ATTACHMENT_FILE_PATH
+
+                println("Invoking the create-attachment action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-attachment",
+                    Map("docid" -> response.get("id").getAsString.toJson,
+                        "docrev" -> response.get("rev").getAsString.toJson,
+                        "attachmentname" -> attachFile.getName.toJson,
+                        "contenttype" -> "text/plain".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe defined
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """read attachment""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                val attachFile = CloudantUtil.ATTACHMENT_FILE_PATH
+                val id = CloudantUtil.createDocumentWithAttachment(credential, attachFile).getId
+                val origData = CloudantUtil.readFile(CloudantUtil.ATTACHMENT_FILE_PATH)
+                val bytes = Array.fill[Byte](100)(0)
+
+                println("Invoking the read-attachment action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/read-attachment",
+                    Map("docid" -> id.toJson,
+                        "attachmentname" -> attachFile.getName.toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        var i = 0
+                        result.fields("data").asInstanceOf[JsArray].elements.foreach({ x =>
+                            bytes.update(i, x.convertTo[Byte])
+                            i += 1
+                        })
+                        val byteString = new String(bytes, "utf-8")
+                        origData.trim shouldBe byteString.trim
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """read attachment with undefined attachmentname""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                val attachFile = CloudantUtil.ATTACHMENT_FILE_PATH
+                val id = CloudantUtil.createDocumentWithAttachment(credential, attachFile).getId
+
+                println("Invoking the read-attachment action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/read-attachment",
+                    Map("docid" -> id.toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("attachmentname is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """update attachment""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                val attachFile = CloudantUtil.ATTACHMENT_FILE_PATH
+                val id = CloudantUtil.createDocumentWithAttachment(credential, attachFile).getId
+                val attachmentName = "attach.txt"
+                val getResponse = CloudantUtil.getDocument(credential, id)
+                val attachment = getResponse.get("_attachments").getAsJsonObject.get(attachmentName).getAsJsonObject
+
+                println("Invoking the update-attachment action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/update-attachment",
+                    Map("docid" -> id.toJson,
+                        "attachmentname" -> attachFile.getName.toJson,
+                        "docrev" -> getResponse.get("_rev").getAsString.toJson,
+                        "attachment" -> "new_update_string".toJson,
+                        "attachmentname" -> attachmentName.toJson,
+                        "contenttype" -> "text/plain".toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        val result = activation.response.result.get
+                        result.fields.get("id") shouldBe Some(JsString(id))
+                }
+                val docResponse = getDocument(credential, id)
+                val updatedAttachment = docResponse.get("_attachments").getAsJsonObject.get(attachmentName).getAsJsonObject
+                getResponse.get("_attachments").getAsJsonObject.has(attachmentName) shouldBe true
+                attachment.get("revpos") should not be updatedAttachment.get("revpos")
+                attachment.get("digest") should not be updatedAttachment.get("digest")
+        }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """update attachment with undefined contenttype""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                val attachFile = CloudantUtil.ATTACHMENT_FILE_PATH
+                val id = CloudantUtil.createDocumentWithAttachment(credential, attachFile).getId
+                val attachmentName = "attach.txt"
+                val getResponse = CloudantUtil.getDocument(credential, id)
+
+                println("Invoking the update-attachment action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/update-attachment",
+                    Map("docid" -> id.toJson,
+                        "attachmentname" -> attachFile.getName.toJson,
+                        "docrev" -> getResponse.get("_rev").getAsString.toJson,
+                        "attachment" -> "new_update_string".toJson,
+                        "attachmentname" -> attachmentName.toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe Some(JsString("contenttype is required."))
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """delete attachment""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                //Create document with attachment
+                val attachFile = CloudantUtil.ATTACHMENT_FILE_PATH
+                val id = CloudantUtil.createDocumentWithAttachment(credential, attachFile).getId
+                val getResponse = CloudantUtil.getDocument(credential, id)
+
+                println("Invoking the delete-attachment action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-attachment",
+                    Map("docid" -> getResponse.get("_id").getAsString.toJson,
+                        "docrev" -> getResponse.get("_rev").getAsString.toJson,
+                        "attachmentname" -> attachFile.getName.toJson))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        activation.response.result.get.fields.get("id") shouldBe defined
+                        activation.response.result.get.fields.get("rev") shouldBe defined
+                }
+                //Assert that attachment does not exist in doc
+                val response = getDocument(credential, id).toString
+                val docJSObject = response.parseJson.asJsObject
+                docJSObject.fields.get("_attachments") should not be defined
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+
+    it should """delete attachment with undefined doc revision""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp
+            val packageName = "dummyCloudantPackage"
+
+            try {
+                CloudantUtil.setUp(credential)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("Creating cloudant package binding.")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> credential.user.toJson,
+                                "password" -> credential.password.toJson,
+                                "host" -> credential.host().toJson,
+                                "dbname" -> credential.dbname.toJson))
+                }
+
+                //Create document with attachment
+                val attachFile = CloudantUtil.ATTACHMENT_FILE_PATH
+                val id = CloudantUtil.createDocumentWithAttachment(credential, attachFile).getId
+                val getResponse = CloudantUtil.getDocument(credential, id)
+
+                println("Invoking the delete-attachment action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-attachment",
+                    Map("docid" -> getResponse.get("_id").getAsString.toJson,
+                        "attachmentname" -> attachFile.getName.toJson))) {
+                    activation =>
+                        activation.response.success shouldBe false
+                        val result = activation.response.result.get
+                        result.fields.get("error") shouldBe defined
+                }
+            }
+            finally {
+                CloudantUtil.unsetUp(credential)
+            }
+    }
+}