public void Should_Use_The_Script_Directory_As_Root_For_Configuration_File()
{
// Given
var fileSystem = Substitute.For <IFileSystem>();
var environment = FakeEnvironment.CreateUnixEnvironment();
var provider = new CakeConfigurationProvider(fileSystem, environment);
var registry = new ContainerRegistrar();
var options = new CakeOptions {
Script = "./foo/bar/build.cake"
};
var module = new ConfigurationModule(provider, options);
// When
module.Register(registry);
// Then
fileSystem.Received(1).Exist(Arg.Is <FilePath>(f => f.FullPath == "/Working/foo/bar/cake.config"));
}
public void Should_Add_Unknown_Arguments_To_Argument_List_Without_Script()
{
// Given
var environment = FakeEnvironment.CreateUnixEnvironment();
var fakeFileSystem = new FakeFileSystem(environment);
fakeFileSystem.CreateFile(new FilePath("build.cake"));
var fixture = new ArgumentParserFixture {
FileSystem = fakeFileSystem
};
var parser = new ArgumentParser(fixture.Log, fixture.VerbosityParser);
// When
var result = parser.Parse(new[] { "--unknown" });
// Then
Assert.True(result.Arguments.ContainsKey("unknown"));
}
public void Should_Read_Content_Of_File_And_Parse_It()
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile("/Working/ReleaseNotes.md").SetContent("### 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());
Assert.Equal("1.2.3", result[0].SemVersion.ToString());
}
public XmlDocExampleCodeParserFixture()
{
XmlFilePath = "/Working/Cake.Common.xml";
Pattern = "/Working/Cake.*.xml";
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile(XmlFilePath.FullPath).SetContent(Resources.XmlDoc_ExampeCode_Cake_Common_Xml);
fileSystem.CreateFile("/Working/Cake.UnCommon.xml").SetContent(Resources.XmlDoc_ExampeCode_Cake_Common_Xml);
FileSystem = fileSystem;
Globber = Substitute.For <IGlobber>();
Globber.Match(Pattern, Arg.Any <GlobberSettings>()).Returns(
new FilePath[] { "/Working/Cake.Common.xml", "/Working/Cake.UnCommon.xml" });
Log = Substitute.For <ICakeLog>();
}
public void Should_Parse_Ini_With_Sections_Correctly()
{
// Given
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile("/Working/cake.config").SetContent(Resources.Ini_Configuration);
var parser = new ConfigurationParser(fileSystem, environment);
// When
var result = parser.Read("/Working/cake.config");
// Then
Assert.True(result.ContainsKey("Section1_Foo"));
Assert.Equal("Bar", result["Section1_Foo"]);
Assert.True(result.ContainsKey("Section2_Baz"));
Assert.Equal("Qux", result["Section2_Baz"]);
}
public ScriptProcessorFixture()
{
Environment = FakeEnvironment.CreateUnixEnvironment();
FileSystem = new FakeFileSystem(Environment);
Log = Substitute.For <ICakeLog>();
Tools = Substitute.For <IToolLocator>();
Installer = Substitute.For <IPackageInstaller>();
Installer.CanInstall(Arg.Any <PackageReference>(), Arg.Any <PackageType>()).Returns(true);
InstallPath = new DirectoryPath("/Working/Bin");
// Create the script analyzer result.
var script = new ScriptInformation("/Working/build.cake");
script.Addins.Add(new PackageReference("custom:?package=addin"));
script.Tools.Add(new PackageReference("custom:?package=tool"));
Result = new ScriptAnalyzerResult(script, new List <string>());
}
public ScriptProcessorFixture()
{
Environment = FakeEnvironment.CreateUnixEnvironment();
FileSystem = new FakeFileSystem(Environment);
Log = Substitute.For <ICakeLog>();
ToolLocator = Substitute.For <IToolLocator>();
Installer = Substitute.For <IPackageInstaller>();
Installer.CanInstall(Arg.Any <PackageReference>(), Arg.Any <PackageType>()).Returns(true);
InstallPath = new DirectoryPath("/Working/Bin");
Addins = new List <PackageReference> {
new PackageReference("custom:?package=addin")
};
Tools = new List <PackageReference> {
new PackageReference("custom:?package=tool")
};
}
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_Return_Empty_If_Package_Directory_Does_Not_Exist()
{
// Given
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
var log = Substitute.For <ICakeLog>();
var assemblyCompatibilityFilter = Substitute.For <INuGetAssemblyCompatibilityFilter>();
var locator = new NuGetPackageAssembliesLocator(fileSystem, log, assemblyCompatibilityFilter, environment);
var addinDirectory = DirectoryPath.FromString("/NonExistentDir");
// When
var result = locator.FindAssemblies(addinDirectory);
// Then
Assert.Empty(result);
}
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_Return_The_Latest_Release_Notes()
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile("/Working/ReleaseNotes.md").SetContent("* 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());
Assert.Equal("1.2.5", result.SemVersion.ToString());
}
public NUnit3XmlReaderFixture()
{
NUnit2ResultPath = "/Working/nunit2results.xml";
NUnit3ResultPath = "/Working/nunit3results.xml";
NUnit3ResultDuplicateNamePath = "/Working/nunit3duplicateresults.xml";
NonExistantPath = "/Working/nonexistantpath.xml";
var environment = FakeEnvironment.CreateUnixEnvironment();
Environment = environment;
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile(NUnit2ResultPath.FullPath).SetContent(Resources.XmlTestResults_NUnit2);
fileSystem.CreateFile(NUnit3ResultPath.FullPath).SetContent(Resources.XmlTestResults_NUnit3);
fileSystem.CreateFile(NUnit3ResultDuplicateNamePath.FullPath).SetContent(Resources.XmlTestResults_NUnit3_DuplicateTestName);
FileSystem = fileSystem;
}
public ProjectParserFixture()
{
ProjFilePath = "/Working/Cake.Sample.csproj";
Pattern = "/Working/Cake.*.csproj";
var environment = FakeEnvironment.CreateUnixEnvironment();
Environment = environment;
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile(ProjFilePath.FullPath).SetContent(Resources.Csproj_ProjectFile);
fileSystem.CreateFile("/Working/Cake.Incomplete.csproj").SetContent(Resources.Csproj_IncompleteFile);
FileSystem = fileSystem;
Globber = Substitute.For <IGlobber>();
Globber.GetFiles(Pattern).Returns(new FilePath[] { "/Working/Cake.Sample.csproj", "/Working/Cake.Incomplete.csproj" });
Log = Substitute.For <ICakeLog>();
}
public NuGetPackageInstallerFixture()
{
Environment = FakeEnvironment.CreateUnixEnvironment();
FileSystem = new FakeFileSystem(Environment);
ContentResolver = Substitute.For <INuGetContentResolver>();
Log = Substitute.For <ICakeLog>();
Config = Substitute.For <ICakeConfiguration>();
ToolResolver = Substitute.For <INuGetToolResolver>();
ToolResolver.ResolvePath().Returns(new FilePath("/Working/tools/nuget.exe"));
Package = new PackageReference("nuget:https://myget.org/temp/?package=Cake.Foo&prerelease&version=1.2.3");
PackageType = PackageType.Addin;
InstallPath = new DirectoryPath("./nuget");
ProcessRunner = Substitute.For <IProcessRunner>();
ProcessRunner.When(p => p.Start(Arg.Any <FilePath>(), Arg.Any <ProcessSettings>()))
.Do(info => FileSystem.CreateDirectory(InstallPath.Combine(Package.Package.ToLowerInvariant()).Combine(Package.Package)));
}
public void Should_Return_True_If_Absolute_Path_Exist()
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
environment.WorkingDirectory = "/Working/target";
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile("/Working/target/some file.txt");
context.FileSystem.Returns(fileSystem);
context.Environment.Returns(environment);
// When
var result = FileAliases.FileExists(context, "/Working/target/some file.txt");
// Then
Assert.True(result);
}
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_Return_Size_If_Path_Exist(string workingDirectory, string filePath)
{
// Given
var context = Substitute.For <ICakeContext>();
var environment = FakeEnvironment.CreateUnixEnvironment();
environment.WorkingDirectory = workingDirectory;
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile(filePath, new byte[] { 1, 2, 3, 4 });
context.FileSystem.Returns(fileSystem);
context.Environment.Returns(environment);
// When
var result = FileAliases.FileSize(context, filePath);
// Then
Assert.Equal(result, 4);
}
public CsvHelpersFixture(bool csvFileExists = true, bool peopleExists = true)
{
Settings = new CsvHelperSettings();
ClassMap = new PersonMap();
DictionaryMap = new Dictionary <string, string>()
{
{ "Id", "EmployeeId" }, { "Name", "GivenName" }
};
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateDirectory("/Working");
if (csvFileExists)
{
var content = Resources.CsvHelper_CsvFile;
var csvFile = fileSystem.CreateFile("/Working/people.csv").SetContent(content);
CsvFilePath = csvFile.Path;
}
ResultPath = "/Working/people.csv";
if (peopleExists)
{
People = new List <Person> {
new Person {
Id = 1, Name = "Jane"
},
new Person {
Id = 2, Name = "Mal"
}
};
}
FileSystem = fileSystem;
Context = Substitute.For <ICakeContext>();
Context.FileSystem.Returns(FileSystem);
Context.Environment.Returns(environment);
}
public void Should_Throw_If_Package_Directory_Is_Not_Absolute()
{
// Given
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
var log = Substitute.For <ICakeLog>();
var assemblyCompatibilityFilter = Substitute.For <INuGetAssemblyCompatibilityFilter>();
var locator = new NuGetPackageAssembliesLocator(fileSystem, log, assemblyCompatibilityFilter, environment);
var addinDirectory = DirectoryPath.FromString("RelativeDirPath");
Assert.True(addinDirectory.IsRelative);
// When
var result = Record.Exception(() => locator.FindAssemblies(addinDirectory));
// Then
Assert.IsCakeException(result, "Package directory (RelativeDirPath) must be an absolute path.");
}
internal UrlLoadDirectiveProviderFixture()
{
Environment = FakeEnvironment.CreateUnixEnvironment();
FileSystem = new FakeFileSystem(Environment);
ProcessRunner = Substitute.For <IProcessRunner>();
LoadedReferences = new Dictionary <string, string>();
ScriptAnalyzerContext = Substitute.For <IScriptAnalyzerContext>();
ScriptAnalyzerContext.Root.Returns(new FilePath(System.IO.Directory.GetCurrentDirectory()));
ScriptAnalyzerContext
.WhenForAnyArgs(x => x.Analyze(Arg.Any <FilePath>()))
.Do(c => {
var fp = c.Arg <FilePath>();
LoadedReferences[fp.FullPath] = System.IO.File.ReadAllText(fp.FullPath);
});
Log = new FakeLog();
Config = new CakeConfiguration(new Dictionary <string, string> ());
}
public void Should_Create_Text_Transformation_From_Disc_Template()
{
// Given
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile("/Working/template.txt").SetContent("Hello World");
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());
}
public ScriptProcessorFixture(
string scriptPath = "./build.cake",
bool scriptExist = true,
string scriptSource = "Console.WriteLine();")
{
ScriptPath = new FilePath(scriptPath);
Source = scriptSource;
Log = Substitute.For <ICakeLog>();
Globber = Substitute.For <IGlobber>();
Environment = FakeEnvironment.CreateUnixEnvironment();
FileSystem = new FakeFileSystem(Environment);
if (scriptExist)
{
FileSystem.CreateFile(ScriptPath.MakeAbsolute(Environment)).SetContent(Source);
}
NuGetToolResolver = new NuGetToolResolver(FileSystem, Environment, Globber);
}
public FtpClientFixture(bool fileToUploadExists = true)
{
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateDirectory("/Working");
if (fileToUploadExists)
{
var fileToUpload = fileSystem.CreateFile("/Working/upload.txt").SetContent("This file is for uploading.");
FileToUpload = fileToUpload.Path;
}
Log = Substitute.For <ICakeLog>();
FtpService = Substitute.For <IFtpService>();
FileSystem = fileSystem;
Environment = environment;
Username = "******";
Password = "******";
ServerUri = new Uri("ftp://my.server.com/test.html");
}
public void Zipped_File_Should_Contain_Correct_Content()
{
// Given
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateFile("/Root/Stuff/file.txt").SetContent("HelloWorld");
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);
}
public XmlPeekAliasesFixture(bool xmlExists = true)
{
Settings = new XmlPeekSettings();
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateDirectory("/Working");
if (xmlExists)
{
var xmlFile = fileSystem.CreateFile("/Working/web.config").SetContent(Resources.XmlPeek_Xml);
XmlPath = xmlFile.Path;
}
FileSystem = fileSystem;
Context = Substitute.For <ICakeContext>();
Context.FileSystem.Returns(FileSystem);
Context.Environment.Returns(environment);
}
public FakeCakeContext()
{
testsDir = new DirectoryPath(Path.GetFullPath(AppContext.BaseDirectory));
var environment = FakeEnvironment.CreateUnixEnvironment(false);
var fileSystem = new FakeFileSystem(environment);
var globber = new Globber(fileSystem, environment);
log = new FakeLog();
var args = new FakeCakeArguments();
var registry = new WindowsRegistry();
var config = new FakeConfiguration();
var tools = new ToolLocator(environment, new ToolRepository(environment), new ToolResolutionStrategy(fileSystem, environment, globber, config));
var processRunner = new ProcessRunner(fileSystem, environment, log, tools, config);
var data = Substitute.For <ICakeDataService>();
context = new CakeContext(fileSystem, environment, globber, log, args, processRunner, registry, tools, data, config);
context.Environment.WorkingDirectory = testsDir;
}
public void Should_Read_File_With_Multiple_Lines_Correctly()
{
// Given
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
var content = new StringBuilder();
content.AppendLine("1");
content.AppendLine("2");
content.AppendLine("3");
var file = fileSystem.CreateFile("text.txt").SetContent(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 XmlPokeFixture(bool xmlExists = true, bool xmlWithDtd = false)
{
Settings = new XmlPokeSettings();
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
fileSystem.CreateDirectory("/Working");
if (xmlExists)
{
string content = xmlWithDtd ? Resources.XmlPoke_Xml_Dtd : Resources.XmlPoke_Xml;
var xmlFile = fileSystem.CreateFile("/Working/web.config").SetContent(content);
XmlPath = xmlFile.Path;
}
FileSystem = fileSystem;
Context = Substitute.For <ICakeContext>();
Context.FileSystem.Returns(FileSystem);
Context.Environment.Returns(environment);
}
public ProgramFixture()
{
Bootstrapper = new TestContainerConfigurator();
Environment = FakeEnvironment.CreateUnixEnvironment();
FileSystem = new FakeFileSystem(Environment);
Log = new FakeLog();
Console = new FakeConsole();
ModuleSearcher = Substitute.For <IModuleSearcher>();
Builder = new BuildFeatureFixture(FileSystem, Environment, Bootstrapper, Log, Console, ModuleSearcher);
// CLI overrides
Overrides = new List <Action <ContainerBuilder> >()
{
builder => builder.RegisterInstance(Bootstrapper).As <IContainerConfigurator>(),
builder => builder.RegisterInstance(Environment).As <ICakeEnvironment>(),
builder => builder.RegisterInstance(FileSystem).As <IFileSystem>(),
builder => builder.RegisterInstance(Log).As <ICakeLog>(),
builder => builder.RegisterInstance(Console).As <IConsole>(),
builder => builder.RegisterInstance(ModuleSearcher).As <IModuleSearcher>(),
builder => builder.RegisterInstance(Builder).As <IBuildFeature>()
};
}
public static GlobberFixture UnixLike()
{
var environment = FakeEnvironment.CreateUnixEnvironment();
var filesystem = new FakeFileSystem(environment);
// Directories
filesystem.CreateDirectory("/RootDir");
filesystem.CreateDirectory("/Working");
filesystem.CreateDirectory("/Working/Foo");
filesystem.CreateDirectory("/Working/Foo/Bar");
filesystem.CreateDirectory("/Working/Bar");
filesystem.CreateDirectory("/Foo/Bar");
filesystem.CreateDirectory("/Foo (Bar)");
filesystem.CreateDirectory("/Foo@Bar/");
filesystem.CreateDirectory("/嵌套");
filesystem.CreateDirectory("/嵌套/目录");
// Files
filesystem.CreateFile("/RootFile.sh");
filesystem.CreateFile("/Working/Foo/Bar/Qux.c");
filesystem.CreateFile("/Working/Foo/Bar/Qex.c");
filesystem.CreateFile("/Working/Foo/Bar/Qux.h");
filesystem.CreateFile("/Working/Foo/Baz/Qux.c");
filesystem.CreateFile("/Working/Foo/Bar/Baz/Qux.c");
filesystem.CreateFile("/Working/Bar/Qux.c");
filesystem.CreateFile("/Working/Bar/Qux.h");
filesystem.CreateFile("/Working/Foo.Bar.Test.dll");
filesystem.CreateFile("/Working/Bar.Qux.Test.dll");
filesystem.CreateFile("/Working/Quz.FooTest.dll");
filesystem.CreateFile("/Foo/Bar.baz");
filesystem.CreateFile("/Foo (Bar)/Baz.c");
filesystem.CreateFile("/Foo@Bar/Baz.c");
filesystem.CreateFile("/嵌套/目录/文件.延期");
filesystem.CreateFile("/Working/foobar.rs");
filesystem.CreateFile("/Working/foobaz.rs");
filesystem.CreateFile("/Working/foobax.rs");
return(new GlobberFixture(filesystem, environment));
}