#!groovy

library identifier: '3scale-toolbox-jenkins@master',
        retriever: modernSCM([$class: 'GitSCMSource',
                              remote: 'https://github.com/rh-integration/3scale-toolbox-jenkins.git',
                              traits: [[$class: 'jenkins.plugins.git.traits.BranchDiscoveryTrait']]])

def service = null

node() {
  stage('Checkout Source') {
    checkout scm
  }

  stage("Prepare") {
    service = toolbox.prepareThreescaleService(
        openapi: [filename: "testcase-03/swagger.json"],
        environment: [ baseSystemName: toolbox.generateRandomBaseSystemName(),
                       publicBasePath: "/v1",
                       publicStagingWildcardDomain: params.PUBLIC_STAGING_WILDCARD_DOMAIN,
                       publicProductionWildcardDomain: params.PUBLIC_PRODUCTION_WILDCARD_DOMAIN,
                       oidcIssuerEndpoint: params.OIDC_ISSUER_ENDPOINT,
                       privateBaseUrl: params.PRIVATE_BASE_URL ],
        toolbox: [ openshiftProject: params.NAMESPACE,
                   destination: params.TARGET_INSTANCE,
                   image: "quay.io/redhat/3scale-toolbox:master", // TODO: remove me once the final image is released
                   insecure: params.DISABLE_TLS_VALIDATION == "yes",
                   secretName: params.SECRET_NAME],
        service: [:],
        applications: [
            [ name: "my-test-app", description: "This is used for tests", plan: "test", account: params.DEVELOPER_ACCOUNT_ID ]
        ],
        applicationPlans: [
          [ systemName: "test", name: "Test", defaultPlan: true, published: true ],
          [ systemName: "silver", name: "Silver" ],
          [ systemName: "gold", name: "Gold" ],
        ]
    )

    echo "toolbox version = " + service.toolbox.getToolboxVersion()
  }

  stage("Import OpenAPI") {
    service.importOpenAPI()
    echo "Service with system_name ${service.environment.targetSystemName} created !"
  }

  stage("Create an Application Plan") {
    service.applyApplicationPlans()
  }

  stage("Create an Application") {
    service.applyApplication()
  }

  stage("Run integration tests") {
    def proxy = service.readProxy("sandbox")
    def tokenEndpoint = getTokenEndpoint(params.OIDC_ISSUER_ENDPOINT)
    def clientId = service.applications[0].clientId
    def clientSecret = service.applications[0].clientSecret
    sh """set -e
    echo "token endpoint is ${tokenEndpoint}"
    echo "Public Staging Base URL is ${proxy.sandbox_endpoint}"
    echo "client_id=${clientId}"
    echo "client_secret=${clientSecret}"
    curl -sfk "${tokenEndpoint}" -d client_id="${clientId}" -d client_secret="${clientSecret}" -d scope=openid -d grant_type=client_credentials -o response.json
    curl -sLfk https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64 -o /tmp/jq
    chmod 755 /tmp/jq
    TOKEN="\$(/tmp/jq -r .access_token response.json)"
    echo "Received access_token '\$TOKEN'"
    curl -sfk -w "ListBeers: %{http_code}\n" -o /dev/null ${proxy.sandbox_endpoint}/v1/beer -H "Authorization: Bearer \$TOKEN"
    curl -sfk -w "GetBeer: %{http_code}\n" -o /dev/null ${proxy.sandbox_endpoint}/v1/beer/Weissbier -H "Authorization: Bearer \$TOKEN"
    curl -sfk -w "FindBeersByStatus: %{http_code}\n" -o /dev/null ${proxy.sandbox_endpoint}/v1/beer/findByStatus/available -H "Authorization: Bearer \$TOKEN"
    """
  }

  stage("Promote to production") {
    service.promoteToProduction()
  }

}

def getTokenEndpoint(String oidcIssuerEndpoint) {
   def m = (oidcIssuerEndpoint =~ /(https?:\/\/)[^:]+:[^@]+@(.*)/)
   return "${m[0][1]}${m[0][2]}/protocol/openid-connect/token"
}