public void CopyFileWithPathsExpectedRecursiveCopy()
{
var innerDir = Guid.NewGuid().ToString();
var tempPath = Path.GetTempPath();
var tempFileName = Path.GetFileName(Path.GetTempFileName());
const string TempData = "some string data";
if (tempFileName != null)
{
var tempFile = Path.Combine(tempPath, innerDir, innerDir, tempFileName);
string directoryName = Path.GetDirectoryName(tempFile);
if (directoryName != null)
{
Directory.CreateDirectory(directoryName);
}
var upperLevelDir = Path.Combine(tempPath, innerDir);
File.WriteAllText(tempFile, TempData);
var dst = Path.Combine(tempPath, Guid.NewGuid().ToString());
var scrEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ActivityIOFactory.CreatePathFromString(upperLevelDir, string.Empty, null, true));
var dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ActivityIOFactory.CreatePathFromString(dst, string.Empty, null, true));
var moveTO = new Dev2CRUDOperationTO(true);
ActivityIOFactory.CreateOperationsBroker().Copy(scrEndPoint, dstEndPoint, moveTO);
var newFilePath = Path.Combine(dst, innerDir, tempFileName);
Assert.IsTrue(File.Exists(newFilePath));
Assert.IsTrue(File.Exists(tempFile));
}
}
public void ActivityIOBroker_Zip_WhenOverwriteSetTrue_ShouldOverwriteFile()
{
//------------Setup for test--------------------------
tempFile = Path.GetTempFileName();
var zipPathName = Path.GetTempPath() + NewFileName + ".zip";
IActivityIOOperationsEndPoint scrEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ActivityIOFactory.CreatePathFromString(tempFile, string.Empty, null, true, ""));
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ActivityIOFactory.CreatePathFromString(zipPathName, string.Empty, null, true, ""));
Dev2ZipOperationTO zipTO = ActivityIOFactory.CreateZipTO(null, null, null, true);
File.WriteAllText(zipPathName, "");
//------------Assert Preconditions-------------------
Assert.IsTrue(zipTO.Overwrite);
Assert.IsTrue(File.Exists(zipPathName));
var readAllBytes = File.ReadAllBytes(zipPathName);
Assert.AreEqual(0, readAllBytes.Length);
//------------Execute Test---------------------------
ActivityIOFactory.CreateOperationsBroker().Zip(scrEndPoint, dstEndPoint, zipTO);
//------------Assert Results-------------------------
Assert.IsTrue(File.Exists(zipPathName));
readAllBytes = File.ReadAllBytes(zipPathName);
Assert.AreNotEqual(0, readAllBytes.Length);
File.Delete(tempFile);
File.Delete(zipPathName);
}
void CreateSourceFileWithSomeDummyData()
{
try
{
Dev2Logger.Log.Debug(string.Format("Source File: {0}", ScenarioContext.Current.Get <string>(ActualSourceHolder)));
var broker = ActivityIOFactory.CreateOperationsBroker();
IActivityIOPath source = ActivityIOFactory.CreatePathFromString(ScenarioContext.Current.Get <string>(ActualSourceHolder),
ScenarioContext.Current.Get <string>(SourceUsernameHolder),
ScenarioContext.Current.Get <string>(SourcePasswordHolder),
true);
var ops = ActivityIOFactory.CreatePutRawOperationTO(WriteType.Overwrite, Guid.NewGuid().ToString());
IActivityIOOperationsEndPoint sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
if (sourceEndPoint.PathIs(sourceEndPoint.IOPath) == enPathType.File)
{
var result = broker.PutRaw(sourceEndPoint, ops);
if (result != "Success")
{
result = broker.PutRaw(sourceEndPoint, ops);
if (result != "Success")
{
Dev2Logger.Log.Debug("Create Source File for file op test error");
}
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Debug("Create Source File for file op test error", e);
}
}
public void PutWithOverwriteTrue_UNCPathValidUser_File_Present_FileInStream()
{
Dev2CRUDOperationTO opTO = new Dev2CRUDOperationTO(true);
string tmp = TestResource.PathOperations_UNC_Path_Secure + Guid.NewGuid() + ".test";
string tmp2 = TestResource.PathOperations_UNC_Path_Secure + Guid.NewGuid() + ".test";
PathIOTestingUtils.CreateAuthedUNCPath(tmp, false, _inDomain);
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(tmp, (_inDomain ? "DEV2\\" : ".\\") + TestResource.PathOperations_Correct_Username, TestResource.PathOperations_Correct_Password);
IActivityIOPath src = ActivityIOFactory.CreatePathFromString(tmp2, (_inDomain ? "DEV2\\" : ".\\") + TestResource.PathOperations_Correct_Username, TestResource.PathOperations_Correct_Password);
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
Stream stream = new MemoryStream(File.ReadAllBytes(_tmpfile1));
var directoryInfo = new FileInfo(src.Path).Directory;
if (directoryInfo != null)
{
int len = FileSystemPro.Put(stream, dst, opTO, directoryInfo.ToString(), new List <string>());
stream.Close();
PathIOTestingUtils.DeleteAuthedUNCPath(tmp);
PathIOTestingUtils.DeleteAuthedUNCPath(tmp2);
Assert.IsTrue(len > 0);
}
else
{
Assert.Fail();
}
}
public void PutWithOverwriteTrue_FileNot_Present_Expect_FileReadAndDataInputToStream()
{
Dev2CRUDOperationTO opTO = new Dev2CRUDOperationTO(true);
string tmp = Path.GetTempFileName();
File.Delete(tmp);
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(tmp, "", "");
IActivityIOPath src = ActivityIOFactory.CreatePathFromString(_tmpfile2, "", "");
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
Stream stream = FileSystemPro.Get(src, new List <string>());
var directoryInfo = new FileInfo(src.Path).Directory;
if (directoryInfo != null)
{
int len = FileSystemPro.Put(stream, dst, opTO, directoryInfo.ToString(), new List <string>());
stream.Close();
File.Delete(tmp);
Assert.IsTrue(len > 0);
}
else
{
Assert.Fail();
}
}
public void CreateOperationEndPointFromIOPath_Expected_IActivityIOOperationsEndPoint_FTPProvider_Type()
{
var path = ActivityIOFactory.CreatePathFromString(ParserStrings.PathOperations_FTP_Path, "", "");
var result = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
Assert.IsTrue(result.GetType() == typeof(Dev2FTPProvider));
}
static void RunCopy()
{
IActivityIOPath source = ActivityIOFactory.CreatePathFromString(ScenarioContext.Current.Get <string>(CommonSteps.ActualSourceHolder),
ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder),
ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
true);
IActivityIOOperationsEndPoint sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
string resourceName = "Dev2.Activities.Specs.Toolbox.FileAndFolder.Unzip.Test.zip";
if (ScenarioContext.Current.ContainsKey("WhenTheUnzipFileToolIsExecutedWithASingleFile"))
{
resourceName = "TestFile.zip";
}
Assembly assembly = Assembly.GetExecutingAssembly();
List <string> filesToCleanup = new List <string>();
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
{
if (stream != null)
{
sourceEndPoint.Put(stream, sourceEndPoint.IOPath, new Dev2CRUDOperationTO(true), null, filesToCleanup);
}
}
filesToCleanup.ForEach(File.Delete);
}
private void BootstrapPersistence(string baseDir)
{
lock (InitLock)
{
if (_debugPath == null)
{
if (baseDir != null)
{
_rootPath = baseDir;
}
if (_rootPath.EndsWith("\\"))
{
_debugPersistPath = _rootPath + SavePath;
}
else
{
_debugPersistPath = _rootPath + "\\" + SavePath;
}
_debugPath = ActivityIOFactory.CreatePathFromString(_debugPersistPath, "", "");
_debugOptsEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(_debugPath);
}
}
}
protected override IList <OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IList <OutputTO> outputs = new List <OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword, update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if (dataObject.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", dataObject.Environment, update);
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", dataObject.Environment, update);
}
}
while (colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
IActivityIOPath ioPath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint endpoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ioPath);
try
{
string result = broker.Get(endpoint);
outputs[0].OutputStrings.Add(result);
}
catch (Exception e)
{
outputs[0].OutputStrings.Add(null);
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
protected static void RemovedFilesCreatedForTesting()
{
// ReSharper disable EmptyGeneralCatchClause
Dev2Logger.Log.Debug("Cleanup");
var broker = ActivityIOFactory.CreateOperationsBroker();
string destLocation;
if (ScenarioContext.Current != null && ScenarioContext.Current.TryGetValue(CommonSteps.ActualDestinationHolder, out destLocation))
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(destLocation,
ScenarioContext.Current.Get <string>(CommonSteps.DestinationUsernameHolder),
ScenarioContext.Current.Get <string>(CommonSteps.DestinationPasswordHolder),
true);
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
try
{
if (dstEndPoint.PathIs(dstEndPoint.IOPath) == enPathType.File)
{
broker.Delete(dstEndPoint);
}
}
catch (Exception)
{
Dev2Logger.Log.Debug("Cleanup Error");
// throw;
}
}
string sourceLocation;
if (ScenarioContext.Current != null && ScenarioContext.Current.TryGetValue(CommonSteps.ActualSourceHolder, out sourceLocation))
{
IActivityIOPath source = ActivityIOFactory.CreatePathFromString(sourceLocation,
ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder),
ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
true);
IActivityIOOperationsEndPoint sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
try
{
if (sourceEndPoint.PathIs(sourceEndPoint.IOPath) == enPathType.File)
{
broker.Delete(sourceEndPoint);
}
}
catch (Exception)
{
Dev2Logger.Log.Debug("Cleanup Error");
//The file may already be deleted
// throw;
}
}
// SOME SILLY CHICKEN BUNDLED TWO DIS-JOIN OPERATIONS IN THIS METHOD.
// THIS CAUSED THE SFTP SERVER TO NEVER SHUTDOWN WHEN THE COMMONSTEPS.ACTUALSOURCEHOLDER KEY WAS NOT PRESENT!
// ;)
}
public void ListDirectory_StarDotStar_With_NoContents_Expected_NoFilesInList()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(_tmpdir3 + "\\*.*", "", "");
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
IList <IActivityIOPath> result = FileSystemPro.ListDirectory(path);
Assert.IsTrue(result.Count == 0);
}
public void DeleteUNCWith_DirPresent_Expected_DeleteSuccesful()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(_uncdir1, "", "");
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path) as Dev2FileSystemProvider;
bool ok = FileSystemPro != null && FileSystemPro.Delete(path);
Assert.IsTrue(ok);
}
public void ListDirectory_StarDotStar_With_Contents_Expected_ListOfDirectoriesAndFiles()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(Path.GetTempPath() + "\\*.*", "", "");
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
IList <IActivityIOPath> result = FileSystemPro.ListDirectory(path);
Assert.IsTrue(result.Count > 0);
}
// ReSharper disable InconsistentNaming
public void CreateOperationEndPointFromIOPath_Expected_IActivityIOOperationsEndPoint_FileSysytemProvider_Type()
// ReSharper restore InconsistentNaming
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(ParserStrings.PathOperations_FileSystem_Path, "", "");
IActivityIOOperationsEndPoint result = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
Assert.IsTrue(result.GetType() == typeof(Dev2FileSystemProvider));
}
public void ListDirectoryWithValidUsername_ValidPath_Expected_List()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(ParserStrings.PathOperations_FTP_Auth + "DontDelete/", ParserStrings.PathOperations_Correct_Username, ParserStrings.PathOperations_Correct_Password);
IActivityIOOperationsEndPoint FTPPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
IList <IActivityIOPath> tmp = FTPPro.ListDirectory(path);
Assert.AreEqual(6, tmp.Count);
}
public void IsFileSystemPathType()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(_tmpfile1, "", "");
IActivityIOOperationsEndPoint fileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
fileSystemPro.Get(path, new List <string>());
Assert.IsTrue(fileSystemPro is Dev2FileSystemProvider);
}
public void ListDirectory_With_Contents_Expected_ListAllFiles()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(_tmpdir1, "", "");
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
IList <IActivityIOPath> result = FileSystemPro.ListDirectory(path);
Assert.IsTrue(result.Count == 2);
}
public void DeleteUNCWith_FilePresent_Expectd_DeleteSucessful()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(_uncfile1, "", "");
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
bool ok = FileSystemPro.Delete(path);
Assert.IsTrue(ok);
}
protected override IList <OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors)
{
IList <OutputTO> outputs = new List <OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(Password));
colItr.AddVariableToIterateOn(passItr);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if (dataObject.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", dataObject.Environment);
AddDebugInputItemUserNamePassword(dataObject.Environment);
}
while (colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
try
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true);
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
string result = broker.Delete(dstEndPoint);
outputs[0].OutputStrings.Add(result);
}
catch (Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, "Failure"));
//outputs[0].OutputStrings.Add(null);
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
public void Create_Should()
{
var tempPath = Path.GetTempPath() + "SomeName.zip";
var scrEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ActivityIOFactory.CreatePathFromString(tempPath, string.Empty, null, true, ""));
var activityOperationsBroker = ActivityIOFactory.CreateOperationsBroker();
var create = activityOperationsBroker.Create(scrEndPoint, new Dev2CRUDOperationTO(false, false), false);
Assert.AreEqual("Success", create);
}
protected override IList <OutputTO> TryExecuteConcreteAction(IDSFDataObject context, out ErrorResultTO error, int update)
{
IsNotCertVerifiable = true;
error = new ErrorResultTO();
IList <OutputTO> outputs = new List <OutputTO>();
using (var colItr = new WarewolfListIterator())
{
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(context.Environment.Eval(InputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(context.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(context.Environment.Eval(DecryptedPassword, update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(context.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
if (context.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", context.Environment, update);
AddDebugInputItem(new DebugItemStaticDataParams(GetReadType().GetDescription(), "Read"));
AddDebugInputItemUserNamePassword(context.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", context.Environment, update);
}
}
while (colItr.HasMoreData())
{
var broker = ActivityIOFactory.CreateOperationsBroker();
var ioPath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
var endPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ioPath);
try
{
ExecuteConcreteAction(outputs, broker, endPoint);
}
catch (Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(null));
error.AddError(e.Message);
break;
}
}
return(outputs);
}
}
protected override IList <OutputTO> TryExecuteConcreteAction(IDSFDataObject context, out ErrorResultTO error, int update)
{
IList <OutputTO> outputs = new List <OutputTO>();
error = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var outputItr = new WarewolfIterator(context.Environment.Eval(OutputPath, update));
colItr.AddVariableToIterateOn(outputItr);
var passItr = new WarewolfIterator(context.Environment.Eval(DecryptedPassword, update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(context.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
if (context.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(OutputPath, "File or Folder", context.Environment, update));
AddDebugInputItem(new DebugItemStaticDataParams(Overwrite.ToString(), "Overwrite"));
AddDebugInputItemUserNamePassword(context.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Destination Private Key File", context.Environment, update);
}
}
while (colItr.HasMoreData())
{
var broker = ActivityIOFactory.CreateOperationsBroker();
var opTo = new Dev2CRUDOperationTO(Overwrite);
try
{
var dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(outputItr),
Username,
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
var dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
var result = broker.Create(dstEndPoint, opTo, true);
outputs.Add(DataListFactory.CreateOutputTO(Result, result));
}
catch (Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, "Failure"));
error.AddError(e.Message);
break;
}
}
return(outputs);
}
public void CreateDirectoryWithOverwriteFalse_Present_Expected_DirectoryNotCreated()
{
Dev2CRUDOperationTO opTO = new Dev2CRUDOperationTO(false);
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(_tmpdir1, "", "");
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
bool ok = FileSystemPro.CreateDirectory(path, opTO);
Assert.IsFalse(ok);
}
public void DeleteUNCValidUserWith_NoDirPresent_DeleteUnsuccesful()
{
string tmp = TestResource.PathOperations_UNC_Path_Secure + Guid.NewGuid() + "_dir";
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(tmp, (_inDomain ? "DEV2\\" : ".\\") + TestResource.PathOperations_Correct_Username, TestResource.PathOperations_Correct_Password);
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
bool ok = FileSystemPro.Delete(path);
Assert.IsFalse(ok);
}
protected void RemovedFilesCreatedForTesting()
{
// ReSharper disable EmptyGeneralCatchClause
var broker = ActivityIOFactory.CreateOperationsBroker();
string destLocation;
if (scenarioContext != null && scenarioContext.TryGetValue(CommonSteps.ActualDestinationHolder, out destLocation))
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(destLocation,
scenarioContext.Get <string>(CommonSteps.DestinationUsernameHolder),
scenarioContext.Get <string>(CommonSteps.DestinationPasswordHolder),
true);
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
try
{
if (dstEndPoint.PathIs(dstEndPoint.IOPath) == enPathType.File)
{
broker.Delete(dstEndPoint);
}
}
catch (Exception)
{
// throw;
}
}
string sourceLocation;
if (scenarioContext != null && scenarioContext.TryGetValue(CommonSteps.ActualSourceHolder, out sourceLocation))
{
if (string.IsNullOrEmpty(sourceLocation))
{
scenarioContext.TryGetValue(CommonSteps.SourceHolder, out sourceLocation);
}
if (string.IsNullOrEmpty(sourceLocation))
{
return;
}
IActivityIOPath source = ActivityIOFactory.CreatePathFromString(sourceLocation,
scenarioContext.Get <string>(CommonSteps.SourceUsernameHolder),
scenarioContext.Get <string>(CommonSteps.SourcePasswordHolder),
true);
IActivityIOOperationsEndPoint sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
try
{
broker.Delete(sourceEndPoint);
}
catch (Exception)
{
//The file may already be deleted
}
}
}
public void DeleteUNCWith_NoFilePresent_DeleteUnsucessful()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(_uncfile1 + "abc", "", "");
File.Delete(_tmpfile1);
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
bool ok = FileSystemPro.Delete(path);
Assert.IsFalse(ok);
}
public void DeleteUNCWith_NoDirPresent_Expected_DeleteUnsuccessful()
{
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(_uncdir1, "", "");
Directory.Delete(_uncdir1, true);
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
bool ok = FileSystemPro.Delete(path);
Assert.IsFalse(ok);
}
// ReSharper disable InconsistentNaming
public void ActivityIOFactory_CreateOperationEndPointFromIOPath_WithSftp_ShouldSetTypeTpSFtp()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
const string Path = "sftp://sftp.theunlimited.co.za/text.txt";
//------------Execute Test---------------------------
IActivityIOOperationsEndPoint scrEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ActivityIOFactory.CreatePathFromString(Path, string.Empty, null, true));
//------------Assert Results-------------------------
Assert.AreEqual(enActivityIOPathType.SFTP, scrEndPoint.IOPath.PathType);
}
protected static void RemovedFilesCreatedForTesting()
{
// ReSharper disable EmptyGeneralCatchClause
Dev2Logger.Log.Debug("Cleanup");
var broker = ActivityIOFactory.CreateOperationsBroker();
string destLocation;
if (ScenarioContext.Current != null && ScenarioContext.Current.TryGetValue(CommonSteps.ActualDestinationHolder, out destLocation))
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(destLocation,
ScenarioContext.Current.Get <string>(CommonSteps.DestinationUsernameHolder),
ScenarioContext.Current.Get <string>(CommonSteps.DestinationPasswordHolder),
true);
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
try
{
if (dstEndPoint.PathIs(dstEndPoint.IOPath) == enPathType.File)
{
broker.Delete(dstEndPoint);
}
}
catch (Exception)
{
Dev2Logger.Log.Debug("Cleanup Error");
// throw;
}
}
string sourceLocation;
if (ScenarioContext.Current != null && ScenarioContext.Current.TryGetValue(CommonSteps.ActualSourceHolder, out sourceLocation))
{
IActivityIOPath source = ActivityIOFactory.CreatePathFromString(sourceLocation,
ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder),
ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
true);
IActivityIOOperationsEndPoint sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
try
{
if (sourceEndPoint.PathIs(sourceEndPoint.IOPath) == enPathType.File)
{
broker.Delete(sourceEndPoint);
}
}
catch (Exception)
{
Dev2Logger.Log.Debug("Cleanup Error");
//The file may already be deleted
}
}
}
public void DeleteUNCValidUserWith_DirPresent_Expected_DeleteSuccessful()
{
string tmp = TestResource.PathOperations_UNC_Path_Secure + Guid.NewGuid() + "_dir";
PathIOTestingUtils.CreateAuthedUNCPath(tmp, true, _inDomain);
IActivityIOPath path = ActivityIOFactory.CreatePathFromString(tmp, (_inDomain ? "DEV2\\" : ".\\") + TestResource.PathOperations_Correct_Username, TestResource.PathOperations_Correct_Password);
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(path);
bool ok = FileSystemPro.Delete(path);
Assert.IsTrue(ok);
}
