public void FileWriteActivity_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new FileWriteActivity {
FileContents = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt"), OutputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt"), Result = result
};
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(result, act.Result);
}
public void FileWriteActivity_UniqueIDDifferent_EmptyFileRead_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var fileRead = new FileWriteActivity();
var fileRead1 = new FileWriteActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void FileWriteActivity_UpdateForEachInputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
var inputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt");
var outputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt");
var act = new FileWriteActivity {
FileContents = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
};
//------------Execute Test---------------------------
act.UpdateForEachInputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(inputPath, act.FileContents);
Assert.AreEqual(outputPath, act.OutputPath);
}
public void FileWriteActivity_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new FileWriteActivity {
FileContents = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt"), OutputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt"), Result = result
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(1, dsfForEachItems.Count);
Assert.AreEqual(result, dsfForEachItems[0].Name);
Assert.AreEqual(result, dsfForEachItems[0].Value);
}
public void FileWriteActivity_UpdateForEachOutputs_1Updates_UpdateResult()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
var inputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt");
var outputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt");
var act = new FileWriteActivity {
FileContents = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
};
var tuple1 = new Tuple <string, string>("[[CompanyName]]", "Test");
//------------Execute Test---------------------------
act.UpdateForEachOutputs(new List <Tuple <string, string> > {
tuple1
});
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.Result);
}
public void FileWriteActivity_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new FileWriteActivity {
FileContents = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt"), OutputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt"), Result = result
};
var tuple1 = new Tuple <string, string>("Test", "Test");
var tuple2 = new Tuple <string, string>("Test2", "Test2");
//------------Execute Test---------------------------
act.UpdateForEachOutputs(new List <Tuple <string, string> > {
tuple1, tuple2
});
//------------Assert Results-------------------------
Assert.AreEqual(result, act.Result);
}
public void FileWriteActivity_GetForEachInputs_WhenHasExpression_ReturnsInputList()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
var inputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt");
var outputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt");
var act = new FileWriteActivity {
FileContents = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachInputs();
//------------Assert Results-------------------------
Assert.AreEqual(2, dsfForEachItems.Count);
Assert.AreEqual(outputPath, dsfForEachItems[0].Name);
Assert.AreEqual(outputPath, dsfForEachItems[0].Value);
Assert.AreEqual(inputPath, dsfForEachItems[1].Name);
Assert.AreEqual(inputPath, dsfForEachItems[1].Value);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfFileWriteWithBase64_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new FileWriteActivity
{
FileContents = "[[FileContents]]",
OutputPath = "[[OutputPath]]",
Password = "******",
PrivateKeyFile = "[[KeyFile]]",
Username = "******",
Result = "[[Result]]"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
var actual = strategy.GetActivityFields(activity);
var expected = new List <string> {
"[[FileContents]]", "[[OutputPath]]", "[[Password]]", "[[Username]]", "[[KeyFile]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void FileWriteActivity_FileContents_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new FileWriteActivity()
{
UniqueID = uniqueId, FileContents = "A"
};
var fileRead1 = new FileWriteActivity()
{
UniqueID = uniqueId, FileContents = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void FileWriteActivity_Password_Same_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new FileWriteActivity()
{
UniqueID = uniqueId, Password = "******"
};
var fileRead1 = new FileWriteActivity()
{
UniqueID = uniqueId, Password = "******"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void FileWriteActivity_PrivateKeyFile_Different_Object_Is_Not_Equal_CaseSensitive()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new FileWriteActivity()
{
UniqueID = uniqueId, PrivateKeyFile = "AAA"
};
var fileRead1 = new FileWriteActivity()
{
UniqueID = uniqueId, PrivateKeyFile = "aaa"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void FileWriteActivity_UniqueIDEquals_EmptyFileRead_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new FileWriteActivity()
{
UniqueID = uniqueId
};
var DsfFileWrite = new FileWriteActivity()
{
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(DsfFileWrite);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void FileWriteActivity_AppendBottom_Same_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var rabbitMqActivity = new FileWriteActivity()
{
UniqueID = uniqueId, Result = "A"
};
var rabbitMqActivity1 = new FileWriteActivity()
{
UniqueID = uniqueId, Result = "A"
};
//---------------Assert Precondition----------------
Assert.IsTrue(rabbitMqActivity.Equals(rabbitMqActivity1));
//---------------Execute Test ----------------------
rabbitMqActivity.AppendBottom = true;
rabbitMqActivity1.AppendBottom = true;
var @equals = rabbitMqActivity.Equals(rabbitMqActivity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void FileWriteActivity_Overwrite_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var rabbitMqActivity = new FileWriteActivity()
{
UniqueID = uniqueId, Result = "A",
};
var rabbitMqActivity1 = new FileWriteActivity()
{
UniqueID = uniqueId, Result = "A"
};
//---------------Assert Precondition----------------
Assert.IsTrue(rabbitMqActivity.Equals(rabbitMqActivity1));
//---------------Execute Test ----------------------
rabbitMqActivity.Overwrite = true;
rabbitMqActivity1.Overwrite = false;
var @equals = rabbitMqActivity.Equals(rabbitMqActivity1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void FileWriteActivity_IsContentBase64_Same_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var sut_one = new FileWriteActivity()
{
UniqueID = uniqueId, Result = "A"
};
var sut_two = new FileWriteActivity()
{
UniqueID = uniqueId, Result = "A"
};
//---------------Assert Precondition----------------
Assert.IsTrue(sut_one.Equals(sut_two));
//---------------Execute Test ----------------------
sut_one.FileContentsAsBase64 = true;
sut_two.FileContentsAsBase64 = true;
var @equals = sut_one.Equals(sut_two);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void ActivityParser_ParseToLinkedFlatList()
{
var topLevelActivity = new DsfDotNetMultiAssignActivity
{
DisplayName = "Assign (1)",
UniqueID = "d006a409-333a-49d3-8e1c-7c908f6ba461",
};
var suspendExecutionActivityOne = new SuspendExecutionActivity
{
DisplayName = "Suspend Execution",
UniqueID = "66b7c885-9ea4-4d75-b822-13ff5ef28128",
};
topLevelActivity.NextNodes = new List <IDev2Activity> {
suspendExecutionActivityOne
};
var dev2DecisionStackOne = new Dev2DecisionStack {
DisplayText = "If [[a]] Is = 2"
};
var flowDecisionActivityOne = new DsfDecision
{
DisplayName = "If [[a]] Is = 2",
UniqueID = "1764efe9-4e0e-423a-8510-b35dc9b053f4",
NextNodes = null,
Conditions = dev2DecisionStackOne
};
var fileWriteActivityOne = new FileWriteActivity
{
DisplayName = "Write File",
UniqueID = "8e35adbf-d0c4-443b-ab04-2a83ca1aaa62",
};
flowDecisionActivityOne.TrueArm = new [] { fileWriteActivityOne };
var flowDecisionActivityOneFalseArmAssign = new DsfDotNetMultiAssignActivity
{
DisplayName = "Assign (1)",
UniqueID = "23b599b7-49f4-40a8-8304-f034d227d3dd",
};
var flowDecisionActivityOneFalseArmFileWrite = new FileWriteActivity
{
DisplayName = "Write File",
UniqueID = "baad2ce3-371b-4fec-81f4-0da4112078c8",
};
flowDecisionActivityOneFalseArmAssign.NextNodes = new List <IDev2Activity> {
flowDecisionActivityOneFalseArmFileWrite
};
flowDecisionActivityOneFalseArmFileWrite.NextNodes = new List <IDev2Activity> {
suspendExecutionActivityOne
};
flowDecisionActivityOne.FalseArm = new [] { flowDecisionActivityOneFalseArmAssign };
suspendExecutionActivityOne.NextNodes = new List <IDev2Activity> {
flowDecisionActivityOne
};
var suspendExecutionActivityTwo = new SuspendExecutionActivity
{
DisplayName = "Suspend Execution",
UniqueID = "f72ab5fe-efc9-46c5-8944-f2032f0613eb",
};
fileWriteActivityOne.NextNodes = new List <IDev2Activity> {
suspendExecutionActivityTwo
};
var dev2DecisionStackTwo = new Dev2DecisionStack {
DisplayText = "If [[a]] Is = 4"
};
var flowDecisionActivityTwo = new DsfDecision
{
DisplayName = "If [[a]] Is = 4",
UniqueID = "9ad7861e-6fe8-449f-8640-92147259f919",
NextNodes = null,
Conditions = dev2DecisionStackTwo
};
var fileWriteActivityTwo = new FileWriteActivity
{
DisplayName = "Write File",
UniqueID = "88deb70e-ad45-4735-8a87-a77f7eb54d83",
};
var flowDecisionActivityTwoFalseArmAssign = new DsfDotNetMultiAssignActivity
{
DisplayName = "Assign (1)",
UniqueID = "c511b3e4-819f-4c38-81f6-6579ae3f52df",
};
var flowDecisionActivityTwoFalseArmFileWrite = new FileWriteActivity
{
DisplayName = "Write File",
UniqueID = "3c477009-7b12-432f-908c-b0ad613e8c57",
};
flowDecisionActivityTwoFalseArmAssign.NextNodes = new List <IDev2Activity> {
flowDecisionActivityTwoFalseArmFileWrite
};
flowDecisionActivityTwoFalseArmFileWrite.NextNodes = new List <IDev2Activity> {
suspendExecutionActivityTwo
};
flowDecisionActivityTwo.NextNodes = null;
flowDecisionActivityTwo.TrueArm = new [] { fileWriteActivityTwo };
flowDecisionActivityTwo.FalseArm = new [] { flowDecisionActivityTwoFalseArmAssign };
suspendExecutionActivityTwo.NextNodes = new List <IDev2Activity> {
flowDecisionActivityTwo
};
var activityParser = new ActivityParser();
var activities = activityParser.ParseToLinkedFlatList(topLevelActivity);
Assert.IsNotNull(activities);
var dev2Activities = activities.ToList();
Assert.AreEqual(13, dev2Activities.Count);
}
public void FileWriteActivity_GetState_ReturnsStateVariable()
{
var act = new FileWriteActivity {
OutputPath = "Path",
Overwrite = true,
AppendTop = true,
AppendBottom = true,
FileContentsAsBase64 = true,
FileContents = "some file contents",
Username = "******",
Password = "******",
PrivateKeyFile = "/path/to/secret",
Result = "[[result]]"
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(9, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "OutputPath",
Value = "Path",
Type = StateVariable.StateType.Output
},
new StateVariable
{
Name = "Overwrite",
Value = "True",
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "AppendTop",
Value = "True",
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "AppendBottom",
Value = "True",
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "FileContents",
Value = "some file contents",
Type = StateVariable.StateType.InputOutput
},
new StateVariable
{
Name = "FileContentsAsBase64",
Value = "True",
Type = StateVariable.StateType.InputOutput
},
new StateVariable
{
Name = "Username",
Value = "myuser",
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "PrivateKeyFile",
Value = "/path/to/secret",
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "Result",
Value = "[[result]]",
Type = StateVariable.StateType.Output
}
};
var iter = act.GetState().Select(
(item, index) => new
{
value = item,
expectValue = expectedResults[index]
}
);
//------------Assert Results-------------------------
foreach (var entry in iter)
{
Assert.AreEqual(entry.expectValue.Name, entry.value.Name);
Assert.AreEqual(entry.expectValue.Type, entry.value.Type);
Assert.AreEqual(entry.expectValue.Value, entry.value.Value);
}
}
