public async Task GivenThatABaseUriChangesVerifyValidationFails() { using (var target = new TestFolder()) using (var cache = new LocalCache()) { var log = new TestLogger(); var settings = new LocalSettings(); var fileSystem1 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root), UriUtility.CreateUri("https://tempuri.org/")); var fileSystem2 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root), UriUtility.CreateUri("https://tempuri.org/b/")); await InitCommand.RunAsync(settings, fileSystem1, log); await SourceUtility.EnsureBaseUriMatchesFeed(fileSystem1, log, CancellationToken.None); InvalidDataException foundEx = null; try { await SourceUtility.EnsureBaseUriMatchesFeed(fileSystem2, log, CancellationToken.None); } catch (InvalidDataException ex) { foundEx = ex; } foundEx.Message.Should().Contain("https://tempuri.org/"); } }
public async Task GivenThatIWantToDestroyAFeedVerifyAFeedWithNupkgsSucceeds() { using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) using (var cache2 = new LocalCache()) using (var outputFolder = new TestFolder()) { var log = new TestLogger(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var fileSystem2 = new PhysicalFileSystem(cache2, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); var root = new DirectoryInfo(target); await InitCommand.RunAsync(settings, fileSystem, enableCatalog : true, enableSymbols : true, log : log, token : CancellationToken.None); var packageA = new TestNupkg("a", "1.0"); var packageB = new TestNupkg("b", "2.0.0-beta+blah"); packageA.Save(packagesFolder.Root); packageB.Save(packagesFolder.Root); await PushCommand.RunAsync(settings, fileSystem, new List <string>() { packagesFolder }, false, false, log); var success = await DestroyCommand.RunAsync(settings, fileSystem2, log); var files = root.GetFiles("*", SearchOption.AllDirectories); var dirs = root.GetDirectories(); success.ShouldBeEquivalentTo(true, "the command should exit without errors"); files.Length.ShouldBeEquivalentTo(0, "all files should be gone"); dirs.Length.ShouldBeEquivalentTo(0, "all directories should be gone"); } }
public async Task GivenAStorageAccountVerifyPushSucceeds() { using (var packagesFolder = new TestFolder()) using (var testContext = new AmazonS3TestContext()) { await testContext.InitAsync(); var testPackage = new TestNupkg("packageA", "1.0.0"); var zipFile = testPackage.Save(packagesFolder.Root); var result = await InitCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, enableCatalog : true, enableSymbols : true, log : testContext.Logger, token : CancellationToken.None); result &= await PushCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, new List <string>() { zipFile.FullName }, force : false, skipExisting : false, log : testContext.Logger); result &= await ValidateCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, testContext.Logger); result.Should().BeTrue(); await testContext.CleanupAsync(); } }
public static async Task CreateCatalogAsync(string root, string feedRoot, string nupkgFolder, Uri baseUri, ILogger log) { using (var cache = new LocalCache()) { var sleetConfig = CreateSleetConfig(root, feedRoot, baseUri); var settings = LocalSettings.Load(sleetConfig); var fileSystem = FileSystemFactory.CreateFileSystem(settings, cache, "feed"); var success = await InitCommand.RunAsync(settings, fileSystem, enableCatalog : true, enableSymbols : false, log : log, token : CancellationToken.None); if (success != true) { throw new InvalidOperationException("Catalog init failed"); } if (Directory.GetFiles(nupkgFolder).Any()) { success = await PushCommand.PushPackages(settings, fileSystem, new List <string>() { nupkgFolder }, false, false, log, CancellationToken.None); if (success != true) { throw new InvalidOperationException("Push failed"); } } } }
public async Task FileSystemLock_VerifyMessageFromSettings() { using (var target = new TestFolder()) using (var cache = new LocalCache()) { var log = new TestLogger(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); settings.FeedLockMessage = "FROMSETTINGS!!"; var lockMessage = Guid.NewGuid().ToString(); await InitCommand.RunAsync(settings, fileSystem, log); var lockObj = await SourceUtility.VerifyInitAndLock(settings, fileSystem, lockMessage, log, CancellationToken.None); lockObj.IsLocked.Should().BeTrue(); var path = Path.Combine(target.Root, ".lock"); var json = JObject.Parse(File.ReadAllText(path)); json["message"].ToString().Should().Be("FROMSETTINGS!!"); json["date"].ToString().Should().NotBeNullOrEmpty(); json["pid"].ToString().Should().NotBeNullOrEmpty(); } }
public async Task Symbols_AddSymbolsPackageWithNoValidSymbolsVerifyFeed() { using (var testContext = new SleetTestContext()) { var context = testContext.SleetContext; context.SourceSettings.SymbolsEnabled = true; var symbols = new Symbols(context); var packageIndex = new PackageIndex(context); var catalog = new Catalog(context); var autoComplete = new AutoComplete(context); var flatContainer = new FlatContainer(context); var registrations = new Registrations(context); var search = new Search(context); // Create package var pkgA = new TestNupkg("a", "1.0.0"); pkgA.Nuspec.IsSymbolPackage = true; var zip = pkgA.Save(testContext.Packages); var pkgInput = testContext.GetPackageInput(zip); // Init var success = await InitCommand.RunAsync( testContext.SleetContext.LocalSettings, testContext.SleetContext.Source, enableCatalog : true, enableSymbols : true, log : testContext.SleetContext.Log, token : CancellationToken.None); // Push success &= await PushCommand.RunAsync( testContext.SleetContext.LocalSettings, testContext.SleetContext.Source, new List <string>() { zip.FullName }, force : false, skipExisting : false, log : testContext.SleetContext.Log); // Validate success &= await ValidateCommand.RunAsync( testContext.SleetContext.LocalSettings, testContext.SleetContext.Source, testContext.SleetContext.Log); success.Should().BeTrue(); // The nupkg should exist, but there should not be any assets added. (await symbols.GetSymbolsPackagesAsync()).Should().BeEmpty(); (await packageIndex.GetSymbolsPackagesAsync()).Should().NotBeEmpty(); // Verify nupkg exists var nupkgPath = Path.Combine(testContext.Target, "symbols", "packages", "a", "1.0.0", "a.1.0.0.symbols.nupkg"); File.Exists(nupkgPath).Should().BeTrue(); // Verify package details var detailsPath = Path.Combine(testContext.Target, "symbols", "packages", "a", "1.0.0", "package.json"); File.Exists(detailsPath).Should().BeTrue(); } }
private async Task <bool> InitAsync() { LocalSettings settings = GetSettings(); AzureFileSystem fileSystem = GetAzureFileSystem(); bool result = await InitCommand.RunAsync(settings, fileSystem, enableCatalog : false, enableSymbols : false, log : new SleetLogger(Log), token : CancellationToken); return(result); }
private async Task <bool> InitAsync() { LocalSettings settings = GetSettings(); AzureFileSystem fileSystem = GetAzureFileSystem(); bool result = await InitCommand.RunAsync(settings, fileSystem, true, true, new SleetLogger(Log), CancellationToken); return(result); }
public async Task GivenThatTheFeedHasMissingPackagesVerifyExistingPackagesAreDownloaded() { using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) using (var cache2 = new LocalCache()) using (var outputFolder = new TestFolder()) { var log = new TestLogger(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var fileSystem2 = new PhysicalFileSystem(cache2, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); await InitCommand.RunAsync(settings, fileSystem, log); var expected = new List <string>(); for (var i = 0; i < 100; i++) { var package = new TestNupkg("a", $"{i}.0.0"); package.Save(packagesFolder); if (i != 50) { expected.Add($"a.{i}.0.0.nupkg"); } } await PushCommand.RunAsync(settings, fileSystem, new List <string>() { packagesFolder }, false, false, log); var root = new DirectoryInfo(target); foreach (var file in root.GetFiles("a.50.0.0*", SearchOption.AllDirectories)) { // Corrupt the feed file.Delete(); } var success = await DownloadCommand.RunAsync(settings, fileSystem2, outputFolder, false, log); var fileNames = Directory.GetFiles(outputFolder, "*.nupkg", SearchOption.AllDirectories) .Select(e => Path.GetFileName(e)) .OrderBy(e => e, StringComparer.OrdinalIgnoreCase) .ToArray(); success.ShouldBeEquivalentTo(false, "the feed is not valid"); fileNames.ShouldBeEquivalentTo(expected, "all files but the deleted one"); log.GetMessages().Should().NotContain("The feed does not contain any packages"); log.GetMessages().Should().Contain("Failed to download all packages!"); foreach (var file in expected) { log.GetMessages().Should().Contain(file); } } }
public async Task GivenInitVerifyBasicOutputs() { using (var target = new TestFolder()) using (var cache = new LocalCache()) { // Arrange var log = new TestLogger(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); var indexJsonOutput = new FileInfo(Path.Combine(target.Root, "index.json")); var settingsOutput = new FileInfo(Path.Combine(target.Root, "sleet.settings.json")); var autoCompleteOutput = new FileInfo(Path.Combine(target.Root, "autocomplete", "query")); var catalogOutput = new FileInfo(Path.Combine(target.Root, "catalog", "index.json")); var searchOutput = new FileInfo(Path.Combine(target.Root, "search", "query")); var packageIndexOutput = new FileInfo(Path.Combine(target.Root, "sleet.packageindex.json")); var symbolsIndexOutput = new FileInfo(Path.Combine(target.Root, "symbols", "packages", "index.json")); // Act var success = await InitCommand.RunAsync(settings, fileSystem, enableCatalog : true, enableSymbols : true, log : log, token : CancellationToken.None); var rootFile = fileSystem.Get("index.json"); var rootJson = await rootFile.GetJson(log, CancellationToken.None); success &= await FeedSettingsCommand.RunAsync( settings, fileSystem, unsetAll : false, getAll : true, getSettings : new string[] { }, unsetSettings : new string[] { }, setSettings : new string[] { }, log : log, token : CancellationToken.None); // Assert success.Should().BeTrue(); indexJsonOutput.Exists.Should().BeTrue(); settingsOutput.Exists.Should().BeTrue(); autoCompleteOutput.Exists.Should().BeTrue(); catalogOutput.Exists.Should().BeTrue(); searchOutput.Exists.Should().BeTrue(); packageIndexOutput.Exists.Should().BeTrue(); symbolsIndexOutput.Exists.Should().BeTrue(); log.GetMessages().Should().Contain("catalogpagesize : 1024"); log.GetMessages().Should().Contain("catalogenabled : true"); log.GetMessages().Should().Contain("symbolsfeedenabled : true"); rootJson.ToString().Should().Contain("catalog/index.json"); rootJson.ToString().Should().Contain("Catalog/3.0.0"); rootJson.ToString().Should().Contain("symbols/packages/index.json"); } }
private async Task <bool> InitAsync() { using (var fileCache = CreateFileCache()) { LocalSettings settings = GetSettings(); AzureFileSystem fileSystem = GetAzureFileSystem(fileCache); bool result = await InitCommand.RunAsync(settings, fileSystem, enableCatalog : false, enableSymbols : false, log : new SleetLogger(Log, NuGet.Common.LogLevel.Verbose), token : CancellationToken); return(result); } }
public async Task VerifyUnSetUpdatesIndexJson() { using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) using (var outputFolder = new TestFolder()) { var log = new TestLogger(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); var context = new SleetContext() { Token = CancellationToken.None, LocalSettings = settings, Log = log, Source = fileSystem, SourceSettings = new FeedSettings() }; var success = await InitCommand.RunAsync(settings, fileSystem, log); success &= await FeedSettingsCommand.RunAsync( settings, fileSystem, unsetAll : false, getAll : false, getSettings : Array.Empty <string>(), unsetSettings : Array.Empty <string>(), setSettings : new string[] { "externalsearch:https://example.org/search/query" }, log : log, token : context.Token); success &= await FeedSettingsCommand.RunAsync( settings, fileSystem, unsetAll : false, getAll : false, getSettings : Array.Empty <string>(), unsetSettings : new string[] { "externalsearch" }, setSettings : Array.Empty <string>(), log : log, token : context.Token); success.Should().BeTrue(); var indexJsonPath = Path.Combine(target.RootDirectory.FullName, "index.json"); var entry = GetSearchEntry(indexJsonPath); var value = entry["@id"].ToObject <string>(); value.Should().NotBe("https://example.org/search/query"); } }
public async Task SubFeed_InitMultipleFeedsVerifyDestroyDoesNotModifyOthers() { using (var packagesFolder = new TestFolder()) using (var testContext = new AzureTestContext()) using (var testContext2 = new AzureTestContext()) { // Use a subfeed for the filesystem var subFeedName = "testSubFeedA"; var subFeedName2 = "testSubFeedB"; var root = UriUtility.GetPath(testContext.Uri, subFeedName); var root2 = UriUtility.GetPath(testContext.Uri, subFeedName2); testContext.FileSystem = new AzureFileSystem(testContext.LocalCache, root, root, testContext.StorageAccount, testContext.ContainerName, feedSubPath: subFeedName); testContext2.FileSystem = new AzureFileSystem(testContext.LocalCache, root2, root2, testContext.StorageAccount, testContext.ContainerName, feedSubPath: subFeedName2); await testContext.InitAsync(); await testContext2.InitAsync(); var testPackage = new TestNupkg("packageA", "1.0.0"); var zipFile = testPackage.Save(packagesFolder.Root); var result = await InitCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, enableCatalog : true, enableSymbols : true, log : testContext.Logger, token : CancellationToken.None); result &= await InitCommand.RunAsync(testContext.LocalSettings, testContext2.FileSystem, enableCatalog : true, enableSymbols : true, log : testContext2.Logger, token : CancellationToken.None); // Destroy feed2 result &= await DestroyCommand.RunAsync(testContext.LocalSettings, testContext2.FileSystem, testContext2.Logger); // Validate feed1 result &= await ValidateCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, testContext.Logger); result.Should().BeTrue(); await testContext.CleanupAsync(); await testContext2.CleanupAsync(); } }
public async Task NuGetReader_DownloadPackageAsync() { // Arrange using (var packagesFolder = new TestFolder()) using (var globalFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) { var outputRoot = Path.Combine(target.Root, "output"); var baseUri = UriUtility.CreateUri("https://localhost:8080/testFeed/"); var log = new TestLogger(); var testPackage = new TestNupkg("packageA", "1.0.0"); var sleetConfig = TestUtility.CreateConfigWithLocal("local", outputRoot, baseUri.AbsoluteUri); var sleetConfigPath = Path.Combine(target.Root, "sleet.config"); await JsonUtility.SaveJsonAsync(new FileInfo(sleetConfigPath), sleetConfig); var zipFile = testPackage.Save(packagesFolder.Root); var settings = LocalSettings.Load(sleetConfigPath); var fileSystem = await FileSystemFactory.CreateFileSystemAsync(settings, cache, "local"); var success = await InitCommand.RunAsync(settings, fileSystem, log); // Act // Run sleet success &= await PushCommand.RunAsync(settings, fileSystem, new List <string>() { packagesFolder.Root }, false, false, log); // Create a repository abstraction for nuget var nugetFileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(outputRoot), baseUri); var localSource = GetSource(outputRoot, baseUri, nugetFileSystem); var resource = await localSource.GetResourceAsync <DownloadResource>(); var cacheContext = new SourceCacheContext() { NoCache = true }; var downloadContext = new PackageDownloadContext(cacheContext, globalFolder, directDownload: false); var result = await resource.GetDownloadResourceResultAsync(new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")), downloadContext, globalFolder, log, CancellationToken.None); // Assert Assert.True(success, log.ToString()); Assert.Equal(DownloadResourceResultStatus.Available, result.Status); Assert.True(result.PackageStream.Length > 0); Assert.Equal(new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")), result.PackageReader.GetIdentity()); } }
public async Task Symbols_AddPackageWithNoSymbolsVerifyNotInIndex(string isSymbolsString) { var isSymbols = bool.Parse(isSymbolsString); using (var testContext = new SleetTestContext()) { var context = testContext.SleetContext; context.SourceSettings.SymbolsEnabled = true; // Create package var pkgA = new TestNupkg("a", "1.0.0"); pkgA.Files.Clear(); pkgA.Nuspec.IsSymbolPackage = isSymbols; var zip = pkgA.Save(testContext.Packages); var pkgInput = testContext.GetPackageInput(zip); // Init var success = await InitCommand.RunAsync( testContext.SleetContext.LocalSettings, testContext.SleetContext.Source, enableCatalog : true, enableSymbols : true, log : testContext.SleetContext.Log, token : CancellationToken.None); // Push success &= await PushCommand.RunAsync( testContext.SleetContext.LocalSettings, testContext.SleetContext.Source, new List <string>() { zip.FullName }, force : false, skipExisting : false, log : testContext.SleetContext.Log); // Validate success &= await ValidateCommand.RunAsync( testContext.SleetContext.LocalSettings, testContext.SleetContext.Source, testContext.SleetContext.Log); var service = new Symbols(context); var packages = new HashSet <PackageIdentity>(await service.GetPackagesAsync()); packages.UnionWith(await service.GetSymbolsPackagesAsync()); // Verify package does not show up in symbols index packages.Should().BeEmpty(); // Validate success.Should().BeTrue(); } }
public async Task GivenSettingsAddedVerifySingleGetReturnsJustOne() { using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) using (var cache2 = new LocalCache()) using (var outputFolder = new TestFolder()) { var log = new TestLogger(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var fileSystem2 = new PhysicalFileSystem(cache2, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); var context = new SleetContext() { Token = CancellationToken.None, LocalSettings = settings, Log = log, Source = fileSystem, SourceSettings = new FeedSettings() }; var success = await InitCommand.RunAsync(settings, fileSystem, log); success &= await FeedSettingsCommand.RunAsync( settings, fileSystem, unsetAll : false, getAll : false, getSettings : new string[] { }, unsetSettings : new string[] { }, setSettings : new string[] { "catalogenabled:false", "a:1" }, log : log, token : context.Token); success &= await FeedSettingsCommand.RunAsync( settings, fileSystem2, unsetAll : false, getAll : false, getSettings : new string[] { "a" }, unsetSettings : new string[] { }, setSettings : new string[] { }, log : log, token : context.Token); success.Should().BeTrue(); log.GetMessages().Should().NotContain("catalogenabled : false"); log.GetMessages().Should().Contain("a : 1"); } }
public async Task NuGetReader_MultiplePackagesOnRegistrationWithRemoveAsync() { // Arrange using (var sourceCacheContext = new SourceCacheContext()) using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) { var outputRoot = Path.Combine(target.Root, "output"); var baseUri = UriUtility.CreateUri("https://localhost:8080/testFeed/"); var log = new TestLogger(); var sleetConfig = TestUtility.CreateConfigWithLocal("local", outputRoot, baseUri.AbsoluteUri); var sleetConfigPath = Path.Combine(target.Root, "sleet.config"); await JsonUtility.SaveJsonAsync(new FileInfo(sleetConfigPath), sleetConfig); var settings = LocalSettings.Load(sleetConfigPath); var fileSystem = await FileSystemFactory.CreateFileSystemAsync(settings, cache, "local"); var success = await InitCommand.RunAsync(settings, fileSystem, log); // push 100 packages for (var i = 0; i < 100; i++) { var testPackage = new TestNupkg("packageA", $"1.0.0-alpha.{i}"); var zipFile = testPackage.Save(packagesFolder.Root); } success &= await PushCommand.RunAsync(settings, fileSystem, new List <string>() { packagesFolder.Root }, false, false, log); success &= await DeleteCommand.RunAsync(settings, fileSystem, "packageA", "1.0.0-alpha.5", string.Empty, false, log); success &= await ValidateCommand.RunAsync(settings, fileSystem, log); // Act // Create a repository abstraction for nuget var nugetFileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(outputRoot), baseUri); var localSource = GetSource(outputRoot, baseUri, nugetFileSystem); var resource = await localSource.GetResourceAsync <PackageMetadataResource>(); var packages = (await resource.GetMetadataAsync("packageA", true, true, sourceCacheContext, log, CancellationToken.None)).ToList(); // Assert Assert.True(success, log.ToString()); Assert.Equal(99, packages.Count); } }
public async Task NuGetReader_AutoCompleteAsync() { // Arrange using (var sourceCacheContext = new SourceCacheContext()) using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) { var outputRoot = Path.Combine(target.Root, "output"); var baseUri = UriUtility.CreateUri("https://localhost:8080/testFeed/"); var log = new TestLogger(); var testPackage = new TestNupkg("packageA", "1.0.0"); var sleetConfig = TestUtility.CreateConfigWithLocal("local", outputRoot, baseUri.AbsoluteUri); var sleetConfigPath = Path.Combine(target.Root, "sleet.config"); await JsonUtility.SaveJsonAsync(new FileInfo(sleetConfigPath), sleetConfig); var zipFile = testPackage.Save(packagesFolder.Root); var settings = LocalSettings.Load(sleetConfigPath); var fileSystem = await FileSystemFactory.CreateFileSystemAsync(settings, cache, "local"); var success = await InitCommand.RunAsync(settings, fileSystem, log); fileSystem.Reset(); // Act // Run sleet success &= await PushCommand.RunAsync(settings, fileSystem, new List <string>() { packagesFolder.Root }, false, false, log); // Create a repository abstraction for nuget var nugetFileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(outputRoot), baseUri); var localSource = GetSource(outputRoot, baseUri, nugetFileSystem); var resource = await localSource.GetResourceAsync <AutoCompleteResource>(); var ids = await resource.IdStartsWith("p", true, log, CancellationToken.None); var versions = await resource.VersionStartsWith("packageA", "1", true, sourceCacheContext, log, CancellationToken.None); // Assert Assert.True(success, log.ToString()); Assert.Equal("packageA", ids.Single()); Assert.Equal("1.0.0", versions.Single().ToFullVersionString()); } }
public async Task GivenThatTheFeedHasMissingPackagesVerifyRecreateSucceedsWithForce() { using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var outputFolder = new TestFolder()) using (var cache = new LocalCache()) using (var cache2 = new LocalCache()) using (var cache3 = new LocalCache()) { var log = new TestLogger(); var settings = new LocalSettings(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); await InitCommand.RunAsync(settings, fileSystem, log); var packageA = new TestNupkg("a", "1.0"); var packageB = new TestNupkg("b", "2.0.0-beta+blah"); packageA.Save(packagesFolder.Root); packageB.Save(packagesFolder.Root); await PushCommand.RunAsync(settings, fileSystem, new List <string>() { packagesFolder }, false, false, log); var root = new DirectoryInfo(target); foreach (var file in root.GetFiles("a.1.0.0*", SearchOption.AllDirectories)) { // Corrupt the feed file.Delete(); } // Recreate var fileSystem2 = new PhysicalFileSystem(cache2, UriUtility.CreateUri(target.Root)); var success = await RecreateCommand.RunAsync(settings, fileSystem2, outputFolder, force : true, log : log); success.Should().BeTrue(); var fileSystem3 = new PhysicalFileSystem(cache3, UriUtility.CreateUri(target.Root)); var finalPackages = (await fileSystem3.GetFiles(log, CancellationToken.None)) .Select(e => Path.GetFileName(e.EntityUri.LocalPath)) .Where(e => e.EndsWith(".nupkg")) .OrderBy(e => e, StringComparer.OrdinalIgnoreCase); Directory.Exists(outputFolder).Should().BeFalse(); log.GetMessages().Should().Contain("Feed recreation complete."); } }
public async Task SubFeed_PushAndVerifyNoFilesInRoot() { using (var packagesFolder = new TestFolder()) using (var testContext = new AmazonS3TestContext()) { // Use a subfeed for the filesystem var subFeedName = "testSubFeed"; var root = UriUtility.GetPath(testContext.Uri, subFeedName); testContext.FileSystem = new AmazonS3FileSystem( testContext.LocalCache, root, root, testContext.Client, testContext.BucketName, ServerSideEncryptionMethod.None, feedSubPath: subFeedName ); await testContext.InitAsync(); var testPackage = new TestNupkg("packageA", "1.0.0"); var zipFile = testPackage.Save(packagesFolder.Root); var result = await InitCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, enableCatalog : true, enableSymbols : true, log : testContext.Logger, token : CancellationToken.None); result &= await PushCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, new List <string>() { zipFile.FullName }, force : false, skipExisting : false, log : testContext.Logger); result &= await ValidateCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, testContext.Logger); result.Should().BeTrue(); var files = await AmazonS3FileSystemAbstraction.GetFilesAsync(testContext.Client, testContext.BucketName, CancellationToken.None); files.Where(e => e.Key.IndexOf(subFeedName, StringComparison.OrdinalIgnoreCase) < 0).Should().BeEmpty(); files.Where(e => e.Key.IndexOf(subFeedName, StringComparison.OrdinalIgnoreCase) > -1).Should().NotBeEmpty(); await testContext.CleanupAsync(); } }
public async Task BaseUri_VerifyBaseUriIsSetForAllFilesAsync() { // Arrange using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) { var outputRoot = Path.Combine(target.Root, "output"); var baseUri = UriUtility.CreateUri("https://localhost:8080/testFeed/"); var log = new TestLogger(); var testPackage = new TestNupkg("packageA", "1.0.0"); var sleetConfig = TestUtility.CreateConfigWithLocal("local", outputRoot, baseUri.AbsoluteUri); var sleetConfigPath = Path.Combine(target.Root, "sleet.config"); await JsonUtility.SaveJsonAsync(new FileInfo(sleetConfigPath), sleetConfig); var zipFile = testPackage.Save(packagesFolder.Root); var settings = LocalSettings.Load(sleetConfigPath); var fileSystem = FileSystemFactory.CreateFileSystem(settings, cache, "local"); // Act var initSuccess = await InitCommand.RunAsync(settings, fileSystem, log); var pushSuccess = await PushCommand.RunAsync(settings, fileSystem, new List <string>() { zipFile.FullName }, false, false, log); var files = Directory.GetFiles(outputRoot, "*.json", SearchOption.AllDirectories); // Assert Assert.True(initSuccess, log.ToString()); Assert.True(pushSuccess, log.ToString()); foreach (var file in files) { var fileJson = await JsonUtility.LoadJsonAsync(new FileInfo(file)); foreach (var entityId in GetEntityIds(fileJson)) { Assert.True(entityId.StartsWith(baseUri.AbsoluteUri), $"{entityId} in {file}"); } } } }
public async Task <bool> InitAsync() { AzureStorageUtils blobUtils = new AzureStorageUtils(AccountName, AccountKey, ContainerName); if (!await blobUtils.CheckIfContainerExistsAsync()) { throw new Exception($"The informed container for the feed '{ContainerName}' doesn't exist!"); } using (var fileCache = CreateFileCache()) { LocalSettings settings = GetSettings(); var fileSystem = FileSystemFactory.CreateFileSystem(settings, fileCache, source.Name); bool result = await InitCommand.RunAsync(settings, fileSystem, enableCatalog : false, enableSymbols : false, log : new SleetLogger(Log, NuGet.Common.LogLevel.Verbose), token : CancellationToken); return(result); } }
public async Task GivenAStorageAccountVerifyPushAndSucceedWithBaseURI() { using (var packagesFolder = new TestFolder()) using (var testContext = new AmazonS3TestContext()) { var baseUri = new Uri("http://tempuri.org/abc/"); var fileSystem = new AmazonS3FileSystem( testContext.LocalCache, testContext.Uri, baseUri, testContext.Client, testContext.BucketName, ServerSideEncryptionMethod.None ); testContext.FileSystem = fileSystem; await testContext.InitAsync(); var testPackage = new TestNupkg("packageA", "1.0.0"); var zipFile = testPackage.Save(packagesFolder.Root); var result = await InitCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, enableCatalog : true, enableSymbols : true, log : testContext.Logger, token : CancellationToken.None); result &= await PushCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, new List <string>() { zipFile.FullName }, force : false, skipExisting : false, log : testContext.Logger); result &= await ValidateCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, testContext.Logger); result.Should().BeTrue(); // Check baseURIs await BaseURITestUtil.VerifyBaseUris(testContext.FileSystem.Files.Values, baseUri); await testContext.CleanupAsync(); } }
public async Task Symbols_AddSymbolsPackageWithSymbolsOffVerifySkipped() { using (var testContext = new SleetTestContext()) { var context = testContext.SleetContext; context.SourceSettings.SymbolsEnabled = true; // Create package var pkgA = new TestNupkg("a", "1.0.0"); pkgA.Files.Clear(); pkgA.AddFile("lib/net45/a.dll", TestUtility.GetResource("SymbolsTestAdll").GetBytes()); pkgA.AddFile("lib/net45/a.pdb", TestUtility.GetResource("SymbolsTestApdb").GetBytes()); pkgA.Nuspec.IsSymbolPackage = true; var zip = pkgA.Save(testContext.Packages); var pkgInput = testContext.GetPackageInput(zip); // Init var success = await InitCommand.RunAsync( testContext.SleetContext.LocalSettings, testContext.SleetContext.Source, enableCatalog : true, enableSymbols : false, log : testContext.SleetContext.Log, token : CancellationToken.None); // Push success &= await PushCommand.RunAsync( testContext.SleetContext.LocalSettings, testContext.SleetContext.Source, new List <string>() { zip.FullName }, force : false, skipExisting : false, log : testContext.SleetContext.Log); success.Should().BeTrue(); var packageIndex = new PackageIndex(context); (await packageIndex.IsEmpty()).Should().BeTrue(); var testLogger = (TestLogger)testContext.SleetContext.Log; testLogger.GetMessages().Should().Contain("to push symbols packages enable the symbols server on this feed"); } }
public async Task FileSystem_VerifyFileSystemResetOnLock() { using (var target = new TestFolder()) using (var cache = new LocalCache()) { var log = new TestLogger(); var fileSystem1 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); var lockMessage = Guid.NewGuid().ToString(); await InitCommand.RunAsync(settings, fileSystem1, log); // Verify that files work normally var testFile = fileSystem1.Get("test.json"); await testFile.GetJsonOrNull(log, CancellationToken.None); var testFile2 = fileSystem1.Get("test2.json"); fileSystem1.Files.Count.Should().BeGreaterThan(1); // Lock the feed to reset it var lockObj1 = await SourceUtility.VerifyInitAndLock(settings, fileSystem1, lockMessage, log, CancellationToken.None); lockObj1.IsLocked.Should().BeTrue(); // 1 file should be found since it loads the index fileSystem1.Files.Count.Should().Be(1); InvalidOperationException failureEx = null; try { // Verify the old file no longer works await testFile.GetJsonOrNull(log, CancellationToken.None); await testFile2.GetJsonOrNull(log, CancellationToken.None); } catch (InvalidOperationException ex) { failureEx = ex; } failureEx.Should().NotBeNull(); } }
public async Task GivenThatTheFeedHasPackagesVerifyRecreateSucceeds() { using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var outputFolder = new TestFolder()) using (var cache = new LocalCache()) using (var cache2 = new LocalCache()) using (var cache3 = new LocalCache()) { var log = new TestLogger(); var settings = new LocalSettings(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); await InitCommand.RunAsync(settings, fileSystem, log); var packageA = new TestNupkg("a", "1.0"); var packageB = new TestNupkg("b", "2.0.0-beta+blah"); packageA.Save(packagesFolder.Root); packageB.Save(packagesFolder.Root); await PushCommand.RunAsync(settings, fileSystem, new List <string>() { packagesFolder }, false, false, log); // Recreate var fileSystem2 = new PhysicalFileSystem(cache2, UriUtility.CreateUri(target.Root)); var success = await RecreateCommand.RunAsync(settings, fileSystem2, outputFolder, false, log); success.Should().BeTrue(); var fileSystem3 = new PhysicalFileSystem(cache3, UriUtility.CreateUri(target.Root)); var finalPackages = (await fileSystem3.GetFiles(log, CancellationToken.None)) .Select(e => Path.GetFileName(e.EntityUri.LocalPath)) .Where(e => e.EndsWith(".nupkg")) .OrderBy(e => e, StringComparer.OrdinalIgnoreCase); Directory.Exists(outputFolder).Should().BeFalse(); finalPackages.ShouldBeEquivalentTo(new string[] { "a.1.0.0.nupkg", "b.2.0.0-beta.nupkg" }); } }
public async Task GivenAStorageAccountVerifyInitSucceeds() { using (var testContext = new AmazonS3TestContext()) { await testContext.InitAsync(); var result = await InitCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, enableCatalog : true, enableSymbols : true, log : testContext.Logger, token : CancellationToken.None); result &= await ValidateCommand.RunAsync(testContext.LocalSettings, testContext.FileSystem, testContext.Logger); result.Should().BeTrue(); await testContext.CleanupAsync(); } }
public async Task GivenThatTheFeedHasSymbolsPackagesVerifyDownloadCommandSucceeds() { using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) using (var cache2 = new LocalCache()) using (var outputFolder = new TestFolder()) { var log = new TestLogger(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var fileSystem2 = new PhysicalFileSystem(cache2, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); var success = await InitCommand.RunAsync(settings, fileSystem, enableCatalog : false, enableSymbols : true, log : log, token : CancellationToken.None); var packageA = new TestNupkg("a", "1.0.0"); var packageASymbols = new TestNupkg("a", "1.0.0"); packageASymbols.Nuspec.IsSymbolPackage = true; packageA.Save(packagesFolder.Root); packageASymbols.Save(packagesFolder.Root); success &= await PushCommand.RunAsync(settings, fileSystem, new List <string>() { packagesFolder }, false, false, log); success &= await DownloadCommand.RunAsync(settings, fileSystem2, outputFolder, false, log); var fileNames = Directory.GetFiles(outputFolder, "*.nupkg", SearchOption.AllDirectories) .Select(e => Path.GetFileName(e)) .OrderBy(e => e, StringComparer.OrdinalIgnoreCase) .ToArray(); success.ShouldBeEquivalentTo(true, "the feed is valid"); fileNames.ShouldBeEquivalentTo(new[] { "a.1.0.0.nupkg", "a.1.0.0.symbols.nupkg" }); log.GetMessages().Should().NotContain("The feed does not contain any packages"); log.GetMessages().Should().Contain("a.1.0.0.nupkg"); log.GetMessages().Should().Contain("a.1.0.0.symbols.nupkg"); } }
public async Task GivenDuplicateSetsVerifyFailure() { using (var packagesFolder = new TestFolder()) using (var target = new TestFolder()) using (var cache = new LocalCache()) using (var cache2 = new LocalCache()) using (var outputFolder = new TestFolder()) { var log = new TestLogger(); var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var fileSystem2 = new PhysicalFileSystem(cache2, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); var context = new SleetContext() { Token = CancellationToken.None, LocalSettings = settings, Log = log, Source = fileSystem, SourceSettings = new FeedSettings() }; var success = await InitCommand.RunAsync(settings, fileSystem, log); Func <Task> action = async() => await FeedSettingsCommand.RunAsync( settings, fileSystem, unsetAll : true, getAll : true, getSettings : new string[] { }, unsetSettings : new string[] { }, setSettings : new string[] { "a:1", "a:2" }, log : log, token : context.Token); action.ShouldThrow <ArgumentException>("invalid combo"); } }
public async Task FileSystemLock_VerifyMessageShownInLog() { using (var target = new TestFolder()) using (var cache = new LocalCache()) { var log = new TestLogger(); var log2 = new TestLogger(); var fileSystem1 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var fileSystem2 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root)); var settings = new LocalSettings(); var lockMessage = Guid.NewGuid().ToString(); await InitCommand.RunAsync(settings, fileSystem1, log); var lockObj1 = await SourceUtility.VerifyInitAndLock(settings, fileSystem1, lockMessage, log, CancellationToken.None); lockObj1.IsLocked.Should().BeTrue(); var lockObj2Task = Task.Run(async() => await SourceUtility.VerifyInitAndLock(settings, fileSystem2, lockMessage, log2, CancellationToken.None)); while (!log2.GetMessages().Contains($"Feed is locked by: {lockMessage}")) { await Task.Delay(10); } lockObj1.Release(); var lockObj2 = await lockObj2Task; while (!lockObj2.IsLocked) { await Task.Delay(10); } lockObj1.IsLocked.Should().BeFalse(); lockObj2.IsLocked.Should().BeTrue(); } }