protected override void BuildDataList()
{
BuildShapeAndTestData();
var PrivateKeyFile = scenarioContext.Get <string>(CommonSteps.SourcePrivatePublicKeyFile);
var DestinationPrivateKeyFile = scenarioContext.Get <string>(CommonSteps.DestinationPrivateKeyFile);
var move = new DsfPathMove
{
InputPath = scenarioContext.Get <string>(CommonSteps.SourceHolder),
Username = scenarioContext.Get <string>(CommonSteps.SourceUsernameHolder),
Password = scenarioContext.Get <string>(CommonSteps.SourcePasswordHolder),
OutputPath = scenarioContext.Get <string>(CommonSteps.DestinationHolder),
DestinationUsername = scenarioContext.Get <string>(CommonSteps.DestinationUsernameHolder),
DestinationPassword = scenarioContext.Get <string>(CommonSteps.DestinationPasswordHolder),
Overwrite = scenarioContext.Get <bool>(CommonSteps.OverwriteHolder),
Result = scenarioContext.Get <string>(CommonSteps.ResultVariableHolder),
PrivateKeyFile = scenarioContext.Get <string>(CommonSteps.SourcePrivatePublicKeyFile),
DestinationPrivateKeyFile = scenarioContext.Get <string>(CommonSteps.DestinationPrivateKeyFile)
};
TestStartNode = new FlowStep
{
Action = move
};
if (!scenarioContext.ContainsKey("activity"))
{
scenarioContext.Add("activity", move);
}
}
public void Move_Construct_Object_Must_Be_OfType_IDestinationUsernamePassword()
{
var pathMove = new DsfPathMove();
IDestinationUsernamePassword password = pathMove;
Assert.IsNotNull(password);
}
public void PathMoveActivity_GetInputs_Expected_Six_Input()
{
DsfPathMove testAct = new DsfPathMove();
IBinaryDataList inputs = testAct.GetInputs();
var res = inputs.FetchAllEntries().Count;
// remove test datalist ;)
Assert.AreEqual(8, res);
}
public void DsfPathMove_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfPathMove {
InputPath = 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 PathMoveActivity_GetOutputs_Expected_One_Output()
{
DsfPathMove testAct = new DsfPathMove();
IBinaryDataList outputs = testAct.GetOutputs();
var res = outputs.FetchAllEntries().Count;
// remove test datalist ;)
DataListRemoval(outputs.UID);
Assert.AreEqual(1, res);
}
public void DsfPathMove_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 DsfPathMove {
InputPath = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
};
//------------Execute Test---------------------------
act.UpdateForEachInputs(null);
//------------Assert Results-------------------------
Assert.AreEqual(inputPath, act.InputPath);
Assert.AreEqual(outputPath, act.OutputPath);
}
public void Move_Execute_Workflow_SourceFile_And_DestinationFile_Has_Separate_Passwords_Both_Passwords_Are_Sent_To_OperationBroker()
{
List <string> fileNames = new List <string>
{
Path.Combine(TestContext.TestRunDirectory, "NewFileFolder\\Dev2.txt")
};
List <string> directoryNames = new List <string>();
directoryNames.Add(Path.Combine(TestContext.TestRunDirectory, "NewFileFolder"));
directoryNames.Add(Path.Combine(TestContext.TestRunDirectory, "NewFileFolder2"));
foreach (string directoryName in directoryNames)
{
Directory.CreateDirectory(directoryName);
}
foreach (string fileName in fileNames)
{
File.WriteAllText(fileName, @"TestData");
}
var activityOperationBrokerMock = new ActivityOperationBrokerMock();
DsfPathMove act = new DsfPathMove
{
InputPath = @"c:\OldFile.txt",
OutputPath = Path.Combine(TestContext.TestRunDirectory, "NewName.txt"),
Result = "[[res]]",
DestinationUsername = "******",
DestinationPassword = "******",
Username = "******",
Password = "******",
GetOperationBroker = () => activityOperationBrokerMock
};
List <DebugItem> inRes;
List <DebugItem> outRes;
CheckPathOperationActivityDebugInputOutput(act, ActivityStrings.DebugDataListShape,
ActivityStrings.DebugDataListWithData, out inRes, out outRes);
Assert.AreEqual(activityOperationBrokerMock.Destination.IOPath.Password, "destPWord");
Assert.AreEqual(activityOperationBrokerMock.Destination.IOPath.Username, "destUName");
Assert.AreEqual(activityOperationBrokerMock.Source.IOPath.Password, "pWord");
Assert.AreEqual(activityOperationBrokerMock.Source.IOPath.Username, "uName");
}
public void DsfPathMove_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfPathMove {
InputPath = 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 DsfPathMove_Serialize_ShouldDeserializeCorrectly()
{
//------------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 DsfPathMove {
InputPath = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
};
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var serialized = serializer.Serialize(act);
//------------Execute Test---------------------------
var deSerialized = serializer.Deserialize <DsfPathMove>(serialized);
//------------Assert Results-------------------------
Assert.AreEqual(inputPath, deSerialized.InputPath);
Assert.AreEqual(outputPath, deSerialized.OutputPath);
}
public void DsfPathMove_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 DsfPathMove {
InputPath = 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 DsfPathMove_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfPathMove {
InputPath = 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 DsfPathMove_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 DsfPathMove {
InputPath = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
};
//------------Execute Test---------------------------
var dsfForEachItems = act.GetForEachInputs();
//------------Assert Results-------------------------
Assert.AreEqual(2, dsfForEachItems.Count);
Assert.AreEqual(inputPath, dsfForEachItems[0].Name);
Assert.AreEqual(inputPath, dsfForEachItems[0].Value);
Assert.AreEqual(outputPath, dsfForEachItems[1].Name);
Assert.AreEqual(outputPath, dsfForEachItems[1].Value);
}
public void GetActivityFieldsOffDsfPathMoveActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfPathMove activity = new DsfPathMove();
activity.InputPath = "[[InputPath]]";
activity.OutputPath = "[[OutputPath]]";
activity.Password = "******";
activity.Username = "******";
activity.DestinationPassword = "******";
activity.DestinationUsername = "******";
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]]", "[[OutputPath]]", "[[DestUsername]]", "[[DestPassword]]", "[[Password]]", "[[Username]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var move = new DsfPathMove();
move.InputPath = ScenarioContext.Current.Get <string>(CommonSteps.SourceHolder);
move.Username = ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder);
move.Password = ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder);
move.OutputPath = ScenarioContext.Current.Get <string>(CommonSteps.DestinationHolder);
move.DestinationUsername = ScenarioContext.Current.Get <string>(CommonSteps.DestinationUsernameHolder);
move.DestinationPassword = ScenarioContext.Current.Get <string>(CommonSteps.DestinationPasswordHolder);
move.Overwrite = ScenarioContext.Current.Get <bool>(CommonSteps.OverwriteHolder);
move.Result = ScenarioContext.Current.Get <string>(CommonSteps.ResultVariableHolder);
TestStartNode = new FlowStep
{
Action = move
};
ScenarioContext.Current.Add("activity", move);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfPathMove_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfPathMove
{
InputPath = "[[InputPath]]",
OutputPath = "[[OutputPath]]",
Password = "******",
Username = "******",
PrivateKeyFile = "[[KeyFile]]",
DestinationPassword = "******",
DestinationUsername = "******",
DestinationPrivateKeyFile = "[[DestKeyFile]]",
Result = "[[Result]]"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
var actual = strategy.GetActivityFields(activity);
var expected = new List <string> {
"[[InputPath]]", "[[OutputPath]]", "[[DestUsername]]", "[[DestKeyFile]]", "[[DestPassword]]", "[[Password]]", "[[Username]]", "[[KeyFile]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void DsfPathMove_GetState_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
//------------Setup for test--------------------------
var act = new DsfPathMove
{
InputPath = "[[InputPath]]",
Username = "******",
PrivateKeyFile = "abcde",
OutputPath = "[[OutputPath]]",
DestinationUsername = "******",
DestinationPrivateKeyFile = "fghij",
Result = "[[res]]"
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(8, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "InputPath",
Type = StateVariable.StateType.Input,
Value = "[[InputPath]]"
},
new StateVariable
{
Name = "Username",
Type = StateVariable.StateType.Input,
Value = "Bob"
},
new StateVariable
{
Name = "PrivateKeyFile",
Type = StateVariable.StateType.Input,
Value = "abcde"
},
new StateVariable
{
Name = "OutputPath",
Type = StateVariable.StateType.Output,
Value = "[[OutputPath]]"
},
new StateVariable
{
Name = "DestinationUsername",
Type = StateVariable.StateType.Input,
Value = "John"
},
new StateVariable
{
Name = "DestinationPrivateKeyFile",
Type = StateVariable.StateType.Input,
Value = "fghij"
},
new StateVariable
{
Name = nameof(Overwrite),
Type = StateVariable.StateType.Input,
Value = Overwrite.ToString()
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = "[[res]]"
}
};
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);
}
}
