diff --git a/.gitignore b/.gitignore
index c95e0ad..7f6823b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,2 @@
-/node_modules/
-*.log
+.gradle
+build/
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..4398fee
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1,14 @@
+include 'tests', ':WhiskTest', ':common:scala', ':core:invoker', ':core:controller'
+
+rootProject.name = 'openwhisk-cloudant-trigger'
+def whiskhome = "$System.env.OPENWHISK_HOME"
+
+project(':WhiskTest').projectDir = new File(whiskhome, 'tests')
+project(':common:scala').projectDir = new File(whiskhome + '/common', 'scala')
+project(':core:invoker').projectDir = new File(whiskhome + '/core', 'invoker')
+project(':core:controller').projectDir = new File(whiskhome + '/core', 'controller')
+
+gradle.ext.scala = [
+        version: '2.11.8',
+        compileFlags: ['-feature', '-unchecked', '-deprecation', '-Xfatal-warnings', '-Ywarn-unused-import']
+]
\ No newline at end of file
diff --git a/tests/build.gradle b/tests/build.gradle
new file mode 100644
index 0000000..78e38eb
--- /dev/null
+++ b/tests/build.gradle
@@ -0,0 +1,69 @@
+def whiskhome = "$System.env.OPENWHISK_HOME"
+
+apply plugin: 'scala'
+apply plugin: 'eclipse'
+compileTestScala.options.encoding = 'UTF-8'
+
+repositories {
+    mavenCentral()
+    maven {
+        url 'https://oss.sonatype.org/content/repositories/snapshots/'
+    }
+}
+
+sourceSets {
+    test {
+        scala {
+            srcDirs = ['src/']
+        }
+    }
+}
+
+test {
+    systemProperty 'testthreads', System.getProperty('testthreads', '1')
+    testLogging {
+        events "passed", "skipped", "failed"
+        showStandardStreams = true
+        exceptionFormat = 'full'
+    }
+    outputs.upToDateWhen { false } // force tests to run everytime
+}
+
+dependencies {
+    testCompile "org.scala-lang:scala-library:${gradle.scala.version}"
+    testCompile 'org.apache.commons:commons-exec:1.1'
+    testCompile 'org.apache.commons:commons-lang3:3.3.2'
+    testCompile 'commons-logging:commons-logging:1.1.3'
+    testCompile 'org.codehaus.groovy:groovy:2.4.3'
+    testCompile 'org.codehaus.groovy:groovy-json:2.4.3'
+    testCompile 'org.codehaus.groovy:groovy-xml:2.4.3'
+    testCompile 'com.google.guava:guava:18.0'
+    testCompile 'org.hamcrest:hamcrest-core:1.3'
+    testCompile 'org.apache.httpcomponents:httpmime:4.3.6'
+    testCompile 'junit:junit:4.11'
+    testCompile 'com.jayway.restassured:rest-assured:2.4.1'
+    testCompile 'org.scalatest:scalatest_2.11:2.2.4'
+    testCompile 'org.seleniumhq.selenium:selenium-java:2.45.0'
+    testCompile 'io.spray:spray-testkit_2.11:1.3.3'
+    testCompile 'io.spray:spray-json_2.11:1.3.2'
+    testCompile 'com.google.code.tempus-fugit:tempus-fugit:1.2-SNAPSHOT'
+    testCompile 'com.google.code.gson:gson:2.3.1'
+    testCompile 'com.cloudant:cloudant-client:1.0.1'
+    testCompile project(':WhiskTest').sourceSets.test.output
+}
+
+tasks.withType(ScalaCompile) {
+    scalaCompileOptions.additionalParameters = gradle.scala.compileFlags
+}
+
+def keystorePath = new File(buildDir, 'classes/test/keystore')
+task deleteKeystore(type: Delete) {
+    delete keystorePath
+}
+task createKeystore(dependsOn: deleteKeystore) << {
+    Properties props = new Properties()
+    props.load(new FileInputStream(file(whiskhome+'/whisk.properties')))
+    def cmd = ['keytool', '-import', '-alias', 'Whisk', '-noprompt', '-trustcacerts', '-file', file(props['whisk.ssl.cert']), '-keystore', keystorePath, '-storepass', 'openwhisk']
+    cmd.execute().waitForProcessOutput(System.out, System.err)
+}
+compileTestScala.finalizedBy createKeystore
diff --git a/tests/dat/attach.txt b/tests/dat/attach.txt
new file mode 100644
index 0000000..630ac45
--- /dev/null
+++ b/tests/dat/attach.txt
@@ -0,0 +1 @@
+My hovercraft is full of eels!
diff --git a/tests/dat/indexdesigndoc.txt b/tests/dat/indexdesigndoc.txt
new file mode 100644
index 0000000..0ea3d2b
--- /dev/null
+++ b/tests/dat/indexdesigndoc.txt
@@ -0,0 +1,8 @@
+{
+  "ddoc":"test-query-index",
+  "name": "test-query-index",
+  "type": "json", 
+  "index": {
+    "fields": ["date"]
+  }
+}
diff --git a/tests/dat/searchdesigndoc.txt b/tests/dat/searchdesigndoc.txt
new file mode 100644
index 0000000..833827c
--- /dev/null
+++ b/tests/dat/searchdesigndoc.txt
@@ -0,0 +1,15 @@
+{
+  "_id": "_design/test_design",
+  "views": {
+    "test_view": {
+      "map": "function (doc) {\n  emit(doc._id, 1);\n}"
+    }
+  },
+  "language": "javascript",
+  "indexes": {
+    "test_search": {
+      "analyzer": "standard",
+      "index": "function (doc) {\n  index(\"date\", doc.date);\n}"
+    }
+  }
+}
diff --git a/tests/src/catalog/CloudantUtil.java b/tests/src/catalog/CloudantUtil.java
new file mode 100755
index 0000000..e4fd188
--- /dev/null
+++ b/tests/src/catalog/CloudantUtil.java
@@ -0,0 +1,373 @@
+/*
+ * 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;
+
+import com.cloudant.client.api.CloudantClient;
+import com.cloudant.client.api.Database;
+import com.google.gson.*;
+import com.jayway.restassured.response.Response;
+import common.Pair;
+import common.TestUtils;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Date;
+import java.util.Map;
+import java.util.Properties;
+import java.util.UUID;
+
+import static com.jayway.restassured.RestAssured.given;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Basic tests of the cloudant trigger function.
+ */
+public class CloudantUtil {
+    public static final String USER_PROPERTY = "user";
+    public static final String PWD_PROPERTY = "password";
+    public static final String DBNAME_PROPERTY = "dbname";
+    public static final String DOC_ID = "testId";
+    public static final File ATTACHMENT_FILE_PATH = getFileRelativeToCloudantHome("tests/dat/attach.txt");
+    public static final File INDEX_DDOC_PATH = getFileRelativeToCloudantHome("tests/dat/indexdesigndoc.txt");
+    public static final File VIEW_AND_SEARCH_DDOC_PATH = getFileRelativeToCloudantHome("tests/dat/searchdesigndoc.txt");
+
+    /**
+     * The root of the Cloudant installation.
+     */
+    private static final String cloudantHome = getCloudantHome();
+    private static final String CLOUDANT_INSTALL_FILE = "installCatalog.sh";
+
+    private static Gson gson = new Gson();
+
+    public static class Credential {
+        public final String user;
+        public final String password;
+        public final String dbname;
+
+        public String host() {
+            return user + ".cloudant.com";
+        }
+
+        public Credential(String user, String password, String dbname) {
+            this.user = user;
+            this.password = password;
+            this.dbname = dbname;
+        }
+
+        public Credential(Properties props) {
+            this(props.getProperty(USER_PROPERTY), props.getProperty(PWD_PROPERTY), props.getProperty(DBNAME_PROPERTY));
+        }
+
+        public static Credential makeFromVCAPFile(String vcapService, String dbNamePrefix) {
+            // Create database name using dbNamePrefix and generated uuid
+            String uniqueSuffix = UUID.randomUUID().toString().replace("-", "");
+            String dbname = dbNamePrefix.toLowerCase() + "-" + uniqueSuffix;
+
+            Map<String,String> credentials = TestUtils.getVCAPcredentials(vcapService);
+            String username = credentials.get("username");
+            String password = credentials.get("password");
+            Properties props = new Properties();
+            props.setProperty(USER_PROPERTY, username);
+            props.setProperty(PWD_PROPERTY, password);
+            props.setProperty(DBNAME_PROPERTY, dbname);
+            return new Credential(props);
+        }
+
+    }
+
+    public static void setUp(Credential credential) throws Exception {
+        deleteTestDatabase(credential);
+        for (int i = 0; i < 5; i++) {
+            try {
+                Pair<Integer, JsonObject> response = CloudantUtil.createTestDatabase(credential, false);
+                if (response.fst == 201)
+                    return;
+                // respond code is sometimes not 201 but still ok
+                // (might be 200 or 202)
+                if (response.snd.has("ok")) {
+                    if (response.snd.get("ok").getAsBoolean())
+                        return;
+                }
+                if (response.snd.has("reason")) {
+                    String reason = response.snd.get("reason").getAsString();
+                    if (reason.contains("exists"))
+                        return;
+                }
+            } catch (Throwable t) {
+                Thread.sleep(1000);
+            }
+        }
+        assertTrue("failed to create database " + credential.dbname, false);
+    }
+
+    public static void unsetUp(Credential credential) throws Exception {
+        deleteTestDatabase(credential);
+    }
+
+    /**
+     * Delete a user-specific Cloudant database.
+     *
+     * @throws UnsupportedEncodingException
+     * @throws InterruptedException
+     */
+    public static JsonObject deleteTestDatabase(Credential credential) throws UnsupportedEncodingException, InterruptedException {
+        return deleteTestDatabase(credential, null);
+    }
+
+    public static JsonObject deleteTestDatabase(Credential credential, String dbName) throws UnsupportedEncodingException, InterruptedException {
+        // Use DELETE to delete the database.
+        // This could fail if the database already exists, but that's ok.
+        Response response = null;
+        String db = (dbName != null && !dbName.isEmpty()) ? dbName : credential.dbname;
+        assertTrue("failed to determine database name", db != null && !db.isEmpty());
+        response = given().port(443).baseUri(cloudantAccount(credential.user)).auth().basic(credential.user, credential.password).when().delete("/" + db);
+        System.out.format("Response of delete database %s: %s\n", db, response.asString());
+        return (JsonObject) new JsonParser().parse(response.asString());
+    }
+
+    /**
+     * Create a user-specific Cloudant database that will be used for this test.
+     *
+     * @throws UnsupportedEncodingException
+     */
+    public static Pair<Integer, JsonObject> createTestDatabase(Credential credential) throws UnsupportedEncodingException {
+        return createTestDatabase(credential, true);
+    }
+
+    private static Pair<Integer, JsonObject> createTestDatabase(Credential credential, boolean failIfCannotCreate) throws UnsupportedEncodingException {
+        // Use PUT to create the database.
+        // This could fail if the database already exists, but that's ok.
+        String dbName = credential.dbname;
+        assertTrue("failed to determine database name", dbName != null && !dbName.isEmpty());
+        Response response = given().port(443).baseUri(cloudantAccount(credential.user)).auth().basic(credential.user, credential.password).when().put("/" + dbName);
+        System.out.format("Response of create database %s: %s\n", dbName, response.asString());
+        if (failIfCannotCreate)
+            assertTrue("failed to create database " + dbName, response.statusCode() == 201 || response.statusCode() == 202);
+        return Pair.make(response.statusCode(), (JsonObject) new JsonParser().parse(response.asString()));
+    }
+
+    /**
+     * read a user-specific Cloudant database to verify database action test
+     * cases.
+     *
+     * @throws UnsupportedEncodingException
+     */
+    public static Response readTestDatabase(Credential credential) {
+        return readTestDatabase(credential, null);
+    }
+
+    public static Response readTestDatabase(Credential credential, String dbName) {
+        try {
+            Response response = null;
+            String db = (dbName != null && !dbName.isEmpty()) ? dbName : credential.dbname;
+            response = given().port(443).baseUri(cloudantAccount(credential.user)).auth().basic(credential.user, credential.password).when().get("/" + db);
+            System.out.format("Response of HTTP GET for database %s: %s\n", credential.dbname, response.asString());
+            return response;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * create a document in the cloudant database
+     *
+     * @throws UnsupportedEncodingException
+     */
+    public static JsonObject createDocument(Credential credential, String jsonObj) throws UnsupportedEncodingException {
+        JsonObject obj = new JsonParser().parse(jsonObj).getAsJsonObject();
+
+        CloudantClient client = new CloudantClient(credential.user, credential.user, credential.password);
+        Database db = client.database(credential.dbname, false);
+        com.cloudant.client.api.model.Response res = db.post(obj);
+        client.shutdown();
+
+        JsonObject ret = new JsonObject();
+        ret.addProperty("ok", true);
+        ret.addProperty("id", res.getId());
+        ret.addProperty("rev", res.getRev());
+        return ret;
+    }
+
+    /**
+     * get a document from the cloudant database
+     *
+     * @throws UnsupportedEncodingException
+     */
+    public static JsonObject getDocument(Credential credential, String docId) throws UnsupportedEncodingException {
+        // use GET to get the document
+        Response response = given().port(443).baseUri(cloudantAccount(credential.user)).auth().basic(credential.user, credential.password).get("/" + credential.dbname + "/" + docId);
+        String responseStr = response.asString();
+        if (responseStr.length() > 500)
+            responseStr = responseStr.substring(0, 500);
+        System.out.format("Response of get document from database %s: %s\n", credential.dbname, responseStr);
+        return (JsonObject) new JsonParser().parse(response.asString());
+    }
+
+    /**
+     * delete a document from the cloudant database
+     *
+     * @throws UnsupportedEncodingException
+     */
+    public static JsonObject deleteDocument(Credential credential, String docId) throws UnsupportedEncodingException {
+        // use GET to get the document
+        Response response = given().port(443).baseUri(cloudantAccount(credential.user)).auth().basic(credential.user, credential.password).delete("/" + credential.dbname + "/" + docId);
+        System.out.format("Response of delete document in database %s: %s\n", credential.dbname, response.asString());
+        assertTrue("failed to delete document in database " + credential.dbname, response.statusCode() == 200 || response.statusCode() == 202);
+        return (JsonObject) new JsonParser().parse(response.asString());
+    }
+
+    /**
+     * Read bulk documents from the cloudant database
+     *
+     * @throws UnsupportedEncodingException
+     */
+    public static JsonArray bulkDocuments(Credential credential, JsonArray bulkDocs) throws UnsupportedEncodingException {
+        JsonObject docs = new JsonObject();
+        docs.add("docs", bulkDocs);
+        // use GET to get the document
+        String dbname = credential.dbname;
+        Response response = given().port(443).baseUri(cloudantAccount(credential.user)).auth().basic(credential.user, credential.password).contentType("application/json").body(docs).post("/" + credential.dbname + "/_bulk_docs?include_docs=true");
+        String responseStr = response.asString();
+        if (responseStr.length() > 500)
+            responseStr = responseStr.substring(0, 500);
+        System.out.format("Response of get document from database %s: %s\n", dbname, responseStr);
+        return (JsonArray) new JsonParser().parse(response.asString());
+    }
+
+    public static JsonObject createDocParameterForWhisk() {
+        return createDocParameterForWhisk(null);
+    }
+
+    public static JsonObject createDocParameterForWhisk(String doc) {
+        JsonObject cloudantDoc = new JsonObject();
+        String now = new Date().toString();
+        cloudantDoc.addProperty("_id", DOC_ID);
+        cloudantDoc.addProperty("date", now);
+        // Create JSON object that will be passed as an argument to whisk cli
+        JsonObject param = new JsonObject();
+        if (doc != null && !doc.isEmpty()) {
+            param.addProperty("doc", doc);
+        } else {
+            param.addProperty("doc", cloudantDoc.toString());
+        }
+        return param;
+    }
+
+    public static JsonArray createDocumentArray(int numDocs) {
+        // Array of docs for bulk
+        JsonArray bulkDocs = new JsonArray();
+        for (int i = 1; i <= numDocs; i++) {
+            JsonObject cloudantDoc = new JsonObject();
+            String now = new Date().toString();
+            cloudantDoc.addProperty("_id", CloudantUtil.DOC_ID + i);
+            cloudantDoc.addProperty("date", now);
+            bulkDocs.add(cloudantDoc);
+        }
+        return bulkDocs;
+    }
+
+    /**
+     * Only keep _id and _rev for each document in the JSON array.
+     */
+    public static JsonArray updateDocsWithOnlyIdAndRev(JsonArray docs) {
+        for (int i = 0; i < docs.size(); i++) {
+            JsonElement id = docs.get(i).getAsJsonObject().get("id");
+            JsonElement rev = docs.get(i).getAsJsonObject().get("rev");
+            docs.get(i).getAsJsonObject().add("_id", id);
+            docs.get(i).getAsJsonObject().add("_rev", rev);
+        }
+        return docs;
+    }
+
+    public static JsonArray addDeletedPropertyToDocs(JsonArray docs) {
+        for (int i = 0; i < docs.size(); i++) {
+            JsonElement id = docs.get(i).getAsJsonObject().get("id");
+            JsonElement rev = docs.get(i).getAsJsonObject().get("rev");
+            docs.get(i).getAsJsonObject().add("_id", id);
+            docs.get(i).getAsJsonObject().add("_rev", rev);
+            docs.get(i).getAsJsonObject().addProperty("_deleted", true);
+        }
+        return docs;
+    }
+
+    public static JsonObject createDesignFromFile(File jsonFile) throws JsonSyntaxException, IOException {
+        return gson.fromJson(readFile(jsonFile), JsonObject.class);
+    }
+
+    public static String readFile(File jsonFile) throws IOException {
+        return new String(Files.readAllBytes(jsonFile.toPath()), StandardCharsets.UTF_8);
+    }
+
+    /**
+     * Create an index in the cloudant database
+     *
+     * @throws UnsupportedEncodingException
+     */
+    public static JsonObject createIndex(Credential credential, String jsonObj) throws UnsupportedEncodingException {
+        Response response = given().port(443).baseUri(cloudantAccount(credential.user)).auth().basic(credential.user, credential.password).contentType("application/json").body(jsonObj).when().post("/" + credential.dbname + "/_index");
+        System.out.format("Response of create document in database %s: %s\n", credential.dbname, response.asString());
+        assertTrue("failed to create index in database " + credential.dbname, response.statusCode() == 200);
+        return (JsonObject) new JsonParser().parse(response.asString());
+    }
+
+    /**
+     * Create a document with attachment in a cloudant database
+     *
+     * @throws UnsupportedEncodingException
+     * @throws FileNotFoundException
+     */
+    public static com.cloudant.client.api.model.Response createDocumentWithAttachment(Credential credential, File attachmentFilePath) throws UnsupportedEncodingException, FileNotFoundException {
+        InputStream attachStream = new FileInputStream(attachmentFilePath);
+        String contentType = "text/plain";
+
+        CloudantClient client = new CloudantClient(credential.user, credential.user, credential.password);
+        Database db = client.database(credential.dbname, false);
+        return db.saveAttachment(attachStream, attachmentFilePath.getName(), contentType);
+    }
+
+    private static String cloudantAccount(String user) {
+        return "https://" + user + ".cloudant.com";
+    }
+
+    public static File getFileRelativeToCloudantHome(String name) {
+        return new File(cloudantHome, name);
+    }
+
+    private static String getCloudantHome() {
+        String dir = System.getProperty("user.dir");
+
+        if (dir != null) {
+            // Look in the directory tree recursively.
+            File propfile = findFileRecursively(dir, CLOUDANT_INSTALL_FILE);
+            return propfile != null ? propfile.getParent() : null;
+        } else return null;
+    }
+
+    private static File findFileRecursively(String dir, String needle) {
+        if (dir != null) {
+            File base = new File(dir);
+            File file = new File(base, needle);
+            if (file.exists()) {
+                return file;
+            } else {
+                return findFileRecursively(base.getParent(), needle);
+            }
+        } else return null;
+    }
+
+}
diff --git a/tests/src/catalog/cloudant/CloudantBindingTests.scala b/tests/src/catalog/cloudant/CloudantBindingTests.scala
new file mode 100644
index 0000000..812de49
--- /dev/null
+++ b/tests/src/catalog/cloudant/CloudantBindingTests.scala
@@ -0,0 +1,121 @@
+/*
+ * 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 org.junit.runner.RunWith
+import org.scalatest.FlatSpec
+import org.scalatest.junit.JUnitRunner
+
+import catalog.CloudantUtil
+import common.JsHelpers
+import common.TestHelpers
+import common.Wsk
+import common.WskProps
+import common.WskTestHelpers
+import spray.json.DefaultJsonProtocol.StringJsonFormat
+import spray.json.JsObject
+import spray.json.pimpAny
+
+@RunWith(classOf[JUnitRunner])
+class CloudantBindingTests extends FlatSpec
+    with TestHelpers
+    with WskTestHelpers
+    with JsHelpers {
+
+    val wskprops = WskProps()
+    val wsk = new Wsk
+
+    val myCloudantCreds = CloudantUtil.Credential.makeFromVCAPFile("cloudantNoSQLDB", this.getClass.getSimpleName)
+
+    behavior of "Cloudant binding"
+
+    /**
+     * Simulate bluemix package binding by supplying a "url" parameter.
+     * Additionally, leave out other key parameters (e.g. username, password)
+     * to ensure that the action uses the "url" bound parameter.
+     */
+    it should """Use "url" property if it is available""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp // shadow global props and make implicit
+            val packageName = "cloudantBindingWithURL"
+
+            try {
+                CloudantUtil.setUp(myCloudantCreds)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("""Creating cloudant package binding with only a "url" parameter.""")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("url" -> s"https://${myCloudantCreds.user}:${myCloudantCreds.password}@${myCloudantCreds.host}".toJson))
+                }
+
+                println("Invoking the document-create action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-document",
+                    Map(
+                        "dbname" -> myCloudantCreds.dbname.toJson,
+                        "doc" -> JsObject("message" -> "I used the url parameter.".toJson)))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        activation.response.result.get.fields.get("id") shouldBe defined
+                }
+            } finally {
+                CloudantUtil.unsetUp(myCloudantCreds)
+            }
+    }
+
+    /**
+     * Simulate a user creating their own binding with "username", "password", and "host".
+     * Do not include "url" in the binding to ensure the package uses the other bound properties.
+     */
+    it should """Use "username", "password", and "host" if "url" is not available""" in withAssetCleaner(wskprops) {
+        (wp, assetHelper) =>
+            implicit val wskprops = wp // shadow global props and make implicit
+            val packageName = "cloudantBindingWithoutURL"
+
+            try {
+                CloudantUtil.setUp(myCloudantCreds)
+
+                val packageGetResult = wsk.pkg.get("/whisk.system/cloudant")
+                println("Fetching cloudant package.")
+                packageGetResult.stdout should include("ok")
+
+                println("""Creating cloudant package binding with "username", "pasword" and "host".""")
+                assetHelper.withCleaner(wsk.pkg, packageName) {
+                    (pkg, name) =>
+                        pkg.bind("/whisk.system/cloudant", name,
+                            Map("username" -> myCloudantCreds.user.toJson,
+                                "password" -> myCloudantCreds.password.toJson,
+                                "host" -> myCloudantCreds.host().toJson))
+                }
+
+                println("Invoking the document-create action.")
+                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-document",
+                    Map(
+                        "dbname" -> myCloudantCreds.dbname.toJson,
+                        "doc" -> JsObject("message" -> "This time I didn't use the URL param.".toJson)))) {
+                    activation =>
+                        activation.response.success shouldBe true
+                        activation.response.result.get.fields.get("id") shouldBe defined
+                }
+            } finally {
+                CloudantUtil.unsetUp(myCloudantCreds)
+            }
+    }
+}