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 async Task UpdateSavesNewStatus()
{
// Arrange
var feedPackageIdentity = new FeedPackageIdentity("howdy", "3.4.6");
var packageValidationResult = new PackageValidationResult(
new PackageIdentity(feedPackageIdentity.Id, new NuGetVersion(feedPackageIdentity.Version)),
null,
null,
Enumerable.Empty <AggregateValidationResult>());
var status = new PackageMonitoringStatus(packageValidationResult);
var storageFactory = new MemoryStorageFactory();
var statusService = new PackageMonitoringStatusService(
storageFactory,
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
// Act
await statusService.UpdateAsync(status, CancellationToken.None);
// Assert
Assert.True(
storageFactory.Create(
PackageState.Valid.ToString().ToLowerInvariant())
.Exists(GetPackageFileName(feedPackageIdentity.Id, feedPackageIdentity.Version)));
}
public async Task GetByPackageWithException()
{
// Arrange
var statusService = new PackageMonitoringStatusService(
new MemoryStorageFactory(),
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
var undesiredStatuses = new PackageMonitoringStatus[]
{
CreateStatusWithPackageValidationResult("json.newtonsoft", "1.0.9", new ValidationResult[] { CreateValidationResult(TestResult.Pass, null) }),
CreateStatusWithPackageValidationResult("json.newtonsoft.json", "1.0.9.1", new ValidationResult[] { CreateValidationResult(TestResult.Fail, null) }),
CreateStatusWithPackageValidationResult("j.n.j", "1.9.1", new ValidationResult[] { CreateValidationResult(TestResult.Skip, null) }),
CreateStatusWithPackageValidationResult("newtonsoft.json", "9.0.2", new ValidationResult[] { CreateValidationResult(TestResult.Pass, null) })
};
var desiredPackageId = "newtonsoft.json";
var desiredPackageVersion = "9.0.1";
var desiredStatus = CreateStatusWithException(desiredPackageId, desiredPackageVersion);
await statusService.UpdateAsync(desiredStatus, CancellationToken.None);
await Task.WhenAll(undesiredStatuses.Select(s => statusService.UpdateAsync(s, CancellationToken.None)));
// Act
var status = await statusService.GetAsync(new FeedPackageIdentity(desiredPackageId, desiredPackageVersion), CancellationToken.None);
// Assert
AssertStatus(desiredStatus, status);
}
public static void AssertStatus(PackageMonitoringStatus expected, PackageMonitoringStatus actual)
{
AssertFieldEqual(expected, actual, i => i.Package.Id);
AssertFieldEqual(expected, actual, i => i.Package.Version);
AssertFieldEqual(expected, actual, i => i.State);
AssertFieldEqual(expected, actual, i => i.ValidationResult, AssertPackageValidationResult);
AssertFieldEqual(expected, actual, i => i.ValidationException, AssertException);
}
private Task SaveToStorage(MemoryStorageFactory storageFactory, PackageMonitoringStatus status)
{
var json = JsonConvert.SerializeObject(status, JsonSerializerUtility.SerializerSettings);
var content = new StringStorageContentWithAccessCondition(
json,
AccessCondition.GenerateEmptyCondition(),
"application/json");
return(SaveToStorage(storageFactory, status.State, status.Package, content));
}
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);
}
public async Task UpdateDeletesOldStatuses(PackageState?previousState)
{
// Arrange
var feedPackageIdentity = new FeedPackageIdentity("howdy", "3.4.6");
var packageValidationResult = new PackageValidationResult(
new PackageIdentity(feedPackageIdentity.Id, new NuGetVersion(feedPackageIdentity.Version)),
null,
null,
Enumerable.Empty <AggregateValidationResult>());
var status = new PackageMonitoringStatus(packageValidationResult);
var storageFactory = new MemoryStorageFactory();
var statusService = new PackageMonitoringStatusService(
storageFactory,
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
var etag = "theETag";
foreach (var state in Enum.GetValues(typeof(PackageState)).Cast <PackageState>())
{
if (previousState != state)
{
status.ExistingState[state] = AccessCondition.GenerateIfNotExistsCondition();
continue;
}
var content = new StringStorageContentWithETag("{}", etag);
await SaveToStorage(storageFactory, state, feedPackageIdentity, content);
status.ExistingState[state] = AccessCondition.GenerateIfMatchCondition(etag);
}
// Act
await statusService.UpdateAsync(status, CancellationToken.None);
// Assert
foreach (var state in Enum.GetValues(typeof(PackageState)).Cast <PackageState>())
{
Assert.Equal(
state == status.State,
DoesPackageExists(storageFactory, state, feedPackageIdentity));
}
PackageMonitoringStatusTestUtility.AssertStatus(
status,
await statusService.GetAsync(feedPackageIdentity, CancellationToken.None));
}
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 async Task UpdateDeletesOldStatuses()
{
// Arrange
var feedPackageIdentity = new FeedPackageIdentity("howdy", "3.4.6");
var packageFileName = GetPackageFileName(feedPackageIdentity.Id, feedPackageIdentity.Version);
var packageValidationResult = new PackageValidationResult(
new PackageIdentity(feedPackageIdentity.Id, new NuGetVersion(feedPackageIdentity.Version)),
null,
null,
Enumerable.Empty <AggregateValidationResult>());
var status = new PackageMonitoringStatus(packageValidationResult);
var storageFactory = new MemoryStorageFactory();
var statusService = new PackageMonitoringStatusService(
storageFactory,
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
foreach (var state in Enum.GetNames(typeof(PackageState)))
{
var storage = storageFactory.Create(state.ToLowerInvariant());
await storage.SaveAsync(storage.ResolveUri(packageFileName), new StringStorageContent("{}"), CancellationToken.None);
Assert.True(storage.Exists(packageFileName));
}
// Act
await statusService.UpdateAsync(status, CancellationToken.None);
// Assert
foreach (var state in Enum.GetNames(typeof(PackageState)))
{
var storage = storageFactory.Create(state.ToLowerInvariant());
if ((PackageState)Enum.Parse(typeof(PackageState), state) == status.State)
{
Assert.True(storage.Exists(packageFileName));
}
else
{
Assert.False(storage.Exists(packageFileName));
}
}
AssertStatus(status, await statusService.GetAsync(feedPackageIdentity, CancellationToken.None));
}
public async Task GetByState()
{
// Arrange
var statusService = new PackageMonitoringStatusService(
new MemoryStorageFactory(),
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
var expectedValidStatuses = new PackageMonitoringStatus[]
{
CreateStatusWithPackageValidationResult("newtonsoft.json", "9.0.2", new ValidationResult[] { CreateValidationResult(TestResult.Pass, null) }),
CreateStatusWithPackageValidationResult("a.b", "1.2.3", new ValidationResult[] { CreateValidationResult(TestResult.Pass, null) }),
CreateStatusWithPackageValidationResult("newtonsoft.json", "6.0.8", new ValidationResult[] { CreateValidationResult(TestResult.Skip, null) }),
CreateStatusWithPackageValidationResult("a.b", "0.8.9", new ValidationResult[] { CreateValidationResult(TestResult.Skip, null) })
};
var expectedInvalidStatuses = new PackageMonitoringStatus[]
{
CreateStatusWithPackageValidationResult("jQuery", "3.1.2", new ValidationResult[] { CreateValidationResult(TestResult.Fail, new ValidationException("malarky!")) }),
CreateStatusWithPackageValidationResult("EntityFramework", "6.1.2", new ValidationResult[] { CreateValidationResult(TestResult.Fail, new ValidationException("absurd!")) }),
CreateStatusWithException("NUnit", "3.6.1")
};
foreach (var expectedValidStatus in expectedValidStatuses)
{
await statusService.UpdateAsync(expectedValidStatus, CancellationToken.None);
}
foreach (var expectedInvalidStatus in expectedInvalidStatuses)
{
await statusService.UpdateAsync(expectedInvalidStatus, CancellationToken.None);
}
// Act
var validStatuses = await statusService.GetAsync(PackageState.Valid, CancellationToken.None);
var invalidStatuses = await statusService.GetAsync(PackageState.Invalid, CancellationToken.None);
// Assert
AssertAll(
expectedValidStatuses.OrderBy(s => s.Package.Id).ThenBy(s => s.Package.Version),
validStatuses.OrderBy(s => s.Package.Id).ThenBy(s => s.Package.Version),
AssertStatus);
AssertAll(
expectedInvalidStatuses.OrderBy(s => s.Package.Id).ThenBy(s => s.Package.Version),
invalidStatuses.OrderBy(s => s.Package.Id).ThenBy(s => s.Package.Version),
AssertStatus);
}
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 void Invalid()
{
var validationResults = new ValidationResult[]
{
new ValidationResult(null, TestResult.Fail)
};
var aggregateValidationResults = new AggregateValidationResult(
null,
validationResults);
var packageValidationResult = new PackageValidationResult(
new PackageIdentity("testPackage", new NuGetVersion(4, 5, 6)),
null,
null,
new AggregateValidationResult[] { aggregateValidationResults });
var status = new PackageMonitoringStatus(packageValidationResult);
Assert.Equal(PackageState.Invalid, status.State);
}
public void Invalid()
{
var status = new PackageMonitoringStatus(new FeedPackageIdentity("hello", "2.1.0"), new Exception());
Assert.Equal(PackageState.Invalid, status.State);
}
