public async Task RejectsCertificateWithMultipleUses()
{
// Arrange
var signature = await TestResources.LoadPrimarySignatureAsync(TestResources.SignedPackageLeaf1);
var existingEndCertificate = new EndCertificate
{
Key = 1,
Thumbprint = TestResources.Leaf1Thumbprint,
Status = EndCertificateStatus.Good,
Use = EndCertificateUse.Timestamping,
CertificateChainLinks = new List <CertificateChainLink>(),
};
_entitiesContext
.Setup(x => x.EndCertificates)
.Returns(DbSetMockFactory.Create(existingEndCertificate));
// Act & Assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(
() => _target.ExtractAsync(_packageKey, signature, _token));
Assert.Equal("The use of an end certificate cannot change.", ex.Message);
_entitiesContext.Verify(
x => x.SaveChangesAsync(),
Times.Never);
Assert.Empty(_savedCertificates);
}
public async Task TryAddReturnsAnExistentRequestIfAlreadyExistsInDatabase()
{
// Arrange
SymbolsServerRequest request1 = new SymbolsServerRequest()
{
Created = DateTime.UtcNow,
LastUpdated = DateTime.UtcNow,
RequestName = PackageKey.ToString(),
RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingested,
SymbolsKey = PackageKey
};
SymbolsServerRequest request2 = new SymbolsServerRequest()
{
Created = new DateTime(2018, 4, 5),
LastUpdated = DateTime.UtcNow,
RequestName = PackageKey.ToString(),
RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingested,
SymbolsKey = PackageKey
};
_validationEntitiesContext
.Setup(x => x.SymbolsServerRequests)
.Returns(DbSetMockFactory.Create(request1));
// Act
var result = await _target.AddSymbolsServerRequestAsync(request2);
// Assert
Assert.Equal(request1.Created, result.Created);
}
public async Task TryUpdateSymbolsServerRequestAsyncReturnsFalseIfRequestNotInDatabase()
{
// Arrange
SymbolsServerRequest request1 = new SymbolsServerRequest()
{
Created = DateTime.UtcNow,
LastUpdated = DateTime.UtcNow,
RequestName = PackageKey.ToString(),
RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingesting,
SymbolsKey = PackageKey
};
SymbolsServerRequest request2 = new SymbolsServerRequest()
{
Created = new DateTime(2018, 4, 5),
LastUpdated = DateTime.UtcNow,
RequestName = "Some Name",
RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingesting,
SymbolsKey = PackageKey
};
_validationEntitiesContext
.Setup(x => x.SymbolsServerRequests)
.Returns(DbSetMockFactory.Create(request1));
// Act
var result = await _target.TryUpdateSymbolsServerRequestAsync(request2, SymbolsPackageIngestRequestStatus.Ingested);
// Assert
Assert.False(result);
}
public async Task TryUpdateSymbolsServerRequestAsyncUpdateRequestIfInDatabase()
{
// Arrange
SymbolsServerRequest request = new SymbolsServerRequest()
{
Created = new DateTime(2000, 4, 5),
LastUpdated = new DateTime(2000, 4, 5),
RequestName = PackageKey.ToString(),
RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingesting,
SymbolsKey = PackageKey
};
_validationEntitiesContext
.Setup(x => x.SymbolsServerRequests)
.Returns(DbSetMockFactory.Create(request));
_validationEntitiesContext
.Setup(x => x.SaveChangesAsync())
.ReturnsAsync(7);
// Act
var result = await _target.TryUpdateSymbolsServerRequestAsync(request, SymbolsPackageIngestRequestStatus.Ingested);
// Assert
Assert.True(result);
Assert.Equal(DateTime.UtcNow.Year, request.LastUpdated.Year);
}
public async Task RejectsPackageWithMultipleTimestamps()
{
// Arrange
var signature = await TestResources.LoadPrimarySignatureAsync(TestResources.SignedPackageLeaf1);
var existingPackageSignature = new PackageSignature
{
Key = 1,
PackageKey = _packageKey,
EndCertificate = new EndCertificate
{
Thumbprint = TestResources.Leaf1Thumbprint,
},
TrustedTimestamps = new[]
{
new TrustedTimestamp(),
new TrustedTimestamp(),
},
Type = PackageSignatureType.Author,
};
_entitiesContext
.Setup(x => x.PackageSignatures)
.Returns(DbSetMockFactory.Create(existingPackageSignature));
// Act & Assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(
() => _target.ExtractAsync(_packageKey, signature, _token));
Assert.Equal("There should never be more than one trusted timestamp per package signature.", ex.Message);
_entitiesContext.Verify(
x => x.SaveChangesAsync(),
Times.Never);
Assert.Empty(_savedCertificates);
}
public async Task RejectsAuthorSignedPackageWithChangedSigningCertificateThumbprint()
{
// Arrange
var signature = await TestResources.LoadPrimarySignatureAsync(TestResources.SignedPackageLeaf1);
var existingPackageSignature = new PackageSignature
{
Key = 1,
PackageKey = _packageKey,
EndCertificate = new EndCertificate
{
Thumbprint = "something else",
},
Type = PackageSignatureType.Author,
};
_entitiesContext
.Setup(x => x.PackageSignatures)
.Returns(DbSetMockFactory.Create(existingPackageSignature));
// Act & Assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(
() => _target.ExtractAsync(_packageKey, signature, _token));
Assert.Equal("The thumbprint of the signature end certificate cannot change.", ex.Message);
_entitiesContext.Verify(
x => x.SaveChangesAsync(),
Times.Never);
Assert.Empty(_savedCertificates);
}
public Facts(ITestOutputHelper output)
{
_packageKey = 23;
_validatorType = "ExampleValidator";
_packageValidation = new PackageValidation
{
Type = _validatorType,
ValidationStatus = ValidationStatus.Incomplete,
Started = new DateTime(2017, 1, 1, 8, 30, 0, DateTimeKind.Utc),
PackageValidationIssues = new List <PackageValidationIssue>(),
PackageValidationSet = new PackageValidationSet(),
};
_nupkgUrl = "https://example/nuget.versioning.4.3.0.nupkg";
_entitiesContext = new Mock <IValidationEntitiesContext>();
_entitiesContext
.Setup(x => x.PackageValidationSets)
.Returns(DbSetMockFactory.Create <PackageValidationSet>());
_packageFileService = new Mock <IValidationPackageFileService>();
_validatorProvider = new Mock <IValidatorProvider>();
_telemetryService = new Mock <ITelemetryService>();
_loggerFactory = new LoggerFactory();
_loggerFactory.AddXunit(output);
InitializeTarget();
}
public async Task RejectsPackageWithMultipleSignatures(PackageSignatureType type, string resourceName)
{
// Arrange
var signature = await TestResources.LoadPrimarySignatureAsync(resourceName);
var existingPackageSignature1 = new PackageSignature
{
Key = 1,
PackageKey = _packageKey,
Type = type,
};
var existingPackageSignature2 = new PackageSignature
{
Key = 2,
PackageKey = _packageKey,
Type = type,
};
_entitiesContext
.Setup(x => x.PackageSignatures)
.Returns(DbSetMockFactory.Create(existingPackageSignature1, existingPackageSignature2));
// Act & Assert
var ex = await Assert.ThrowsAsync <InvalidOperationException>(
() => _target.ExtractAsync(_packageKey, signature, _token));
Assert.Equal("There should never be more than one package signature per package and signature type.", ex.Message);
_entitiesContext.Verify(
x => x.SaveChangesAsync(),
Times.Never);
Assert.Empty(_savedCertificates);
}
private DbSet <MediaInstance> CreateMediaInstancesDbSet()
{
var mediaInstance1 = new MediaInstance
{
Id = "1",
Timestamp = new DateTime(2009, 1, 1, 0, 0, 0)
};
var mediaInstance2 = new MediaInstance
{
Id = "2",
Timestamp = new DateTime(2008, 1, 1, 0, 0, 0)
};
var mediaInstance3 = new MediaInstance
{
Id = "3",
Timestamp = new DateTime(2008, 6, 1, 0, 0, 0)
};
var instances = new HashSet <MediaInstance>()
{
mediaInstance1,
mediaInstance2,
mediaInstance3
};
return(DbSetMockFactory.Create(instances).Object);
}
public async Task ReturnsMatchingCount()
{
// Arrange
_entitiesContext
.Setup(x => x.PackageValidationSets)
.Returns(DbSetMockFactory.Create(
new PackageValidationSet {
PackageKey = _packageKey - 1
},
new PackageValidationSet {
PackageKey = _packageKey
},
new PackageValidationSet {
PackageKey = _packageKey
},
new PackageValidationSet {
PackageKey = _packageKey
},
new PackageValidationSet {
PackageKey = _packageKey + 1
}));
var actual = await _target.GetValidationSetCountAsync(_packageValidatingEntity);
Assert.Equal(3, actual);
}
private IApplicationContext CreateMockApplicationContext(IEnumerable <MediaInstance> givenMedia)
{
var tagMock = DbSetMockFactory.Create(givenMedia);
var mock = new Mock <IApplicationContext>();
mock.Setup(m => m.MediaInstances).Returns(tagMock.Object);
return(mock.Object);
}
public ProduceWorkAsync(ITestOutputHelper output)
{
_entitiesContextFactory = new Mock <IEntitiesContextFactory>();
_entitiesContext = new Mock <IEntitiesContext>();
_options = new Mock <IOptionsSnapshot <Db2AzureSearchConfiguration> >();
_config = new Db2AzureSearchConfiguration
{
DatabaseBatchSize = 2,
};
_developmentOptions = new Mock <IOptionsSnapshot <Db2AzureSearchDevelopmentConfiguration> >();
_developmentConfig = new Db2AzureSearchDevelopmentConfiguration();
_logger = output.GetLogger <NewPackageRegistrationProducer>();
_packageRegistrations = DbSetMockFactory.Create <PackageRegistration>();
_packages = DbSetMockFactory.Create <Package>();
_work = new ConcurrentBag <NewPackageRegistration>();
_token = CancellationToken.None;
_auxiliaryFileClient = new Mock <IAuxiliaryFileClient>();
_excludedPackages = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_auxiliaryFileClient
.Setup(x => x.LoadExcludedPackagesAsync())
.ReturnsAsync(() => _excludedPackages);
_downloads = new DownloadData();
_auxiliaryFileClient
.Setup(x => x.LoadDownloadDataAsync())
.ReturnsAsync(() => _downloads);
_downloadOverrides = new Dictionary <string, long>(StringComparer.OrdinalIgnoreCase);
_auxiliaryFileClient
.Setup(x => x.LoadDownloadOverridesAsync())
.ReturnsAsync(() => _downloadOverrides);
_entitiesContextFactory
.Setup(x => x.CreateAsync(It.IsAny <bool>()))
.ReturnsAsync(() => _entitiesContext.Object);
_entitiesContext
.Setup(x => x.Set <PackageRegistration>())
.Returns(() => _packageRegistrations);
_entitiesContext
.Setup(x => x.Set <Package>())
.Returns(() => _packages);
_options
.Setup(x => x.Value)
.Returns(() => _config);
_developmentOptions
.Setup(x => x.Value)
.Returns(() => _developmentConfig);
_target = new NewPackageRegistrationProducer(
_entitiesContextFactory.Object,
_auxiliaryFileClient.Object,
_options.Object,
_developmentOptions.Object,
_logger);
}
public WhenVerifyingBrowseToken()
{
_timeProviderMock = new Mock <ITimeProvider>();
_timeProviderMock.Setup(provider => provider.GetUtc())
.Returns(_givenDate);
_browseTokensMock = DbSetMockFactory.Create(_givenBrowseTokens);
_authorizationContextMock = new Mock <IAuthorizationContext>();
_authorizationContextMock.Setup(context => context.BrowseTokens)
.Returns(_browseTokensMock.Object);
}
public async Task DropsAllPackageSignaturesWhenPackageStateTransitionsToUnsigned()
{
// Arrange
const int packageKey = 1;
const string packageId = "packageId";
const string packageVersion = "1.0.0";
const PackageSigningStatus newStatus = PackageSigningStatus.Unsigned;
var signature1 = new PackageSignature();
var signature2 = new PackageSignature();
var packageSigningState = new PackageSigningState
{
PackageId = packageId,
PackageKey = packageKey,
SigningStatus = PackageSigningStatus.Valid,
PackageNormalizedVersion = packageVersion,
PackageSignatures = new List <PackageSignature> {
signature1, signature2
}
};
var logger = _loggerFactory.CreateLogger <PackageSigningStateService>();
var packageSigningStatesDbSetMock = DbSetMockFactory.CreateMock(packageSigningState);
var packageSignaturesDbSetMock = DbSetMockFactory.CreateMock(signature1, signature2);
var validationContextMock = new Mock <IValidationEntitiesContext>(MockBehavior.Strict);
validationContextMock.Setup(m => m.PackageSigningStates).Returns(packageSigningStatesDbSetMock.Object);
validationContextMock.Setup(m => m.PackageSignatures).Returns(packageSignaturesDbSetMock.Object);
// Act
var packageSigningStateService = new PackageSigningStateService(validationContextMock.Object, logger);
// Assert
await packageSigningStateService.SetPackageSigningState(
packageKey,
packageId,
packageVersion,
status : newStatus);
// Assert
Assert.Equal(newStatus, packageSigningState.SigningStatus);
packageSignaturesDbSetMock.Verify(m => m.Remove(signature1), Times.Once);
packageSignaturesDbSetMock.Verify(m => m.Remove(signature2), Times.Once);
validationContextMock.Verify(
m => m.SaveChangesAsync(),
Times.Never,
"Saving the context here is incorrect as updating the validator's status also saves the context. Doing so would cause both queries not to be executed in the same transaction.");
}
public IDbSetMock GetDbSet(Type entityType)
{
//Return the substitute value
IDbSetMock returnValue;
if (!setValues.TryGetValue(entityType, out returnValue))
{
var collection = database.Set(entityType);
returnValue = DbSetMockFactory.Create(entityType, collection);
setValues.Add(entityType, returnValue);
}
return(returnValue);
}
public async Task AcceptsRepoSignedPackageWithChangedSigningCertificateThumbprint()
{
// Arrange
var signature = await TestResources.LoadPrimarySignatureAsync(TestResources.RepoSignedPackageLeaf1);
var existingTrustedTimestamp = new TrustedTimestamp
{
EndCertificate = new EndCertificate
{
Thumbprint = "something else B",
},
};
var existingPackageSignature = new PackageSignature
{
Key = 1,
PackageKey = _packageKey,
EndCertificate = new EndCertificate
{
Thumbprint = "something else A",
},
Type = PackageSignatureType.Repository,
TrustedTimestamps = new List <TrustedTimestamp>
{
existingTrustedTimestamp
},
};
_entitiesContext
.Setup(x => x.PackageSignatures)
.Returns(DbSetMockFactory.Create(existingPackageSignature));
_entitiesContext
.Setup(x => x.TrustedTimestamps)
.Returns(DbSetMockFactory.Create(existingTrustedTimestamp));
// Act
await _target.ExtractAsync(_packageKey, signature, _token);
// Assert
var newPackageSignature = Assert.Single(_entitiesContext.Object.PackageSignatures);
Assert.NotSame(existingPackageSignature, newPackageSignature);
Assert.Equal(TestResources.Leaf1Thumbprint, newPackageSignature.EndCertificate.Thumbprint);
var newTrustedTimestamp = Assert.Single(_entitiesContext.Object.TrustedTimestamps);
Assert.NotSame(existingTrustedTimestamp, newTrustedTimestamp);
Assert.Equal(TestResources.Leaf1TimestampThumbprint, newTrustedTimestamp.EndCertificate.Thumbprint);
}
public WhenIssuingBrowseToken()
{
_addedTokens = new HashSet <BrowseToken>();
_removedTokens = new HashSet <BrowseToken>();
_timeProviderMock = new Mock <ITimeProvider>();
_timeProviderMock.Setup(provider => provider.GetUtc())
.Returns(_givenDate);
_browseTokensMock = DbSetMockFactory.Create(_givenBrowseTokens);
_browseTokensMock.StoreAddedEntitiesIn(_addedTokens);
_browseTokensMock.StoreRemovedEntitiesIn(_removedTokens);
_authorizationContextMock = new Mock <IAuthorizationContext>();
_authorizationContextMock.Setup(context => context.BrowseTokens)
.Returns(_browseTokensMock.Object);
}
private DbSet <MediaInstance> CreateMediaInstancesDbSet()
{
var user1 = "user1";
var user2 = "user2";
var mediaInstance1 = new MediaInstance
{
Id = "1",
IsPrivate = true,
AuthorId = user1
};
var mediaInstance2 = new MediaInstance
{
Id = "2",
IsPrivate = false,
AuthorId = user1
};
var mediaInstance3 = new MediaInstance
{
Id = "3",
IsPrivate = true,
AuthorId = user2
};
var mediaInstance4 = new MediaInstance
{
Id = "4",
IsPrivate = false,
AuthorId = user2
};
var mediaInstance5 = new MediaInstance
{
Id = "5",
IsPrivate = false
};
var instances = new HashSet <MediaInstance>()
{
mediaInstance1,
mediaInstance2,
mediaInstance3,
mediaInstance4,
mediaInstance5
};
return(DbSetMockFactory.Create(instances).Object);
}
public async Task ReturnsFalseIfOtherValidationSetIsOutOfRange()
{
// Arrange
_entitiesContext
.Setup(x => x.PackageValidationSets)
.Returns(DbSetMockFactory.Create(
new PackageValidationSet {
PackageKey = _packageKey, Created = _before, ValidationTrackingId = _idB
}));
// Act
var actual = await _target.OtherRecentValidationSetForPackageExists(
_packageValidatingEntity,
_duration,
_idA);
// Assert
Assert.False(actual, $"The validation set with ID {_idB} should not have be considered since it was out of the range.");
}
public async Task ReturnsTrueIfOtherValidationSetIsInRange()
{
// Arrange
_entitiesContext
.Setup(x => x.PackageValidationSets)
.Returns(DbSetMockFactory.Create(
new PackageValidationSet {
PackageKey = _packageKey, Created = _now, ValidationTrackingId = _idB
}));
// Act
var actual = await _target.OtherRecentValidationSetForPackageExists(
_packageValidatingEntity,
_duration,
_idA);
// Assert
Assert.True(actual, $"The validation set with validation ID {_idB} should have been detected.");
}
public async Task ReturnsFalseIfOnlyValidationSetInRangeIsSelf()
{
// Arrange
_entitiesContext
.Setup(x => x.PackageValidationSets)
.Returns(DbSetMockFactory.Create(
new PackageValidationSet {
PackageKey = _packageKey, Created = _now, ValidationTrackingId = _idA
}));
// Act
var actual = await _target.OtherRecentValidationSetForPackageExists(
_packageValidatingEntity,
_duration,
_idA);
// Assert
Assert.False(actual, $"The current validation set with ID {_idA} should not have be considered.");
}
public ExtractAsync()
{
_packageKey = 23;
_token = CancellationToken.None;
_savedCertificates = new List <X509Certificate2>();
_certificateStore = new Mock <ICertificateStore>();
_certificateStore
.Setup(x => x.ExistsAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns <string, CancellationToken>((t, _) => Task.FromResult(_savedCertificates.Any(x => x.ComputeSHA256Thumbprint() == t)));
_certificateStore
.Setup(x => x.SaveAsync(It.IsAny <X509Certificate2>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Callback <X509Certificate2, CancellationToken>((cert, _) => _savedCertificates.Add(new X509Certificate2(cert.RawData)));
_entitiesContext = new Mock <IValidationEntitiesContext>();
_entitiesContext
.Setup(x => x.ParentCertificates)
.Returns(DbSetMockFactory.Create <ParentCertificate>());
_entitiesContext
.Setup(x => x.EndCertificates)
.Returns(DbSetMockFactory.Create <EndCertificate>());
_entitiesContext
.Setup(x => x.CertificateChainLinks)
.Returns(DbSetMockFactory.Create <CertificateChainLink>());
_entitiesContext
.Setup(x => x.PackageSignatures)
.Returns(DbSetMockFactory.Create <PackageSignature>());
_entitiesContext
.Setup(x => x.TrustedTimestamps)
.Returns(DbSetMockFactory.Create <TrustedTimestamp>());
_logger = new Mock <ILogger <SignaturePartsExtractor> >();
_target = new SignaturePartsExtractor(
_certificateStore.Object,
_entitiesContext.Object,
_logger.Object);
}
public Facts(ITestOutputHelper output)
{
SqlConnectionFactory = new Mock <ISqlConnectionFactory <GalleryDbConfiguration> >();
EntitiesContextFactory = new Mock <IEntitiesContextFactory>();
EntitiesContext = new Mock <IEntitiesContext>();
TelemetryService = new Mock <IAzureSearchTelemetryService>();
Logger = output.GetLogger <DatabaseAuxiliaryDataFetcher>();
PackageRegistrations = DbSetMockFactory.Create <PackageRegistration>();
EntitiesContextFactory
.Setup(x => x.CreateAsync(It.IsAny <bool>()))
.ReturnsAsync(() => EntitiesContext.Object);
EntitiesContext
.Setup(x => x.PackageRegistrations)
.Returns(() => PackageRegistrations);
Target = new DatabaseAuxiliaryDataFetcher(
SqlConnectionFactory.Object,
EntitiesContextFactory.Object,
TelemetryService.Object,
Logger);
}
private DbSet <MediaInstance> CreateMediaInstancesDbSet()
{
var user1 = "user1";
var user2 = "user2";
var mediaInstance1 = new MediaInstance
{
Id = "1"
};
var mediaInstance2 = new MediaInstance
{
Id = "2"
};
var mediaInstance3 = new MediaInstance
{
Id = "3"
};
var favoriteMedia1 = CreateFavoriteMedia(user1, mediaInstance1);
var favoriteMedia2 = CreateFavoriteMedia(user1, mediaInstance2);
var favoriteMedia3 = CreateFavoriteMedia(user2, mediaInstance2);
var favoriteMedia4 = CreateFavoriteMedia(user2, mediaInstance3);
mediaInstance1.FavoriteMedia.Add(favoriteMedia1);
mediaInstance2.FavoriteMedia.Add(favoriteMedia2);
mediaInstance2.FavoriteMedia.Add(favoriteMedia3);
mediaInstance3.FavoriteMedia.Add(favoriteMedia4);
var instances = new HashSet <MediaInstance>()
{
mediaInstance1,
mediaInstance2,
mediaInstance3
};
return(DbSetMockFactory.Create(instances).Object);
}
public async Task AddsNewStateWhenSignatureStateIsNull()
{
// Arrange
const int packageKey = 1;
const string packageId = "packageId";
const string packageVersion = "1.0.0";
const PackageSigningStatus newStatus = PackageSigningStatus.Invalid;
var logger = _loggerFactory.CreateLogger <PackageSigningStateService>();
var packageSigningStatesDbSetMock = DbSetMockFactory.Create <PackageSigningState>();
var validationContextMock = new Mock <IValidationEntitiesContext>(MockBehavior.Strict);
validationContextMock.Setup(m => m.PackageSigningStates).Returns(packageSigningStatesDbSetMock);
// Act
var packageSigningStateService = new PackageSigningStateService(validationContextMock.Object, logger);
// Assert
await packageSigningStateService.SetPackageSigningState(
packageKey,
packageId,
packageVersion,
status : newStatus);
// Assert
var newState = validationContextMock.Object.PackageSigningStates.FirstOrDefault();
Assert.NotNull(newState);
Assert.Equal(packageKey, newState.PackageKey);
Assert.Equal(packageId, newState.PackageId);
Assert.Equal(packageVersion, newState.PackageNormalizedVersion);
Assert.Equal(newStatus, newState.SigningStatus);
validationContextMock.Verify(
m => m.SaveChangesAsync(),
Times.Never,
"Saving the context here is incorrect as updating the validator's status also saves the context. Doing so would cause both queries not to be executed in the same transaction.");
}
public ProduceWorkAsync(ITestOutputHelper output)
{
_entitiesContextFactory = new Mock <IEntitiesContextFactory>();
_entitiesContext = new Mock <IEntitiesContext>();
_options = new Mock <IOptionsSnapshot <Db2AzureSearchConfiguration> >();
_config = new Db2AzureSearchConfiguration
{
DatabaseBatchSize = 2,
EnablePopularityTransfers = true,
};
_developmentOptions = new Mock <IOptionsSnapshot <Db2AzureSearchDevelopmentConfiguration> >();
_developmentConfig = new Db2AzureSearchDevelopmentConfiguration();
_logger = output.GetLogger <NewPackageRegistrationProducer>();
_packageRegistrations = DbSetMockFactory.Create <PackageRegistration>();
_packages = DbSetMockFactory.Create <Package>();
_work = new ConcurrentBag <NewPackageRegistration>();
_token = CancellationToken.None;
_auxiliaryFileClient = new Mock <IAuxiliaryFileClient>();
_excludedPackages = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_auxiliaryFileClient
.Setup(x => x.LoadExcludedPackagesAsync())
.ReturnsAsync(() => _excludedPackages);
_downloads = new DownloadData();
_auxiliaryFileClient
.Setup(x => x.LoadDownloadDataAsync())
.ReturnsAsync(() => _downloads);
_popularityTransfers = new PopularityTransferData();
_databaseFetcher = new Mock <IDatabaseAuxiliaryDataFetcher>();
_databaseFetcher
.Setup(x => x.GetPopularityTransfersAsync())
.ReturnsAsync(() => _popularityTransfers);
_downloadTransferrer = new Mock <IDownloadTransferrer>();
_transferChanges = new SortedDictionary <string, long>(StringComparer.OrdinalIgnoreCase);
_downloadTransferrer
.Setup(x => x.InitializeDownloadTransfers(
It.IsAny <DownloadData>(),
It.IsAny <PopularityTransferData>()))
.Returns(_transferChanges);
_featureFlags = new Mock <IFeatureFlagService>();
_featureFlags
.Setup(x => x.IsPopularityTransferEnabled())
.Returns(true);
_entitiesContextFactory
.Setup(x => x.CreateAsync(It.IsAny <bool>()))
.ReturnsAsync(() => _entitiesContext.Object);
_entitiesContext
.Setup(x => x.Set <PackageRegistration>())
.Returns(() => _packageRegistrations);
_entitiesContext
.Setup(x => x.Set <Package>())
.Returns(() => _packages);
_options
.Setup(x => x.Value)
.Returns(() => _config);
_developmentOptions
.Setup(x => x.Value)
.Returns(() => _developmentConfig);
_target = new NewPackageRegistrationProducer(
_entitiesContextFactory.Object,
_auxiliaryFileClient.Object,
_databaseFetcher.Object,
_downloadTransferrer.Object,
_featureFlags.Object,
_options.Object,
_developmentOptions.Object,
_logger);
}
public async Task DoesNotDuplicateWhenSomeDataAlreadyExist()
{
// Arrange
var signature = await TestResources.LoadPrimarySignatureAsync(TestResources.SignedPackageLeaf1);
var existingParentCertificate = new ParentCertificate
{
Key = 1,
Thumbprint = TestResources.RootThumbprint,
CertificateChainLinks = new List <CertificateChainLink>(),
};
var existingEndCertificate = new EndCertificate
{
Key = 1,
Thumbprint = TestResources.Leaf1Thumbprint,
Status = EndCertificateStatus.Good, // Different than the default.
Use = EndCertificateUse.CodeSigning,
CertificateChainLinks = new List <CertificateChainLink>(),
};
var existingLink = new CertificateChainLink
{
ParentCertificate = existingParentCertificate,
ParentCertificateKey = existingParentCertificate.Key,
EndCertificate = existingEndCertificate,
EndCertificateKey = existingEndCertificate.Key,
};
existingParentCertificate.CertificateChainLinks.Add(existingLink);
existingEndCertificate.CertificateChainLinks.Add(existingLink);
var existingPackageSignature = new PackageSignature
{
Key = 1,
EndCertificate = existingEndCertificate,
EndCertificateKey = existingEndCertificate.Key,
Status = PackageSignatureStatus.Valid,
CreatedAt = new DateTime(2017, 1, 1, 8, 30, 0, DateTimeKind.Utc),
PackageKey = _packageKey,
Type = PackageSignatureType.Author,
TrustedTimestamps = new List <TrustedTimestamp>(),
};
_entitiesContext
.Setup(x => x.ParentCertificates)
.Returns(DbSetMockFactory.Create(existingParentCertificate));
_entitiesContext
.Setup(x => x.EndCertificates)
.Returns(DbSetMockFactory.Create(existingEndCertificate));
_entitiesContext
.Setup(x => x.CertificateChainLinks)
.Returns(DbSetMockFactory.Create(existingLink));
_entitiesContext
.Setup(x => x.PackageSignatures)
.Returns(DbSetMockFactory.Create(existingPackageSignature));
// Act
await _target.ExtractAsync(_packageKey, signature, _token);
// Assert
VerifyExtractedInformation(Leaf1Certificates, Leaf1TimestampValue, PackageSignatureType.Author);
Assert.Equal(2, _entitiesContext.Object.EndCertificates.Count());
Assert.Equal(4, _entitiesContext.Object.ParentCertificates.Count());
Assert.Equal(4, _entitiesContext.Object.CertificateChainLinks.Count());
Assert.Equal(1, _entitiesContext.Object.PackageSignatures.Count());
Assert.Equal(1, _entitiesContext.Object.TrustedTimestamps.Count());
Assert.Equal(EndCertificateStatus.Good, existingEndCertificate.Status);
Assert.Equal(PackageSignatureStatus.Valid, existingPackageSignature.Status);
}
public AzureSearchCollectorLogicIntegrationTests(ITestOutputHelper output)
{
_utilityConfig = new CommitCollectorConfiguration
{
MaxConcurrentCatalogLeafDownloads = 1,
};
_utilityOptions = new Mock <IOptionsSnapshot <CommitCollectorConfiguration> >();
_utilityOptions.Setup(x => x.Value).Returns(() => _utilityConfig);
_config = new Catalog2AzureSearchConfiguration
{
MaxConcurrentBatches = 1,
MaxConcurrentVersionListWriters = 1,
StorageContainer = "integration-tests-container",
StoragePath = "integration-tests-path",
RegistrationsBaseUrl = "https://example/registrations/",
GalleryBaseUrl = Data.GalleryBaseUrl,
FlatContainerBaseUrl = Data.FlatContainerBaseUrl,
FlatContainerContainerName = Data.FlatContainerContainerName,
Scoring = new AzureSearchScoringConfiguration()
};
_options = new Mock <IOptionsSnapshot <Catalog2AzureSearchConfiguration> >();
_options.Setup(x => x.Value).Returns(() => _config);
_developmentConfig = new AzureSearchJobDevelopmentConfiguration();
_developmentOptions = new Mock <IOptionsSnapshot <AzureSearchJobDevelopmentConfiguration> >();
_developmentOptions.Setup(x => x.Value).Returns(() => _developmentConfig);
_telemetryClient = new Mock <ITelemetryClient>();
_telemetryService = new AzureSearchTelemetryService(_telemetryClient.Object);
_v3TelemetryService = new V3TelemetryService(_telemetryClient.Object);
// Mock the database that is used for fetching owner information. The product code only reads
// from the database so it is less important to have a realistic, stateful implementation.
_entitiesContextFactory = new Mock <IEntitiesContextFactory>();
_entitiesContext = new Mock <IEntitiesContext>();
_entitiesContextFactory.Setup(x => x.CreateAsync(It.IsAny <bool>())).ReturnsAsync(() => _entitiesContext.Object);
_entitiesContext.Setup(x => x.PackageRegistrations).Returns(DbSetMockFactory.Create <PackageRegistration>());
_ownerFetcher = new DatabaseAuxiliaryDataFetcher(
new Mock <ISqlConnectionFactory <GalleryDbConfiguration> >().Object,
_entitiesContextFactory.Object,
_telemetryService,
output.GetLogger <DatabaseAuxiliaryDataFetcher>());
_cloudBlobClient = new InMemoryCloudBlobClient();
_versionListDataClient = new VersionListDataClient(
_cloudBlobClient,
_options.Object,
output.GetLogger <VersionListDataClient>());
_registrationClient = new InMemoryRegistrationClient();
_catalogClient = new InMemoryCatalogClient();
_leafFetcher = new CatalogLeafFetcher(
_registrationClient,
_catalogClient,
_options.Object,
_telemetryService,
output.GetLogger <CatalogLeafFetcher>());
_baseDocumentBuilder = new BaseDocumentBuilder(_options.Object);
_search = new SearchDocumentBuilder(_baseDocumentBuilder);
_hijack = new HijackDocumentBuilder(_baseDocumentBuilder);
_builder = new CatalogIndexActionBuilder(
_versionListDataClient,
_leafFetcher,
_ownerFetcher,
_search,
_hijack,
output.GetLogger <CatalogIndexActionBuilder>());
_searchIndex = new Mock <ISearchIndexClientWrapper>();
_searchDocuments = new InMemoryDocumentsOperations();
_searchIndex.Setup(x => x.Documents).Returns(() => _searchDocuments);
_hijackIndex = new Mock <ISearchIndexClientWrapper>();
_hijackDocuments = new InMemoryDocumentsOperations();
_hijackIndex.Setup(x => x.Documents).Returns(() => _hijackDocuments);
_fixUpEvaluator = new DocumentFixUpEvaluator(
_versionListDataClient,
_leafFetcher,
output.GetLogger <DocumentFixUpEvaluator>());
_commitCollectorUtility = new CommitCollectorUtility(
_catalogClient,
_v3TelemetryService,
_utilityOptions.Object,
output.GetLogger <CommitCollectorUtility>());
_collector = new AzureSearchCollectorLogic(
_builder,
() => new BatchPusher(
_searchIndex.Object,
_hijackIndex.Object,
_versionListDataClient,
_options.Object,
_developmentOptions.Object,
_telemetryService,
output.GetLogger <BatchPusher>()),
_fixUpEvaluator,
_commitCollectorUtility,
_options.Object,
_telemetryService,
output.GetLogger <AzureSearchCollectorLogic>());
}
public SignatureValidatorIntegrationTests(CertificateIntegrationTestFixture fixture, ITestOutputHelper output)
{
_fixture = fixture ?? throw new ArgumentNullException(nameof(fixture));
_output = output ?? throw new ArgumentNullException(nameof(output));
_validationEntitiesContext = new Mock <IValidationEntitiesContext>();
_validationEntitiesContext
.Setup(x => x.PackageSigningStates)
.Returns(DbSetMockFactory.Create <PackageSigningState>());
_validationEntitiesContext
.Setup(x => x.ParentCertificates)
.Returns(DbSetMockFactory.Create <ParentCertificate>());
_validationEntitiesContext
.Setup(x => x.EndCertificates)
.Returns(DbSetMockFactory.Create <EndCertificate>());
_validationEntitiesContext
.Setup(x => x.CertificateChainLinks)
.Returns(DbSetMockFactory.Create <CertificateChainLink>());
_validationEntitiesContext
.Setup(x => x.PackageSignatures)
.Returns(DbSetMockFactory.Create <PackageSignature>());
_validationEntitiesContext
.Setup(x => x.TrustedTimestamps)
.Returns(DbSetMockFactory.Create <TrustedTimestamp>());
var loggerFactory = new LoggerFactory();
loggerFactory.AddXunit(output);
_packageSigningStateService = new PackageSigningStateService(
_validationEntitiesContext.Object,
loggerFactory.CreateLogger <PackageSigningStateService>());
_certificateStore = new Mock <ICertificateStore>();
_signaturePartsExtractor = new SignaturePartsExtractor(
_certificateStore.Object,
_validationEntitiesContext.Object,
loggerFactory.CreateLogger <SignaturePartsExtractor>());
_packageFileService = new Mock <IProcessorPackageFileService>();
_nupkgUri = new Uri("https://example-storage/TestProcessor/b777135f-1aac-4ec2-a3eb-1f64fe1880d5/nuget.versioning.4.3.0.nupkg");
_packageFileService
.Setup(x => x.GetReadAndDeleteUriAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(() => _nupkgUri);
_packageFileService
.Setup(x => x.SaveAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <Stream>()))
.Returns(Task.CompletedTask)
.Callback <string, string, Guid, Stream>((_, __, ___, s) =>
{
using (var memoryStream = new MemoryStream())
{
s.Position = 0;
s.CopyTo(memoryStream);
_savedPackageBytes = memoryStream.ToArray();
}
});
_corePackageService = new Mock <ICorePackageService>();
// These dependencies are concrete.
_minimalPackageSignatureVerifier = PackageSignatureVerifierFactory.CreateMinimal();
_fullPackageSignatureVerifier = PackageSignatureVerifierFactory.CreateFull();
_telemetryClient = new Mock <ITelemetryClient>();
_telemetryService = new TelemetryService(_telemetryClient.Object);
_logger = new RecordingLogger <SignatureValidator>(loggerFactory.CreateLogger <SignatureValidator>());
// Initialize data.
_packageKey = 23;
_message = new SignatureValidationMessage(
"SomePackageId",
"1.2.3",
new Uri("https://example/validation/somepackageid.1.2.3.nupkg"),
new Guid("8eb5affc-2d0e-4315-9b79-5a194d39ebd1"));
_token = CancellationToken.None;
// Initialize the subject of testing.
_target = new SignatureValidator(
_packageSigningStateService,
_minimalPackageSignatureVerifier,
_fullPackageSignatureVerifier,
_signaturePartsExtractor,
_packageFileService.Object,
_corePackageService.Object,
_telemetryService,
_logger);
}
