private static Db2Generator CreateFixture(QuoterOptions options = null) { var generatorOptions = new OptionsWrapper <GeneratorOptions>(new GeneratorOptions()); var quoterOptions = new OptionsWrapper <QuoterOptions>(options); return(new Db2Generator(new Db2ISeriesQuoter(quoterOptions), generatorOptions)); }
public void SetupTest() { RedisConnectionMock = new Mock <IConnectionMultiplexer>(); LoggerMock = new Mock <ILogger <LobbyService> >(); SubscriberMock = new Mock <ISubscriber>(); DatabaseMock = new Mock <IDatabase>(); LobbyOptions = new OptionsWrapper <GametekiLobbyOptions>(new GametekiLobbyOptions { NodeName = "TestNode" }); TestUsers = new List <LobbyUser>(); RedisConnectionMock.Setup(c => c.GetSubscriber(It.IsAny <object>())).Returns(SubscriberMock.Object); RedisConnectionMock.Setup(c => c.GetDatabase(It.IsAny <int>(), It.IsAny <object>())).Returns(DatabaseMock.Object); Service = new LobbyService(RedisConnectionMock.Object, LobbyOptions, LoggerMock.Object); for (var i = 0; i < 50; i++) { var testUser = TestUtils.GetRandomLobbyUser(); TestUsers.Add(testUser); Service.NewUserAsync(testUser); } SubscriberMock.Reset(); }
private IDeliveryClient GetDeliveryClient(Action mockAction) { mockAction(); var httpClient = mockHttp.ToHttpClient(); var deliveryOptions = new OptionsWrapper <DeliveryOptions>(new DeliveryOptions { ProjectId = guid }); var contentLinkUrlResolver = A.Fake <IContentLinkUrlResolver>(); var contentItemsProcessor = A.Fake <IInlineContentItemsProcessor>(); var contentPropertyMapper = new PropertyMapper(); var contentTypeProvider = new CustomTypeProvider(); var modelProvider = new ModelProvider(contentLinkUrlResolver, contentItemsProcessor, contentTypeProvider, contentPropertyMapper); var retryPolicy = A.Fake <IRetryPolicy>(); var retryPolicyProvider = A.Fake <IRetryPolicyProvider>(); A.CallTo(() => retryPolicyProvider.GetRetryPolicy()).Returns(retryPolicy); A.CallTo(() => retryPolicy.ExecuteAsync(A <Func <Task <HttpResponseMessage> > > ._)) .ReturnsLazily(call => call.GetArgument <Func <Task <HttpResponseMessage> > >(0)()); var client = new DeliveryClient( deliveryOptions, httpClient, contentLinkUrlResolver, null, modelProvider, retryPolicyProvider, contentTypeProvider ); return(client); }
private IDeliveryClient GetDeliveryClient(Action mockAction) { mockAction(); var httpClient = mockHttp.ToHttpClient(); var deliveryOptions = new OptionsWrapper <DeliveryOptions>(new DeliveryOptions { ProjectId = guid }); var contentLinkUrlResolver = A.Fake <IContentLinkUrlResolver>(); var contentItemsProcessor = A.Fake <IInlineContentItemsProcessor>(); var contentPropertyMapper = new PropertyMapper(); var contentTypeProvider = new CustomTypeProvider(); var modelProvider = new ModelProvider(contentLinkUrlResolver, contentItemsProcessor, contentTypeProvider, contentPropertyMapper); var resiliencePolicyProvider = A.Fake <IResiliencePolicyProvider>(); A.CallTo(() => resiliencePolicyProvider.Policy) .Returns(Policy.HandleResult <HttpResponseMessage>(result => true).RetryAsync(deliveryOptions.Value.MaxRetryAttempts)); var client = new DeliveryClient( deliveryOptions, httpClient, contentLinkUrlResolver, null, modelProvider, resiliencePolicyProvider, contentTypeProvider ); return(client); }
public JsonPocoConverterTests() { var options = new JsonSerializerOptions(); var wrapper = new OptionsWrapper <JsonSerializerOptions>(options); _jsonPocoConverter = new JsonPocoConverter(wrapper); }
public async Task Invoke_hstsEnabled_AddsResponseHeaderWithCorrectValue() { bool nextInvoked = false; RequestDelegate next = (ctxt) => { nextInvoked = true; ctxt.Response.StatusCode = (int)HttpStatusCode.Accepted; return(Task.CompletedTask); }; var options = new HostHstsOptions() { IsEnabled = true, MaxAge = new TimeSpan(10, 0, 0, 0) }; var hstsOptions = new OptionsWrapper <HostHstsOptions>(options); var middleware = new HstsConfigurationMiddleware(hstsOptions); var httpContext = new DefaultHttpContext(); httpContext.Request.IsHttps = true; await middleware.Invoke(httpContext, next); Assert.True(nextInvoked); Assert.Equal(httpContext.Response.Headers["Strict-Transport-Security"].ToString(), "max-age=864000"); }
/// <summary> /// Registers a <see cref="HttpRestClient" /> with a named configuration. /// </summary> /// <param name="services">An instance of <see cref="IServiceCollection" /> to attach the configuration to.</param> /// <param name="configurationName">The name of the configuration to be used for the <see cref="IHttpClientFactory" />.</param> /// <param name="httpClientBuilderCustomization">A delegate to customize an instance of <see cref="IHttpClientBuilder"/>.</param> /// <returns>The same instance passed as <paramref name="services"/>.</returns> public static IServiceCollection AddHttpRestClient(this IServiceCollection services, string configurationName, Action <IHttpClientBuilder> httpClientBuilderCustomization) { services.AddLogging(); services.AddOptions(); services.Configure <HttpRestClientOptions>(configurationName, options => options.HttpClientName = configurationName); var httpClientBuilder = services.AddHttpClient(configurationName); httpClientBuilderCustomization?.Invoke(httpClientBuilder); services.AddTransient <IHttpRestClient>(sp => { var snapshot = sp.GetRequiredService <IOptionsSnapshot <HttpRestClientOptions> >(); var options = snapshot.Get(configurationName); var logger = sp.GetRequiredService <ILogger <HttpRestClient> >(); var httpClientFactory = sp.GetRequiredService <IHttpClientFactory>(); var wrapper = new OptionsWrapper <HttpRestClientOptions>(options); var service = new HttpRestClient(httpClientFactory, wrapper, logger); return(service); }); return(services); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) { app.UseStaticFiles(); // For any requests coming in from '/dist/**/*' or '__webpack_hmr', we wan't to proxy those requests // to our webpack dev server that is running. // Make sure you have 'gulp dev-server' running before starting the .NET web stuff. // NOTE: You may want to configure this to only run on a dev environment, and not production. var proxyOptions = new OptionsWrapper <ProxyOptions>(new ProxyOptions { Host = "localhost", Port = "5001" }); app.Use(async(context, next) => { if (!context.Request.Path.StartsWithSegments("/dist") && !context.Request.Path.StartsWithSegments("/__webpack_hmr")) { await next(); return; } var proxyMiddleware = new ProxyMiddleware(httpContext => next.Invoke(), proxyOptions); await proxyMiddleware.Invoke(context); }); app.UseJsEngine(); // this needs to be before MVC app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); }
public async Task Invoke_hstsDisabled_DoesNotAddResponseHeader() { var hstsOptions = new OptionsWrapper <HostHstsOptions>(new HostHstsOptions() { IsEnabled = false }); bool nextInvoked = false; RequestDelegate next = (ctxt) => { nextInvoked = true; ctxt.Response.StatusCode = (int)HttpStatusCode.Accepted; return(Task.CompletedTask); }; var middleware = new HstsConfigurationMiddleware(hstsOptions); var httpContext = new DefaultHttpContext(); httpContext.Request.IsHttps = true; await middleware.Invoke(httpContext, next); Assert.True(nextInvoked); Assert.Equal(httpContext.Response.Headers.Count, 0); }
public void Opens_Connection() { var options = new OptionsWrapper <RabbitMQOptions>(new RabbitMQOptions { HostName = Constants.LocalHost }); var loggerFactory = new LoggerFactory(); var mockServiceFactory = new Mock <IRabbitMQServiceFactory>(); var mockNameResolver = new Mock <INameResolver>(); var config = new RabbitMQExtensionConfigProvider(options, mockNameResolver.Object, mockServiceFactory.Object, loggerFactory, _emptyConfig); var mockService = new Mock <IRabbitMQService>(); mockServiceFactory.Setup(m => m.CreateService(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>())).Returns(mockService.Object); RabbitMQAttribute attr = new RabbitMQAttribute { ConnectionStringSetting = string.Empty, HostName = Constants.LocalHost, UserName = "******", Password = "******", Port = 5672 }; RabbitMQClientBuilder clientBuilder = new RabbitMQClientBuilder(config, options); var model = clientBuilder.Convert(attr); mockServiceFactory.Verify(m => m.CreateService(It.IsAny <string>(), Constants.LocalHost, "guest", "guest", 5672), Times.Exactly(1)); }
/// <summary> /// Creates a Bot client that connects itself to the api gateway /// </summary> /// <returns></returns> private async Task <GatewayClient> CreateExternalClient() { var config = GetConfig(); var info = new GatewayInformation(config); var clientInfo = new ClientInformation() { Credentials = new ClientCredentials() { ClientId = info.ExternalClientInfo.ClientId, ClientSecret = info.ExternalClientInfo.ClientSecret }, TargetApiName = info.GatewayApiName, TargetBaseUrl = info.GatewayApiBaseUrl, AuthServerLocation = info.AuthServerUrl }; var clientInfoOptions = new OptionsWrapper <ClientInformation>(clientInfo); var client = new GatewayClient(clientInfoOptions, new MockLoggerFactory <object>()); var tokenResponse = await GetAccessTokenFromAuthServer(clientInfo); client.SetBearerToken(tokenResponse.AccessToken); return(client); }
public async Task Invoke_CallsFunction() { var testFunctions = new Collection <FunctionDescriptor>(); string testFunctionName = "TestFunction"; string triggerParameterName = "testTrigger"; string testInput = Guid.NewGuid().ToString(); bool functionInvoked = false; var scriptHostMock = new Mock <IScriptJobHost>(); scriptHostMock.Setup(p => p.CallAsync(It.IsAny <string>(), It.IsAny <IDictionary <string, object> >(), CancellationToken.None)) .Callback <string, IDictionary <string, object>, CancellationToken>((name, args, token) => { // verify the correct arguments were passed to the invoke Assert.Equal(testFunctionName, name); Assert.Equal(1, args.Count); Assert.Equal(testInput, (string)args[triggerParameterName]); functionInvoked = true; }) .Returns(Task.CompletedTask); scriptHostMock.Setup(p => p.Functions).Returns(testFunctions); // Add a few parameters, with the trigger parameter last // to verify parameter order handling Collection <ParameterDescriptor> parameters = new Collection <ParameterDescriptor> { new ParameterDescriptor("context", typeof(ExecutionContext)), new ParameterDescriptor("log", typeof(TraceWriter)), new ParameterDescriptor(triggerParameterName, typeof(string)) { IsTrigger = true } }; testFunctions.Add(new FunctionDescriptor(testFunctionName, null, null, parameters, null, null, null)); FunctionInvocation invocation = new FunctionInvocation { Input = testInput }; var scriptPath = Path.GetTempPath(); var applicationHostOptions = new ScriptApplicationHostOptions(); applicationHostOptions.ScriptPath = scriptPath; var optionsWrapper = new OptionsWrapper <ScriptApplicationHostOptions>(applicationHostOptions); var functionsManagerMock = new Mock <IWebFunctionsManager>(); var mockRouter = new Mock <IWebJobsRouter>(); var testController = new FunctionsController(functionsManagerMock.Object, mockRouter.Object, new LoggerFactory(), optionsWrapper); IActionResult response = testController.Invoke(testFunctionName, invocation, scriptHostMock.Object); Assert.IsType <AcceptedResult>(response); // The call is fire-and-forget, so watch for functionInvoked to be set. await TestHelpers.Await(() => functionInvoked, timeout : 3000, pollingInterval : 100); Assert.True(functionInvoked); }
private static FunctionsController SetUpFunctionsController(string testFunctionName, bool isFileSystemReadOnly, bool functionCreatedSuccess = true) { var scriptPath = Path.GetTempPath(); var applicationHostOptions = new ScriptApplicationHostOptions { ScriptPath = scriptPath, IsFileSystemReadOnly = isFileSystemReadOnly }; var functionsMetadataMock = new Mock <FunctionMetadataResponse>(); var functionsManagerMock = new Mock <IWebFunctionsManager>(); functionsManagerMock.Setup(p => p.CreateOrUpdate(It.IsAny <string>(), It.IsAny <FunctionMetadataResponse>(), It.IsAny <HttpRequest>())) .Callback <string, FunctionMetadataResponse, HttpRequest>((name, functionMetadata, request) => { // verify the correct arguments were passed to the method Assert.Equal(testFunctionName, name); Assert.Equal(request.Method, "Put"); }) .Returns(Task.FromResult((functionCreatedSuccess, true, functionsMetadataMock.Object))); var mockRouter = new Mock <IWebJobsRouter>(); var optionsWrapper = new OptionsWrapper <ScriptApplicationHostOptions>(applicationHostOptions); var testController = new FunctionsController(functionsManagerMock.Object, mockRouter.Object, new LoggerFactory(), optionsWrapper); var httpContext = new DefaultHttpContext(); httpContext.Request.Host = new HostString("local"); httpContext.Request.Method = "Put"; httpContext.Request.Path = $"/admin/functions/{testFunctionName}"; testController.ControllerContext.HttpContext = httpContext; return(testController); }
public HostControllerTests() { _scriptPath = Path.GetTempPath(); var applicationHostOptions = new ScriptApplicationHostOptions(); applicationHostOptions.ScriptPath = _scriptPath; var optionsWrapper = new OptionsWrapper <ScriptApplicationHostOptions>(applicationHostOptions); var loggerProvider = new TestLoggerProvider(); var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(loggerProvider); _mockEnvironment = new Mock <IEnvironment>(MockBehavior.Strict); _mockEnvironment.Setup(p => p.GetEnvironmentVariable(It.IsAny <string>())).Returns <string>(null); _mockScriptHostManager = new Mock <IScriptHostManager>(MockBehavior.Strict); _mockScriptHostManager.SetupGet(p => p.State).Returns(ScriptHostState.Running); _functionsSyncManager = new Mock <IFunctionsSyncManager>(MockBehavior.Strict); _extensionBundleManager = new Mock <IExtensionBundleManager>(MockBehavior.Strict); var mockServiceProvider = new Mock <IServiceProvider>(MockBehavior.Strict); _hostHealthMonitorOptions = new HostHealthMonitorOptions(); var wrappedHealthMonitorOptions = new OptionsWrapper <HostHealthMonitorOptions>(_hostHealthMonitorOptions); _mockHostPerformanceManager = new Mock <HostPerformanceManager>(_mockEnvironment.Object, wrappedHealthMonitorOptions, mockServiceProvider.Object, null); _hostController = new HostController(optionsWrapper, loggerFactory, _mockEnvironment.Object, _mockScriptHostManager.Object, _functionsSyncManager.Object, _mockHostPerformanceManager.Object); _appOfflineFilePath = Path.Combine(_scriptPath, ScriptConstants.AppOfflineFileName); if (File.Exists(_appOfflineFilePath)) { File.Delete(_appOfflineFilePath); } }
public void OnSettingsUI(UIHelperBase helper) { var flags = Flags.CollectFlags(true); var defaultIndex = 0; if (OptionsWrapper <Options> .Options.replacement != string.Empty) { for (var i = 0; i < flags.Count; i++) { var flag = flags[i]; if (!flag.id.Equals(OptionsWrapper <Options> .Options.replacement)) { continue; } defaultIndex = i + 1; break; } if (defaultIndex == 0) { OptionsWrapper <Options> .Options.replacement = string.Empty; OptionsWrapper <Options> .SaveOptions(); } } helper.AddDropdown("Replace stock Flags with", new[] { "-----" }.Concat(flags.Select(flag => flag.description)).ToArray(), defaultIndex, sel => { OptionsWrapper <Options> .Options.replacement = sel == 0 ? string.Empty : flags[sel - 1].id; OptionsWrapper <Options> .SaveOptions(); }); helper.AddOptionsGroup <Options>(); }
public HostControllerTests() { _scriptPath = Path.GetTempPath(); var applicationHostOptions = new ScriptApplicationHostOptions(); applicationHostOptions.ScriptPath = _scriptPath; var optionsWrapper = new OptionsWrapper <ScriptApplicationHostOptions>(applicationHostOptions); var hostOptions = new OptionsWrapper <JobHostOptions>(new JobHostOptions()); var loggerProvider = new TestLoggerProvider(); var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(loggerProvider); var mockAuthorizationService = new Mock <IAuthorizationService>(MockBehavior.Strict); var mockWebFunctionsManager = new Mock <IWebFunctionsManager>(MockBehavior.Strict); _mockEnvironment = new Mock <IEnvironment>(MockBehavior.Strict); _mockEnvironment.Setup(p => p.GetEnvironmentVariable(It.IsAny <string>())).Returns <string>(null); _mockScriptHostManager = new Mock <IScriptHostManager>(MockBehavior.Strict); _hostController = new HostController(optionsWrapper, hostOptions, loggerFactory, mockAuthorizationService.Object, mockWebFunctionsManager.Object, _mockEnvironment.Object, _mockScriptHostManager.Object); _appOfflineFilePath = Path.Combine(_scriptPath, ScriptConstants.AppOfflineFileName); if (File.Exists(_appOfflineFilePath)) { File.Delete(_appOfflineFilePath); } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) { app.UseStaticFiles(); // For any requests coming in from '/dist/**/*' or '__webpack_hmr', we wan't to proxy those requests // to our webpack dev server that is running. // Make sure you have 'gulp dev' running before starting the .NET web stuff. // NOTE: You may want to configure this to only run on a dev environment, and not production. var proxyOptions = new OptionsWrapper<ProxyOptions>(new ProxyOptions { Host = "localhost", Port = "5001" }); app.Use(async (context, next) => { if(!context.Request.Path.StartsWithSegments("/dist") && !context.Request.Path.StartsWithSegments("/__webpack_hmr")) { await next(); return; } var proxyMiddleware = new ProxyMiddleware(httpContext => next.Invoke(), proxyOptions); await proxyMiddleware.Invoke(context); }); app.UseJsEngine(); // this needs to be before MVC app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); }
public async Task Invoke_hasCustomHeaders_AddsResponseHeaders() { var headers = new CustomHttpHeadersOptions { { "X-Content-Type-Options", "nosniff" }, { "Feature-Policy", "camera 'none'; geolocation 'none'" } }; var headerOptions = new OptionsWrapper <CustomHttpHeadersOptions>(headers); bool nextInvoked = false; RequestDelegate next = (context) => { nextInvoked = true; context.Response.StatusCode = (int)HttpStatusCode.Accepted; return(Task.CompletedTask); }; var middleware = new CustomHttpHeadersMiddleware(headerOptions); var httpContext = new DefaultHttpContext(); await middleware.Invoke(httpContext, next); Assert.True(nextInvoked); Assert.Equal(httpContext.Response.Headers["X-Content-Type-Options"].ToString(), "nosniff"); Assert.Equal(httpContext.Response.Headers["Feature-Policy"].ToString(), "camera 'none'; geolocation 'none'"); }
private static UITextField AddTextfield <T>(this UIHelperBase group, string text, string propertyName, TextfieldAttribute attr) { var property = typeof(T).GetProperty(propertyName); var initialValue = Convert.ToString(property.GetValue(OptionsWrapper <T> .Options, null)); return((UITextField)group.AddTextfield(text, initialValue, s => { }, s => { object value; if (property.PropertyType == typeof(int)) { value = Convert.ToInt32(s); } else if (property.PropertyType == typeof(short)) { value = Convert.ToInt16(s); } else if (property.PropertyType == typeof(double)) { value = Convert.ToDouble(s); } else if (property.PropertyType == typeof(float)) { value = Convert.ToSingle(s); } else { value = s; //TODO: more types } property.SetValue(OptionsWrapper <T> .Options, value, null); OptionsWrapper <T> .SaveOptions(); attr.Action <string>().Invoke(s); })); }
public void ShouldEnable_ReturnsExpectedValue() { IOptions <HttpOptions> optionsWrapper = null; var scriptHostManagerMock = new Mock <IScriptHostManager>(MockBehavior.Strict); var hostServiceProviderMock = scriptHostManagerMock.As <IServiceProvider>(); hostServiceProviderMock.Setup(p => p.GetService(typeof(IOptions <HttpOptions>))).Returns(() => optionsWrapper); var rootServiceProvider = new Mock <IServiceProvider>(MockBehavior.Strict); rootServiceProvider.Setup(p => p.GetService(typeof(IScriptHostManager))).Returns(scriptHostManagerMock.Object); Assert.False(HttpThrottleMiddleware.ShouldEnable(null)); Assert.False(HttpThrottleMiddleware.ShouldEnable(rootServiceProvider.Object)); var httpOptions = new HttpOptions(); optionsWrapper = new OptionsWrapper <HttpOptions>(httpOptions); Assert.False(HttpThrottleMiddleware.ShouldEnable(rootServiceProvider.Object)); httpOptions.MaxConcurrentRequests = 5; Assert.True(HttpThrottleMiddleware.ShouldEnable(rootServiceProvider.Object)); httpOptions.MaxConcurrentRequests = -1; httpOptions.DynamicThrottlesEnabled = true; Assert.True(HttpThrottleMiddleware.ShouldEnable(rootServiceProvider.Object)); }
public async Task Invoke_hasCustomHeaders_AddsResponseHeaders() { var headers = new CustomHttpHeadersOptions { { "X-Content-Type-Options", "nosniff" }, { "Feature-Policy", "camera 'none'; geolocation 'none'" } }; var headerOptions = new OptionsWrapper <CustomHttpHeadersOptions>(headers); using (var host = GetTestHost(o => { o.Add("X-Content-Type-Options", "nosniff"); o.Add("Feature-Policy", "camera 'none'; geolocation 'none'"); })) { await host.StartAsync(); HttpResponseMessage response = await host.GetTestClient().GetAsync(string.Empty); await host.StopAsync(); Assert.True(_nextInvoked); Assert.Equal(response.Headers.GetValues("X-Content-Type-Options").Single(), "nosniff"); Assert.Equal(response.Headers.GetValues("Feature-Policy").Single(), "camera 'none'; geolocation 'none'"); } }
public async Task Get4DomainsFromSampleTwitterFeed() { int expected = 4; var mockOptions = new OptionsWrapper <AppSettings>(new AppSettings { TwitterApiKey = "SOMEKEYVALUE", TwitterSecret = "SOMESECRET", BearerToken = "SOMETOKEN" }); TwitterStatCache cache = new TwitterStatCache(); cache.SampleSize = 1; await cache.AddTweet(model); var mockQueue = new Mock <IBackgroundTaskQueue>(); TwitterStreamService service = new TwitterStreamService(mockOptions, cache, mockQueue.Object); var controller = new TwitterStatsController(mockOptions, service, cache); var actionResult = controller.GetDomainListFromCollection(); var resultObject = Helper.GetObjectResultContent <List <Entity> >(actionResult.Result); Assert.Equal(expected, resultObject.Count); }
public async Task Minimal_Defaults_enGB() { Skip.IfNot(OperatingSystem.IsWindows(), "Windows Only"); // arrange var resolver = new Mock <ISupportedCulturesResolver>(); var options = new OptionsWrapper <RequestLocalizationOptions>(new RequestLocalizationOptions()); var mw = new DynamicLocalizationMiddleware(innerHttpContext => { innerHttpContext.Response.WriteAsync(CultureInfo.CurrentCulture.ToString()); return(Task.CompletedTask); }, options); var services = new ServiceCollection(); services.AddSingleton(resolver.Object); var context = new DefaultHttpContext(); context.Response.Body = new MemoryStream(); context.RequestServices = services.BuildServiceProvider(); // act await mw.InvokeAsync(context); // assert context.Response.Body.Seek(0, SeekOrigin.Begin); var body = await new StreamReader(context.Response.Body).ReadToEndAsync(); body.ShouldBe("en-GB"); }
public async Task Invoke_HasCorsConfig_InvokesNext() { var testOrigin = "https://functions.azure.com"; var hostCorsOptions = new OptionsWrapper <HostCorsOptions>(new HostCorsOptions { AllowedOrigins = new List <string> { testOrigin } }); var testPolicy = new CorsPolicy(); var testOptions = new CorsOptions(); testOptions.AddDefaultPolicy(testPolicy); var corsOptions = new OptionsWrapper <CorsOptions>(testOptions); var corsFactory = new CorsMiddlewareFactory(corsOptions, NullLoggerFactory.Instance); bool nextInvoked = false; RequestDelegate next = (context) => { nextInvoked = true; context.Response.StatusCode = (int)HttpStatusCode.Accepted; return(Task.CompletedTask); }; var middleware = new JobHostCorsMiddleware(hostCorsOptions, corsFactory); var httpContext = new DefaultHttpContext(); await middleware.Invoke(httpContext, next); Assert.True(nextInvoked); }
protected OptionsWrapper <MkSmtpMailerSettings> SetupMailerOptions(out bool isMailServerAlive) { var mailOptions = new OptionsWrapper <MkSmtpMailerSettings>( new MkSmtpMailerSettings { FromDisplayName = "xunit", FromEmailAddress = "*****@*****.**", ReplyToEmailAddress = "*****@*****.**", ReplyToDisplayName = "Xunit - NoReply", SmtpServer = "localhost", SmtpPort = 25, SmtpRequireSsl = false, TemplateSettings = new MkFileTemplateSettings { TemplatePath = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, @"..\..\..\..\TestData\templates")) } }); isMailServerAlive = false; var tcp = new TcpClient(); try { tcp.ConnectAsync(mailOptions.Value.SmtpServer, mailOptions.Value.SmtpPort).Wait(); isMailServerAlive = tcp.Connected; } catch { // ignored } tcp.Dispose(); return(mailOptions); }
public void ConsumptionDefaulstDoNotOverrideCustomerOptions() { var connectionStringResolver = new TestConnectionStringResolver(); var options = new DurableTaskOptions(); options.StorageProvider.Add("ControlQueueBufferThreshold", 999); options.MaxConcurrentOrchestratorFunctions = 888; options.MaxConcurrentActivityFunctions = 777; var mockOptions = new OptionsWrapper <DurableTaskOptions>(options); var nameResolver = new Mock <INameResolver>().Object; var factory = new AzureStorageDurabilityProviderFactory( mockOptions, connectionStringResolver, nameResolver, NullLoggerFactory.Instance, TestHelpers.GetMockPlatformInformationService(inConsumption: true)); var settings = factory.GetAzureStorageOrchestrationServiceSettings(); // We want to make sure that the consumption defaults (listed below) // aren't applied on non-consumption plans. Assert.Equal(999, settings.ControlQueueBufferThreshold); Assert.Equal(888, settings.MaxConcurrentTaskOrchestrationWorkItems); Assert.Equal(777, settings.MaxConcurrentTaskActivityWorkItems); }
public static IServiceCollection WithOptions <T>(this IServiceCollection services, T options) where T : class, new() { IOptions <T> o = new OptionsWrapper <T>(options); services.AddTransient(p => o); return(services); }
public async Task X() { // setup var builder = new DbContextOptionsBuilder <ShipbotDbContext>() .UseInMemoryDatabase("SlackMessageTest"); var options = builder.Options; var context = new ShipbotDbContext( options, new[] { new SlackIntegrationDbContextConfigurator() } ); var repo = new EntityRepository <SlackMessage>(context, new UnitOfWork(_loggerFactory.CreateLogger <UnitOfWork>(), context)); var log = _loggerFactory.CreateLogger <SlackClient>(); var slackConfiguration = new OptionsWrapper <SlackConfiguration>(new SlackConfiguration() { Token = "xoxb-720397510838-721891676752-0ZZsUFHop90k4lOGdHkmn1qx", Timeout = 0 }); var client = new SlackClient( log, repo, new SlackClientWrapper(slackConfiguration), new SlackApiClientWrapper(slackConfiguration) ); // run var handle = await client.PostMessageAsync("slack-bots-and-more", new SlackMessageBuilder("hello world").Build()); await client.UpdateMessageAsync(handle, new SlackMessageBuilder("goodbye!").Build()); // verify }
protected override IMigrationProcessor CreateProcessor() { var mockedDbFactory = new Mock <SQLiteDbFactory>(); mockedDbFactory.SetupGet(conn => conn.Factory).Returns(MockedDbProviderFactory.Object); var mockedConnStringReader = new Mock <IConnectionStringReader>(); mockedConnStringReader.SetupGet(r => r.Priority).Returns(0); mockedConnStringReader.Setup(r => r.GetConnectionString(It.IsAny <string>())).Returns("server=this"); var serviceProvider = new ServiceCollection() .AddLogging() .AddSingleton <ILoggerProvider, TestLoggerProvider>() .AddTransient <SQLiteBatchParser>() .BuildServiceProvider(); var logger = serviceProvider.GetRequiredService <ILogger <SQLiteProcessor> >(); var opt = new OptionsWrapper <ProcessorOptions>(new ProcessorOptions()); return(new SQLiteProcessor( mockedDbFactory.Object, new SQLiteGenerator(), logger, opt, MockedConnectionStringAccessor.Object, serviceProvider)); }
public async Task VerifyReceiptAsync_Fallbacks_To_Test_Environment_Only_When_Explicitly_Set(bool isTestEnvEnabled, bool expectedReceiptValidity) { var httpHandlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict); httpHandlerMock.Protected() .SetupSequence <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .ReturnsAsync(new HttpResponseMessage() { Content = new StringContent(GetVerifiedReceiptJson("Invalid_Receipt_Is_From_Test_Environment")) }) .ReturnsAsync(new HttpResponseMessage() { Content = new StringContent(GetVerifiedReceiptJson("Valid_Production_Excluding_Old_Subscriptions")) }); var httpClient = new HttpClient(httpHandlerMock.Object); var options = new OptionsWrapper <AppleReceiptVerifierOptions>(new AppleReceiptVerifierOptions() { AppSecret = "test_app_password", AcceptTestEnvironmentReceipts = isTestEnvEnabled }); var verifier = new AppleReceiptVerifier(options, httpClient); var receipt = await verifier.VerifyReceiptAsync("test_receipt_data", true); Assert.Equal(expectedReceiptValidity, receipt.IsValid); httpHandlerMock.Protected() .Verify <Task <HttpResponseMessage> >("SendAsync", Times.Exactly(isTestEnvEnabled ? 2 : 1), ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()); }
public async Task InitializeAsync() { Environment.SetEnvironmentVariable(LanguageWorkerConstants.FunctionWorkerRuntimeSettingName, _functionsWorkerRuntime); _copiedRootPath = Path.Combine(Path.GetTempPath(), "FunctionsE2E", DateTime.UtcNow.ToString("yyMMdd-HHmmss")); FileUtility.CopyDirectory(_rootPath, _copiedRootPath); var extensionsToInstall = GetExtensionsToInstall(); if (extensionsToInstall != null && extensionsToInstall.Length > 0) { TestFunctionHost.WriteNugetPackageSources(_copiedRootPath, "http://www.myget.org/F/azure-appservice/api/v2", "https://www.myget.org/F/azure-appservice-staging/api/v2", "https://api.nuget.org/v3/index.json"); var options = new OptionsWrapper <ScriptJobHostOptions>(new ScriptJobHostOptions { RootScriptPath = _copiedRootPath }); var manager = new ExtensionsManager(options, NullLogger <ExtensionsManager> .Instance); await manager.AddExtensions(extensionsToInstall); } string logPath = Path.Combine(Path.GetTempPath(), @"Functions"); Host = new TestFunctionHost(_copiedRootPath, logPath, ConfigureJobHost); string connectionString = Host.JobHostServices.GetService <IConfiguration>().GetWebJobsConnectionString(ConnectionStringNames.Storage); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); QueueClient = storageAccount.CreateCloudQueueClient(); BlobClient = storageAccount.CreateCloudBlobClient(); TableClient = storageAccount.CreateCloudTableClient(); await CreateTestStorageEntities(); }
static void Main() { OptionsWrapper op = new OptionsWrapper(); op.AnimationTid = 1; op.VendeTid = 1; op.VentTid = 4; GlobalValues.optionsWrapper = op; (new Indstillinger()).ShowDialog(); /* * using (var game = new Vendespillet()) game.Run();*/ }
public void Contact() { // Arrange var config = new ConfigurationRoot(new List<IConfigurationProvider> {new MemoryConfigurationProvider(new MemoryConfigurationSource())}); config["kEY1"] = "keyValue1"; config["key2"] = "keyValue2"; config["USERNAME"] = "******"; var otherSettings = new OtherSettings { Numbers = new int[] { 234, 567 } }; var options = new OptionsWrapper<OtherSettings>(otherSettings); var loggerFactory = new LoggerFactory(); var logger = loggerFactory.CreateLogger<HomeController>(); IMemoryCache cache = new MemoryCache(new MemoryCacheOptions()); HomeController controller = new HomeController(config, options, logger, cache); // Act ViewResult result = controller.Contact() as ViewResult; // Assert Assert.Equal("keyValue1 SNeagu 234, 567", result.ViewBag.Message); }
public void OptionsWrapper_MakesOptions() { var options = new OptionsWrapper<FakeOptions>(new FakeOptions { Message = "This is a message" }); Assert.Equal("This is a message", options.Value.Message); }