public void FileSystemWatcher_Directory_Delete_DeepDirectoryStructure() { // List of created directories List<TempDirectory> lst = new List<TempDirectory>(); using (var testDirectory = new TempDirectory(GetTestFilePath())) using (var dir = new TempDirectory(Path.Combine(testDirectory.Path, "dir"))) using (var watcher = new FileSystemWatcher(dir.Path, "*")) { watcher.IncludeSubdirectories = true; watcher.NotifyFilter = NotifyFilters.DirectoryName; // Priming directory lst.Add(new TempDirectory(Path.Combine(dir.Path, "dir"))); // Create a deep directory structure and expect things to work for (int i = 1; i < 20; i++) { // Test that the creation triggers an event correctly string dirPath = Path.Combine(lst[i - 1].Path, String.Format("dir{0}", i)); Action action = () => Directory.Delete(dirPath); Action cleanup = () => Directory.CreateDirectory(dirPath); cleanup(); ExpectEvent(watcher, WatcherChangeTypes.Deleted, action, cleanup); // Create the directory so subdirectories may be created from it. lst.Add(new TempDirectory(dirPath)); } } }
public void ctor_string_bool() { using (var temp = new TempDirectory()) { Assert.NotNull(new DirectoryCreateCommand(temp.Info.FullName, true)); } }
public void transaction_Complete() { try { using (var temp = new TempDirectory()) { var path = temp.Info.ToDirectory("example").FullName; Recovery.MasterDirectory = temp.Info.ToDirectory("Recovery"); using (var scope = new TransactionScope()) { var obj = new DerivedDurableEnlistmentNotification(Guid.NewGuid(), EnlistmentOptions.None); obj.Operation.Commands.Add(new DirectoryCreateCommand(path)); scope.Complete(); } Assert.True(new DirectoryInfo(path).Exists); Thread.Sleep(1000); } } finally { Recovery.MasterDirectory = null; } }
public static TempFile CreateCSharpAnalyzerAssemblyWithTestAnalyzer(TempDirectory dir, string assemblyName) { var analyzerSource = @" using System; using System.Collections.Immutable; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.Diagnostics; [DiagnosticAnalyzer(LanguageNames.CSharp)] public class TestAnalyzer : DiagnosticAnalyzer { public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { throw new NotImplementedException(); } } public override void Initialize(AnalysisContext context) { throw new NotImplementedException(); } }"; dir.CopyFile(typeof(System.Reflection.Metadata.MetadataReader).Assembly.Location); var immutable = dir.CopyFile(typeof(ImmutableArray).Assembly.Location); var analyzer = dir.CopyFile(typeof(DiagnosticAnalyzer).Assembly.Location); dir.CopyFile(Path.Combine(Path.GetDirectoryName(typeof(CSharpCompilation).Assembly.Location), "System.IO.FileSystem.dll")); var analyzerCompilation = CSharpCompilation.Create( assemblyName, new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(analyzerSource) }, new MetadataReference[] { TestReferences.NetStandard13.SystemRuntime, MetadataReference.CreateFromFile(immutable.Path), MetadataReference.CreateFromFile(analyzer.Path) }, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); return dir.CreateFile(assemblyName + ".dll").WriteAllBytes(analyzerCompilation.EmitToArray()); }
public void FileSystemWatcher_File_NotifyFilter_Attributes(NotifyFilters filter) { using (var testDirectory = new TempDirectory(GetTestFilePath())) using (var file = new TempFile(Path.Combine(testDirectory.Path, "file"))) using (var watcher = new FileSystemWatcher(testDirectory.Path, Path.GetFileName(file.Path))) { watcher.NotifyFilter = filter; var attributes = File.GetAttributes(file.Path); Action action = () => File.SetAttributes(file.Path, attributes | FileAttributes.ReadOnly); Action cleanup = () => File.SetAttributes(file.Path, attributes); WatcherChangeTypes expected = 0; if (filter == NotifyFilters.Attributes) expected |= WatcherChangeTypes.Changed; else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && ((filter & LinuxFiltersForAttribute) > 0)) expected |= WatcherChangeTypes.Changed; else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && ((filter & OSXFiltersForModify) > 0)) expected |= WatcherChangeTypes.Changed; else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && ((filter & NotifyFilters.Security) > 0)) expected |= WatcherChangeTypes.Changed; // Attribute change on OSX is a ChangeOwner operation which passes the Security NotifyFilter. ExpectEvent(watcher, expected, action, cleanup, file.Path); } }
public void SetUp() { kernel = new StandardKernel(); tmp = new TempDirectory(); rootDir = new LocalFileSystemDirectory(tmp); using (var writer = rootDir.CreateTextFile("file1")) writer.WriteLine("Contents of file 1"); using (var writer = rootDir.CreateTextFile("file2")) writer.WriteLine("Contents of file 2"); using (var writer = rootDir.CreateTextFile("file3")) writer.WriteLine("Contents of file 3"); sourceSet1 = new SourceSet("test1"); sourceSet1.Add(new SuiteRelativePath("file1")); sourceSet1.Add(new SuiteRelativePath("file2")); sourceSet2 = new SourceSet("test2"); sourceSet2.Add(new SuiteRelativePath("file1")); sourceSet2.Add(new SuiteRelativePath("file3")); kernel.Bind<IFileSystemDirectory>().ToConstant(rootDir).WhenTargetHas<SuiteRootAttribute>(); var factoryMock = new Mock<ISourceSetFingerprintFactory>(); factoryMock.Setup( f => f.CreateSourceSetFingerprint(It.IsAny<IEnumerable<SuiteRelativePath>>(), It.IsAny<Func<string, bool>>(), It.IsAny<bool>())) .Returns<IEnumerable<SuiteRelativePath>, Func<string, bool>, bool>( (files, exclusions, fullDependency) => new SourceSetFingerprint(rootDir, files, exclusions, fullDependency)); fingerprintFactory = factoryMock.Object; }
public void ctor() { using (var directory = new TempDirectory()) { Assert.NotNull(directory); } }
public void op_Do() { try { using (var temp = new TempDirectory()) { Recovery.MasterDirectory = temp.Info.ToDirectory("Recovery"); var path1 = temp.Info.ToDirectory("1").FullName; var path2 = temp.Info.ToDirectory("2").FullName; var obj = new Operation(Guid.NewGuid()) { Info = Guid.NewGuid().ToString() }; obj.Commands.Add(new DirectoryCreateCommand(path1)); obj.Commands.Add(new DirectoryCreateCommand(path2)); Assert.True(obj.Do()); Assert.True(new DirectoryInfo(path1).Exists); Assert.True(new DirectoryInfo(path2).Exists); } } finally { Recovery.MasterDirectory = null; } }
public FileSystemWatchingBundleRebuilder_Tests() { tempDirectory = new TempDirectory(); Directory.CreateDirectory(Path.Combine(tempDirectory, "cache")); var settings = new CassetteSettings { SourceDirectory = new FileSystemDirectory(tempDirectory), CacheDirectory = new FileSystemDirectory(Path.Combine(tempDirectory, "cache")), IsFileSystemWatchingEnabled = true }; bundles = new BundleCollection(settings, Mock.Of<IFileSearchProvider>(), Mock.Of<IBundleFactoryProvider>()); bundleConfiguration = new Mock<IConfiguration<BundleCollection>>(); var bundle = new TestableBundle("~"); var asset1 = new StubAsset("~/test.js"); var asset2 = new StubAsset("~/sub/test2.js"); asset1.AddRawFileReference("~/image.png"); bundle.Assets.Add(asset1); bundle.Assets.Add(asset2); bundles.Add(bundle); fileSearch = new Mock<IFileSearch>(); fileSearch .Setup(s => s.IsMatch(It.IsAny<string>())) .Returns<string>(path => path.EndsWith(".js")); var initializer = new BundleCollectionInitializer(new[] { bundleConfiguration.Object }, new ExternalBundleGenerator(Mock.Of<IBundleFactoryProvider>(), settings)); rebuilder = new FileSystemWatchingBundleRebuilder(settings, bundles, initializer, new[] { fileSearch.Object }); }
private void CopyProjectToTempDir(string projectDir, TempDirectory tempDir) { foreach (var file in Directory.EnumerateFiles(projectDir)) { tempDir.CopyFile(file); } }
public void ItPersistsArgumentsInFile( string containerDirectory, string machineIp, string syslogHostIp, string syslogPort, string machineName) { using(var tempDirectory = new TempDirectory()) { var configurationManager = new ConfigurationManagerTest(); var context = new InstallContext(); context.Parameters.Add("CONTAINER_DIRECTORY", containerDirectory); context.Parameters.Add("MACHINE_IP", machineIp); context.Parameters.Add("SYSLOG_HOST_IP", syslogHostIp); context.Parameters.Add("SYSLOG_PORT", syslogPort); context.Parameters.Add("assemblypath", tempDirectory.ToString()); context.Parameters.Add("MACHINE_NAME", machineName); configurationManager.Context = context; configurationManager.OnBeforeInstall(null); var javaScriptSerializer = new System.Web.Script.Serialization.JavaScriptSerializer(); var jsonString = File.ReadAllText(Path.Combine(tempDirectory.ToString(), @"..\parameters.json")); var hash = javaScriptSerializer.Deserialize<Dictionary<string, string>>(jsonString); Assert.Equal(hash["CONTAINER_DIRECTORY"], containerDirectory); Assert.Equal(hash["MACHINE_IP"], machineIp); Assert.Equal(hash["SYSLOG_HOST_IP"], syslogHostIp); Assert.Equal(hash["SYSLOG_PORT"], syslogPort); Assert.Equal(hash["MACHINE_NAME"], machineName); } }
public void Constructor_NoParent_CreatesTempDirectory() { using (var tempDir = new TempDirectory()) { Assert.IsTrue(Directory.Exists(tempDir)); } }
public void op_Run_DirectoryInfo_TextWriter() { using (var temp = new TempDirectory()) { var log = temp.Info.ToFile("log.txt"); using (var stream = File.Open(log.FullName, FileMode.CreateNew, FileAccess.Write, FileShare.Read)) { using (var writer = new StreamWriter(stream)) { var mock = new Mock<IRunTest>(); // ReSharper disable AccessToDisposedClosure mock .Setup(x => x.Run(temp.Info, writer)) .Returns(true) .Verifiable(); // ReSharper restore AccessToDisposedClosure Assert.True(mock.Object.Run(temp.Info, writer)); mock.VerifyAll(); } } } }
public void ctor_DirectoryInfo() { using (var directory = new TempDirectory(new DirectoryInfo("C:\\").Root)) { Assert.NotNull(directory); } }
public BundleCollectionCache_Write_Tests() { path = new TempDirectory(); directory = new FileSystemDirectory(path); var bundles = new BundleCollection(new CassetteSettings(), Mock.Of<IFileSearchProvider>(), Mock.Of<IBundleFactoryProvider>()); scriptBundle = new Mock<ScriptBundle>("~/test1"); scriptBundle.CallBase = true; scriptBundle.Object.Hash = new byte[] { 1, 2, 3 }; scriptBundle.Object.Assets.Add(new StubAsset("~/test/asset.js", "script-bundle-content")); scriptBundle.Object.Renderer = new ScriptBundleHtmlRenderer(Mock.Of<IUrlGenerator>()); scriptBundle.Setup(b => b.Render()).Returns(""); bundles.Add(scriptBundle.Object); stylesheetBundle = new Mock<StylesheetBundle>("~/test2"); stylesheetBundle.CallBase = true; stylesheetBundle.Object.Hash = new byte[] { 4, 5, 6 }; stylesheetBundle.Object.Assets.Add(new StubAsset("~/test2/asset.css", "stylesheet-bundle-content")); stylesheetBundle.Object.Renderer = new StylesheetHtmlRenderer(Mock.Of<IUrlGenerator>()); stylesheetBundle.Setup(b => b.Render()).Returns(""); bundles.Add(stylesheetBundle.Object); var cache = new BundleCollectionCache(directory, b => null); cache.Write(new Manifest(bundles, "VERSION")); }
public void ctor_DirectoryInfo_bool() { using (var temp = new TempDirectory()) { Assert.NotNull(new DirectoryCreateCommand(temp.Info, true)); } }
public void ctor_DirectoryInfo_string_SearchOption() { using (var temp = new TempDirectory()) { Assert.NotNull(new DerivedFileReceiverTask(temp.Info, "*.txt", SearchOption.TopDirectoryOnly)); } }
public void FileSystemWatcher_File_Delete_DeepDirectoryStructure() { // List of created directories List<TempDirectory> lst = new List<TempDirectory>(); using (var testDirectory = new TempDirectory(GetTestFilePath())) using (var dir = new TempDirectory(Path.Combine(testDirectory.Path, "dir"))) using (var watcher = new FileSystemWatcher(dir.Path, "*")) { watcher.IncludeSubdirectories = true; watcher.NotifyFilter = NotifyFilters.FileName; // Create a deep directory structure lst.Add(new TempDirectory(Path.Combine(dir.Path, "dir"))); for (int i = 1; i < 20; i++) { string dirPath = Path.Combine(lst[i - 1].Path, String.Format("dir{0}", i)); lst.Add(new TempDirectory(dirPath)); } // Put a file at the very bottom and expect it to raise an event string fileName = Path.Combine(lst[lst.Count - 1].Path, "file"); Action action = () => File.Delete(fileName); Action cleanup = () => File.Create(fileName).Dispose(); cleanup(); ExpectEvent(watcher, WatcherChangeTypes.Deleted, action, cleanup, fileName); } }
public void op_Dispose_whenContainsDirectory() { using (var directory = new TempDirectory()) { var example = directory.Info.CreateSubdirectory("example"); example.CreateSubdirectory(Guid.NewGuid().ToString()); } }
public void TempDirectory_FullName_ReturnsExistingDirectory() { var tempDirectory = new TempDirectory(); var directory = tempDirectory.FullName; Assert.IsTrue(Directory.Exists(directory)); }
public void GetRandomDirectory(IsolatedStorageScope scope) { using (var temp = new TempDirectory()) { string randomDir = Helper.GetRandomDirectory(temp.Path, scope); Assert.True(Directory.Exists(randomDir)); } }
public void op_ToCsvFile_DirectoryInfo_stringEmpty() { using (var temp = new TempDirectory()) { // ReSharper disable once AccessToDisposedClosure Assert.Throws<ArgumentOutOfRangeException>(() => temp.Info.ToCsvFile(string.Empty)); } }
public ScriptExecutorTests() { _root = Temp.CreateDirectory(); var sourceTestProjectPath = Path.Combine(s_testProjectRoot, "TestApp"); binTestProjectPath = _root.CopyDirectory(sourceTestProjectPath).Path; project = ProjectContext.Create(binTestProjectPath, NuGetFramework.Parse("netstandardapp1.5")).ProjectFile; }
public void op_ToCsvFile_DirectoryInfo_stringNull() { using (var temp = new TempDirectory()) { // ReSharper disable once AccessToDisposedClosure Assert.Throws<ArgumentNullException>(() => temp.Info.ToCsvFile(null as string)); } }
public void op_Load_FileInfoNotFound() { using (var temp = new TempDirectory()) { var file = temp.Info.ToFile("sabc.csv"); Assert.Throws<FileNotFoundException>(() => BritishTelephoneNumberPlan.Load(file)); } }
public void op_PackageReference_PackageNull() { using (var temp = new TempDirectory()) { var obj = ProjectFile.Create(temp.Info.ToFile("example.csproj")); Assert.Throws<ArgumentNullException>(() => obj.PackageReference(null)); } }
public void TempDirectory_CallingDispose_DeletesDirectory() { var tempDirectory = new TempDirectory(); var directory = tempDirectory.FullName; tempDirectory.Dispose(); Assert.IsFalse(Directory.Exists(directory)); }
public void ctor_FileInfoMissing() { using (var temp = new TempDirectory()) { // ReSharper disable AccessToDisposedClosure Assert.Throws<FileNotFoundException>(() => new TsvDataFile(temp.Info.ToFile("missing.txt"))); // ReSharper restore AccessToDisposedClosure } }
public void TempDirectory_FullNameCalledTwice_ReturnsSameName() { var tempDirectory = new TempDirectory(); var directory1 = tempDirectory.FullName; var directory2 = tempDirectory.FullName; Assert.AreEqual(directory1, directory2); }
void it_creates_and_deletes_a_temporary_directory_accessible_as_path_string() { string path; using (var tmp = new TempDirectory()) { path = tmp.PathString(); Directory.Exists(path).should_be_true(); } Directory.Exists(path).should_be_false(); }
public void FileSystemWatcher_File_NotifyFilter_Security(NotifyFilters filter) { using (var testDirectory = new TempDirectory(GetTestFilePath())) using (var file = new TempFile(Path.Combine(testDirectory.Path, "file"))) using (var watcher = new FileSystemWatcher(testDirectory.Path, Path.GetFileName(file.Path))) { watcher.NotifyFilter = filter; Action action = () => { // ACL support is not yet available, so pinvoke directly. uint result = SetSecurityInfoByHandle(file.Path, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, // Only setting the DACL owner: IntPtr.Zero, group: IntPtr.Zero, dacl: IntPtr.Zero, // full access to everyone sacl: IntPtr.Zero); Assert.Equal(ERROR_SUCCESS, result); }; Action cleanup = () => { // Recreate the file. File.Delete(file.Path); File.AppendAllText(file.Path, "text"); }; WatcherChangeTypes expected = 0; if (filter == NotifyFilters.Security) { expected |= WatcherChangeTypes.Changed; } else if (PlatformDetection.IsWindows7 && filter == NotifyFilters.Attributes) // win7 FSW Security change passes the Attribute filter { expected |= WatcherChangeTypes.Changed; } ExpectEvent(watcher, expected, action, expectedPath: file.Path); } }
public CreateBundlesWithRawFilesTests() { root = new TempDirectory(); CreateDirectory("source"); CreateDirectory("source\\bin"); CreateDirectory("output"); WriteFile("source\\test.css", @"p { background: url(test.png); } .other { background: url(notfound.png); }"); WriteFile("source\\test.png", "image"); var configurationDll = CompileConfigurationDll(); File.Move(configurationDll, PathUtilities.Combine(root, "source", "bin", "test.dll")); File.Copy("Cassette.dll", PathUtilities.Combine(root, "source", "bin", "Cassette.dll")); File.Copy("Cassette.pdb", PathUtilities.Combine(root, "source", "bin", "Cassette.pdb")); File.Copy("AjaxMin.dll", PathUtilities.Combine(root, "source", "bin", "AjaxMin.dll")); #if NET35 File.Copy("Iesi.Collections.dll", PathUtilities.Combine(root, "source", "bin", "Iesi.Collections.dll")); #endif buildEngine = new BuildEngineStub(); var task = new CreateBundles { BuildEngine = buildEngine }; var taskLoggingHelper = new TaskLoggingHelper(task); var command = new CreateBundlesCommand( PathUtilities.Combine(root, "source"), PathUtilities.Combine(root, "source", "bin"), PathUtilities.Combine(root, "output"), true, taskLoggingHelper ); CreateBundlesCommand.ExecuteInSeparateAppDomain(command); }
public async Task ProxyMetadata_WhenProxyFileChanges_IsRefreshed() { using (var tempDirectory = new TempDirectory()) { var testProxiesPath = Path.Combine(Environment.CurrentDirectory, @"TestScripts\Proxies"); var options = new OptionsWrapper <ScriptJobHostOptions>(new ScriptJobHostOptions { RootScriptPath = tempDirectory.Path }); var environment = new TestEnvironment(); var eventManager = new ScriptEventManager(); var provider = new ProxyFunctionProvider(options, environment, eventManager, NullLoggerFactory.Instance); // Get metadata before proxies exist ImmutableArray <FunctionMetadata> proxyMetadata1 = await provider.GetFunctionMetadataAsync(); ImmutableArray <FunctionMetadata> proxyMetadata2 = await provider.GetFunctionMetadataAsync(); Assert.True(proxyMetadata2.IsDefaultOrEmpty); Assert.True(proxyMetadata1.IsDefaultOrEmpty); // Update our proxies definition FileUtility.CopyDirectory(testProxiesPath, tempDirectory.Path); // Simulate a file change notification eventManager.Publish(new FileEvent(EventSources.ScriptFiles, new FileSystemEventArgs(WatcherChangeTypes.Changed, tempDirectory.Path, ScriptConstants.ProxyMetadataFileName))); ImmutableArray <FunctionMetadata> proxyMetadata3 = await provider.GetFunctionMetadataAsync(); var proxyClient = (proxyMetadata3.FirstOrDefault() as ProxyFunctionMetadata).ProxyClient; Assert.True(proxyMetadata3.Select(p => (p as ProxyFunctionMetadata).ProxyClient).All(c => c.Equals(proxyClient))); Assert.Equal(20, proxyMetadata3.Length); } }
public async Task GetFunctiontSecrets_WhenNonDecryptedSecrets_SavesAndRefreshes() { using (var directory = new TempDirectory()) { string functionName = "testfunction"; string expectedTraceMessage = string.Format(Resources.TraceNonDecryptedFunctionSecretRefresh, functionName); string functionSecretsJson = @"{ 'keys': [ { 'name': 'Key1', 'value': 'cryptoError', 'encrypted': true }, { 'name': 'Key2', 'value': '1234', 'encrypted': false } ] }"; File.WriteAllText(Path.Combine(directory.Path, functionName + ".json"), functionSecretsJson); Mock <IKeyValueConverterFactory> mockValueConverterFactory = GetConverterFactoryMock(true, false); IDictionary <string, string> functionSecrets; ISecretsRepository repository = new FileSystemSecretsRepository(directory.Path); using (var secretManager = new SecretManager(repository, mockValueConverterFactory.Object, null)) { functionSecrets = await secretManager.GetFunctionSecretsAsync(functionName); } Assert.NotNull(functionSecrets); Assert.Equal(functionSecrets["Key1"], "cryptoError"); var result = JsonConvert.DeserializeObject <FunctionSecrets>(File.ReadAllText(Path.Combine(directory.Path, functionName + ".json"))); Assert.Equal(result.GetFunctionKey("Key1", functionName).Value, "!cryptoError"); Assert.Equal(1, Directory.GetFiles(directory.Path, $"{functionName}.{ScriptConstants.Snapshot}*").Length); } }
public void PlaytimeImportTest() { var gameId = "tesId"; var libPlugin = new Mock <ILibraryPlugin>(); var timeToImport = 500; libPlugin.Setup(a => a.Id).Returns(Guid.NewGuid()); libPlugin.Setup(a => a.GetGames()).Returns(() => new List <Game> { new Game() { GameId = gameId, Playtime = timeToImport, PluginId = libPlugin.Object.Id } }); using (var temp = TempDirectory.Create()) { var db = new GameDatabase(temp.TempPath); db.OpenDatabase(); GameLibrary.ImportGames(libPlugin.Object, db, true); Assert.AreEqual(timeToImport, db.Games.First().Playtime); timeToImport = 600; GameLibrary.ImportGames(libPlugin.Object, db, false); Assert.AreEqual(500, db.Games.First().Playtime); GameLibrary.ImportGames(libPlugin.Object, db, true); Assert.AreEqual(timeToImport, db.Games.First().Playtime); var g = db.Games.First(); g.Playtime = 0; db.Games.Update(g); Assert.AreEqual(0, db.Games.First().Playtime); GameLibrary.ImportGames(libPlugin.Object, db, false); Assert.AreEqual(timeToImport, db.Games.First().Playtime); } }
public void Add_Directory(TarFormat format, bool withContents) { using TempDirectory root = new TempDirectory(); string dirName = "dir"; string dirPath = Path.Join(root.Path, dirName); Directory.CreateDirectory(dirPath); if (withContents) { // Add a file inside the directory, we need to ensure the contents // of the directory are ignored when using AddFile File.Create(Path.Join(dirPath, "file.txt")).Dispose(); } using MemoryStream archive = new MemoryStream(); using (TarWriter writer = new TarWriter(archive, format, leaveOpen: true)) { writer.WriteEntry(fileName: dirPath, entryName: dirName); } archive.Seek(0, SeekOrigin.Begin); using (TarReader reader = new TarReader(archive)) { Assert.Equal(TarFormat.Unknown, reader.Format); TarEntry entry = reader.GetNextEntry(); Assert.Equal(format, reader.Format); Assert.NotNull(entry); Assert.Equal(dirName, entry.Name); Assert.Equal(TarEntryType.Directory, entry.EntryType); Assert.Null(entry.DataStream); VerifyPlatformSpecificMetadata(dirPath, entry); Assert.Null(reader.GetNextEntry()); // If the dir had contents, they should've been excluded } }
public void Add_Fifo(TarEntryFormat format) { RemoteExecutor.Invoke((string strFormat) => { TarEntryFormat expectedFormat = Enum.Parse <TarEntryFormat>(strFormat); using TempDirectory root = new TempDirectory(); string fifoName = "fifofile"; string fifoPath = Path.Join(root.Path, fifoName); Interop.CheckIo(Interop.Sys.MkFifo(fifoPath, (int)DefaultMode)); using MemoryStream archive = new MemoryStream(); using (TarWriter writer = new TarWriter(archive, expectedFormat, leaveOpen: true)) { writer.WriteEntry(fileName: fifoPath, entryName: fifoName); } archive.Seek(0, SeekOrigin.Begin); using (TarReader reader = new TarReader(archive)) { PosixTarEntry entry = reader.GetNextEntry() as PosixTarEntry; Assert.Equal(expectedFormat, entry.Format); Assert.NotNull(entry); Assert.Equal(fifoName, entry.Name); Assert.Equal(DefaultLinkName, entry.LinkName); Assert.Equal(TarEntryType.Fifo, entry.EntryType); Assert.Null(entry.DataStream); VerifyPlatformSpecificMetadata(fifoPath, entry); Assert.Null(reader.GetNextEntry()); } }, format.ToString(), new RemoteInvokeOptions { RunAsSudo = true }).Dispose(); }
public async Task SpecialFile_Unelevated_Throws_Async() { using TempDirectory root = new TempDirectory(); using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, TestTarFormat.ustar, "specialfiles"); TarReader reader = new TarReader(ms); await using (reader) { string path = Path.Join(root.Path, "output"); // Block device requires elevation for writing PosixTarEntry blockDevice = await reader.GetNextEntryAsync() as PosixTarEntry; Assert.NotNull(blockDevice); await Assert.ThrowsAsync <UnauthorizedAccessException>(() => blockDevice.ExtractToFileAsync(path, overwrite: false)); Assert.False(File.Exists(path)); // Character device requires elevation for writing PosixTarEntry characterDevice = await reader.GetNextEntryAsync() as PosixTarEntry; Assert.NotNull(characterDevice); await Assert.ThrowsAsync <UnauthorizedAccessException>(() => characterDevice.ExtractToFileAsync(path, overwrite: false)); Assert.False(File.Exists(path)); // Fifo does not require elevation, should succeed PosixTarEntry fifo = await reader.GetNextEntryAsync() as PosixTarEntry; Assert.NotNull(fifo); await fifo.ExtractToFileAsync(path, overwrite : false); Assert.True(File.Exists(path)); Assert.Null(await reader.GetNextEntryAsync()); } }
public async Task MultiRepo_WorksWithCloning() { using var projectDirectory = TempDirectory.Create(preferUserDirectoryOnMacOS: true); var content = @" name: VotingSample services: - name: vote repository: https://github.com/jkotalik/TyeMultiRepoVoting - name: results repository: https://github.com/jkotalik/TyeMultiRepoResults"; var yamlFile = Path.Combine(projectDirectory.DirectoryPath, "tye.yaml"); await File.WriteAllTextAsync(yamlFile, content); // Debug targets can be null if not specified, so make sure calling host.Start does not throw. var outputContext = new OutputContext(_sink, Verbosity.Debug); var application = await ApplicationFactory.CreateAsync(outputContext, new FileInfo(yamlFile)); var handler = new HttpClientHandler { ServerCertificateCustomValidationCallback = (a, b, c, d) => true, AllowAutoRedirect = false }; var client = new HttpClient(new RetryHandler(handler)); await RunHostingApplication(application, Array.Empty <string>(), async (app, uri) => { var votingUri = await GetServiceUrl(client, uri, "vote"); var workerUri = await GetServiceUrl(client, uri, "worker"); var votingResponse = await client.GetAsync(votingUri); var workerResponse = await client.GetAsync(workerUri); Assert.True(votingResponse.IsSuccessStatusCode); Assert.Equal(HttpStatusCode.NotFound, workerResponse.StatusCode); }); }
public async Task GetFunctiontSecrets_AddsMetrics() { using (var directory = new TempDirectory()) { string functionName = "testfunction"; string functionSecretsJson = @"{ 'keys': [ { 'name': 'Key1', 'value': 'cryptoError', 'encrypted': true }, { 'name': 'Key2', 'value': '1234', 'encrypted': false } ] }"; File.WriteAllText(Path.Combine(directory.Path, functionName + ".json"), functionSecretsJson); Mock <IKeyValueConverterFactory> mockValueConverterFactory = GetConverterFactoryMock(true, false); IDictionary <string, string> functionSecrets; ISecretsRepository repository = new FileSystemSecretsRepository(directory.Path); TestMetricsLogger metricsLogger = new TestMetricsLogger(); using (var secretManager = new SecretManager(repository, mockValueConverterFactory.Object, null, metricsLogger)) { functionSecrets = await secretManager.GetFunctionSecretsAsync(functionName); } string eventName = string.Format(MetricEventNames.SecretManagerGetFunctionSecrets, repository.GetType().Name.ToLower()); metricsLogger.EventsBegan.Single(e => e.StartsWith(eventName)); metricsLogger.EventsBegan.Single(e => e.Contains("testfunction")); metricsLogger.EventsEnded.Single(e => e.ToString().StartsWith(eventName)); metricsLogger.EventsEnded.Single(e => e.ToString().Contains("testfunction")); } }
public void FileSystemWatcher_File_Rename_NotAffectEachOther() { ExecuteWithRetry(() => { using (var testDirectory = new TempDirectory(GetTestFilePath())) using (var file = new TempFile(Path.Combine(testDirectory.Path, "file"))) using (var watcher1 = new FileSystemWatcher(testDirectory.Path, Path.GetFileName(file.Path))) using (var watcher2 = new FileSystemWatcher(testDirectory.Path, Path.GetFileName(file.Path))) { AutoResetEvent autoResetEvent1_created = WatchCreated(watcher1, new[] { Path.Combine(testDirectory.Path, "file") }).EventOccured; AutoResetEvent autoResetEvent1_deleted = WatchDeleted(watcher1, new[] { Path.Combine(testDirectory.Path, "file") }).EventOccured; AutoResetEvent autoResetEvent2_created = WatchCreated(watcher2, new[] { Path.Combine(testDirectory.Path, "file") }).EventOccured; AutoResetEvent autoResetEvent2_deleted = WatchDeleted(watcher2, new[] { Path.Combine(testDirectory.Path, "file") }).EventOccured; watcher1.EnableRaisingEvents = true; watcher2.EnableRaisingEvents = true; string filePath = file.Path; string filePathRenamed = file.Path + "_renamed"; File.Move(filePath, filePathRenamed); Assert.True(WaitHandle.WaitAll( new[] { autoResetEvent1_created, autoResetEvent1_deleted, autoResetEvent2_created, autoResetEvent2_deleted }, WaitForExpectedEventTimeout_NoRetry)); File.Move(filePathRenamed, filePath); watcher1.EnableRaisingEvents = false; File.Move(filePath, filePathRenamed); Assert.False(WaitHandle.WaitAll( new[] { autoResetEvent1_created, autoResetEvent1_deleted }, WaitForUnexpectedEventTimeout)); Assert.True(WaitHandle.WaitAll( new[] { autoResetEvent2_created, autoResetEvent2_deleted }, WaitForExpectedEventTimeout_NoRetry)); } }); }
public async Task ShadowCopySingleFileChangedWorks() { using var directory = TempDirectory.Create(); var deploymentParameters = Fixture.GetBaseDeploymentParameters(); deploymentParameters.HandlerSettings["experimentalEnableShadowCopy"] = "true"; deploymentParameters.HandlerSettings["shadowCopyDirectory"] = directory.DirectoryPath; var deploymentResult = await DeployAsync(deploymentParameters); DirectoryCopy(deploymentResult.ContentRoot, directory.DirectoryPath, copySubDirs: true); var response = await deploymentResult.HttpClient.GetAsync("Wow!"); Assert.True(response.IsSuccessStatusCode); // Rewrite file var dirInfo = new DirectoryInfo(deploymentResult.ContentRoot); string dllPath = ""; foreach (var file in dirInfo.EnumerateFiles()) { if (file.Extension == ".dll") { dllPath = file.FullName; break; } } var fileContents = File.ReadAllBytes(dllPath); File.WriteAllBytes(dllPath, fileContents); await deploymentResult.AssertRecycledAsync(); response = await deploymentResult.HttpClient.GetAsync("Wow!"); Assert.True(response.IsSuccessStatusCode); }
public void Save_throws_when_existing_files() { using (var directory = new TempDirectory()) { var contextPath = Path.Combine(directory.Path, "TestContext.cs"); File.WriteAllText(contextPath, "// Old"); var entityTypePath = Path.Combine(directory.Path, "TestEntity.cs"); File.WriteAllText(entityTypePath, "// Old"); var scaffolder = CreateScaffolder(); var scaffoldedModel = new ScaffoldedModel { ContextFile = new ScaffoldedFile { Path = "TestContext.cs", Code = "// TestContext" }, AdditionalFiles = { new ScaffoldedFile { Path = "TestEntity.cs", Code = "// TestEntity" } } }; var ex = Assert.Throws <OperationException>( () => scaffolder.Save(scaffoldedModel, directory.Path, overwriteFiles: false)); Assert.Equal( DesignStrings.ExistingFiles( directory.Path, string.Join(CultureInfo.CurrentCulture.TextInfo.ListSeparator, "TestContext.cs", "TestEntity.cs")), ex.Message); } }
public async Task FrontendBackendRunTest() { var projectDirectory = new DirectoryInfo(Path.Combine(TestHelpers.GetSolutionRootDirectory("tye"), "samples", "frontend-backend")); using var tempDirectory = TempDirectory.Create(); DirectoryCopy.Copy(projectDirectory.FullName, tempDirectory.DirectoryPath); var projectFile = new FileInfo(Path.Combine(tempDirectory.DirectoryPath, "tye.yaml")); var outputContext = new OutputContext(_sink, Verbosity.Debug); var application = await ApplicationFactory.CreateAsync(outputContext, projectFile); using var host = new TyeHost(application.ToHostingApplication(), Array.Empty <string>()) { Sink = _sink, }; await host.StartAsync(); try { var handler = new HttpClientHandler { ServerCertificateCustomValidationCallback = (a, b, c, d) => true, AllowAutoRedirect = false }; var client = new HttpClient(new RetryHandler(handler)); var dashboardUri = new Uri(host.DashboardWebApplication !.Addresses.First()); await CheckServiceIsUp(host.Application, client, "backend", dashboardUri); await CheckServiceIsUp(host.Application, client, "frontend", dashboardUri); } finally { await host.StopAsync(); } }
public async Task CachedSecrets_UsedWhenPresent() { using (var directory = new TempDirectory()) { string startupContextPath = Path.Combine(directory.Path, Guid.NewGuid().ToString()); _testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteStartupContextCache, startupContextPath); _testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.WebSiteAuthEncryptionKey, TestEncryptionKey); WriteStartContextCache(startupContextPath); using (var secretManager = CreateSecretManager(directory.Path)) { var functionSecrets = await secretManager.GetFunctionSecretsAsync("function1", true); Assert.Equal(4, functionSecrets.Count); Assert.Equal("function1value", functionSecrets["test-function-1"]); Assert.Equal("function2value", functionSecrets["test-function-2"]); Assert.Equal("hostfunction1value", functionSecrets["test-host-function-1"]); Assert.Equal("hostfunction2value", functionSecrets["test-host-function-2"]); var hostSecrets = await secretManager.GetHostSecretsAsync(); Assert.Equal("test-master-key", hostSecrets.MasterKey); Assert.Equal(2, hostSecrets.FunctionKeys.Count); Assert.Equal("hostfunction1value", hostSecrets.FunctionKeys["test-host-function-1"]); Assert.Equal("hostfunction2value", hostSecrets.FunctionKeys["test-host-function-2"]); Assert.Equal(2, hostSecrets.SystemKeys.Count); Assert.Equal("system1value", hostSecrets.SystemKeys["test-system-1"]); Assert.Equal("system2value", hostSecrets.SystemKeys["test-system-2"]); } var logs = _loggerProvider.GetAllLogMessages(); Assert.Equal($"Sentinel watcher initialized for path {directory.Path}", logs[0].FormattedMessage); Assert.Equal($"Loading startup context from {startupContextPath}", logs[1].FormattedMessage); Assert.Equal($"Loaded keys for 2 functions from startup context", logs[2].FormattedMessage); Assert.Equal($"Loaded host keys from startup context", logs[3].FormattedMessage); } }
public void PlaytimeImportTest() { var gameId = "tesId"; var libPlugin = new Mock <LibraryPlugin>(MockBehavior.Loose, null); ulong timeToImport = 500; libPlugin.Setup(a => a.Id).Returns(Guid.NewGuid()); libPlugin.Setup(a => a.GetGames(It.IsAny <LibraryGetGamesArgs>())).Returns(() => new List <GameMetadata> { new GameMetadata() { GameId = gameId, Playtime = timeToImport } }); using (var temp = TempDirectory.Create()) using (var db = new GameDatabase(temp.TempPath)) using (var token = new CancellationTokenSource()) { db.OpenDatabase(); db.ImportGames(libPlugin.Object, true, token.Token); Assert.AreEqual(timeToImport, db.Games.First().Playtime); timeToImport = 600; db.ImportGames(libPlugin.Object, false, token.Token); Assert.AreEqual(500, db.Games.First().Playtime); db.ImportGames(libPlugin.Object, true, token.Token); Assert.AreEqual(timeToImport, db.Games.First().Playtime); var g = db.Games.First(); g.Playtime = 0; db.Games.Update(g); Assert.AreEqual(0, db.Games.First().Playtime); db.ImportGames(libPlugin.Object, false, token.Token); Assert.AreEqual(timeToImport, db.Games.First().Playtime); } }
public async Task GetSecretSnapshots_ReturnsExpected(SecretsRepositoryType repositoryType, ScriptSecretsType secretsType) { using (var directory = new TempDirectory()) { await _fixture.TestInitialize(repositoryType, directory.Path); ScriptSecrets secrets = null; if (secretsType == ScriptSecretsType.Host) { secrets = new HostSecrets() { MasterKey = new Key("master", "test") }; } else { secrets = new FunctionSecrets() { Keys = new List <Key>() { new Key(KeyName, "test") } }; } string testFunctionName = secretsType == ScriptSecretsType.Host ? null : functionName; var target = _fixture.GetNewSecretRepository(); await target.WriteAsync(secretsType, testFunctionName, secrets); for (int i = 0; i < 5; i++) { await target.WriteSnapshotAsync(secretsType, testFunctionName, secrets); } string[] files = await target.GetSecretSnapshots(secretsType, testFunctionName); Assert.True(files.Length > 0); } }
public void Save_throws_when_readonly_files() { using var directory = new TempDirectory(); var contextPath = Path.Combine(directory.Path, "TestContext.cs"); File.WriteAllText(contextPath, "// Old"); var entityTypePath = Path.Combine(directory.Path, "TestEntity.cs"); File.WriteAllText(entityTypePath, "// Old"); var originalAttributes = File.GetAttributes(contextPath); File.SetAttributes(contextPath, originalAttributes | FileAttributes.ReadOnly); File.SetAttributes(entityTypePath, originalAttributes | FileAttributes.ReadOnly); try { var scaffolder = CreateScaffolder(); var scaffoldedModel = new ScaffoldedModel(new ScaffoldedFile("TestContext.cs", "// TestContext")) { AdditionalFiles = { new ScaffoldedFile("TestEntity.cs", "// TestEntity") } }; var ex = Assert.Throws <OperationException>( () => scaffolder.Save(scaffoldedModel, directory.Path, overwriteFiles: true)); Assert.Equal( DesignStrings.ReadOnlyFiles( directory.Path, string.Join(CultureInfo.CurrentCulture.TextInfo.ListSeparator, "TestContext.cs", "TestEntity.cs")), ex.Message); } finally { File.SetAttributes(contextPath, originalAttributes); File.SetAttributes(entityTypePath, originalAttributes); } }
public async Task UsePollingFileWatcher_UseActivePolling_HasChanged_SymbolicLink_TargetDeleted(bool useWildcard) { // Arrange using var rootOfFile = new TempDirectory(GetTestFilePath()); string filePath = Path.Combine(rootOfFile.Path, GetTestFileName()); File.WriteAllText(filePath, "v1.1"); using var rootOfLink = new TempDirectory(GetTestFilePath()); string linkName = GetTestFileName(); string linkPath = Path.Combine(rootOfLink.Path, linkName); File.CreateSymbolicLink(linkPath, filePath); string filter = useWildcard ? "*" : linkName; using var provider = new PhysicalFileProvider(rootOfLink.Path) { UsePollingFileWatcher = true, UseActivePolling = true }; IChangeToken token = provider.Watch(filter); var tcs = new TaskCompletionSource <bool>(); token.RegisterChangeCallback(_ => { tcs.TrySetResult(true); }, null); var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30)); cts.Token.Register(() => tcs.TrySetCanceled()); // Act File.Delete(linkPath); // Assert Assert.True(await tcs.Task, $"Change event was not raised - current time: {DateTime.UtcNow:O}, file LastWriteTimeUtc: {File.GetLastWriteTimeUtc(filePath):O}."); }
public void Save_works_when_overwriteFiles() { using (var directory = new TempDirectory()) { var path = Path.Combine(directory.Path, "Test.cs"); File.WriteAllText(path, "// Old"); var scaffolder = CreateScaffolder(); var scaffoldedModel = new ScaffoldedModel { ContextFile = new ScaffoldedFile { Path = "Test.cs", Code = "// Test" } }; var result = scaffolder.Save(scaffoldedModel, directory.Path, outputDir: null, overwriteFiles: true); Assert.Equal(path, result.ContextFile); Assert.Equal("// Test", File.ReadAllText(path)); } }
public void XSDValidationGeneratesInvalidError_2() { using (var tempDirectory = new TempDirectory()) { Initialize(); CreateSchema2(tempDirectory.Path); XmlReaderSettings settings = new XmlReaderSettings(); settings.XmlResolver = new XmlUrlResolver(); settings.Schemas.XmlResolver = new XmlUrlResolver(); // TempDirectory path must end with a DirectorySeratorChar, otherwise it will throw in the Xml validation. settings.Schemas.Add("mainschema", XmlReader.Create(new StringReader(xsd), null, EnsureTrailingSlash(tempDirectory.Path))); settings.ValidationType = ValidationType.Schema; XmlReader reader = XmlReader.Create(new StringReader(xml), settings); XmlDocument doc = new XmlDocument(); doc.Load(reader); ValidationEventHandler valEventHandler = new ValidationEventHandler(ValidationCallback); doc.Validate(valEventHandler); Assert.Equal(0, warningCount); Assert.Equal(0, errorCount); } }
public void FileSystemWatcher_StopCalledOnBackgroundThreadDoesNotDeadlock() { // Check the case where Stop or Dispose (they do the same thing) is called from // a FSW event callback and make sure we don't Thread.Join to deadlock using (var dir = new TempDirectory(GetTestFilePath())) { string filePath = Path.Combine(dir.Path, "testfile.txt"); File.Create(filePath).Dispose(); AutoResetEvent are = new AutoResetEvent(false); FileSystemWatcher watcher = new FileSystemWatcher(Path.GetFullPath(dir.Path), "*"); FileSystemEventHandler callback = (sender, arg) => { watcher.Dispose(); are.Set(); }; watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite; watcher.Changed += callback; watcher.EnableRaisingEvents = true; File.SetLastWriteTime(filePath, File.GetLastWriteTime(filePath).AddDays(1)); Assert.True(are.WaitOne(10000)); Assert.Throws <ObjectDisposedException>(() => watcher.EnableRaisingEvents = true); } }
public void GivenAssetWithReferenceToUrl_WhenSaveContainer_ThenXmlHasReferenceElementWithUrlAsPath() { using (var cacheDir = new TempDirectory()) { var settings = new CassetteSettings("") { SourceDirectory = Mock.Of <IDirectory>(), CacheDirectory = new FileSystemDirectory(cacheDir) }; var cache = new BundleCache("VERSION", settings); var bundle = new TestableBundle("~/bundle-1"); var asset = StubAsset(); var reference = new AssetReference("http://test.com", asset.Object, -1, AssetReferenceType.Url); asset.SetupGet(a => a.References) .Returns(new[] { reference }); bundle.Assets.Add(asset.Object); cache.SaveBundleContainer(new BundleContainer(new Bundle[] { bundle, new ExternalScriptBundle("http://test.com"), })); var xml = File.ReadAllText(Path.Combine(cacheDir, "container.xml")); xml.ShouldContain("<Reference Path=\"http://test.com\" />"); } }
public void GivenAssetWithRawFilenameReference_WhenSaveContainer_ThenXmlHasFileElement() { using (var cacheDir = new TempDirectory()) { var settings = new CassetteSettings("") { SourceDirectory = Mock.Of <IDirectory>(), CacheDirectory = new FileSystemDirectory(cacheDir) }; var cache = new BundleCache("VERSION", settings); var bundle = new TestableBundle("~/bundle-1"); var asset = StubAsset(); var reference = new AssetReference("~/images/test.png", asset.Object, -1, AssetReferenceType.RawFilename); asset.SetupGet(a => a.References) .Returns(new[] { reference }); bundle.Assets.Add(asset.Object); cache.SaveBundleContainer(new BundleContainer(new[] { bundle })); var xml = File.ReadAllText(Path.Combine(cacheDir, "container.xml")); xml.ShouldContain("<File Path=\"~/images/test.png\" />"); } }
public static void DuplicateSignedAndUnsignedAssemblies() { using (TempDirectory dir = new TempDirectory()) using (TempDirectory dir2 = new TempDirectory()) using (TempFile core = new TempFile(Path.Combine(dir.Path, TestData.s_PhonyCoreAssemblySimpleName), TestData.s_PhonyCoreAssemblyImage)) using (TempFile tf1 = new TempFile(Path.Combine(dir.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleSignedVersioned100Image)) using (TempFile tf2 = new TempFile(Path.Combine(dir2.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleUnsignedVersioned100Image)) { var resolver = new PathAssemblyResolver(new string[] { core.Path, tf1.Path, tf2.Path }); using (var lc = new MetadataLoadContext(resolver, TestData.s_PhonyCoreAssemblyFullName)) { Assert.Equal(1, lc.GetAssemblies().Count()); // These are treated as different since one contains a PublicKeyToken and one does not. Assembly a1 = lc.LoadFromAssemblyName(TestData.s_SimpleUnsignedVersioned100FullName); Assembly a2 = lc.LoadFromAssemblyName(TestData.s_SimpleSignedVersioned100FullName); Assert.NotSame(a1, a2); Assert.Equal(3, lc.GetAssemblies().Count()); } } }
public async Task PurgeOldSecrets_RemovesOldAndKeepsCurrentSecrets() { using (var directory = new TempDirectory()) { Func <int, string> getFilePath = i => Path.Combine(directory.Path, $"{i}.json"); var sequence = Enumerable.Range(0, 10); var files = sequence.Select(i => getFilePath(i)).ToList(); // Create files files.ForEach(f => File.WriteAllText(f, "test")); var target = new FileSystemSecretsRepository(directory.Path); // Purge, passing even named files as the existing functions var currentFunctions = sequence.Where(i => i % 2 == 0).Select(i => i.ToString()).ToList(); await target.PurgeOldSecretsAsync(currentFunctions, new TestTraceWriter(TraceLevel.Off)); // Ensure only expected files exist Assert.True(sequence.All(i => (i % 2 == 0) == File.Exists(getFilePath(i)))); } }
public async Task RenamedInIndexFile_False_Async() { using (var tempDir = new TempDirectory()) using (var repo = CreateRepository(tempDir)) { var service = CreatePullRequestService(repo); var repositoryModel = CreateLocalRepositoryModel(repo); var path = "file.txt"; var renamedPath = "renamed.txt"; var file = Path.Combine(repo.Info.WorkingDirectory, path); var renamedFile = Path.Combine(repo.Info.WorkingDirectory, renamedPath); File.WriteAllText(file, "contents"); Commands.Stage(repo, path); repo.Commit("foo", Author, Author); File.Move(file, renamedFile); Commands.Stage(repo, path); Commands.Stage(repo, renamedPath); var count = await service.CountSubmodulesToSync(repositoryModel).FirstAsync(); Assert.That(0, Is.EqualTo(count)); } }
public async Task ShouldExposeVideoPath() { using var tempDirectory = new TempDirectory(); var context = await Browser.NewContextAsync( recordVideo : new RecordVideoOptions { Dir = tempDirectory.Path, Size = new ViewportSize { Width = 100, Height = 100 } }); var page = await context.NewPageAsync(); await page.EvaluateAsync("() => document.body.style.backgroundColor = 'red'"); string path = await page.Video.GetPathAsync(); Assert.Contains(tempDirectory.Path, path); await context.CloseAsync(); Assert.True(new FileInfo(path).Exists); }
public async Task LocalBehindRemote_ReturnRemoteCommitSha() { using (var temp = new TempDirectory()) { string expectSha; var dir = temp.Directory.FullName; using (var repo = new Repository(Repository.Init(dir))) { AddCommit(repo); // First commit var commit1 = AddCommit(repo); var commit2 = AddCommit(repo); repo.Reset(ResetMode.Hard, commit1); expectSha = commit1.Sha; AddTrackedBranch(repo, repo.Head, commit2); } var target = new GitService(new RepositoryFacade()); var sha = await target.GetLatestPushedSha(dir).ConfigureAwait(false); Assert.That(sha, Is.EqualTo(expectSha)); } }
public async Task GetExtensions_ReturnsNewlyAddedExtension() { using (var testDir = new TempDirectory()) { var manager = GetExtensionsManager(testDir.Path); var extension = new ExtensionPackageReference { Id = "Microsoft.Azure.WebJobs.Samples.Extension", Version = "1.0.0" }; await manager.AddExtensions(extension); IEnumerable <ExtensionPackageReference> extensions = await manager.GetExtensions(); Assert.Equal(1, extensions.Count()); var reference = extensions.FirstOrDefault(p => string.Equals(p.Id, extensions.First().Id)); Assert.NotNull(reference); Assert.Equal(extension.Version, reference.Version); } }