public void Remove()
{
if (Keep || !_componentDirectory.Exists)
{
return;
}
try
{
StaticViewModel.AddDebugMessage($"Removing {_componentDirectory.FullName}");
foreach (IFileInfo file in _componentDirectory.EnumerateFiles("*", SearchOption.AllDirectories))
{
if (file.IsReadOnly)
{
file.IsReadOnly = false;
}
}
_componentDirectory.Delete(true);
}
catch (Exception ex)
{
StaticViewModel.AddDebugMessage(ex, $"Unable to delete {_componentDirectory.FullName}");
}
}
private void DeleteFolderWithSubfolders()
{
string folder = string.Format("{0}\\{1}", GetRootFolder(), "folder1");
FileSystemAwareDirectoryInfoProvider dirInfoProvider = new FileSystemAwareDirectoryInfoProvider(new DeviceManager());
DisplayMessage(string.Format("Deleteing {0}", folder));
IDirectoryInfo info1 = dirInfoProvider.GetDirectoryInfo(folder);
info1.Delete();
if (!info1.Exists)
{
DisplayMessage(string.Format("{0} Deleted OK", info1.FullName));
}
else
{
DisplayMessage(string.Format("{0} Failed to delete", info1.FullName), DisplayLevel.Error);
}
IDirectoryInfo info2 = dirInfoProvider.GetDirectoryInfo(GetRootFolder());
info2.Delete();
if (!info2.Exists)
{
DisplayMessage(string.Format("{0} Deleted OK", info2.FullName));
}
else
{
DisplayMessage(string.Format("{0} Failed to delete", info2.FullName), DisplayLevel.Error);
}
}
public void TearDown()
{
if (Environment.GetEnvironmentVariable("EAW_CI_TEST_STEAM_CLIENT") != "YES")
{
return;
}
string?itemIdString = Environment.GetEnvironmentVariable("EAW_CI_STEAM_WORKSHOP_ITEM_ID");
if (itemIdString == null)
{
return;
}
_steamAppIdFile.Delete();
_itemFolder.Delete(true);
_descriptionFile.Delete();
Item item = GetItem(_itemId);
DirectoryInfo directory = new DirectoryInfo(item.Directory);
if (directory.Exists)
{
directory.Delete(true);
}
SteamClient.Shutdown();
}
public void TearDown()
{
_sourceFileInfo.Delete();
_targetFileInfo.Delete();
_directoryInfo.Delete();
Assert.IsFalse(_fileSystem.File.Exists(GetPlatformSourcePath()));
Assert.IsFalse(_fileSystem.File.Exists(GetPlatformTargetPath()));
}
private static void RecursiveDelete(IDirectoryInfo directoryInfo)
{
if (!directoryInfo.Exists)
{
return;
}
directoryInfo.EnumerateDirectories().ForEach(dir => RecursiveDelete(dir));
directoryInfo.Delete(true);
}
public void DeleteTrue()
{
string fileName = "test1";
string fullPath = Path.Combine(this.testFolder.FullName, fileName);
IDirectoryInfo dirInfo = Factory.CreateDirectoryInfo(fullPath);
dirInfo.Create();
Assert.That(dirInfo.Exists, Is.True);
dirInfo.Delete(true);
dirInfo.Refresh();
Assert.That(dirInfo.Exists, Is.False);
}
public static void DeleteIfEmpty(this IDirectoryInfo directoryInfo)
{
if (!directoryInfo.Exists)
{
return;
}
if (!directoryInfo.IsEmpty())
{
return;
}
directoryInfo.Delete(true);
}
/// <summary>
/// remove a folder if there are no files in it, used by the synchroniser
/// </summary>
/// <param name="folder">folder to delete</param>
/// <param name="whatIf">true to emit all the status updates but not actually perform the deletes, false to do the delete</param>
public void RemoveFolderIfEmpty(string folder, bool whatIf)
{
IDirectoryInfo directoryInfo = _directoryInfoProvider.GetDirectoryInfo(folder);
if (!directoryInfo.Exists)
{
return;
}
IDirectoryInfo[] subFolders;
try
{
subFolders = directoryInfo.GetDirectories("*.*");
}
catch (DirectoryNotFoundException)
{
// if the folder is not there then there is nothing to do
return;
}
if (subFolders != null && subFolders.Length > 0)
{
// the folder is not empty - there are subfolders
return;
}
IFileInfo[] files;
try
{
files = directoryInfo.GetFiles("*.*");
}
catch (DirectoryNotFoundException)
{
// if the folder is not there then there is nothing to do
return;
}
if (files != null && files.Length > 0)
{
// the folder is not empty there are files
return;
}
OnStatusUpdate(string.Format(CultureInfo.InvariantCulture, "Removing folder: {0}", directoryInfo.FullName));
if (!whatIf)
{
directoryInfo.Delete();
}
}
private void When_deleting_directory_recursively_it_must_succeed()
{
// Arrange
const string path = @"c:\some\folder";
IFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(path)
.Build();
IDirectoryInfo dirInfo = fileSystem.ConstructDirectoryInfo(path);
// Act
dirInfo.Delete(true);
// Assert
fileSystem.Directory.Exists(path).Should().BeFalse();
}
public void CreateDirectory_MoveTo()
{
//arange
IDirectory directory = new DirectoryWrap(); // should create this somewhere and inject into you method for later mocking
var source = Path.GetRandomFileName();
var target = Path.GetRandomFileName();
//act
IDirectoryInfo info = directory.CreateDirectory(source);
info.MoveTo(target);
//assert
Assert.IsTrue(info.Exists);
// clean
info.Delete();
}
public void Remove_Directory_Does_Not_Exist_Does_Nothing()
{
MockFileSystem fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ @"C:\driver\path1\path2\display\component1\driver.inf", new MockFileData(string.Empty) }
});
IDirectoryInfo rootDir = fileSystem.DirectoryInfo.FromDirectoryName(@"C:\driver");
IDirectoryInfo componentDir = fileSystem.DirectoryInfo.FromDirectoryName(@"C:\driver\path1\path2\display\component1");
DisplayComponentModel displayComponentModel = new DisplayComponentModel(rootDir, componentDir);
componentDir.Delete(true);
displayComponentModel.Keep = false;
displayComponentModel.Remove();
Assert.That(rootDir.Exists, Is.True);
}
private void ScrubOutAllTestData()
{
// note you may want to comment this out to see what the hell is going on
// get rid of any file that we created
FileSystemAwareFileUtilities fileUtils = new FileSystemAwareFileUtilities(new DeviceManager(), new StreamHelper(), new FileSystemAwareFileInfoProvider(new DeviceManager()));
if (fileUtils.FileExists(GetDestinationPath()))
{
fileUtils.FileDelete(GetDestinationPath());
}
// get rid of any folders we created
FileSystemAwareDirectoryInfoProvider dirInfoProvider = new FileSystemAwareDirectoryInfoProvider(new DeviceManager());
IDirectoryInfo info = dirInfoProvider.GetDirectoryInfo(GetRootFolder());
info.Delete();
}
private void DeleteFolderInRoot()
{
string folder = GetRootFolder();
DisplayMessage(string.Format("Deleteing {0}", folder));
FileSystemAwareDirectoryInfoProvider dirInfoProvider = new FileSystemAwareDirectoryInfoProvider(new DeviceManager());
IDirectoryInfo info = dirInfoProvider.GetDirectoryInfo(folder);
info.Delete();
if (!info.Exists)
{
DisplayMessage(string.Format("{0} Deleted OK", info.FullName));
}
else
{
DisplayMessage(string.Format("{0} Failed to delete", info.FullName), DisplayLevel.Error);
}
}
/// <summary>
/// purge a folder, removing any files that were automatically generated first
/// </summary>
/// <param name="folder">folder to delete</param>
public void PurgeFolder(IDirectoryInfo folder)
{
IFileInfo[] files;
try
{
files = folder.GetFiles("*.*");
}
catch (DirectoryNotFoundException)
{
// if the folder is not there then there is nothing to do
return;
}
foreach (IFileInfo file in files)
{
if (_filesThatCanBeAutomaticallyDeleted.Contains(file.Name.ToLower(CultureInfo.InvariantCulture)))
{
_fileUtilities.FileDelete(file.FullName);
}
}
folder.Delete();
}
private void When_changing_directory_existence_it_must_not_refresh_automatically()
{
// Arrange
const string path = @"c:\some\folder";
IFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(path)
.Build();
IDirectoryInfo dirInfo = fileSystem.ConstructDirectoryInfo(path);
bool beforeFound = dirInfo.Exists;
// Act
dirInfo.Delete();
// Assert
bool afterFound = dirInfo.Exists;
beforeFound.Should().BeTrue();
afterFound.Should().BeTrue();
}
private void When_deleting_directory_it_must_update_cache_on_refresh()
{
// Arrange
const string path = @"c:\some\folder";
IFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(path)
.Build();
IDirectoryInfo dirInfo = fileSystem.ConstructDirectoryInfo(path);
bool beforeFound = dirInfo.Exists;
dirInfo.Delete();
// Act
dirInfo.Refresh();
// Assert
bool afterFound = dirInfo.Exists;
beforeFound.Should().BeTrue();
afterFound.Should().BeFalse();
}
public void TearDown()
{
SteamClient.Shutdown();
_steamAppIdFile.Delete();
_itemFolder.Delete(true);
}
public void Delete()
{
_info.Delete();
}
///// <summary>
///// Deletes the subdirectories of the file if they are empty.
///// </summary>
///// <param name="file">
///// The file to check.
///// </param>
//private void DeleteEmptySubdirectories(FileResult file)
//{
// // If no files exist in the directory
// if (file.InputFile.Directory != null && !file.InputFile.Directory.GetFiles().Any()
// && !file.InputFile.Directory.GetDirectories().Any())
// {
// // If this isn't the source directory
// if (
// !file.InputFile.Directory.FullName.TrimEnd(Path.DirectorySeparatorChar).Equals(
// this.settings.SourceDirectory.TrimEnd(Path.DirectorySeparatorChar)))
// {
// file.InputFile.Directory.Delete(true);
// Logger.OnLogMessage(this, "Delete directory: {0}", LogType.Info, file.InputFile.DirectoryName.Truncate());
// }
// }
//}
/// <summary>
/// Deletes the Empty source folder after copy
/// </summary>
/// <param name="directory">Directory to delete</param>
private void DeleteEmptySubdirectories(IDirectoryInfo directory)
{
if(directory != null && !directory.GetFiles().Where(file => this.settings.FileExtensions.Contains(file.Extension)).Any())
{
if (!directory.FullName.ToLower().Equals(this.settings.DefaultDestinationDirectory))
{
directory.Delete(true);
Logger.OnLogMessage(this, "Delete directory: {0}", LogType.Info, directory.FullName.Truncate());
}
}
}
public void Delete() => _info.Delete();
