public void SimpleFilterCaseInsensitive()
{
MockContextFactory.SeedAndTestContextFor("FilterTests_SimpleFilterCaseInsensitive", TestSeeders.SimpleSeedScenario, ctx =>
{
var resultShouldMatch = ctx.Items.Where(t => t.Name.ToLower().EndsWith("Cables".ToLower())).ToList();
var criteria = new QueryCriteria()
{
Filters = new List <IFilter>
{
new SimpleFilter
{
Path = "Name",
Type = FilterType.EndsWith,
Value = "Cables",
CaseInsensitive = true
}
}
};
var queryHandler = new QueryHandler(Enumerable.Empty <IQueryInterceptorProvider>());
var result = queryHandler.Execute(ctx.Items, criteria);
Assert.Equal(resultShouldMatch, result.Data);
});
}
public void TestItemTypUpdate()
{
var context = MockContextFactory.Create();
var testItem = new Database.Models.Itemtyp()
{
Id = 1,
Number = 1,
Title = "Hamburger",
Description = "Knuspriges Brot, belegt mit Käse, Speck und Hamburger",
ItemPrice = 24,
Category = Database.Models.Category.Normal,
Image = "Bild von Hamburger",
Priority = 2
};
context.Itemtyp.Add(testItem);
context.SaveChanges();
var service = new ItemTypeService(new MockDataService(context));
var result = service.GetItemTypes(0);
Assert.Equal("Hamburger", result.ElementAt(0).Title);
testItem.Title = "Veggiburger";
testItem.Description = "Knuspriges Brot, belegt mit Käse und Tofu";
testItem.Image = "Bild von Veggiburger";
Assert.False(result.ElementAt(0).Title == "Hamburger");
}
public void TestOnOrderAssignedWI()
{
var context = MockContextFactory.Create();
String fakeIdentifier = "Laptop";
var waiter = new Tablet()
{
Id = 2,
Identifier = "Karim",
Mode = Mode.Waiter
};
var testOrder = new Order()
{
Id = 1,
OrderStatus = OrderStatus.New,
CreationTime = new DateTime(2017, 2, 4, 17, 0, 0),
UpdateTime = new DateTime(2017, 2, 4, 17, 0, 0),
Waiter = waiter,
Guests = new List <Tablet>()
};
context.Tablet.Add(waiter);
context.Order.Add(testOrder);
context.SaveChanges();
var service = new AssignOrderService(new MockDataService(context));
var result = service.OnOrderAssigned(fakeIdentifier, testOrder.Id);
Assert.Equal(false, result);
}
public void TestGetItemTypeDetails()
{
var context = MockContextFactory.Create();
var testItem = new Database.Models.Itemtyp()
{
Id = 1,
Number = 1,
Title = "Hamburger",
Description = "Knuspriges Brot, belegt mit Käse, Speck und Hamburger",
ItemPrice = 24,
Category = Database.Models.Category.Normal,
Image = "Bild von Hamburger",
Priority = 2
};
context.Itemtyp.Add(testItem);
context.SaveChanges();
var service = new ItemTypeService(new MockDataService(context));
var result = service.GetItemTypes(0);
Assert.Equal(1, result.ElementAt(0).Id);
Assert.Equal(1, result.ElementAt(0).Number);
Assert.Equal("Hamburger", result.ElementAt(0).Title);
Assert.Equal("Knuspriges Brot, belegt mit Käse, Speck und Hamburger", result.ElementAt(0).Description);
Assert.Equal(24, result.ElementAt(0).ItemPrice);
Assert.Equal("Normal", result.ElementAt(0).Category.ToString());
Assert.Equal("Bild von Hamburger", result.ElementAt(0).Image);
Assert.Equal(2, result.ElementAt(0).Priority);
}
public void TestCreateOrder()
{
// Wieso schlägt dieser Test auf Zeile 18 fehlt???
var context = MockContextFactory.Create();
var table = new Table()
{
Id = 3,
Name = "albertus",
Orders = new List <Order>()
};
var waiter = new Tablet()
{
Id = 4,
Identifier = "brutus",
Mode = Mode.Waiter
};
context.Table.Add(table);
context.Tablet.Add(waiter);
context.SaveChanges();
var service = new OrderService(new MockDataService(context));
var result = service.CreateOrder(table.Id, waiter.Identifier);
Assert.Equal(OrderStatus.New, result.OrderStatus);
Assert.Equal(result.UpdateTime, result.CreationTime);
Assert.Equal(0, result.PriceOrder);
}
public void Multi()
{
MockContextFactory.SeedAndTestContextFor("FilterInterceptorTests_Multi", TestSeeders.SimpleSeedScenario, ctx =>
{
var queryable = ctx.Orders.AsQueryable();
var criteria = new QueryCriteria()
{
Filters = new List <IFilter>
{
new SimpleFilter {
Path = "CustomerFirstName", Value = "David", Type = FilterType.Contains
}
}
};
var query = new QueryHandler(Enumerable.Empty <IQueryInterceptorProvider>());
query.AddInterceptor(new MockFilterInterceptorA());
query.AddInterceptor(new MockFilterInterceptorB());
var result = query.Execute(queryable, criteria);
var actual = result.Data;
var expected = queryable.Where(t => t.Customer.LastName == "Norris").ToList();
Assert.Equal(expected, actual);
});
}
public void TestTabletHub()
{
var context = MockContextFactory.Create();
var tabletService = new TabletService(new MockDataService(context));
var request = new GetTabletsByModeRequest();
request.Mode = Database.Models.Mode.Waiter;
var command = new Command <GetTabletsByModeRequest>();
command.RequestId = "123";
command.Arguments = request;
var called = false;
var hub = new TabletHub(tabletService);
var responseType = "GetTabletsByModeResponse";
var action = new Action <Command <GetTabletsByModeResponse> >((response) =>
{
Assert.Equal(response.RequestId, command.RequestId);
Assert.NotNull(response.Arguments.Tablets);
called = true;
});
hub.Clients = MockHubFactory.CreateClients(responseType, action);
hub.GetTabletsByModeRequest(command);
Assert.True(called);
}
public void TestMenuUpdate()
{
var context = MockContextFactory.Create();
var testMenu = new Database.Models.Menu()
{
Id = 1,
Number = 1,
Name = "Sommermenü",
Description = "Feine Sommerspeisen",
};
context.Menu.Add(testMenu);
context.SaveChanges();
var service = new MenuService(new MockDataService(context));
var result = service.GetMenus();
Assert.Equal("Sommermenü", result.ElementAt(0).Name);
testMenu.Name = "Wintermenü";
testMenu.Description = "Feine Winterspeisen";
Assert.False(result.ElementAt(0).Name == "Sommermenü");
}
public void SimpleFilter()
{
MockContextFactory.SeedAndTestContextFor("AsyncTests_SimpleFilter", TestSeeders.SimpleSeedScenario, async ctx =>
{
var resultShouldMatch = ctx.Items.Where(t => t.Name.EndsWith("Cables")).ToList();
var criteria = new QueryCriteria()
{
Filters = new List <IFilter>
{
new SimpleFilter
{
Path = "Name",
Type = FilterType.EndsWith,
Value = "Cables"
}
}
};
var asyncService = new AsyncQueryableService(new[] { new AsyncQueryableHandlerService() });
var queryHandler = new QueryHandlerAsync(asyncService);
var result = await queryHandler.ExecuteAsync(ctx.Items, criteria);
Assert.Equal(resultShouldMatch, result.Data);
});
}
public void TestCollection()
{
var serviceProvider = DIService();
MockContextFactory.SeedAndTestContextFor("CriteriaTests_TestPagging", TestSeeders.SimpleSeedScenario, ctx =>
{
// var resultShouldMatch =
// ctx.Customers.Include(c => c.Orders); //OrderBy(t => t.Id).Skip(5).Take(5).ToList();
// query handler that is empty should be the same as running to list.
var criteria = new QueryCriteria();
criteria.Filters.AddRange(new List <IFilter>
{
// new SimpleFilter
// {
// Path = "RegisterTime",
// Value = "2018-10-1",
// Type = FilterType.GreaterThanOrEqual,
// And = true
// },
// new SimpleFilter
// {
// Path = "RegisterTime",
// Value = "2018-12-1",
// Type = FilterType.LessThanOrEqual,
// And = true
// },
new CompositeFilter()
{
And = true,
Type = FilterType.Composite,
Filters = new List <IFilter>
{
new SimpleFilter
{
And = true,
Path = "Orders.Date",
Value = "2018-01-03",
Type = FilterType.GreaterThanOrEqual
},
new SimpleFilter
{
And = true,
Path = "Orders.Date",
Value = "2018-01-04",
Type = FilterType.LessThanOrEqual
}
}
}
});
criteria.Sorts.Add(new Sort("Id"));
criteria.Page = 1;
criteria.PageSize = 15;
var queryHandler = serviceProvider.GetService <IQueryHandler>();
var result = queryHandler.Execute(ctx.Customers.Include(c => c.Orders), criteria);
var data = result.Data.Cast <Customer>().ToList();
});
}
public void Simple()
{
MockContextFactory.SeedAndTestContextFor("GroupInterceptorTests_Simple", TestSeeders.SimpleSeedScenario, ctx =>
{
var expected = ctx.Orders
.OrderBy(t => t.Customer.FirstName)
.GroupBy(t => t.Customer.FirstName)
.Select(t => t.Key)
.ToList();
var criteria = new QueryCriteria();
criteria.Groups.Add(new Group {
Path = "CustomerFirstName"
});
var queryHandler = new QueryHandler(Enumerable.Empty <IQueryInterceptorProvider>());
queryHandler.AddInterceptor(new MockGroupInterceptor());
var result = queryHandler.Execute(ctx.Orders.Include(t => t.Customer), criteria, new QueryExecutionOptions
{
GroupByInMemory = true
});
var groupedResult = result.GroupedResult();
var actual = groupedResult.Groups.Select(t => t.GroupValue).ToList();
Assert.Equal(expected, actual);
});
}
public void SetupTest()
{
// In-memory database only exists while the connection is open
_connection = new SqliteConnection("DataSource=:memory:");
_connection.Open();
try
{
var options = new DbContextOptionsBuilder <TodoDbContext>()
.UseSqlite(_connection)
.Options;
// Create the schema in the database
_context = new TodoDbContext(options);
DbInitializer.Initialize(_context);
_contextFactory = new MockContextFactory(_context);
}
catch (Exception)
{
_connection.Close();
_context = null;
_connection = null;
}
}
public void TestSubmenuUpdate()
{
var context = MockContextFactory.Create();
var testSubmenu = new Database.Models.Submenu()
{
Id = 1,
Number = 1,
Name = "Vorspeisen",
Description = "Vorspeisen"
};
context.Submenu.Add(testSubmenu);
context.SaveChanges();
var service = new SubmenuService(new MockDataService(context));
var result = service.GetSubmenus(0);
Assert.Equal("Vorspeisen", result.ElementAt(0).Name);
testSubmenu.Name = "Hauptspeisen";
testSubmenu.Description = "Hauptspeisen";
Assert.False(result.ElementAt(0).Name == "Vorspeisen");
}
public void InterceptorsWithGrouping()
{
MockContextFactory.SeedAndTestContextFor("GroupTests_InterceptorsWithGrouping", TestSeeders.SeedTicketScenario, ctx =>
{
var criteria = new QueryCriteria()
{
Groups = new List <IGroup>()
{
new Group {
Path = "TicketType"
}
},
Aggregates = new List <IAggregate>()
{
new Aggregate {
Type = AggregateType.Count
}
}
};
var interceptor = new InterceptorsWithGrouping();
var queryHandler = new QueryHandler(Enumerable.Empty <IQueryInterceptorProvider>());
queryHandler.AddInterceptor(interceptor);
var result = queryHandler.Execute <Ticket, InterceptorWithGroupingFakeModel>(ctx.Tickets, criteria, new QueryExecutionOptions
{
GroupByInMemory = true
});
Assert.Equal(4, interceptor.Count);
Assert.True(interceptor.Test);
Assert.True(interceptor.Test2);
Assert.True(interceptor.Test3);
Assert.True(interceptor.Test4);
});
}
public void CompositeFilter()
{
MockContextFactory.SeedAndTestContextFor("FilterTests_CompositeFilter", TestSeeders.SimpleSeedScenario, ctx =>
{
var resultShouldMatch = ctx.Customers.Where(t => t.FirstName == "John" || t.LastName == "Norris").ToList();
var criteria = new QueryCriteria()
{
Filters = new List <IFilter>
{
new CompositeFilter()
{
Type = FilterType.Composite,
Filters = new List <IFilter>
{
new SimpleFilter()
{
Path = "FirstName", Type = FilterType.Equal, Value = "John"
},
new SimpleFilter()
{
Path = "LastName", Type = FilterType.Equal, Value = "Norris"
}
}
}
}
};
var queryHandler = new QueryHandler(Enumerable.Empty <IQueryInterceptorProvider>());
var result = queryHandler.Execute(ctx.Customers, criteria);
Assert.Equal(resultShouldMatch, result.Data);
});
}
public void TestDoChangeOrderStatus()
{
var context = MockContextFactory.Create();
var tablet = new Tablet()
{
Id = 5,
Identifier = "Eugen",
Mode = Mode.Waiter
};
var table = new Table()
{
Id = 5,
Name = "TestTisch"
};
var order4 = new Order
{
Id = 2,
OrderStatus = OrderStatus.New,
PriceOrder = 3,
TableId = 7,
Waiter = tablet,
Table = table
};
context.Order.Add(order4);
context.SaveChanges();
var service = new OrderService(new MockDataService(context));
var result = service.DoChangeOrderStatus(2, OrderStatus.Done);
Assert.Equal(OrderStatus.Done, result.OrderStatus);
}
public void SimpleWithExtensions()
{
MockContextFactory.SeedAndTestContextFor("FilterInterceptorTests_SimpleWithExtensions", TestSeeders.SimpleSeedScenario, ctx =>
{
var queryable = ctx.Orders.AsQueryable();
var criteria = new QueryCriteria()
{
Filters = new List <IFilter>
{
new SimpleFilter {
Path = "CustomerFirstName", Value = "David", Type = FilterType.Contains
}
}
};
var query = new QueryHandler();
query.AddInterceptor(new MockFilterInterceptorAWithExtension());
var result = query.Execute(queryable, criteria);
var actual = result.Data.Cast <Order>().ToList();
var expected = queryable.Where(t => t.Customer.FirstName == "David").ToList();
Assert.Equal(expected, actual);
});
}
public void TearDownTest()
{
_context?.Dispose();
_connection?.Close();
_context = null;
_connection = null;
_contextFactory = null;
}
public void TestItemTypeCount()
{
var context = MockContextFactory.Create();
var testItem1 = new Database.Models.Itemtyp()
{
Id = 1,
Number = 1,
Title = "Hamburger",
Description = "Knuspriges Brot, belegt mit Käse, Speck und Hamburger",
ItemPrice = 24,
Category = Database.Models.Category.Normal,
Image = "Bild von Hamburger",
Priority = 2
};
var testItem2 = new Database.Models.Itemtyp()
{
Id = 2,
Number = 2,
Title = "Toast Hawai",
Description = "Knuspriges Toast, garniert mit Schinken und Ananas",
ItemPrice = 10,
Category = Database.Models.Category.Normal,
Image = "Bild von Toast",
Priority = 2
};
var testItem3 = new Database.Models.Itemtyp()
{
Id = 3,
Number = 3,
Title = "Spaghetti Pesto",
Description = "Spaghetti al Dente mit hauseigener Pestosauce",
ItemPrice = 20,
Category = Database.Models.Category.Vegi,
Image = "Bild von Spaghetti",
Priority = 2
};
context.Itemtyp.Add(testItem1);
context.Itemtyp.Add(testItem2);
context.Itemtyp.Add(testItem3);
context.SaveChanges();
var service = new ItemTypeService(new MockDataService(context));
var result = service.GetItemTypes(0);
Assert.Equal(3, result.Count());
context.Itemtyp.Remove(testItem1);
context.SaveChanges();
result = service.GetItemTypes(0);
Assert.Equal(2, result.Count());
}
public void TestGetOrdersByWaiter()
{
var context = MockContextFactory.Create();
var waiter = new Tablet
{
Id = 3,
Identifier = "Georg",
Mode = Mode.Waiter
};
var tableAlpha = new Table()
{
Id = 6,
Name = "Test"
};
var tableBeta = new Table()
{
Id = 9,
Name = "TestB"
};
var order1 = new Order
{
Id = 4,
OrderStatus = OrderStatus.New,
PriceOrder = 0,
Table = tableAlpha,
TableId = 6,
Waiter = waiter
};
var order2 = new Order
{
Id = 8,
OrderStatus = OrderStatus.Active,
PriceOrder = 2,
Table = tableBeta,
TableId = 9,
Waiter = waiter
};
context.Tablet.Add(waiter);
context.Order.Add(order1);
context.Order.Add(order2);
context.SaveChanges();
var service = new OrderService(new MockDataService(context));
var result = service.GetOrdersByWaiter("Georg");
Assert.NotNull(result);
Assert.Equal(order2.PriceOrder, result.FirstOrDefault(t => t.OrderStatus == OrderStatus.Active).PriceOrder);
Assert.Equal(order1.PriceOrder, result.FirstOrDefault(t => t.OrderStatus == OrderStatus.New).PriceOrder);
}
public void Generic()
{
MockContextFactory.SeedAndTestContextFor("ConvertibleIntereceptorTests_Generic", TestSeeders.SimpleSeedScenario, ctx =>
{
var criteria = new QueryCriteria();
var queryHandler = new QueryHandler();
queryHandler.AddInterceptor(new MockQueryConvertGenericInterceptor());
var result = queryHandler.Execute <Customer, CustomerModel>(ctx.Customers, criteria);
Assert.All(result.Data, t => Assert.IsType <CustomerModel>(t));
});
}
public void NonGeneric()
{
MockContextFactory.SeedAndTestContextFor("QueryConvertInterceptorTests_NonGeneric", TestSeeders.SimpleSeedScenario, ctx =>
{
var criteria = new QueryCriteria();
var queryHandler = new QueryHandler();
queryHandler.AddInterceptor(new MockQueryConvertInterceptor());
var result = queryHandler.Execute(ctx.Customers, criteria);
Assert.All(result.Data.Cast <Customer>().ToList(), t => Assert.IsType <CustomerModel>(t));
});
}
public void TestMenuCount()
{
var context = MockContextFactory.Create();
var testMenu1 = new Database.Models.Menu()
{
Id = 1,
Number = 1,
Name = "Wintermenü",
Description = "Feine Winterspeisen",
};
var testMenu2 = new Database.Models.Menu()
{
Id = 2,
Number = 2,
Name = "Frühlingsmenü",
Description = "Feine Frühlingsspeisen",
};
var testMenu3 = new Database.Models.Menu()
{
Id = 3,
Number = 3,
Name = "Sommermenü",
Description = "Feine Sommerspeisen",
};
var testMenu4 = new Database.Models.Menu()
{
Id = 4,
Number = 4,
Name = "Herbstmenü",
Description = "Feine Herbstspeisen",
};
context.Menu.Add(testMenu1);
context.Menu.Add(testMenu2);
context.Menu.Add(testMenu3);
context.Menu.Add(testMenu4);
context.SaveChanges();
var service = new MenuService(new MockDataService(context));
var result = service.GetMenus();
Assert.Equal(4, result.Count());
context.Menu.Remove(testMenu1);
context.SaveChanges();
result = service.GetMenus();
Assert.Equal(3, result.Count());
}
public void Simple()
{
MockContextFactory.SeedAndTestContextFor("DbContextFactoryPrimaryKeyTests_Simple", TestSeeders.SimpleSeedScenario, ctx =>
{
var sw = new Stopwatch();
sw.Start();
var factory = new DbContextFactory(ctx);
var keys = factory.GetKeyProperties(typeof(Order));
Assert.Single <PropertyInfo>(keys, t => t.Name == "Id");
sw.Stop();
output.WriteLine($"Stop Watch of success took: {sw.Elapsed}");
});
}
public void TestOrderHub()
{
var context = MockContextFactory.Create();
var getTablesService = new TableService(new MockDataService(context));
var orderService = new OrderService(new MockDataService(context));
var orderPosService = new OrderPosService(new MockDataService(context), orderService);
var assignOrderService = new AssignOrderService(new MockDataService(context));
var tabletService = new TabletService(new MockDataService(context));
context.Table.Add(new Database.Models.Table
{
Id = 12,
Name = "Hera",
});
context.Tablet.Add(new Database.Models.Tablet
{
Id = 7,
Identifier = "Mira",
Mode = Database.Models.Mode.Guest
});
context.SaveChanges();
var request = new CreateOrderRequest();
request.TableId = 12;
request.TabletIdentifier = "Mira";
var command = new Command <CreateOrderRequest>();
command.RequestId = "123";
command.Arguments = request;
var called = false;
var hub = new OrderHub(getTablesService, orderService, orderPosService, assignOrderService, tabletService);
var responseType = "CreateOrderResponse";
var action = new Action <Command <CreateOrderResponse> >((response) =>
{
Assert.Equal(response.RequestId, command.RequestId);
Assert.NotNull(response.Arguments.Order);
called = true;
});
hub.Clients = MockHubFactory.CreateClients(responseType, action);
hub.CreateOrderRequest(command);
Assert.True(called);
}
public void TestEmptyCriteria()
{
MockContextFactory.SeedAndTestContextFor("CriteriaTests_TestEmptyCriteria", TestSeeders.SimpleSeedScenario, ctx =>
{
var resultShouldMatch = ctx.Items.ToList();
var queryable = ctx.Items.AsQueryable();
// query handler that is empty should be the same as running to list.
var criteria = new QueryCriteria();
var queryHandler = new QueryHandler();
var result = queryHandler.Execute(queryable, criteria);
Assert.Equal(resultShouldMatch, result.Data);
});
}
public void Simple()
{
MockContextFactory.SeedAndTestContextFor("QueryProviderTests_Simple", TestSeeders.SimpleSeedScenario, ctx =>
{
// criteria
var criteria = new QueryCriteria();
var queryHandler = new QueryHandler(new List <IQueryInterceptorProvider> {
new QueryInterceptorProvider()
});
queryHandler.AddInterceptor(new FakeInterceptor());
var interceptors = queryHandler.ResolveInterceptors <Order, Order>(criteria, ctx.Orders);
Assert.Equal(1, interceptors.Count);
Assert.True(interceptors[0].GetType() == typeof(FakeInterceptor));
});
}
public void TestEmptyCriteria()
{
MockContextFactory.SeedAndTestContextFor("AsyncTests_TestEmptyCriteria", TestSeeders.SimpleSeedScenario, async ctx =>
{
var resultShouldMatch = ctx.Items.ToList();
var queryable = ctx.Items.AsQueryable();
// query handler that is empty should be the same as running to list.
var aqf = new AsyncQueryableService(new[] { new AsyncQueryableHandlerService() });
var criteria = new QueryCriteria();
var queryHandler = new QueryHandlerAsync(aqf);
var result = await queryHandler.ExecuteAsync(queryable, criteria);
Assert.Equal(resultShouldMatch, result.Data);
});
}
public void Simple()
{
MockContextFactory.SeedAndTestContextFor("GroupTests_Simple", TestSeeders.SimpleSeedScenario, ctx =>
{
var shouldResult = ctx.Orders
.OrderBy(t => t.CustomerId)
.ToList()
.GroupBy(t => t.CustomerId)
.Select(t => new
{
CustomerId = t.Key,
Orders = t.ToList()
})
.ToList();
// query handler that is empty should be the same as running to list.
var criteria = new QueryCriteria()
{
Groups = new List <IGroup>
{
new Group {
Path = "CustomerId"
}
}
};
var queryHandler = new QueryHandler(Enumerable.Empty <IQueryInterceptorProvider>());
var result = queryHandler.Execute(ctx.Orders, criteria, new QueryExecutionOptions
{
GroupByInMemory = true,
GroupByInMemoryNullCheck = false
});
var groupedResult = result.GroupedResult();
// top level should have same amount of group levels.
Assert.Equal(groupedResult.Groups.Count, shouldResult.Count);
for (var i = 0; i < shouldResult.Count; i++)
{
var expected = shouldResult[0];
var actual = groupedResult.Groups[0];
Assert.Equal(expected.CustomerId, actual.GroupValue);
var expectedOrderIds = expected.Orders.Select(t => t.Id).ToList();
var actualOrderIds = actual.Data.Cast <Order>().Select(t => t.Id).ToList();
Assert.Equal(expectedOrderIds, actualOrderIds);
}
});
}
public void Simple()
{
MockContextFactory.SeedAndTestContextFor("SortInterceptorTests_Simple", TestSeeders.SimpleSeedScenario, ctx =>
{
// expected
var expected = ctx.Orders.OrderBy(t => t.Customer.FirstName).ThenBy(t => t.Customer.LastName).ToList();
// criteria
var criteria = new QueryCriteria();
criteria.Sorts.Add(new Sort("CustomerFullName"));
var queryHandler = new QueryHandler();
queryHandler.AddInterceptor(new MockSortInterceptor());
var result = queryHandler.Execute(ctx.Orders, criteria);
Assert.Equal(expected, result.Data.Cast <Order>().ToList());
});
}
