diff options
Diffstat (limited to 'bigtop-tests/smoke-tests/odpi-runtime/src/test/groovy/org')
-rw-r--r-- | bigtop-tests/smoke-tests/odpi-runtime/src/test/groovy/org/odpi/specs/runtime/TestSpecsRuntime.groovy | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/bigtop-tests/smoke-tests/odpi-runtime/src/test/groovy/org/odpi/specs/runtime/TestSpecsRuntime.groovy b/bigtop-tests/smoke-tests/odpi-runtime/src/test/groovy/org/odpi/specs/runtime/TestSpecsRuntime.groovy new file mode 100644 index 00000000..bc2a3b20 --- /dev/null +++ b/bigtop-tests/smoke-tests/odpi-runtime/src/test/groovy/org/odpi/specs/runtime/TestSpecsRuntime.groovy @@ -0,0 +1,275 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 + * <p/> + * http://www.apache.org/licenses/LICENSE-2.0 + * <p/> + * 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 org.odpi.specs.runtime + +import groovy.io.FileType +import org.junit.Assert +import org.apache.bigtop.itest.shell.* +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.Parameterized +import org.junit.runners.Parameterized.Parameters + +import java.util.regex.Matcher +import java.util.regex.Pattern + +/** + * Check all expected environment + * Tests are constructed dynamically, using external DSL to define + * - test name + * - test type + * - command to execute the test + * - expected pattern of the output + */ +@RunWith(Parameterized.class) +public class TestSpecsRuntime { + private String testName + private String type + private Map arguments + + private static ENV = System.getenv() + + @Parameters(name="{0}") + public static Collection<Object[]> allTests() { + List<Object[]> specs = []; + + config.specs.tests.each { test -> + specs.add([test.value.name, test.value.type, test.value.arguments] as Object[]) + } + return specs + } + + public TestSpecsRuntime (String testName, String type, Map arguments) { + this.testName = testName + this.type = type + this.arguments = arguments + } + + public static final String testsList = System.properties['test.resources.dir'] ?: + "${System.properties['buildDir']}/resources/test" + def final static config = new ConfigSlurper().parse(new URL("file:${getTestConfigName()}")) + + private static String getTestConfigName() { + return "$testsList/testRuntimeSpecConf.groovy"; + } + + private Map getEnvMap(String command) { + def envMap = [:] + Shell sh = new Shell() + def envvars = sh.exec(command).getOut() + if (sh.getRet() == 0) { + envvars.each { + def match = it =~ /(?<variable>[^=]+)='(?<value>[^']+)'$/ + if ( match.matches() ) { + envMap[match.group('variable')] = match.group('value') + } + } + } + return envMap + } + + private String getEnv(String name, String cmd) { + String value = ENV[name] + if (value == null) { + value = getEnvMap(cmd)[name] + } + return value + } + + @Test + public void testAll() { + switch (type) { + case 'shell': + Shell sh = new Shell() + def output = sh.exec(arguments['command']).getOut().join("\n") + int actualResult = sh.getRet() + int expectedResult = arguments['expectedResult'] ? arguments['expectedResult'] : 0 // use 0 as default success code + Assert.assertTrue("${testName} fail: ${arguments['message']} - '${arguments['command']}' returned ${actualResult} instead of ${expectedResult}", + actualResult == expectedResult) + break + + case 'envdir': + def var = arguments['variable'] + def isPathRelative = arguments['relative'] + def pathString = getEnv(var, arguments['envcmd']) + Assert.assertTrue("${testName} fail: environment variable ${var} does not exist", pathString != null ) + + if ( arguments['pattern'] ) { + Assert.assertTrue("${testName} fail: $pathString doesn't contain expected pattern", + pathString ==~ /${arguments['pattern']}/) + } + + def pathFile = new File(pathString) + if ( isPathRelative ) { + Assert.assertFalse("${testName} fail: ${pathString} is not relative", pathFile.isAbsolute() ) + } else { + if (!arguments['donotcheckexistance']) { + Assert.assertTrue("${testName} fail: ${pathString} does not exist", pathFile.exists() ) + Assert.assertTrue("${testName} fail: ${pathString} is not directory", pathFile.isDirectory() ) + } + } + break + + case 'dirstruct': + def expectedFiles = [] + new File("${testsList}", "${arguments['referenceList']}").eachLine { line -> + expectedFiles << ~line + } + def baseDirEnv = getEnv(arguments['baseDirEnv'], arguments['envcmd']) + Assert.assertNotNull("${baseDirEnv} has to be set for the test to continue", + baseDirEnv) + def root = new File(baseDirEnv) + def actualFiles = [] + def missingFiles = [] + if ( ! root.exists() ) { + Assert.assertFail("${testName} fail: ${baseDirEnv} does not exist!"); + } + + root.eachFileRecurse(FileType.ANY) { file -> + def relPath = new File( root.toURI().relativize( file.toURI() ).toString() ).path + actualFiles << relPath + } + + expectedFiles.each { wantFile -> + def ok = false + for (def x : actualFiles) { + if (actualFiles =~ wantFile) { + ok = true + break + } + } + if (!ok) { + missingFiles << wantFile + } + } + + Assert.assertTrue("${testName} fail: Directory structure for ${baseDirEnv} does not match reference. Missing files: ${missingFiles} ", + missingFiles.size() == 0) + break + + case 'dircontent': + def expectedFiles = [] + new File("${testsList}", "${arguments['referenceList']}").eachLine { line -> + expectedFiles << ~line + } + + def baseDir = getEnv(arguments['baseDirEnv'], arguments['envcmd']) + def subDir = arguments['subDir'] + if (!subDir && arguments['subDirEnv']) { + subDir = getEnv(arguments['subDirEnv'], arguments['envcmd']) + } + + def dir = null + if (subDir) { + dir = new File(baseDir, subDir) + } else { + dir = new File(baseDir) + } + Assert.assertNotNull("Directory has to be set for the test to continue", dir) + + def actualFiles = [] + if (dir.exists()) { + dir.eachFile FileType.FILES, { file -> + def relPath = new File( dir.toURI().relativize( file.toURI() ).toString() ).path + actualFiles << relPath + } + } + + def missingList = [] + for (def wantFile : expectedFiles) { + def ok = false + for (def haveFile : actualFiles) { + if (haveFile =~ wantFile) { + ok = true + break + } + } + if (! ok) { + missingList << wantFile + } + } + + def extraList = [] + for (def haveFile : actualFiles) { + def ok = false + for (def wantFile : expectedFiles) { + if (haveFile =~ wantFile) { + ok = true + break + } + } + if (! ok) { + extraList << haveFile + } + } + + def commonFiles = actualFiles.intersect(expectedFiles) + Assert.assertTrue("${testName} fail: Directory content for ${dir.path} does not match reference. Missing files: ${missingList}. Extra files: ${extraList}", + missingList.size() == 0 && extraList.size() == 0) + break + case 'hadoop_tools': + def toolsPathStr = getEnv("HADOOP_TOOLS_PATH", "hadoop envvars") + Assert.assertNotNull("${testName} fail: HADOOP_TOOLS_PATH environment variable should be set", toolsPathStr) + + def toolsPath = new File(toolsPathStr) + Assert.assertTrue("${testName} fail: HADOOP_TOOLS_PATH must be an absolute path.", toolsPath.isAbsolute()) + + Shell sh = new Shell() + def classPath = sh.exec("hadoop classpath").getOut().join("\n") + Assert.assertTrue("${testName} fail: Failed to retrieve hadoop's classpath", sh.getRet()==0) + + Assert.assertFalse("${testName} fail: The enire '${toolsPath}' path should not be included in the hadoop's classpath", + classPath.split(File.pathSeparator).any { + new File(it).getCanonicalPath() =~ /^${toolsPath}\/?\*/ + } + ) + break + case 'api_examination': + def basedir = getEnv(arguments['baseDirEnv'], arguments['envcmd']) + def libdir = getEnv(arguments['libDir'], arguments['envcmd']) + + def dir = new File(basedir + "/" + libdir) + Assert.assertTrue("Expected " + dir.getPath() + " to be a directory", dir.isDirectory()) + def pattern = Pattern.compile(arguments['jar'] + "-[0-9]+.*\\.jar") + def String[] jars = dir.list(new FilenameFilter() { + @Override + boolean accept(File d, String name) { + Matcher matcher = pattern.matcher(name) + return (matcher.matches() && !name.contains("test")) + } + }) + Assert.assertEquals("Expected only one jar, but got " + jars.join(", "), 1, jars.length) + def jar = dir.getAbsolutePath() + "/" + jars[0] + + def examinerJar = System.properties['odpi.test.hive.hcat.job.jar'] + def resourceFile = System.properties['test.resources.dir']+ "/" + arguments['resourceFile'] + Shell sh = new Shell() + def results = sh.exec("hadoop jar " + examinerJar + " org.odpi.specs.runtime.hadoop.ApiExaminer -c " + resourceFile + " -j " + jar).getErr() + int rc = sh.getRet() + Assert.assertEquals("Expected command to succeed, but got return code " + rc, 0, rc) + if (results.size() > 0) { + System.out.println("Received report for jar " + arguments['jar'] + results.join("\n")) + } + break; + + + default: + break + } + } +} |