/// <summary>
/// Add Config Server and Cloud Foundry as application configuration sources. Add Config Server health check
/// contributor to the service container.
/// </summary>
/// <param name="hostBuilder"><see cref="IWebHostBuilder"/></param>
/// <param name="loggerFactory"><see cref="ILoggerFactory"/></param>
/// <returns><see cref="IWebHostBuilder"/> with config server and Cloud Foundry Config Provider attached</returns>
public static IWebHostBuilder AddConfigServer(this IWebHostBuilder hostBuilder, ILoggerFactory loggerFactory = null)
{
hostBuilder.ConfigureAppConfiguration((context, config) =>
{
config.AddConfigServer(context.HostingEnvironment, loggerFactory);
});
hostBuilder.ConfigureServices((services) =>
{
services.AddConfigServerHealthContributor();
});
return(hostBuilder);
}
public static IWebHostBuilder AddSharedConfiguration(this IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration((context, configurationBuilder) =>
{
var env = context.HostingEnvironment;
var path = AppDomain.CurrentDomain.BaseDirectory;
configurationBuilder.AddJsonFile(Path.Combine(path, "sharedsettings.json"), true);
configurationBuilder.AddJsonFile(
Path.Combine(path, $"sharedsettings.{env.EnvironmentName}.json"), true);
});
return(builder);
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
base.ConfigureWebHost(builder);
var config = new ConfigurationBuilder();
config.AddEnvironmentVariables();
var con = config.Build();
// 增加单元测试本身的配置文件
builder.ConfigureAppConfiguration(app => app.AddJsonFile(TestHelper.RetrievePath($"UnitTest{Path.DirectorySeparatorChar}appsettings.json"), false, true));
if (con.GetValue("Appveyor", false))
{
builder.ConfigureAppConfiguration(app => app.AddJsonFile(TestHelper.RetrievePath($"UnitTest{Path.DirectorySeparatorChar}appsettings.appveyor.json"), false, true));
}
TestHelper.ConfigureWebHost(builder);
// 替换 SMS 服务
builder.ConfigureServices(services =>
{
services.AddTransient <ISMSProvider, DefaultSMSProvider>();
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
// Use TestAppSettings
builder.ConfigureAppConfiguration(configuration =>
{
configuration.AddJsonFile("appsettings.json");
Configuration = configuration.Build();
});
builder.ConfigureServices(services =>
{
services.UseConfigurationValidation();
// Parse and setup settings from configuration
services.ConfigureValidatableSetting <DatabaseSettings>(Configuration.GetSection("DatabaseSettings"));
services.ConfigureValidatableSetting <EnvironmentSettings>(
Configuration.GetSection("EnvironmentSettings"));
services.ConfigureValidatableSetting <IdentitySettings>(Configuration.GetSection("IdentitySettings"));
services.ConfigureValidatableSetting <MailgunSettings>(Configuration.GetSection("MailgunSettings"));
services.ConfigureValidatableSetting <MobilePaySettings>(Configuration.GetSection("MobilePaySettings"));
// Remove the app's ApplicationDbContext registration.
var descriptor = services.SingleOrDefault(
d => d.ServiceType ==
typeof(DbContextOptions <CoffeeCardContext>));
if (descriptor != null)
{
services.Remove(descriptor);
}
// Add ApplicationDbContext using an in-memory database for testing.
services.AddDbContext <CoffeeCardContext>(options =>
{
options.UseInMemoryDatabase("InMemoryDbForTesting");
});
// Build the service provider
var sp = services.BuildServiceProvider();
// Create a scope to obtain a reference to the database context (ApplicationDbContext).
using var scope = sp.CreateScope();
var scopedServices = scope.ServiceProvider;
var db = scopedServices.GetRequiredService <CoffeeCardContext>();
// Ensure the database is created.
db.Database.EnsureCreated();
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseEnvironment("Testing");
builder.ConfigureAppConfiguration((context, conf) =>
{
conf.AddJsonFile(AppDomain.CurrentDomain.BaseDirectory + "appsettings.Testing.json");
conf.AddUserSecrets <Startup>();
});
builder.ConfigureTestServices((services) =>
{
var configuration = services.BuildServiceProvider().GetRequiredService <IConfiguration>();
services.RegisterDebugRepositoriesModule(configuration);
services.AddDebugServicesModule(configuration);
var testGraphsMapping = configuration.GetSection("FunctionalTests:Graphs").Get <Dictionary <string, string> >();
var fakeRepo = new FakeTripleStoreRepository(testGraphsMapping);
services.RemoveAll(typeof(ITripleStoreRepository));
services.AddSingleton <ITripleStoreRepository>(provider =>
{
return(fakeRepo);
});
services.RemoveAll(typeof(IRemoteAppDataService));
services.AddTransient(provider =>
{
var remoteAppDataMock = new Mock <IRemoteAppDataService>();
var validPersons = new List <string> {
"*****@*****.**", "*****@*****.**", "*****@*****.**"
};
remoteAppDataMock.Setup(mock => mock.CheckPerson(It.IsIn <string>(validPersons))).Returns(It.IsAny <bool>());
remoteAppDataMock.Setup(mock => mock.CheckPerson(It.IsNotIn <string>(validPersons))).Returns(It.IsAny <bool>());
remoteAppDataMock.Setup(t => t.CreateConsumerGroup(It.IsAny <Uri>()));
remoteAppDataMock.Setup(t => t.DeleteConsumerGroup(It.IsAny <Uri>()));
remoteAppDataMock.Setup(t => t.NotifyResourcePublished(It.IsAny <Resource>()));
return(remoteAppDataMock.Object);
});
services.RemoveAll(typeof(IMessageQueueService));
services.AddTransient(provider => new Mock <IMessageQueueService>().Object);
services.RemoveAll(typeof(IReindexingService));
services.AddTransient(provider => new Mock <IReindexingService>().Object);
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
// This instructs the web host to use the appsettings.json file in the
// test project not the one in the original project being tested
var projectDir = Directory.GetCurrentDirectory();
var configPath = Path.Combine(projectDir, "appsettings.tests.json");
builder.ConfigureAppConfiguration((_, cfg) =>
{
cfg.AddJsonFile(configPath);
cfg.AddUserSecrets(typeof(Scenario_01).Assembly);
});
builder.ConfigureTestServices(services =>
{
// This reconfigures identity server to accept the ResourceOwnerPassword
// grant which enables the integration tests to acquire access tokens
// directly using the username and password
services.AddSingleton <IUserClientsProvider, IntegrationTestsClientsProvider>();
});
//// This initializes the test database
//builder.ConfigureServices(services =>
//{
// var sp = services.BuildServiceProvider();
// // This won't run automatically when using WebApplicationFactory
// Program.InitDatabase(sp).Wait();
// // Databases seeding and preparation
// string connString;
// string adminEmail;
// IShardResolver shardResolver;
// using (var scope = sp.CreateScope())
// {
// var config = scope.ServiceProvider.GetRequiredService<IConfiguration>();
// connString = config.GetConnectionString(Constants.AdminConnection);
// adminEmail = config.Get<GlobalOptions>()?.Admin?.Email ?? "*****@*****.**";
// shardResolver = scope.ServiceProvider.GetRequiredService<IShardResolver>();
// // Retrieve the access token specific to the developer
// _token = config.GetValue<string>("AccessToken");
// }
// ArrangeDatabasesForTests(connString, adminEmail, shardResolver);
//});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(s =>
{
s.AddTransient <IUnitOfWorkManager, FakeUnitOfWorkManager>();
s.AddTransient <IConnectionFactory, TestsDbConnectionFactory>();
});
builder.ConfigureAppConfiguration(a =>
{
a.Sources.Clear();
a.AddInMemoryCollection(_config);
});
builder.UseEnvironment("LOCAL");
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
// https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-2.2
// Add database name for testing
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddInMemoryCollection(arrayDict);
})
.ConfigureServices(services =>
{
services.AddScoped <BookService>();
});
SeedData.InitData();
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration(config =>
{
ModifyConfiguration(config);
var integrationConfig = new ConfigurationBuilder().AddJsonFile("appsettings.integrationtest.json").Build();
config.AddConfiguration(integrationConfig);
});
builder.ConfigureTestServices(services =>
{
ModifyServices(services);
services.AddSingleton <RestApiOptions, RestApiOptions>();
services.AutoRegistrateServices(Assembly.GetAssembly(typeof(ApiRegistration)) !, Assembly.GetAssembly(typeof(WebApiStartupFactory)) !);
});
}
/// <summary>
/// 配置应用启动
/// </summary>
/// <param name="builder"></param>
public void Configure(IWebHostBuilder builder)
{
// 自动注入 AddApp() 服务
builder.ConfigureServices(services =>
{
services.AddTransient <IStartupFilter, StartupFilter>();
services.AddApp();
});
// 自动装载配置
builder.ConfigureAppConfiguration(configurationBuilder =>
{
AutoAddJsonFile(configurationBuilder);
});
}
/// <summary>
/// 配置应用启动
/// </summary>
/// <param name="builder"></param>
public void Configure(IWebHostBuilder builder)
{
//可以添加配置
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
// 自动装载配置
App.AddConfigureFiles(config, hostingContext.HostingEnvironment);
});
//可以添加ConfigureServices
// 自动注入 AddApp() 服务
builder.ConfigureServices(services =>
{
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
#if Debug
builder.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.SetMinimumLevel(LogLevel.Trace).AddDebug().AddConsole();
});
#else
builder.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.SetMinimumLevel(LogLevel.Error).AddDebug().AddConsole();
});
#endif
builder.ConfigureAppConfiguration(SetupConfig);
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile("appsettings.IntegrationTests.json",
optional: true,
reloadOnChange: false);
});
builder.ConfigureTestServices(ConfigureServices);
builder.ConfigureLogging((WebHostBuilderContext context, ILoggingBuilder loggingBuilder) =>
{
loggingBuilder.ClearProviders();
loggingBuilder.AddConsole(options => options.IncludeScopes = true);
});
}
public static IWebHostBuilder UseAzureKeyVaultConfiguration(this IWebHostBuilder webHostBuilder)
{
return(webHostBuilder.ConfigureAppConfiguration(builder =>
{
var config = builder.Build();
string keyVaultUrl = $"https://{config["KeyVault"]}.vault.azure.net/";
if (!string.IsNullOrEmpty(keyVaultUrl))
{
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var kvClient = new KeyVaultClient(
(authority, resource, scope) => azureServiceTokenProvider.KeyVaultTokenCallback(authority, resource, scope));
builder.AddAzureKeyVault(keyVaultUrl, kvClient, new DefaultKeyVaultSecretManager());
}
}));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration((context, configBuilder) =>
{
configBuilder.AddInMemoryCollection(
new Dictionary <string, string>
{
["ApiKey"] = "DummyKey"
});
});
builder.ConfigureServices(services =>
{
services.AddSingleton(provider => _blobContainerClient);
});
}
protected override void Init(IWebHostBuilder builder)
{
builder
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddEnvironmentVariables("URA_KATA_");
})
.ConfigureLogging((context, loggingBuilder) =>
{
loggingBuilder.ClearProviders();
loggingBuilder.AddLambdaLogger(context.Configuration, "Logging");
loggingBuilder.SetMinimumLevel(LogLevel.Trace);
})
.UseStartup <Startup>();
}
public static IWebHostBuilder AddGatewayConfigurationFiles(this IWebHostBuilder webHostBuilder)
{
return(webHostBuilder.ConfigureAppConfiguration((hostingContext, config) =>
{
config
.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile(
$"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json",
optional: true,
reloadOnChange: true)
.AddJsonFile("ocelot-configuration.json")
.AddEnvironmentVariables();
}));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration((context, configBuilder) =>
{
var json = JsonConvert.SerializeObject(ApplicationSettings.New(), new JsonSerializerSettings
{
ContractResolver = new PrivateReadResolver(),
Converters = new List <JsonConverter> {
new StringEnumConverter()
},
});
configBuilder.Sources.Clear();
configBuilder.AddJsonStream(new MemoryStream(Encoding.ASCII.GetBytes(json)));
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration(config =>
{
Configuration = new ConfigurationBuilder().AddJsonFile("integrationsettings.json").Build();
config.AddConfiguration(Configuration);
});
builder.ConfigureTestServices(services =>
{
services.AddScoped <ICarsService, CarsService>();
services.AddScoped <IDriversService, DriversService>();
services.AddScoped <IGrandPrixesService, GrandPrixesService>();
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
var env = GetEnvironmentName();
builder.ConfigureAppConfiguration(config =>
{
var integrationConfig = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.AddJsonFile($"appsettings.{env}.json", optional: true)
.AddEnvironmentVariables()
.Build();
config.AddConfiguration(integrationConfig);
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration(b => b.AddEnvironmentVariables())
.UseStartup <Startup>();
builder.ConfigureServices(services =>
{
services.ConfigureDynamoDB();
var serviceProvider = services.BuildServiceProvider();
DynamoDb = serviceProvider.GetRequiredService <IAmazonDynamoDB>();
DynamoDbContext = serviceProvider.GetRequiredService <IDynamoDBContext>();
EnsureTablesExist(DynamoDb, _tables);
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration(b => b.AddEnvironmentVariables())
.UseStartup <Startup>();
builder.ConfigureServices(services =>
{
services.ConfigureDynamoDB();
services.ConfigureDynamoDbFixture();
var serviceProvider = services.BuildServiceProvider();
DbFixture = serviceProvider.GetRequiredService <IDynamoDbFixture>();
DbFixture.EnsureTablesExist(_tables);
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseContentRoot(".");
builder.ConfigureAppConfiguration(configuration =>
{
configuration.AddInMemoryCollection(new Dictionary <string, string>
{
{ "connectionStrings:featureFlags", databaseFixture.ConnectionString },
{ "connectionStrings:featureFlagsInitialization", databaseFixture.ConnectionString },
});
});
base.ConfigureWebHost(builder);
}
protected override void Init(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration((context, config) =>
{
var env = context.HostingEnvironment;
// NOTE: A default AWS SDK configuration has been added to appsettings.Development.json.
// More Details can be found at: https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-netcore.html
// Add systems manager parameter store paths
config.AddSystemsManager($"/dotnet-aws-samples/systems-manager-sample/common");
config.AddSystemsManager($"/dotnet-aws-samples/systems-manager-sample/{env.EnvironmentName}", optional: true);
})
.UseStartup <Startup>();
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration((_, conf) =>
{
var projectDir = Directory.GetCurrentDirectory();
var configPath = Path.Combine(projectDir, "appsettings.Test.json");
conf.AddJsonFile(configPath);
});
builder.ConfigureServices(services =>
{
Console.WriteLine("\t--Configring services test-location-01");
services.ConfigureInMemoryDB();
});
}
public static IWebHostBuilder ConfigureDefaultAppConfiguration(
this IWebHostBuilder host
, string webHostBuilderBasePath
, string[] args)
{
host
.ConfigureAppConfiguration((hostContext, configApp) =>
{
configApp.SetBasePath(webHostBuilderBasePath);
configApp.AddJsonFile("appsettings.json", optional: true);
configApp.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true);
configApp.AddCommandLine(args);
});
return(host);
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration(config =>
{
var integrationConfig = new ConfigurationBuilder()
.AddJsonFile("IntegrationSettings.json")
.Build();
config.AddConfiguration(integrationConfig);
});
builder.ConfigureTestServices(services =>
{
services.AddAutoMapper(typeof(WebAPI.Startup));
});
}
public static IWebHostBuilder UseAzureKeyVaultConfiguration(this IWebHostBuilder webHostBuilder)
{
return(webHostBuilder.ConfigureAppConfiguration(builder =>
{
IConfigurationRoot config = builder.Build();
string keyVaultUrl = config["Lab:KeyVaultBaseUrl"];
if (!string.IsNullOrEmpty(keyVaultUrl))
{
// Need token provider to use Managed Identity
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var kvClient = new KeyVaultClient((authority, resource, scope) => azureServiceTokenProvider.KeyVaultTokenCallback(authority, resource, scope));
builder.AddAzureKeyVault(keyVaultUrl, kvClient, new DefaultKeyVaultSecretManager());
}
}));
}
public static IWebHostBuilder UseDbSettings(this IWebHostBuilder builder, bool reloadOnChange = true)
{
var dbConfigurationSource = new DbConfigurationSource {
ReloadOnChange = reloadOnChange
};
return(builder
.ConfigureAppConfiguration((_, config) =>
{
config.Add(dbConfigurationSource);
})
.ConfigureServices((_, services) =>
{
services.AddSingleton <INotificationHandler <SettingsChanged> >(dbConfigurationSource);
}));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
var dict = new Dictionary <string, string>
{
["Storage"] = "InMemory"
};
config.AddInMemoryCollection(dict);
});
base.ConfigureWebHost(builder);
}
