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