public void ActionMethodUnhandledExceptionLogEntry()
{
var server = new TestServerBuilder()
.AddGraphType <LogTestController>()
.Build();
var package = server.CreateFieldContextBuilder <LogTestController>(nameof(LogTestController.ExecuteField2));
var graphMethod = TemplateHelper.CreateActionMethodTemplate <LogTestController>(nameof(LogTestController.ExecuteField2)) as IGraphMethod;
var fieldRequest = package.FieldRequest;
var result = new object();
var exception = new Exception("inner error");
var entry = new ActionMethodUnhandledExceptionLogEntry(graphMethod, fieldRequest, exception);
Assert.AreEqual(LogEventIds.ControllerUnhandledException.Id, entry.EventId);
Assert.AreEqual(fieldRequest.Id, entry.PipelineRequestId);
Assert.AreEqual(graphMethod.Parent.InternalFullName, entry.ControllerTypeName);
Assert.AreEqual(graphMethod.Name, entry.ActionName);
Assert.IsNotNull(entry.ToString());
var exceptionEntry = entry.Exception as ExceptionLogItem;
Assert.IsNotNull(exceptionEntry);
Assert.AreEqual(exception.Message, exceptionEntry.ExceptionMessage);
Assert.AreEqual(exception.StackTrace, exceptionEntry.StackTrace);
Assert.AreEqual(exception.GetType().FriendlyName(true), exceptionEntry.TypeName);
}
public async Task PublishSubEvent_UnusableListForSubscriptionEvents_ThrowsException()
{
var server = new TestServerBuilder()
.AddGraphController <InvokableController>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <InvokableController>(
nameof(InvokableController.MutationRaisesSubEvent));
var arg1Value = "random string";
fieldContextBuilder.AddInputArgument("arg1", arg1Value);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
// prepopulate with a collection thats not really a collection
var eventCollection = new TwoPropertyObject();
resolutionContext.Request.Items.TryAdd(SubscriptionConstants.RAISED_EVENTS_COLLECTION_KEY, eventCollection);
var controller = new InvokableController();
Assert.ThrowsAsync <GraphExecutionException>(async() =>
{
var result = await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext);
});
await Task.CompletedTask;
}
public async Task PublishSubEvent_NoDataYieldsNoEvent()
{
var server = new TestServerBuilder()
.AddGraphController <InvokableController>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <InvokableController>(
nameof(InvokableController.MutationRaisesSubEventNoData));
var arg1Value = "random string";
fieldContextBuilder.AddInputArgument("arg1", arg1Value);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
var controller = new InvokableController();
var result = await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext);
// ensure the method executed completely
Assert.IsNotNull(result);
Assert.IsTrue(result is ObjectReturnedGraphActionResult);
// ensure the event collection was not created
Assert.IsFalse(resolutionContext
.Request
.Items
.ContainsKey(SubscriptionConstants.RAISED_EVENTS_COLLECTION_KEY));
}
public void ValidModelItem_BuildsLogEntry()
{
var server = new TestServerBuilder()
.AddGraphType <LogTestController>()
.Build();
var builder = server.CreateFieldContextBuilder <LogTestController>(nameof(LogTestController.ValidatableInputObject));
var context = builder.CreateExecutionContext();
// valid range 0 - 35
var item = new ValidatableObject()
{
Age = 18,
};
var generator = new ModelStateGenerator();
var argumentToTest = CreateArgument("testItem", item);
var dictionary = generator.CreateStateDictionary(argumentToTest);
var entry = new ActionMethodModelStateValidatedLogEntry(
builder.GraphMethod.Object,
context.Request,
dictionary);
this.ValidateModelDictionaryToLogEntry(builder.GraphMethod.Object, context.Request, dictionary, entry);
}
public async Task TemplateIsInterface_SourceDataDoesImplementInterface_RendersCorrectly()
{
var server = new TestServerBuilder()
.AddGraphType <ResolverObject>()
.AddGraphType <IResolverInterface>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <ResolverObject>(nameof(ResolverObject.Address1));
var item = new ResolverObject();
item.Address1 = "15th Street";
fieldContextBuilder.AddSourceData(item);
// set properties parent to be an interface that the source data is castable
// this scenario shouldnt be possible in general execution but exists
// in case of developers extending the framework
var parentMock = new Mock <IGraphTypeTemplate>();
parentMock.Setup(x => x.ObjectType).Returns(typeof(IResolverInterface));
fieldContextBuilder.GraphMethod.Setup(x => x.Parent).Returns(parentMock.Object);
var resolver = new GraphObjectPropertyResolver(fieldContextBuilder.GraphMethod.Object);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
await resolver.Resolve(resolutionContext);
Assert.AreEqual("15th Street", resolutionContext.Result);
Assert.IsTrue(resolutionContext.Messages.IsSucessful);
}
public async Task KnownExecutionError_FailsRequest()
{
var server = new TestServerBuilder()
.AddGraphType <ResolverObject>()
.Build();
var builder = server.CreateFieldContextBuilder <ResolverObject>(
nameof(ResolverObject.MethodWithArgument));
// the method declares one input argument which is not provided on this request
// resulting in a GraphExecutionException which
// is absorbed into a message (with no attached exception)
// source data is not of the type the resolver is for
builder.AddSourceData(new ResolverObject());
var resolver = new GraphObjectMethodResolver(builder.GraphMethod.Object);
var context = builder.CreateResolutionContext();
await resolver.Resolve(context);
Assert.AreEqual(null, context.Result);
Assert.IsFalse(context.Messages.IsSucessful);
Assert.AreEqual(null, context.Messages[0].Exception);
Assert.AreEqual(Constants.ErrorCodes.EXECUTION_ERROR, context.Messages[0].Code);
}
public async Task TemplateIsInterface_SourceDataDoesNotImplementInterface_FailsRequest()
{
var server = new TestServerBuilder()
.AddGraphType <ResolverObject>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <ResolverObject>(nameof(ResolverObject.Address1));
fieldContextBuilder.AddSourceData(new TwoPropertyObject());
// set properties parent to be an interface
// that hte source data is not castable to
var parentMock = new Mock <IGraphTypeTemplate>();
parentMock.Setup(x => x.ObjectType).Returns(typeof(ITestInterface));
fieldContextBuilder.GraphMethod.Setup(x => x.Parent).Returns(parentMock.Object);
var resolver = new GraphObjectPropertyResolver(fieldContextBuilder.GraphMethod.Object);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
await resolver.Resolve(resolutionContext);
Assert.AreEqual(null, resolutionContext.Result);
Assert.IsFalse(resolutionContext.Messages.IsSucessful);
Assert.AreEqual(Constants.ErrorCodes.INVALID_OBJECT, resolutionContext.Messages[0].Code);
}
public async Task PublishSubEvent_ExistingEventCollectionisAppendedTo()
{
var server = new TestServerBuilder()
.AddGraphController <InvokableController>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <InvokableController>(
nameof(InvokableController.MutationRaisesSubEvent));
var arg1Value = "random string";
fieldContextBuilder.AddInputArgument("arg1", arg1Value);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
var eventCollection = new List <SubscriptionEventProxy>();
resolutionContext.Request.Items.TryAdd(SubscriptionConstants.RAISED_EVENTS_COLLECTION_KEY, eventCollection);
var controller = new InvokableController();
var result = await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext);
// ensure the method executed completely
Assert.IsNotNull(result);
Assert.IsTrue(result is ObjectReturnedGraphActionResult);
Assert.AreEqual(1, eventCollection.Count);
}
public async Task MethodInvocation_EnsureInternalPropertiesAreSet()
{
var server = new TestServerBuilder()
.AddGraphController <InvokableController>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <InvokableController>(nameof(InvokableController.AsyncActionMethod));
fieldContextBuilder.AddInputArgument("arg1", "random string");
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
var controller = new InvokableController();
var result = await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext);
Assert.IsNotNull(result);
Assert.IsTrue(result is ObjectReturnedGraphActionResult);
Assert.AreEqual(3, controller.CapturedItems.Count);
Assert.AreEqual(server.ServiceProvider, controller.CapturedItems["RequestServices"]);
Assert.AreEqual(resolutionContext.Request, controller.CapturedItems["Request"]);
var modelState = controller.CapturedItems["ModelState"] as InputModelStateDictionary;
Assert.IsTrue(modelState.IsValid);
Assert.IsTrue(modelState.ContainsKey("arg1"));
}
private FieldResolutionContext CreateResolutionContext(object sourceData = null)
{
var server = new TestServerBuilder()
.AddGraphType <ActionableController>()
.Build();
var builder = server
.CreateFieldContextBuilder <ActionableController>(nameof(ActionableController.DoStuff), sourceData);
return(builder.CreateResolutionContext());
}
public void MethodInvocation_UserCodeExceptionIsAllowedToThrow()
{
var tester = new TestServerBuilder().Build();
var fieldContextBuilder = tester.CreateFieldContextBuilder <InvokableController>(nameof(InvokableController.AsyncActionMethodToCauseException));
fieldContextBuilder.AddInputArgument("arg1", "random string");
var controller = new InvokableController();
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
Assert.ThrowsAsync <UserThrownException>(async() => await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext));
}
public async Task NotFoundResult_ViaCustomErrorMessage()
{
var server = new TestServerBuilder().Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <InvokableController>(nameof(InvokableController.CreateNotFoundResult));
var controller = new InvokableController();
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
var result = await controller.InvokeActionAsync(
fieldContextBuilder.GraphMethod.Object,
resolutionContext) as RouteNotFoundGraphActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("it was not found", result.Message);
}
public async Task MethodInvocation_SyncMethodReturnsObjectNotTask()
{
var tester = new TestServerBuilder().Build();
var fieldContextBuilder = tester.CreateFieldContextBuilder <InvokableController>(nameof(InvokableController.SyncronousActionMethod));
fieldContextBuilder.AddInputArgument("arg1", "random string");
var controller = new InvokableController();
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
var result = await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext);
Assert.IsNotNull(result);
Assert.IsTrue(result is ObjectReturnedGraphActionResult);
}
public async Task MethodInvocation_MissingMethodInfo_ReturnsInternalServerError()
{
var tester = new TestServerBuilder().Build();
var fieldContextBuilder = tester.CreateFieldContextBuilder <InvokableController>(nameof(InvokableController.SyncronousActionMethod));
fieldContextBuilder.AddInputArgument("arg1", "random string");
fieldContextBuilder.GraphMethod.Setup(x => x.Method).Returns <MethodInfo>(null);
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 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());
}
public async Task NullSourceData_FailsRequest()
{
var server = new TestServerBuilder()
.AddGraphType <ResolverObject>()
.Build();
var builder = server.CreateFieldContextBuilder <ResolverObject>(
nameof(ResolverObject.MethodRetrieveData));
var resolver = new GraphObjectMethodResolver(builder.GraphMethod.Object);
var context = builder.CreateResolutionContext();
await resolver.Resolve(context);
Assert.AreEqual(null, context.Result);
Assert.IsFalse(context.Messages.IsSucessful);
Assert.AreEqual(Constants.ErrorCodes.INVALID_OBJECT, context.Messages[0].Code);
}
public void ActionMethodInvocationStartedLogEntry()
{
var server = new TestServerBuilder()
.AddGraphType <LogTestController>()
.Build();
var graphMethod = TemplateHelper.CreateActionMethodTemplate <LogTestController>(nameof(LogTestController.ExecuteField2)) as IGraphMethod;
var package = server.CreateFieldContextBuilder <LogTestController>(nameof(LogTestController.ExecuteField2));
var fieldRequest = package.FieldRequest;
var entry = new ActionMethodInvocationStartedLogEntry(graphMethod, fieldRequest);
Assert.AreEqual(LogEventIds.ControllerInvocationStarted.Id, entry.EventId);
Assert.AreEqual(fieldRequest.Id, entry.PipelineRequestId);
Assert.AreEqual(graphMethod.Parent.InternalFullName, entry.ControllerName);
Assert.AreEqual(graphMethod.Name, entry.ActionName);
Assert.AreEqual(graphMethod.Route.Path, entry.FieldPath);
Assert.AreEqual(graphMethod.ObjectType.ToString(), entry.SourceObjectType);
Assert.AreEqual(graphMethod.IsAsyncField, entry.IsAsync);
Assert.IsNotNull(entry.ToString());
}
public async Task SourceDataIsNotOfTheTemplate_FailsRequest()
{
var server = new TestServerBuilder()
.AddGraphType <ResolverObject>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <ResolverObject>(
nameof(ResolverObject.Address1));
// source data is not of the type the resolver is for
fieldContextBuilder.AddSourceData(new TwoPropertyObject());
var resolver = new GraphObjectPropertyResolver(fieldContextBuilder.GraphMethod.Object);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
await resolver.Resolve(resolutionContext);
Assert.AreEqual(null, resolutionContext.Result);
Assert.IsFalse(resolutionContext.Messages.IsSucessful);
Assert.AreEqual(Constants.ErrorCodes.INVALID_OBJECT, resolutionContext.Messages[0].Code);
}
public void FieldResolutionCompletedLogEntry()
{
var server = new TestServerBuilder()
.AddGraphType <LogTestController>()
.Build();
var package = server.CreateFieldContextBuilder <LogTestController>(nameof(LogTestController.ExecuteField2));
var resolutionContext = package.CreateResolutionContext();
var fieldRequest = package.FieldRequest;
resolutionContext.Result = "15";
var entry = new FieldResolutionCompletedLogEntry(resolutionContext);
Assert.AreEqual(LogEventIds.FieldResolutionCompleted.Id, entry.EventId);
Assert.AreEqual(fieldRequest.Id, entry.PipelineRequestId);
Assert.AreEqual(fieldRequest.Field.Route.Path, entry.FieldPath);
Assert.AreEqual(fieldRequest.Field.TypeExpression.ToString(), entry.TypeExpression);
Assert.AreEqual(true, entry.HasData);
Assert.AreEqual(true, entry.ResultIsValid);
Assert.IsNotNull(entry.ToString());
}
public async Task SingleFieldResolution_ViaPipeline_YieldsCorrectResult()
{
var server = new TestServerBuilder()
.AddGraphType <SimpleExecutionController>()
.Build();
var builder = server.CreateFieldContextBuilder <SimpleExecutionController>(
nameof(SimpleExecutionController.SimpleQueryMethod));
builder.AddInputArgument("arg1", "my value");
builder.AddInputArgument("arg2", 15L);
builder.AddSourceData(new object());
var context = builder.CreateExecutionContext();
await server.ExecuteField(context);
var data = context.Result as TwoPropertyObject;
Assert.IsNotNull(data);
Assert.AreEqual("my value", data.Property1);
}
public async Task PropertyThrowsException_FailsRequest()
{
var server = new TestServerBuilder()
.AddGraphType <ResolverObject>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <ResolverObject>(
nameof(ResolverObject.PropertyThrowException));
// source data is not of the type the resolver is for
fieldContextBuilder.AddSourceData(new ResolverObject());
var resolver = new GraphObjectPropertyResolver(fieldContextBuilder.GraphMethod.Object);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
await resolver.Resolve(resolutionContext);
Assert.AreEqual(null, resolutionContext.Result);
Assert.IsFalse(resolutionContext.Messages.IsSucessful);
Assert.IsTrue(resolutionContext.Messages[0].Exception is InvalidOperationException);
Assert.AreEqual("resolver.property.throwException", resolutionContext.Messages[0].Exception.Message);
Assert.AreEqual(Constants.ErrorCodes.UNHANDLED_EXCEPTION, resolutionContext.Messages[0].Code);
}
public async Task PublishSubEvent_PublishesEventWithCorrectData()
{
var server = new TestServerBuilder()
.AddGraphController <InvokableController>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <InvokableController>(
nameof(InvokableController.MutationRaisesSubEvent));
var arg1Value = "random string";
fieldContextBuilder.AddInputArgument("arg1", arg1Value);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
var controller = new InvokableController();
var result = await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext);
// ensure the method executed completely
Assert.IsNotNull(result);
Assert.IsTrue(result is ObjectReturnedGraphActionResult);
// ensure the event collection was created on the context
Assert.IsTrue(resolutionContext.Request.Items.ContainsKey(SubscriptionConstants.RAISED_EVENTS_COLLECTION_KEY));
var raisedEvents = resolutionContext.Request.Items[SubscriptionConstants.RAISED_EVENTS_COLLECTION_KEY]
as List <SubscriptionEventProxy>;
// ensure only one event was added
Assert.AreEqual(1, raisedEvents.Count);
var eventData = raisedEvents[0];
// ensure event properties
Assert.AreEqual("event1", eventData.EventName);
var obj = eventData.DataObject as TwoPropertyObject;
Assert.IsNotNull(obj);
Assert.AreEqual(arg1Value, obj.Property1);
}
public void ActionMethodInvocationCompletedLogEntry()
{
var server = new TestServerBuilder()
.AddGraphType <LogTestController>()
.Build();
var graphMethod = TemplateHelper.CreateActionMethodTemplate <LogTestController>(nameof(LogTestController.ExecuteField2)) as IGraphMethod;
var package = server.CreateFieldContextBuilder <LogTestController>(nameof(LogTestController.ExecuteField2));
var resolutionContext = package.CreateResolutionContext();
var fieldRequest = package.FieldRequest;
var result = new object();
var entry = new ActionMethodInvocationCompletedLogEntry(graphMethod, fieldRequest, result);
Assert.AreEqual(LogEventIds.ControllerInvocationCompleted.Id, entry.EventId);
Assert.AreEqual(fieldRequest.Id, entry.PipelineRequestId);
Assert.AreEqual(graphMethod.Parent.InternalFullName, entry.ControllerName);
Assert.AreEqual(graphMethod.Name, entry.ActionName);
Assert.AreEqual(graphMethod.Route.Path, entry.FieldPath);
Assert.AreEqual(result.GetType().FriendlyName(true), entry.ResultTypeName);
Assert.IsNotNull(entry.ToString());
}
public async Task PublishSubEvent_NoEventNameFailsTheResolver_BubblesExceptionUp()
{
var server = new TestServerBuilder()
.AddGraphController <InvokableController>()
.Build();
var fieldContextBuilder = server.CreateFieldContextBuilder <InvokableController>(
nameof(InvokableController.MutationRaiseSubEventWithNoEventName));
var arg1Value = "random string";
fieldContextBuilder.AddInputArgument("arg1", arg1Value);
var resolutionContext = fieldContextBuilder.CreateResolutionContext();
var controller = new InvokableController();
Assert.ThrowsAsync <ArgumentException>(async() =>
{
var result = await controller.InvokeActionAsync(fieldContextBuilder.GraphMethod.Object, resolutionContext);
});
await Task.CompletedTask;
}