public async Task ProcessAsync_WhenNewPackageVersionWouldChangeExistingPage_RepaginatesExistingPage()
{
const int partitionSize = 2;
var pages = new List <ExpectedPage>();
CatalogIndependentPackageDetails packageDetails;
IReadOnlyDictionary <string, IGraph> newItem;
MemoryStorage storage;
IReadOnlyList <ExpectedPage> expectedPages;
for (var i = 0; i < 2; ++i)
{
packageDetails = new CatalogIndependentPackageDetails(id: "a", version: $"1.0.{i * 2}");
newItem = CreateNewItem(packageDetails);
storage = await ProcessAsync(newItem, packageDetails.Id, partitionSize);
pages.Add(new ExpectedPage(packageDetails));
expectedPages = Repaginate(pages, partitionSize);
Verify(storage, expectedPages, partitionSize);
}
packageDetails = new CatalogIndependentPackageDetails(id: "a", version: "1.0.1");
newItem = CreateNewItem(packageDetails);
storage = await ProcessAsync(newItem, packageDetails.Id, partitionSize);
pages.Insert(index: 1, item: new ExpectedPage(packageDetails));
expectedPages = Repaginate(pages, partitionSize);
Verify(storage, expectedPages, partitionSize);
}
private void VerifyRegistrationPackage(
MemoryStorage registrationStorage,
RegistrationPackage package,
CatalogIndependentPackageDetails packageDetails,
string commitId,
string commitTimeStamp)
{
var packageId = packageDetails.Id.ToLowerInvariant();
var packageVersion = packageDetails.Version.ToLowerInvariant();
var packageVersionUri = GetRegistrationPackageVersionUri(packageId, packageVersion);
var packageContentUri = GetPackageContentUri(_contentBaseAddress, packageId, packageVersion);
Assert.Equal(packageVersionUri.AbsoluteUri, package.IdKeyword);
Assert.Equal(CatalogConstants.Package, package.TypeKeyword);
Assert.Equal(commitId, package.CommitId);
Assert.Equal(commitTimeStamp, package.CommitTimeStamp);
Assert.Equal(packageDetails.IdKeyword, package.CatalogEntry.IdKeyword);
Assert.Equal(CatalogConstants.PackageDetails, package.CatalogEntry.TypeKeyword);
Assert.Equal(packageDetails.Authors, package.CatalogEntry.Authors);
Assert.Equal(packageDetails.Description, package.CatalogEntry.Description);
Assert.Empty(package.CatalogEntry.IconUrl);
Assert.Equal(packageDetails.Id, package.CatalogEntry.Id);
Assert.Empty(package.CatalogEntry.Language);
Assert.Empty(package.CatalogEntry.LicenseUrl);
Assert.Equal(packageDetails.Listed, package.CatalogEntry.Listed);
Assert.Empty(package.CatalogEntry.MinClientVersion);
Assert.Equal(packageContentUri.AbsoluteUri, package.CatalogEntry.PackageContent);
Assert.Empty(package.CatalogEntry.ProjectUrl);
Assert.Equal(GetRegistrationDateTime(packageDetails.Published), package.CatalogEntry.Published);
Assert.Equal(packageDetails.RequireLicenseAcceptance, package.CatalogEntry.RequireLicenseAcceptance);
Assert.Empty(package.CatalogEntry.Summary);
Assert.Equal(new[] { string.Empty }, package.CatalogEntry.Tags);
Assert.Empty(package.CatalogEntry.Title);
Assert.Equal(packageDetails.Version, package.CatalogEntry.Version);
var independentPackageUri = GetRegistrationPackageVersionUri(packageId, packageVersion);
var independentPackage = GetStorageContent <RegistrationIndependentPackage>(
registrationStorage,
independentPackageUri);
VerifyRegistrationIndependentPackage(
registrationStorage,
independentPackage,
independentPackageUri,
packageDetails,
packageId,
packageVersion);
}
private static IReadOnlyDictionary <string, IGraph> CreateNewItem(CatalogIndependentPackageDetails packageDetails)
{
var json = JsonConvert.SerializeObject(packageDetails, _jsonSettings);
using (var reader = new JsonTextReader(new StringReader(json)))
{
reader.DateParseHandling = DateParseHandling.DateTimeOffset; // make sure we always preserve timezone info
var jObject = JObject.Load(reader);
var graph = Utils.CreateGraph(jObject, readOnly: true);
return(new Dictionary <string, IGraph>()
{
{ packageDetails.IdKeyword, graph }
});
}
}
public async Task ProcessAsync_WithCustomPartitionSize_FillsPages(int partitionSize)
{
// The idea here is that we should see pages filled before a new pages is created.
// Ultimately, we should have 2 filled pages plus one unfilled page.
var packageVersionCount = partitionSize * 2 + 1;
var pages = new List <ExpectedPage>();
for (var i = 0; i < packageVersionCount; ++i)
{
var packageDetails = new CatalogIndependentPackageDetails(id: "A", version: $"1.0.{i}");
var newItem = CreateNewItem(packageDetails);
var storage = await ProcessAsync(newItem, packageDetails.Id, partitionSize);
pages.Add(new ExpectedPage(packageDetails));
var expectedPages = Repaginate(pages, partitionSize);
Verify(storage, expectedPages, partitionSize);
}
}
private void VerifyRegistrationIndependentPackage(
MemoryStorage registrationStorage,
RegistrationIndependentPackage package,
Uri packageUri,
CatalogIndependentPackageDetails packageDetails,
string packageId,
string packageVersion)
{
var packageContentUri = GetPackageContentUri(_contentBaseAddress, packageId, packageVersion);
var packageIndexUri = GetRegistrationPackageIndexUri(registrationStorage.BaseAddress);
Assert.Equal(packageUri.AbsoluteUri, package.IdKeyword);
Assert.Equal(
new[] { CatalogConstants.Package, CatalogConstants.NuGetCatalogSchemaPermalinkUri },
package.TypeKeyword);
Assert.Equal(packageDetails.Listed, package.Listed);
Assert.Equal(packageContentUri.AbsoluteUri, package.PackageContent);
Assert.Equal(GetRegistrationDateTime(packageDetails.Published), package.Published);
Assert.Equal(packageIndexUri.AbsoluteUri, package.Registration);
var expectedContext = new JObject(
new JProperty(CatalogConstants.VocabKeyword, CatalogConstants.NuGetSchemaUri),
new JProperty(CatalogConstants.Xsd, CatalogConstants.XmlSchemaUri),
new JProperty(CatalogConstants.CatalogEntry,
new JObject(
new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.IdKeyword))),
new JProperty(CatalogConstants.Registration,
new JObject(
new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.IdKeyword))),
new JProperty(CatalogConstants.PackageContent,
new JObject(
new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.IdKeyword))),
new JProperty(CatalogConstants.Published,
new JObject(
new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime))));
Assert.Equal(expectedContext.ToString(), package.ContextKeyword.ToString());
}
public async Task ProcessAsync_WithCustomPackageCountThreshold_TransitionsToPageWhenThresholdHit()
{
const int partitionSize = 2;
const int packageCountThreshold = 2;
var pages = new List <ExpectedPage>();
CatalogIndependentPackageDetails packageDetails;
IReadOnlyDictionary <string, IGraph> newItem;
MemoryStorage storage;
IReadOnlyList <ExpectedPage> expectedPages;
for (var i = 0; i < 2; ++i)
{
packageDetails = new CatalogIndependentPackageDetails(id: "a", version: $"1.0.{i}");
newItem = CreateNewItem(packageDetails);
storage = await ProcessAsync(newItem, packageDetails.Id, partitionSize, packageCountThreshold);
pages.Add(new ExpectedPage(packageDetails));
expectedPages = Repaginate(pages, partitionSize);
Verify(storage, expectedPages, partitionSize, packageCountThreshold);
}
}
public async Task ProcessAsync_WithVariablePartitionSize_RepaginatesExistingPages()
{
var partitionSize = 2;
var packageVersionCount = partitionSize * 2;
var pages = new List <ExpectedPage>();
CatalogIndependentPackageDetails packageDetails;
IReadOnlyDictionary <string, IGraph> newItem;
MemoryStorage storage;
IReadOnlyList <ExpectedPage> expectedPages;
for (var i = 0; i < packageVersionCount; ++i)
{
packageDetails = new CatalogIndependentPackageDetails(id: "a", version: $"1.0.{i}");
newItem = CreateNewItem(packageDetails);
storage = await ProcessAsync(newItem, packageDetails.Id, partitionSize);
pages.Add(new ExpectedPage(packageDetails));
expectedPages = Repaginate(pages, partitionSize);
Verify(storage, expectedPages, partitionSize);
}
partitionSize = 3;
++packageVersionCount;
packageDetails = new CatalogIndependentPackageDetails(id: "a", version: $"1.0.{packageVersionCount}");
newItem = CreateNewItem(packageDetails);
storage = await ProcessAsync(newItem, packageDetails.Id, partitionSize);
pages.Add(new ExpectedPage(packageDetails));
expectedPages = Repaginate(pages, partitionSize);
Verify(storage, expectedPages, partitionSize);
}
public async Task RunAsync_WhenPackageIdSpansCommitsAndVariesInCasing_BatchesAcrossCommitsByLowerCasePackageId()
{
var pageUri = new Uri(_baseUri, "v3-catalog0/page0.json");
var indexUri = new Uri(_baseUri, "v3-catalog0/index.json");
var contentBaseUri = new Uri(_baseUri, "packages");
SharedInit(useLegacy: true, useSemVer2: true, baseUri: _baseUri, indexUri: indexUri, contentBaseUri: contentBaseUri);
var commitId1 = Guid.NewGuid().ToString();
var commitId2 = Guid.NewGuid().ToString();
var commitTimeStamp1 = DateTimeOffset.UtcNow.AddMinutes(-1);
var commitTimeStamp2 = commitTimeStamp1.AddMinutes(1);
var independentPackageDetails1 = new CatalogIndependentPackageDetails(
id: "ABC",
version: "1.0.0",
baseUri: _baseUri.AbsoluteUri,
commitId: commitId1,
commitTimeStamp: commitTimeStamp1);
var independentPackageDetails2 = new CatalogIndependentPackageDetails(
id: "AbC",
version: "1.0.1",
baseUri: _baseUri.AbsoluteUri,
commitId: commitId1,
commitTimeStamp: commitTimeStamp1);
var independentPackageDetails3 = new CatalogIndependentPackageDetails(
id: "abc",
version: "1.0.2",
baseUri: _baseUri.AbsoluteUri,
commitId: commitId2,
commitTimeStamp: commitTimeStamp2);
var packageDetails = new[]
{
CatalogPackageDetails.Create(independentPackageDetails1),
CatalogPackageDetails.Create(independentPackageDetails2),
CatalogPackageDetails.Create(independentPackageDetails3)
};
var independentPage = new CatalogIndependentPage(
pageUri.AbsoluteUri,
CatalogConstants.CatalogPage,
commitId2,
commitTimeStamp2.ToString(CatalogConstants.CommitTimeStampFormat),
packageDetails.Length,
indexUri.AbsoluteUri,
packageDetails,
_contextKeyword);
var index = CatalogIndex.Create(independentPage, _contextKeyword);
var catalogStorage = new MemoryStorage(_baseUri);
catalogStorage.Content.TryAdd(indexUri, CreateStringStorageContent(index));
catalogStorage.Content.TryAdd(pageUri, CreateStringStorageContent(independentPage));
catalogStorage.Content.TryAdd(
new Uri(independentPackageDetails1.IdKeyword),
CreateStringStorageContent(independentPackageDetails1));
catalogStorage.Content.TryAdd(
new Uri(independentPackageDetails2.IdKeyword),
CreateStringStorageContent(independentPackageDetails2));
catalogStorage.Content.TryAdd(
new Uri(independentPackageDetails3.IdKeyword),
CreateStringStorageContent(independentPackageDetails3));
await _mockServer.AddStorageAsync(catalogStorage);
await _target.RunAsync(CancellationToken.None);
var expectedPage = new ExpectedPage(independentPackageDetails1, independentPackageDetails2, independentPackageDetails3);
Verify(_legacyStorage, expectedPage);
Verify(_semVer2Storage, expectedPage);
}
private void VerifyRegistrationPackage(
MemoryStorage registrationStorage,
RegistrationPackage package,
CatalogIndependentPackageDetails packageDetails,
string commitId,
string commitTimeStamp,
bool filterOutDeprecation)
{
var packageId = packageDetails.Id.ToLowerInvariant();
var packageVersion = packageDetails.Version.ToLowerInvariant();
var packageVersionUri = GetRegistrationPackageVersionUri(packageId, packageVersion);
var packageContentUri = GetPackageContentUri(_contentBaseAddress, packageId, packageVersion);
Assert.Equal(packageVersionUri.AbsoluteUri, package.IdKeyword);
Assert.Equal(CatalogConstants.Package, package.TypeKeyword);
Assert.Equal(commitId, package.CommitId);
Assert.Equal(commitTimeStamp, package.CommitTimeStamp);
Assert.Equal(packageDetails.IdKeyword, package.CatalogEntry.IdKeyword);
Assert.Equal(CatalogConstants.PackageDetails, package.CatalogEntry.TypeKeyword);
Assert.Equal(packageDetails.Authors, package.CatalogEntry.Authors);
Assert.Equal(packageDetails.Description, package.CatalogEntry.Description);
Assert.Empty(package.CatalogEntry.IconUrl);
Assert.Equal(packageDetails.Id, package.CatalogEntry.Id);
Assert.Empty(package.CatalogEntry.Language);
Assert.Empty(package.CatalogEntry.LicenseUrl);
Assert.Equal(packageDetails.Listed, package.CatalogEntry.Listed);
Assert.Empty(package.CatalogEntry.MinClientVersion);
Assert.Equal(packageContentUri.AbsoluteUri, package.CatalogEntry.PackageContent);
Assert.Empty(package.CatalogEntry.ProjectUrl);
Assert.Equal(GetRegistrationDateTime(packageDetails.Published), package.CatalogEntry.Published);
Assert.Equal(packageDetails.RequireLicenseAcceptance, package.CatalogEntry.RequireLicenseAcceptance);
Assert.Empty(package.CatalogEntry.Summary);
Assert.Equal(new[] { string.Empty }, package.CatalogEntry.Tags);
Assert.Empty(package.CatalogEntry.Title);
Assert.Equal(packageDetails.Version, package.CatalogEntry.Version);
var actualDeprecation = package.CatalogEntry.Deprecation;
var expectedDeprecation = packageDetails.Deprecation;
if (filterOutDeprecation || expectedDeprecation == null)
{
Assert.Null(actualDeprecation);
}
else
{
Assert.NotNull(actualDeprecation);
Assert.Equal(expectedDeprecation.Reasons.OrderBy(r => r), actualDeprecation.Reasons.OrderBy(r => r));
Assert.Equal(expectedDeprecation.Message, actualDeprecation.Message);
var actualDeprecationAltPackage = actualDeprecation.AlternatePackage;
var expectedDeprecationAltPackage = expectedDeprecation.AlternatePackage;
if (expectedDeprecationAltPackage == null)
{
Assert.Null(actualDeprecationAltPackage);
}
else
{
Assert.NotNull(actualDeprecationAltPackage);
Assert.Equal(expectedDeprecationAltPackage.Id, actualDeprecationAltPackage.Id);
Assert.Equal(expectedDeprecationAltPackage.Range, actualDeprecationAltPackage.Range);
}
}
var independentPackageUri = GetRegistrationPackageVersionUri(packageId, packageVersion);
var independentPackage = GetStorageContent <RegistrationIndependentPackage>(
registrationStorage,
independentPackageUri);
VerifyRegistrationIndependentPackage(
registrationStorage,
independentPackage,
independentPackageUri,
packageDetails,
packageId,
packageVersion);
}
