public void Constructor_Empty_FileNameExtensionTmp() { using (var temporaryFile = new TemporaryFile()) { Assert.That(Path.GetExtension(temporaryFile.FileName), Is.EqualTo(".tmp")); } }
public void TestExportFeeds() { using (var feedFile1 = new TemporaryFile("0install-unit-tests")) using (var feedFile2 = new TemporaryFile("0install-unit-tests")) { var feedCacheMock = CreateMock<IFeedCache>(); feedCacheMock.Setup(x => x.GetPath(FeedTest.Sub1Uri)).Returns(feedFile1); feedCacheMock.Setup(x => x.GetPath(FeedTest.Sub2Uri)).Returns(feedFile2); var signature = new ValidSignature(123, new byte[0], new DateTime(2000, 1, 1)); feedCacheMock.Setup(x => x.GetSignatures(FeedTest.Sub1Uri)).Returns(new OpenPgpSignature[] { signature }); feedCacheMock.Setup(x => x.GetSignatures(FeedTest.Sub2Uri)).Returns(new OpenPgpSignature[] { signature }); var openPgpMock = CreateMock<IOpenPgp>(); openPgpMock.Setup(x => x.ExportKey(signature)).Returns("abc"); _target.ExportFeeds(feedCacheMock.Object, openPgpMock.Object); string contentDir = Path.Combine(_destination, "content"); FileAssert.AreEqual( expected: new FileInfo(feedFile1), actual: new FileInfo(Path.Combine(contentDir, FeedTest.Sub1Uri.PrettyEscape())), message: "Feed should be exported."); FileAssert.AreEqual( expected: new FileInfo(feedFile2), actual: new FileInfo(Path.Combine(contentDir, FeedTest.Sub2Uri.PrettyEscape())), message: "Feed should be exported."); File.ReadAllText(Path.Combine(contentDir, "000000000000007B.gpg")).Should() .Be("abc", because: "GPG keys should be exported."); } }
public void ShouldApplyDeltaToPreviousPackageToCreateNewPackage() { using (var basisFile = new TemporaryFile(PackageBuilder.BuildSamplePackage("Acme.Web", "1.0.0.0"))) using (var signatureFile = new TemporaryFile(basisFile.FilePath + ".octosig")) { var signatureResult = Invoke(OctoDiff() .Action("signature") .PositionalArgument(basisFile.FilePath) .PositionalArgument(signatureFile.FilePath)); signatureResult.AssertZero(); Assert.That(File.Exists(signatureFile.FilePath)); using (var newFile = new TemporaryFile(PackageBuilder.BuildSamplePackage("Acme.Web", "1.0.0.1", true))) using (var deltaFile = new TemporaryFile(basisFile.FilePath + "_to_" + NewFileName + ".octodelta")) { var deltaResult = Invoke(OctoDiff() .Action("delta") .PositionalArgument(signatureFile.FilePath) .PositionalArgument(newFile.FilePath) .PositionalArgument(deltaFile.FilePath)); deltaResult.AssertZero(); Assert.That(File.Exists(deltaFile.FilePath)); var patchResult = ApplyDelta(basisFile.FilePath, basisFile.Hash, deltaFile.FilePath, NewFileName); patchResult.AssertZero(); patchResult.AssertOutput("Applying delta to {0} with hash {1} and storing as {2}", basisFile.FilePath, basisFile.Hash, Path.Combine(DownloadPath, NewFileName)); patchResult.AssertServiceMessage(ServiceMessageNames.PackageDeltaVerification.Name); } } }
/// <summary> /// Compiles a string of C# code using the newest C# compiler available on the system. /// </summary> /// <param name="compilerParameters">The compiler configuration (e.g. output file path).</param> /// <param name="code">The C# code to compile.</param> /// <param name="manifest">The contents of the Win32 manifest to apply to the output file. Will only be applied if a C# 3.0 or newer compiler is available.</param> public static void CompileCSharp([NotNull] this CompilerParameters compilerParameters, [NotNull, Localizable(false)] string code, [NotNull, Localizable(false)] string manifest) { #region Sanity checks if (compilerParameters == null) throw new ArgumentNullException(nameof(compilerParameters)); if (string.IsNullOrEmpty(code)) throw new ArgumentNullException(nameof(code)); if (string.IsNullOrEmpty(manifest)) throw new ArgumentNullException(nameof(manifest)); #endregion // Make sure the containing directory exists string directory = Path.GetDirectoryName(Path.GetFullPath(compilerParameters.OutputAssembly)); if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory)) Directory.CreateDirectory(directory); using (var manifestFile = new TemporaryFile("0install")) { File.WriteAllText(manifestFile, manifest); var compiler = GetCSharpCompiler(compilerParameters, manifestFile); var compilerResults = compiler.CompileAssemblyFromSource(compilerParameters, code); if (compilerResults.Errors.HasErrors) { var error = compilerResults.Errors[0]; if (error.ErrorNumber == "CS0016") throw new IOException(error.ErrorText); else throw new InvalidOperationException("Compilation error " + error.ErrorNumber + " in line " + error.Line + Environment.NewLine + error.ErrorText); } } }
public void ShouldFindOneEarlierPackageVersion() { using (var acmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId, packageVersion))) { var destinationFilePath = Path.Combine(downloadPath, Path.GetFileName(acmeWeb.FilePath) + "-" + Guid.NewGuid()); File.Copy(acmeWeb.FilePath, destinationFilePath); using (var newAcmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId, newpackageVersion))) { var result = FindPackages(packageId, newpackageVersion, newAcmeWeb.Hash); result.AssertZero(); result.AssertOutput("Package {0} version {1} hash {2} has not been uploaded.", packageId, newpackageVersion, newAcmeWeb.Hash); result.AssertOutput("Finding earlier packages that have been uploaded to this Tentacle"); result.AssertOutput("Found 1 earlier version of {0} on this Tentacle", packageId); result.AssertOutput(" - {0}: {1}", packageVersion, destinationFilePath); result.AssertServiceMessage(ServiceMessageNames.FoundPackage.Name, Is.True, new Dictionary<string, object> { {"Metadata.Id", packageId}, {"Metadata.Version", packageVersion}, {"Metadata.Hash", acmeWeb.Hash}, {"FullPath", destinationFilePath} }); } } }
/// <inheritdoc/> public IEnumerable<OpenPgpSignature> Verify(byte[] data, byte[] signature) { #region Sanity checks if (data == null) throw new ArgumentNullException(nameof(data)); if (signature == null) throw new ArgumentNullException(nameof(signature)); #endregion string result; using (var signatureFile = new TemporaryFile("0install-sig")) { File.WriteAllBytes(signatureFile, signature); result = new CliControl(HomeDir, data).Execute("--batch", "--no-secmem-warning", "--status-fd", "1", "--verify", signatureFile.Path, "-"); } string[] lines = result.SplitMultilineText(); // Each signature is represented by one line of encoded information var signatures = new List<OpenPgpSignature>(lines.Length); foreach (var line in lines) { try { var parsedSignature = ParseSignatureLine(line); if (parsedSignature != null) signatures.Add(parsedSignature); } #region Error handling catch (FormatException ex) { // Wrap exception since only certain exception types are allowed throw new IOException(ex.Message, ex); } #endregion } return signatures; }
public void Execute(BoostTestRunnerCommandLineArgs args, BoostTestRunnerSettings settings, IProcessExecutionContext executionContext) { var fixedArgs = args; if (args != null) { // Adapt a copy of the command-line arguments to avoid changing the original fixedArgs = AdaptArguments(args.Clone()); } using (var stderr = new TemporaryFile(IsStandardErrorFileDifferent(args, fixedArgs) ? fixedArgs.StandardErrorFile : null)) { this.Runner.Execute(fixedArgs, settings, executionContext); // Extract the report output to its intended location string source = (fixedArgs == null) ? null : fixedArgs.StandardErrorFile; string destination = (args == null) ? null : args.ReportFile; if ((source != null) && (destination != null)) { try { ExtractReport(source, destination, string.IsNullOrEmpty(stderr.Path)); } catch (Exception ex) { Logger.Exception(ex, "Failed to extract test report from standard error [{0}] to report file [{1}] ({2})", source, destination, ex.Message); } } } }
private static TemporaryFile Deploy(Stream stream) { var tempFile = new TemporaryFile("0install-unit-tests"); using (var fileStream = File.Create(tempFile)) stream.CopyTo(fileStream); return tempFile; }
public override void Activation() { base.Activation(); m_prevActive = false; string report = Exec("pfctl -si"); if (report.IndexOf ("denied") != -1) throw new Exception("Permission denied."); else if (report.IndexOf ("Status: Enabled") != -1) m_prevActive = true; else if (report.IndexOf("Status: Disabled") != -1) m_prevActive = false; else throw new Exception("Unexpected PF Firewall status"); if (m_prevActive == false) { string reportActivation = Exec ("pfctl -e"); if (reportActivation.IndexOf ("pf enabled") == -1) throw new Exception ("Unexpected PF Firewall activation failure"); } m_filePfConf = new TemporaryFile("pf.conf"); OnUpdateIps(); if (m_prevActive == false) { Exec("pfctl -e"); } }
public void ConvertCsvToExcel_MicrosoftOfficeInteropExcel() { StringBuilder content = new StringBuilder(); content.AppendLine("param1\tparam2\tstatus"); content.AppendLine("0.5\t10\tpassed"); content.AppendLine("10\t20\tfail"); using (TemporaryFile xlsxFile = new TemporaryFile(".xlsx")) { Clipboard.SetText(content.ToString()); Microsoft.Office.Interop.Excel.Application xlexcel; Microsoft.Office.Interop.Excel.Workbook xlWorkBook; Microsoft.Office.Interop.Excel.Worksheet xlWorkSheet; object misValue = System.Reflection.Missing.Value; xlexcel = new Microsoft.Office.Interop.Excel.Application(); // for excel visibility //xlexcel.Visible = true; // Creating a new workbook xlWorkBook = xlexcel.Workbooks.Add(misValue); // Putting Sheet 1 as the sheet you want to put the data within xlWorkSheet = (Microsoft.Office.Interop.Excel.Worksheet) xlWorkBook.Worksheets.get_Item(1); // creating the range Microsoft.Office.Interop.Excel.Range CR = (Microsoft.Office.Interop.Excel.Range) xlWorkSheet.Cells[1, 1]; CR.Select(); xlWorkSheet.Paste(CR, false); xlWorkSheet.SaveAs(xlsxFile.FileName); xlexcel.Quit(); Console.WriteLine("Created file {0}", xlsxFile.FileName); } }
public void Constructor_Empty_FileExists() { using (var temporaryFile = new TemporaryFile()) { Assert.That(File.Exists(temporaryFile.FileName), Is.True); } }
public DownloadResult( ILog logger, Stream zipContent ) { File = new TemporaryFile( ".zip" ); using( zipContent ) using( var sw = System.IO.File.Open( File.Path, FileMode.Open ) ) zipContent.CopyTo( sw ); try { // open the zip file using( ZipFile zip = ZipFile.Read( File.Path ) ) { var manifestEntry = zip.Where( z => z.FileName == "manifest.xml" ).FirstOrDefault(); if( manifestEntry != null ) { var ms = new MemoryStream(); manifestEntry.Extract( ms ); try { Manifest = HelpManifestData.Deserialize( ms ); } catch( Exception ex ) { logger.Error( "Unable to parse manifest", ex ); throw; } } } } catch( Exception ex ) { logger.Error( "Unable to read downloaded help content as a zip file", ex ); throw; } }
public void MatchingFile() { using (var file = new TemporaryFile()) { Assert.IsTrue(filter.IsMatch(file.FileInfo, environment)); } }
public void Constructor_Empty_FilePlacedIntoTemporaryFolder() { using (var temporaryFile = new TemporaryFile()) { Assert.That(Path.GetDirectoryName(temporaryFile.FileName) + @"\", Is.EqualTo(Path.GetTempPath())); } }
public void OldFile_IsMatch_ReturnsTrue() { using (var file = new TemporaryFile()) { file.FileInfo.LastWriteTime = DateTime.Now.Subtract(TimeSpan.FromDays(2)); Assert.IsTrue(filter.IsMatch(file.FileInfo, environment)); } }
public void NewFile_IsMatch_ReturnsFalse() { using (var file = new TemporaryFile()) { file.FileInfo.LastWriteTime = DateTime.Now; Assert.IsFalse(filter.IsMatch(file.FileInfo, environment)); } }
public void TestCopyToFile() { using (var tempFile = new TemporaryFile("unit-tests")) { "abc".ToStream().CopyToFile(tempFile); new FileInfo(tempFile).ReadFirstLine(Encoding.UTF8).Should().Be("abc"); } }
public void NonMatchingFile() { using (var file = new TemporaryFile()) { file.Contents = "01234"; Assert.IsFalse(filter.IsMatch(file.FileInfo, environment)); } }
public void Dispose_Empty_FileDeleted() { string fileName; using (var temporaryFile = new TemporaryFile()) { fileName = temporaryFile.FileName; } Assert.That(File.Exists(fileName), Is.False); }
public void PowershellDecryptsSensitiveVariables() { using (var scriptFile = new TemporaryFile(Path.ChangeExtension(Path.GetTempFileName(), "ps1"))) { File.WriteAllText(scriptFile.FilePath, "Write-Host $mysecrect"); var result = ExecuteScript(new PowerShellScriptEngine(), scriptFile.FilePath, GetDictionaryWithSecret()); result.AssertOutput("KingKong"); } }
public void CSharpDecryptsSensitiveVariables() { using (var scriptFile = new TemporaryFile(Path.ChangeExtension(Path.GetTempFileName(), "cs"))) { File.WriteAllText(scriptFile.FilePath, "System.Console.WriteLine(Octopus.Parameters[\"mysecrect\"]);"); var result = ExecuteScript(new ScriptCSScriptEngine(), scriptFile.FilePath, GetDictionaryWithSecret()); result.AssertOutput("KingKong"); } }
public void BashDecryptsSensitiveVariables() { using (var scriptFile = new TemporaryFile(Path.ChangeExtension(Path.GetTempFileName(), "sh"))) { File.WriteAllText(scriptFile.FilePath, "#!/bin/bash\necho $(get_octopusvariable \"mysecrect\")"); var result = ExecuteScript(new BashScriptEngine(), scriptFile.FilePath, GetDictionaryWithSecret()); result.AssertOutput("KingKong"); } }
public void Test_WithContent() { // Act. using (var temp = new TemporaryFile("stuff")) { // Assert. Assert.True(temp.File.Exists); Assert.Equal("stuff", File.ReadAllText(temp.File.FullName)); } }
public void TestSet() { using (var flagFile = new TemporaryFile("0install-unit-tests")) { FlagUtils.Set(flagFile, Path.Combine("dir1", "file1")); File.ReadAllText(flagFile).Should().Be("/dir1/file1\n"); FlagUtils.Set(flagFile, Path.Combine("dir2", "file2")); File.ReadAllText(flagFile).Should().Be("/dir1/file1\n/dir2/file2\n"); } }
public void TemporaryFileSimpleDemo() { using (TemporaryFile temporaryFile = new TemporaryFile()) { File.WriteAllText(temporaryFile.FileName, "[0]: test"); File.AppendAllText(temporaryFile.FileName, "[1]: additional text"); string allText = File.ReadAllText(temporaryFile.FileName); Assert.That(allText, Is.EqualTo("[0]: test" + "[1]: additional text")); } }
public void Test_File() { // Arrange. var temp = new TemporaryFile(); // Act. var file = temp.File; // Assert. Assert.NotNull(file); Assert.Equal(Path.GetTempPath().TrimEnd(Path.DirectorySeparatorChar), file.DirectoryName.TrimEnd(Path.DirectorySeparatorChar)); }
public void ShouldFindNoEarlierPackageVersions() { using (var acmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId, packageVersion))) { var result = FindPackages(packageId, packageVersion, acmeWeb.Hash); result.AssertZero(); result.AssertOutput("Package {0} version {1} hash {2} has not been uploaded.", packageId, packageVersion, acmeWeb.Hash); result.AssertOutput("Finding earlier packages that have been uploaded to this Tentacle"); result.AssertOutput("No earlier packages for {0} has been uploaded", packageId); } }
public void Test_Dispose() { // Arrange. var temp = new TemporaryFile().Touch(); // Act. temp.Dispose(); temp.File.Refresh(); // Assert. Assert.False(temp.File.Exists); }
public static string HashWithGit(Stream file) { // Write the data to a file and insert that, so that git will handle any // EOL and encoding issues. using (var tempFile = new TemporaryFile()) { using (var tempStream = File.Create(tempFile)) { file.CopyTo(tempStream); } return HashWithGit(tempFile); } }
CalamariResult DeployPackage(string packageName) { using (var variablesFile = new TemporaryFile(Path.GetTempFileName())) using (var acmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageName, "1.0.0"))) { variables.Save(variablesFile.FilePath); return Invoke(Calamari() .Action("deploy-azure-web") .Argument("package", acmeWeb.FilePath) .Argument("variables", variablesFile.FilePath)); } }
public CommandResult ExecuteScript(IScriptEngine scriptEngine, Script script, CalamariVariableDictionary variables, ICommandLineRunner commandLineRunner) { if (!ServiceFabricHelper.IsServiceFabricSdkKeyInRegistry()) { throw new Exception("Could not find the Azure Service Fabric SDK on this server. This SDK is required before running Service Fabric commands."); } var workingDirectory = Path.GetDirectoryName(script.File); variables.Set("OctopusFabricTargetScript", "\"" + script.File + "\""); variables.Set("OctopusFabricTargetScriptParameters", script.Parameters); // Azure PS modules are required for looking up Azure environments (needed for AAD url lookup in Service Fabric world). SetAzureModulesLoadingMethod(variables); // Read thumbprint from our client cert variable (if applicable). var securityMode = variables.Get(SpecialVariables.Action.ServiceFabric.SecurityMode); var clientCertThumbprint = string.Empty; if (securityMode == AzureServiceFabricSecurityMode.SecureClientCertificate.ToString()) { var certificateVariable = GetMandatoryVariable(variables, SpecialVariables.Action.ServiceFabric.ClientCertVariable); clientCertThumbprint = variables.Get($"{certificateVariable}.{SpecialVariables.Certificate.Properties.Thumbprint}"); } // Set output variables for our script to access. SetOutputVariable("OctopusFabricConnectionEndpoint", variables.Get(SpecialVariables.Action.ServiceFabric.ConnectionEndpoint), variables); SetOutputVariable("OctopusFabricSecurityMode", variables.Get(SpecialVariables.Action.ServiceFabric.SecurityMode), variables); SetOutputVariable("OctopusFabricServerCertThumbprint", variables.Get(SpecialVariables.Action.ServiceFabric.ServerCertThumbprint), variables); SetOutputVariable("OctopusFabricClientCertThumbprint", clientCertThumbprint, variables); SetOutputVariable("OctopusFabricCertificateFindType", variables.Get(SpecialVariables.Action.ServiceFabric.CertificateFindType, "FindByThumbprint"), variables); SetOutputVariable("OctopusFabricCertificateFindValueOverride", variables.Get(SpecialVariables.Action.ServiceFabric.CertificateFindValueOverride), variables); SetOutputVariable("OctopusFabricCertificateStoreLocation", variables.Get(SpecialVariables.Action.ServiceFabric.CertificateStoreLocation, "LocalMachine"), variables); SetOutputVariable("OctopusFabricCertificateStoreName", variables.Get(SpecialVariables.Action.ServiceFabric.CertificateStoreName, "MY"), variables); SetOutputVariable("OctopusFabricAadCredentialType", variables.Get(SpecialVariables.Action.ServiceFabric.AadCredentialType), variables); SetOutputVariable("OctopusFabricAadClientCredentialSecret", variables.Get(SpecialVariables.Action.ServiceFabric.AadClientCredentialSecret), variables); SetOutputVariable("OctopusFabricAadUserCredentialUsername", variables.Get(SpecialVariables.Action.ServiceFabric.AadUserCredentialUsername), variables); SetOutputVariable("OctopusFabricAadUserCredentialPassword", variables.Get(SpecialVariables.Action.ServiceFabric.AadUserCredentialPassword), variables); using (new TemporaryFile(Path.Combine(workingDirectory, "AzureProfile.json"))) using (var contextScriptFile = new TemporaryFile(CreateContextScriptFile(workingDirectory))) { return(scriptEngine.Execute(new Script(contextScriptFile.FilePath), variables, commandLineRunner)); } }
/// <summary> /// Compiles a string of C# code using the newest C# compiler available on the system. /// </summary> /// <param name="compilerParameters">The compiler configuration (e.g. output file path).</param> /// <param name="code">The C# code to compile.</param> /// <param name="manifest">The contents of the Win32 manifest to apply to the output file. Will only be applied if a C# 3.0 or newer compiler is available.</param> public static void CompileCSharp([NotNull] this CompilerParameters compilerParameters, [NotNull, Localizable(false)] string code, [NotNull, Localizable(false)] string manifest) { #region Sanity checks if (compilerParameters == null) { throw new ArgumentNullException(nameof(compilerParameters)); } if (string.IsNullOrEmpty(code)) { throw new ArgumentNullException(nameof(code)); } if (string.IsNullOrEmpty(manifest)) { throw new ArgumentNullException(nameof(manifest)); } #endregion // Make sure the containing directory exists string directory = Path.GetDirectoryName(Path.GetFullPath(compilerParameters.OutputAssembly)); if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory)) { Directory.CreateDirectory(directory); } using (var manifestFile = new TemporaryFile("0install")) { File.WriteAllText(manifestFile, manifest); var compiler = GetCSharpCompiler(compilerParameters, manifestFile); var compilerResults = compiler.CompileAssemblyFromSource(compilerParameters, code); if (compilerResults.Errors.HasErrors) { var error = compilerResults.Errors[0]; if (error.ErrorNumber == "CS0016") { throw new IOException(error.ErrorText); } else { throw new InvalidOperationException("Compilation error " + error.ErrorNumber + " in line " + error.Line + Environment.NewLine + error.ErrorText); } } } }
public void VerifyAllConfigOptionsMappedToConfigObject() { var pipelineConfigObj = new Dictionary<string, object> { ["outputs"] = new List<Dictionary<string, object>> { new Dictionary<string, object> { ["type"] = "ElasticSearch", ["indexNamePrefix"] = "myprefix", ["eventDocumentTypeName"] = "mytype", ["serviceUri"] = "http://localhost:1000", ["basicAuthenticationUserName"] = "******", ["basicAuthenticationUserPassword"] = "******", ["numberOfShards"] = 10, ["numberOfReplicas"] = 20, ["refreshInterval"] = "60s", } } }; using (var configFile = new TemporaryFile()) { var pipelineConfig = JsonConvert.SerializeObject(pipelineConfigObj); configFile.Write(pipelineConfig); var configBuilder = new ConfigurationBuilder(); configBuilder.AddJsonFile(configFile.FilePath); var configuration = configBuilder.Build(); var outputConfigSection = configuration.GetSection("outputs"); var configFragments = outputConfigSection.GetChildren().ToList(); var esOutputConfiguration = new ElasticSearchOutputConfiguration(); configFragments[0].Bind(esOutputConfiguration); Assert.Equal(esOutputConfiguration.IndexNamePrefix, "myprefix"); Assert.Equal(esOutputConfiguration.EventDocumentTypeName, "mytype"); Assert.Equal(esOutputConfiguration.ServiceUri, "http://localhost:1000"); Assert.Equal(esOutputConfiguration.BasicAuthenticationUserName, "myesuser"); Assert.Equal(esOutputConfiguration.BasicAuthenticationUserPassword, "myespass"); Assert.Equal(esOutputConfiguration.NumberOfShards, 10); Assert.Equal(esOutputConfiguration.NumberOfReplicas, 20); Assert.Equal(esOutputConfiguration.RefreshInterval, "60s"); } }
private void DoLosslessCompress(FileInfo file) { using (MagickImage image = new MagickImage(file)) { CheckFormat(image); image.Strip(); image.Settings.SetDefine(MagickFormat.Png, "exclude-chunks", "all"); image.Settings.SetDefine(MagickFormat.Png, "include-chunks", "tRNS,gAMA"); CheckTransparency(image); Collection <TemporaryFile> tempFiles = new Collection <TemporaryFile>(); try { TemporaryFile bestFile = null; foreach (int quality in GetQualityList()) { TemporaryFile tempFile = new TemporaryFile(); tempFiles.Add(tempFile); image.Quality = quality; image.Write(tempFile); if (bestFile == null || bestFile.Length > tempFile.Length) { bestFile = tempFile; } } if (bestFile.Length < file.Length) { bestFile.CopyTo(file); } } finally { foreach (TemporaryFile tempFile in tempFiles) { tempFile.Dispose(); } } } }
public void ApplySettings(IActivityMonitor monitor) { using (monitor.OpenInfo($"Executing {_scripts.Count} script(s) on this Workstation.")) using (var tempPS1 = new TemporaryFile("ps1")) { bool hasError = false; HashSet <EnvVar> currentVariables = null; foreach (var o in _scripts) { if (hasError) { break; } switch (o) { case HashSet <EnvVar> v: currentVariables = v; break; case ScriptLine script: { using (monitor.OpenTrace($"Executing script Type='{script.Type}', WorkingDir='{script.WorkingDir}', Arguments='{script.Arguments}', ContinueOnNonZeroExitCode='{script.ContinueOnNonZeroExitCode}'.")) { monitor.Debug($"With EnvironmentVariables: {currentVariables?.Select( v => v.ToString() ).Concatenate()}."); monitor.Debug(script.Script); System.IO.File.WriteAllText(tempPS1.Path, script.Script); if (!ProcessRunner.RunPowerShell( monitor, script.WorkingDir, tempPS1.Path, new[] { script.Arguments }, stdErrorLevel: LogLevel.Warn, currentVariables?.Select(v => (v.Name, Environment.ExpandEnvironmentVariables(v.Value))))) { hasError |= !script.ContinueOnNonZeroExitCode; if (!hasError) { monitor.Warn("ContinueOnNonZeroExitCode is true: error is ignored."); } } } break; } } } } }
string Upload(string packageName, List <S3FileSelectionProperties> fileSelections) { var bucketKeyPrefix = $"test/{Guid.NewGuid():N}/"; fileSelections.ForEach(properties => { if (properties is S3MultiFileSelectionProperties multiFileSelectionProperties) { multiFileSelectionProperties.BucketKeyPrefix = bucketKeyPrefix; } if (properties is S3SingleFileSelectionProperties singleFileSelectionProperties) { singleFileSelectionProperties.BucketKeyPrefix = bucketKeyPrefix; } }); var variablesFile = Path.GetTempFileName(); var variables = new VariableDictionary(); variables.Set("Octopus.Action.AwsAccount.Variable", "AWSAccount"); variables.Set("AWSAccount.AccessKey", Environment.GetEnvironmentVariable("AWS_Calamari_Access")); variables.Set("AWSAccount.SecretKey", Environment.GetEnvironmentVariable("AWS_Calamari_Secret")); variables.Set("Octopus.Action.Aws.Region", RegionEndpoint.APSoutheast1.SystemName); variables.Set(AwsSpecialVariables.S3.FileSelections, JsonConvert.SerializeObject(fileSelections, GetEnrichedSerializerSettings())); variables.Save(variablesFile); var packageDirectory = TestEnvironment.GetTestPath("AWS", "S3", packageName); using (var package = new TemporaryFile(PackageBuilder.BuildSimpleZip(packageName, "1.0.0", packageDirectory))) using (new TemporaryFile(variablesFile)) { var command = new UploadAwsS3Command(); var result = command.Execute(new[] { "--package", $"{package.FilePath}", "--variables", $"{variablesFile}", "--bucket", BucketName, "--targetMode", S3TargetMode.FileSelections.ToString() }); result.Should().Be(0); } return(bucketKeyPrefix); }
public void TestSaveLoad() { using (var tempFile = new TemporaryFile("unit-tests")) { var grid = new NibbleGrid(new byte[, ] { { 2, 4 }, { 5, 10 } }); grid.Save(tempFile); using (var stream = File.OpenRead(tempFile)) grid = NibbleGrid.Load(stream); grid[0, 0].Should().Be(2); grid[0, 1].Should().Be(4); grid[1, 0].Should().Be(5); grid[1, 1].Should().Be(10); } }
public void TestSaveLoad() { using (var tempFile = new TemporaryFile("unit-tests")) { var grid = new ByteGrid(new byte[, ] { { 10, 20 }, { 100, 200 } }); grid.Save(tempFile); using (var stream = File.OpenRead(tempFile)) grid = ByteGrid.Load(stream); grid[0, 0].Should().Be(10); grid[0, 1].Should().Be(20); grid[1, 0].Should().Be(100); grid[1, 1].Should().Be(200); } }
public async Task CompressedContentsDoNotDependOnInputPath() { var patchBuilder = new XdeltaPatchBuilder(XdeltaPatchSystemFactory.Preferred); using (var newFile1 = new TemporaryFile()) using (var newFile2 = new TemporaryFile()) using (var patchFile1 = new TemporaryFile()) using (var patchFile2 = new TemporaryFile()) { File.WriteAllText(newFile1.Path, "b"); File.WriteAllText(newFile2.Path, "b"); await patchBuilder.CompressAsync(newFile1.Path, patchFile1.Path); await patchBuilder.CompressAsync(newFile2.Path, patchFile2.Path); CollectionAssert.AreEquivalent(File.ReadAllBytes(patchFile1.Path), File.ReadAllBytes(patchFile2.Path)); } }
public void ShouldNotFindEarlierPackageVersionWhenExactMatchRequested() { using (var acmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId, packageVersion))) { var destinationFilePath = Path.Combine(downloadPath, PackageName.ToCachedFileName(packageId, VersionFactory.CreateSemanticVersion(packageVersion), ".nupkg")); File.Copy(acmeWeb.FilePath, destinationFilePath); using (var newAcmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId, newpackageVersion))) { var result = FindPackagesExact(packageId, newpackageVersion, newAcmeWeb.Hash, true); result.AssertSuccess(); result.AssertOutput("Package {0} version {1} hash {2} has not been uploaded.", packageId, newpackageVersion, newAcmeWeb.Hash); result.AssertNoOutput("Finding earlier packages that have been uploaded to this Tentacle"); } } }
public void OutOfProcessPowerShellDeployAgent_should_expose_live_output_to_the_deployment_event_recorder() { var deploymentEventRecorder = new StubDeploymentEventRecorder(); using (var scriptFile = new TemporaryFile(".ps1", "'hello there'")) { var data = new DeployAgentData { DeployScriptFile = scriptFile.FileInfo.Name, DeployScriptRoot = scriptFile.FileInfo.DirectoryName }; var agent = new OutOfProcessPowerShellDeployAgent(deploymentEventRecorder, ClrVersion.Version2); agent.Deploy(data); } StringAssert.Contains(deploymentEventRecorder.OutputDelegate(), "hello there"); }
private static void TestSaveLoad(AppList appList) { Assert.That(appList, Is.XmlSerializable); AppList appList2; using (var tempFile = new TemporaryFile("0install-unit-tests")) { // Write and read file appList.SaveXml(tempFile); appList2 = XmlStorage.LoadXml <AppList>(tempFile); } // Ensure data stayed the same appList2.Should().Be(appList, because: "Serialized objects should be equal."); appList2.GetHashCode().Should().Be(appList.GetHashCode(), because: "Serialized objects' hashes should be equal."); appList2.Should().NotBeSameAs(appList, because: "Serialized objects should not return the same reference."); }
[Fact] // Ensures local Selections XMLs are correctly detected and parsed. public void TestImportSelections() { var selections = Fake.Selections; ExpectFetchUncached(selections, new Implementation { ID = "id1", ManifestDigest = new ManifestDigest(sha256: "abc"), Version = new ImplementationVersion("1.0") }, new Implementation { ID = "id2", ManifestDigest = new ManifestDigest(sha256: "xyz"), Version = new ImplementationVersion("1.0") }); using var tempFile = new TemporaryFile("0install-unit-tests"); selections.SaveXml(tempFile); selections.Normalize(); RunAndAssert(Resources.AllComponentsDownloaded, 0, selections, tempFile); }
public void ShouldPerformReplacementInXmlFileWithANonXmlExtension() { using (var file = new TemporaryFile(PackageBuilder.BuildSamplePackage(ServiceName, ServiceVersion))) { Variables.Set(KnownVariables.Package.EnabledFeatures, KnownVariables.Features.StructuredConfigurationVariables); Variables.Set(ActionVariables.StructuredConfigurationVariablesTargets, XmlFileNameWithNonXmlExtension); Variables.Set("/document/key", "new-value"); var result = DeployPackage(file.FilePath); result.AssertSuccess(); var extractedPackageUpdatedXmlFile = File.ReadAllText(Path.Combine(StagingDirectory, ServiceName, ServiceVersion, XmlFileNameWithNonXmlExtension)); result.AssertOutput("The file will be tried as multiple formats and will be treated as the first format that can be successfully parsed"); result.AssertOutput("couldn't be parsed as Json"); this.Assent(extractedPackageUpdatedXmlFile, TestEnvironment.AssentXmlConfiguration); } }
public void Compress_WithQualitySetTo40_FileIsSmallerThanNormalCompression() { using (TemporaryFile tempFile = new TemporaryFile(Files.ImageMagickJPG)) { JpegOptimizer optimizer = new JpegOptimizer(); optimizer.Compress(tempFile); IMagickImageInfo info = new MagickImageInfo(tempFile); Assert.AreEqual(85, info.Quality); File.Copy(Files.ImageMagickJPG, tempFile.FullName, true); optimizer.Compress(tempFile, 40); info = new MagickImageInfo(tempFile); Assert.AreEqual(40, info.Quality); } }
public void ExecutionUsingPodServiceAccount_WithServerCert() { variables.Set(ScriptVariables.Syntax, ScriptSyntax.PowerShell.ToString()); variables.Set(PowerShellVariables.Edition, "Desktop"); using (var dir = TemporaryDirectory.Create()) using (var podServiceAccountToken = new TemporaryFile(Path.Combine(dir.DirectoryPath, "podServiceAccountToken"))) using (var certificateAuthority = new TemporaryFile(Path.Combine(dir.DirectoryPath, "certificateAuthority"))) { File.WriteAllText(podServiceAccountToken.FilePath, "podServiceAccountToken"); File.WriteAllText(certificateAuthority.FilePath, "certificateAuthority"); redactMap[podServiceAccountToken.FilePath] = "<podServiceAccountTokenPath>"; redactMap[certificateAuthority.FilePath] = "<certificateAuthorityPath>"; variables.Set("Octopus.Action.Kubernetes.PodServiceAccountTokenPath", podServiceAccountToken.FilePath); variables.Set("Octopus.Action.Kubernetes.CertificateAuthorityPath", certificateAuthority.FilePath); var wrapper = CreateWrapper(); TestScriptInReadOnlyMode(wrapper).AssertSuccess(); } }
public void PowerShellDoesntForceTraceMode(string variableValue) { using (var scriptFile = new TemporaryFile(Path.ChangeExtension(Path.GetTempFileName(), "ps1"))) { File.WriteAllText(scriptFile.FilePath, "Write-Host $mysecrect"); var calamariVariableDictionary = GetVariables(); if (!string.IsNullOrEmpty(variableValue)) { calamariVariableDictionary.Set("Octopus.Action.PowerShell.PSDebug.Trace", variableValue); } var result = ExecuteScript(new PowerShellScriptExecutor(), scriptFile.FilePath, calamariVariableDictionary); result.AssertOutput("KingKong"); result.AssertNoOutput("DEBUG: 1+ >>>> Write-Host $mysecrect"); } }
public void LogFileCopiesTheContentsOfTheSourceFile() { using (TemporaryFile sourceFile = new TemporaryFile()) { string sourceContent = "Source file content"; File.WriteAllText(sourceFile.FileName, sourceContent); using (FilesContainer filesContainer = new FilesContainer(new Logger())) { LoggedFile file = filesContainer.LogFile(sourceFile.FileName, null); string content = File.ReadAllText(file.FilePath); Assert.AreEqual(sourceContent, content); } } }
/// <summary> /// Compare a given sting against the contents of a file with test data and show a diff tool when they are not equal /// </summary> public static void AreEqual(string actual, string fileExtension, [CallerMemberName] string fileName = null) { string expectedFileName = Path.Combine("TestData", fileName + fileExtension); string expected = File.ReadAllText(expectedFileName); try { Assert.AreEqual(expected, actual); } catch (AssertFailedException) { // Show diff tool when two strings aren't equal using var actualFile = new TemporaryFile(actual, fileExtension); using Process diff = Process.Start(DiffExecutable, string.Format(DiffArguments, actualFile.Name, expectedFileName)); diff.WaitForExit(); throw; } }
public void SaveLoad() { Config config1; object config2; using (var tempFile = new TemporaryFile("0install-test-config")) { // Write and read file config1 = CreateTestConfig(); config1.Save(tempFile); config2 = Config.Load(tempFile); } // Ensure data stayed the same config2.Should().Be(config1, because: "Serialized objects should be equal."); config2.GetHashCode().Should().Be(config1.GetHashCode(), because: "Serialized objects' hashes should be equal."); config2.Should().NotBeSameAs(config1, because: "Serialized objects should not return the same reference."); }
public async Task <ActionResult> ParseFile(HttpPostedFileBase file) { var service = new GetPackagesService(_nuGetPackagesRepository, _uiLibraryPackageRepository); PackagesFileResult <IPackage> result = null; using (TemporaryFile tempFile = new TemporaryFile()) { file.SaveAs(tempFile.FileName); result = await service.ParseFileAsync(tempFile.FileName, file.FileName); } var builder = new ParseResultViewModelBuilder(); var viewModel = builder.Build(new[] { result }); return(View(_outputView, viewModel)); }
public static void RethrowWithLockingInformation_GivenIOExceptionWithNoLockedFiles_ReturnsFalse() { using var tmpPath = new TemporaryFile(); try { using (var file = tmpPath.FileInfo.Open(FileMode.OpenOrCreate, FileAccess.Write, FileShare.None)) using (var innerFile = tmpPath.FileInfo.Open(FileMode.OpenOrCreate, FileAccess.Write, FileShare.None)) _ = "won't get here"; Assert.Fail("The file locking did not throw an exception when it should have."); } catch (IOException ex) { var result = ex.RethrowWithLockingInformation(tmpPath.FileInfo); Assert.That(result, Is.False); } }
public void CanPerformReplacementOnMultipleTargetFiles() { using (var file = new TemporaryFile(PackageBuilder.BuildSamplePackage(ServiceName, ServiceVersion))) { Variables.Set(KnownVariables.Package.EnabledFeatures, KnownVariables.Features.StructuredConfigurationVariables); Variables.Set(ActionVariables.StructuredConfigurationVariablesTargets, $"{JsonFileName}\n{YamlFileName}"); Variables.Set("key", "new-value"); var result = DeployPackage(file.FilePath); result.AssertSuccess(); var extractedPackageUpdatedJsonFile = File.ReadAllText(Path.Combine(StagingDirectory, ServiceName, ServiceVersion, JsonFileName)); var extractedPackageUpdatedYamlFile = File.ReadAllText(Path.Combine(StagingDirectory, ServiceName, ServiceVersion, YamlFileName)); this.Assent(extractedPackageUpdatedJsonFile, TestEnvironment.AssentJsonConfiguration); this.Assent(extractedPackageUpdatedYamlFile, TestEnvironment.AssentYamlConfiguration); } }
/// <inheritdoc/> public IEnumerable <OpenPgpSignature> Verify(byte[] data, byte[] signature) { #region Sanity checks if (data == null) { throw new ArgumentNullException(nameof(data)); } if (signature == null) { throw new ArgumentNullException(nameof(signature)); } #endregion string result; using (var signatureFile = new TemporaryFile("0install-sig")) { File.WriteAllBytes(signatureFile, signature); result = new CliControl(_homeDir, data).Execute("--batch", "--no-secmem-warning", "--status-fd", "1", "--verify", signatureFile.Path, "-"); } var lines = result.SplitMultilineText(); // Each signature is represented by one line of encoded information var signatures = new List <OpenPgpSignature>(lines.Length); foreach (string line in lines) { try { var parsedSignature = ParseSignatureLine(line); if (parsedSignature != null) { signatures.Add(parsedSignature); } } #region Error handling catch (FormatException ex) { // Wrap exception since only certain exception types are allowed throw new IOException(ex.Message, ex); } #endregion } return(signatures); }
public void TestGetUncachedSelectionsPackageManager() { using (var tempFile = new TemporaryFile("0install-unit-tests")) { var impl1 = new ExternalImplementation("RPM", "firefox", new ImplementationVersion("1.0")) { IsInstalled = false }; var impl2 = new ExternalImplementation("RPM", "thunderbird", new ImplementationVersion("1.0")) { IsInstalled = true }; var impl3 = new ExternalImplementation("RPM", "vlc", new ImplementationVersion("1.0")) { IsInstalled = true, QuickTestFile = tempFile }; var selections = new Selections { InterfaceUri = FeedTest.Test1Uri, Command = Command.NameRun, Implementations = { new ImplementationSelection { InterfaceUri = FeedTest.Test1Uri, FromFeed = new FeedUri(FeedUri.FromDistributionPrefix + FeedTest.Test1Uri), ID = impl1.ID, QuickTestFile = impl1.QuickTestFile }, new ImplementationSelection { InterfaceUri = FeedTest.Test1Uri, FromFeed = new FeedUri(FeedUri.FromDistributionPrefix + FeedTest.Test1Uri), ID = impl2.ID, QuickTestFile = impl2.QuickTestFile }, new ImplementationSelection { InterfaceUri = FeedTest.Test1Uri, FromFeed = new FeedUri(FeedUri.FromDistributionPrefix + FeedTest.Test1Uri), ID = impl3.ID, QuickTestFile = impl3.QuickTestFile } } }; PackageManagerMock.Setup(x => x.Lookup(selections.Implementations[0])).Returns(impl1); PackageManagerMock.Setup(x => x.Lookup(selections.Implementations[1])).Returns(impl2); var implementationSelections = Target.GetUncachedSelections(selections); // Only the first implementation should be listed as uncached implementationSelections.Should().BeEquivalentTo(new[] { selections.Implementations[0] }, because: "Only the first implementation should be listed as uncached"); } }
public static async Task <DependencyGraphSpec> GenerateRestoreGraphFile(ILogger logger, string projectPath) { DependencyGraphSpec spec = null; using (var restoreGraphResult = new TemporaryFile()) { await Task.Run(() => { var pc = new Microsoft.Build.Evaluation.ProjectCollection(); try { var parameters = new BuildParameters(pc) { Loggers = new[] { new LoggerRedirect(logger, true) } //Instance of ILogger instantiated earlier }; // Run a MSBuild /t:Restore <projectfile> var request = new BuildRequestData(projectPath, new Dictionary <string, string> { { "RestoreGraphOutputPath", restoreGraphResult.Path }, { "RestoreRecursive", "false" } }, null, new[] { "GenerateRestoreGraphFile" }, null, BuildRequestDataFlags.None); mainBuildManager.Build(parameters, request); } finally { pc.UnloadAllProjects(); pc.Dispose(); } }); if (File.Exists(restoreGraphResult.Path) && new FileInfo(restoreGraphResult.Path).Length != 0) { spec = DependencyGraphSpec.Load(restoreGraphResult.Path); File.Delete(restoreGraphResult.Path); } else { spec = new DependencyGraphSpec(); } } return(spec); }
public void VerifyAllConfigOptionsMappedToConfigObject() { var pipelineConfigObj = new Dictionary <string, object> { ["outputs"] = new List <Dictionary <string, object> > { new Dictionary <string, object> { ["type"] = "Http", ["format"] = "JsonLines", ["ServiceUri"] = "http://localhost:1000", ["basicAuthenticationUserName"] = "******", ["basicAuthenticationUserPassword"] = "******", ["httpContentType"] = "application/x-custom", ["headers"] = new Dictionary <string, string> { ["X-Foo"] = "example" } } } }; using (var configFile = new TemporaryFile()) { var pipelineConfig = JsonConvert.SerializeObject(pipelineConfigObj, EventFlowJsonUtilities.GetDefaultSerializerSettings()); configFile.Write(pipelineConfig); var configBuilder = new ConfigurationBuilder(); configBuilder.AddJsonFile(configFile.FilePath); var configuration = configBuilder.Build(); var outputConfigSection = configuration.GetSection("outputs"); var configFragments = outputConfigSection.GetChildren().ToList(); var httpOutputConfiguration = new HttpOutputConfiguration(); configFragments[0].Bind(httpOutputConfiguration); Assert.Equal("http://localhost:1000", httpOutputConfiguration.ServiceUri); Assert.Equal(HttpOutputFormat.JsonLines, httpOutputConfiguration.Format); Assert.Equal("mywebuser", httpOutputConfiguration.BasicAuthenticationUserName); Assert.Equal("mywebpass", httpOutputConfiguration.BasicAuthenticationUserPassword); Assert.Equal("application/x-custom", httpOutputConfiguration.HttpContentType); Assert.Equal("example", httpOutputConfiguration.Headers["X-Foo"]); } }
public void CanSaveAsOverwriteExistingFile() { using (var existing = new TemporaryFile()) { // Arrange File.WriteAllText(existing.Path, ""); // Act using (var wb = new XLWorkbook()) { var sheet = wb.Worksheets.Add("TestSheet"); wb.SaveAs(existing.Path); } // Assert Assert.IsTrue(File.Exists(existing.Path)); Assert.Greater(new FileInfo(existing.Path).Length, 0); } }
internal ServerChunkRecord(HttpxServer Server, string Id, string From, string To, HttpRequest Request, IEndToEndEncryption E2e, string EndpointReference, TemporaryFile File, int MaxChunkSize, bool Sipub, bool Ibb, bool Socks5, bool Jingle) : base() { this.server = Server; this.id = Id; this.from = From; this.to = To; this.request = Request; this.e2e = E2e; this.e2eReference = EndpointReference; this.file = File; this.maxChunkSize = MaxChunkSize; this.sipub = Sipub; this.ibb = Ibb; this.s5 = Socks5; this.jingle = Jingle; }
public void ShouldApplyDeltaToPreviousPackageToCreateNewPackage() { using (var basisFile = new TemporaryFile(PackageBuilder.BuildSamplePackage("Acme.Web", "1.0.0"))) using (var signatureFile = new TemporaryFile(basisFile.FilePath + ".octosig")) { #if USE_OCTODIFF_EXE var signatureResult = Invoke(OctoDiff() .Action("signature") .PositionalArgument(basisFile.FilePath) .PositionalArgument(signatureFile.FilePath)); signatureResult.AssertSuccess(); #else var exitCode = Octodiff.Program.Main(new[] { "signature", basisFile.FilePath, signatureFile.FilePath }); Assert.That(exitCode, Is.EqualTo(0), string.Format("Expected command to return exit code 0, received {0}", exitCode)); #endif Assert.That(File.Exists(signatureFile.FilePath)); using (var newFile = new TemporaryFile(PackageBuilder.BuildSamplePackage("Acme.Web", "1.0.1", true))) using (var deltaFile = new TemporaryFile(basisFile.FilePath + "_to_" + NewFileName + ".octodelta")) { #if USE_OCTODIFF_EXE var deltaResult = Invoke(OctoDiff() .Action("delta") .PositionalArgument(signatureFile.FilePath) .PositionalArgument(newFile.FilePath) .PositionalArgument(deltaFile.FilePath)); deltaResult.AssertSuccess(); #else var deltaExitCode = Octodiff.Program.Main(new[] { "delta", signatureFile.FilePath, newFile.FilePath, deltaFile.FilePath }); Assert.That(deltaExitCode, Is.EqualTo(0), string.Format("Expected command to return exit code 0, received {0}", exitCode)); #endif Assert.That(File.Exists(deltaFile.FilePath)); var patchResult = ApplyDelta(basisFile.FilePath, basisFile.Hash, deltaFile.FilePath, NewFileName); patchResult.AssertSuccess(); patchResult.AssertOutput("Applying delta to {0} with hash {1} and storing as {2}", basisFile.FilePath, basisFile.Hash, Path.Combine(DownloadPath, NewFileName)); patchResult.AssertServiceMessage(ServiceMessageNames.PackageDeltaVerification.Name); } } }