sap-jenkins-library/test/groovy/com/sap/piper/FileUtilsTest.groovy

package com.sap.piper

import org.junit.BeforeClass
import org.junit.ClassRule
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.rules.ExpectedException
import org.junit.rules.TemporaryFolder
import org.junit.rules.RuleChain

import util.Rules

import com.lesfurets.jenkins.unit.BasePipelineTest

import com.sap.piper.FileUtils

import hudson.AbortException


class FileUtilsTest extends BasePipelineTest {

    @ClassRule
    public static TemporaryFolder tmp = new TemporaryFolder()

    private ExpectedException thrown = new ExpectedException()

    @Rule
    public RuleChain rules = Rules.getCommonRules(this)
                .around(thrown)

    private static emptyDir
    private static notEmptyDir
    private static file

    private static script

    @BeforeClass
    static void createTestFiles() {

        emptyDir = tmp.newFolder('emptyDir').getAbsolutePath()
        notEmptyDir = tmp.newFolder('notEmptyDir').getAbsolutePath()
        file = tmp.newFile('notEmptyDir/file.txt').getAbsolutePath()
    }

    @Before
    void setup() {

        script = loadScript('commonPipelineEnvironment.groovy').commonPipelineEnvironment
    }


    @Test
    void validateDirectory_nullParameterTest() {

        thrown.expect(IllegalArgumentException)
        thrown.expectMessage("The parameter 'dir' can not be null or empty.")

        FileUtils.validateDirectory(script, null)
    }

    @Test
    void validateDirectory_emptyParameterTest() {

        thrown.expect(IllegalArgumentException)
        thrown.expectMessage("The parameter 'dir' can not be null or empty.")

        FileUtils.validateDirectory(script, '')
    }

    @Test
    void validateDirectory_directoryDoestNotExistTest() {

        def dir = new File("$emptyDir", 'test').getAbsolutePath()

        helper.registerAllowedMethod('sh', [Map], { Map m -> script(m, dir) })

        thrown.expect(AbortException)
        thrown.expectMessage("Validation failed. '$dir' does not exist.")

        FileUtils.validateDirectory(script, dir)
    }

    @Test
    void validateDirectory_isNotDirectoryTest() {

        helper.registerAllowedMethod('sh', [Map], { Map m -> script(m, file) })

        thrown.expect(AbortException)
        thrown.expectMessage("Validation failed. '$file' is not a directory.")

        FileUtils.validateDirectory(script, file)
    }

    @Test
    void validateDirectoryTest() {

        helper.registerAllowedMethod('sh', [Map], { Map m -> script(m, notEmptyDir) })

        FileUtils.validateDirectory(script, notEmptyDir)
    }

    @Test
    void validateDirectoryIsNotEmpty_directoryIsEmptyTest() {

        helper.registerAllowedMethod('sh', [Map], { Map m -> script(m, emptyDir) })

        thrown.expect(AbortException)
        thrown.expectMessage("Validation failed. '$emptyDir' is empty.")

        FileUtils.validateDirectoryIsNotEmpty(script, emptyDir)
    }

    @Test
    void validateDirectoryIsNotEmptyTest() {

        helper.registerAllowedMethod('sh', [Map], { Map m -> script(m, notEmptyDir) })

        FileUtils.validateDirectoryIsNotEmpty(script, notEmptyDir)
    }

    @Test
    void validateFile_NoFilePathTest() {

        thrown.expect(IllegalArgumentException)
        thrown.expectMessage("The parameter 'filePath' can not be null or empty.")

        FileUtils.validateFile(script, null)
    }

    @Test
    void validateFile_emptyParameterTest() {

        thrown.expect(IllegalArgumentException)
        thrown.expectMessage("The parameter 'filePath' can not be null or empty.")

        FileUtils.validateFile(script, '')
    }

    @Test
    void validateFile_fileDoesNotExistTest() {

        def path = new File("$emptyDir", 'test').getAbsolutePath()

        helper.registerAllowedMethod('sh', [Map], { Map m -> script(m, path) })

        thrown.expect(AbortException)
        thrown.expectMessage("Validation failed. '$path' does not exist.")

        FileUtils.validateFile(script, path)
    }

    @Test
    void validateFileTest() {

        helper.registerAllowedMethod('sh', [Map], { Map m -> script(m, file) })

        FileUtils.validateFile(script, file)
    }


    private script(parameters, path) {
      if(parameters.script.contains('exists')) return directoryOrFileExists(path)
      else if(parameters.script.contains('directory')) return isDirectory(path)
      else if(parameters.script.contains('empty')) return isDirectoryEmpty(path)
      else if(parameters.script.contains('file')) return isFile(path)
    }

    private directoryOrFileExists(dirOrFile) {
        def file = new File(dirOrFile)
        if (file.exists()) return 0
        else return 1
    }

    private isDirectory(dir) {
        def file = new File(dir)
        if (file.isDirectory()) return 0
        else return 1
    }

    private isDirectoryEmpty(dir) {
        def file = new File(dir)
        if (file.list().size() == 0) return 1
        return 0
    }

    private isFile(filePath) {
        def file = new File(filePath)
        if (file.isFile()) return 0
        return 1
    }
}