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)); }