public void TestSql_Insert_Query() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var orders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = orders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); Order order2 = new Order { OrderName = "Test2" }; db.Insert(order2); Order order3 = new Order { OrderName = "Prod3" }; db.Insert(order3); var orderItems = new List<OrderItem>(); var results = (from o in db.Query<Order>() where o.OrderName == "Test1" orderby o.OrderName select o).ToList(); Assert.IsTrue(results.Count == 1); Assert.AreEqual(results[0].OrderName, "Test1"); var results2 = (from o in db.Query<Order>() where o.OrderName.StartsWith("Test") select o).ToList(); Assert.IsTrue(results2.Count == 2); Assert.AreEqual(results2[0].OrderName, "Test1"); Assert.AreEqual(results2[1].OrderName, "Test2"); } catch { throw; } finally { db.RollBack(); } } }
public void IQueryableShouldFilterAndSortDesc() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); Order order2 = new Order { OrderName = "Test2" }; db.Insert(order2); Order order3 = new Order { OrderName = "Test3" }; db.Insert(order3); var orders = db.Queryable<Order>() .Where(o => o.OrderName == "Test1" || o.OrderName == "Test2") .OrderByDescending(o => o.OrderName) .ToArray(); Assert.AreEqual(2, orders.Length); var o1 = orders[0]; var o2 = orders[1]; Assert.AreEqual(o1.OrderName, "Test2"); Assert.AreEqual(o2.OrderName, "Test1"); } catch { throw; } finally { db.RollBack(); } } }
public void Test_Complex_Paging_WithJoins_WithWhereClause_WithMultipleOrderClauses() { using (var db = CreateSqlServerDB()) { try { db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>() .Entity(order) .GetIdentity() .Execute(); OrderItem orderItem1 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc1", Price = 5.5m }; OrderItem orderItem2 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc2", Price = 6.6m }; db.Insert(orderItem1); db.Insert(orderItem2); } // Get page 1 with 2 records var page1 = db.Query<Order>() .Join<Order, OrderItem>(JoinType.Left, o => o.OrderItems, (o, oi) => o.ID == oi.OrderID) .Where(o => o.OrderName == "Order09") .OrderBy(o => o.OrderName) .ThenByDescending(o => o.ID) .Page(1, 2) .ToList(); Assert.AreEqual(1, page1.Count, "Page size should be 1."); Assert.AreEqual("Order09", page1[0].OrderName); Assert.AreEqual(2, page1[0].OrderItems.Count); } catch { throw; } finally { db.RollBack(); } } }
public void Test_Complex_Paging_WithJoins() { using (var db = CreateSqlServerDB()) { try { db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>() .Entity(order) .GetIdentity() .Execute(); OrderItem orderItem1 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc1", Price = 5.5m }; OrderItem orderItem2 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc2", Price = 6.6m }; db.Insert(orderItem1); db.Insert(orderItem2); } string query1 = db.Query<Order>() .Join<Order, OrderItem>(JoinType.Left, o => o.OrderItems, (o, oi) => o.ID == oi.OrderID) .OrderBy(o => o.OrderName) .Page(1, 2) .BuildQuery(); Assert.IsNotNull(query1); // Get page 1 with 2 records var page1 = db.Query<Order>() .Join<Order, OrderItem>(JoinType.Left, o => o.OrderItems, (o,oi) => o.ID == oi.OrderID) .OrderBy(o => o.OrderName) .Page(1, 2) .ToList(); Assert.AreEqual(2, page1.Count, "Page size should be 2."); Assert.AreEqual("Order01", page1[0].OrderName); Assert.AreEqual("Order02", page1[1].OrderName); Assert.AreEqual(2, page1[0].OrderItems.Count); // Get page 1 with 2 records var page2 = db.Query<Order>() .Join<Order, OrderItem>(JoinType.Left, o => o.OrderItems, (o, oi) => o.ID == oi.OrderID) .OrderBy(o => o.OrderName) .Page(2, 2) .ToList(); Assert.AreEqual(2, page2.Count, "Page size should be 2."); Assert.AreEqual("Order03", page2[0].OrderName); Assert.AreEqual("Order04", page2[1].OrderName); Assert.AreEqual(2, page2[0].OrderItems.Count); } catch (Exception ex) { throw; } finally { db.RollBack(); } } }
public void Test_Simple_Paging_WithNoJoins_WithMultipleOrderByClauses() { using (var db = CreateSqlServerDB()) { try { db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>(order); } // Get page 1 with up to 2 records var page1 = db.Query<Order>() .Where(o => o.OrderName == "Order09") .OrderBy(o => o.OrderName) .ThenByDescending(o => o.ID) .Page(1, 2) .ToList(); Assert.AreEqual(1, page1.Count, "Page should only have one record."); Assert.AreEqual("Order09", page1[0].OrderName); } catch { throw; } finally { db.RollBack(); } } }
public void Test_Simple_Paging_WithNoJoins() { using (var db = CreateSqlServerDB()) { try { db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>(order); } // Get page 1 with 2 records var page1 = db.Query<Order>() .OrderBy(o => o.OrderName) .Page(1, 2) .ToList(); Assert.AreEqual(2, page1.Count, "Page size should be 2."); Assert.AreEqual("Order01", page1[0].OrderName); Assert.AreEqual("Order02", page1[1].OrderName); // Get page 1 with 2 records var page2 = db.Query<Order>() .OrderBy(o => o.OrderName) .Page(2, 2) .ToList(); Assert.AreEqual(2, page2.Count, "Page size should be 2."); Assert.AreEqual("Order03", page2[0].OrderName); Assert.AreEqual("Order04", page2[1].OrderName); } catch (Exception ex) { throw; } finally { db.RollBack(); } } }
public void IQueryableShouldHandlePaging() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); Order order2 = new Order { OrderName = "Test2" }; db.Insert(order2); Order order3 = new Order { OrderName = "Test3" }; db.Insert(order3); var orders = db.Queryable<Order>() .Where(o => o.OrderName.StartsWith("Test")) .Skip(1) .Take(1) .OrderBy(o => o.OrderName) .ToArray(); Assert.AreEqual(1, orders.Length); var o1 = orders[0]; Assert.AreEqual(o1.OrderName, "Test2"); } catch { throw; } finally { db.RollBack(); } } }
public void Test_Filtering_ChildrenToload_With_Graph() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>() .Entity(order) .GetIdentity() .Execute(); OrderItem orderItem1 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc1", Price = 5.5m }; OrderItem orderItem2 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc2", Price = 6.6m }; db.Insert<OrderItem>(orderItem1); db.Insert<OrderItem>(orderItem2); Receipt receipt1 = new Receipt { OrderItemID = orderItem1.ID, AmountPaid = orderItem1.Price }; Receipt receipt2 = new Receipt { OrderItemID = orderItem2.ID, AmountPaid = orderItem2.Price }; db.Insert<Receipt>(receipt1); db.Insert<Receipt>(receipt2); } // Try to get entire graph, including orderitems and receipts var orders = db.Query<Order>().FromView("V_OrdersReceipts").Graph(o => o.OrderItems, o => o.OrderItems.First().ItemReceipt).ToList(); Assert.IsTrue(orders.Count > 0); Assert.IsNotNull(orders[0].OrderItems); Assert.IsNotNull(orders[0].OrderItems[0].ItemReceipt); // Try to get filtered graph without receipt var orders2 = db.Query<Order>().FromView("V_OrdersReceipts").Graph(o => o.OrderItems).ToList(); Assert.IsTrue(orders2.Count > 0); Assert.IsNotNull(orders2[0].OrderItems); Assert.IsNull(orders2[0].OrderItems[0].ItemReceipt); } catch { throw; } finally { db.RollBack(); } } }
public void IQueryable_ShouldReturnTwoLevelsIfBaseQueryIsProvided() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); OrderItem orderItem1 = new OrderItem { ItemDescription = "Desc", OrderID = order1.ID, Price = 5.5m }; db.Insert(orderItem1); var baseQuery = db.Query<Order>(); baseQuery.Join<Order, OrderItem>(QGen.JoinType.Inner, o => o.OrderItems, (o, oi) => o.ID == oi.OrderID); IQueryable<Order> ctx = db.Queryable<Order>(baseQuery); var order = ctx .Where(o => o.OrderName == "Test1") .FirstOrDefault(); Assert.IsNotNull(order); Assert.AreEqual(1, order.OrderItems.Count); } catch { throw; } finally { db.RollBack(); } } }
public void IQueryable_ShouldThrowUnsupportedExceptionIfTheyIncludeAFunctionInTheWhereClause() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); // Bury the order within another object to ensure that the expression visitor can parse out the OrderName var nestedPropertyObj = new NestedPropertyObject { Order = new Order { OrderName = "Test1" } }; var order = db.Queryable<Order>() .Where(o => o.OrderName == nestedPropertyObj.GetOrder().OrderName) .FirstOrDefault(); Assert.IsNotNull(order); Assert.AreEqual("Test1", order.OrderName); } catch { throw; } finally { db.RollBack(); } } }
public void IQueryable_ShouldOnlyReturnRootLevelByDefault() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); OrderItem orderItem1 = new OrderItem { ItemDescription = "Desc", OrderID = order1.ID, Price = 5.5m }; db.Insert(orderItem1); IQueryable<Order> ctx = db.Queryable<Order>(); var order = ctx .Where(o => o.OrderName == "Test1") .FirstOrDefault(); Assert.IsNotNull(order); Assert.IsNull(order.OrderItems, "No order items should have been queried because no Graph settings were specified via a base query."); } catch { throw; } finally { db.RollBack(); } } }
public void IQueryable_FirstOrDefault_ShouldReturnOneResult() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); Order order2 = new Order { OrderName = "Test2" }; db.Insert(order2); Order order3 = new Order { OrderName = "Test3" }; db.Insert(order3); var order = db.Queryable<Order>() .Where(o => o.OrderName == "Test2") .FirstOrDefault(); Assert.IsNotNull(order); Assert.AreEqual("Test2", order.OrderName); } catch { throw; } finally { db.RollBack(); } } }
public void IQueryable_First_WithNoResult_ShouldThrowException() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); Order order2 = new Order { OrderName = "Test2" }; db.Insert(order2); Order order3 = new Order { OrderName = "Test3" }; db.Insert(order3); var order = db.Queryable<Order>() .Where(o => o.OrderName == "does not exist") .First(); } catch { throw; } finally { db.RollBack(); } } }
public void IQueryableShouldHandlePagingWithNoWhereAndNonConstantValues() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "Test1" }; db.Insert(order1); Order order2 = new Order { OrderName = "Test2" }; db.Insert(order2); Order order3 = new Order { OrderName = "Test3" }; db.Insert(order3); var kvp = new KeyValuePair<int, int>(1, 1); Func<int> getOne = () => 1 * 1; var orders = db.Queryable<Order>() .OrderBy(o => o.OrderName) .Skip(kvp.Value) .Take(getOne()) .ToArray(); Assert.AreEqual(1, orders.Length); var o1 = orders[0]; Assert.AreEqual(o1.OrderName, "Test2"); } catch { throw; } finally { db.RollBack(); } } }
public void Test_Paging_With_View() { using (var db = CreateSqlServerDB()) { try { db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>() .Entity(order) .GetIdentity() .Execute(); Assert.IsTrue(order.ID > 0, "Identity value should have been returned."); OrderItem orderItem1 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc1", Price = 5.5m }; OrderItem orderItem2 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc2", Price = 6.6m }; db.Insert(orderItem1); db.Insert(orderItem2); } db.SqlMode = SqlModes.Text; // Get page 1 with up to 2 records var page1 = db.Query<Order>() .FromView("V_Orders") .Graph(o => o.OrderItems) .OrderBy(o => o.OrderName) .Page(1, 2) .ToList(); Assert.AreEqual(2, page1.Count, "Page should have two records."); Assert.AreEqual(2, page1[0].OrderItems.Count); Assert.AreEqual(2, page1[1].OrderItems.Count); } catch { throw; } finally { db.RollBack(); } } }
public void Test_GetRowCount() { using (var db = CreateSqlServerDB()) { try { db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>(order); } // Row count without a where statement var orders = db.Query<Order>().ToList(); Assert.IsTrue(orders.Count == 10); int count = db.Query<Order>().GetRowCount(); Assert.AreEqual(orders.Count, count); // Row count with a where statement var filteredOrders = db.Query<Order>().Where(o => o.OrderName == "Order03").ToList(); int filteredCount = db.Query<Order>().Where(o => o.OrderName == "Order03").GetRowCount(); Assert.AreEqual(filteredOrders.Count, filteredCount); // Row count with paged results var pagedOrders = db.Query<Order>() .Page(1, 2) .OrderBy(o => o.OrderName) .ToList(); Assert.AreEqual(2, pagedOrders.Count); int totalCount = db.Query<Order>().GetRowCount(); Assert.IsTrue(totalCount > pagedOrders.Count); } catch { throw; } finally { db.RollBack(); } } }
public void Test_Linq_Clauses_Mixed_With_FromView() { using (var db = CreateSqlServerDB()) { try { db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>(order); Assert.IsTrue(order.ID > 0, "Identity value should have been returned."); OrderItem orderItem1 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc1", Price = 5.5m }; OrderItem orderItem2 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc2", Price = 6.6m }; db.Insert(orderItem1); db.Insert(orderItem2); } db.SqlMode = SqlModes.Text; var orders = db.Query<Order>() .Graph(o => o.OrderItems) .FromView("V_Orders") .Where<OrderItem>(oi => oi.Price > 6m) .ToList(); Assert.IsTrue(orders.Count > 0); var orderItems = db.Query<OrderItem>() .FromView("V_Orders") .Where(oi => oi.Price > 6) .OrWhere(oi => oi.Price > 6.1m) // Test using OrWhere method in the SortBuilder .ToList(); Assert.IsTrue(orderItems.Count > 0); } catch { throw; } finally { db.RollBack(); } } }
public void Test_GetRowCount_WithTableJoins() { using (var db = CreateSqlServerDB()) { try { db.BeginTransaction(); // Insert 10 orders for (int i = 1; i < 11; i++) { Order order = new Order { OrderName = "Order" + (i.ToString().PadLeft(2, '0')) }; db.Insert<Order>(order); Assert.IsTrue(order.ID > 0, "Identity value should have been returned."); OrderItem orderItem1 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc1", Price = 5.5m }; OrderItem orderItem2 = new OrderItem { OrderID = order.ID, ItemDescription = "Desc2", Price = 6.6m }; db.Insert(orderItem1); db.Insert(orderItem2); } // First verify that there are 20 order item records var orderItems = db.Query<OrderItem>() .FromView("V_Orders") .ToList(); Assert.AreEqual(20, orderItems.Count); // Row count with a join var orders = db.Query<Order>() .Join<Order, OrderItem>(JoinType.Left, o => o.OrderItems, (o, oi) => o.ID == oi.OrderID) .ToList(); Assert.IsTrue(orders.Count == 10); int count = db.Query<Order>() .Join<Order, OrderItem>(JoinType.Left, o => o.OrderItems, (o, oi) => o.ID == oi.OrderID) .GetRowCount(); Assert.AreEqual(orders.Count, count); // Rowcount from a view var orders2 = db.Query<Order>() .FromView("V_Orders") .Graph(o => o.OrderItems) .ToList(); Assert.IsTrue(orders2.Count == 10); int count2 = db.Query<Order>() .FromView("V_Orders") .Graph(o => o.OrderItems) .GetRowCount(); Assert.AreEqual(orders2.Count, count2); } catch { throw; } finally { db.RollBack(); } } }
public void TestJoin() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); // Insert a new order Order newOrder = new Order(); newOrder.OrderName = "new order"; int orderID = Convert.ToInt32(db.Insert<Order>().Entity(newOrder).GetIdentity().Execute()); Assert.IsTrue(orderID > 0); // Update order name to use the generated ID autoincremented value newOrder.OrderName = string.Concat(newOrder.OrderName, " ", newOrder.ID); db.Update<Order>(newOrder, o => o.ID == newOrder.ID); // Add an order item associated to the newly added order OrderItem orderItem = new OrderItem { OrderID = newOrder.ID, ItemDescription = "Test item", Price = 5.5m }; int orderItemID = Convert.ToInt32(db.Insert<OrderItem>().Entity(orderItem).GetIdentity().Execute()); Assert.IsTrue(orderItemID > 0); // Add a receipt associated to the new ordeer / order item Receipt receipt = new Receipt { OrderItemID = orderItem.ID, AmountPaid = 5.5m }; db.Insert<Receipt>(receipt); // Query the newly added order with its order item (do not query receipt) var orderWithItem = db.Query<Order>() .Join<Order, OrderItem>(JoinType.Left, o => o.OrderItems, (o, oi) => o.ID == oi.OrderID) .Where(o => o.ID == newOrder.ID) .FirstOrDefault(); // Query the newly added order with associated order item and receipt var orderWithItemAndReceipt = db.Query<Order>() .Join<Order, OrderItem>(JoinType.Left, o => o.OrderItems, (o, oi) => o.ID == oi.OrderID) .Join<OrderItem, Receipt>(JoinType.Left, oi => oi.ItemReceipt, (oi, r) => oi.ID == r.OrderItemID) .Where(o => o.ID == newOrder.ID).FirstOrDefault(); Assert.IsNotNull(orderWithItem); Assert.IsTrue(orderWithItem.OrderItems.Count == 1); Assert.IsNull(orderWithItem.OrderItems[0].ItemReceipt); Assert.IsNotNull(orderWithItemAndReceipt.OrderItems[0].ItemReceipt); // Delete all added items db.Delete<Order>(o => o.ID == orderID); db.Delete<OrderItem>(oi => oi.ID == orderItemID); db.Delete<Receipt>(r => r.OrderItemID == orderItemID); // Verify items are deleted var receipts = db.Query<Receipt>().Where(r => r.OrderItemID == orderItemID).ToList(); Assert.IsTrue(receipts.Count == 0); var orderItems = db.Query<OrderItem>().Where(oi => oi.ID == orderItemID).ToList(); Assert.IsTrue(orderItems.Count == 0); var orders = db.Query<Order>().Where(o => o.ID == orderID).ToList(); Assert.IsTrue(orders.Count == 0); } catch { throw; } finally { db.RollBack(); } } }
public void IQueryableShouldHandleFilterWithTwoSorts() { using (var db = CreateSqlServerDB()) { try { db.SqlMode = SqlModes.Text; db.BeginTransaction(); // Clear out any existing records var existingOrders = db.Query<Order>().Where(o => o.ID > 0).ToList(); int count = existingOrders.Count; db.Delete<Order>(o => o.ID > 0); Order order1 = new Order { OrderName = "GroupA" }; db.Insert<Order>(order1); Order order2 = new Order { OrderName = "GroupB" }; db.Insert<Order>(order2); Order order3 = new Order { OrderName = "GroupA" }; db.Insert<Order>(order3); Order order4 = new Order { OrderName = "Test" }; db.Insert<Order>(order4); var orders = db.Queryable<Order>() .Where(o => o.OrderName.StartsWith("Group")) .OrderBy(o => o.OrderName) .ThenByDescending(o => o.ID) .ToArray(); // Test where clause Assert.AreEqual(3, orders.Length); var r1 = orders[0]; var r2 = orders[1]; var r3 = orders[2]; // Test primary sort Assert.AreEqual(r1.OrderName, "GroupA"); Assert.AreEqual(r2.OrderName, "GroupA"); Assert.AreEqual(r3.OrderName, "GroupB"); // Test secondary sort Assert.AreEqual(order3.ID, r1.ID); Assert.AreEqual(order1.ID, r2.ID); Assert.AreEqual(order2.ID, r3.ID); } catch { throw; } finally { db.RollBack(); } } }