public NuGetFixture(FilePath toolPath = null, bool defaultToolExist = true)
{
Environment = Substitute.For <ICakeEnvironment>();
Environment.WorkingDirectory.Returns("/Working");
Globber = Substitute.For <IGlobber>();
Globber.Match("./tools/**/NuGet.exe").Returns(new[] { (FilePath)"/Working/tools/NuGet.exe" });
Process = Substitute.For <IProcess>();
Process.GetExitCode().Returns(0);
ProcessRunner = Substitute.For <IProcessRunner>();
ProcessRunner.Start(Arg.Any <ProcessStartInfo>()).Returns(Process);
Log = Substitute.For <ICakeLog>();
FileSystem = new FakeFileSystem(true);
FileSystem.GetCreatedFile("/Working/existing.nuspec", Resources.Nuspec_NoMetadataValues);
if (defaultToolExist)
{
FileSystem.GetCreatedFile("/Working/tools/NuGet.exe");
}
if (toolPath != null)
{
FileSystem.GetCreatedFile(toolPath);
}
}
public XmlTransformationFixture(bool xmlExists = true, bool xslExists = true, bool resultExist = false)
{
Settings = new XmlTransformationSettings();
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedDirectory("/Working");
if (xmlExists)
{
var xmlFile = fileSystem.GetCreatedFile("/Working/breakfast_menu.xml", Resources.XmlTransformation_Xml);
XmlPath = xmlFile.Path;
}
if (xslExists)
{
var xslFile = fileSystem.GetCreatedFile("/Working/breakfast_menu.xsl", Resources.XmlTransformation_Xsl);
XslPath = xslFile.Path;
}
if (resultExist)
{
var resultFile = fileSystem.GetCreatedFile("/Working/breakfast_menu.htm", Resources.XmlTransformation_Htm);
ResultPath = resultFile.Path;
}
else
{
ResultPath = "/Working/breakfast_menu.htm";
}
FileSystem = fileSystem;
}
private static FakeFileSystem CreateFileSystem(bool isUnix)
{
var fileSystem = new FakeFileSystem(isUnix);
fileSystem.GetCreatedDirectory("/Temp");
fileSystem.GetCreatedDirectory("/Temp/HasDirectories");
fileSystem.GetCreatedDirectory("/Temp/HasDirectories/A");
fileSystem.GetCreatedDirectory("/Temp/HasFiles");
fileSystem.GetCreatedDirectory("/Temp/Hello");
fileSystem.GetCreatedDirectory("/Temp/Hello/Empty");
fileSystem.GetCreatedDirectory("/Temp/Hello/More/Empty");
fileSystem.GetCreatedDirectory("/Temp/Hello/World");
fileSystem.GetCreatedDirectory("/Temp/Goodbye");
fileSystem.GetCreatedFile("/Presentation.ppt");
fileSystem.GetCreatedFile("/Budget.xlsx");
fileSystem.GetCreatedFile("/Text.txt");
fileSystem.GetCreatedFile("/Temp");
fileSystem.GetCreatedFile("/Temp/Hello/Document.txt");
fileSystem.GetCreatedFile("/Temp/Hello/World/Text.txt");
fileSystem.GetCreatedFile("/Temp/Hello/World/Picture.png");
fileSystem.GetCreatedFile("/Temp/Goodbye/OtherText.txt");
fileSystem.GetCreatedFile("/Temp/Goodbye/OtherPicture.png");
fileSystem.GetCreatedFile("/Temp/HasFiles/A.txt");
return(fileSystem);
}
public XmlDocExampleCodeParserFixture()
{
XmlFilePath = "/Working/Cake.Common.xml";
Pattern = "/Working/Cake.*.xml";
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedFile(XmlFilePath.FullPath, Resources.XmlDoc_ExampeCode_Cake_Common_Xml);
fileSystem.GetCreatedFile("/Working/Cake.UnCommon.xml", Resources.XmlDoc_ExampeCode_Cake_Common_Xml);
FileSystem = fileSystem;
Globber = Substitute.For <IGlobber>();
Globber.GetFiles(Pattern).Returns(new FilePath[] { "/Working/Cake.Common.xml", "/Working/Cake.UnCommon.xml" });
}
public ScriptRunnerFixture(string fileName = "./build.cake")
{
Source = "Hello World";
Options = new CakeOptions();
Options.Verbosity = Verbosity.Diagnostic;
Options.Script = fileName;
Environment = Substitute.For <ICakeEnvironment>();
Environment.WorkingDirectory.Returns("/Working");
FileSystem = new FakeFileSystem(true);
FileSystem.GetCreatedFile(Options.Script.MakeAbsolute(Environment), Source);
Session = Substitute.For <IScriptSession>();
SessionFactory = Substitute.For <IScriptSessionFactory>();
SessionFactory.CreateSession(Arg.Any <IScriptHost>()).Returns(Session);
Arguments = new CakeArguments();
AliasGenerator = Substitute.For <IScriptAliasGenerator>();
Host = Substitute.For <IScriptHost>();
Log = Substitute.For <ICakeLog>();
ScriptProcessor = new ScriptProcessor(FileSystem, Environment, Log);
}
public void Should_Transform_Text_From_Disc_Template_Using_Specified_Placeholders()
{
// Given
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedFile("/Working/template.txt", "Hello {subject}");
var environment = Substitute.For <ICakeEnvironment>();
environment.WorkingDirectory.Returns("/Working");
var context = Substitute.For <ICakeContext>();
context.FileSystem.Returns(fileSystem);
context.Environment.Returns(environment);
var transform = TextTransformationAliases.TransformTextFile(context, "./template.txt", "{", "}");
transform.WithToken("subject", "World");
// When
var result = transform.ToString();
// Then
Assert.Equal("Hello World", result);
}
public ScriptRunnerFixture(string fileName = "./build.cake")
{
Script = fileName;
Source = "Hello World";
ArgumentDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
Environment = Substitute.For <ICakeEnvironment>();
Environment.WorkingDirectory.Returns("/Working");
FileSystem = new FakeFileSystem(true);
FileSystem.GetCreatedFile(Script.MakeAbsolute(Environment), Source);
Globber = Substitute.For <IGlobber>();
Session = Substitute.For <IScriptSession>();
SessionFactory = Substitute.For <IScriptSessionFactory>();
SessionFactory.CreateSession(Arg.Any <IScriptHost>(), ArgumentDictionary).Returns(Session);
Arguments = Substitute.For <ICakeArguments>();
AliasGenerator = Substitute.For <IScriptAliasGenerator>();
Log = Substitute.For <ICakeLog>();
NuGetToolResolver = new NuGetToolResolver(FileSystem, Globber, Environment);
ScriptProcessor = new ScriptProcessor(FileSystem, Environment, Log, NuGetToolResolver);
var context = Substitute.For <ICakeContext>();
context.Arguments.Returns(c => Arguments);
context.Environment.Returns(c => Environment);
context.FileSystem.Returns(c => FileSystem);
Host = Substitute.For <IScriptHost>();
Host.Context.Returns(context);
}
public void Should_Read_File_With_Single_Line_Correctly()
{
// Given
var fileSystem = new FakeFileSystem(true);
var file = fileSystem.GetCreatedFile("text.txt", "Hello World");
// When
var result = file.ReadLines(Encoding.UTF8).ToList();
// Then
Assert.Equal(1, result.Count);
}
public void Should_Return_Empty_List_If_File_Contains_No_Lines()
{
// Given
var fileSystem = new FakeFileSystem(true);
var file = fileSystem.GetCreatedFile("text.txt");
// When
var result = file.ReadLines(Encoding.UTF8).ToList();
// Then
Assert.Equal(0, result.Count);
}
public GlobberFixture(bool isFileSystemCaseSensitive)
{
FileSystem = new FakeFileSystem(isFileSystemCaseSensitive);
FileSystem.GetCreatedDirectory("/Temp");
FileSystem.GetCreatedDirectory("/Temp/Hello");
FileSystem.GetCreatedDirectory("/Temp/Hello/World");
FileSystem.GetCreatedDirectory("/Temp/Goodbye");
FileSystem.GetCreatedFile("/Presentation.ppt");
FileSystem.GetCreatedFile("/Budget.xlsx");
FileSystem.GetCreatedFile("/Text.txt");
FileSystem.GetCreatedFile("/Temp");
FileSystem.GetCreatedFile("/Temp/Hello/World/Text.txt");
FileSystem.GetCreatedFile("/Temp/Hello/World/Picture.png");
FileSystem.GetCreatedFile("/Temp/Goodbye/OtherText.txt");
FileSystem.GetCreatedFile("/Temp/Goodbye/OtherPicture.png");
FileSystem.GetCreatedFile("/Working/Text.txt");
FileSystem.GetCreatedFile("C:/Temp/Hello/World/Text.txt");
Environment = Substitute.For <ICakeEnvironment>();
Environment.IsUnix().Returns(isFileSystemCaseSensitive);
Environment.WorkingDirectory.Returns("/Temp");
}
public void Should_Return_True_If_Directory_Exist()
{
// Given
var context = Substitute.For <ICakeContext>();
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedFile("some file.txt");
context.FileSystem.Returns(fileSystem);
// When
var result = FileAliases.FileExists(context, "some file.txt");
// Then
Assert.True(result);
}
public void Should_Zip_Provided_Files()
{
// Given
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedFile("/Root/file.txt", "HelloWorld");
var environment = Substitute.For <ICakeEnvironment>();
var log = Substitute.For <ICakeLog>();
var zipper = new Zipper(fileSystem, environment, log);
// When
zipper.Zip("/Root", "/file.zip", new FilePath[] { "/Root/file.txt" });
// Then
Assert.True(fileSystem.GetFile("/file.zip").Exists);
}
public void Should_Throw_If_File_Is_Not_Relative_To_Root()
{
// Given
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedFile("/NotRoot/file.txt");
var environment = Substitute.For <ICakeEnvironment>();
var log = Substitute.For <ICakeLog>();
var zipper = new Zipper(fileSystem, environment, log);
// When
var result = Record.Exception(() => zipper.Zip("/Root", "/file.zip", new FilePath[] { "/NotRoot/file.txt" }));
// Then
Assert.IsType <CakeException>(result);
Assert.Equal("File '/NotRoot/file.txt' is not relative to root path '/Root'.", result.Message);
}
public ScriptProcessorFixture(string scriptPath = "./build.cake", bool scriptExist = true,
string scriptSource = "Console.WriteLine();")
{
ScriptPath = new FilePath(scriptPath);
Source = scriptSource;
Environment = Substitute.For <ICakeEnvironment>();
Environment.WorkingDirectory.Returns("/Working");
Log = Substitute.For <ICakeLog>();
FileSystem = new FakeFileSystem(true);
if (scriptExist)
{
FileSystem.GetCreatedFile(ScriptPath.MakeAbsolute(Environment), Source);
}
}
public void Should_Read_Content_Of_File_And_Parse_It()
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = Substitute.For <ICakeEnvironment>();
environment.WorkingDirectory = "/Working";
var fileSystem = new FakeFileSystem(true);
fileSystem.GetCreatedFile("/Working/ReleaseNotes.md", "### New in 1.2.3");
context.FileSystem.Returns(fileSystem);
context.Environment.Returns(environment);
// When
var result = context.ParseAllReleaseNotes("ReleaseNotes.md");
// Then
Assert.Equal("1.2.3", result[0].Version.ToString());
}
public void Should_Return_The_Latest_Release_Notes()
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = Substitute.For <ICakeEnvironment>();
environment.WorkingDirectory = "/Working";
var fileSystem = new FakeFileSystem(true);
fileSystem.GetCreatedFile("/Working/ReleaseNotes.md", "* 1.2.3 - Line 1\n* 1.2.5 Line 2\n* 1.2.4 Line 3");
context.FileSystem.Returns(fileSystem);
context.Environment.Returns(environment);
// When
var result = context.ParseReleaseNotes("ReleaseNotes.md");
// Then
Assert.Equal("1.2.5", result.Version.ToString());
}
private MSBuildRunnerFixture(bool is64BitOperativeSystem, bool msBuildFileExist, IEnumerable <DirectoryPath> existingMSBuildPaths)
{
Process = Substitute.For <IProcess>();
ProcessRunner = Substitute.For <IProcessRunner>();
ProcessRunner.Start(Arg.Any <FilePath>(), Arg.Any <ProcessSettings>()).Returns(Process);
Environment = Substitute.For <ICakeEnvironment>();
Environment.Is64BitOperativeSystem().Returns(is64BitOperativeSystem);
Environment.GetSpecialPath(SpecialPath.ProgramFilesX86).Returns("/Program86");
Environment.GetSpecialPath(SpecialPath.Windows).Returns("/Windows");
Environment.WorkingDirectory.Returns("/Working");
Settings = new MSBuildSettings("./src/Solution.sln");
Settings.ToolVersion = MSBuildToolVersion.VS2013;
if (existingMSBuildPaths != null)
{
// Add all existing MSBuild tool paths.
var fileSystem = new FakeFileSystem(true);
FileSystem = fileSystem;
foreach (var existingPath in existingMSBuildPaths)
{
fileSystem.GetCreatedDirectory(existingPath);
fileSystem.GetCreatedFile(existingPath.GetFilePath("MSBuild.exe"));
}
}
else
{
FileSystem = Substitute.For <IFileSystem>();
FileSystem.GetFile(
Arg.Is <FilePath>(p => p.FullPath.EndsWith("MSBuild.exe", System.StringComparison.Ordinal)))
.Returns(c =>
{
// All requested files exist.
var file = Substitute.For <IFile>();
file.Exists.Returns(msBuildFileExist);
file.Path.Returns(c.Arg <FilePath>());
return(file);
});
}
}
public void Should_Read_File_With_Multiple_Lines_Correctly()
{
// Given
var fileSystem = new FakeFileSystem(true);
var content = new StringBuilder();
content.AppendLine("1");
content.AppendLine("2");
content.AppendLine("3");
var file = fileSystem.GetCreatedFile("text.txt", content.ToString());
// When
var result = file.ReadLines(Encoding.UTF8).ToList();
// Then
Assert.Equal(3, result.Count);
Assert.Equal("1", result[0]);
Assert.Equal("2", result[1]);
Assert.Equal("3", result[2]);
}
public void Zipped_File_Should_Contain_Correct_Content()
{
// Given
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedFile("/Root/Stuff/file.txt", "HelloWorld");
var environment = Substitute.For <ICakeEnvironment>();
var log = Substitute.For <ICakeLog>();
var zipper = new Zipper(fileSystem, environment, log);
zipper.Zip("/Root", "/file.zip", new FilePath[] { "/Root/Stuff/file.txt" });
// When
var archive = new ZipArchive(fileSystem.GetFile("/file.zip").Open(FileMode.Open, FileAccess.Read, FileShare.Read));
var entry = archive.GetEntry("Stuff/file.txt");
// Then
Assert.NotNull(entry);
Assert.True(entry.Length == 10);
}
private FakeFileSystem CreateFileStructure(FakeFileSystem ffs)
{
Action <string> dir = path => ffs.GetCreatedDirectory(path);
Action <string> file = path => ffs.GetCreatedFile(path);
dir("C:/Temp");
{
file("C:/Temp/file1.txt");
file("C:/Temp/file2.txt");
dir("C:/Temp/Stuff");
{
file("C:/Temp/Stuff/file1.txt");
file("C:/Temp/Stuff/file2.txt");
}
dir("C:/Temp/Things");
{
file("C:/Temp/Things/file1.txt");
}
}
return(ffs);
}
protected NuGetFixture()
{
Environment = Substitute.For <ICakeEnvironment>();
Environment.WorkingDirectory.Returns("/Working");
Process = Substitute.For <IProcess>();
Process.GetExitCode().Returns(0);
ProcessRunner = Substitute.For <IProcessRunner>();
ProcessRunner.Start(Arg.Any <FilePath>(), Arg.Any <ProcessSettings>()).Returns(Process);
NuGetToolResolver = Substitute.For <IToolResolver>();
NuGetToolResolver.Name.Returns("NuGet");
Log = Substitute.For <ICakeLog>();
FileSystem = new FakeFileSystem(true);
// By default, there is a default tool.
NuGetToolResolver.ResolveToolPath().Returns("/Working/tools/NuGet.exe");
FileSystem.GetCreatedFile("/Working/tools/NuGet.exe");
// Set standard output.
Process.GetStandardOutput().Returns(new string[0]);
}
public void Should_Create_Text_Transformation_From_Disc_Template()
{
// Given
var fileSystem = new FakeFileSystem(false);
fileSystem.GetCreatedFile("/Working/template.txt", "Hello World");
var environment = Substitute.For <ICakeEnvironment>();
environment.WorkingDirectory.Returns("/Working");
var context = Substitute.For <ICakeContext>();
context.FileSystem.Returns(fileSystem);
context.Environment.Returns(environment);
// When
var result = TextTransformationAliases.TransformTextFile(
context, "./template.txt", "{", "}");
// Then
Assert.Equal("Hello World", result.ToString());
}
