private async Task RunPackageValidatorAsync(
PackageValidatorContext queuedContext,
CancellationToken token)
{
var feedPackage = queuedContext.Package;
Logger.LogInformation("Running PackageValidator on PackageValidatorContext for {PackageId} {PackageVersion}.", feedPackage.Id, feedPackage.Version);
var catalogEntries = queuedContext.CatalogEntries;
var existingStatus = await _statusService.GetAsync(feedPackage, token);
if (catalogEntries != null && existingStatus?.ValidationResult?.CatalogEntries != null && CompareCatalogEntries(catalogEntries, existingStatus.ValidationResult.CatalogEntries))
{
// A newer catalog entry of this package has already been validated.
Logger.LogInformation("A newer catalog entry of {PackageId} {PackageVersion} has already been processed ({OldCommitTimeStamp} < {NewCommitTimeStamp}).",
feedPackage.Id, feedPackage.Version,
catalogEntries.Max(c => c.CommitTimeStamp),
existingStatus.ValidationResult.CatalogEntries.Max(c => c.CommitTimeStamp));
return;
}
var context = new PackageValidatorContext(feedPackage, catalogEntries);
var result = await _packageValidator.ValidateAsync(context, _client, token);
await _notificationService.OnPackageValidationFinishedAsync(result, token);
var status = new PackageMonitoringStatus(result);
PackageMonitoringStatusAccessConditionHelper.UpdateFromExisting(status, existingStatus);
await _statusService.UpdateAsync(status, token);
}
public void Constructor_WhenArgumentsAreValid_InitializesInstance(CatalogIndexEntry[] catalogEntries)
{
var context = new PackageValidatorContext(_feedPackageIdentity, catalogEntries);
Assert.Same(_feedPackageIdentity, context.Package);
Assert.Same(catalogEntries, context.CatalogEntries);
}
private async Task SaveFailedPackageMonitoringStatusAsync(
PackageValidatorContext queuedContext,
Exception exception,
CancellationToken token)
{
var feedPackage = new FeedPackageIdentity(queuedContext.Package.Id, queuedContext.Package.Version);
await _notificationService.OnPackageValidationFailedAsync(feedPackage.Id, feedPackage.Version, exception, token);
var status = new PackageMonitoringStatus(feedPackage, exception);
await _statusService.UpdateAsync(status, token);
}
private async Task SaveFailedPackageMonitoringStatusAsync(
PackageValidatorContext queuedContext,
Exception exception,
CancellationToken token)
{
var queuedVersion = queuedContext.Package.Version;
var version = NuGetVersion.TryParse(queuedVersion, out var parsedVersion)
? parsedVersion.ToFullString() : queuedVersion;
var feedPackage = new FeedPackageIdentity(queuedContext.Package.Id, version);
await _notificationService.OnPackageValidationFailedAsync(feedPackage.Id, feedPackage.Version, exception, token);
var status = new PackageMonitoringStatus(feedPackage, exception);
await _statusService.UpdateAsync(status, token);
}
public void Constructor_WhenArgumentsAreValid_InitializesInstance()
{
var catalogEntries = new[]
{
new CatalogIndexEntry(
new Uri("https://nuget.test/a"),
CatalogConstants.NuGetPackageDetails,
Guid.NewGuid().ToString(),
DateTime.UtcNow,
_packageIdentity)
};
var context = new PackageValidatorContext(_feedPackageIdentity, catalogEntries);
Assert.Same(_feedPackageIdentity, context.Package);
Assert.Same(catalogEntries, context.CatalogEntries);
}
private async Task ProcessPackagesAsync(
ConcurrentBag <PackageStatusOutdatedCheck> checkBag, CancellationToken cancellationToken)
{
while (checkBag.TryTake(out var check))
{
if (await IsStatusOutdatedAsync(check, cancellationToken))
{
Logger.LogWarning("Status for {Id} {Version} is outdated!", check.Identity.Id, check.Identity.Version);
var context = new PackageValidatorContext(check.Identity, null);
await _packageValidatorContextQueue.AddAsync(context, cancellationToken);
}
else
{
Logger.LogInformation("Status for {Id} {Version} is up to date.", check.Identity.Id, check.Identity.Version);
}
}
}
private async Task RunPackageValidatorAsync(
PackageValidatorContext queuedContext,
CancellationToken token)
{
var feedPackage = queuedContext.Package;
Logger.LogInformation("Running PackageValidator on PackageValidatorContext for {PackageId} {PackageVersion}.", feedPackage.Id, feedPackage.Version);
IEnumerable <CatalogIndexEntry> catalogEntries = null;
if (queuedContext.CatalogEntries != null)
{
catalogEntries = queuedContext.CatalogEntries;
}
else
{
Logger.LogInformation("PackageValidatorContext for {PackageId} {PackageVersion} is missing catalog entries! " +
"Attempting to fetch most recent catalog entry from registration.",
feedPackage.Id, feedPackage.Version);
catalogEntries = await FetchCatalogIndexEntriesFromRegistrationAsync(feedPackage, token);
}
var existingStatus = await _statusService.GetAsync(feedPackage, token);
if (existingStatus?.ValidationResult != null && CompareCatalogEntries(catalogEntries, existingStatus.ValidationResult.CatalogEntries))
{
// A newer catalog entry of this package has already been validated.
Logger.LogInformation("A newer catalog entry of {PackageId} {PackageVersion} has already been processed ({OldCommitTimeStamp} < {NewCommitTimeStamp}).",
feedPackage.Id, feedPackage.Version,
catalogEntries.Max(c => c.CommitTimeStamp),
existingStatus.ValidationResult.CatalogEntries.Max(c => c.CommitTimeStamp));
return;
}
var context = new PackageValidatorContext(feedPackage, catalogEntries);
var result = await _packageValidator.ValidateAsync(context, _client, token);
await _notificationService.OnPackageValidationFinishedAsync(result, token);
var status = new PackageMonitoringStatus(result);
await _statusService.UpdateAsync(status, token);
}
public async Task ValidateAsync_WhenCancellationTokenIsCancelled_Throws()
{
var validator = new PackageValidator(
_aggregateValidators,
_storageFactory,
_feedToSource,
_logger,
_contextLogger);
var context = new PackageValidatorContext(
new FeedPackageIdentity(id: "a", version: "1.0.0"),
catalogEntries: Enumerable.Empty <CatalogIndexEntry>());
using (var client = new CollectorHttpClient())
{
await Assert.ThrowsAsync <OperationCanceledException>(
() => validator.ValidateAsync(context, client, new CancellationToken(canceled: true)));
}
}
public async Task ValidateAsync_WhenClientIsNull_Throws()
{
var validator = new PackageValidator(
_aggregateValidators,
_storageFactory,
_feedToSource,
_logger,
_contextLogger);
var context = new PackageValidatorContext(
new FeedPackageIdentity(id: "a", version: "1.0.0"),
catalogEntries: Enumerable.Empty <CatalogIndexEntry>());
const CollectorHttpClient client = null;
var exception = await Assert.ThrowsAsync <ArgumentNullException>(
() => validator.ValidateAsync(context, client, CancellationToken.None));
Assert.Equal("client", exception.ParamName);
}
public async Task ValidateAsync_WhenContextIsNull_Throws()
{
var validator = new PackageValidator(
_aggregateValidators,
_storageFactory,
_feedToSource,
_logger,
_contextLogger);
const PackageValidatorContext context = null;
using (var client = new CollectorHttpClient())
{
var exception = await Assert.ThrowsAsync <ArgumentNullException>(
() => validator.ValidateAsync(context, client, CancellationToken.None));
Assert.Equal("context", exception.ParamName);
}
}
public async Task ValidateAsync_WhenArgumentsAreValid_ReturnsResults()
{
var validator = new PackageValidator(
_aggregateValidators,
_storageFactory,
_feedToSource,
_logger,
_contextLogger);
var packageIdentity = new PackageIdentity(id: "a", version: new NuGetVersion("1.0.0"));
var catalogEntries = new[]
{
new CatalogIndexEntry(
new Uri($"https://nuget.test/{packageIdentity.Id}"),
CatalogConstants.NuGetPackageDetails,
Guid.NewGuid().ToString(),
DateTime.UtcNow,
packageIdentity)
};
var context = new PackageValidatorContext(new FeedPackageIdentity(packageIdentity), catalogEntries);
using (var httpClient = new CollectorHttpClient())
{
var actualResult = await validator.ValidateAsync(context, httpClient, CancellationToken.None);
Assert.Equal(catalogEntries, actualResult.CatalogEntries);
Assert.Empty(actualResult.DeletionAuditEntries);
Assert.Equal(packageIdentity, actualResult.Package);
Assert.Single(actualResult.AggregateValidationResults);
var actualValidationResult = actualResult.AggregateValidationResults.Single();
Assert.Same(_aggregateValidator, actualValidationResult.AggregateValidator);
Assert.Same(_validationResults, actualValidationResult.ValidationResults);
}
}
