public async Task SuppressWWWAuthenticateHeader_verify_true() { var realm = TestServerBuilder.Realm; using var server = TestServerBuilder.BuildInHeaderOrQueryParamsServerWithProvider(options => { options.KeyName = FakeApiKeys.KeyName; options.Realm = realm; options.SuppressWWWAuthenticateHeader = true; }); using var client = server.CreateClient(); using var response = await client.GetAsync(TestServerBuilder.BaseUrl); Assert.False(response.IsSuccessStatusCode); Assert.Empty(response.Headers.WwwAuthenticate); }
public void Parse_FromInterface_CreateGraphType_PropertyCheck() { var server = new TestServerBuilder().Build(); var template = TemplateHelper.CreateInterfaceTemplate <ISimpleInterface>(); var typeMaker = new DefaultGraphTypeMakerProvider(); var graphType = typeMaker.CreateTypeMaker(server.Schema, TypeKind.INTERFACE) .CreateGraphType(typeof(ISimpleInterface)).GraphType as IInterfaceGraphType; Assert.IsNotNull(graphType); Assert.AreEqual(template.Name, graphType.Name); Assert.AreEqual(TypeKind.INTERFACE, graphType.Kind); // Property1, Property2, __typename Assert.AreEqual(3, graphType.Fields.Count()); }
public void ApiKeyProviderType_verify_not_null() { using var server = TestServerBuilder.BuildInHeaderOrQueryParamsServerWithProvider(); var services = server.Host.Services; var apiKeyOptionsSnapshot = services.GetService <IOptionsSnapshot <ApiKeyOptions> >(); var apiKeyOptions = apiKeyOptionsSnapshot.Get(ApiKeyDefaults.AuthenticationScheme); Assert.NotNull(apiKeyOptions); Assert.NotNull(apiKeyOptions.ApiKeyProviderType); Assert.Equal(typeof(FakeApiKeyProvider), apiKeyOptions.ApiKeyProviderType); var apiKeyProvider = services.GetService <IApiKeyProvider>(); Assert.NotNull(apiKeyProvider); Assert.Equal(typeof(FakeApiKeyProvider), apiKeyProvider.GetType()); }
public async Task Delete_sensor_and_response_bad_request_status_code() { //Arrange using var server = new TestServerBuilder() .UseCustomAuth(AdminAreaDefaults.DefaultUser, AuthSettings.Roles.Supervisor) .Build(); var client = server.CreateClient(); //Act var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Delete, "api/admin/sensors") { Content = new StringContent(string.Empty, Encoding.UTF8, "application/json") }); //Assert Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); }
public async Task ListOfEnums_WithAnUnlabeledValue_Fails() { var server = new TestServerBuilder() .AddGraphType <ListController>() .Build(); // controller returns a list of {Value1, -3} var builder = server.CreateQueryContextBuilder() .AddQueryText("query { createEnumListWithInValidValue }"); // ensure hte -3 wasnt accepted as valid for the enum being // returned var result = await server.ExecuteQuery(builder); Assert.IsFalse(result.Messages.IsSucessful); Assert.AreEqual(1, result.Messages.Count); }
public async Task WhenNoLeafValuesAreRequested_ItemIsReturnedAsNullAndPropegated() { var server = new TestServerBuilder() .AddGraphType <SimpleExecutionController>() .Build(); var builder = server.CreateQueryContextBuilder(); builder.AddQueryText("query Operation1{ simple { simpleQueryMethod } }"); builder.AddOperationName("Operation1"); var result = await server.RenderResult(builder); CommonAssertions.AreEqualJsonStrings( "{ \"data\" : null }", result); }
public void FieldResolutionStartedLogEntry() { var server = new TestServerBuilder() .AddGraphType <LogTestController>() .Build(); var package = server.CreateFieldContextBuilder <LogTestController>(nameof(LogTestController.ExecuteField2)); var resolutionContext = package.CreateResolutionContext(); var entry = new FieldResolutionStartedLogEntry(resolutionContext); Assert.AreEqual(LogEventIds.FieldResolutionStarted.Id, entry.EventId); Assert.AreEqual(resolutionContext.Request.Id, entry.PipelineRequestId); Assert.AreEqual(resolutionContext.Request.Field.Mode.ToString(), entry.FieldExecutionMode); Assert.AreEqual(resolutionContext.Request.Field.Route.Path, entry.FieldPath); Assert.IsNotNull(entry.ToString()); }
CreateConnection() { var server = new TestServerBuilder() .AddGraphController <ApolloSubscriptionController>() .AddSubscriptionServer((options) => { options.KeepAliveInterval = TimeSpan.FromMinutes(15); }) .Build(); var socketClient = server.CreateClient(); var subServer = server.ServiceProvider.GetService <ISubscriptionServer <GraphSchema> >(); var apolloClient = await subServer.RegisterNewClient(socketClient); return(socketClient, apolloClient as ApolloClientProxy <GraphSchema>); }
public void create_valid_request_using_route_when_parameters_are_not_primitives_with_null_properties() { var server = new TestServerBuilder() .UseDefaultStartup() .Build(); var complexParameter = new Pagination() { PageIndex = 1 }; var requestGet = server.CreateHttpApiRequest <ValuesV3Controller>( controller => controller.Get4(complexParameter)); requestGet.GetConfiguredAddress() .Should().Be("api/values/get4/1"); }
public async Task Delete_sensor_and_response_forbidden_status_code() { //Arrange using var server = new TestServerBuilder() .UseDefaultAuth() .Build(); var client = server.CreateClient(); //Act var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Delete, "api/admin/sensors") { Content = new StringContent(string.Empty, Encoding.UTF8, "application/json") }); //Assert Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); }
public async Task MethodInvocation_UnawaitableAsyncMethodFlag_ResultsInInternalError() { var tester = new TestServerBuilder().Build(); var fieldContextBuilder = tester.CreateFieldContextBuilder <InvokableController>(nameof(InvokableController.SyncronousActionMethod)); fieldContextBuilder.AddInputArgument("arg1", "random string"); fieldContextBuilder.GraphMethod.Setup(x => x.IsAsyncField).Returns(true); var controller = new InvokableController(); var resolutionContext = fieldContextBuilder.CreateResolutionContext(); var result = await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext); // ensure a server error reslt is generated Assert.IsNotNull(result); Assert.IsTrue(result is InternalServerErrorGraphActionResult); }
public async Task ErrorResult() { var server = new TestServerBuilder().Build(); var fieldContextBuilder = server.CreateFieldContextBuilder <InvokableController>(nameof(InvokableController.ErrorResult)); var controller = new InvokableController(); var resolutionContext = fieldContextBuilder.CreateResolutionContext(); var result = await controller.InvokeActionAsync( fieldContextBuilder.GraphMethod.Object, resolutionContext) as GraphFieldErrorActionResult; Assert.IsNotNull(result); Assert.AreEqual("an error happened", result.Message); Assert.AreEqual("12345", result.Code); Assert.IsNotNull(result.Exception); Assert.AreEqual("exception text", result.Exception.Message); }
public async Task MetaDataOnMessage_RendersAsExpected() { var fixedDate = DateTimeOffset.UtcNow.UtcDateTime; var builder = new TestServerBuilder() .AddGraphType <SimpleExecutionController>(); builder.AddGraphQL(o => { o.ResponseOptions.TimeStampLocalizer = (_) => fixedDate; }); var server = builder.Build(); var queryBuilder = server.CreateQueryContextBuilder(); queryBuilder.AddQueryText("query Operation1{ simple { customMessage } }"); var response = await server.ExecuteQuery(queryBuilder); var writer = new DefaultResponseWriter <GraphSchema>(server.Schema); var result = await this.WriteResponse(writer, response); var expectedData = @" { ""errors"": [ { ""message"": ""fail text"", ""extensions"": { ""code"": ""fail code"", ""timestamp"": """ + fixedDate.ToRfc3339String() + @""", ""severity"": ""CRITICAL"", ""metaData"" : { ""customKey1"": ""customValue1"" } } } ] }"; // no errors collection generated because no errors occured. CommonAssertions.AreEqualJsonStrings( expectedData, result); }
public async Task DefaultWriteOperation_InvalidSyntax_RendersJsonWithError() { var fixedDate = DateTimeOffset.UtcNow.UtcDateTime; var serverBuilder = new TestServerBuilder() .AddGraphType <SimpleExecutionController>(); serverBuilder.AddGraphQL(o => { o.ResponseOptions.TimeStampLocalizer = (_) => fixedDate; }); var server = serverBuilder.Build(); var queryBuilder = server.CreateQueryContextBuilder(); queryBuilder.AddQueryText("query Operation1{ simple \n {{ simpleQueryMethod { property1} } }"); var response = await server.ExecuteQuery(queryBuilder); var writer = new DefaultResponseWriter <GraphSchema>(server.Schema); var result = await this.WriteResponse(writer, response); var expectedData = @" { ""errors"": [ { ""message"": ""Invalid query. Expected 'NameToken' but received 'ControlToken'"", ""locations"": [ { ""line"": 2, ""column"": 3 }], ""extensions"": { ""code"": ""SYNTAX_ERROR"", ""timestamp"": """ + fixedDate.ToRfc3339String() + @""", ""severity"": ""CRITICAL"" } }] }"; // no errors collection generated because no errors occured. CommonAssertions.AreEqualJsonStrings( expectedData, result); }
/// <summary> /// Creates test server with identity base startup file. /// </summary> /// <param name="emailServiceMock"></param> /// <param name="configBuild"></param> /// <returns></returns> public static TestServer CreateServer( Mock <IEmailService> emailServiceMock = null, Action <TestConfigurationBuilder> configBuild = null) { TestServer testServer = null; Func <HttpMessageHandler> messageHandlerFactory = () => { return(testServer.CreateHandler()); }; testServer = new TestServerBuilder() .UseEnvironment("Test") .UseContentRoot() .AddStartup((environment) => { var builder = new TestConfigurationBuilder() .UseDefaultConfiguration(); if (configBuild != null) { configBuild.Invoke(builder); } var startup = new IdentityBase.Startup( builder.Build(), environment, new NullLoggerFactory(), messageHandlerFactory ); if (emailServiceMock != null) { startup.OverrideServices = (services => { services.Replace(emailServiceMock.Object); }); } return(startup); }) .Build(); return(testServer); }
public async Task WithAuthorizedUser_AllFieldsResolve() { var serverBuilder = new TestServerBuilder() .AddGraphController <SecuredController>() .AddGraphQL(options => { options.AuthorizationOptions.Method = AuthorizationMethod.PerRequest; }); serverBuilder.User.Authenticate(); // should produce no errors and render both fields var server = serverBuilder.Build(); var builder = server.CreateQueryContextBuilder(); builder.AddQueryText(@" query { unsecured { property1 property2 } secured { property1 property2 } }"); var result = await server.RenderResult(builder); var expectedResults = @" { ""data"": { ""unsecured"": { ""property1"": ""unsecure object"", ""property2"": 1 }, ""secured"": { ""property1"": ""secured object"", ""property2"": 5 } } }"; CommonAssertions.AreEqualJsonStrings(expectedResults, result); }
public async Task Invite_User() { string confirmUrl = null; string cancelUrl = null; // Mock the email service to intercept the outgoing email messages var emailServiceMock = EmailServiceHelper.GetEmailServiceMock( IdentityBaseConstants.EmailTemplates.UserAccountInvited, "invited@localhost", (templateName, emailTo, viewData, isHtml) => { // 3. Get confirm url confirmUrl = viewData.ToDictionary()["ConfirmUrl"] as string; cancelUrl = viewData.ToDictionary()["CancelUrl"] as string; }); // Create a server with custom configuration var config = ConfigBuilder.Default // remove the default service since we mocking it .RemoveDefaultMailService() .Alter("App:EnableInvitationCreateEndpoint", "true") .Build(); var server = TestServerBuilder.BuildServer <Startup>(config, (services) => { services.AddSingleton(emailServiceMock.Object); }); var client = server.CreateClient(); // Act var response = await client.PutJsonAsync("/invitations", new { Email = "invited@localhost", ClientId = "mvc.hybrid" }); response.EnsureSuccessStatusCode(); // Try to follow the confirmation link again it should return an error var response3 = await client.GetAsync(confirmUrl); response3.StatusCode.Should().Be(HttpStatusCode.OK); var doc2 = await response3.Content.ReadAsHtmlDocumentAsync(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static java.net.URI getHttpsUriFromNeo4jRule(java.net.URI configuredHttpsUri) throws Throwable private static URI GetHttpsUriFromNeo4jRule(URI configuredHttpsUri) { ServerControls serverControls = mock(typeof(ServerControls)); when(serverControls.HttpsURI()).thenReturn(Optional.ofNullable(configuredHttpsUri)); TestServerBuilder serverBuilder = mock(typeof(TestServerBuilder)); when(serverBuilder.NewServer()).thenReturn(serverControls); Neo4jRule rule = new Neo4jRule(serverBuilder); AtomicReference <URI> uriRef = new AtomicReference <URI>(); Statement statement = rule.apply(new StatementAnonymousInnerClass(rule, uriRef) , createTestDescription(typeof(Neo4jRuleTest), "test")); statement.evaluate(); return(uriRef.get()); }
public void Execute_WhenFetchAll_ShouldReturnOk() { //---------------Arrange------------------- var requestUri = "todo/fetch/all"; var useCase = CreateFetchTodoCollectionUseCase(); var testServer = new TestServerBuilder <FetchAllTodo>() .WithInstanceRegistration <IFetchAllTodoUseCase>(useCase) .Build(); using (testServer) { var client = TestHttpClientFactory.CreateClient(testServer); //---------------Act------------------- var response = client.GetAsync(requestUri).Result; //---------------Assert------------------- Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); } }
public async Task RolePolicy_UserInRole_Success() { var builder = new TestServerBuilder() .AddGraphType <Controller_NoPolicies>(); builder.Authorization.AddRolePolicy("RequiresRole1", "role1"); builder.User.AddUserRole("role1"); var server = builder.Build(); var fieldBuilder = server.CreateFieldContextBuilder <Controller_NoPolicies>( nameof(Controller_NoPolicies.RequireRolePolicy_RequiresRole1)); var authContext = fieldBuilder.CreateAuthorizationContext(); await server.ExecuteFieldAuthorization(authContext); AssertAuthorizationSuccess(authContext.Result); }
public async Task IgnoreAuthenticationIfAllowAnonymous_verify_true() { var realm = TestServerBuilder.Realm; using var server = TestServerBuilder.BuildTestServerWithService(options => { options.Realm = realm; options.IgnoreAuthenticationIfAllowAnonymous = true; }); using var client = server.CreateClient(); using var request = new HttpRequestMessage(HttpMethod.Get, TestServerBuilder.AnonymousUrl); request.Headers.Authorization = FakeUsers.FakeUserIgnoreAuthenticationIfAllowAnonymous.ToAuthenticationHeaderValue(); using var response = await client.SendAsync(request); Assert.True(response.IsSuccessStatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode); }
public void create_valid_request_using_route_and_query_string_when_parameters_are_not_primitives() { var server = new TestServerBuilder() .UseDefaultStartup() .Build(); var complexParameter = new Pagination() { PageCount = 10, PageIndex = 1 }; var requestGet = server.CreateHttpApiRequest <ValuesV3Controller>( controller => controller.Get3(complexParameter)); requestGet.GetConfiguredAddress() .Should().Be("api/values/get3?pageindex=1&pagecount=10"); }
public async Task IgnoreAuthenticationIfAllowAnonymous_verify_false() { var realm = TestServerBuilder.Realm; using var server = TestServerBuilder.BuildTestServerWithService(options => { options.Realm = realm; options.IgnoreAuthenticationIfAllowAnonymous = false; }); using var client = server.CreateClient(); using var request = new HttpRequestMessage(HttpMethod.Get, TestServerBuilder.AnonymousUrl); request.Headers.Authorization = FakeUsers.FakeUserIgnoreAuthenticationIfAllowAnonymous.ToAuthenticationHeaderValue(); var exception = await Assert.ThrowsAsync <InvalidOperationException>(() => client.SendAsync(request)); Assert.Equal(nameof(BasicOptions.IgnoreAuthenticationIfAllowAnonymous), exception.Message); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReturnBoltUriWhenDefaultBoltConnectorOffAndOtherConnectorConfigured() public virtual void ShouldReturnBoltUriWhenDefaultBoltConnectorOffAndOtherConnectorConfigured() { TestServerBuilder serverBuilder = newInProcessBuilder(TestDir.directory()).withConfig("dbms.connector.bolt.enabled", "false").withConfig("dbms.connector.another_bolt.type", "BOLT").withConfig("dbms.connector.another_bolt.enabled", "true").withConfig("dbms.connector.another_bolt.listen_address", ":0"); using (ServerControls server = serverBuilder.NewServer()) { HostnamePort boltHostPort = connectorAddress(server.Graph(), "bolt"); HostnamePort anotherBoltHostPort = connectorAddress(server.Graph(), "another_bolt"); assertNull(boltHostPort); assertNotNull(anotherBoltHostPort); URI boltUri = server.BoltURI(); assertEquals("bolt", boltUri.Scheme); assertEquals(anotherBoltHostPort.Host, boltUri.Host); assertEquals(anotherBoltHostPort.Port, boltUri.Port); } }
public async Task ClaimsPolicy_UserDoesHaveClaim_ButWrongValue_Fail() { var builder = new TestServerBuilder() .AddGraphType <Controller_NoPolicies>(); builder.Authorization.AddClaimPolicy("RequiresTestClaim6", "testClaim6", "testClaim6Value"); builder.User.AddUserClaim("testClaim6", "differentValueThanRequired"); var server = builder.Build(); var fieldBuilder = server.CreateFieldContextBuilder <Controller_NoPolicies>( nameof(Controller_NoPolicies.RequireClaimPolicy_RequiresTestClaim6)); var authContext = fieldBuilder.CreateAuthorizationContext(); await server.ExecuteFieldAuthorization(authContext); AssertAuthorizationFails(authContext.Result); }
public async Task AllowAnon_WhenUserDoesntPassChecks_Success() { var builder = new TestServerBuilder() .AddGraphType <Controller_NoPolicies>(); builder.Authorization.AddClaimPolicy("RequiresTestClaim7", "testClaim7", "testClaim7Value"); builder.User.AddUserClaim("testClaim6", "testClaim6Value"); var server = builder.Build(); var fieldBuilder = server.CreateFieldContextBuilder <Controller_NoPolicies>( nameof(Controller_NoPolicies.RequireClaimPolicy_RequiresTestClaim7_ButAlsoAllowAnon)); var authContext = fieldBuilder.CreateAuthorizationContext(); await server.ExecuteFieldAuthorization(authContext); AssertAuthorizationSuccess(authContext.Result); }
public RecoverTests() { // Create strict moq so it throws exceptions if get called, since this // tests should all fail var emailServiceMock = new Mock <IEmailService>(MockBehavior.Strict); // Create a server with custom configuration var config = ConfigBuilder.Default // remove the default service since we mocking it .RemoveDefaultMailService() .Build(); _server = TestServerBuilder.BuildServer <Startup>(config, (services) => { services.AddSingleton(emailServiceMock.Object); }); _client = _server.CreateClient(); }
public async Task DirectRoleCheck_UserHasRole_Succeeds() { var builder = new TestServerBuilder() .AddGraphType <Controller_NoPolicies>(); builder.User.AddUserRole("role5"); var server = builder.Build(); // policy name isnt declared on the controller method var fieldBuilder = server.CreateFieldContextBuilder <Controller_NoPolicies>( nameof(Controller_NoPolicies.MethodHasRoles_Role5)); var authContext = fieldBuilder.CreateAuthorizationContext(); await server.ExecuteFieldAuthorization(authContext); AssertAuthorizationSuccess(authContext.Result); }
public void create_valid_request_using_from_body_complex_arguments_and_complex_query_parameters() { var server = new TestServerBuilder() .UseDefaultStartup() .Build(); var complexParameter = new Pagination() { PageCount = 10, PageIndex = 1 }; var requestPost = server.CreateHttpApiRequest <ValuesV3Controller>( controller => controller.Post3(2, complexParameter, complexParameter)); requestPost.GetConfiguredAddress() .Should().Be("api/values/post/2/1/10"); }
public async Task QueryPlanGeneratedLogEntry() { var server = new TestServerBuilder() .AddGraphType <LogTestController>() .Build(); var queryPlan = await server.CreateQueryPlan("query Operation1{ field1 } query Operation2 { fieldException }"); var entry = new QueryPlanGeneratedLogEntry(queryPlan); Assert.AreEqual(LogEventIds.QueryPlanGenerationCompleted.Id, entry.EventId); Assert.AreEqual(typeof(GraphSchema).FriendlyName(true), entry.SchemaTypeName); Assert.AreEqual(queryPlan.Id, entry.QueryPlanId); Assert.AreEqual(queryPlan.IsValid, entry.QueryPlanIsValid); Assert.AreEqual(queryPlan.Operations.Count, entry.QueryOperationCount); Assert.AreEqual(queryPlan.EstimatedComplexity, entry.QueryPlanEstimatedComplexity); Assert.AreEqual(queryPlan.MaxDepth, entry.QueryPlanMaxDepth); Assert.IsNotNull(entry.ToString()); }