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);
}
