public void MapsProperties()
{
var v1 = NuGetVersion.Parse("1.0.0");
var changes = MutableIndexChanges.FromLatestIndexChanges(new Dictionary <SearchFilters, LatestIndexChanges>
{
{
SearchFilters.Default,
new LatestIndexChanges(
SearchIndexChangeType.AddFirst,
new List <HijackIndexChange>
{
HijackIndexChange.UpdateMetadata(v1),
HijackIndexChange.SetLatestToTrue(v1),
})
},
});
var solid = changes.Solidify();
Assert.Equal(new[] { SearchFilters.Default }, solid.Search.Keys.ToArray());
Assert.Equal(SearchIndexChangeType.AddFirst, solid.Search[SearchFilters.Default]);
Assert.False(solid.Hijack[v1].Delete);
Assert.True(solid.Hijack[v1].UpdateMetadata);
Assert.True(solid.Hijack[v1].LatestStableSemVer1);
Assert.False(solid.Hijack[v1].LatestSemVer1);
Assert.False(solid.Hijack[v1].LatestStableSemVer2);
Assert.False(solid.Hijack[v1].LatestSemVer2);
}
public void Merge(MutableIndexChanges added)
{
if (added == null)
{
throw new ArgumentNullException(nameof(added));
}
foreach (var pair in added.SearchChanges)
{
MergeSearchIndexChanges(pair.Key, pair.Value);
}
foreach (var pair in added.HijackChanges)
{
MergeHijackIndexChanges(pair.Key, pair.Value);
}
// Verify that there are not multiple latest versions per search filter.
foreach (var searchFilters in DocumentUtilities.AllSearchFilters)
{
var latest = HijackDocuments
.Where(x => x.Value.GetLatest(searchFilters).GetValueOrDefault(false))
.Select(x => x.Key.ToFullString())
.ToList();
Guard.Assert(
latest.Count <= 1,
$"There are {latest.Count} versions set to be latest on search filter {searchFilters}: {string.Join(", ", latest)}");
}
}
private MutableIndexChanges Upsert(
string fullVersion,
NuGetVersion parsedVersion,
VersionPropertiesData data)
{
var added = new VersionProperties(fullVersion, parsedVersion, data);
_versionProperties[added.ParsedVersion] = KeyValuePair.Create(added.FullVersion, data);
// Detect changes related to the latest versions, per search filter.
var output = new Dictionary <SearchFilters, LatestIndexChanges>();
foreach (var pair in _versionLists)
{
var searchFilter = pair.Key;
var listState = pair.Value;
var predicate = SearchFilterPredicates[searchFilter];
LatestIndexChanges latestIndexChanges;
if (predicate(added))
{
latestIndexChanges = listState.Upsert(added.Filtered);
}
else
{
latestIndexChanges = listState.Remove(added.ParsedVersion);
}
output[searchFilter] = latestIndexChanges;
}
return(MutableIndexChanges.FromLatestIndexChanges(output));
}
internal MutableIndexChanges ApplyChangesInternal(IEnumerable <VersionListChange> changes)
{
var mutableChanges = new MutableIndexChanges();
// Process the changes in descending order.
var sortedChanges = changes
.OrderByDescending(x => x.ParsedVersion)
.ToList();
// Verify that there is only one change per version.
var versionsWithMultipleChanges = sortedChanges
.GroupBy(x => x.ParsedVersion)
.OrderBy(x => x.Key)
.Select(x => KeyValuePair.Create(x.Key.ToFullString(), x.Count()))
.Where(x => x.Value > 1)
.ToList();
if (versionsWithMultipleChanges.Any())
{
throw new ArgumentException(
$"There are multiple changes for the following version(s): " +
string.Join(", ", versionsWithMultipleChanges.Select(x => $"{x.Key} ({x.Value} changes)")),
nameof(changes));
}
foreach (var change in sortedChanges)
{
MutableIndexChanges versionChanges;
if (!change.IsDelete)
{
versionChanges = Upsert(change.FullVersion, change.ParsedVersion, change.Data);
}
else
{
versionChanges = Delete(change.ParsedVersion);
}
mutableChanges.Merge(versionChanges);
}
// Verify that we are updating the metadata of all non-delete changes.
foreach (var change in changes)
{
Guard.Assert(
mutableChanges.HijackDocuments.ContainsKey(change.ParsedVersion),
$"The should be a hijack document for each changed version. Version {change.FullVersion} does " +
"not have a hijack document.");
if (!change.IsDelete)
{
Guard.Assert(
mutableChanges.HijackDocuments[change.ParsedVersion].UpdateMetadata == true,
$"The metadata of version {change.FullVersion} should be updated.");
}
}
return(mutableChanges);
}
internal MutableIndexChanges Delete(NuGetVersion parsedVersion)
{
_versionProperties.Remove(parsedVersion);
// Detect changes related to the latest versions, per search filter.
var output = new Dictionary <SearchFilters, LatestIndexChanges>();
foreach (var pair in _versionLists)
{
var searchFilter = pair.Key;
var listState = pair.Value;
// We can execute this on all lists, no matter the search filter predicate because removing a version
// that was never added will result in recalculating the version list, which supports the reflow
// scenario.
output[searchFilter] = listState.Delete(parsedVersion);
}
return(MutableIndexChanges.FromLatestIndexChanges(output));
}
