/*
 * Copyright 2015-2016 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 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.{JsArray, JsNumber, JsString, JsValue, pimpAny}
import whisk.utils.JsHelpers

import scala.collection.mutable.HashSet

@RunWith(classOf[JUnitRunner])
class CloudantAccountActionsTests 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 account actions"


    it should """create cloudant database""" in withAssetCleaner(wskprops) {
        (wp, assetHelper) =>
            implicit val wskprops = wp
            val packageName = "dummyCloudantPackage"
            val dbName = credential.dbname.concat("create_db")

            try {
                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))
                }

                //create database
                println("Invoking the create-database action.")
                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-database",
                    Map("dbname" -> dbName.toJson))) {
                    activation =>
                        activation.response.success shouldBe true
                }
                val response = CloudantUtil.readTestDatabase(credential, dbName)
                response.getStatusCode should be (200)
            }
            finally {
                CloudantUtil.deleteTestDatabase(credential, dbName)
            }
    }

    it should """create cloudant database with undefined dbname""" in withAssetCleaner(wskprops) {
        (wp, assetHelper) =>
            implicit val wskprops = wp
            val packageName = "dummyCloudantPackage"

            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))
            }

            //create database
            println("Invoking the create-database action.")
            withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/create-database")) {
                activation =>
                    activation.response.success shouldBe false
                    val result = activation.response.result.get
                    result.fields.get("error") shouldBe Some(JsString("dbname is required."))
            }
    }

    it should """read cloudant database""" 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 read-database action.")
                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/read-database",
                    Map("dbname" -> credential.dbname.toJson))) {
                    activation =>
                        activation.response.success shouldBe true
                        val result = activation.response.result.get
                        result.fields.get("db_name") shouldBe Some(JsString(credential.dbname))
                }
            }
            finally {
                CloudantUtil.unsetUp(credential)
            }
    }

    it should """read cloudant database that does not exist""" in withAssetCleaner(wskprops) {
        (wp, assetHelper) =>
            implicit val wskprops = wp
            val packageName = "dummyCloudantPackage"

            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 read-database action.")
            withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/read-database",
                Map("dbname" -> "doesNotExistDB".toJson))) {
                activation =>
                    activation.response.success shouldBe false
                    val result = activation.response.result.get
                    JsHelpers.getFieldPath(result, "error", "statusCode") shouldBe Some(JsNumber(404))
            }
    }

    it should """delete cloudant database""" 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 delete-database action.")
                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-database",
                    Map("dbname" -> credential.dbname.toJson))) {
                    activation =>
                        activation.response.success shouldBe true
                }
                val response = CloudantUtil.readTestDatabase(credential)
                response.get("error").getAsString() shouldBe "not_found"
                response.get("reason").getAsString() shouldBe "Database does not exist."
            }
            finally {
                CloudantUtil.unsetUp(credential)
            }
    }

    it should """delete cloudant database with incorrect hostname""" 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" -> "invalidHost".toJson))
                }

                println("Invoking the delete-database action.")
                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/delete-database",
                    Map("dbname" -> credential.dbname.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 """list all cloudant databases""" 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-all-databases action.")
                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/list-all-databases")) {
                    activation =>
                        activation.response.success shouldBe true
                        val result = activation.response.result.get
                        val matchedDBs = new HashSet[JsValue]
                        val databases = result.fields("all_databases").asInstanceOf[JsArray].elements
                        databases map {
                            case x@JsString(credential.dbname) => matchedDBs.add(x)
                            case _ => None
                        }
                        matchedDBs.size should be > 0
                }
            }
            finally {
                CloudantUtil.unsetUp(credential)
            }
    }

    it should """list all cloudant databases with incorrect user""" 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" -> "invalidUser".toJson,
                                "password" -> credential.password.toJson,
                                "host" -> credential.host().toJson))
                }

                println("Invoking the list-all-databases action.")
                withActivation(wsk.activation, wsk.action.invoke(s"${packageName}/list-all-databases")) {
                    activation =>
                        activation.response.success shouldBe false
                        val result = activation.response.result.get
                        JsHelpers.getFieldPath(result, "error", "statusCode") shouldBe Some(JsNumber(401))
                }
            }
            finally {
                CloudantUtil.unsetUp(credential)
            }
    }

}