public void Merge_Should_DeepMerge_EnumConfigurations()
{
// arrange
var convention = new MockSortConvention(
x => x.ConfigureEnum <DefaultSortEnumType>(d => d.Name("Foo")));
var extension = new SortConventionExtension(
x => x.ConfigureEnum <DefaultSortEnumType>(d => d.Name("Foo")));
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.NotNull(convention.DefinitionAccessor);
List <ConfigureSortEnumType> configuration =
Assert.Single(convention.DefinitionAccessor !.EnumConfigurations.Values) !;
Assert.Equal(2, configuration.Count);
}
public void Merge_Should_Merge_ProviderExtensions()
{
// arrange
var provider1 = new MockProviderExtensions();
var convention = new MockSortConvention(x => x.AddProviderExtension(provider1));
var provider2 = new MockProviderExtensions();
var extension = new SortConventionExtension(x => x.AddProviderExtension(provider2));
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.NotNull(convention.DefinitionAccessor);
Assert.Collection(
convention.DefinitionAccessor !.ProviderExtensions,
x => Assert.Equal(provider1, x),
x => Assert.Equal(provider2, x));
}
public void SortConvention_Should_Work_With_ProviderExtensionsType()
{
// arrange
var provider = new QueryableSortProvider(
descriptor =>
{
descriptor.AddFieldHandler <QueryableDefaultSortFieldHandler>();
});
var convention = new SortConvention(
descriptor =>
{
descriptor.BindRuntimeType <string, TestEnumType>();
descriptor.Provider(provider);
});
var extension1 = new SortConventionExtension(
descriptor =>
{
descriptor.Operation(DefaultSortOperations.Ascending).Name("ASC");
descriptor.AddProviderExtension <MockSortProviderExtensionConvention>();
});
IValueNode value = Utf8GraphQLParser.Syntax.ParseValueLiteral("{ bar: ASC}");
var type = new FooSortType();
//act
CreateSchemaWith(type, convention, extension1);
var executor = new ExecutorBuilder(type);
Func <Foo[], Foo[]> func = executor.Build <Foo>(value);
// assert
Foo[]? a = new[] { new Foo {
Bar = "a"
}, new Foo {
Bar = "b"
}, new Foo {
Bar = "c"
} };
Assert.Collection(
func(a),
x => Assert.Equal("a", x.Bar),
x => Assert.Equal("b", x.Bar),
x => Assert.Equal("c", x.Bar));
Foo[]? b = new[] { new Foo {
Bar = "c"
}, new Foo {
Bar = "b"
}, new Foo {
Bar = "a"
} };
Assert.Collection(
func(b),
x => Assert.Equal("a", x.Bar),
x => Assert.Equal("b", x.Bar),
x => Assert.Equal("c", x.Bar));
}
public void Merge_Should_Merge_Provider()
{
// arrange
var convention = new MockSortConvention(x => x.Provider <QueryableSortProvider>());
var extension = new SortConventionExtension(x => x.Provider <MockProvider>());
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.Equal(typeof(MockProvider), convention.DefinitionAccessor?.Provider);
}
public void Merge_Should_Merge_ArgumentName()
{
// arrange
var convention = new MockSortConvention(x => x.ArgumentName("Foo"));
var extension = new SortConventionExtension(x => x.ArgumentName("Bar"));
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.Equal("Bar", convention.DefinitionAccessor?.ArgumentName);
}
public void Merge_Should_Merge_Configurations()
{
// arrange
var convention = new MockSortConvention(
x => x.Configure <SortInputType <Foo> >(d => d.Name("Foo")));
var extension = new SortConventionExtension(
x => x.Configure <SortInputType <Bar> >(d => d.Name("Foo")));
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.NotNull(convention.DefinitionAccessor);
Assert.Equal(2, convention.DefinitionAccessor !.Configurations.Count);
}
public void Merge_Should_Merge_Bindings()
{
// arrange
var convention = new MockSortConvention(
x => x.BindRuntimeType <int, DefaultSortEnumType>());
var extension = new SortConventionExtension(
x => x.BindRuntimeType <double, DefaultSortEnumType>());
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.NotNull(convention.DefinitionAccessor);
Assert.Contains(typeof(int), convention.DefinitionAccessor !.Bindings);
Assert.Contains(typeof(double), convention.DefinitionAccessor !.Bindings);
}
public void Merge_Should_Merge_DefaultBinding()
{
// arrange
var convention = new MockSortConvention(
x => x.DefaultBinding <DefaultSortEnumType>());
var extension = new SortConventionExtension(
x => x.DefaultBinding <MockSortEnumType>());
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.Equal(
typeof(MockSortEnumType),
convention.DefinitionAccessor?.DefaultBinding);
}
