ScpStepsDefinitions.java

package alien4cloud.it.provider;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.junit.Assert;

import alien4cloud.it.Context;
import alien4cloud.it.provider.util.AttributeUtil;
import alien4cloud.it.provider.util.SSHUtil;
import cucumber.api.java.en.Then;
import cucumber.api.java.en.When;
import junitx.framework.FileAssert;

public class ScpStepsDefinitions {

    @When("^I upload the local file \"([^\"]*)\" to the node \"([^\"]*)\"'s remote path \"([^\"]*)\" with the keypair defined in environment variable \"([^\"]*)\" and user \"([^\"]*)\"$")
    public void iUploadTheLocalFileToTheNodeSRemotePathWithTheKeypairDefinedInEnvironmentVariableAndUser(String localFile, String nodeName, String remotePath,
                                                                                                         String keyPathEnv, String user) throws Throwable {
        String keypair = System.getenv(keyPathEnv);
        Assert.assertTrue(keyPathEnv + " must be defined as environment variable", StringUtils.isNotBlank(keypair));
        I_upload_the_local_file_to_the_node_s_remote_path_with_the_keypair_and_user(localFile, nodeName, remotePath, keypair, user);
    }

    @When("^I upload the local file \"([^\"]*)\" to the node \"([^\"]*)\"'s remote path \"([^\"]*)\" with the keypair \"([^\"]*)\" and user \"([^\"]*)\"$")
    public void I_upload_the_local_file_to_the_node_s_remote_path_with_the_keypair_and_user(String localFile, String nodeName, String remotePath,
                                                                                            String keypair, String user) throws Throwable {
        SSHUtil.upload(user, AttributeUtil.getAttribute(nodeName, "public_ip_address"), Context.SCP_PORT, Context.LOCAL_TEST_DATA_PATH.resolve(keypair)
                .toString(), remotePath, Context.LOCAL_TEST_DATA_PATH.resolve(localFile).toString());
    }

    @When("^I upload the local file \"(.*?)\" to the node \"(.*?)\" instance (\\d+) remote path \"(.*?)\" with the keypair \"(.*?)\" and user \"(.*?)\"$")
    public void i_upload_the_local_file_to_the_node_instance_remote_path_with_the_keypair_and_user(String localFile, String nodeName, int instanceIdx,
                                                                                                   String remotePath, String keypair, String user) throws Throwable {
        String ip = AttributeUtil.getAttribute(nodeName, "public_ip_address", instanceIdx);
        SSHUtil.upload(user, ip, Context.SCP_PORT, Context.LOCAL_TEST_DATA_PATH.resolve(keypair).toString(), remotePath,
                Context.LOCAL_TEST_DATA_PATH.resolve(localFile).toString());
    }

    @When("^I upload to a node's remote path the local file with the keypair \"([^\"]*)\" and user \"([^\"]*)\"$")
    public void i_upload_to_a_node_s_remote_path_the_local_file_with_the_keypair_and_user(String keypair, String user, List<List<String>> uploadInfos)
            throws Throwable {
        for (List<String> uploadInfo : uploadInfos) {
            String nodeName = uploadInfo.get(0);
            String remotePath = uploadInfo.get(1);
            String localFile = uploadInfo.get(2);
            I_upload_the_local_file_to_the_node_s_remote_path_with_the_keypair_and_user(localFile, nodeName, remotePath, keypair, user);
        }
    }

    private static final String CURRENT_DOWNLOADED_FILE_PATH;

    static {
        try {
            CURRENT_DOWNLOADED_FILE_PATH = Files.createTempFile("provider-int-tst", "").toString();
        } catch (IOException e) {
            throw new RuntimeException("Unable to create temp file");
        }
    }

    @When("^I download the remote file \"([^\"]*)\" from the node \"([^\"]*)\" with the keypair \"([^\"]*)\" and user \"([^\"]*)\"$")
    public void I_download_the_remote_file_from_the_node_with_the_keypair_and_user(String remoteFilePath, String nodeName, String keypair, String user)
            throws Throwable {
        Path keyPath = Context.LOCAL_TEST_DATA_PATH.resolve(keypair);
        SSHUtil.download(user, AttributeUtil.getAttribute(nodeName, "public_ip_address"), Context.SCP_PORT, keyPath.toString(), remoteFilePath,
                CURRENT_DOWNLOADED_FILE_PATH);
    }

    @When("^I download the remote file \"(.*?)\" from the node \"(.*?)\" instance (\\d+) with the keypair \"(.*?)\" and user \"(.*?)\"$")
    public void i_download_the_remote_file_from_the_node_instance_with_the_keypair_and_user(String remoteFilePath, String nodeName, int instanceIdx,
                                                                                            String keypair, String user) throws Throwable {
        SSHUtil.download(user, AttributeUtil.getAttribute(nodeName, "public_ip_address", instanceIdx), Context.SCP_PORT,
                Context.LOCAL_TEST_DATA_PATH.resolve(keypair).toString(), remoteFilePath, CURRENT_DOWNLOADED_FILE_PATH);
    }

    @Then("^The downloaded file should have the same content as the local file \"([^\"]*)\"$")
    public void The_downloaded_file_should_have_the_same_content_as_the_local_file(String localFilePath) throws Throwable {
        FileAssert.assertEquals(new File(Context.LOCAL_TEST_DATA_PATH.resolve(localFilePath).toString()), new File(CURRENT_DOWNLOADED_FILE_PATH));
    }

    @When("^I download the remote file \"([^\"]*)\" from the node \"([^\"]*)\" with the keypair defined in environment variable \"([^\"]*)\" and user \"([^\"]*)\"$")
    public void iDownloadTheRemoteFileFromTheNodeWithTheKeypairDefinedInEnvironmentVariableAndUser(String remoteFilePath, String nodeName, String keyName, String user) throws Throwable {
        String keypair = System.getenv(keyName);
        Assert.assertTrue(keyName + " must be defined as environment variable", StringUtils.isNotBlank(keypair));
        I_download_the_remote_file_from_the_node_with_the_keypair_and_user(remoteFilePath, nodeName, keypair, user);
    }
}