public OpenRpcGenerator(IOptions <JsonRpcOptions> jsorRpcOptions, IOptions <OpenRpcOptions> options, IApiDescriptionGroupCollectionProvider apiDescriptionsProvider, ContentDescriptorGenerator contentDescriptorGenerator)
{
this.options = options.Value;
this.jsonRpcOptions = jsorRpcOptions.Value;
this.apiDescriptionsProvider = apiDescriptionsProvider;
this.contentDescriptorGenerator = contentDescriptorGenerator;
}
public ActionResultConverter(JsonRpcFormatter jsonRpcFormatter, IJsonRpcErrorFactory jsonRpcErrorFactory, IOptions <JsonRpcOptions> options, ILogger <ActionResultConverter> log)
{
this.JsonRpcFormatter = jsonRpcFormatter;
this.jsonRpcErrorFactory = jsonRpcErrorFactory;
this.options = options.Value;
this.log = log;
}
public void Test_ValidateRouting_AddsAndFailsOnDuplicates()
{
var options = new JsonRpcOptions();
var data1 = new MethodMetadata(options.DefaultMethodOptions, new JsonName("", ""), new JsonName("", "a"));
var data2 = new MethodMetadata(options.DefaultMethodOptions, new JsonName("", ""), new JsonName("", "b"));
var matcherMock = new Mock <IMethodMatcher>();
matcherMock.Setup(x => x.GetActionName(It.IsAny <MethodMetadata>())).Returns <MethodMetadata>(x => x.Action.Json);
var actionConvention = GetActionConvention(options, matcherMock.Object);
actionConvention.KnownRoutes.Should().HaveCount(0);
Action addDiffertentRoutes = () =>
{
actionConvention.ValidateRouting(data1);
actionConvention.ValidateRouting(data2);
};
addDiffertentRoutes.Should().NotThrow();
actionConvention.KnownRoutes.Should().HaveCount(2);
Action addDuplicate1 = () => actionConvention.ValidateRouting(data1);
addDuplicate1.Should().Throw <InvalidOperationException>();
Action addDuplicate2 = () => actionConvention.ValidateRouting(data2);
addDuplicate2.Should().Throw <InvalidOperationException>();
actionConvention.KnownRoutes.Should().HaveCount(2);
}
public void Test_GetMethodMetadata_UsesSerializerAndMethodOptions(Type serializerType)
{
var actionName = "actionName";
var controllerName = "controllerName";
var serializer = testEnvironment.ServiceProvider.GetRequiredService(serializerType) as IJsonRpcSerializer;
var controllerModel = new Mock <ControllerModel>(typeof(JsonRpcTestController).GetTypeInfo(), new List <object> {
}).Object;
var model = new Mock <ActionModel>(typeof(JsonRpcTestController).GetMethod(nameof(JsonRpcTestController.VoidAction)), new List <object>()).Object;
model.Controller = controllerModel;
model.ActionName = actionName;
model.Controller.ControllerName = controllerName;
var options = new JsonRpcOptions();
var actionConvention = GetActionConvention(options);
var methodOptions = new JsonRpcMethodOptions()
{
RequestSerializer = serializerType
};
var result = actionConvention.GetMethodMetadata(model, methodOptions);
result.Action.Should().BeEquivalentTo(serializer.GetJsonName(actionName));
result.Controller.Should().BeEquivalentTo(serializer.GetJsonName(controllerName));
result.MethodOptions.Should().NotBe(options.DefaultMethodOptions);
result.MethodOptions.Should().Be(methodOptions);
}
public void Test_MakeOptions_UsesControllerAttributes()
{
var serializerType = typeof(CamelCaseJsonRpcSerializer);
var route = new PathString("/test");
var methodStyle = MethodStyle.ActionOnly;
var attributes = new List <object>
{
new Mock <JsonRpcSerializerAttribute>(serializerType).Object,
new Mock <RouteAttribute>(route.Value).Object,
new Mock <JsonRpcMethodStyleAttribute>(methodStyle).Object,
};
var controllerModel = new Mock <ControllerModel>(typeof(JsonRpcTestController).GetTypeInfo(), attributes).Object;
var model = new Mock <ActionModel>(typeof(JsonRpcTestController).GetMethod(nameof(JsonRpcTestController.VoidAction)), new List <object>()).Object;
model.Controller = controllerModel;
var options = new JsonRpcOptions();
var actionConvention = GetActionConvention(options);
var result = actionConvention.MakeOptions(model);
result.Should().NotBe(options.DefaultMethodOptions);
result.Should().NotBeEquivalentTo(options.DefaultMethodOptions);
result.Route.Should().Be(route);
result.MethodStyle.Should().Be(methodStyle);
result.RequestSerializer.Should().Be(serializerType);
}
public void Test_SetAttributes_ClearsSelectorsAndAddsCustomSelector()
{
var controllerModel = new Mock <ControllerModel>(typeof(JsonRpcTestController).GetTypeInfo(), new List <object>()).Object;
var model = new Mock <ActionModel>(typeof(JsonRpcTestController).GetMethod(nameof(JsonRpcTestController.VoidAction)), new List <object>()).Object;
model.Controller = controllerModel;
var selectorToRemove = new SelectorModel();
model.Selectors.Add(selectorToRemove);
var options = new JsonRpcOptions();
var route = new PathString("/test");
options.DefaultMethodOptions.Route = route;
var actionConvention = GetActionConvention(options);
actionConvention.SetAttributes(model, options.DefaultMethodOptions);
model.Selectors.Should().HaveCount(1);
model.Selectors[0].Should().NotBe(selectorToRemove);
model.Selectors[0].AttributeRouteModel.Template.Should().Be(route);
model.Selectors[0].ActionConstraints.Should().HaveCount(2);
model.Selectors[0].ActionConstraints[0].Should().BeOfType <JsonRpcAttribute>();
model.Selectors[0].ActionConstraints[1].Should().BeOfType <HttpMethodActionConstraint>();
model.Selectors[0].ActionConstraints[1].As <HttpMethodActionConstraint>().HttpMethods.Should().HaveCount(1);
model.Selectors[0].ActionConstraints[1].As <HttpMethodActionConstraint>().HttpMethods.First().Should().Be(HttpMethods.Post);
}
public RequestHandler(IJsonRpcErrorFactory errorFactory, HeaderJsonRpcSerializer headerJsonRpcSerializer, INestedContextFactory nestedContextFactory, IResponseReader responseReader, IOptions <JsonRpcOptions> options, ILogger <RequestHandler> log)
{
this.errorFactory = errorFactory;
this.headerJsonRpcSerializer = headerJsonRpcSerializer;
this.nestedContextFactory = nestedContextFactory;
this.responseReader = responseReader;
this.log = log;
this.options = options.Value;
}
public void Test_JsonRpcOptions_Defaults()
{
var options = new JsonRpcOptions();
options.AllowRawResponses.Should().Be(false);
options.DetailedResponseExceptions.Should().Be(false);
options.DefaultMethodOptions.Should().NotBeNull();
options.BatchHandling.Should().Be(BatchHandling.Sequential);
options.HeaderSerializer.Should().Be <HeaderJsonRpcSerializer>();
}
/// <summary>
/// Resolve ActionConvention with options and overriding services instead of registered in DI
/// </summary>
/// <param name="jsonRpcOptions"></param>
/// <param name="services"></param>
/// <returns></returns>
private ActionConvention GetActionConvention(JsonRpcOptions jsonRpcOptions, params object[] services)
{
var optionsWrapper = new OptionsWrapper <JsonRpcOptions>(jsonRpcOptions);
var allServices = new List <object> {
optionsWrapper
};
allServices.AddRange(services);
return(ActivatorUtilities.CreateInstance <ActionConvention>(testEnvironment.ServiceProvider, allServices.ToArray()));
}
public void Setup()
{
jsonRpcOptions = new JsonRpcOptions();
var optionsMock = new Mock <IOptions <JsonRpcOptions> >();
optionsMock.Setup(x => x.Value)
.Returns(jsonRpcOptions);
testEnvironment = new TestEnvironment(services =>
{
services.AddSingleton(optionsMock.Object);
services.AddSingleton <JsonRpcErrorFactory>();
});
}
public void Test_Apply_IgnoresMvcActions()
{
var controllerModel = new Mock <ControllerModel>(typeof(MvcTestController).GetTypeInfo(), new List <object>()).Object;
var model = new Mock <ActionModel>(typeof(MvcTestController).GetMethod(nameof(MvcTestController.VoidAction)), new List <object>()).Object;
model.Controller = controllerModel;
model.Selectors.Add(new SelectorModel());
model.Filters.Add(someFilter);
var options = new JsonRpcOptions();
var actionConvention = GetActionConvention(options);
actionConvention.Apply(model);
model.Selectors.Should().HaveCount(1);
model.Filters.Should().HaveCount(1);
model.Filters[0].Should().Be(someFilter);
}
public void Test_Apply_AddsProperty()
{
var controllerModel = new Mock <ControllerModel>(typeof(JsonRpcTestController).GetTypeInfo(), new List <object>()).Object;
var model = new Mock <ActionModel>(typeof(JsonRpcTestController).GetMethod(nameof(JsonRpcTestController.VoidAction)), new List <object>()).Object;
model.Controller = controllerModel;
var options = new JsonRpcOptions();
var actionConvention = GetActionConvention(options);
actionConvention.KnownRoutes.Should().HaveCount(0);
model.Properties.Should().HaveCount(0);
actionConvention.Apply(model);
model.Properties.Should().HaveCount(1);
model.Properties.First().Key.Should().Be(typeof(MethodMetadata));
model.Properties.First().Value.Should().BeOfType <MethodMetadata>();
actionConvention.KnownRoutes.Should().HaveCount(1);
}
public void Test_ValidateRouting_FailsOnReservedName()
{
var options = new JsonRpcOptions();
options.DefaultMethodOptions.MethodStyle = MethodStyle.ActionOnly;
var data = new MethodMetadata(options.DefaultMethodOptions, new JsonName("", ""), new JsonName("", $"{JsonRpcConstants.ReservedMethodPrefix}a"));
var matcherMock = new Mock <IMethodMatcher>();
matcherMock.Setup(x => x.GetActionName(It.IsAny <MethodMetadata>())).Returns <MethodMetadata>(x => x.Action.Json);
var actionConvention = GetActionConvention(options, matcherMock.Object);
actionConvention.KnownRoutes.Should().HaveCount(0);
Action addDuplicate1 = () => actionConvention.ValidateRouting(data);
addDuplicate1.Should().Throw <InvalidOperationException>();
actionConvention.KnownRoutes.Should().HaveCount(0);
}
public void Test_MakeOptions_UsesDefaults()
{
var controllerModel = new Mock <ControllerModel>(typeof(JsonRpcTestController).GetTypeInfo(), new List <object>()).Object;
var model = new Mock <ActionModel>(typeof(JsonRpcTestController).GetMethod(nameof(JsonRpcTestController.VoidAction)), new List <object>()).Object;
model.Controller = controllerModel;
var options = new JsonRpcOptions()
{
DefaultMethodOptions = new JsonRpcMethodOptions
{
MethodStyle = MethodStyle.ActionOnly,
Route = new PathString("/test"),
RequestSerializer = typeof(CamelCaseJsonRpcSerializer)
}
};
var actionConvention = GetActionConvention(options);
var result = actionConvention.MakeOptions(model);
result.Should().NotBe(options.DefaultMethodOptions);
result.Should().BeEquivalentTo(options.DefaultMethodOptions);
}
public JsonRpcErrorFactory(IOptions <JsonRpcOptions> options, ILogger <JsonRpcErrorFactory> log)
{
this.log = log;
this.options = options.Value;
}
public static IEndpointConventionBuilder MapJsonRpc(this IEndpointRouteBuilder endpoints, RoutePattern pattern, JsonRpcOptions options)
{
if (endpoints == null)
{
throw new ArgumentNullException(nameof(endpoints));
}
var pipeline = endpoints.CreateApplicationBuilder()
.UseJsonRpc(options)
.Build();
return(endpoints.Map(pattern, pipeline));
}
public static IEndpointConventionBuilder MapJsonRpc(this IEndpointRouteBuilder endpoints, string pattern, JsonRpcOptions options)
{
if (endpoints == null)
{
throw new ArgumentNullException(nameof(endpoints));
}
return(MapJsonRpc(endpoints, RoutePatternFactory.Parse(pattern), options));
}
public JsonRpcDescriptionProvider(IMethodMatcher methodMatcher, ITypeEmitter typeEmitter, IOptions <JsonRpcOptions> options)
{
this.methodMatcher = methodMatcher;
this.typeEmitter = typeEmitter;
this.options = options.Value;
}
public static IApplicationBuilder UseJsonRpc(this IApplicationBuilder builder, JsonRpcOptions options)
{
return(builder.UseMiddleware <JsonRpcMiddleware>(Options.Create(options)));
}
private JsonSerializer GetSerializer()
{
var options = new JsonRpcOptions();
return(JsonSerializer.Create(options.JsonSerializerSettings));
}
public static IApplicationBuilder UseJsonRpc(this IApplicationBuilder builder, JsonRpcOptions options)
{
var httpContextAccessor = builder.ApplicationServices.GetRequiredService <IHttpContextAccessor>();
return(builder.UseMiddleware <JsonRpcMiddleware>(httpContextAccessor, Options.Create(options)));
}
