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