This is an automated email from the ASF dual-hosted git repository.
exceptionfactory pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/nifi.git
The following commit(s) were added to refs/heads/main by this push:
new b7861f3502 NIFI-15402 Enabled testEcho in TestExecuteProcess and
TestExecuteStreamCommand on Windows (#10706)
b7861f3502 is described below
commit b7861f35029dc97a8b364a8373b1e2222451b327
Author: dan-s1 <[email protected]>
AuthorDate: Mon Dec 29 20:43:15 2025 -0500
NIFI-15402 Enabled testEcho in TestExecuteProcess and
TestExecuteStreamCommand on Windows (#10706)
Signed-off-by: David Handermann <[email protected]>
---
.../processors/standard/TestExecuteProcess.java | 57 +-
.../standard/TestExecuteStreamCommand.java | 833 ++++++++++-----------
2 files changed, 416 insertions(+), 474 deletions(-)
diff --git
a/nifi-extension-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteProcess.java
b/nifi-extension-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteProcess.java
index f5b426f08b..58443b8c0c 100644
---
a/nifi-extension-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteProcess.java
+++
b/nifi-extension-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteProcess.java
@@ -28,9 +28,8 @@ import org.apache.nifi.util.LogMessage;
import org.apache.nifi.util.MockFlowFile;
import org.apache.nifi.util.TestRunner;
import org.apache.nifi.util.TestRunners;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.DisabledOnOs;
-import org.junit.jupiter.api.condition.OS;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -39,6 +38,12 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class TestExecuteProcess {
+ private TestRunner runner;
+
+ @BeforeEach
+ void setUp() {
+ runner = TestRunners.newTestRunner(ExecuteProcess.class);
+ }
@Test
public void testSplitArgs() {
@@ -54,7 +59,7 @@ public class TestExecuteProcess {
final List<String> singleArg = ArgumentUtils.splitArgs(" hello ",
';');
assertEquals(1, singleArg.size());
- assertEquals(" hello ", singleArg.get(0));
+ assertEquals(" hello ", singleArg.getFirst());
final List<String> twoArg = ArgumentUtils.splitArgs(" hello ;
good-bye ", ';');
assertEquals(2, twoArg.size());
@@ -63,7 +68,7 @@ public class TestExecuteProcess {
final List<String> oneUnnecessarilyQuotedArg =
ArgumentUtils.splitArgs(" \"hello\" ", ';');
assertEquals(1, oneUnnecessarilyQuotedArg.size());
- assertEquals(" hello ", oneUnnecessarilyQuotedArg.get(0));
+ assertEquals(" hello ", oneUnnecessarilyQuotedArg.getFirst());
final List<String> twoQuotedArg = ArgumentUtils.splitArgs("\"
hello\" \"good bye\"", ' ');
assertEquals(2, twoQuotedArg.size());
@@ -84,10 +89,8 @@ public class TestExecuteProcess {
assertEquals("", twoArgOneWholeQuotedArgOneEmptyArg.get(3));
}
- @DisabledOnOs(OS.WINDOWS)
@Test
public void testEcho() {
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteProcess.class);
runner.setProperty(ExecuteProcess.COMMAND, "echo");
runner.setProperty(ExecuteProcess.COMMAND_ARGUMENTS, "test-args");
runner.setProperty(ExecuteProcess.BATCH_DURATION, "500 millis");
@@ -103,7 +106,6 @@ public class TestExecuteProcess {
@Test
public void validateProcessInterruptOnStop() throws Exception {
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteProcess.class);
runner.setEnvironmentVariableValue("command", "ping");
runner.setProperty(ExecuteProcess.COMMAND, "${command}");
runner.setProperty(ExecuteProcess.COMMAND_ARGUMENTS,
"nifi.apache.org");
@@ -125,36 +127,10 @@ public class TestExecuteProcess {
final List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteProcess.REL_SUCCESS);
if (!flowFiles.isEmpty()) {
- assertEquals("ping", flowFiles.get(0).getAttribute("command"));
+ assertEquals("ping", flowFiles.getFirst().getAttribute("command"));
}
}
- // @Test
- public void testBigBinaryInputData() {
- System.setProperty("org.slf4j.simpleLogger.log.org.apache.nifi",
"TRACE");
-
System.setProperty("org.slf4j.simpleLogger.log.org.apache.nifi.processors.standard",
"DEBUG");
-
- String workingDirName = "/var/test";
- String testFile = "eclipse-java-luna-SR2-win32.zip";
-
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteProcess.class);
- runner.setProperty(ExecuteProcess.COMMAND, "cmd");
- runner.setProperty(ExecuteProcess.COMMAND_ARGUMENTS, " /c type " +
testFile);
- runner.setProperty(ExecuteProcess.WORKING_DIR, workingDirName);
-
- File inFile = new File(workingDirName, testFile);
-
- runner.run();
-
- final List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteProcess.REL_SUCCESS);
- long totalFlowFilesSize = 0;
- for (final MockFlowFile flowFile : flowFiles) {
- totalFlowFilesSize += flowFile.getSize();
- }
-
- assertEquals(inFile.length(), totalFlowFilesSize);
- }
-
@Test
public void testBigInputSplit() {
System.setProperty("org.slf4j.simpleLogger.log.org.apache.nifi",
"TRACE");
@@ -162,9 +138,7 @@ public class TestExecuteProcess {
String workingDirName = "/var/test";
String testFile =
"Novo_dicionário_da_língua_portuguesa_by_Cândido_de_Figueiredo.txt";
- // String testFile = "eclipse-java-luna-SR2-win32.zip";
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteProcess.class);
runner.setProperty(ExecuteProcess.COMMAND, "cmd");
runner.setProperty(ExecuteProcess.COMMAND_ARGUMENTS, " /c type " +
testFile);
runner.setProperty(ExecuteProcess.WORKING_DIR, workingDirName);
@@ -201,7 +175,6 @@ public class TestExecuteProcess {
@Test
public void testNotRedirectErrorStream() {
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteProcess.class);
runner.setProperty(ExecuteProcess.COMMAND, "cd");
runner.setProperty(ExecuteProcess.COMMAND_ARGUMENTS, "does-not-exist");
@@ -222,7 +195,7 @@ public class TestExecuteProcess {
final int expectedWarningMessages = 1;
final int maxRetry = 5;
for (int i = 0; i < maxRetry
- && (runner.getLogger().getWarnMessages().size() <
expectedWarningMessages); i++) {
+ && (runner.getLogger().getWarnMessages().isEmpty()); i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException ignored) {
@@ -238,7 +211,6 @@ public class TestExecuteProcess {
@Test
public void testRedirectErrorStream() {
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteProcess.class);
runner.setProperty(ExecuteProcess.COMMAND, "cd");
runner.setProperty(ExecuteProcess.COMMAND_ARGUMENTS, "does-not-exist");
runner.setProperty(ExecuteProcess.REDIRECT_ERROR_STREAM, "true");
@@ -262,7 +234,6 @@ public class TestExecuteProcess {
@Test
public void testRedirectErrorStreamWithExpressions() {
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteProcess.class);
runner.setProperty(ExecuteProcess.COMMAND, "ls");
runner.setProperty(ExecuteProcess.COMMAND_ARGUMENTS,
"${literal('does-not-exist'):toUpper()}");
runner.setProperty(ExecuteProcess.REDIRECT_ERROR_STREAM, "true");
@@ -282,9 +253,9 @@ public class TestExecuteProcess {
"the output should be sent as a content of flow-file.");
final List<MockFlowFile> succeeded =
runner.getFlowFilesForRelationship(ExecuteProcess.REL_SUCCESS);
assertEquals(1, succeeded.size());
- assertTrue(new
String(succeeded.get(0).toByteArray()).contains("DOES-NOT-EXIST"));
-
assertEquals(succeeded.get(0).getAttribute(ExecuteProcess.ATTRIBUTE_COMMAND),
"ls");
-
assertEquals(succeeded.get(0).getAttribute(ExecuteProcess.ATTRIBUTE_COMMAND_ARGS),
"DOES-NOT-EXIST");
+ assertTrue(new
String(succeeded.getFirst().toByteArray()).contains("DOES-NOT-EXIST"));
+
assertEquals(succeeded.getFirst().getAttribute(ExecuteProcess.ATTRIBUTE_COMMAND),
"ls");
+
assertEquals(succeeded.getFirst().getAttribute(ExecuteProcess.ATTRIBUTE_COMMAND_ARGS),
"DOES-NOT-EXIST");
}
/**
diff --git
a/nifi-extension-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java
b/nifi-extension-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java
index 8578542387..b34126fb41 100644
---
a/nifi-extension-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java
+++
b/nifi-extension-bundles/nifi-standard-bundle/nifi-standard-processors/src/test/java/org/apache/nifi/processors/standard/TestExecuteStreamCommand.java
@@ -23,10 +23,12 @@ import org.apache.nifi.components.PropertyDescriptor;
import org.apache.nifi.expression.ExpressionLanguageScope;
import org.apache.nifi.flowfile.attributes.CoreAttributes;
import org.apache.nifi.processors.standard.util.ArgumentUtils;
+import org.apache.nifi.processors.standard.util.JsonUtil;
import org.apache.nifi.util.LogMessage;
import org.apache.nifi.util.MockFlowFile;
import org.apache.nifi.util.TestRunner;
import org.apache.nifi.util.TestRunners;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.DisabledOnOs;
import org.junit.jupiter.api.condition.OS;
@@ -48,13 +50,17 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
-@DisabledOnOs(value = OS.WINDOWS, disabledReason = "Test only runs on *nix")
public class TestExecuteStreamCommand {
+ private TestRunner runner;
+
+ @BeforeEach
+ void setUp() {
+ runner = TestRunners.newTestRunner(ExecuteStreamCommand.class);
+ }
+
@Test
public void testDynamicPropertyArgumentsStrategyValid() {
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
-
runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
runner.setProperty("command.argument.1", "-version");
@@ -67,8 +73,6 @@ public class TestExecuteStreamCommand {
@Test
public void testCommandArgumentsPropertyStrategyValid() {
- final TestRunner runner =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
-
runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.COMMAND_ARGUMENTS_PROPERTY_STRATEGY.getValue());
runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
runner.setProperty("RUNTIME_VERSION", "version-1");
@@ -85,17 +89,16 @@ public class TestExecuteStreamCommand {
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(ExecuteStreamCommand.MIME_TYPE.getName(),
"text/plain");
- 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);
+ runner.setProperty(ExecuteStreamCommand.MIME_TYPE.getName(),
"text/plain");
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
byte[] byteArray = outputFlowFile.toByteArray();
String result = new String(byteArray);
assertTrue(Pattern.compile("Test was a
success\r?\n").matcher(result).find());
@@ -107,7 +110,7 @@ public class TestExecuteStreamCommand {
assertEquals(expected, attribute.substring(attribute.length() -
expected.length()));
outputFlowFile.assertAttributeEquals(CoreAttributes.MIME_TYPE.key(),
"text/plain");
- MockFlowFile originalFlowFile =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP).get(0);
+ MockFlowFile originalFlowFile =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP).getFirst();
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"));
@@ -119,28 +122,27 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
1);
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
byte[] byteArray = outputFlowFile.toByteArray();
String result = new String(byteArray);
assertTrue(Pattern.compile("Test was a
success\r?\n").matcher(result).find());
@@ -151,7 +153,7 @@ public class TestExecuteStreamCommand {
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);
+ MockFlowFile originalFlowFile =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP).getFirst();
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"));
@@ -164,16 +166,15 @@ public class TestExecuteStreamCommand {
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.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,
0);
-
controller.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP,
1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP);
- MockFlowFile flowFile = flowFiles.get(0);
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+
runner.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP);
+ MockFlowFile flowFile = flowFiles.getFirst();
assertEquals(0, flowFile.getSize());
assertTrue(flowFile.getAttribute("execution.error").contains("Error:
Unable to access jarfile"));
assertTrue(flowFile.isPenalized());
@@ -185,28 +186,27 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
-
controller.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP,
1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP);
- MockFlowFile flowFile = flowFiles.get(0);
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+
runner.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP);
+ MockFlowFile flowFile = flowFiles.getFirst();
assertEquals(0, flowFile.getSize());
assertTrue(flowFile.getAttribute("execution.error").contains("Error:
Unable to access jarfile"));
assertTrue(flowFile.isPenalized());
@@ -226,15 +226,14 @@ public class TestExecuteStreamCommand {
}
String jarPath = exJar.getAbsolutePath();
exJar.setExecutable(true);
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue(dummy10MBytes.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();
+ runner.enqueue(dummy10MBytes.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.getFirst().toByteArray();
String result = new String(byteArray);
assertTrue(Pattern.compile("nifi-standard-processors:ModifiedResult\r?\n").matcher(result).find());
@@ -254,27 +253,26 @@ public class TestExecuteStreamCommand {
}
String jarPath = exJar.getAbsolutePath();
exJar.setExecutable(true);
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue(dummy10MBytes.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy10MBytes.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, 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();
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.getFirst().toByteArray();
String result = new String(byteArray);
assertTrue(Pattern.compile("nifi-standard-processors:ModifiedResult\r?\n").matcher(result).find());
@@ -286,19 +284,18 @@ public class TestExecuteStreamCommand {
File dummy = new File("src/test/resources/ExecuteCommand/1mb.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 flowFile = flowFiles.get(0);
+ runner.setValidateExpressionUsage(false);
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ MockFlowFile flowFile = flowFiles.getFirst();
assertEquals(0, flowFile.getSize());
-
assertTrue(flowFile.getAttribute("execution.error").contains("ÄÖÜäöüß"));
-
assertTrue(flowFile.getAttribute("execution.error").contains("fffffffffffffffffffffffffffffff"));
+
assertTrue(flowFile.getAttribute("execution.error").matches("^\\W{7}f+$"),
+ "Attribute 'execution.error' did not match regular expression
^\\W{7}f+$. Full value of 'execution.error' attribute is
%s".formatted(flowFile.getAttribute("execution.error")));
}
@Test
@@ -307,31 +304,30 @@ public class TestExecuteStreamCommand {
File dummy = new File("src/test/resources/ExecuteCommand/1mb.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.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.setValidateExpressionUsage(false);
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, 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 flowFile = flowFiles.get(0);
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ MockFlowFile flowFile = flowFiles.getFirst();
assertEquals(0, flowFile.getSize());
-
assertTrue(flowFile.getAttribute("execution.error").contains("ÄÖÜäöüß"));
-
assertTrue(flowFile.getAttribute("execution.error").contains("fffffffffffffffffffffffffffffff"));
+
assertTrue(flowFile.getAttribute("execution.error").matches("^\\W{7}f+$"),
+ "Attribute 'execution.error' did not match regular expression
^\\W{7}f+$. Full value of 'execution.error' attribute is
%s".formatted(flowFile.getAttribute("execution.error")));
}
@Test
@@ -340,16 +336,15 @@ public class TestExecuteStreamCommand {
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.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();
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.getFirst().toByteArray();
String result = new String(byteArray);
final String quotedSeparator = Pattern.quote(File.separator);
@@ -362,28 +357,27 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, 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();
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.getFirst().toByteArray();
String result = new String(byteArray);
final String quotedSeparator = Pattern.quote(File.separator);
@@ -396,17 +390,16 @@ public class TestExecuteStreamCommand {
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.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();
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.getFirst().toByteArray();
String result = new String(byteArray);
assertTrue(Pattern.compile("target:ModifiedResult\r?\n$").matcher(result).find(),
"TestIngestAndUpdate.jar should not have received anything to modify");
}
@@ -417,29 +410,28 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, 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();
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.getFirst().toByteArray();
String result = new String(byteArray);
assertTrue(Pattern.compile("target:ModifiedResult\r?\n$").matcher(result).find(),
"TestIngestAndUpdate.jar should not have received anything to modify");
}
@@ -450,18 +442,17 @@ public class TestExecuteStreamCommand {
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.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();
+ runner.setProperty("NIFI_TEST_1", "testvalue1");
+ runner.setProperty("NIFI_TEST_2", "testvalue2");
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.getFirst().toByteArray();
String result = new String(byteArray);
Set<String> dynamicEnvironmentVariables = new
HashSet<>(Arrays.asList(result.split("\r?\n")));
assertFalse(dynamicEnvironmentVariables.size() < 2, "Should contain at
least two environment variables starting with NIFI");
@@ -475,30 +466,29 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.setProperty("NIFI_TEST_1", "testvalue1");
+ runner.setProperty("NIFI_TEST_2", "testvalue2");
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, 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();
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ byte[] byteArray = flowFiles.getFirst().toByteArray();
String result = new String(byteArray);
Set<String> dynamicEnvironmentVariables = new
HashSet<>(Arrays.asList(result.split("\r?\n")));
assertFalse(dynamicEnvironmentVariables.size() < 2, "Should contain at
least two environment variables starting with NIFI");
@@ -510,27 +500,26 @@ public class TestExecuteStreamCommand {
public void testSmallEchoPutToAttribute() {
File dummy = new File("src/test/resources/hello.txt");
assertTrue(dummy.exists());
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.setProperty(ExecuteStreamCommand.MIME_TYPE,
"application/json");
- controller.enqueue("".getBytes());
+ runner.setProperty(ExecuteStreamCommand.MIME_TYPE, "application/json");
+ runner.enqueue("".getBytes());
if (isWindows()) {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"/c;echo Hello");
- controller.setProperty(ExecuteStreamCommand.ARG_DELIMITER, ";");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"/c;echo Hello");
+ runner.setProperty(ExecuteStreamCommand.ARG_DELIMITER, ";");
} else {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"echo");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"Hello");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "echo");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"Hello");
}
- controller.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
outputFlowFile.assertContentEquals("");
outputFlowFile.assertAttributeNotExists(CoreAttributes.MIME_TYPE.key());
String ouput =
outputFlowFile.getAttribute("executeStreamCommand.output");
@@ -543,43 +532,42 @@ public class TestExecuteStreamCommand {
public void testSmallEchoPutToAttributeDynamicProperties() {
File dummy = new File("src/test/resources/hello.txt");
assertTrue(dummy.exists());
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue("".getBytes());
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue("".getBytes());
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
if (isWindows()) {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "/c");
+ runner.setProperty(dynamicProp1, "/c");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, "echo Hello");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"/c;echo Hello");
+ runner.setProperty(dynamicProp2, "echo Hello");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"/c;echo Hello");
} else {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"echo");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "echo");
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "Hello");
+ runner.setProperty(dynamicProp1, "Hello");
}
- controller.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
outputFlowFile.assertContentEquals("");
String ouput =
outputFlowFile.getAttribute("executeStreamCommand.output");
assertTrue(ouput.startsWith("Hello"));
@@ -587,51 +575,51 @@ public class TestExecuteStreamCommand {
assertEquals(isWindows() ? "cmd.exe" : "echo",
outputFlowFile.getAttribute("execution.command"));
}
+ @DisabledOnOs(value = OS.WINDOWS, disabledReason = "Not reaching expected
relationships")
@Test
public void testArgumentsWithQuotesFromAttributeDynamicProperties() throws
Exception {
File dummy = new File("src/test/resources/TestJson/json-sample.json");
assertTrue(dummy.exists());
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
Map<String, String> attrs = new HashMap<>();
String json = FileUtils.readFileToString(dummy,
StandardCharsets.UTF_8);
- attrs.put("json.attribute", json);
- controller.enqueue("".getBytes(), attrs);
+ attrs.put("json.attribute", JsonUtil.getExpectedContent(json));
+ runner.enqueue("".getBytes(), attrs);
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
if (isWindows()) {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "/c");
+ runner.setProperty(dynamicProp1, "/c");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, "echo");
+ runner.setProperty(dynamicProp2, "echo");
} else {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"echo");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "echo");
}
PropertyDescriptor dynamicProp3 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.3")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp3, "${json.attribute}");
- controller.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.setProperty(dynamicProp3, "${json.attribute}");
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
1);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
String output = new String(outputFlowFile.toByteArray());
ObjectMapper mapper = new ObjectMapper();
JsonNode tree1 = mapper.readTree(json);
@@ -647,17 +635,16 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"-jar;" + jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
-
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
String result =
outputFlowFile.getAttribute("executeStreamCommand.output");
outputFlowFile.assertContentEquals(dummy);
assertTrue(Pattern.compile("Test was a
success\r?\n").matcher(result).find());
@@ -675,29 +662,28 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
-
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
String result =
outputFlowFile.getAttribute("executeStreamCommand.output");
outputFlowFile.assertContentEquals(dummy);
assertTrue(Pattern.compile("Test was a
success\r?\n").matcher(result).find());
@@ -714,20 +700,19 @@ public class TestExecuteStreamCommand {
File exJar = new
File("src/test/resources/ExecuteCommand/TestSuccess.jar");
String jarPath = exJar.getAbsolutePath();
exJar.setExecutable(true);
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue("small test".getBytes());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"-jar;" + jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_ATTRIBUTE_MAX_LENGTH,
"10");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"outputDest");
- assertEquals(1,
controller.getProcessContext().getAvailableRelationships().size());
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
-
controller.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP,
0);
-
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ runner.enqueue("small test".getBytes());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_ATTRIBUTE_MAX_LENGTH,
"10");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"outputDest");
+ assertEquals(1,
runner.getProcessContext().getAvailableRelationships().size());
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+
runner.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP, 0);
+
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
outputFlowFile.assertContentEquals("small test".getBytes());
String result = outputFlowFile.getAttribute("outputDest");
assertTrue(Pattern.compile("Test was a").matcher(result).find());
@@ -744,32 +729,31 @@ public class TestExecuteStreamCommand {
File exJar = new
File("src/test/resources/ExecuteCommand/TestSuccess.jar");
String jarPath = exJar.getAbsolutePath();
exJar.setExecutable(true);
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue("small test".getBytes());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue("small test".getBytes());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_ATTRIBUTE_MAX_LENGTH,
"10");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"outputDest");
- assertEquals(1,
controller.getProcessContext().getAvailableRelationships().size());
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
-
controller.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP,
0);
-
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_ATTRIBUTE_MAX_LENGTH,
"10");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"outputDest");
+ assertEquals(1,
runner.getProcessContext().getAvailableRelationships().size());
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+
runner.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP, 0);
+
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
outputFlowFile.assertContentEquals("small test".getBytes());
String result = outputFlowFile.getAttribute("outputDest");
assertTrue(Pattern.compile("Test was a").matcher(result).find());
@@ -794,16 +778,15 @@ public class TestExecuteStreamCommand {
}
String jarPath = exJar.getAbsolutePath();
exJar.setExecutable(true);
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue(dummy10MBytes.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"-jar;" + jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"outputDest");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- String result = flowFiles.get(0).getAttribute("outputDest");
+ runner.enqueue(dummy10MBytes.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"outputDest");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ String result = flowFiles.getFirst().getAttribute("outputDest");
assertTrue(Pattern.compile("nifi-standard-processors:ModifiedResult\r?\n").matcher(result).find());
}
@@ -821,28 +804,27 @@ public class TestExecuteStreamCommand {
}
String jarPath = exJar.getAbsolutePath();
exJar.setExecutable(true);
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue(dummy10MBytes.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy10MBytes.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"outputDest");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- String result = flowFiles.get(0).getAttribute("outputDest");
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"outputDest");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ String result = flowFiles.getFirst().getAttribute("outputDest");
assertTrue(Pattern.compile("nifi-standard-processors:ModifiedResult\r?\n").matcher(result).find());
}
@@ -858,27 +840,26 @@ public class TestExecuteStreamCommand {
}
}
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue("".getBytes());
+ runner.enqueue("".getBytes());
if (isWindows()) {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"/c;type " + dummy10MBytes.getAbsolutePath());
- controller.setProperty(ExecuteStreamCommand.ARG_DELIMITER, ";");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"/c;type " + dummy10MBytes.getAbsolutePath());
+ runner.setProperty(ExecuteStreamCommand.ARG_DELIMITER, ";");
} else {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cat");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
dummy10MBytes.getAbsolutePath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "cat");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
dummy10MBytes.getAbsolutePath());
}
- controller.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.setProperty(ExecuteStreamCommand.PUT_ATTRIBUTE_MAX_LENGTH,
"256");
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.setProperty(ExecuteStreamCommand.PUT_ATTRIBUTE_MAX_LENGTH,
"256");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- flowFiles.get(0).assertAttributeEquals("execution.status", "0");
- String result =
flowFiles.get(0).getAttribute("executeStreamCommand.output");
+ flowFiles.getFirst().assertAttributeEquals("execution.status", "0");
+ String result =
flowFiles.getFirst().getAttribute("executeStreamCommand.output");
assertTrue(Pattern.compile("a{256}").matcher(result).matches());
}
@@ -893,43 +874,42 @@ public class TestExecuteStreamCommand {
}
}
- final TestRunner controller =
TestRunners.newTestRunner(ExecuteStreamCommand.class);
- controller.enqueue("".getBytes());
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue("".getBytes());
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
if (isWindows()) {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cmd.exe");
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "/c");
+ runner.setProperty(dynamicProp1, "/c");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, "type " +
dummy10MBytes.getAbsolutePath());
+ runner.setProperty(dynamicProp2, "type " +
dummy10MBytes.getAbsolutePath());
} else {
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND,
"cat");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "cat");
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1,
dummy10MBytes.getAbsolutePath());
+ runner.setProperty(dynamicProp1, dummy10MBytes.getAbsolutePath());
}
- controller.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.setProperty(ExecuteStreamCommand.PUT_ATTRIBUTE_MAX_LENGTH,
"256");
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.setProperty(ExecuteStreamCommand.PUT_ATTRIBUTE_MAX_LENGTH,
"256");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- flowFiles.get(0).assertAttributeEquals("execution.status", "0");
- String result =
flowFiles.get(0).getAttribute("executeStreamCommand.output");
+ flowFiles.getFirst().assertAttributeEquals("execution.status", "0");
+ String result =
flowFiles.getFirst().getAttribute("executeStreamCommand.output");
assertTrue(Pattern.compile("a{256}").matcher(result).matches());
}
@@ -939,16 +919,15 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"streamOutput");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"-jar;" + jarPath);
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- String result = flowFiles.get(0).getAttribute("streamOutput");
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"streamOutput");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ String result = flowFiles.getFirst().getAttribute("streamOutput");
final String quotedSeparator = Pattern.quote(File.separator);
assertTrue(Pattern.compile(quotedSeparator +
"nifi-standard-processors" + quotedSeparator +
"target:ModifiedResult\r?\n").matcher(result).find());
@@ -960,28 +939,27 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"streamOutput");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"streamOutput");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- String result = flowFiles.get(0).getAttribute("streamOutput");
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ String result = flowFiles.getFirst().getAttribute("streamOutput");
final String quotedSeparator = Pattern.quote(File.separator);
assertTrue(Pattern.compile(quotedSeparator +
"nifi-standard-processors" + quotedSeparator +
"target:ModifiedResult\r?\n").matcher(result).find());
@@ -993,17 +971,16 @@ public class TestExecuteStreamCommand {
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.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.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- String result =
flowFiles.get(0).getAttribute("executeStreamCommand.output");
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ String result =
flowFiles.getFirst().getAttribute("executeStreamCommand.output");
assertTrue(Pattern.compile("target:ModifiedResult\r?\n?").matcher(result).find(),
"TestIngestAndUpdate.jar should not have received anything to
modify");
}
@@ -1014,29 +991,28 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- String result =
flowFiles.get(0).getAttribute("executeStreamCommand.output");
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.setProperty(ExecuteStreamCommand.IGNORE_STDIN, "true");
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ String result =
flowFiles.getFirst().getAttribute("executeStreamCommand.output");
assertTrue(Pattern.compile("target:ModifiedResult\r?\n?").matcher(result).find(),
"TestIngestAndUpdate.jar should not have received anything to
modify");
}
@@ -1047,18 +1023,17 @@ public class TestExecuteStreamCommand {
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.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.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- String result =
flowFiles.get(0).getAttribute("executeStreamCommand.output");
+ runner.setProperty("NIFI_TEST_1", "testvalue1");
+ runner.setProperty("NIFI_TEST_2", "testvalue2");
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ String result =
flowFiles.getFirst().getAttribute("executeStreamCommand.output");
Set<String> dynamicEnvironmentVariables = new
HashSet<>(Arrays.asList(result.split("\r?\n")));
assertFalse(dynamicEnvironmentVariables.size() < 2, "Should contain at
least two environment variables starting with NIFI");
assertTrue(dynamicEnvironmentVariables.contains("NIFI_TEST_1=testvalue1"),
"NIFI_TEST_1 environment variable is missing");
@@ -1071,30 +1046,29 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.setProperty("NIFI_TEST_1", "testvalue1");
+ runner.setProperty("NIFI_TEST_2", "testvalue2");
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.WORKING_DIR, "target");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- String result =
flowFiles.get(0).getAttribute("executeStreamCommand.output");
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.run(1);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ String result =
flowFiles.getFirst().getAttribute("executeStreamCommand.output");
Set<String> dynamicEnvironmentVariables = new
HashSet<>(Arrays.asList(result.split("\r?\n")));
assertFalse(dynamicEnvironmentVariables.size() < 2, "Should contain at
least two environment variables starting with NIFI");
assertTrue(dynamicEnvironmentVariables.contains("NIFI_TEST_1=testvalue1"),
"NIFI_TEST_1 environment variable is missing");
@@ -1102,7 +1076,7 @@ public class TestExecuteStreamCommand {
}
@Test
- public void testQuotedArguments() throws Exception {
+ public void testQuotedArguments() {
List<String> args = ArgumentUtils.splitArgs("echo -n \"arg1 arg2
arg3\"", ' ');
assertEquals(3, args.size());
args = ArgumentUtils.splitArgs("echo;-n;\"arg1 arg2 arg3\"", ';');
@@ -1110,14 +1084,13 @@ public class TestExecuteStreamCommand {
}
@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();
+ public void testInvalidDelimiter() {
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "echo");
+ runner.assertValid();
+ runner.setProperty(ExecuteStreamCommand.ARG_DELIMITER, "foo");
+ runner.assertNotValid();
+ runner.setProperty(ExecuteStreamCommand.ARG_DELIMITER, "f");
+ runner.assertValid();
}
@Test
@@ -1126,18 +1099,17 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS,
"-jar;" + jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
-
controller.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP,
0);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_ARGUMENTS, "-jar;" +
jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.run(1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+
runner.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP, 0);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
String result =
outputFlowFile.getAttribute("executeStreamCommand.output");
outputFlowFile.assertContentEquals(dummy);
assertTrue(result.isEmpty()); // java -jar with bad path only prints
to standard error not standard out
@@ -1155,30 +1127,29 @@ public class TestExecuteStreamCommand {
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.enqueue(dummy.toPath());
- controller.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
- controller.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
+ runner.enqueue(dummy.toPath());
+ runner.setProperty(ExecuteStreamCommand.EXECUTION_COMMAND, "java");
+ runner.setProperty(ExecuteStreamCommand.ARGUMENTS_STRATEGY,
ExecuteStreamCommand.DYNAMIC_PROPERTY_ARGUMENTS_STRATEGY.getValue());
PropertyDescriptor dynamicProp1 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.1")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp1, "-jar");
+ runner.setProperty(dynamicProp1, "-jar");
PropertyDescriptor dynamicProp2 = new PropertyDescriptor.Builder()
.dynamic(true)
.name("command.argument.2")
.expressionLanguageSupported(ExpressionLanguageScope.FLOWFILE_ATTRIBUTES)
.build();
- controller.setProperty(dynamicProp2, jarPath);
- controller.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
- controller.run(1);
-
controller.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP,
0);
-
controller.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP,
0);
-
controller.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP, 1);
-
- List<MockFlowFile> flowFiles =
controller.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
- MockFlowFile outputFlowFile = flowFiles.get(0);
+ runner.setProperty(dynamicProp2, jarPath);
+ runner.setProperty(ExecuteStreamCommand.PUT_OUTPUT_IN_ATTRIBUTE,
"executeStreamCommand.output");
+ runner.run(1);
+
runner.assertTransferCount(ExecuteStreamCommand.OUTPUT_STREAM_RELATIONSHIP, 0);
+
runner.assertTransferCount(ExecuteStreamCommand.NONZERO_STATUS_RELATIONSHIP, 0);
+ runner.assertTransferCount(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP,
1);
+
+ List<MockFlowFile> flowFiles =
runner.getFlowFilesForRelationship(ExecuteStreamCommand.ORIGINAL_RELATIONSHIP);
+ MockFlowFile outputFlowFile = flowFiles.getFirst();
String result =
outputFlowFile.getAttribute("executeStreamCommand.output");
outputFlowFile.assertContentEquals(dummy);
assertTrue(result.isEmpty()); // java -jar with bad path only prints
to standard error not standard out
