You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nifi.apache.org by ma...@apache.org on 2015/09/25 15:15:50 UTC
[4/5] nifi git commit: NIFI-604: Fixed checkstyle violation
NIFI-604: Fixed checkstyle violation
Project: http://git-wip-us.apache.org/repos/asf/nifi/repo
Commit: http://git-wip-us.apache.org/repos/asf/nifi/commit/eb94dab0
Tree: http://git-wip-us.apache.org/repos/asf/nifi/tree/eb94dab0
Diff: http://git-wip-us.apache.org/repos/asf/nifi/diff/eb94dab0
Branch: refs/heads/master
Commit: eb94dab00cf6011cfb59e5e0b08fd840184a5b12
Parents: 24c0807
Author: Mark Payne <ma...@hotmail.com>
Authored: Thu Sep 24 11:51:44 2015 -0400
Committer: Mark Payne <ma...@hotmail.com>
Committed: Thu Sep 24 11:51:44 2015 -0400
----------------------------------------------------------------------
.../standard/TestExecuteStreamCommand.java | 414 +++++++++----------
1 file changed, 207 insertions(+), 207 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/nifi/blob/eb94dab0/nifi-nar-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java b/nifi-nar-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java
index 8f945ac..0f13ba2 100644
--- a/nifi-nar-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java
+++ b/nifi-nar-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java
@@ -42,212 +42,212 @@ import org.junit.Test;
*
*/
public class TestExecuteStreamCommand {
- @BeforeClass
- public static void init() {
- System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "info");
- System.setProperty("org.slf4j.simpleLogger.showDateTime", "true");
- System.setProperty("org.slf4j.simpleLogger.log.nifi.processors.standard.ExecuteStreamCommand", "debug");
- System.setProperty("org.slf4j.simpleLogger.log.nifi.processors.standard.TestExecuteStreamCommand", "debug");
- }
-
- @Test
- public void testExecuteJar() throws Exception {
- File exJar = new File("src/test/resources/ExecuteCommand/TestSuccess.jar");
- File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
- String jarPath = exJar.getAbsolutePath();
- exJar.setExecutable(true);
- final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setValidateExpressionUsage(false);
- controller.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
- controller.run(1);
- controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
-
- List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
- byte[] byteArray = outputFlowFile.toByteArray();
- String result = new String(byteArray);
- assertTrue(Pattern.compile("Test was a success\r?\n").matcher(result).find());
- assertEquals("0", outputFlowFile.getAttribute("execution.status"));
- assertEquals("java", outputFlowFile.getAttribute("execution.command"));
- assertEquals("-jar;", outputFlowFile.getAttribute("execution.command.args").substring(0, 5));
- String attribute = outputFlowFile.getAttribute("execution.command.args");
- String expected = "src" + File.separator + "test" + File.separator + "resources" + File.separator + "ExecuteCommand" + File.separator + "TestSuccess.jar";
- assertEquals(expected, attribute.substring(attribute.length() - expected.length()));
-
- MockFlowFile originalFlowFile = controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP).get(0);
- assertEquals(outputFlowFile.getAttribute("execution.status"), originalFlowFile.getAttribute("execution.status"));
- assertEquals(outputFlowFile.getAttribute("execution.command"), originalFlowFile.getAttribute("execution.command"));
- assertEquals(outputFlowFile.getAttribute("execution.command.args"), originalFlowFile.getAttribute("execution.command.args"));
- }
-
- @Test
- public void testExecuteJarWithBadPath() throws Exception {
- File exJar = new File("src/test/resources/ExecuteCommand/noSuchFile.jar");
- File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
- String jarPath = exJar.getAbsolutePath();
- exJar.setExecutable(true);
- final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setValidateExpressionUsage(false);
- controller.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
- controller.run(1);
- controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- assertEquals(0, flowFiles.get(0).getSize());
- assertEquals("Error: Unable to access jarfile", flowFiles.get(0).getAttribute("execution.error").substring(0, 31));
- }
-
- @Test
- public void testExecuteIngestAndUpdate() throws IOException {
- File exJar = new File("src/test/resources/ExecuteCommand/TestIngestAndUpdate.jar");
- File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
- File dummy100MBytes = new File("target/100MB.txt");
- FileInputStream fis = new FileInputStream(dummy);
- FileOutputStream fos = new FileOutputStream(dummy100MBytes);
- byte[] bytes = new byte[1024];
- assertEquals(1000, fis.read(bytes));
- fis.close();
- for (int i = 0; i < 100000; i++) {
- fos.write(bytes, 0, 1000);
- }
- fos.close();
- String jarPath = exJar.getAbsolutePath();
- exJar.setExecutable(true);
- final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setValidateExpressionUsage(false);
- controller.enqueue(dummy100MBytes.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
- controller.run(1);
- controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- byte[] byteArray = flowFiles.get(0).toByteArray();
- String result = new String(byteArray);
-
- assertTrue(Pattern.compile("nifi-standard-processors:ModifiedResult\r?\n").matcher(result).find());
- }
-
- @Test
- public void testExecuteIngestAndUpdateWithWorkingDir() throws IOException {
- File exJar = new File("src/test/resources/ExecuteCommand/TestIngestAndUpdate.jar");
- File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
- String jarPath = exJar.getAbsolutePath();
- exJar.setExecutable(true);
- final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setValidateExpressionUsage(false);
- controller.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
- controller.run(1);
- controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- byte[] byteArray = flowFiles.get(0).toByteArray();
- String result = new String(byteArray);
-
- final String quotedSeparator = Pattern.quote(File.separator);
- assertTrue(Pattern.compile(quotedSeparator + "nifi-standard-processors" + quotedSeparator + "target:ModifiedResult\r?\n").matcher(result).find());
- }
-
- @Test
- public void testIgnoredStdin() throws IOException {
- File exJar = new File("src/test/resources/ExecuteCommand/TestIngestAndUpdate.jar");
- File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
- String jarPath = exJar.getAbsolutePath();
- exJar.setExecutable(true);
- final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setValidateExpressionUsage(false);
- controller.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
- controller.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
- controller.run(1);
- controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- byte[] byteArray = flowFiles.get(0).toByteArray();
- String result = new String(byteArray);
- assertTrue("TestIngestAndUpdate.jar should not have received anything to modify",
- Pattern.compile("target:ModifiedResult\r?\n$").matcher(result).find());
- }
-
- // this is dependent on window with cygwin...so it's not enabled
- @Ignore
- @Test
- public void testExecuteTouch() throws Exception {
- File testFile = new File("target/test.txt");
- testFile.delete();
- File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
- final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setValidateExpressionUsage(false);
- controller.enqueue(dummy.toPath());
- controller.enqueue(dummy.toPath());
- controller.enqueue(dummy.toPath());
- controller.enqueue(dummy.toPath());
- controller.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target/xx1");
- controller.setThreadCount(6);
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "c:\\cygwin\\bin\\touch");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "test.txt");
- controller.assertValid();
- controller.run(6);
- List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- assertEquals(5, flowFiles.size());
- assertEquals(0, flowFiles.get(0).getSize());
-
- }
-
- @Test
- public void testDynamicEnvironment() throws Exception {
- File exJar = new File("src/test/resources/ExecuteCommand/TestDynamicEnvironment.jar");
- File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
- String jarPath = exJar.getAbsolutePath();
- exJar.setExecutable(true);
- final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setProperty("NIFI_TEST_1", "testvalue1");
- controller.setProperty("NIFI_TEST_2", "testvalue2");
- controller.setValidateExpressionUsage(false);
- controller.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
- controller.run(1);
- controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- byte[] byteArray = flowFiles.get(0).toByteArray();
- String result = new String(byteArray);
- Set<String> dynamicEnvironmentVariables = new HashSet<>(Arrays.asList(result.split("\r?\n")));
- assertFalse("Should contain at least two environment variables starting with NIFI", dynamicEnvironmentVariables.size() < 2);
- assertTrue("NIFI_TEST_1 environment variable is missing", dynamicEnvironmentVariables.contains("NIFI_TEST_1=testvalue1"));
- assertTrue("NIFI_TEST_2 environment variable is missing", dynamicEnvironmentVariables.contains("NIFI_TEST_2=testvalue2"));
- }
-
- @Test
- public void testQuotedArguments() throws Exception {
- List<String> args = ArgumentUtils.splitArgs("echo -n \"arg1 arg2 arg3\"", ' ');
- assertEquals(3, args.size());
- args = ArgumentUtils.splitArgs("echo;-n;\"arg1 arg2 arg3\"", ';');
- assertEquals(3, args.size());
- }
-
- @Test
- public void testInvalidDelimiter() throws Exception {
- final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "echo");
- controller.assertValid();
- controller.setProperty(ExecuteStreamCommand.ARG_DELIMITER, "foo");
- controller.assertNotValid();
- controller.setProperty(ExecuteStreamCommand.ARG_DELIMITER, "f");
- controller.assertValid();
- }
+ @BeforeClass
+ public static void init() {
+ System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "info");
+ System.setProperty("org.slf4j.simpleLogger.showDateTime", "true");
+ System.setProperty("org.slf4j.simpleLogger.log.nifi.processors.standard.ExecuteStreamCommand", "debug");
+ System.setProperty("org.slf4j.simpleLogger.log.nifi.processors.standard.TestExecuteStreamCommand", "debug");
+ }
+
+ @Test
+ public void testExecuteJar() throws Exception {
+ File exJar = new File("src/test/resources/ExecuteCommand/TestSuccess.jar");
+ File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
+ String jarPath = exJar.getAbsolutePath();
+ exJar.setExecutable(true);
+ final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ controller.setValidateExpressionUsage(false);
+ controller.enqueue(dummy.toPath());
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
+ controller.run(1);
+ controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
+ controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+
+ List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.get(0);
+ byte[] byteArray = outputFlowFile.toByteArray();
+ String result = new String(byteArray);
+ assertTrue(Pattern.compile("Test was a success\r?\n").matcher(result).find());
+ assertEquals("0", outputFlowFile.getAttribute("execution.status"));
+ assertEquals("java", outputFlowFile.getAttribute("execution.command"));
+ assertEquals("-jar;", outputFlowFile.getAttribute("execution.command.args").substring(0, 5));
+ String attribute = outputFlowFile.getAttribute("execution.command.args");
+ String expected = "src" + File.separator + "test" + File.separator + "resources" + File.separator + "ExecuteCommand" + File.separator + "TestSuccess.jar";
+ assertEquals(expected, attribute.substring(attribute.length() - expected.length()));
+
+ MockFlowFile originalFlowFile = controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP).get(0);
+ assertEquals(outputFlowFile.getAttribute("execution.status"), originalFlowFile.getAttribute("execution.status"));
+ assertEquals(outputFlowFile.getAttribute("execution.command"), originalFlowFile.getAttribute("execution.command"));
+ assertEquals(outputFlowFile.getAttribute("execution.command.args"), originalFlowFile.getAttribute("execution.command.args"));
+ }
+
+ @Test
+ public void testExecuteJarWithBadPath() throws Exception {
+ File exJar = new File("src/test/resources/ExecuteCommand/noSuchFile.jar");
+ File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
+ String jarPath = exJar.getAbsolutePath();
+ exJar.setExecutable(true);
+ final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ controller.setValidateExpressionUsage(false);
+ controller.enqueue(dummy.toPath());
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
+ controller.run(1);
+ controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
+ controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ assertEquals(0, flowFiles.get(0).getSize());
+ assertEquals("Error: Unable to access jarfile", flowFiles.get(0).getAttribute("execution.error").substring(0, 31));
+ }
+
+ @Test
+ public void testExecuteIngestAndUpdate() throws IOException {
+ File exJar = new File("src/test/resources/ExecuteCommand/TestIngestAndUpdate.jar");
+ File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
+ File dummy100MBytes = new File("target/100MB.txt");
+ FileInputStream fis = new FileInputStream(dummy);
+ FileOutputStream fos = new FileOutputStream(dummy100MBytes);
+ byte[] bytes = new byte[1024];
+ assertEquals(1000, fis.read(bytes));
+ fis.close();
+ for (int i = 0; i < 100000; i++) {
+ fos.write(bytes, 0, 1000);
+ }
+ fos.close();
+ String jarPath = exJar.getAbsolutePath();
+ exJar.setExecutable(true);
+ final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ controller.setValidateExpressionUsage(false);
+ controller.enqueue(dummy100MBytes.toPath());
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
+ controller.run(1);
+ controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
+ controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.get(0).toByteArray();
+ String result = new String(byteArray);
+
+ assertTrue(Pattern.compile("nifi-standard-processors:ModifiedResult\r?\n").matcher(result).find());
+ }
+
+ @Test
+ public void testExecuteIngestAndUpdateWithWorkingDir() throws IOException {
+ File exJar = new File("src/test/resources/ExecuteCommand/TestIngestAndUpdate.jar");
+ File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
+ String jarPath = exJar.getAbsolutePath();
+ exJar.setExecutable(true);
+ final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ controller.setValidateExpressionUsage(false);
+ controller.enqueue(dummy.toPath());
+ controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
+ controller.run(1);
+ controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
+ controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.get(0).toByteArray();
+ String result = new String(byteArray);
+
+ final String quotedSeparator = Pattern.quote(File.separator);
+ assertTrue(Pattern.compile(quotedSeparator + "nifi-standard-processors" + quotedSeparator + "target:ModifiedResult\r?\n").matcher(result).find());
+ }
+
+ @Test
+ public void testIgnoredStdin() throws IOException {
+ File exJar = new File("src/test/resources/ExecuteCommand/TestIngestAndUpdate.jar");
+ File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
+ String jarPath = exJar.getAbsolutePath();
+ exJar.setExecutable(true);
+ final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ controller.setValidateExpressionUsage(false);
+ controller.enqueue(dummy.toPath());
+ controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
+ controller.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ controller.run(1);
+ controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
+ controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.get(0).toByteArray();
+ String result = new String(byteArray);
+ assertTrue("TestIngestAndUpdate.jar should not have received anything to modify",
+ Pattern.compile("target:ModifiedResult\r?\n$").matcher(result).find());
+ }
+
+ // this is dependent on window with cygwin...so it's not enabled
+ @Ignore
+ @Test
+ public void testExecuteTouch() throws Exception {
+ File testFile = new File("target/test.txt");
+ testFile.delete();
+ File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
+ final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ controller.setValidateExpressionUsage(false);
+ controller.enqueue(dummy.toPath());
+ controller.enqueue(dummy.toPath());
+ controller.enqueue(dummy.toPath());
+ controller.enqueue(dummy.toPath());
+ controller.enqueue(dummy.toPath());
+ controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target/xx1");
+ controller.setThreadCount(6);
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "c:\\cygwin\\bin\\touch");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "test.txt");
+ controller.assertValid();
+ controller.run(6);
+ List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ assertEquals(5, flowFiles.size());
+ assertEquals(0, flowFiles.get(0).getSize());
+
+ }
+
+ @Test
+ public void testDynamicEnvironment() throws Exception {
+ File exJar = new File("src/test/resources/ExecuteCommand/TestDynamicEnvironment.jar");
+ File dummy = new File("src/test/resources/ExecuteCommand/1000bytes.txt");
+ String jarPath = exJar.getAbsolutePath();
+ exJar.setExecutable(true);
+ final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ controller.setProperty("NIFI_TEST_1", "testvalue1");
+ controller.setProperty("NIFI_TEST_2", "testvalue2");
+ controller.setValidateExpressionUsage(false);
+ controller.enqueue(dummy.toPath());
+ controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" + jarPath);
+ controller.run(1);
+ controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
+ controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles = controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.get(0).toByteArray();
+ String result = new String(byteArray);
+ Set<String> dynamicEnvironmentVariables = new HashSet<>(Arrays.asList(result.split("\r?\n")));
+ assertFalse("Should contain at least two environment variables starting with NIFI", dynamicEnvironmentVariables.size() < 2);
+ assertTrue("NIFI_TEST_1 environment variable is missing", dynamicEnvironmentVariables.contains("NIFI_TEST_1=testvalue1"));
+ assertTrue("NIFI_TEST_2 environment variable is missing", dynamicEnvironmentVariables.contains("NIFI_TEST_2=testvalue2"));
+ }
+
+ @Test
+ public void testQuotedArguments() throws Exception {
+ List<String> args = ArgumentUtils.splitArgs("echo -n \"arg1 arg2 arg3\"", ' ');
+ assertEquals(3, args.size());
+ args = ArgumentUtils.splitArgs("echo;-n;\"arg1 arg2 arg3\"", ';');
+ assertEquals(3, args.size());
+ }
+
+ @Test
+ public void testInvalidDelimiter() throws Exception {
+ final TestRunner controller = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "echo");
+ controller.assertValid();
+ controller.setProperty(ExecuteStreamCommand.ARG_DELIMITER, "foo");
+ controller.assertNotValid();
+ controller.setProperty(ExecuteStreamCommand.ARG_DELIMITER, "f");
+ controller.assertValid();
+ }
}