public void Should_Return_False_If_Directory_Does_Not_Exist()
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
context.FileSystem.Returns(fileSystem);
// When
var result = DirectoryAliases.DirectoryExists(context, "non-existent-path");
// Then
Assert.False(result);
}
public void Should_Create_Directory_If_Missing()
{
// Given
var directory = new DirectoryPath("/NonExisting");
var fixture = new FileSystemFixture();
var context = Substitute.For <ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
// When
DirectoryAliases.CleanDirectory(context, directory);
// Then
Assert.True(fixture.FileSystem.Exist((DirectoryPath)"/NonExisting"));
}
public void Should_Delete_Files_In_Provided_Directory()
{
// Given
var directory = new DirectoryPath("/Temp/Hello");
var fixture = new FileSystemFixture();
var context = Substitute.For <ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
// When
DirectoryAliases.CleanDirectory(context, directory);
// Then
Assert.Empty(fixture.FileSystem.GetDirectory(directory).GetFiles("*", SearchScope.Recursive));
}
public void Should_Leave_Provided_Directory_Itself_Intact()
{
// Given
var directory = new DirectoryPath("/Temp/Hello");
var fixture = new FileSystemFixture();
var context = Substitute.For <ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
// When
DirectoryAliases.CleanDirectory(context, directory);
// Then
Assert.True(fixture.FileSystem.GetDirectory(directory).Exists);
}
public void Should_Expand_Existing_Environment_Variables()
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = FakeEnvironment.CreateWindowsEnvironment();
environment.SetEnvironmentVariable("FOO", "bar");
context.Environment.Returns(environment);
// When
var result = DirectoryAliases.ExpandEnvironmentVariables(context, "/%FOO%/baz");
// Then
Assert.Equal("/bar/baz", result.FullPath);
}
public void Should_Return_True_If_Directory_Exist()
{
// Given
var context = Substitute.For <ICakeContext>();
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedDirectory("some path");
context.FileSystem.Returns(fileSystem);
// When
var result = DirectoryAliases.DirectoryExists(context, "some path");
// Then
Assert.True(result);
}
public void Should_Delete_Directories_Respecting_Predicate_In_Provided_Directory()
{
// Given
var fixture = new FileSystemFixture();
var context = Substitute.For <ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
var directory = fixture.FileSystem.GetDirectory("/Temp/Hello");
// When
DirectoryAliases.CleanDirectory(context, directory.Path, info => !info.Hidden);
// Then
Assert.Equal(1, directory.GetDirectories("*", SearchScope.Recursive).Count());
Assert.True(fixture.FileSystem.GetDirectory("/Temp/Hello/Hidden").Exists);
}
public void Should_Skip_Predicate_Folder()
{
// Given
var fixture = new FileSystemFixture();
var context = Substitute.For<ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
var directory = context.FileSystem.GetDirectory("/Temp");
// When
DirectoryAliases.CleanDirectory(context, directory.Path, predicate => predicate.Path.FullPath != "/Temp/Goodbye");
// Then
Assert.True(context.FileSystem.GetDirectory("/Temp").Exists);
Assert.Equal(1, directory.GetDirectories("*", SearchScope.Recursive).Count());
Assert.True(context.FileSystem.GetDirectory("/Temp/Goodbye").Exists);
}
public void Should_Delete_Files_And_Directories_In_Provided_Directory_Using_Relative_Path()
{
// Given
var directory = new DirectoryPath("./Hello");
var fixture = new FileSystemFixture();
var context = Substitute.For<ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
context.Environment.WorkingDirectory.Returns(info => new DirectoryPath("/Temp"));
// When
DirectoryAliases.CleanDirectory(context, directory);
// Then
Assert.Empty(fixture.FileSystem.GetDirectory(directory).GetFiles("*", SearchScope.Recursive));
Assert.Empty(fixture.FileSystem.GetDirectory(directory).GetDirectories("*", SearchScope.Recursive));
}
public void Should_Throw_If_Source_Directory_Does_Not_Exist()
{
// Given
var context = Substitute.For<ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
context.FileSystem.Returns(new FakeFileSystem(environment));
var sourcePath = new DirectoryPath("/Temp");
var destinationPath = new DirectoryPath("/Temp2");
// When
var result = Record.Exception(() =>
DirectoryAliases.CopyDirectory(context, sourcePath, destinationPath));
// Then
Assert.IsType<DirectoryNotFoundException>(result);
Assert.Equal("Source directory does not exist or could not be found: /Temp", result.Message);
}
public void Should_Create_Destination_Folder_If_Not_Exist()
{
// Given
var context = Substitute.For<ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
CreateFileStructure(fileSystem);
context.FileSystem.Returns(fileSystem);
var sourcePath = new DirectoryPath("/Temp");
var destinationPath = new DirectoryPath("/Temp2");
// When
DirectoryAliases.CopyDirectory(context, sourcePath, destinationPath);
// Then
Assert.True(fileSystem.GetDirectory(destinationPath).Exists);
}
public void Should_Create_Non_Existing_Directory()
{
// Given
var fileSystem = Substitute.For<IFileSystem>();
var directory = Substitute.For<IDirectory>();
directory.Exists.Returns(false);
fileSystem.GetDirectory(Arg.Is<DirectoryPath>(p => p.FullPath == "/Temp")).Returns(directory);
var context = Substitute.For<ICakeContext>();
context.FileSystem.Returns(fileSystem);
// When
DirectoryAliases.CreateDirectory(context, "/Temp");
// Then
directory.Received(1).Create();
}
public void Should_Not_Create_Directory_Or_Fail_If_It_Already_Exist ()
{
// Given
var fileSystem = Substitute.For<IFileSystem> ();
var directory = Substitute.For<IDirectory> ();
directory.Exists.Returns (true);
fileSystem.GetDirectory (Arg.Is<DirectoryPath> (p => p.FullPath == "/Temp")).Returns (directory);
var context = Substitute.For<ICakeContext> ();
context.FileSystem.Returns (fileSystem);
// When
DirectoryAliases.EnsureDirectoryExists (context, "/Temp");
// Then
directory.Received (0).Create ();
}
public void Should_Create_Directories_If_Missing()
{
// Given
var fixture = new FileSystemFixture();
var context = Substitute.For<ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
var paths = new[] {
"/Temp/Hello", "/NonExisting"
};
// When
DirectoryAliases.CleanDirectories(context, paths);
// Then
Assert.True(fixture.FileSystem.Exist((DirectoryPath)"/NonExisting"));
}
public void Should_Make_Relative_Path_Absolute ()
{
// Given
var fileSystem = Substitute.For<IFileSystem> ();
var context = Substitute.For<ICakeContext> ();
var environment = Substitute.For<ICakeEnvironment> ();
environment.WorkingDirectory.Returns ("/Temp");
context.FileSystem.Returns (fileSystem);
context.Environment.Returns (environment);
// When
DirectoryAliases.EnsureDirectoryExists (context, "Hello");
// Then
fileSystem.Received (1).GetDirectory (Arg.Is<DirectoryPath> (
p => p.FullPath == "/Temp/Hello"));
}
public void Should_Leave_Provided_Directories_Intact()
{
// Given
var fixture = new FileSystemFixture();
var context = Substitute.For<ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
var paths = new[] {
"/Temp/Hello", "/Temp/Goodbye"
};
// When
DirectoryAliases.CleanDirectories(context, paths);
// Then
Assert.True(fixture.FileSystem.GetDirectory(paths[0]).Exists);
Assert.True(fixture.FileSystem.GetDirectory(paths[1]).Exists);
}
public void Should_Delete_Files_In_Provided_Directories()
{
// Given
var fixture = new FileSystemFixture();
var context = Substitute.For<ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
var paths = new[] {
"/Temp/Hello", "/Temp/Goodbye"
};
// When
Record.Exception(() => DirectoryAliases.CleanDirectories(context, paths));
// Then
Assert.Empty(fixture.FileSystem.GetDirectory(paths[0]).GetFiles("*", SearchScope.Recursive));
Assert.Empty(fixture.FileSystem.GetDirectory(paths[1]).GetFiles("*", SearchScope.Recursive));
}
public void Should_List_All_Directories_In_Directory()
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
CreateFileStructure(fileSystem);
context.FileSystem.Returns(fileSystem);
var directoryPath = new DirectoryPath("/Temp");
// When
var directories = DirectoryAliases.GetSubDirectories(context, directoryPath);
// Then
Assert.Contains(directories, d => d.GetDirectoryName() == "Stuff");
Assert.Contains(directories, d => d.GetDirectoryName() == "Things");
Assert.DoesNotContain(directories, d => d.GetDirectoryName() == "file1.txt");
}
public void Should_Skip_Predicate_Folder()
{
// Given
var directory = new DirectoryPath("/Temp");
var fixture = new FileSystemFixture();
var context = Substitute.For <ICakeContext>();
context.FileSystem.Returns(fixture.FileSystem);
var preHelloFiles = context.FileSystem
.GetDirectory("/Temp/Hello/")
.GetFiles("*.*", SearchScope.Recursive)
.Select(file => file.Path.FullPath)
.ToArray();
var preGoodbyeFiles = context.FileSystem
.GetDirectory("/Temp/Goodbye/")
.GetFiles("*.*", SearchScope.Recursive)
.Select(file => file.Path.FullPath)
.ToArray();
// When
DirectoryAliases.CleanDirectory(context, directory, predicate => predicate.Path.FullPath != "/Temp/Goodbye");
// Then
var postHelloFiles = context.FileSystem
.GetDirectory("/Temp/Hello/")
.GetFiles("*.*", SearchScope.Recursive)
.Select(file => file.Path.FullPath)
.ToArray();
var postGoodbyeFiles = context.FileSystem
.GetDirectory("/Temp/Goodbye/")
.GetFiles("*.*", SearchScope.Recursive)
.Select(file => file.Path.FullPath)
.ToArray();
Assert.DoesNotContain(preHelloFiles, fileName => fixture.FileSystem.Exist((FilePath)fileName));
Assert.Empty(postHelloFiles);
Assert.Equal(preGoodbyeFiles, postGoodbyeFiles);
Assert.All(preGoodbyeFiles, fileName => fixture.FileSystem.Exist((FilePath)fileName));
}
public void Should_Delete_Files_Respecting_Predicate_In_Provided_Directory()
{
// Given
var directory = new DirectoryPath("/Temp/Hello");
var fixture = new FileSystemFixture();
var context = Substitute.For<ICakeContext>();
Func<IFileSystemInfo, bool> wherePredicate = entry => !entry.Hidden;
context.FileSystem.Returns(fixture.FileSystem);
var filesNotMatchingPredicate = fixture
.FileSystem
.GetDirectory(directory)
.GetFiles("*", SearchScope.Recursive)
.Where(entry => !wherePredicate(entry))
.ToArray();
// When
DirectoryAliases.CleanDirectory(context, directory, wherePredicate);
// Then
Assert.Empty(fixture.FileSystem.GetDirectory(directory).GetFiles("*", SearchScope.Recursive).Where(wherePredicate));
Assert.Equal(filesNotMatchingPredicate, fixture.FileSystem.GetDirectory(directory).GetFiles("*", SearchScope.Recursive));
}
public void Should_Recursively_Copy_Files_And_Directory()
{
// Given
var context = Substitute.For<ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
CreateFileStructure(fileSystem);
context.FileSystem.Returns(fileSystem);
var sourcePath = new DirectoryPath("/Temp");
var destinationPath = new DirectoryPath("/Temp2");
// When
DirectoryAliases.CopyDirectory(context, sourcePath, destinationPath);
// Then
// Directories should exist
Assert.True(fileSystem.GetDirectory("/Temp2/Stuff").Exists);
Assert.True(fileSystem.GetDirectory("/Temp2/Things").Exists);
// Files should exist
Assert.True(fileSystem.GetFile("/Temp2/Stuff/file1.txt").Exists);
Assert.True(fileSystem.GetFile("/Temp2/Stuff/file2.txt").Exists);
Assert.True(fileSystem.GetFile("/Temp2/Things/file1.txt").Exists);
}
