protected override void BuildDataList()
{
BuildShapeAndTestData();
scenarioContext.TryGetValue(CommonSteps.SourcePrivatePublicKeyFile, out string privateKeyFile);
var fileRead = new DsfFileRead
{
InputPath = scenarioContext.Get <string>(CommonSteps.SourceHolder),
Username = scenarioContext.Get <string>(CommonSteps.SourceUsernameHolder).ResolveDomain(),
Password = scenarioContext.Get <string>(CommonSteps.SourcePasswordHolder),
Result = scenarioContext.Get <string>(CommonSteps.ResultVariableHolder),
PrivateKeyFile = privateKeyFile
};
TestStartNode = new FlowStep
{
Action = fileRead
};
scenarioContext.Add("activity", fileRead);
var viewModel = new ReadFileDesignerViewModel(ModelItemUtils.CreateModelItem(fileRead));
if (!scenarioContext.ContainsKey("viewModel"))
{
scenarioContext.Add("viewModel", viewModel);
}
}
public void FileReadActivity_GetOutputs_Expected_One_Output()
{
DsfFileRead testAct = new DsfFileRead();
IBinaryDataList outputs = testAct.GetOutputs();
// remove test datalist ;)
Assert.AreEqual(1, outputs.FetchAllEntries().Count);
}
// ReSharper disable InconsistentNaming
public void FileReadActivity_GetInputs_Expected_Four_Input()
// ReSharper restore InconsistentNaming
{
DsfFileRead testAct = new DsfFileRead();
IBinaryDataList inputs = testAct.GetInputs();
// remove test datalist ;)
Assert.AreEqual(4, inputs.FetchAllEntries().Count);
}
public void DsfFileRead_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfFileRead {
InputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt"), Result = result
};
act.UpdateForEachOutputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(result, act.Result);
}
public void DsfFileRead_UpdateForEachInputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
var inputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt");
var act = new DsfFileRead {
InputPath = inputPath, Result = "[[CompanyName]]"
};
//------------Execute Test---------------------------
act.UpdateForEachInputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(inputPath, act.InputPath);
}
public void UniqueIDDifferent_EmptyFileRead_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileRead();
var fileRead1 = new DsfFileRead();
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void DsfFileReadActivity_GetState_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
var inputPath = "/Path";
var result = "[result]";
//------------Setup for test--------------------------
var activity = new DsfFileRead {
InputPath = inputPath, Result = result
};
//------------Execute Test---------------------------
var stateItems = activity.GetState();
Assert.AreEqual(2, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "InputPath",
Type = StateVariable.StateType.Input,
Value = inputPath
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = result
}
};
var iter = activity.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);
}
}
public void DsfFileRead_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfFileRead {
InputPath = 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 GetActivityFieldsOffDsfFileReadActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfFileRead activity = new DsfFileRead();
activity.InputPath = "[[InputPath]]";
activity.Password = "******";
activity.Username = "******";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List <string> actual = strategy.GetActivityFields(activity);
List <string> expected = new List <string> {
"[[InputPath]]", "[[Password]]", "[[Username]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void DsfFileRead_UpdateForEachInputs_1Update_Updates()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
var inputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt");
var act = new DsfFileRead {
InputPath = inputPath, Result = "[[CompanyName]]"
};
var tuple1 = new Tuple <string, string>(inputPath, "Test");
//------------Execute Test---------------------------
act.UpdateForEachInputs(new List <Tuple <string, string> > {
tuple1
});
//------------Assert Results-------------------------
Assert.AreEqual("Test", act.InputPath);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfFileRead_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfFileRead
{
InputPath = "[[InputPath]]",
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> {
"[[InputPath]]", "[[Password]]", "[[Username]]", "[[KeyFile]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void UniqueIDEquals_EmptyFileRead_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileRead {
UniqueID = uniqueId
};
var dsfFileRead = new DsfFileRead {
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(dsfFileRead);
//---------------Test Result -----------------------
Assert.IsTrue(equals);
}
public void DsfFileRead_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfFileRead {
InputPath = 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 Equals_Given_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileRead {
UniqueID = uniqueId, DisplayName = "A"
};
var fileRead1 = new DsfFileRead {
UniqueID = uniqueId, DisplayName = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void Password_Different_Object_Is_Not_Equal_CaseSensitive()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileRead {
UniqueID = uniqueId, Password = "******"
};
var fileRead1 = new DsfFileRead {
UniqueID = uniqueId, Password = "******"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void Password_Same_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileRead {
UniqueID = uniqueId, Password = "******"
};
var fileRead1 = new DsfFileRead {
UniqueID = uniqueId, Password = "******"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsTrue(equals);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var fileRead = new DsfFileRead
{
InputPath = ScenarioContext.Current.Get <string>(CommonSteps.SourceHolder),
Username = ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder).ResolveDomain(),
Password = ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
Result = ScenarioContext.Current.Get <string>(CommonSteps.ResultVariableHolder)
};
TestStartNode = new FlowStep
{
Action = fileRead
};
ScenarioContext.Current.Add("activity", fileRead);
}
public void IsNotCertVerifiable_Same_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var rabbitMqActivity = new DsfFileRead {
UniqueID = uniqueId, Result = "A"
};
var rabbitMqActivity1 = new DsfFileRead {
UniqueID = uniqueId, Result = "A"
};
//---------------Assert Precondition----------------
Assert.IsTrue(rabbitMqActivity.Equals(rabbitMqActivity1));
//---------------Execute Test ----------------------
rabbitMqActivity.IsNotCertVerifiable = true;
rabbitMqActivity1.IsNotCertVerifiable = true;
var @equals = rabbitMqActivity.Equals(rabbitMqActivity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
