public void AllTypesDependingOnIFileStorageServiceAreReturnedByGetStorageDependents() { // Arrange var config = GetConfiguration(); // Act var dependents = StorageDependent.GetAll(config); // Assert var actual = new HashSet <Type>(dependents.Select(x => x.ImplementationType)); var allTypes = typeof(DefaultDependenciesModule).Assembly.GetTypes(); var expected = new HashSet <Type>(); foreach (var type in allTypes) { var constructors = type.GetConstructors(); foreach (var constructor in constructors) { var parameters = constructor.GetParameters(); if (parameters.Any(p => p.ParameterType == typeof(IFileStorageService))) { expected.Add(type); } } } Assert.Subset(expected, actual); Assert.Subset(actual, expected); }
public void StorageDependentsHaveExpectedTypes() { // Arrange var config = GetConfiguration(); // Act var dependents = StorageDependent.GetAll(config); // Assert var implementationToInterface = dependents.ToDictionary(x => x.ImplementationType, x => x.InterfaceType); Assert.Contains(typeof(CertificateService), implementationToInterface.Keys); Assert.Contains(typeof(ContentService), implementationToInterface.Keys); Assert.Contains(typeof(PackageFileService), implementationToInterface.Keys); Assert.Contains(typeof(SymbolPackageFileService), implementationToInterface.Keys); Assert.Contains(typeof(UploadFileService), implementationToInterface.Keys); Assert.Contains(typeof(CoreLicenseFileService), implementationToInterface.Keys); Assert.Contains(typeof(RevalidationStateService), implementationToInterface.Keys); Assert.Equal(7, implementationToInterface.Count); Assert.Equal(typeof(ICertificateService), implementationToInterface[typeof(CertificateService)]); Assert.Equal(typeof(IContentService), implementationToInterface[typeof(ContentService)]); Assert.Equal(typeof(IPackageFileService), implementationToInterface[typeof(PackageFileService)]); Assert.Equal(typeof(ISymbolPackageFileService), implementationToInterface[typeof(SymbolPackageFileService)]); Assert.Equal(typeof(IUploadFileService), implementationToInterface[typeof(UploadFileService)]); Assert.Equal(typeof(ICoreLicenseFileService), implementationToInterface[typeof(CoreLicenseFileService)]); Assert.Equal(typeof(IRevalidationStateService), implementationToInterface[typeof(RevalidationStateService)]); }
private static void ConfigureForLocalFileSystem(ContainerBuilder builder, IGalleryConfigurationService configuration) { builder.RegisterType <FileSystemService>() .AsSelf() .As <IFileSystemService>() .SingleInstance(); builder.RegisterType <FileSystemFileStorageService>() .AsSelf() .As <IFileStorageService>() .As <ICoreFileStorageService>() .SingleInstance(); foreach (var dependent in StorageDependent.GetAll(configuration.Current)) { var registration = builder.RegisterType(dependent.ImplementationType) .AsSelf() .As(dependent.InterfaceType); if (dependent.IsSingleInstance) { registration.SingleInstance(); } else { registration.InstancePerLifetimeScope(); } } builder.RegisterInstance(NullReportService.Instance) .AsSelf() .As <IReportService>() .SingleInstance(); builder.RegisterInstance(NullStatisticsService.Instance) .AsSelf() .As <IStatisticsService>() .SingleInstance(); // If we're not using azure storage, then aggregate stats comes from SQL builder.RegisterType <SqlAggregateStatsService>() .AsSelf() .As <IAggregateStatsService>() .InstancePerLifetimeScope(); builder.RegisterInstance(new SqlErrorLog(configuration.Current.SqlConnectionString)) .As <ErrorLog>() .SingleInstance(); builder.RegisterType <GalleryContentFileMetadataService>() .As <IContentFileMetadataService>() .SingleInstance(); }
public void StorageDependentsUseCorrectConnectionString() { // Arrange var config = GetConfiguration(); // Act var dependents = StorageDependent.GetAll(config); // Assert var typeToConnectionString = dependents.ToDictionary(x => x.ImplementationType, x => x.AzureStorageConnectionString); Assert.Equal(typeToConnectionString[typeof(ContentService)], config.AzureStorage_Content_ConnectionString); Assert.Equal(typeToConnectionString[typeof(PackageFileService)], config.AzureStorage_Packages_ConnectionString); Assert.Equal(typeToConnectionString[typeof(UploadFileService)], config.AzureStorage_Uploads_ConnectionString); }
public void StorageDependentsAreGroupedByConnectionString() { // Arrange var mock = new Mock <IAppConfiguration>(); mock.Setup(x => x.AzureStorage_Content_ConnectionString).Returns("Content"); mock.Setup(x => x.AzureStorage_Packages_ConnectionString).Returns("Packages and Uploads"); mock.Setup(x => x.AzureStorage_Uploads_ConnectionString).Returns("Packages and Uploads"); var config = mock.Object; // Act var dependents = StorageDependent.GetAll(config); // Assert var typeToBindingKey = dependents.ToDictionary(x => x.ImplementationType, x => x.BindingKey); Assert.Equal(typeToBindingKey[typeof(PackageFileService)], typeToBindingKey[typeof(UploadFileService)]); }
public void AllTypesDependingOnIFileStorageServiceAreReturnedByGetStorageDependents() { // Arrange var config = GetConfiguration(); var allGalleryTypes = typeof(DefaultDependenciesModule).Assembly.GetTypes(); var allGalleryAndCoreTypes = allGalleryTypes.Concat(typeof(ICoreFileStorageService).Assembly.GetTypes()); Assert.True(typeof(ICoreFileStorageService).IsAssignableFrom(typeof(IFileStorageService))); // classes in Gallery and Gallery.Core that depend on ICoreFileStorageService (or, // transitively, on IFileStorageService since the latter implements the former) var fileStorageDependents = new HashSet <Type>(allGalleryAndCoreTypes .Where(gct => gct .GetConstructors() .Any(c => c .GetParameters() .Any(pi => typeof(ICoreFileStorageService).IsAssignableFrom(pi.ParameterType))))); var fileStorageDependentsInterfaces = new HashSet <Type>(fileStorageDependents.SelectMany(t => t.GetInterfaces())); // file storage dependents that are actually used by Gallery types. var fileStorageDependentsInterfacesUsedByGallery = new HashSet <Type>(allGalleryTypes .SelectMany(gt => gt .GetConstructors() .SelectMany(c => c .GetParameters() .Where(pi => fileStorageDependentsInterfaces.Contains(pi.ParameterType)) .Select(pi => pi.ParameterType)))); var expected = new HashSet <Type>(fileStorageDependents .Where(t => fileStorageDependentsInterfacesUsedByGallery.Any(i => i.IsAssignableFrom(t)))); // Act var dependents = StorageDependent.GetAll(config); // Assert var actual = new HashSet <Type>(dependents.Select(x => x.ImplementationType)); Assert.Subset(expected, actual); Assert.Subset(actual, expected); }
public void StorageDependentsHaveExpectedTypes() { // Arrange var config = GetConfiguration(); // Act var dependents = StorageDependent.GetAll(config); // Assert var implementationToInterface = dependents.ToDictionary(x => x.ImplementationType, x => x.InterfaceType); Assert.Contains(typeof(ContentService), implementationToInterface.Keys); Assert.Contains(typeof(NuGetExeDownloaderService), implementationToInterface.Keys); Assert.Contains(typeof(PackageFileService), implementationToInterface.Keys); Assert.Contains(typeof(UploadFileService), implementationToInterface.Keys); Assert.Equal(4, implementationToInterface.Count); Assert.Equal(implementationToInterface[typeof(ContentService)], typeof(IContentService)); Assert.Equal(implementationToInterface[typeof(NuGetExeDownloaderService)], typeof(INuGetExeDownloaderService)); Assert.Equal(implementationToInterface[typeof(PackageFileService)], typeof(IPackageFileService)); Assert.Equal(implementationToInterface[typeof(UploadFileService)], typeof(IUploadFileService)); }
private static void ConfigureForAzureStorage(ContainerBuilder builder, IGalleryConfigurationService configuration, ITelemetryClient telemetryClient) { /// The goal here is to initialize a <see cref="ICloudBlobClient"/> and <see cref="IFileStorageService"/> /// instance for each unique connection string. Each dependent of <see cref="IFileStorageService"/> (that /// is, each service that has a <see cref="IFileStorageService"/> constructor parameter) is registered in /// <see cref="StorageDependent.GetAll(IAppConfiguration)"/> and is grouped by the respective storage /// connection string. Each group is given a binding key which refers to the appropriate instance of the /// <see cref="IFileStorageService"/>. var completedBindingKeys = new HashSet <string>(); foreach (var dependent in StorageDependent.GetAll(configuration.Current)) { if (completedBindingKeys.Add(dependent.BindingKey)) { builder.RegisterInstance(new CloudBlobClientWrapper(dependent.AzureStorageConnectionString, configuration.Current.AzureStorageReadAccessGeoRedundant)) .AsSelf() .As <ICloudBlobClient>() .SingleInstance() .Keyed <ICloudBlobClient>(dependent.BindingKey); builder.RegisterType <CloudBlobFileStorageService>() .WithParameter(new ResolvedParameter( (pi, ctx) => pi.ParameterType == typeof(ICloudBlobClient), (pi, ctx) => ctx.ResolveKeyed <ICloudBlobClient>(dependent.BindingKey))) .AsSelf() .As <IFileStorageService>() .As <ICloudStorageStatusDependency>() .SingleInstance() .Keyed <IFileStorageService>(dependent.BindingKey); } var registration = builder.RegisterType(dependent.ImplementationType) .WithParameter(new ResolvedParameter( (pi, ctx) => pi.ParameterType == typeof(IFileStorageService), (pi, ctx) => ctx.ResolveKeyed <IFileStorageService>(dependent.BindingKey))) .AsSelf() .As(dependent.InterfaceType); if (dependent.IsSingleInstance) { registration.SingleInstance(); } else { registration.InstancePerLifetimeScope(); } } // when running on Windows Azure, we use a back-end job to calculate stats totals and store in the blobs builder.RegisterInstance(new JsonAggregateStatsService(configuration.Current.AzureStorage_Statistics_ConnectionString, configuration.Current.AzureStorageReadAccessGeoRedundant)) .AsSelf() .As <IAggregateStatsService>() .SingleInstance(); // when running on Windows Azure, pull the statistics from the warehouse via storage builder.RegisterInstance(new CloudReportService(configuration.Current.AzureStorage_Statistics_ConnectionString, configuration.Current.AzureStorageReadAccessGeoRedundant)) .AsSelf() .As <IReportService>() .As <ICloudStorageStatusDependency>() .SingleInstance(); // when running on Windows Azure, download counts come from the downloads.v1.json blob var downloadCountService = new CloudDownloadCountService( telemetryClient, configuration.Current.AzureStorage_Statistics_ConnectionString, configuration.Current.AzureStorageReadAccessGeoRedundant); builder.RegisterInstance(downloadCountService) .AsSelf() .As <IDownloadCountService>() .SingleInstance(); ObjectMaterializedInterception.AddInterceptor(new DownloadCountObjectMaterializedInterceptor(downloadCountService)); builder.RegisterType <JsonStatisticsService>() .AsSelf() .As <IStatisticsService>() .SingleInstance(); builder.RegisterInstance(new TableErrorLog(configuration.Current.AzureStorage_Errors_ConnectionString)) .As <ErrorLog>() .SingleInstance(); }