private async Task <SortedList <DateTime, IList <FeedPackageIdentity> > > GetDeletedPackages(IStorage auditingStorage, DateTime since)
{
var result = new SortedList <DateTime, IList <FeedPackageIdentity> >();
// Get all audit blobs (based on their filename which starts with a date that can be parsed)
// NOTE we're getting more files than needed (to account for a time difference between servers)
var minimumFileTime = since.AddMinutes(-15);
var auditEntries = await DeletionAuditEntry.GetAsync(auditingStorage, CancellationToken.None,
minTime : minimumFileTime, logger : Logger);
foreach (var auditEntry in auditEntries)
{
if (!string.IsNullOrEmpty(auditEntry.PackageId) && !string.IsNullOrEmpty(auditEntry.PackageVersion) && auditEntry.TimestampUtc > since)
{
// Mark the package "deleted"
if (!result.TryGetValue(auditEntry.TimestampUtc.Value, out var packages))
{
packages = new List <FeedPackageIdentity>();
result.Add(auditEntry.TimestampUtc.Value, packages);
}
packages.Add(new FeedPackageIdentity(auditEntry.PackageId, auditEntry.PackageVersion));
}
}
return(result);
}
/// <summary>
/// Runs <see cref="IValidator"/>s from the <see cref="IAggregateValidator"/>s against a package.
/// </summary>
/// <returns>A <see cref="PackageValidationResult"/> generated from the results of the <see cref="IValidator"/>s.</returns>
public async Task <PackageValidationResult> ValidateAsync(PackageValidatorContext context, CollectorHttpClient client, CancellationToken cancellationToken)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
cancellationToken.ThrowIfCancellationRequested();
var package = new PackageIdentity(context.Package.Id, NuGetVersion.Parse(context.Package.Version));
var deletionAuditEntries = await DeletionAuditEntry.GetAsync(
_auditingStorageFactory,
cancellationToken,
package,
logger : _logger);
var validationContext = new ValidationContext(
package,
context.CatalogEntries,
deletionAuditEntries,
_feedToSource,
client,
cancellationToken,
_contextLogger);
var results = await Task.WhenAll(AggregateValidators.Select(endpoint => endpoint.ValidateAsync(validationContext)).ToList());
return(new PackageValidationResult(validationContext, results));
}
public async Task GetDeletionAuditRecords_HandlesEmptyStorage()
{
var auditingStorage = new MemoryStorage();
var records = await DeletionAuditEntry.GetAsync(auditingStorage, CancellationToken.None, logger : _logger);
Assert.Empty(records);
}
public async Task GetDeletionAuditRecords_FiltersOnAll_EntryExists()
{
// Arrange
var auditingStorage = new MemoryStorage();
var targetPackageIdentity = new PackageIdentity("targetPackage", NuGetVersion.Parse("3.2.1"));
var minTimestamp = DefaultAuditRecordTimeStamp.Subtract(new TimeSpan(2, 0, 0));
var maxTimestamp = DefaultAuditRecordTimeStamp.Subtract(new TimeSpan(1, 0, 0));
AddAuditRecordToMemoryStorage(auditingStorage, targetPackageIdentity, timestamp: minTimestamp.Add(new TimeSpan((maxTimestamp.Ticks - minTimestamp.Ticks) / 2)));
AddDummyAuditRecords(auditingStorage, (count) => targetPackageIdentity.Id, (count) => targetPackageIdentity.Version.ToNormalizedString());
// Act
var auditEntries = await DeletionAuditEntry.GetAsync(CreateStorageFactory(auditingStorage, targetPackageIdentity), CancellationToken.None, targetPackageIdentity, minTimestamp, maxTimestamp, logger : _logger);
// Assert
Assert.Equal(1, auditEntries.Count());
var auditEntry = auditEntries.ElementAt(0);
Assert.Equal(targetPackageIdentity.Id, auditEntry.PackageId);
Assert.Equal(targetPackageIdentity.Version.ToString(), auditEntry.PackageVersion);
Assert.True(auditEntry.TimestampUtc.HasValue);
Assert.True(auditEntry.TimestampUtc.Value.Ticks >= minTimestamp.Ticks);
Assert.True(auditEntry.TimestampUtc.Value.Ticks <= maxTimestamp.Ticks);
}
public PackageStatusOutdatedCheck(
DeletionAuditEntry auditEntry)
: this(
new FeedPackageIdentity(auditEntry.PackageId, ParseVersionString(auditEntry.PackageVersion)),
auditEntry.TimestampUtc.Value)
{
}
public void DeletionAuditEntries_ReturnsCorrectValue()
{
var entry = new DeletionAuditEntry();
var entries = new[] { entry };
var context = CreateContext(deletionAuditEntries: entries);
Assert.Equal(entries.Length, context.DeletionAuditEntries.Count);
Assert.Same(entry, context.DeletionAuditEntries[0]);
}
public async Task GetDeletionAuditRecords_FiltersOnPackage_EntryMissing()
{
// Arrange
var auditingStorage = new MemoryStorage();
var targetPackageIdentity = new PackageIdentity("targetPackage", NuGetVersion.Parse("3.2.1"));
// Act
var auditEntries = await DeletionAuditEntry.GetAsync(CreateStorageFactory(auditingStorage, targetPackageIdentity), CancellationToken.None, targetPackageIdentity, logger : _logger);
// Assert
Assert.Empty(auditEntries);
}
public async Task GetDeletionAuditRecords_FiltersOnMaxTimestamp_EntryMissing()
{
// Arrange
var auditingStorage = new MemoryStorage();
var maxTimestamp = DefaultAuditRecordTimeStamp.Subtract(new TimeSpan(1, 0, 0));
AddDummyAuditRecords(auditingStorage);
// Act
var auditEntries = await DeletionAuditEntry.GetAsync(auditingStorage, CancellationToken.None, maxTime : maxTimestamp, logger : _logger);
// Assert
Assert.Empty(auditEntries);
}
public static void AssertDeletionAuditEntry(DeletionAuditEntry expected, DeletionAuditEntry actual)
{
if (expected == null)
{
Assert.Null(actual);
return;
}
AssertFieldEqual(expected, actual, i => i.PackageId);
AssertFieldEqual(expected, actual, i => i.PackageVersion);
AssertFieldEqual(expected, actual, i => i.Record);
AssertFieldEqual(expected, actual, i => i.TimestampUtc);
AssertFieldEqual(expected, actual, i => i.Uri);
}
/// <summary>
/// Runs <see cref="IValidator"/>s from the <see cref="IAggregateValidator"/>s against a package.
/// </summary>
/// <returns>A <see cref="PackageValidationResult"/> generated from the results of the <see cref="IValidator"/>s.</returns>
public async Task <PackageValidationResult> ValidateAsync(PackageValidatorContext context, CollectorHttpClient client, CancellationToken cancellationToken)
{
var package = new PackageIdentity(context.Package.Id, NuGetVersion.Parse(context.Package.Version));
var deletionAuditEntries = await DeletionAuditEntry.GetAsync(
_auditingStorageFactory,
cancellationToken,
package,
logger : _logger);
var validationContext = new ValidationContext(package, context.CatalogEntries, deletionAuditEntries, client, cancellationToken);
var results = await Task.WhenAll(AggregateValidators.Select(endpoint => endpoint.ValidateAsync(validationContext)).ToList());
return(new PackageValidationResult(validationContext, results));
}
public async Task GetDeletionAuditRecords_FiltersOnAll_EntryMissing()
{
// Arrange
var auditingStorage = new MemoryStorage();
var targetPackageIdentity = new PackageIdentity("targetPackage", NuGetVersion.Parse("3.2.1"));
var minTimestamp = DefaultAuditRecordTimeStamp.Subtract(new TimeSpan(2, 0, 0));
var maxTimestamp = DefaultAuditRecordTimeStamp.Subtract(new TimeSpan(1, 0, 0));
AddDummyAuditRecords(auditingStorage, (count) => targetPackageIdentity.Id, (count) => targetPackageIdentity.Version.ToNormalizedString());
// Act
var auditEntries = await DeletionAuditEntry.GetAsync(CreateStorageFactory(auditingStorage, targetPackageIdentity), CancellationToken.None, targetPackageIdentity, minTimestamp, maxTimestamp, logger : _logger);
// Assert
Assert.Empty(auditEntries);
}
public async Task GetDeletionAuditRecords_FiltersOnPackage_EntryExists()
{
// Arrange
var auditingStorage = new MemoryStorage();
var targetPackageIdentity = new PackageIdentity("targetPackage", NuGetVersion.Parse("3.2.1"));
AddAuditRecordToMemoryStorage(auditingStorage, targetPackageIdentity);
// Act
var auditEntries = await DeletionAuditEntry.GetAsync(CreateStorageFactory(auditingStorage, targetPackageIdentity), CancellationToken.None, targetPackageIdentity, logger : _logger);
// Assert
Assert.Equal(1, auditEntries.Count());
var auditEntry = auditEntries.ElementAt(0);
Assert.Equal(targetPackageIdentity.Id, auditEntry.PackageId);
Assert.Equal(targetPackageIdentity.Version.ToString(), auditEntry.PackageVersion);
}
public async Task GetDeletionAuditRecords_FiltersOnMinTimestamp_EntryExists()
{
// Arrange
var auditingStorage = new MemoryStorage();
var minTimestamp = DefaultAuditRecordTimeStamp.Add(new TimeSpan(1, 0, 0));
AddAuditRecordToMemoryStorage(auditingStorage, package: null, timestamp: minTimestamp);
AddDummyAuditRecords(auditingStorage);
// Act
var auditEntries = await DeletionAuditEntry.GetAsync(auditingStorage, CancellationToken.None, minTime : minTimestamp, logger : _logger);
// Assert
Assert.Equal(1, auditEntries.Count());
var auditEntry = auditEntries.ElementAt(0);
Assert.True(auditEntry.TimestampUtc.HasValue);
Assert.True(auditEntry.TimestampUtc.Value.Ticks >= minTimestamp.Ticks);
}
public async Task GetDeletionAuditRecords_WithoutFilter()
{
// Arrange
var auditingStorage = new MemoryStorage();
var addedAuditEntries = AddDummyAuditRecords(auditingStorage);
// Act
var auditEntries = await DeletionAuditEntry.GetAsync(auditingStorage, CancellationToken.None, logger : _logger);
// Assert
Assert.Equal(addedAuditEntries.Item1, auditEntries.Count());
for (var i = 0; i < addedAuditEntries.Item1; i++)
{
Assert.Contains(auditEntries,
entry =>
entry.PackageId == addedAuditEntries.Item2[i] &&
entry.PackageVersion == addedAuditEntries.Item3[i] &&
entry.TimestampUtc.HasValue &&
entry.TimestampUtc.Value.Ticks == addedAuditEntries.Item4[i].Ticks);
}
}
