Jenkinsfile.ci

#!groovy


libindyBuildFinished = ["Ubuntu": false, "RedHat": false]
libvcxBuildFinished = ["Ubuntu": false, "RedHat": false]

testing()

def testing() {
    stage('Testing') {
        parallel([
                'ubuntu-test' : { ubuntuTesting() },
                'android-test': { androidTesting() },
                'macos-test'  : { macosTesting() },
                'ios-test'    : { iosTesting() },
                'redhat-test' : { rhelTesting() },
                'windows-test': { windowsTesting() }
        ])
    }
}

def windowsTesting() {
    node('win2016') {
        stage('Windows Test') {
            def ws_path = "workspace/${env.JOB_NAME}".replace(' ', '_')
            ws(ws_path) {
                try {
                    echo "Windows Test: Checkout scm"
                    checkout scm

                    echo "Windows Test: Run Indy pool"
                    bat "docker -H $INDY_SDK_SERVER_IP build --build-arg pool_ip=$INDY_SDK_SERVER_IP -f ci/indy-pool.dockerfile -t indy_pool ci"
                    bat "docker -H $INDY_SDK_SERVER_IP run -d --network host --name indy_pool -p 9701-9708:9701-9708 indy_pool"

                    setupRust()

                    dir('libindy') {
                        echo "Windows Test: Download prebuilt dependencies"
                        bat 'wget -O prebuilt.zip "https://repo.sovrin.org/windows/libindy/deps/indy-sdk-deps.zip"'
                        bat 'unzip prebuilt.zip -d prebuilt'

                        echo "Windows Libindy Test: Build"
                        withEnv([
                                "INDY_PREBUILT_DEPS_DIR=$WORKSPACE\\libindy\\prebuilt",
                                "INDY_CRYPTO_PREBUILT_DEPS_DIR=$WORKSPACE\\libindy\\prebuilt",
                                "MILAGRO_DIR=$WORKSPACE\\libindy\\prebuilt",
                                "LIBZMQ_PREFIX=$WORKSPACE\\libindy\\prebuilt",
                                "SODIUM_LIB_DIR=$WORKSPACE\\libindy\\prebuilt",
                                "OPENSSL_DIR=$WORKSPACE\\libindy\\prebuilt",
                                "PATH=$WORKSPACE\\libindy\\prebuilt\\lib;$PATH",
                                "RUST_BACKTRACE=1"
                        ]) {
                            bat "cargo build --features fatal_warnings"
                            bat "cargo test --no-run"

                            echo "Windows Libindy Test: Run tests"
                            withEnv([
                                    "RUST_TEST_THREADS=1",
                                    "RUST_LOG=indy::=debug,zmq=trace",
                                    "TEST_POOL_IP=$INDY_SDK_SERVER_IP"
                            ]) {
                                bat "cargo test"
                            }
                        }
                    }

                    dir('libnullpay') {
                        echo "Windows Libnullpay Test: Build"
                        withEnv([
                                "RUST_BACKTRACE=1"
                        ]) {
                            bat "cargo build --features fatal_warnings"
                            bat "cargo test --no-run"

                            echo "Windows Libnullpay Test: Run tests"
                            withEnv([
                                    "RUST_TEST_THREADS=1",
                                    "RUST_LOG=indy::=debug,zmq=trace",
                                    "TEST_POOL_IP=$INDY_SDK_SERVER_IP",
                                    "PATH=$WORKSPACE\\libindy\\target\\debug;$PATH",
                            ]) {
                                bat "cargo test"
                            }
                        }
                    }

                    bat "copy $WORKSPACE\\libnullpay\\target\\debug\\nullpay.dll $WORKSPACE\\cli"

                    dir('cli') {
                        bat "sed -i -e \"s/10\\.0\\.0\\.2/${INDY_SDK_SERVER_IP}/g\" docker_pool_transactions_genesis"

                        def featuresArgs = '--features "nullpay_plugin"'

                        echo "Windows Indy Cli Test: Build"
                        withEnv([
                                "RUST_BACKTRACE=1"
                        ]) {
                            bat "cargo test $featuresArgs --no-run"

                            echo "Windows Indy Cli Test: Run tests"
                            withEnv([
                                    "RUST_TEST_THREADS=1",
                                    "RUST_LOG=indy::=debug,zmq=trace",
                                    "TEST_POOL_IP=$INDY_SDK_SERVER_IP"
                            ]) {
                                bat "cargo test $featuresArgs"
                            }
                        }
                    }

                    bat "copy $WORKSPACE\\libnullpay\\target\\debug\\nullpay.dll $WORKSPACE\\vcx\\libvcx"

                    dir('vcx/libvcx') {
                        echo "Windows Libvcx Test: Build"
                        withEnv([
                                "OPENSSL_DIR=$WORKSPACE\\libindy\\prebuilt",
                                "RUST_BACKTRACE=1"
                        ]) {
                            bat "cargo build --features fatal_warnings"
                            bat "cargo test --no-run"

                            echo "Windows Libvcx Test: Run tests"
                            withEnv([
                                    "RUST_TEST_THREADS=1",
                                    "RUST_LOG=vcx=debug,indy::=debug",
                                    "PATH=$WORKSPACE\\libindy\\target\\debug;$PATH",
                            ]) {
                                bat "cargo test"
                            }
                        }
                    }

                    //TODO wrappers testing

                } finally {
                    try {
                        bat "docker -H $INDY_SDK_SERVER_IP stop indy_pool"
                    } catch (ignore) {
                    }
                    try {
                        bat "docker -H $INDY_SDK_SERVER_IP rm indy_pool"
                    } catch (ignore) {
                    }
                    cleanWs()
                }
            }
            cleanWs()
        }
    }
}

def macosTesting() {
    node('macos') {
        stage('MacOS Test') {
            try {
                echo "MacOS Test: Checkout scm"
                checkout scm

                setupRust()
                setupBrewPackages()

                macosModuleBuilding('libindy') // TODO: testing

                sh "cp libindy/target/debug/libindy.dylib libnullpay"
                sh "cp libindy/target/debug/libindy.dylib vcx/libvcx"

                macosModuleBuilding('libnullpay') // TODO: testing

                sh "cp libnullpay/target/debug/libnullpay.dylib vcx/libvcx"

                macosModuleBuilding('vcx/libvcx')
                macosModuleTesting('vcx/libvcx')

                //TODO wrappers testing
            } finally {
                step([$class: 'WsCleanup'])
            }
        }
    }
}

def macosModuleBuilding(library) {
    dir(library) {
        echo "MacOS ${library} Testing: Build"
        sh "LIBRARY_PATH=./ cargo build --features fatal_warnings"
        sh "LIBRARY_PATH=./ cargo test --no-run"
    }
}

def macosModuleTesting(library) {
    dir(library) {
        echo "MacOS ${library} Testing: Run Tests"
        sh "LIBRARY_PATH=./ RUST_TEST_THREADS=1 cargo test"
    }
}

def androidTesting() {
    env_name = "android_on_linux"
    network_name = "pool_network"
    linuxModuleTesting("ci/ubuntu.dockerfile ci", env_name, network_name, this.&linuxAndroidOnEmulatorTesting)
}

def iosTesting() {

    def setupRustIOS ={
        sh "rustup target add x86_64-apple-ios"
    }

    def cleanSimulators = {
        sh '''
            xcrun simctl list devices | grep 'IndySDK' | awk '{print $4}' | sed -n  's/(\\(.*\\))/\\1/p'
            xcrun simctl list devices | grep 'IndySDK' | awk '{print $4}' | sed -n  's/(\\(.*\\))/\\1/p' | xargs xcrun simctl delete
        '''
    }

    def createSimulators = {
        sh '''
            xcrun simctl create "iPhone X IndySDK" "iPhone X" "11.2"
        '''
    }

    node('macos') {
        stage('iOS Test') {
            try {
                echo "iOS Test: Checkout scm"
                checkout scm

                echo "iOS Test: setup rust, brew and simulators"
                setupRust()
                setupRustIOS()
                setupBrewPackages()
                cleanSimulators()
                createSimulators()

                withEnv([
                    "BUNDLE_PATH=$HOME/.gem.indy_sdk"
                ]) {
                    dir('wrappers/ios') {
                        echo "iOS Test: Installing ruby, bundler and gems"

                        sh '''
                            rbenv install -s $(cat .ruby-version)

                            gem install bundler
                            bundler exec gem env

                            bundler install
                            bundler list
                        '''
                    }

                    dir('wrappers/ios/libindy-pod') {
                        echo "iOS Test: Installing dependencies (pods)"
                        sh "bundler exec pod install --repo-update"
                    }

                    echo "iOS Test: Running pool"
                    sh "docker rm -f indy_pool || true"
                    sh "docker build -f ci/indy-pool.dockerfile -t indy_pool ci"
                    sh "docker run -d --name indy_pool -p 9701-9708:9701-9708 indy_pool"

                    sh 'chmod -R 777 ci'
                    echo "iOS Test: build libindy pod"
                    sh "ci/ios-build.sh libindy x86_64-apple-ios"

                    // FIXME replace this hack (manually rewrite installed pod)
                    sh "rm -f wrappers/ios/libindy-pod/Pods/libindy/*.[ah]"
                    sh "cp libindy/out_pod/*.[ah] wrappers/ios/libindy-pod/Pods/libindy"

                    dir('wrappers/ios/libindy-pod') {
                        echo "iOS Test: Testing"
                        sh "xcodebuild test -workspace Indy.xcworkspace -scheme Indy-demo -destination 'platform=iOS Simulator,name=iPhone X IndySDK,OS=11.2'"
                    }
                }
            } finally {
                try {
                    cleanSimulators()
                } catch (ignore) {
                }
                try {
                    sh "docker stop indy_pool"
                } catch (ignore) {
                }
                try {
                    sh "docker rm indy_pool"
                } catch (ignore) {
                }
                step([$class: 'WsCleanup'])
            }
        }
    }
}

def ubuntuTesting() {
    stage('Ubuntu Test') {
        linuxTesting("ci/ubuntu.dockerfile ci", "Ubuntu", "pool_network")
    }
}

def rhelTesting() {
    stage('RedHat Test') {
        linuxTesting("ci/amazon.dockerfile ci", "RedHat", "pool_network")
    }
}

def linuxTesting(file, env_name, network_name) {
    parallel([
            failFast                                  : true,
            "${env_name} Test: build and test libindy": {
                node('ubuntu') {
                    linuxLibindyBuild(file, env_name, network_name)
                }
            },
            "${env_name} Test: test other components" : {
                waitUntil {
                    libindyBuildFinished[env_name]
                }
                def jobs = [
                        "${env_name}-nodejs-test"     : {
                            linuxModuleTesting(file, env_name, network_name, this.&linuxNodejsTesting)
                        },
                        "${env_name}-cli-test"        : {
                            linuxModuleTesting(file, env_name, network_name, this.&linuxCLITesting)
                        },
                        "${env_name}-rust-test"       : {
                            linuxModuleTesting(file, env_name, network_name, this.&linuxRustTesting)
                        },
                        "${env_name}-vcx-test"        : {
                            vcxTesting(file, env_name, network_name)
                        },
                        "${env_name}-cloud-agent-test": {
                            linuxModuleTesting(file, env_name, network_name, this.&linuxCloudAgentTesting)
                        }
                ]
                if (env_name == "Ubuntu") {
                    jobs["${env_name}-java-test"] = {
                        linuxModuleTesting(file, env_name, network_name, this.&linuxJavaTesting)
                    }
                    jobs["${env_name}-python-test"] = {
                        linuxModuleTesting(file, env_name, network_name, this.&linuxPythonTesting)
                    }
                }
                parallel(jobs)
            },
    ])
}

def vcxTesting(file, env_name, network_name) {
    parallel([
            failFast                                     : true,
            "${env_name} Test: build and test libvcx"    : {
                node('ubuntu') {
                    linuxVcxBuild(file, env_name, network_name)
                }
            },
            "${env_name} Test: test other vcx components": {
                waitUntil {
                    libvcxBuildFinished[env_name]
                }
                def jobs = [
                        "${env_name}-vcx-nodejs-test": {
                            linuxModuleTesting(file, env_name, network_name, this.&linuxVcxNodejsTesting)
                        }
                ]
                if (env_name == "Ubuntu") {
                    jobs["${env_name}-vcx-java-test"] = {
                        linuxModuleTesting(file, env_name, network_name, this.&linuxVcxJavaTesting)
                    }
                    jobs["${env_name}-vcx-python-test"] = {
                        linuxModuleTesting(file, env_name, network_name, this.&linuxVcxPythonTesting)
                    }
                }
                parallel(jobs)
            },
    ])
}

def linuxLibindyBuild(file, env_name, network_name) {
    def poolInst
    try {
        echo "${env_name} Test: Checkout csm"
        checkout scm

        poolInst = openPool(env_name, network_name)

        def testEnv = buildTestEnv(file, env_name)

        testEnv.inside {
            echo "${env_name} Libindy Test: Build"
            sh '''
                cd libindy
                cargo build --features "fatal_warnings sodium_static"
            '''
        }

        sh "cp libindy/target/debug/libindy.so wrappers/java/lib"
        sh "cp libindy/target/debug/libindy.so wrappers/python"
        sh "cp libindy/target/debug/libindy.so wrappers/nodejs"
        sh "cp libindy/target/debug/libindy.so wrappers/rust"
        sh "cp libindy/target/debug/libindy.so cli"
        sh "cp libindy/target/debug/libindy.so libnullpay"
        sh "cp libindy/target/debug/libindy.so vcx/libvcx"
        sh "cp libindy/target/debug/libindy.so vcx/wrappers/node"
        sh "cp libindy/target/debug/libindy.so vcx/wrappers/java"
        sh "cp libindy/target/debug/libindy.so vcx/wrappers/python3"
        sh "cp libindy/target/debug/libindy.so vcx/dummy-cloud-agent"

        testEnv.inside {
            echo "${env_name} Libnullpay Test: Build"
            sh '''
                cd libnullpay
                LIBRARY_PATH=./ cargo build --features fatal_warnings
            '''
        }

        sh "cp libnullpay/target/debug/libnullpay.so cli"
        sh "cp libnullpay/target/debug/libnullpay.so vcx/libvcx"
        sh "cp libnullpay/target/debug/libnullpay.so vcx/wrappers/node"
        sh "cp libnullpay/target/debug/libnullpay.so vcx/wrappers/java"
        sh "cp libnullpay/target/debug/libnullpay.so vcx/wrappers/python3"

        stash includes: 'wrappers/java/lib/libindy.so', name: "LibindyJavaSO${env_name}"
        stash includes: 'wrappers/python/libindy.so', name: "LibindyPythonSO${env_name}"
        stash includes: 'wrappers/nodejs/libindy.so', name: "LibindyNodejsSO${env_name}"
        stash includes: 'wrappers/rust/libindy.so', name: "LibindyRustSO${env_name}"
        stash includes: 'cli/libindy.so', name: "LibindyCliSO${env_name}"
        stash includes: 'cli/libnullpay.so', name: "LibnullpayCliSO${env_name}"
        stash includes: 'vcx/libvcx/libindy.so,vcx/libvcx/libnullpay.so', name: "VCXLibindyAndLibnullpaySO${env_name}"
        stash includes: 'vcx/wrappers/node/libindy.so,vcx/wrappers/node/libnullpay.so', name: "VcxNodeLibindyAndLibnullpaySO${env_name}"
        stash includes: 'vcx/wrappers/java/libindy.so,vcx/wrappers/java/libnullpay.so', name: "VcxJavaLibindyAndLibnullpaySO${env_name}"
        stash includes: 'vcx/wrappers/python3/libindy.so,vcx/wrappers/python3/libnullpay.so', name: "VcxPythonLibindyAndLibnullpaySO${env_name}"
        stash includes: 'vcx/dummy-cloud-agent/libindy.so', name: "LibindyCloudAgentSO${env_name}"

        libindyBuildFinished[env_name] = true

        echo "${env_name} Libindy Test: Test"
        testEnv.inside("--network=${network_name}") {
            sh '''
                cd libindy
                RUST_BACKTRACE=1 cargo test --no-run --features sodium_static
                RUST_BACKTRACE=1 RUST_LOG=indy::=debug,zmq=trace RUST_TEST_THREADS=1 TEST_POOL_IP=10.0.0.2 cargo test --features sodium_static
            '''
        }

        echo "${env_name} Libnullpay Test: Test"
        testEnv.inside("--network=${network_name}") {
            sh '''
                cd libnullpay
                LIBRARY_PATH=./ RUST_BACKTRACE=1 cargo test --no-run
                LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} RUST_BACKTRACE=1 RUST_LOG=indy::=debug,zmq=trace RUST_TEST_THREADS=1 TEST_POOL_IP=10.0.0.2 cargo test
            '''
        }
    }

    finally {
        closePool(env_name, network_name, poolInst)
    }
}

def linuxVcxBuild(file, env_name, network_name) {
    def poolInst
    try {
        echo "${env_name} Test: Checkout csm"
        checkout scm

        poolInst = openPool(env_name, network_name)

        def testEnv = buildTestEnv(file, env_name)

        unstash name: "VCXLibindyAndLibnullpaySO${env_name}"

        echo "${env_name} Libvcx Test: Build"
        testEnv.inside {
            sh '''
                cd vcx/libvcx
                LIBRARY_PATH=./ cargo build --features fatal_warnings
            '''
        }

        sh "cp vcx/libvcx/target/debug/libvcx.so vcx/wrappers/node"
        sh "cp vcx/libvcx/target/debug/libvcx.so vcx/wrappers/java"
        sh "cp vcx/libvcx/target/debug/libvcx.so vcx/wrappers/python3"

        stash includes: 'vcx/wrappers/node/libvcx.so', name: "VcxNodeLibvcxSO${env_name}"
        stash includes: 'vcx/wrappers/java/libvcx.so', name: "VcxJavaLibvcxSO${env_name}"
        stash includes: 'vcx/wrappers/python3/libvcx.so', name: "VcxPythonLibvcxSO${env_name}"

        libvcxBuildFinished[env_name] = true

        testEnv.inside("--network=${network_name}") {
            echo "${env_name} Libvcx Test: Run Cloud Agent"
            sh '''
                cp vcx/libvcx/libindy.so vcx/dummy-cloud-agent
                cd vcx/dummy-cloud-agent
                LIBRARY_PATH=./ LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} RUST_BACKTRACE=1 RUST_LOG=indy=info cargo run sample-config.json &
            '''

            echo "${env_name} Libvcx Test: Run tests"
            sh '''
                cd vcx/libvcx
                LIBRARY_PATH=./ LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} RUST_BACKTRACE=1 RUST_LOG=vcx=debug,indy=debug RUST_TEST_THREADS=1 TEST_POOL_IP=10.0.0.2 cargo test --features "pool_tests agency"
            '''
        }
    }
    finally {
        closePool(env_name, network_name, poolInst)
    }
}

def linuxModuleTesting(file, env_name, network_name, module_tester) {
    node('ubuntu') {
        def poolInst
        try {
            echo "${env_name} Test: Checkout csm"
            checkout scm

            poolInst = openPool(env_name, network_name)

            def testEnv = buildTestEnv(file, env_name)

            module_tester(env_name, network_name, testEnv)
        } finally {
            closePool(env_name, network_name, poolInst)
        }
    }
}

def linuxAndroidOnEmulatorTesting(env_name, network_name, testEnv) {
    dir('libindy') {
        sh 'chmod -R 777 ci/*.sh'
        sh 'chmod -R 777 *.sh'

        def emu_arch = "x86"

        echo "${env_name} Libindy Test: Test on ${emu_arch} emulator"
        testEnv.inside("--network=${network_name}") {
            sh "./android.test.sh ${emu_arch} --release"
        }
    }
}

def linuxJavaTesting(env_name, network_name, testEnv) {
    unstash name: "LibindyJavaSO${env_name}"
    dir('wrappers/java') {
        testEnv.inside("--network=${network_name}") {
            echo "${env_name} Libindy Test: Test java wrapper"

            sh "TEST_POOL_IP=10.0.0.2 mvn clean test"
        }
    }
}

def linuxPythonTesting(env_name, network_name, testEnv) {
    unstash name: "LibindyPythonSO${env_name}"
    dir('wrappers/python') {
        testEnv.inside("--network=${network_name}") {
            echo "${env_name} Libindy Test: Test python wrapper"

            sh '''
                python3.5 -m pip install --user -e .
                LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} TEST_POOL_IP=10.0.0.2 python3.5 -m pytest
            '''
        }
    }
}

def linuxNodejsTesting(env_name, network_name, testEnv) {
    unstash name: "LibindyNodejsSO${env_name}"
    testEnv.inside("--network=${network_name}") {
        echo "${env_name} Libindy Test: Test nodejs wrapper"

        sh '''
                cd wrappers/nodejs
                npm run prepare
                npm install
                LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} RUST_LOG=indy::=debug TEST_POOL_IP=10.0.0.2 npm test
            '''
    }
}

def linuxVcxNodejsTesting(env_name, network_name, testEnv) {
    unstash name: "VcxNodeLibvcxSO${env_name}"
    unstash name: "VcxNodeLibindyAndLibnullpaySO${env_name}"

    testEnv.inside("--network=${network_name}") {
        echo "${env_name} Vcx Test: Test nodejs wrapper"
        sh '''
            cd vcx/wrappers/node/
            npm i
            npm run compile
            LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} LIBVCX_PATH=./ npm test
        '''
    }
}

def linuxVcxJavaTesting(env_name, network_name, testEnv) {
    unstash name: "VcxJavaLibvcxSO${env_name}"
    unstash name: "VcxJavaLibindyAndLibnullpaySO${env_name}"

    dir('vcx/wrappers/java') {
        echo "${env_name} Vcx Test: Test java wrapper"

        testEnv.inside("--network=${network_name}") {
            sh 'LIBRARY_PATH=./ LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH}  ./gradlew --no-daemon test'
        }
    }
}

def linuxVcxPythonTesting(env_name, network_name, testEnv) {
    unstash name: "VcxPythonLibvcxSO${env_name}"
    unstash name: "VcxPythonLibindyAndLibnullpaySO${env_name}"

    dir('vcx/wrappers/python3') {
        testEnv.inside("--network=${network_name}") {
            echo "${env_name} Vcx Test: Test python wrapper"

            sh '''
                    python3.5 -m pip install --user pytest==3.4.2 qrcode pytest-asyncio
                    LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} python3.5 -m pytest -s
            '''
        }
    }
}

def linuxCLITesting(env_name, network_name, testEnv) {
    unstash name: "LibindyCliSO${env_name}"
    unstash name: "LibnullpayCliSO${env_name}"

    echo "${env_name} Indy Cli Test: tests"
    testEnv.inside("--network=${network_name}") {
        sh '''
            cd cli
            LIBRARY_PATH=./ RUST_BACKTRACE=1 cargo test --features "nullpay_plugin" --no-run
            LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} RUST_BACKTRACE=1 RUST_LOG=indy::=debug,zmq=trace RUST_TEST_THREADS=1 TEST_POOL_IP=10.0.0.2 cargo test --features "nullpay_plugin"
        '''
    }
}

def linuxRustTesting(env_name, network_name, testEnv) {
    unstash name: "LibindyRustSO${env_name}"

    dir('wrappers/rust') {
        testEnv.inside("--network=${network_name}") {
            echo "${env_name} Indy Rust wrapper Test: Build"
            sh 'LIBRARY_PATH=./ RUST_BACKTRACE=1 cargo test --no-run'

            echo "${env_name} Indy Rust wrupper Test: Run tests"
            sh 'LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} RUST_BACKTRACE=1 RUST_LOG=indy::=debug,zmq=trace RUST_TEST_THREADS=1 TEST_POOL_IP=10.0.0.2 cargo test'
        }
    }
}

def linuxCloudAgentTesting(env_name, network_name, testEnv) {
    unstash name: "LibindyCloudAgentSO${env_name}"

    echo "${env_name} Cloud Agent Test: tests"
    testEnv.inside {
        sh '''
            cd vcx/dummy-cloud-agent
            LIBRARY_PATH=./ RUST_BACKTRACE=1 cargo test --no-run
            LD_LIBRARY_PATH=./:${LD_LIBRARY_PATH} RUST_BACKTRACE=1 RUST_LOG=indy::=debug RUST_TEST_THREADS=1 cargo test
        '''
    }
}

def getBuildPoolVerOptions(pool_type, plenum_ver, anoncreds_ver, node_ver) {
    if (pool_type != null && plenum_ver != null && anoncreds_ver != null && node_ver != null) {
        return "--build-arg=indy_stream=${pool_type} --build-arg indy_plenum_ver=${plenum_ver} --build-arg indy_anoncreds_ver=${anoncreds_ver} --build-arg indy_node_ver=${node_ver}"
    } else {
        return ""
    }
}

def getUserUid() {
    return sh(returnStdout: true, script: 'id -u').trim()
}

def buildTestEnv(file, env_name) {
    dir('libindy') {
        echo "${env_name} Build test environment"
        return dockerBuild('libindy', file)
    }
}

def dockerBuild(name, file = 'ci/ubuntu.dockerfile ci', customParams = '') {
    return docker.build("$name-test", "--build-arg uid=${getUserUid()} ${customParams} -f $file")
}

def dockerClean(env_name, network_name) {
    try {
        try {
            sh "docker ps --format '{{.ID}}' --filter network=${network_name} | xargs docker rm -f || true"//TODO: FIXME
        } catch (error) {
            echo "${env_name} Test: error while force clean-up network ${network_name} - ${error}"
        }
        try {
            echo "${env_name} Test: remove pool network ${network_name}"
            sh "docker network rm ${network_name} || true" //TODO: FIXME
        } catch (error) {
            echo "${env_name} Test: error while delete ${network_name} - ${error}"
        }
    }
    finally {
        sh "docker container prune -f"
        sh "docker network prune -f"
    }
}

def openPool(env_name, network_name, pool_type = null, pool_ver = null, plenum_ver = null, anoncreds_ver = null, node_ver = null) {
    echo "${env_name} Test: Clean docker"
    dockerClean(env_name, network_name)

    echo "${env_name} Test: Create docker network (${network_name}) for nodes pool and test image"
    sh "docker network create --subnet=10.0.0.0/8 ${network_name}"

    echo "${env_name} Test: Build docker image for nodes pool ver. ${pool_ver}"
    echo "${env_name} Test: Building nodes pool for versions: plenum ${plenum_ver}, anoncreds ${anoncreds_ver}, node ${node_ver}"
    verOptions = getBuildPoolVerOptions(pool_type, plenum_ver, anoncreds_ver, node_ver)
    def poolEnv = dockerBuild("indy_pool_${pool_ver}", 'ci/indy-pool.dockerfile ci', "--build-arg pool_ip=10.0.0.2 ${verOptions}")
    echo "${env_name} Test: Run nodes pool"
    return poolEnv.run("--ip=\"10.0.0.2\" --network=${network_name}")
}

def closePool(env_name, network_name, poolInst) {
    echo "${env_name} Test: Cleanup"
    try {
        echo "${env_name} Test: stop pool"
        poolInst.stop()
    } catch (error) {
        echo "${env_name} Tests: error while stop pool ${error}"
    }
    finally {
        dockerClean(env_name, network_name)
    }
    step([$class: 'WsCleanup'])
}

def shell(command) {
    if (isUnix()) {
        sh command
    } else {
        bat command
    }
}

def setupRust() {
    shell("rustup default 1.31.0")
}

def setupBrewPackages() {
    sh "brew switch libsodium 1.0.12"
    sh "brew switch openssl 1.0.2l"
    sh "brew switch zeromq 4.2.3"
}