public async Task UpgradeUtility_VerifyMatchingVersionOfCapabilityWorksAsync()
{
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
}
};
// Init
await InitCommand.InitAsync(context);
// Change index.json
var indexJsonPath = Path.Combine(target.Root, "index.json");
var json = JObject.Parse(File.ReadAllText(indexJsonPath));
json["sleet:capabilities"] = "schema:1.0.0";
File.WriteAllText(indexJsonPath, json.ToString());
var fileSystem2 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root));
await UpgradeUtility.EnsureCompatibility(fileSystem2, log, CancellationToken.None);
}
}
public void GivenThatTheFeedIsNotInitializedVerifyRecreateFails()
{
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()
};
Func <Task> action = async() => await RecreateCommand.RunAsync(settings, fileSystem, outputFolder, force : false, log : log);
action.ShouldThrow <InvalidOperationException>("the feed is not initialized");
}
}
public async Task CatalogTest_CreatePackageDetails_Minimal()
{
using (var packagesFolder = new TestFolder())
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 context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
var catalog = new Catalog(context);
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 = PackageInput.Create(zipFile.FullName);
var nupkgUri = UriUtility.CreateUri("http://tempuri.org/flatcontainer/packageA/1.0.0/packageA.1.0.0.nupkg");
// Act
var actual = await CatalogUtility.CreatePackageDetailsAsync(input, catalog.CatalogBaseURI, nupkgUri, context.CommitId, writeFileList : true);
var dependencyGroups = actual["dependencyGroups"] as JArray;
var frameworkAssemblyGroups = actual["frameworkAssemblyGroup"] as JArray;
var tags = actual["tags"] as JArray;
// Assert
Assert.EndsWith(".json", actual["@id"].ToString());
Assert.Equal(string.Empty, actual["authors"].ToString());
Assert.Equal(string.Empty, actual["copyright"].ToString());
Assert.Equal(string.Empty, actual["description"].ToString());
Assert.Equal(string.Empty, actual["iconUrl"].ToString());
Assert.Equal(string.Empty, actual["licenseUrl"].ToString());
Assert.Null(actual["minClientVersion"]);
Assert.Equal(string.Empty, actual["projectUrl"].ToString());
Assert.False(actual["requireLicenseAcceptance"].ToObject <bool>());
Assert.Null(actual["title"]);
Assert.Equal(testPackage.Nuspec.Id, actual["id"].ToString());
Assert.Equal(testPackage.Nuspec.Version, actual["version"].ToString());
Assert.EndsWith(".nupkg", actual["packageContent"].ToString());
Assert.Empty(dependencyGroups);
Assert.Empty(frameworkAssemblyGroups);
Assert.Empty(tags);
}
}
}
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 void GivenBothGetAndSetArePassedVerifyFailure()
{
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()
};
Func <Task> action = async() => await FeedSettingsCommand.RunAsync(
settings,
fileSystem,
unsetAll : true,
getAll : true,
getSettings : new string[] { },
unsetSettings : new string[] { },
setSettings : new string[] { },
log : log,
token : context.Token);
action.ShouldThrow <InvalidOperationException>("invalid combo");
}
}
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 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 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 UpgradeUtility_Verify210FeedsAreNotCompatibleAsync()
{
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
}
};
// Init
await InitCommand.InitAsync(context);
// Change index.json
var indexJsonPath = Path.Combine(target.Root, "index.json");
var json = JObject.Parse(File.ReadAllText(indexJsonPath));
json["sleet:version"] = "2.1.1";
File.WriteAllText(indexJsonPath, json.ToString());
Exception ex = null;
try
{
var fileSystem2 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root));
await UpgradeUtility.EnsureCompatibility(fileSystem2, log, CancellationToken.None);
}
catch (Exception current)
{
ex = current;
}
ex.Should().NotBeNull();
ex.Message.Should().Contain("Sleet recreate");
}
}
public SleetTestContext()
{
Packages = Path.Combine(Root.Root, "packages");
Target = Path.Combine(Root.Root, "target");
SleetContext = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = new LocalSettings(),
Log = new TestLogger(),
Source = new PhysicalFileSystem(new LocalCache(Path.Combine(Root.Root, "cache")), UriUtility.CreateUri(Target)),
SourceSettings = new FeedSettings()
{
CatalogEnabled = false,
SymbolsEnabled = false,
}
};
}
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 <ISet <PackageIdentity> > GetPackageIdentitiesAsync()
{
var context = new SleetContext
{
LocalSettings = GetSettings(),
Log = new SleetLogger(Log),
Source = GetAzureFileSystem(),
Token = CancellationToken
};
context.SourceSettings = await FeedSettingsUtility.GetSettingsOrDefault(
context.Source,
context.Log,
context.Token);
var packageIndex = new PackageIndex(context);
return(await packageIndex.GetPackagesAsync());
}
public async Task <ISet <PackageIdentity> > GetPackageIdentitiesAsync()
{
using (var fileCache = CreateFileCache())
{
var context = new SleetContext
{
LocalSettings = GetSettings(),
Log = new SleetLogger(Log, NuGet.Common.LogLevel.Verbose),
Source = GetAzureFileSystem(fileCache),
Token = CancellationToken
};
context.SourceSettings = await FeedSettingsUtility.GetSettingsOrDefault(
context.Source,
context.Log,
context.Token);
var packageIndex = new PackageIndex(context);
return(await packageIndex.GetPackagesAsync());
}
}
public async Task RetentionSettingsCommand_DisableRetention()
{
// 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
}
};
await InitCommand.InitAsync(context);
// Enable retention
var success = await RetentionSettingsCommand.RunAsync(context.LocalSettings, context.Source, 10, 5, 2, false, log);
// Disable retention
success &= await RetentionSettingsCommand.RunAsync(context.LocalSettings, context.Source, -1, -1, true, log);
var updatedSettings = await FeedSettingsUtility.GetSettingsOrDefault(context.Source, log, context.Token);
success.Should().BeTrue();
updatedSettings.RetentionMaxStableVersions.Should().BeNull();
updatedSettings.RetentionMaxPrereleaseVersions.Should().BeNull();
updatedSettings.RetentionGroupByFirstPrereleaseLabelCount.Should().BeNull();
}
}
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 GivenAnEmptyFeedVerifyGetSettingsSucceeds()
{
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 : true,
getSettings : new string[] { },
unsetSettings : new string[] { },
setSettings : new string[] { },
log : log,
token : context.Token);
success.Should().BeTrue();
}
}
public async Task CatalogTest_AddPackageAsync_SupportsWritingMultiplePages()
{
using (var packagesFolder = new TestFolder())
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 context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true,
CatalogPageSize = 1,
}
};
var catalog = new Catalog(context);
var catalogIndex = TemplateUtility.LoadTemplate(
"CatalogIndex",
DateTimeOffset.UtcNow,
fileSystem.BaseURI);
await fileSystem.Get("catalog/index.json").Write(
JObject.Parse(catalogIndex),
log,
context.Token);
var testPackageA = new TestNupkg("packageA", "1.0.0");
var testPackageB = new TestNupkg("packageB", "1.0.0");
var zipFileA = testPackageA.Save(packagesFolder.Root);
var zipFileB = testPackageB.Save(packagesFolder.Root);
using (var zipA = new ZipArchive(File.OpenRead(zipFileA.FullName), ZipArchiveMode.Read, false))
using (var zipB = new ZipArchive(File.OpenRead(zipFileB.FullName), ZipArchiveMode.Read, false))
{
var inputA = new PackageInput(zipFileA.FullName, new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")), false)
{
NupkgUri = UriUtility.CreateUri("http://tempuri.org/flatcontainer/packageA/1.0.0/packageA.1.0.0.nupkg"),
Zip = zipA,
Package = new PackageArchiveReader(zipA)
};
var inputB = new PackageInput(zipFileB.FullName, new PackageIdentity("packageB", NuGetVersion.Parse("1.0.0")), false)
{
NupkgUri = UriUtility.CreateUri("http://tempuri.org/flatcontainer/packageB/1.0.0/packageB.1.0.0.nupkg"),
Zip = zipB,
Package = new PackageArchiveReader(zipB)
};
// Act
await catalog.AddPackageAsync(inputA);
await catalog.AddPackageAsync(inputB);
await fileSystem.Commit(context.Log, context.Token);
// Assert
Assert.True(
await fileSystem.Get("catalog/page.0.json").Exists(context.Log, context.Token),
"The first catalog page should exist.");
Assert.True(
await fileSystem.Get("catalog/page.1.json").Exists(context.Log, context.Token),
"The second catalog page should exist.");
}
}
}
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 CatalogTest_CreatePackageDetails()
{
using (var packagesFolder = new TestFolder())
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 context = new SleetContext()
{
Token = CancellationToken.None,
LocalSettings = settings,
Log = log,
Source = fileSystem,
SourceSettings = new FeedSettings()
{
CatalogEnabled = true
}
};
var catalog = new Catalog(context);
var testPackage = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "packageA",
Version = "1.0.0-alpha.1",
Authors = "authorA, authorB",
Copyright = "Copyright info",
Description = "Package A",
IconUrl = "http://tempuri.org/icon.png",
LicenseUrl = "http://tempuri.org/license.html",
Language = "en-us",
MinClientVersion = "3.3.0",
DevelopmentDependency = "true",
Owners = "ownerA, ownerB",
ProjectUrl = "http://tempuri.org/project.html",
ReleaseNotes = "release 1.0",
RequireLicenseAcceptance = "true",
Summary = "package summary.",
Tags = "tagA tagB tagC",
Title = "packageA title",
Dependencies = new List <PackageDependencyGroup>()
{
new PackageDependencyGroup(NuGetFramework.AnyFramework, new List <PackageDependency>()
{
new PackageDependency("packageB", VersionRange.Parse("1.0.0"))
}),
new PackageDependencyGroup(NuGetFramework.Parse("net46"), new List <PackageDependency>()),
new PackageDependencyGroup(NuGetFramework.Parse("net45"), new List <PackageDependency>()
{
new PackageDependency("packageAll"),
new PackageDependency("packageExact", VersionRange.Parse("[2.0.0]")),
}),
},
FrameworkAssemblies = new List <KeyValuePair <string, List <NuGetFramework> > >()
{
new KeyValuePair <string, List <NuGetFramework> >("System.IO.Compression", new List <NuGetFramework>()
{
NuGetFramework.Parse("net45"),
NuGetFramework.Parse("win8")
}),
new KeyValuePair <string, List <NuGetFramework> >("System.Threading", new List <NuGetFramework>()
{
NuGetFramework.Parse("net40")
}),
new KeyValuePair <string, List <NuGetFramework> >("System.All", new List <NuGetFramework>()
{
})
},
}
};
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-alpha.1")), false)
{
NupkgUri = UriUtility.CreateUri("http://tempuri.org/flatcontainer/packageA/1.0.0-alpha.1/packageA.1.0.0-alpha.1.nupkg"),
Zip = zip,
Package = new PackageArchiveReader(zip)
};
// Act
var actual = await CatalogUtility.CreatePackageDetailsAsync(input, catalog.CatalogBaseURI, context.CommitId, writeFileList : true);
var dependencyGroups = actual["dependencyGroups"] as JArray;
var frameworkAssemblyGroups = actual["frameworkAssemblyGroup"] as JArray;
// Assert
Assert.EndsWith(".json", actual["@id"].ToString());
Assert.Contains("/catalog/data/", actual["@id"].ToString());
Assert.Equal(testPackage.Nuspec.Authors, actual["authors"].ToString());
Assert.Equal(testPackage.Nuspec.Copyright, actual["copyright"].ToString());
Assert.Equal(testPackage.Nuspec.Description, actual["description"].ToString());
Assert.Equal(testPackage.Nuspec.IconUrl, actual["iconUrl"].ToString());
Assert.Equal(testPackage.Nuspec.LicenseUrl, actual["licenseUrl"].ToString());
Assert.Equal(testPackage.Nuspec.MinClientVersion, actual["minClientVersion"].ToString());
Assert.Equal(testPackage.Nuspec.ProjectUrl, actual["projectUrl"].ToString());
Assert.True(actual["requireLicenseAcceptance"].ToObject <bool>());
Assert.Equal(testPackage.Nuspec.Title, actual["title"].ToString());
Assert.Equal(testPackage.Nuspec.Id, actual["id"].ToString());
Assert.Equal(testPackage.Nuspec.Version, actual["version"].ToString());
Assert.Equal("tagA", ((JArray)actual["tags"])[0].ToString());
Assert.Equal("tagB", ((JArray)actual["tags"])[1].ToString());
Assert.Equal("tagC", ((JArray)actual["tags"])[2].ToString());
Assert.EndsWith(".nupkg", actual["packageContent"].ToString());
Assert.Null(dependencyGroups[0]["targetFramework"]);
Assert.Equal("packageB", ((JArray)dependencyGroups[0]["dependencies"]).Single()["id"]);
Assert.Equal("[1.0.0, )", ((JArray)dependencyGroups[0]["dependencies"]).Single()["range"]);
Assert.Equal("net45", dependencyGroups[1]["targetFramework"]);
Assert.NotNull(dependencyGroups[1]["dependencies"]);
Assert.Equal("net46", dependencyGroups[2]["targetFramework"]);
Assert.Null(dependencyGroups[2]["dependencies"]);
Assert.Null(frameworkAssemblyGroups[0]["targetFramework"]);
Assert.Equal("net40", frameworkAssemblyGroups[1]["targetFramework"]);
Assert.Equal("net45", frameworkAssemblyGroups[2]["targetFramework"]);
Assert.Equal("win8", frameworkAssemblyGroups[3]["targetFramework"]);
Assert.Equal("System.All", ((JArray)frameworkAssemblyGroups[0]["assembly"]).Single());
Assert.Equal("System.Threading", ((JArray)frameworkAssemblyGroups[1]["assembly"]).Single());
Assert.Equal("System.IO.Compression", ((JArray)frameworkAssemblyGroups[2]["assembly"]).Single());
Assert.Equal("System.IO.Compression", ((JArray)frameworkAssemblyGroups[3]["assembly"]).Single());
}
}
}
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 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");
}
}
private async Task <bool> PushAsync(
IEnumerable <string> items,
PushOptions options)
{
LocalSettings settings = GetSettings();
SleetLogger log = new SleetLogger(Log, NuGet.Common.LogLevel.Verbose);
var packagesToPush = items.ToList();
// Create a separate LocalCache to use for read only operations on the feed.
// Files added to the cache before the lock could be modified by the process
// currently holding the lock. Sleet assumes that files in the cache
// are valid and identical to the ones on the feed since operations are
// normally performed inside the lock.
using (var preLockCache = CreateFileCache())
{
var preLockFileSystem = GetAzureFileSystem(preLockCache);
if (!options.AllowOverwrite && options.PassIfExistingItemIdentical)
{
var context = new SleetContext
{
LocalSettings = settings,
Log = log,
Source = preLockFileSystem,
Token = CancellationToken
};
context.SourceSettings = await FeedSettingsUtility.GetSettingsOrDefault(
context.Source,
context.Log,
context.Token);
var flatContainer = new FlatContainer(context);
var packageIndex = new PackageIndex(context);
// Check packages sequentially: Task.WhenAll caused IO exceptions in Sleet.
for (int i = packagesToPush.Count - 1; i >= 0; i--)
{
string item = packagesToPush[i];
bool?identical = await IsPackageIdenticalOnFeedAsync(
item,
packageIndex,
context.Source,
flatContainer,
log);
if (identical == null)
{
continue;
}
packagesToPush.RemoveAt(i);
if (identical == true)
{
Log.LogMessage(
MessageImportance.Normal,
"Package exists on the feed, and is verified to be identical. " +
$"Skipping upload: '{item}'");
}
else
{
Log.LogError(
"Package exists on the feed, but contents are different. " +
$"Upload failed: '{item}'");
}
}
if (!packagesToPush.Any())
{
Log.LogMessage("After skipping idempotent uploads, no items need pushing.");
return(true);
}
}
}
// Create a new cache to be used once a lock is obtained.
using (var fileCache = CreateFileCache())
{
var lockedFileSystem = GetAzureFileSystem(fileCache);
return(await PushCommand.RunAsync(
settings,
lockedFileSystem,
packagesToPush,
options.AllowOverwrite,
skipExisting : false,
log : log));
}
}
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_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 SourceSettings()
};
var testPackage1 = new TestPackageContext()
{
Nuspec = new TestNuspecContext()
{
Id = "packageA",
Version = "1.0.0"
}
};
var testPackage2 = new TestPackageContext()
{
Nuspec = new TestNuspecContext()
{
Id = "packageB",
Version = "1.0.0"
}
};
var zipFile1 = testPackage1.Create(packagesFolder.Root);
var zipFile2 = testPackage2.Create(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 = new PackageInput()
{
Identity = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")),
Zip = zip1,
Package = new PackageArchiveReader(zip1),
PackagePath = zipFile1.FullName
};
var input2 = new PackageInput()
{
Identity = new PackageIdentity("packageB", NuGetVersion.Parse("1.0.0")),
Zip = zip2,
Package = new PackageArchiveReader(zip2),
PackagePath = 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 InitCommandTestHook.RunCore(context.LocalSettings, context.Source, context.Log);
await PushCommandTestHook.RunCore(context.LocalSettings, context.Source, new List <string>() { zipFile1.FullName }, false, context.Log);
await PushCommandTestHook.RunCore(context.LocalSettings, context.Source, new List <string>() { zipFile2.FullName }, false, context.Log);
var validateOutput = await ValidateCommandTestHook.RunCore(context.LocalSettings, context.Source, context.Log);
// read outputs
var catalogEntries = await catalog.GetIndexEntries();
var catalogExistingEntries = await catalog.GetExistingPackagesIndex();
var regPackages = await registration.GetPackagesById("packageA");
var indexPackages = await packageIndex.GetPackages();
var searchPackages = await search.GetPackages();
var autoCompletePackages = await autoComplete.GetPackageIds();
// Assert
Assert.Equal(0, 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 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 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 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);
}
}
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();
}
}
private async Task <bool> PushAsync(
IEnumerable <string> items,
PushOptions options)
{
LocalSettings settings = GetSettings();
AzureFileSystem fileSystem = GetAzureFileSystem();
SleetLogger log = new SleetLogger(Log);
var packagesToPush = items.ToList();
if (!options.AllowOverwrite && options.PassIfExistingItemIdentical)
{
var context = new SleetContext
{
LocalSettings = settings,
Log = log,
Source = fileSystem,
Token = CancellationToken
};
context.SourceSettings = await FeedSettingsUtility.GetSettingsOrDefault(
context.Source,
context.Log,
context.Token);
var flatContainer = new FlatContainer(context);
var packageIndex = new PackageIndex(context);
// Check packages sequentially: Task.WhenAll caused IO exceptions in Sleet.
for (int i = packagesToPush.Count - 1; i >= 0; i--)
{
string item = packagesToPush[i];
bool?identical = await IsPackageIdenticalOnFeedAsync(
item,
packageIndex,
context.Source,
flatContainer,
log);
if (identical == null)
{
continue;
}
packagesToPush.RemoveAt(i);
if (identical == true)
{
Log.LogMessage(
MessageImportance.Normal,
"Package exists on the feed, and is verified to be identical. " +
$"Skipping upload: '{item}'");
}
else
{
Log.LogError(
"Package exists on the feed, but contents are different. " +
$"Upload failed: '{item}'");
}
}
if (!packagesToPush.Any())
{
Log.LogMessage("After skipping idempotent uploads, no items need pushing.");
return(true);
}
}
return(await PushCommand.RunAsync(
settings,
fileSystem,
packagesToPush,
options.AllowOverwrite,
skipExisting : false,
log : log));
}
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);
}
}
}
