public async Task <ValidationSetProcessorResult> ProcessValidationsAsync(PackageValidationSet validationSet)
{
_logger.LogInformation("Starting processing validation request for {PackageId} {PackageVersion}, validation set {ValidationSetId}",
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSet.ValidationTrackingId);
var processorStats = new ValidationSetProcessorResult();
int loopLimit = MaxProcessAttempts;
await ProcessIncompleteValidations(validationSet, processorStats);
bool hadSucceededValidations = false;
do
{
// we will try to start more validations in case previous validation start attempts
// result in Succeeded validation immediately (i.e. the validation was synchronous).
// If no validation start attempts resulted in succeeded validation (ProcessNotStartedValidations
// returns false) we move on and will check on progress later.
// loopLimit is there to prevent looping here infinitely if there are any bugs that
// cause ProcessNotStartedValidations to always return true.
hadSucceededValidations = await ProcessNotStartedValidations(validationSet, processorStats);
} while (hadSucceededValidations && loopLimit-- > 0);
if (loopLimit <= 0)
{
_logger.LogWarning("Too many processing attempts ({NumAttempts}) for {PackageId} {PackageVersion}, validation set {ValidationSetId}",
MaxProcessAttempts,
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSet.ValidationTrackingId);
}
return(processorStats);
}
public ValidationOutcomeProcessorFacts()
{
PackageServiceMock = new Mock <ICorePackageService>();
PackageFileServiceMock = new Mock <ICorePackageFileService>();
ValidationEnqueuerMock = new Mock <IPackageValidationEnqueuer>();
ConfigurationAccessorMock = new Mock <IOptionsSnapshot <ValidationConfiguration> >();
MessageServiceMock = new Mock <IMessageService>();
LoggerMock = new Mock <ILogger <ValidationOutcomeProcessor> >();
Configuration = new ValidationConfiguration();
Configuration.Validations = new List <ValidationConfigurationItem>();
Package = new Package
{
PackageRegistration = new PackageRegistration {
Id = "package"
},
Version = "1.2.3.456",
NormalizedVersion = "1.2.3",
PackageStatusKey = PackageStatus.Validating
};
Package.PackageRegistration.Packages.Add(Package);
ValidationSet = new PackageValidationSet();
ValidationSet.PackageValidations = new List <PackageValidation>();
ValidationSet.PackageId = Package.PackageRegistration.Id;
ValidationSet.PackageNormalizedVersion = Package.NormalizedVersion;
ValidationSet.ValidationTrackingId = Guid.NewGuid();
ConfigurationAccessorMock
.SetupGet(ca => ca.Value)
.Returns(Configuration);
}
private static string BuildValidationSetPackageFileName(PackageValidationSet validationSet)
{
return($"validation-sets/{validationSet.ValidationTrackingId}/" +
$"{validationSet.PackageId.ToLowerInvariant()}." +
$"{validationSet.PackageNormalizedVersion.ToLowerInvariant()}" +
CoreConstants.NuGetPackageFileExtension);
}
public void ItShouldProceedWhenFromFailedStateWithNoValidationInProgress()
{
// Arrange
IValidatingEntity <SymbolPackage> validatingSymbolPackage = null;
SymbolsPackageServiceMock.Setup(sp => sp.FindPackageByIdAndVersionStrict(PackageId, PackageVersion))
.Returns(validatingSymbolPackage);
var validationSet = new PackageValidationSet
{
PackageId = FailedSymbolPackage.Id,
PackageNormalizedVersion = FailedSymbolPackage.Version,
PackageKey = FailedSymbolPackageValidatingEntity.Key,
PackageValidations = new List <PackageValidation>
{
new PackageValidation {
Type = "SomeValidator"
},
}
};
// Act
bool result = Target.CanProceedToMakePackageAvailable(FailedSymbolPackageValidatingEntity, validationSet);
Target.SetStatusAsync(FailedSymbolPackageValidatingEntity, validationSet, PackageStatus.Available);
// Assert
Assert.True(result);
SymbolPackageFileServiceMock.Verify(spfs => spfs.DoesValidationSetPackageExistAsync(It.IsAny <PackageValidationSet>()), Times.Once);
}
public void ItShouldNotProceedWhenFromFailedStateWithValidationInProgress()
{
// Arrange
SymbolsPackageServiceMock.Setup(sp => sp.FindPackageByIdAndVersionStrict(PackageId, PackageVersion))
.Returns(ValidatingSymbolPackageValidatingEntity);
var validationSet = new PackageValidationSet
{
PackageId = FailedSymbolPackage.Id,
PackageNormalizedVersion = FailedSymbolPackage.Version,
PackageKey = FailedSymbolPackageValidatingEntity.Key,
PackageValidations = new List <PackageValidation>
{
new PackageValidation {
Type = "SomeValidator"
},
}
};
// Act
bool result = Target.CanProceedToMakePackageAvailable(FailedSymbolPackageValidatingEntity, validationSet);
Target.SetStatusAsync(FailedSymbolPackageValidatingEntity, validationSet, PackageStatus.Available);
// Assert
Assert.False(result);
SymbolPackageFileServiceMock.Verify(spfs => spfs.DoesValidationSetPackageExistAsync(It.IsAny <PackageValidationSet>()), Times.Never);
SymbolPackageFileServiceMock.Verify(spfs => spfs.CopyValidationSetPackageToPackageFileAsync(It.IsAny <PackageValidationSet>(), It.IsAny <IAccessCondition>()), Times.Never);
SymbolPackageFileServiceMock.Verify(spfs => spfs.CopyValidationPackageToPackageFileAsync(It.IsAny <PackageValidationSet>()), Times.Never);
SymbolPackageFileServiceMock.Verify(spfs => spfs.UpdatePackageBlobMetadataInValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
SymbolPackageFileServiceMock.Verify(spfs => spfs.UpdatePackageBlobMetadataInValidationAsync(It.IsAny <PackageValidationSet>()), Times.Never);
SymbolsPackageServiceMock.Verify(sps => sps.UpdateStatusAsync(It.IsAny <SymbolPackage>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()), Times.Never);
}
protected override async Task OnCleanupAfterDatabaseUpdateFailure(
IValidatingEntity <Package> validatingEntity,
PackageValidationSet validationSet)
{
if (validatingEntity.EntityRecord.EmbeddedLicenseType != EmbeddedLicenseFileType.Absent)
{
using (_telemetryService.TrackDurationToDeleteLicenseFile(validationSet.PackageId, validationSet.PackageNormalizedVersion, validationSet.ValidationTrackingId.ToString()))
{
_logger.LogInformation("Cleaning up the license file for the package {PackageId} {PackageVersion}", validationSet.PackageId, validationSet.PackageNormalizedVersion);
await _coreLicenseFileService.DeleteLicenseFileAsync(validationSet.PackageId, validationSet.PackageNormalizedVersion);
_logger.LogInformation("Deleted the license file for the package {PackageId} {PackageVersion}", validationSet.PackageId, validationSet.PackageNormalizedVersion);
}
}
if (validatingEntity.EntityRecord.HasEmbeddedReadme)
{
using (_telemetryService.TrackDurationToDeleteReadmeFile(validationSet.PackageId, validationSet.PackageNormalizedVersion, validationSet.ValidationTrackingId.ToString()))
{
_logger.LogInformation("Cleaning up the readme file for the package {PackageId} {PackageVersion}", validationSet.PackageId, validationSet.PackageNormalizedVersion);
await _coreReadmeFileService.DeleteReadmeFileAsync(validationSet.PackageId, validationSet.PackageNormalizedVersion);
_logger.LogInformation("Deleted the readme file for the package {PackageId} {PackageVersion}", validationSet.PackageId, validationSet.PackageNormalizedVersion);
}
}
}
public static IReadOnlyList <ValidationIssue> GetValidationIssues(this PackageValidationSet validationSet)
{
IReadOnlyList <ValidationIssue> issues = null;
if (validationSet != null)
{
// Get the failed validation set's validation issues. The issues are ordered by their
// key so that it appears that issues are appended as more validations fail.
issues = validationSet
.PackageValidations
.SelectMany(v => v.PackageValidationIssues)
.OrderBy(i => i.Key)
.Select(i => ValidationIssue.Deserialize(i.IssueCode, i.Data))
.ToList();
// Filter out unknown issues and deduplicate the issues by code and data. This also deduplicates cases
// where there is extraneous data in the serialized data field or if the issue code is unknown.
issues = issues
.GroupBy(x => new { x.IssueCode, Data = x.Serialize() })
.Select(x => x.First())
.ToList();
}
// If the package failed validation but we could not find an issue that explains why, use a generic error message.
if (issues == null || !issues.Any())
{
issues = new[] { ValidationIssue.Unknown };
}
return(issues);
}
public async Task DownloadPackageFileToDiskAsync()
{
_fileStorageService
.Setup(x => x.GetFileReadUriAsync(
_packagesContainerName,
_packageFileName,
null))
.ReturnsAsync(_testUri)
.Verifiable();
_packageDownloader
.Setup(x => x.DownloadAsync(_testUri, CancellationToken.None))
.ReturnsAsync(_packageStream)
.Verifiable();
var validationSet = new PackageValidationSet()
{
PackageNormalizedVersion = _package.NormalizedVersion,
PackageKey = _package.Key,
PackageId = _package.PackageRegistration.Id
};
var actual = await _target.DownloadPackageFileToDiskAsync(validationSet);
Assert.Same(_packageStream, actual);
_fileStorageService.Verify();
_packageDownloader.Verify();
}
public async Task SendValidationFailedMessageAsync(Package package, PackageValidationSet validationSet)
{
package = package ?? throw new ArgumentNullException(nameof(package));
validationSet = validationSet ?? throw new ArgumentNullException(nameof(validationSet));
var galleryPackageUrl = _serviceConfiguration.GalleryPackageUrl(package.PackageRegistration.Id, package.NormalizedVersion);
var packageSupportUrl = _serviceConfiguration.PackageSupportUrl(package.PackageRegistration.Id, package.NormalizedVersion);
var packageValidationFailedMessage = new PackageValidationFailedMessage(
_serviceConfiguration,
package,
validationSet,
galleryPackageUrl,
packageSupportUrl,
_serviceConfiguration.EmailConfiguration.AnnouncementsUrl,
_serviceConfiguration.EmailConfiguration.TwitterUrl);
_logger.LogInformation(
"The validation failed email will be sent for the package {PackageId} {PackageVersion} and " +
"{ValidationSetId}",
package.Id,
package.NormalizedVersion,
validationSet.ValidationTrackingId);
await _messageService.SendMessageAsync(packageValidationFailedMessage);
}
protected static string BuildValidationSetPackageFileName(PackageValidationSet validationSet, string extension)
{
return($"validation-sets/{validationSet.ValidationTrackingId}/" +
$"{validationSet.PackageId.ToLowerInvariant()}." +
$"{validationSet.PackageNormalizedVersion.ToLowerInvariant()}" +
extension);
}
public async Task DoesNotEmitTelemetryIfMultipleValidationSetsExist()
{
const string validation1 = "validation1";
Configuration.Validations = new List <ValidationConfigurationItem>
{
new ValidationConfigurationItem()
{
Name = validation1, TrackAfter = TimeSpan.FromDays(1), RequiredValidations = new List <string> {
}
}
};
Guid validationTrackingId = Guid.NewGuid();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetAsync(validationTrackingId))
.ReturnsAsync((PackageValidationSet)null)
.Verifiable();
PackageValidationSet createdSet = null;
ValidationStorageMock
.Setup(vs => vs.CreateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns <PackageValidationSet>(pvs => Task.FromResult(pvs))
.Callback <PackageValidationSet>(pvs => createdSet = pvs)
.Verifiable();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetCountAsync(It.IsAny <IValidatingEntity <Package> >()))
.ReturnsAsync(2);
ValidationStorageMock
.Setup(vs => vs.OtherRecentValidationSetForPackageExists(It.IsAny <IValidatingEntity <Package> >(), It.IsAny <TimeSpan>(), It.IsAny <Guid>()))
.ReturnsAsync(false);
var provider = new ValidationSetProvider <Package>(
ValidationStorageMock.Object,
PackageFileServiceMock.Object,
ValidatorProvider.Object,
ConfigurationAccessorMock.Object,
TelemetryServiceMock.Object,
LoggerMock.Object);
var packageValidationMessageData = new ProcessValidationSetData(
Package.PackageRegistration.Id,
Package.NormalizedVersion,
validationTrackingId,
ValidatingType.Package,
Package.Key);
var returnedSet = await provider.TryGetOrCreateValidationSetAsync(packageValidationMessageData, PackageValidatingEntity);
ValidationStorageMock
.Verify(vs => vs.CreateValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Once);
TelemetryServiceMock.Verify(
x => x.TrackDurationToValidationSetCreation(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <TimeSpan>()),
Times.Never);
}
public SymbolsMessageServiceFacts()
{
EmailConfiguration = new EmailConfiguration
{
PackageUrlTemplate = "https://example.com/package/{0}/{1}",
PackageSupportTemplate = "https://example.com/packageSupport/{0}/{1}",
EmailSettingsUrl = ValidSettingsUrl,
AnnouncementsUrl = "https://announcements.com",
TwitterUrl = "https://twitter.com/nuget",
GalleryNoReplyAddress = "NuGet Gallery <*****@*****.**>",
GalleryOwner = "NuGet Gallery <*****@*****.**>"
};
EmailConfigurationAccessorMock
.SetupGet(eca => eca.Value)
.Returns(EmailConfiguration);
var package = new Package
{
PackageRegistration = new PackageRegistration {
Id = "package"
},
Version = "1.2.3.4",
NormalizedVersion = "1.2.3"
};
SymbolPackage = new SymbolPackage()
{
Package = package
};
ValidationSet = new PackageValidationSet();
}
public ValidationSetProviderFacts()
{
ValidationStorageMock = new Mock <IValidationStorageService>(MockBehavior.Strict);
ConfigurationAccessorMock = new Mock <IOptionsSnapshot <ValidationConfiguration> >();
LoggerMock = new Mock <ILogger <ValidationSetProvider> >();
Configuration = new ValidationConfiguration();
ConfigurationAccessorMock
.SetupGet(ca => ca.Value)
.Returns(() => Configuration);
Package = new Package
{
PackageRegistration = new PackageRegistration {
Id = "package1"
},
Version = "1.2.3.456",
NormalizedVersion = "1.2.3",
Key = 42,
};
Package.PackageRegistration.Packages = new List <Package> {
Package
};
ValidationSet = new PackageValidationSet
{
PackageId = Package.PackageRegistration.Id,
PackageNormalizedVersion = Package.NormalizedVersion,
ValidationTrackingId = Guid.NewGuid()
};
}
public async Task BackupPackageFileFromValidationSetPackageAsync(PackageValidationSet validationSet, string sasDefinition)
{
if (validationSet.ValidatingType == ValidatingType.Generic)
{
throw new ArgumentException(
$"This method is not supported for validation sets of validating type {validationSet.ValidatingType}",
nameof(validationSet));
}
using (_telemetryService.TrackDurationToBackupPackage(validationSet))
{
_logger.LogInformation(
"Backing up package for validation set {ValidationTrackingId} ({PackageId} {PackageVersion}).",
validationSet.ValidationTrackingId,
validationSet.PackageId,
validationSet.PackageNormalizedVersion);
var packageUri = await GetPackageForValidationSetReadUriAsync(
validationSet,
sasDefinition,
DateTimeOffset.UtcNow.Add(AccessDuration));
using (var result = await _fileDownloader.DownloadAsync(packageUri, CancellationToken.None))
{
await StorePackageFileInBackupLocationAsync(validationSet, result.GetStreamOrThrow());
}
}
}
public async Task DropsMessageIfPackageIsSoftDeletedForCheckValidator()
{
var messageData = PackageValidationMessageData.NewCheckValidator(Guid.NewGuid());
var validationConfiguration = new ValidationConfiguration();
var package = new Package {
Key = 42, PackageStatusKey = PackageStatus.Deleted
};
var packageValidatingEntity = new PackageValidatingEntity(package);
var validationSet = new PackageValidationSet {
PackageKey = package.Key, ValidatingType = ValidatingType.Package
};
ValidationSetProviderMock
.Setup(ps => ps.TryGetParentValidationSetAsync(messageData.CheckValidator.ValidationId))
.ReturnsAsync(validationSet)
.Verifiable();
CorePackageServiceMock
.Setup(ps => ps.FindPackageByKey(package.Key))
.Returns(packageValidatingEntity);
var handler = CreateHandler();
var result = await handler.HandleAsync(messageData);
Assert.True(result);
ValidationSetProviderMock.Verify(
vsp => vsp.TryGetParentValidationSetAsync(messageData.CheckValidator.ValidationId),
Times.Once);
CorePackageServiceMock.Verify(
ps => ps.FindPackageByKey(package.Key),
Times.Once);
}
private async Task ProcessValidationSetAsync(
IValidatingEntity <TEntity> entity,
PackageValidationSet validationSet,
bool scheduleNextCheck)
{
if (validationSet.ValidationSetStatus == ValidationSetStatus.Completed)
{
_logger.LogInformation(
"The validation set {ValidatingType} {PackageId} {PackageVersion} {Key} {ValidationSetId} is " +
"already completed. Discarding the message.",
ValidatingType,
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSet.PackageKey,
validationSet.ValidationTrackingId);
return;
}
var processorStats = await _validationSetProcessor.ProcessValidationsAsync(validationSet);
await _validationOutcomeProcessor.ProcessValidationOutcomeAsync(
validationSet,
entity,
processorStats,
scheduleNextCheck);
}
private async Task ScheduleCheckIfNotTimedOut(PackageValidationSet validationSet, IValidatingEntity <T> validatingEntity, bool tooLongNotificationAllowed)
{
var validationSetDuration = await UpdateValidationDurationAsync(validationSet, validatingEntity, tooLongNotificationAllowed);
// Schedule another check if we haven't reached the validation set timeout yet.
if (validationSetDuration <= _validationConfiguration.TimeoutValidationSetAfter)
{
var messageData = new PackageValidationMessageData(
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSet.ValidationTrackingId,
validationSet.ValidatingType,
entityKey: validationSet.PackageKey);
var postponeUntil = DateTimeOffset.UtcNow + _validationConfiguration.ValidationMessageRecheckPeriod;
await _validationEnqueuer.StartValidationAsync(messageData, postponeUntil);
}
else
{
_logger.LogWarning("Abandoning checking status of validation set {ValidationTrackingId} for " +
"package {PackageId} {PackageVersion} because it took too long (Duration: {Duration}, CutOffDuration: {CutOffDuration})",
validationSet.ValidationTrackingId,
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSetDuration,
_validationConfiguration.TimeoutValidationSetAfter);
_telemetryService.TrackValidationSetTimeout(validationSet.PackageId, validationSet.PackageNormalizedVersion, validationSet.ValidationTrackingId);
}
}
public void ReturnsSingleUnknownIssueIfNoneArePersisted()
{
// Arrange
_package.Key = 123;
_package.PackageStatusKey = PackageStatus.FailedValidation;
var packageValidationSet = new PackageValidationSet
{
PackageKey = 123,
PackageValidations = new[]
{
new PackageValidation
{
ValidationStatus = ValidationStatus.Failed,
PackageValidationIssues = new PackageValidationIssue[0],
}
}
};
_validationSets
.Setup(x => x.GetAll())
.Returns(new[] { packageValidationSet }.AsQueryable());
// Act
var issues = _target.GetLatestValidationIssues(_package);
// Assert
_validationSets.Verify(x => x.GetAll(), Times.Once);
var issue = Assert.Single(issues);
Assert.Equal(ValidationIssueCode.Unknown, issue.IssueCode);
}
private bool AreOptionalValidationsRunning(PackageValidationSet packageValidationSet)
{
return(packageValidationSet
.PackageValidations
.Any(pv => pv.ValidationStatus == ValidationStatus.Incomplete &&
GetValidationConfigurationItemByName(pv.Type)?.FailureBehavior == ValidationFailureBehavior.AllowedToFail));
}
protected override async Task OnBeforeUpdateDatabaseToMakePackageAvailable(
IValidatingEntity <Package> validatingEntity,
PackageValidationSet validationSet)
{
if (validatingEntity.EntityRecord.EmbeddedLicenseType != EmbeddedLicenseFileType.Absent || validatingEntity.EntityRecord.HasEmbeddedReadme)
{
using (_telemetryService.TrackDurationToExtractLicenseAndReadmeFile(validationSet.PackageId, validationSet.PackageNormalizedVersion, validationSet.ValidationTrackingId.ToString()))
using (var packageStream = await _packageFileService.DownloadPackageFileToDiskAsync(validationSet, _sasDefinitionConfiguration.PackageStatusProcessorSasDefinition))
{
if (validatingEntity.EntityRecord.EmbeddedLicenseType != EmbeddedLicenseFileType.Absent)
{
_logger.LogInformation("Extracting the license file of type {EmbeddedLicenseFileType} for the package {PackageId} {PackageVersion}",
validatingEntity.EntityRecord.EmbeddedLicenseType,
validationSet.PackageId,
validationSet.PackageNormalizedVersion);
await _coreLicenseFileService.ExtractAndSaveLicenseFileAsync(validatingEntity.EntityRecord, packageStream);
_logger.LogInformation("Successfully extracted the license file.");
}
if (validatingEntity.EntityRecord.HasEmbeddedReadme)
{
_logger.LogInformation("Extracting the readme file of type {EmbeddedReadmeType} for the package {PackageId} {PackageVersion}",
validatingEntity.EntityRecord.EmbeddedReadmeType,
validationSet.PackageId,
validationSet.PackageNormalizedVersion);
await _coreReadmeFileService.ExtractAndSaveReadmeFileAsync(validatingEntity.EntityRecord, packageStream);
_logger.LogInformation("Successfully extracted the readme file.");
}
}
}
}
private bool AllRequiredValidationsSucceeded(PackageValidationSet packageValidationSet)
{
return(packageValidationSet
.PackageValidations
.All(pv => pv.ValidationStatus == ValidationStatus.Succeeded ||
GetValidationConfigurationItemByName(pv.Type)?.FailureBehavior == ValidationFailureBehavior.AllowedToFail));
}
public BaseFacts()
{
Package = new Package
{
PackageRegistration = new PackageRegistration(),
PackageStatusKey = PackageStatus.Validating,
};
ValidationSet = new PackageValidationSet
{
PackageValidations = new List <PackageValidation>
{
new PackageValidation {
Type = "SomeValidator"
},
}
};
PackageServiceMock = new Mock <ICorePackageService>();
PackageFileServiceMock = new Mock <IValidationPackageFileService>();
ValidatorProviderMock = new Mock <IValidatorProvider>();
TelemetryServiceMock = new Mock <ITelemetryService>();
LoggerMock = new Mock <ILogger <PackageStatusProcessor> >();
PackageFileServiceMock
.Setup(x => x.DownloadPackageFileToDiskAsync(It.IsAny <Package>()))
.ReturnsAsync(() => Stream.Null);
Target = new PackageStatusProcessor(
PackageServiceMock.Object,
PackageFileServiceMock.Object,
ValidatorProviderMock.Object,
TelemetryServiceMock.Object,
LoggerMock.Object);
}
public Facts(ITestOutputHelper output)
{
Options = new Mock <IOptionsSnapshot <ValidationConfiguration> >();
EntityService = new Mock <IEntityService <TestEntity> >();
ValidationSetProvider = new Mock <IValidationSetProvider <TestEntity> >();
ValidationSetProcessor = new Mock <IValidationSetProcessor>();
ValidationOutcomeProcessor = new Mock <IValidationOutcomeProcessor <TestEntity> >();
LeaseService = new Mock <ILeaseService>();
PackageValidationEnqueuer = new Mock <IPackageValidationEnqueuer>();
FeatureFlagService = new Mock <IFeatureFlagService>();
TelemetryService = new Mock <ITelemetryService>();
Logger = new LoggerFactory().AddXunit(output).CreateLogger <SymbolValidationMessageHandler>();
Config = new ValidationConfiguration
{
MissingPackageRetryCount = 1,
};
ValidatingEntity = new Mock <IValidatingEntity <TestEntity> >();
ValidationSet = new PackageValidationSet
{
PackageKey = 42,
ValidationTrackingId = new Guid("dc2aa638-a23c-4791-a4ff-c3e07b1320a4"),
PackageId = "NuGet.Versioning",
PackageNormalizedVersion = "5.3.0-BETA",
ValidatingType = ValidatingType.Package,
ValidationSetStatus = ValidationSetStatus.InProgress,
};
LeaseResourceName = "Package/nuget.versioning/5.3.0-beta";
ValidationSetProcessorResult = new ValidationSetProcessorResult();
LeaseResult = LeaseResult.Success("lease-id");
Options.Setup(x => x.Value).Returns(() => Config);
EntityService
.Setup(x => x.FindPackageByKey(It.IsAny <int>()))
.Returns(() => ValidatingEntity.Object);
ValidationSetProcessor
.Setup(x => x.ProcessValidationsAsync(It.IsAny <PackageValidationSet>()))
.ReturnsAsync(() => ValidationSetProcessorResult);
ValidatingEntity
.Setup(x => x.Status)
.Returns(PackageStatus.Validating);
LeaseService
.Setup(x => x.TryAcquireAsync(It.IsAny <string>(), It.IsAny <TimeSpan>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => LeaseResult);
FeatureFlagService.Setup(x => x.IsQueueBackEnabled()).Returns(true);
FeatureFlagService.Setup(x => x.IsOrchestratorLeaseEnabled()).Returns(true);
Target = new TestHandler(
Options.Object,
EntityService.Object,
ValidationSetProvider.Object,
ValidationSetProcessor.Object,
ValidationOutcomeProcessor.Object,
LeaseService.Object,
PackageValidationEnqueuer.Object,
FeatureFlagService.Object,
TelemetryService.Object,
Logger);
}
public static string BuildFileName(PackageValidationSet validationSet, string pathTemplate, string extension)
{
string id = validationSet.PackageId;
string version = validationSet.PackageNormalizedVersion;
return(FileNameHelper.BuildFileName(id, version, pathTemplate, extension));
}
public async Task WaitsForPackageAvailabilityInGalleryDBWithCheckValidator()
{
var messageData = PackageValidationMessageData.NewCheckValidator(Guid.NewGuid());
var validationConfiguration = new ValidationConfiguration();
var validationSet = new PackageValidationSet {
PackageKey = 42, ValidatingType = ValidatingType.SymbolPackage
};
ValidationSetProviderMock
.Setup(ps => ps.TryGetParentValidationSetAsync(messageData.CheckValidator.ValidationId))
.ReturnsAsync(validationSet)
.Verifiable();
CoreSymbolPackageServiceMock
.Setup(ps => ps.FindPackageByKey(validationSet.PackageKey))
.Returns <SymbolPackage>(null)
.Verifiable();
var handler = CreateHandler();
var result = await handler.HandleAsync(messageData);
ValidationSetProviderMock.Verify(
ps => ps.TryGetParentValidationSetAsync(messageData.CheckValidator.ValidationId),
Times.Once);
CoreSymbolPackageServiceMock.Verify(
ps => ps.FindPackageByKey(validationSet.PackageKey),
Times.Once);
Assert.False(result, "The handler should not have succeeded.");
}
protected ValidationSetProcessorFactsBase(
MockBehavior validatorProviderMockBehavior = MockBehavior.Default,
MockBehavior validationStorageMockBehavior = MockBehavior.Default,
MockBehavior configurationAccessorMockBehavior = MockBehavior.Default,
MockBehavior packageFileServiceMockBehavior = MockBehavior.Default,
MockBehavior loggerMockBehavior = MockBehavior.Default)
{
ValidatorProviderMock = new Mock <IValidatorProvider>(validatorProviderMockBehavior);
ValidationStorageMock = new Mock <IValidationStorageService>(validationStorageMockBehavior);
ConfigurationAccessorMock = new Mock <IOptionsSnapshot <ValidationConfiguration> >(configurationAccessorMockBehavior);
PackageFileServiceMock = new Mock <ICorePackageFileService>(packageFileServiceMockBehavior);
LoggerMock = new Mock <ILogger <ValidationSetProcessor> >(loggerMockBehavior);
Configuration = new ValidationConfiguration
{
Validations = new List <ValidationConfigurationItem>
{
}
};
ConfigurationAccessorMock
.SetupGet(ca => ca.Value)
.Returns(Configuration);
Package = new Package
{
PackageRegistration = new PackageRegistration {
Id = "packageId"
},
Version = "1.2.3.456",
NormalizedVersion = "1.2.3"
};
Package.PackageRegistration.Packages.Add(Package);
ValidationSet = new PackageValidationSet
{
Key = 238423,
PackageId = Package.PackageRegistration.Id,
PackageNormalizedVersion = Package.NormalizedVersion,
PackageValidations = new List <PackageValidation>
{
}
};
ValidationSet.PackageValidations.ToList().ForEach(v => v.PackageValidationSet = ValidationSet);
Validators = new Dictionary <string, Mock <IValidator> >();
PackageFileServiceMock
.Setup(pfs => pfs.GetValidationPackageReadUriAsync(It.IsAny <Package>(), It.IsAny <DateTimeOffset>()))
.Returns <Package, DateTimeOffset>(
(p, e) => Task.FromResult(new Uri($"https://example.com/{ValidationContainerName}/{p.PackageRegistration.Id}/{p.NormalizedVersion}?e={e:yyyy-MM-dd-hh-mm-ss}")));
PackageFileServiceMock
.Setup(pfs => pfs.GetPackageReadUriAsync(It.IsAny <Package>()))
.Returns <Package>(
p => Task.FromResult(new Uri($"https://example.com/{PublicContainerName}/{p.PackageRegistration.Id}/{p.NormalizedVersion}")));
PackageFileServiceMock
.Setup(pfs => pfs.DoesValidationPackageFileExistAsync(Package))
.ReturnsAsync(true);
}
private List <PackageValidation> GetFailedValidations(PackageValidationSet packageValidationSet)
{
return(packageValidationSet
.PackageValidations
.Where(v => v.ValidationStatus == ValidationStatus.Failed)
.Where(v => GetValidationConfigurationItemByName(v.Type)?.FailureBehavior == ValidationFailureBehavior.MustSucceed)
.ToList());
}
public async Task <string> GetPublicPackageBlobETagOrNullAsync(PackageValidationSet validationSet)
{
var fileName = BuildFileName(validationSet,
_fileMetadataService.FileSavePathTemplate,
_fileMetadataService.FileExtension);
return(await _fileStorageService.GetETagOrNullAsync(_fileMetadataService.FileFolderName, fileName));
}
private async Task MarkValidationSetAsCompletedAsync(PackageValidationSet validationSet)
{
// Move the validation set to the completed status. This operation is done using optimistic concurrency
// meaning if another thread is processing this same validation set at the same time, one thread will win
// and one thread will fail. In other words, subsequent steps will be executed at most one time. From
validationSet.ValidationSetStatus = ValidationSetStatus.Completed;
await _validationStorageService.UpdateValidationSetAsync(validationSet);
}
public Task <Uri> GetPackageReadUriAsync(PackageValidationSet validationSet)
{
var fileName = BuildFileName(validationSet,
_fileMetadataService.FileSavePathTemplate,
_fileMetadataService.FileExtension);
return(_fileStorageService.GetFileReadUriAsync(_fileMetadataService.FileFolderName, fileName, endOfAccess: null));
}