public JsonWrapperTests()
{
QueryExprSerializer.ConfigureRules(rules =>
rules.RuleForType <QueryExprSerializerTests>()
.RuleForType <TestableThing>()
.RuleForType(typeof(Tuple)));
}
private void Reset()
{
ServiceHost.GetService <IMemberAdapter>().Reset();
QueryExprSerializer.ConfigureRules(
rules => rules.RuleForType <QueryExprSerializerTests>()
.RuleForType <TestableThing>()
.RuleForType <BinarySerializerTests>()
.RuleForType(typeof(KeyValuePair))
.RuleForType(typeof(Tuple)));
}
public void HandlesElementInits()
{
Expression <Func <DataHost> > elemInit = () => new DataHost {
Elems = { new DataElem() }
};
var root = QueryExprSerializer.Serialize(elemInit, config => config.CompressExpressionTree(false));
var json = wrapper.FromSerializationRoot(root);
var deserializedRoot = wrapper.ToSerializationRoot(json);
QueryExprSerializer.ConfigureRules(rules => rules.RuleForType <DataHost>()
.RuleForType <DataElem>());
var deserializedExpr = QueryExprSerializer.Deserialize <LambdaExpression>(deserializedRoot);
Assert.True(elemInit.IsEquivalentTo(deserializedExpr));
}
public void GivenRulesPassedWhenMapPowerToolsEFCoreBaseCalledThenShouldConfigureRules()
{
IEndpointRouteBuilder builder = null;
CreateSimpleServer(config => builder = config);
builder.MapPowerToolsEFCore(
routePattern,
defaultTypes,
rules => rules.RuleForType <MiddlewareExtensionsTests>());
var engine = ServiceHost.GetService <IRulesEngine>();
Assert.True(engine.MemberIsAllowed(typeof(MiddlewareExtensionsTests)));
// reset rules
QueryExprSerializer.ConfigureRules();
}
public void AlternateSelectManyWorks()
{
QueryExprSerializer.ConfigureRules(
rules => rules.RuleForType <RelatedThing>());
var db = typeof(JsonWrapperTests).Assembly.GetTypes()
.Select(t => new MockType
{
Id = t.ToString(),
Name = t.FullName,
Methods = t.GetMethods().Select(
m => new MockMethod
{
Id = m.ToString(),
Name = m.Name,
Parameters = m.GetParameters()
.Select(p => new MockParameter
{
Id = $"{p.Position}-{p.ParameterType}",
Name = p.Name,
}).ToList()
}).ToList()
});
Func <IQueryable <MockType>, IQueryable <RelatedThing> > makeQuery = q =>
q
.Where(t => t.Name != null)
.SelectMany(
t =>
t.Methods, (t, m) =>
new
{
t.Name,
MethodName = m.Name,
m.Parameters,
})
.SelectMany(
tm => tm.Parameters,
(tm, p) =>
new RelatedThing
{
TypeName = tm.Name,
MethodName = tm.MethodName,
ParameterName = p.Name,
})
.OrderBy(r => r.TypeName)
.ThenBy(r => r.MethodName)
.ThenBy(r => r.ParameterName);
var queryToSerialize = makeQuery(new List <MockType>().AsQueryable());
var root = QueryExprSerializer.Serialize(queryToSerialize);
var json = wrapper.FromSerializationRoot(root);
var deserializedRoot = wrapper.ToSerializationRoot(json);
var newQuery = QueryExprSerializer.DeserializeQuery <RelatedThing>(deserializedRoot, db.AsQueryable());
var result = makeQuery(db.AsQueryable());
var expected = result.ToList();
var actual = newQuery.ToList();
Assert.NotNull(actual);
Assert.Equal(expected.Count(), actual.Count());
}
/// <summary>
/// Main configuration method for Power Tools EF Core middleware.
/// </summary>
/// <param name="endpointRouteBuilder">The <see cref="IEndpointRouteBuilder"/>.</param>
/// <param name="pattern">The pattern for the route (defaults to <c>/efcore</c>).</param>
/// <param name="dbContextTypes">The list of <c>DbContext</c> types to support.</param>
/// <param name="rules">The <see cref="IRulesConfiguration"/> to configure serialization rules.</param>
/// <param name="noDefaultRules">Determines whether the default rule set should be applied.</param>
/// <param name="options">The <see cref="IConfigurationBuilder"/> to configure options.</param>
/// <returns>The <see cref="IEndpointConventionBuilder"/>.</returns>
public static IEndpointConventionBuilder MapPowerToolsEFCore(
this IEndpointRouteBuilder endpointRouteBuilder,
RoutePattern pattern,
Type[] dbContextTypes,
Action <IRulesConfiguration> rules = null,
bool noDefaultRules = false,
Action <IConfigurationBuilder> options = null)
{
Ensure.NotNull(() => endpointRouteBuilder);
Ensure.NotNull(() => pattern);
Ensure.NotNull(() => dbContextTypes);
if (pattern.Parameters.Count != 2)
{
throw new ArgumentException(
$"{DefaultPattern}<~>{pattern.RawText}",
nameof(pattern));
}
if (!pattern.Parameters.Any(p => p.Name == Context))
{
throw new ArgumentException(Context, nameof(pattern));
}
if (!pattern.Parameters.Any(p => p.Name == Collection))
{
throw new ArgumentException(Collection, nameof(pattern));
}
if (dbContextTypes.Length == 0)
{
throw new ArgumentException(
$"{nameof(dbContextTypes)}.Length = 0",
nameof(dbContextTypes));
}
var badType = dbContextTypes.FirstOrDefault(
t => !typeof(DbContext).IsAssignableFrom(t));
if (badType != null)
{
throw new ArgumentException(
$"{badType} != {typeof(DbContext)}",
nameof(dbContextTypes));
}
// passed tests, check configuration
if (options != null)
{
QueryExprSerializer.ConfigureDefaults(options);
}
if (rules != null || noDefaultRules == true)
{
QueryExprSerializer.ConfigureRules(rules, noDefaultRules);
}
var appBuilder = endpointRouteBuilder.CreateApplicationBuilder();
appBuilder.UseMiddleware <ExpressionPowerToolsEFCoreMiddleware>(
pattern.RawText,
dbContextTypes);
return(endpointRouteBuilder.Map(pattern, appBuilder.Build())
.WithDisplayName($"Expression Power Tools Serialization Pipeline"));
}
public BinarySerializerTests()
{
QueryExprSerializer.ConfigureRules(config => config.RuleForType <BinarySerializerTests>());
}
