public async Task BadgeFile_VerifyBadgesUpdatedAfterDeleteAll()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
BadgesEnabled = true
}
};
// Initial packages
var identities = new HashSet <PackageIdentity>()
{
new PackageIdentity("a", NuGetVersion.Parse("2.0.0"))
};
foreach (var id in identities)
{
var testPackage = new TestNupkg(id.Id, id.Version.ToFullString());
var zipFile = testPackage.Save(packagesFolder.Root);
}
// Push
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { packagesFolder.Root }, false, false, context.Log);
// Remove
await DeleteCommand.RunAsync(context.LocalSettings, context.Source, "a", "2.0.0", "test", true, context.Log);
// Validate
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
validateOutput.Should().BeTrue();
// read output
var stablePath = Path.Combine(target.Root, "badges/v/a.svg");
var prePath = Path.Combine(target.Root, "badges/vpre/a.svg");
File.Exists(stablePath).Should().BeFalse();
File.Exists(prePath).Should().BeFalse();
var stablePathJson = Path.Combine(target.Root, "badges/v/a.json");
var prePathJson = Path.Combine(target.Root, "badges/vpre/a.json");
File.Exists(stablePathJson).Should().BeFalse();
File.Exists(prePathJson).Should().BeFalse();
}
}
public async Task GivenAStorageAccountWithNoContainerVerifyPushSucceeds()
{
using (var packagesFolder = new TestFolder())
using (var testContext = new AmazonS3TestContext())
{
// Skip creation and allow it to be done during push.
testContext.CreateBucketOnInit = false;
await testContext.InitAsync();
var testPackage = new TestNupkg("packageA", "1.0.0");
var zipFile = testPackage.Save(packagesFolder.Root);
var 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 async Task GivenAStorageAccountWithNoInitVerifyPushSucceeds()
{
using (var packagesFolder = new TestFolder())
using (var testContext = new AzureTestContext())
{
await testContext.InitAsync();
var testPackage = new TestNupkg("packageA", "1.0.0");
var zipFile = testPackage.Save(packagesFolder.Root);
// Skip init
var 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 async Task Symbols_VerifyFilesExistAfterPush()
{
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
var testPackage = new TestNupkg("packageA", "1.0.0");
testPackage.Files.Clear();
testPackage.AddFile("lib/net45/SymbolsTestA.dll", TestUtility.GetResource("SymbolsTestAdll").GetBytes());
testPackage.AddFile("lib/net45/SymbolsTestA.pdb", TestUtility.GetResource("SymbolsTestApdb").GetBytes());
testPackage.AddFile("lib/net45/SymbolsTestB.dll", TestUtility.GetResource("SymbolsTestBdll").GetBytes());
testPackage.AddFile("lib/net45/SymbolsTestB.pdb", TestUtility.GetResource("SymbolsTestBpdb").GetBytes());
var zipFile = testPackage.Save(testContext.Packages);
// run commands
await InitCommand.InitAsync(context);
// add package
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile.FullName }, false, false, context.Log);
// validate
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
validateOutput.Should().BeTrue();
}
}
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 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();
}
}
public async Task AddRemove_AddAndDeletePackagesAsync()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
var testPackage1 = new TestNupkg("packageA", "1.0.0");
var testPackage2 = new TestNupkg("packageA", "2.0.0");
var testPackage3 = new TestNupkg("packageB", "2.0.0");
var zipFile1 = testPackage1.Save(packagesFolder.Root);
var zipFile2 = testPackage2.Save(packagesFolder.Root);
var zipFile3 = testPackage3.Save(packagesFolder.Root);
var toDelete = new List <PackageIdentity>()
{
new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")), new PackageIdentity("packageB", NuGetVersion.Parse("2.0.0"))
};
// Act
// run commands
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { packagesFolder.Root }, false, false, context.Log);
await DeleteCommand.DeletePackagesAsync(context.LocalSettings, context.Source, toDelete, string.Empty, false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read outputs
var packageIndex = new PackageIndex(context);
var indexPackages = await packageIndex.GetPackagesAsync();
// Assert
Assert.True(validateOutput);
Assert.Equal(1, indexPackages.Count);
Assert.Equal("packageA", indexPackages.First().Id);
Assert.Equal("2.0.0", indexPackages.First().Version.ToNormalizedString());
}
}
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 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 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 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 PushCommand_GivenAEmptyFolderVerifyAutoInit()
{
// Arrange
using (var packagesFolder = new TestFolder())
using (var target = new TestFolder())
using (var cache = new LocalCache())
{
var root = Path.Combine(target.Root, "a/b/feed");
Directory.CreateDirectory(root);
var log = new TestLogger();
var fileSystem = new PhysicalFileSystem(cache, UriUtility.CreateUri(root));
var settings = new LocalSettings();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
var testPackage = new TestNupkg("packageA", "1.0.0");
var packageIdentity = new PackageIdentity(testPackage.Nuspec.Id, NuGetVersion.Parse(testPackage.Nuspec.Version));
var zipFile = testPackage.Save(packagesFolder.Root);
// Act
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile.FullName }, false, false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read outputs
var packageIndex = new PackageIndex(context);
var indexPackages = await packageIndex.GetPackagesAsync();
// Assert
Assert.Equal(1, indexPackages.Count);
}
}
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 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 AddRemove_AddAndRemovePackageAsync()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
var testPackage = new TestNupkg("packageA", "1.0.0");
var zipFile = testPackage.Save(packagesFolder.Root);
using (var zip = new ZipArchive(File.OpenRead(zipFile.FullName), ZipArchiveMode.Read, false))
{
var input = new PackageInput(zipFile.FullName, new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")), false)
{
Zip = zip,
Package = new PackageArchiveReader(zip)
};
var catalog = new Catalog(context);
var registration = new Registrations(context);
var packageIndex = new PackageIndex(context);
var search = new Search(context);
var autoComplete = new AutoComplete(context);
// Act
// run commands
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile.FullName }, false, false, context.Log);
await DeleteCommand.RunAsync(context.LocalSettings, context.Source, "packageA", "1.0.0", string.Empty, false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read outputs
var catalogEntries = await catalog.GetIndexEntriesAsync();
var catalogExistingEntries = await catalog.GetExistingPackagesIndexAsync();
var catalogLatest = await catalog.GetLatestEntryAsync(input.Identity);
var regPackages = await registration.GetPackagesByIdAsync(input.Identity.Id);
var indexPackages = await packageIndex.GetPackagesAsync();
var searchPackages = await search.GetPackagesAsync();
var autoCompletePackages = await autoComplete.GetPackageIds();
// Assert
Assert.True(validateOutput);
Assert.Equal(2, catalogEntries.Count);
Assert.Equal(0, catalogExistingEntries.Count);
Assert.Equal(0, regPackages.Count);
Assert.Equal(0, indexPackages.Count);
Assert.Equal(0, searchPackages.Count);
Assert.Equal(0, autoCompletePackages.Count);
Assert.Equal("packageA", catalogLatest.Id);
Assert.Equal("1.0.0", catalogLatest.Version.ToIdentityString());
Assert.Equal(SleetOperation.Remove, catalogLatest.Operation);
}
}
}
public async Task GivenThatIRemoveAllPackagesWithTheCatalogDisabledVerifyItSucceeds()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
context.SourceSettings.CatalogEnabled = false;
var testPackage1 = new TestNupkg("packageA", "1.0.1");
var testPackage2 = new TestNupkg("packageA", "1.0.2");
var testPackage3 = new TestNupkg("packageA", "1.0.3");
var zipFile1 = testPackage1.Save(packagesFolder.Root);
var zipFile2 = testPackage2.Save(packagesFolder.Root);
var zipFile3 = testPackage3.Save(packagesFolder.Root);
var catalog = new Catalog(context);
var registration = new Registrations(context);
var packageIndex = new PackageIndex(context);
var search = new Search(context);
var autoComplete = new AutoComplete(context);
// Act
// run commands
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile1.FullName }, false, false, context.Log);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile2.FullName }, false, false, context.Log);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile3.FullName }, false, false, context.Log);
await DeleteCommand.RunAsync(context.LocalSettings, context.Source, "packageA", "1.0.3", "", false, context.Log);
await DeleteCommand.RunAsync(context.LocalSettings, context.Source, "packageA", "1.0.1", "", false, context.Log);
await DeleteCommand.RunAsync(context.LocalSettings, context.Source, "packageA", "1.0.2", "", false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read outputs
var catalogEntries = await catalog.GetIndexEntriesAsync();
var catalogExistingEntries = await catalog.GetExistingPackagesIndexAsync();
var regPackages = await registration.GetPackagesByIdAsync("packageA");
var indexPackages = await packageIndex.GetPackagesAsync();
var searchPackages = await search.GetPackagesAsync();
var autoCompletePackages = await autoComplete.GetPackageIds();
// Assert
validateOutput.Should().BeTrue("the feed is valid");
catalogEntries.Should().BeEmpty("the catalog is disabled");
catalogExistingEntries.Should().BeEmpty("the catalog is disabled");
regPackages.Should().BeEmpty("all packages were removed");
indexPackages.Should().BeEmpty("all packages were removed");
searchPackages.Should().BeEmpty("all packages were removed");
autoCompletePackages.Should().BeEmpty("all packages were removed");
}
}
public async Task GivenThatIAddAPackageWithTheCatalogDisabledVerifyItSucceeds()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
context.SourceSettings.CatalogEnabled = false;
var testPackage = new TestNupkg("packageA", "1.0.0");
var zipFile = testPackage.Save(packagesFolder.Root);
using (var zip = new ZipArchive(File.OpenRead(zipFile.FullName), ZipArchiveMode.Read, false))
{
var input = new PackageInput(zipFile.FullName, new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")), false)
{
Zip = zip,
Package = new PackageArchiveReader(zip)
};
var catalog = new Catalog(context);
var registration = new Registrations(context);
var packageIndex = new PackageIndex(context);
var search = new Search(context);
var autoComplete = new AutoComplete(context);
// Act
// run commands
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile.FullName }, false, false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read outputs
var catalogEntries = await catalog.GetIndexEntriesAsync();
var catalogExistingEntries = await catalog.GetExistingPackagesIndexAsync();
var catalogLatest = await catalog.GetLatestEntryAsync(input.Identity);
var regPackages = await registration.GetPackagesByIdAsync(input.Identity.Id);
var indexPackages = await packageIndex.GetPackagesAsync();
var searchPackages = await search.GetPackagesAsync();
var autoCompletePackages = await autoComplete.GetPackageIds();
var catalogEntry = await registration.GetCatalogEntryFromPackageBlob(input.Identity);
// Assert
validateOutput.Should().BeTrue("the feed is valid");
catalogEntries.Should().BeEmpty("the catalog is disabled");
catalogExistingEntries.Should().BeEmpty("the catalog is disabled");
regPackages.Should().BeEquivalentTo(new[] { input.Identity });
indexPackages.Should().BeEquivalentTo(new[] { input.Identity });
searchPackages.Should().BeEquivalentTo(new[] { input.Identity });
autoCompletePackages.Should().BeEquivalentTo(new[] { input.Identity.Id });
catalogLatest.Should().BeNull();
catalogEntry["version"].ToString().Should().Be("1.0.0");
catalogEntry["sleet:operation"].ToString().Should().Be("add");
}
}
}
public async Task Feed_VerifyBaseUriIsAppliedToLocal(string baseUriString)
{
// Arrange
using (var packagesFolder = new TestFolder())
using (var target = new TestFolder())
using (var cache = new LocalCache())
{
var log = new TestLogger();
var fileSystemRoot = UriUtility.CreateUri(target.Root);
var baseUri = new Uri(baseUriString);
var fileSystem = new PhysicalFileSystem(cache, fileSystemRoot, baseUri);
var settings = new LocalSettings();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true,
SymbolsEnabled = true
}
};
var testPackage = new TestNupkg("packageA", "1.0.0");
var zipFile = testPackage.Save(packagesFolder.Root);
using (var zip = new ZipArchive(File.OpenRead(zipFile.FullName), ZipArchiveMode.Read, false))
{
var input = new PackageInput(zipFile.FullName, new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")), false)
{
Zip = zip,
Package = new PackageArchiveReader(zip)
};
var catalog = new Catalog(context);
var registration = new Registrations(context);
var packageIndex = new PackageIndex(context);
var search = new Search(context);
var autoComplete = new AutoComplete(context);
// Act
// run commands
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile.FullName }, false, false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read outputs
var catalogEntries = await catalog.GetIndexEntriesAsync();
var catalogExistingEntries = await catalog.GetExistingPackagesIndexAsync();
var catalogLatest = await catalog.GetLatestEntryAsync(input.Identity);
var regPackages = await registration.GetPackagesByIdAsync(input.Identity.Id);
var indexPackages = await packageIndex.GetPackagesAsync();
var searchPackages = await search.GetPackagesAsync();
var autoCompletePackages = await autoComplete.GetPackageIds();
// Assert
Assert.True(validateOutput);
Assert.Equal(1, catalogEntries.Count);
Assert.Equal(1, catalogExistingEntries.Count);
Assert.Equal(1, regPackages.Count);
Assert.Equal(1, indexPackages.Count);
Assert.Equal(1, searchPackages.Count);
Assert.Equal(1, autoCompletePackages.Count);
// Walk json to check for bad urls
await TestUtility.WalkJsonAsync(target.Root, (file, json, toCheck) =>
{
// Check only URLs found
if (toCheck.IndexOf("://") > -1)
{
var cleanUriSchema = toCheck.Replace(":///", string.Empty).Replace("://", string.Empty);
var doubleSlash = cleanUriSchema.IndexOf("//") > -1;
Assert.False(doubleSlash, toCheck);
}
});
}
}
}
public async Task AddRemove_AddManyPackagesThenRemoveSome()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true,
SymbolsEnabled = true
}
};
var identities = new HashSet <PackageIdentity>();
var ids = new[] { "a", "b", "c", "d" };
foreach (var id in ids)
{
for (var i = 0; i < 50; i++)
{
var testPackage = new TestNupkg(id, $"{i}.0.0");
var zipFile = testPackage.Save(packagesFolder.Root);
identities.Add(new PackageIdentity(testPackage.Nuspec.Id, NuGetVersion.Parse(testPackage.Nuspec.Version)));
}
}
var catalog = new Catalog(context);
var registration = new Registrations(context);
var packageIndex = new PackageIndex(context);
var search = new Search(context);
var autoComplete = new AutoComplete(context);
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { packagesFolder.Root }, false, false, context.Log);
// Act
// run delete command
await DeleteCommand.RunAsync(context.LocalSettings, context.Source, "b", null, "removing", false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read output
var catalogEntries = await catalog.GetIndexEntriesAsync();
var catalogExistingEntries = await catalog.GetExistingPackagesIndexAsync();
var catalogPackages = await catalog.GetPackagesAsync();
var regPackages = new HashSet <PackageIdentity>();
foreach (var id in ids)
{
regPackages.UnionWith(await registration.GetPackagesByIdAsync(id));
}
var indexPackages = await packageIndex.GetPackagesAsync();
var searchPackages = await search.GetPackagesAsync();
var autoCompletePackages = await autoComplete.GetPackageIds();
// Assert
Assert.True(validateOutput);
Assert.Equal(identities.Count + 50, catalogEntries.Count);
Assert.Equal(identities.Count - 50, catalogExistingEntries.Count);
regPackages.Count.Should().Be(identities.Count - 50);
Assert.Equal(identities.Count - 50, indexPackages.Count);
Assert.Equal(identities.Count - 50, searchPackages.Count);
Assert.Equal(ids.Length - 1, autoCompletePackages.Count);
}
}
public async Task SubFeed_PushAndVerifyWithNestedFeedsVerifySuccess()
{
using (var packagesFolder = new TestFolder())
using (var testContext = new AzureTestContext())
using (var testContext2 = new AzureTestContext())
{
// Use a subfeed for the filesystem
var subFeedName = "testSubFeed";
var root = UriUtility.GetPath(testContext.Uri, subFeedName);
testContext.FileSystem = new AzureFileSystem(testContext.LocalCache, root, root, testContext.StorageAccount, testContext.ContainerName, feedSubPath: subFeedName);
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);
result &= await PushCommand.RunAsync(testContext.LocalSettings,
testContext.FileSystem,
new List <string>() { zipFile.FullName },
force : false,
skipExisting : false,
log : testContext.Logger);
result &= await PushCommand.RunAsync(testContext.LocalSettings,
testContext2.FileSystem,
new List <string>() { zipFile.FullName },
force : false,
skipExisting : false,
log : testContext2.Logger);
result &= await ValidateCommand.RunAsync(testContext.LocalSettings,
testContext.FileSystem,
testContext.Logger);
result &= await ValidateCommand.RunAsync(testContext.LocalSettings,
testContext2.FileSystem,
testContext2.Logger);
result.Should().BeTrue();
await testContext.CleanupAsync();
await testContext2.CleanupAsync();
}
}
public async Task Symbols_AddPackageWithSymbolsVerifyInIndex(string isSymbolsString)
{
var isSymbols = bool.Parse(isSymbolsString);
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
var symbols = new Symbols(context);
var packageIndex = new PackageIndex(context);
// 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 = 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 symbolsIndex = new HashSet <PackageIdentity>();
var packageIndexPkgs = new HashSet <PackageIdentity>();
if (isSymbols)
{
symbolsIndex.UnionWith(await symbols.GetSymbolsPackagesAsync());
packageIndexPkgs.UnionWith(await packageIndex.GetSymbolsPackagesAsync());
}
else
{
symbolsIndex.UnionWith(await symbols.GetPackagesAsync());
packageIndexPkgs.UnionWith(await packageIndex.GetPackagesAsync());
}
// Verify package does not show up in symbols index
symbolsIndex.Should().BeEquivalentTo(new[] { new PackageIdentity("a", NuGetVersion.Parse("1.0.0")) });
packageIndexPkgs.Should().BeEquivalentTo(new[] { new PackageIdentity("a", NuGetVersion.Parse("1.0.0")) });
// Validate
success.Should().BeTrue();
}
}
public async Task Symbols_AddAndRemovePackagesMultipleTimesVerifyValidation()
{
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
// Create package
var identity = new PackageIdentity("a", NuGetVersion.Parse("1.0.0"));
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());
var zip = pkgA.Save(testContext.Packages);
var pkgInput = testContext.GetPackageInput(zip);
var symPkgA = new TestNupkg("a", "1.0.0");
symPkgA.Files.Clear();
symPkgA.AddFile("lib/net45/a.dll", TestUtility.GetResource("SymbolsTestAdll").GetBytes());
symPkgA.AddFile("lib/net45/a.pdb", TestUtility.GetResource("SymbolsTestApdb").GetBytes());
symPkgA.Nuspec.IsSymbolPackage = true;
var symZip = symPkgA.Save(testContext.Packages);
var symPkgInput = testContext.GetPackageInput(symZip);
// 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, symZip.FullName },
force : false,
skipExisting : false,
log : testContext.SleetContext.Log);
// Validate 1
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
log : testContext.SleetContext.Log);
// Remove
success &= await DeleteCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
"a",
"1.0.0",
"reason",
force : false,
log : testContext.SleetContext.Log);
// Validate 2
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
log : testContext.SleetContext.Log);
// Push Again
success &= await PushCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
new List <string>() { zip.FullName, symZip.FullName },
force : false,
skipExisting : false,
log : testContext.SleetContext.Log);
// Validate 3
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
log : testContext.SleetContext.Log);
// Remove Again
success &= await DeleteCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
"a",
"1.0.0",
"reason",
force : false,
log : testContext.SleetContext.Log);
// Validate 4
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
log : testContext.SleetContext.Log);
success.Should().BeTrue();
}
}
public async Task Symbols_AddSymbolsPackagesContainingTheSameFilesVerifyDeleteDoesNotRemove()
{
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
// Create package
var identity = new PackageIdentity("a", NuGetVersion.Parse("1.0.0"));
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);
var identityB = new PackageIdentity("b", NuGetVersion.Parse("1.0.0"));
var pkgB = new TestNupkg("b", "1.0.0");
pkgB.Files.Clear();
pkgB.AddFile("lib/net45/a.dll", TestUtility.GetResource("SymbolsTestAdll").GetBytes());
pkgB.AddFile("lib/net45/a.pdb", TestUtility.GetResource("SymbolsTestApdb").GetBytes());
pkgB.Nuspec.IsSymbolPackage = true;
var zipB = pkgB.Save(testContext.Packages);
var pkgInputB = testContext.GetPackageInput(zipB);
// File path
var dllPath = Path.Combine(testContext.Target, "symbols", "a.dll", "A7F83EF08000", "a.dll");
var dllPackagesJsonPath = Path.Combine(testContext.Target, "symbols", "a.dll", "A7F83EF08000", "packages.json");
var pdbPath = Path.Combine(testContext.Target, "symbols", "a.pdb", "B1680B8315F8485EA0A10F55AF08B565ffffffff", "a.pdb");
var pdbPackagesJsonPath = Path.Combine(testContext.Target, "symbols", "a.pdb", "B1680B8315F8485EA0A10F55AF08B565ffffffff", "packages.json");
var files = new List <string>
{
dllPath,
dllPackagesJsonPath,
pdbPath,
pdbPackagesJsonPath
};
// 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, zipB.FullName },
force : false,
skipExisting : false,
log : testContext.SleetContext.Log);
// Verify files are present
files.ForEach(e => File.Exists(e).Should().BeTrue(e));
// Remove
success &= await DeleteCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
"a",
"1.0.0",
"reason",
force : false,
log : testContext.SleetContext.Log);
// Verify files are still present
files.ForEach(e => File.Exists(e).Should().BeTrue(e));
// Validate
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
log : testContext.SleetContext.Log);
success.Should().BeTrue();
}
}
public async Task Symbols_RemovePackageVerifySymbolsRemoved()
{
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
// Create package
var identity = new PackageIdentity("a", NuGetVersion.Parse("1.0.0"));
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);
// File path
var nupkgPath = Path.Combine(testContext.Target, ToLocalPath(SymbolsIndexUtility.GetSymbolsNupkgPath(identity)));
var detailsPath = Path.Combine(testContext.Target, ToLocalPath(SymbolsIndexUtility.GetSymbolsPackageDetailsPath(identity)));
var dllPath = Path.Combine(testContext.Target, "symbols", "a.dll", "A7F83EF08000", "a.dll");
var dllPackagesJsonPath = Path.Combine(testContext.Target, "symbols", "a.dll", "A7F83EF08000", "packages.json");
var pdbPath = Path.Combine(testContext.Target, "symbols", "a.pdb", "B1680B8315F8485EA0A10F55AF08B565ffffffff", "a.pdb");
var pdbPackagesJsonPath = Path.Combine(testContext.Target, "symbols", "a.pdb", "B1680B8315F8485EA0A10F55AF08B565ffffffff", "packages.json");
var packageAssetsPath = Path.Combine(testContext.Target, ToLocalPath(SymbolsIndexUtility.GetPackageToAssemblyIndexPath(identity)));
var files = new List <string>
{
nupkgPath,
detailsPath,
dllPath,
dllPackagesJsonPath,
pdbPath,
pdbPackagesJsonPath,
packageAssetsPath
};
// 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);
// Verify files are present
files.ForEach(e => File.Exists(e).Should().BeTrue(e));
// Remove
success &= await DeleteCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
"a",
"1.0.0",
"reason",
force : false,
log : testContext.SleetContext.Log);
// Verify files are gone
files.ForEach(e => File.Exists(e).Should().BeFalse(e));
// Validate
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
log : testContext.SleetContext.Log);
success.Should().BeTrue();
var testLogger = (TestLogger)testContext.SleetContext.Log;
testLogger.GetMessages().Should().Contain("Removing symbols package a.1.0.0");
}
}
public async Task AddRemove_AddTwoPackagesOfUniqueIds()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
var testPackage1 = new TestNupkg("packageA", "1.0.0");
var testPackage2 = new TestNupkg("packageB", "1.0.0");
var zipFile1 = testPackage1.Save(packagesFolder.Root);
var zipFile2 = testPackage2.Save(packagesFolder.Root);
using (var zip1 = new ZipArchive(File.OpenRead(zipFile1.FullName), ZipArchiveMode.Read, false))
using (var zip2 = new ZipArchive(File.OpenRead(zipFile2.FullName), ZipArchiveMode.Read, false))
{
var input1 = PackageInput.Create(zipFile1.FullName);
var input2 = PackageInput.Create(zipFile2.FullName);
var catalog = new Catalog(context);
var registration = new Registrations(context);
var packageIndex = new PackageIndex(context);
var search = new Search(context);
var autoComplete = new AutoComplete(context);
// Act
// run commands
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile1.FullName }, false, false, context.Log);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile2.FullName }, false, false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read outputs
var catalogEntries = await catalog.GetIndexEntriesAsync();
var catalogExistingEntries = await catalog.GetExistingPackagesIndexAsync();
var regPackages = await registration.GetPackagesByIdAsync("packageA");
var indexPackages = await packageIndex.GetPackagesAsync();
var searchPackages = await search.GetPackagesAsync();
var autoCompletePackages = await autoComplete.GetPackageIds();
// Assert
Assert.True(validateOutput);
Assert.Equal(2, catalogEntries.Count);
Assert.Equal(2, catalogExistingEntries.Count);
Assert.Equal(1, regPackages.Count);
Assert.Equal(2, indexPackages.Count);
Assert.Equal(2, searchPackages.Count);
Assert.Equal(2, autoCompletePackages.Count);
}
}
}
public async Task PushCommand_GivenADifferentNuspecCasingVerifyPush()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
var testPackage = new TestNupkg("packageA", "1.0.0");
var zipFile = testPackage.Save(packagesFolder.Root);
using (var tempZip = new ZipArchive(zipFile.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None), ZipArchiveMode.Update))
{
var nuspec = tempZip.Entries.Single(e => e.FullName == "packageA.nuspec");
using (var ms = new MemoryStream())
{
using (var nuspecStream = nuspec.Open())
{
nuspecStream.CopyTo(ms);
}
ms.Position = 0;
nuspec.Delete();
var newEntry = tempZip.CreateEntry("PacKAGEa.NuSpec");
ms.CopyTo(newEntry.Open());
}
}
using (var zip = new ZipArchive(File.OpenRead(zipFile.FullName), ZipArchiveMode.Read, false))
{
var input = PackageInput.Create(zipFile.FullName);
// Act
// run commands
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile.FullName }, false, false, context.Log);
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read outputs
var catalog = new Catalog(context);
var registration = new Registrations(context);
var packageIndex = new PackageIndex(context);
var search = new Search(context);
var autoComplete = new AutoComplete(context);
var catalogEntries = await catalog.GetIndexEntriesAsync();
var indexPackages = await packageIndex.GetPackagesAsync();
// Assert
Assert.True(validateOutput);
Assert.Equal(1, catalogEntries.Count);
Assert.Equal(1, indexPackages.Count);
}
}
}
public async Task RetentionPruneCommand_PrunesOnPushWithMultiplePushes()
{
// Arrange
using (var packagesFolder = new TestFolder())
using (var packagesFolder2 = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true,
SymbolsEnabled = true,
RetentionMaxStableVersions = 2,
RetentionMaxPrereleaseVersions = 1
}
};
// Initial packages
var identities = new List <PackageIdentity>()
{
new PackageIdentity("a", NuGetVersion.Parse("1.0.0-alpha")),
new PackageIdentity("a", NuGetVersion.Parse("1.0.0-beta")),
new PackageIdentity("a", NuGetVersion.Parse("1.0.0")),
new PackageIdentity("b", NuGetVersion.Parse("1.0.0-alpha")),
new PackageIdentity("b", NuGetVersion.Parse("1.0.0-beta")),
new PackageIdentity("b", NuGetVersion.Parse("1.0.0")),
new PackageIdentity("a", NuGetVersion.Parse("2.0.0-alpha")),
new PackageIdentity("a", NuGetVersion.Parse("2.0.0-beta")),
new PackageIdentity("a", NuGetVersion.Parse("2.0.0")),
new PackageIdentity("b", NuGetVersion.Parse("2.0.0-alpha")),
new PackageIdentity("b", NuGetVersion.Parse("2.0.0-beta")),
new PackageIdentity("b", NuGetVersion.Parse("2.0.0")),
new PackageIdentity("a", NuGetVersion.Parse("3.0.0-alpha")),
new PackageIdentity("a", NuGetVersion.Parse("3.0.0-beta")),
new PackageIdentity("a", NuGetVersion.Parse("3.0.0")),
new PackageIdentity("b", NuGetVersion.Parse("3.0.0-alpha")),
new PackageIdentity("b", NuGetVersion.Parse("3.0.0-beta")),
new PackageIdentity("b", NuGetVersion.Parse("3.0.0")),
};
await InitCommand.InitAsync(context);
// Push packages 1 at a time
foreach (var id in identities)
{
var testPackage = new TestNupkg(id.Id, id.Version.ToFullString());
var zipFile = testPackage.Save(packagesFolder.Root);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { zipFile.FullName }, false, false, context.Log);
}
// Validate
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read output
var packageIndex = new PackageIndex(context);
var indexPackages = await packageIndex.GetPackagesAsync();
// Assert
indexPackages.Count().Should().Be(6);
indexPackages.Contains(new PackageIdentity("a", NuGetVersion.Parse("3.0.0"))).Should().BeTrue();
indexPackages.Contains(new PackageIdentity("a", NuGetVersion.Parse("2.0.0"))).Should().BeTrue();
indexPackages.Contains(new PackageIdentity("a", NuGetVersion.Parse("3.0.0-beta"))).Should().BeTrue();
indexPackages.Contains(new PackageIdentity("b", NuGetVersion.Parse("3.0.0"))).Should().BeTrue();
indexPackages.Contains(new PackageIdentity("b", NuGetVersion.Parse("2.0.0"))).Should().BeTrue();
indexPackages.Contains(new PackageIdentity("b", NuGetVersion.Parse("3.0.0-beta"))).Should().BeTrue();
}
}
public async Task Symbols_ForcePushPackageShouldNotAffectOtherType(bool isSymbols)
{
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
// Create package
var identity = new PackageIdentity("a", NuGetVersion.Parse("1.0.0"));
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());
var zip = pkgA.Save(testContext.Packages);
var pkgInput = testContext.GetPackageInput(zip);
var symPkgA = new TestNupkg("a", "1.0.0");
symPkgA.Files.Clear();
symPkgA.AddFile("lib/net45/a.dll", TestUtility.GetResource("SymbolsTestAdll").GetBytes());
symPkgA.AddFile("lib/net45/a.pdb", TestUtility.GetResource("SymbolsTestApdb").GetBytes());
symPkgA.Nuspec.IsSymbolPackage = true;
var symZip = symPkgA.Save(testContext.Packages);
var symPkgInput = testContext.GetPackageInput(symZip);
var forcePushZip = zip.FullName;
if (isSymbols)
{
forcePushZip = symZip.FullName;
}
// 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, symZip.FullName },
force : false,
skipExisting : false,
log : testContext.SleetContext.Log);
// Force push
success &= await PushCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
new List <string>() { forcePushZip },
force : true,
skipExisting : false,
log : testContext.SleetContext.Log);
// Validate
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
log : testContext.SleetContext.Log);
success.Should().BeTrue();
// Both packages should exist, force should not delete one or the other.
var index = new PackageIndex(context);
(await index.Exists(identity)).Should().BeTrue();
(await index.SymbolsExists(identity)).Should().BeTrue();
}
}
public async Task Symbols_AddSymbolsPackageVerifyFeed()
{
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.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 : 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();
// Exists under symbols
(await symbols.GetSymbolsPackagesAsync()).Should().NotBeEmpty();
(await packageIndex.GetSymbolsPackagesAsync()).Should().NotBeEmpty();
// Does not exist in non-symbols
(await symbols.GetPackagesAsync()).Should().BeEmpty();
(await packageIndex.GetPackagesAsync()).Should().BeEmpty();
// Verify it does not appear in other services
(await catalog.GetPackagesAsync()).Should().BeEmpty();
(await autoComplete.GetPackageIds()).Should().BeEmpty();
(await flatContainer.GetPackagesByIdAsync("a")).Should().BeEmpty();
(await registrations.GetPackagesByIdAsync("a")).Should().BeEmpty();
(await search.GetPackagesAsync()).Should().BeEmpty();
// 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();
}
}
public async Task RetentionPruneCommand_NoopsWhenNoPackagesNeedToBeRemoved()
{
// Arrange
using (var packagesFolder = new TestFolder())
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();
var context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true,
SymbolsEnabled = true
}
};
var identities = new HashSet <PackageIdentity>()
{
new PackageIdentity("a", NuGetVersion.Parse("1.0.0")),
new PackageIdentity("a", NuGetVersion.Parse("2.0.0")),
new PackageIdentity("a", NuGetVersion.Parse("3.0.0")),
new PackageIdentity("a", NuGetVersion.Parse("4.0.0")),
new PackageIdentity("a", NuGetVersion.Parse("5.0.0")),
};
foreach (var id in identities)
{
var testPackage = new TestNupkg(id.Id, id.Version.ToFullString());
var zipFile = testPackage.Save(packagesFolder.Root);
}
await InitCommand.InitAsync(context);
await PushCommand.RunAsync(context.LocalSettings, context.Source, new List <string>() { packagesFolder.Root }, false, false, context.Log);
var pruneContext = new RetentionPruneCommandContext()
{
StableVersionMax = 10,
PrereleaseVersionMax = 10
};
// Run prune
await RetentionPruneCommand.PrunePackages(context, pruneContext);
// Validate
var validateOutput = await ValidateCommand.RunAsync(context.LocalSettings, context.Source, context.Log);
// read output
var packageIndex = new PackageIndex(context);
var indexPackages = await packageIndex.GetPackagesAsync();
// Assert
indexPackages.Count().Should().Be(5);
}
}
