public void FileWriteActivity_GetOutputs_Expected_One_Output()
{
DsfFileWrite testAct = new DsfFileWrite();
IBinaryDataList outputs = testAct.GetOutputs();
// remove test datalist ;)
Assert.AreEqual(1, outputs.FetchAllEntries().Count);
}
public void DsfFileWrite_UpdateForEachOutputs_NullUpdates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfFileWrite { 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);
}
// ReSharper disable InconsistentNaming
public void FileWriteActivity_GetInputs_Expected_Seven_Input()
// ReSharper restore InconsistentNaming
{
DsfFileWrite testAct = new DsfFileWrite();
IBinaryDataList inputs = testAct.GetInputs();
// remove test datalist ;)
Assert.AreEqual(9, inputs.FetchAllEntries().Count);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var readtype = _scenarioContext.Get <string>("method");
var overwrite = false;
var appendTop = false;
var appendBottom = false;
switch (readtype)
{
case "Overwrite":
overwrite = true;
break;
case "Append Top":
appendTop = true;
break;
case "Append Bottom":
appendBottom = true;
break;
default:
break;
}
var fileWrite = new DsfFileWrite
{
Username = _scenarioContext.Get <string>(CommonSteps.SourceUsernameHolder),
Password = _scenarioContext.Get <string>(CommonSteps.SourcePasswordHolder),
Result = _scenarioContext.Get <string>(CommonSteps.ResultVariableHolder),
OutputPath = _scenarioContext.Get <string>(CommonSteps.SourceHolder),
Overwrite = overwrite,
AppendTop = appendTop,
AppendBottom = appendBottom,
FileContents = _scenarioContext.Get <string>("content"),
PrivateKeyFile = _scenarioContext.Get <string>(CommonSteps.SourcePrivatePublicKeyFile)
};
TestStartNode = new FlowStep
{
Action = fileWrite
};
_scenarioContext.Add("activity", fileWrite);
var viewModel = new WriteFileDesignerViewModel(ModelItemUtils.CreateModelItem(fileWrite));
if (!_scenarioContext.ContainsKey("viewModel"))
{
_scenarioContext.Add("viewModel", viewModel);
}
}
public void DsfFileWrite_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfFileWrite { 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 DsfFileWrite_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 DsfFileWrite { 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 DsfFileWrite_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 DsfFileWrite { 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 DsfFileWrite_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
{
//------------Setup for test--------------------------
var newGuid = Guid.NewGuid();
const string result = "[[CompanyName]]";
var act = new DsfFileWrite { 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 DsfFileWrite_UniqueIDDifferent_EmptyFileRead_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileWrite();
var fileRead1 = new DsfFileWrite();
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void DsfFileWrite_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 DsfFileWrite { 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 GetActivityFieldsOffDsfFileWriteActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfFileWrite activity = new DsfFileWrite();
activity.FileContents = "[[FileContents]]";
activity.OutputPath = "[[OutputPath]]";
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> {
"[[FileContents]]", "[[OutputPath]]", "[[Password]]", "[[Username]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var readtype = ScenarioContext.Current.Get <string>("method");
var overwrite = false;
var appendTop = false;
var appendBottom = false;
switch (readtype)
{
case "Overwrite":
overwrite = true;
break;
case "Append Top":
appendTop = true;
break;
case "Append Bottom":
appendBottom = true;
break;
}
var fileWrite = new DsfFileWrite
{
Username = ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder),
Password = ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
Result = ScenarioContext.Current.Get <string>(CommonSteps.ResultVariableHolder),
OutputPath = ScenarioContext.Current.Get <string>(CommonSteps.SourceHolder),
Overwrite = overwrite,
AppendTop = appendTop,
AppendBottom = appendBottom,
FileContents = ScenarioContext.Current.Get <string>("content"),
PrivateKeyFile = ScenarioContext.Current.Get <string>(CommonSteps.SourcePrivatePublicKeyFile)
};
TestStartNode = new FlowStep
{
Action = fileWrite
};
ScenarioContext.Current.Add("activity", fileWrite);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfFileWrite__Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfFileWrite
{
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 DsfFileWrite_FileContents_Same_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileWrite()
{
UniqueID = uniqueId, FileContents = "a"
};
var fileRead1 = new DsfFileWrite()
{
UniqueID = uniqueId, FileContents = "a"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void DsfFileWrite_Password_Different_Object_Is_Not_Equal_CaseSensitive()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileWrite()
{
UniqueID = uniqueId, Password = "******"
};
var fileRead1 = new DsfFileWrite()
{
UniqueID = uniqueId, Password = "******"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void DsfFileWrite_UniqueIDEquals_EmptyFileRead_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileWrite()
{
UniqueID = uniqueId
};
var DsfFileWrite = new DsfFileWrite()
{
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(DsfFileWrite);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void DsfFileWrite_Equals_Given_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var fileRead = new DsfFileWrite()
{
UniqueID = uniqueId, DisplayName = "A"
};
var fileRead1 = new DsfFileWrite()
{
UniqueID = uniqueId, DisplayName = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(fileRead);
//---------------Execute Test ----------------------
var @equals = fileRead.Equals(fileRead1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void DsfFileWrite_AppendBottom_Same_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var rabbitMqActivity = new DsfFileWrite()
{
UniqueID = uniqueId, Result = "A"
};
var rabbitMqActivity1 = new DsfFileWrite()
{
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 DsfFileWrite_Overwrite_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var rabbitMqActivity = new DsfFileWrite()
{
UniqueID = uniqueId, Result = "A",
};
var rabbitMqActivity1 = new DsfFileWrite()
{
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 DsfFileWrite_GetState_ReturnsStateVariable()
{
var act = new DsfFileWrite {
OutputPath = "Path",
Overwrite = true,
AppendTop = true,
AppendBottom = true,
FileContents = "some file contents",
Username = "******",
Password = "******",
PrivateKeyFile = "/path/to/secret",
Result = "[[result]]"
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(8, 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 = "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);
}
}
