public void Zip_Construct_Object_Must_Be_OfType_IDestinationUsernamePassword()
{
var zip = new DsfZip();
IDestinationUsernamePassword password = zip;
Assert.IsNotNull(password);
}
protected override void BuildDataList()
{
try
{
BuildShapeAndTestData();
var zip = new DsfZip
{
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),
ArchivePassword = scenarioContext.Get <string>("archivePassword"),
CompressionRatio = scenarioContext.Get <string>("compressio"),
PrivateKeyFile = scenarioContext.Get <string>(CommonSteps.SourcePrivatePublicKeyFile),
DestinationPrivateKeyFile = scenarioContext.Get <string>(CommonSteps.DestinationPrivateKeyFile)
};
TestStartNode = new FlowStep
{
Action = zip
};
// CI
scenarioContext.Add("activity", zip);
}
catch (Exception)
{
//
}
}
public void Zip_Execute_Workflow_SourceFile_And_DestinationFile_Has_Separate_Passwords_Both_Passwords_Are_Sent_To_OperationBroker()
{
var fileNames = new List <string>();
var randomFileName = Guid.NewGuid();
fileNames.Add(Path.Combine(myTestContext.TestRunDirectory, randomFileName + "Dev2.txt"));
foreach (string fileName in fileNames)
{
File.WriteAllText(fileName, "TestData");
}
var activityOperationBrokerMock = new ActivityOperationBrokerMock();
var preact = new DsfZip
{
InputPath = @"c:\OldFile.txt",
OutputPath = Path.Combine(TestContext.TestRunDirectory, "NewName.txt"),
Result = "[[res]]",
DestinationUsername = "******",
DestinationPassword = "******",
Username = "******",
Password = "******",
GetOperationBroker = () => activityOperationBrokerMock
};
CheckPathOperationActivityDebugInputOutput(preact, ActivityStrings.DebugDataListShape,
ActivityStrings.DebugDataListWithData, out List <DebugItem> inRes, out List <DebugItem> 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");
}
protected override void BuildDataList()
{
try
{
BuildShapeAndTestData();
var zip = new DsfZip
{
InputPath = ScenarioContext.Current.Get <string>(CommonSteps.SourceHolder),
Username = ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder),
Password = ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
OutputPath = ScenarioContext.Current.Get <string>(CommonSteps.DestinationHolder),
DestinationUsername = ScenarioContext.Current.Get <string>(CommonSteps.DestinationUsernameHolder),
DestinationPassword = ScenarioContext.Current.Get <string>(CommonSteps.DestinationPasswordHolder),
Overwrite = ScenarioContext.Current.Get <bool>(CommonSteps.OverwriteHolder),
Result = ScenarioContext.Current.Get <string>(CommonSteps.ResultVariableHolder),
ArchivePassword = ScenarioContext.Current.Get <string>("archivePassword"),
CompressionRatio = ScenarioContext.Current.Get <string>("compressio"),
};
TestStartNode = new FlowStep
{
Action = zip
};
// CI
ScenarioContext.Current.Add("activity", zip);
}
catch (Exception e)
{
Dev2Logger.Log.Debug("Error Setting Up Zip", e);
}
}
public void GetActivityFieldsOffDsfZipActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfZip activity = new DsfZip();
activity.ArchiveName = "[[ArchiveName]]";
activity.ArchivePassword = "******";
activity.CompressionRatio = "[[CompressionRatio]]";
activity.InputPath = "[[InputPath]]";
activity.OutputPath = "[[OutputPath]]";
activity.Password = "******";
activity.Username = "******";
activity.PrivateKeyFile = "[[KeyFile]]";
activity.DestinationPassword = "******";
activity.DestinationUsername = "******";
activity.DestinationPrivateKeyFile = "[[DestKeyFile]]";
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> {
"[[ArchivePassword]]", "[[ArchiveName]]", "[[CompressionRatio]]", "[[InputPath]]", "[[OutputPath]]", "[[DestUsername]]", "[[DestKeyFile]]", "[[DestPassword]]", "[[Password]]", "[[Username]]", "[[KeyFile]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfZip_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfZip
{
ArchiveName = "[[ArchiveName]]",
ArchivePassword = "******",
CompressionRatio = "[[CompressionRatio]]",
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> {
"[[ArchivePassword]]", "[[ArchiveName]]", "[[CompressionRatio]]", "[[InputPath]]", "[[OutputPath]]", "[[DestUsername]]", "[[DestKeyFile]]", "[[DestPassword]]", "[[Password]]", "[[Username]]", "[[KeyFile]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void ZipActivity_GetInputs_Expected_Eight_Input()
{
DsfZip testAct = new DsfZip();
IBinaryDataList inputs = testAct.GetInputs();
Assert.IsTrue(inputs.FetchAllEntries().Count == 11);
}
public void ZipActivity_GetOutputs_Expected_One_Output()
{
DsfZip testAct = new DsfZip();
IBinaryDataList outputs = testAct.GetOutputs();
Assert.IsTrue(outputs.FetchAllEntries().Count == 1);
}
public void Zip_Execute_WhenOutputPathNotIsRooted_MovesArchivePasswordItr()
{
//---------------Setup----------------------------------------------
var fileNames = new List <string>();
var guid = Guid.NewGuid();
fileNames.Add(Path.Combine(TestContext.TestRunDirectory, guid + "Dev2.txt"));
List <DebugItem> inRes;
List <DebugItem> outRes;
foreach (string fileName in fileNames)
{
File.Delete(fileName);
}
var activityOperationBrokerMock = new ActivityOperationBrokerMock();
var act = new DsfZip
{
InputPath = @"c:\OldFile.txt",
OutputPath = "NewName.txt",
Result = "[[res(*).a]]",
DestinationUsername = "******",
DestinationPassword = "******",
Username = "******",
Password = "******",
ArchivePassword = "******",
CompressionRatio = "[[comp(*).val]]",
ArchiveName = "[[arch(*).name]]",
GetOperationBroker = () => activityOperationBrokerMock
};
const string shape = "<ADL><res><a></a></res><pass><word></word></pass><comp><val></val></comp><arch><name></name></arch></ADL>";
const string data = "<ADL><pass><word>test</word></pass><pass><word>test2</word></pass><pass><word>test3</word></pass><comp><val>test</val></comp><comp><val>test2</val></comp><comp><val>test3</val></comp><arch><name>test</name></arch><arch><name>test2</name></arch><arch><name>test3</name></arch></ADL>";
//-------------------------Execute-----------------------------------------------
CheckPathOperationActivityDebugInputOutput(act, shape,
data, out inRes, out outRes);
//-------------------------Assertions---------------------------------------------
Assert.AreEqual(1, outRes.Count);
var outputResultList = outRes[0].FetchResultsList();
Assert.AreEqual(3, outputResultList.Count);
Assert.AreEqual("", outputResultList[0].Value);
Assert.AreEqual("[[res(1).a]]", outputResultList[0].Variable);
Assert.AreEqual("", outputResultList[1].Value);
Assert.AreEqual("[[res(1).a]]", outputResultList[1].Variable);
Assert.AreEqual("", outputResultList[2].Value);
Assert.AreEqual("[[res(1).a]]", outputResultList[2].Variable);
}
public void UniqueIDDifferent_Emptyzip_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var zip = new DsfZip();
var zip1 = new DsfZip();
//---------------Assert Precondition----------------
Assert.IsNotNull(zip);
//---------------Execute Test ----------------------
var @equals = zip.Equals(zip1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void Password_Different_Object_Is_Not_Equal_CaseSensitive()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var zip = new DsfZip()
{
UniqueID = uniqueId, Password = "******"
};
var zip1 = new DsfZip()
{
UniqueID = uniqueId, Password = "******"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(zip);
//---------------Execute Test ----------------------
var @equals = zip.Equals(zip1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void Password_Same_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var zip = new DsfZip()
{
UniqueID = uniqueId, Password = "******"
};
var zip1 = new DsfZip()
{
UniqueID = uniqueId, Password = "******"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(zip);
//---------------Execute Test ----------------------
var @equals = zip.Equals(zip1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void PrivateKeyFile_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var zip = new DsfZip()
{
UniqueID = uniqueId, PrivateKeyFile = "A"
};
var zip1 = new DsfZip()
{
UniqueID = uniqueId, PrivateKeyFile = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(zip);
//---------------Execute Test ----------------------
var @equals = zip.Equals(zip1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void UniqueIDEquals_Emptyzip_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var zip = new DsfZip()
{
UniqueID = uniqueId
};
var DsfZip = new DsfZip()
{
UniqueID = uniqueId
};
//---------------Assert Precondition----------------
Assert.IsNotNull(zip);
//---------------Execute Test ----------------------
var @equals = zip.Equals(DsfZip);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void IsNotCertVerifiable_Same_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var zip = new DsfZip()
{
UniqueID = uniqueId, Result = "A"
};
var zip1 = new DsfZip()
{
UniqueID = uniqueId, Result = "A"
};
//---------------Assert Precondition----------------
Assert.IsTrue(zip.Equals(zip1));
//---------------Execute Test ----------------------
zip.IsNotCertVerifiable = true;
zip1.IsNotCertVerifiable = true;
var @equals = zip.Equals(zip1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void DsfZip_GetState()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var inputPath = @"c:\OldFile.txt";
var username = "******";
var privateKeyFile = "[[KeyFile]]";
var outputPath = @"c:\OldFile_Zip.txt";
var destinationUsername = "******";
var destinationPrivateKeyFile = "[[destinationPrivateKeyFile]]";
var overwrite = false;
var archiveName = "[[archiveName]]";
var compressionRatio = "[[compressionRatio]]";
var result = "[[result]]";
var zip = new DsfZip()
{
UniqueID = uniqueId,
InputPath = inputPath,
Username = username,
PrivateKeyFile = privateKeyFile,
OutputPath = outputPath,
DestinationUsername = destinationUsername,
DestinationPrivateKeyFile = destinationPrivateKeyFile,
Overwrite = overwrite,
ArchiveName = archiveName,
CompressionRatio = compressionRatio,
Result = result
};
//------------Execute Test---------------------------
var stateItems = zip.GetState();
Assert.AreEqual(10, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "InputPath",
Value = inputPath,
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "Username",
Value = username,
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "PrivateKeyFile",
Value = privateKeyFile,
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "OutputPath",
Value = outputPath,
Type = StateVariable.StateType.Output
},
new StateVariable
{
Name = "DestinationUsername",
Value = destinationUsername,
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "DestinationPrivateKeyFile",
Value = destinationPrivateKeyFile,
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "Overwrite",
Value = overwrite.ToString(),
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "ArchiveName",
Value = archiveName,
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "CompressionRatio",
Value = compressionRatio,
Type = StateVariable.StateType.Input
},
new StateVariable
{
Name = "Result",
Value = result,
Type = StateVariable.StateType.Output
}
};
var iter = zip.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);
}
}
