public void OrderBySubMemberTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
IDbCommand mockCommand = mocks.NewMock<IDbCommand>();
IDataReader mockReader = mocks.NewMock<IDataReader>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(mockCommand));
Expect.Once.On(mockCommand)
.SetProperty("CommandText").To("SELECT DISTINCT products.id AS product_id, products.name AS product_name, suppliers.id AS supplier_id, suppliers.name AS supplier_name FROM products JOIN suppliers ON products.main_supplier = suppliers.id ORDER BY ModifierFunction(supplier_name);");
Expect.Once.On(mockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(false));
Expect.Once.On(mockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
SQLBuilder builder = new MySQLBuilder();
builder.AddSelectTypeClause("products", typeof(Product));
builder.AddSelectTypeClause("suppliers", typeof(Supplier));
builder.AddFromClause("products");
builder.AddJoinClause("JOIN", "suppliers", "products.main_supplier = suppliers.id");
LazyDBQueryProvider<Product> provider = new LazyDBQueryProvider<Product>(() => mockConnection, builder, new Dictionary<string, object>());
Query<Product> myQuery = new Query<Product>(provider);
var orderedResults = from x in myQuery
orderby x.MainSupplier.Name
select x;
List<Product> resultsList = orderedResults.ToList();
mocks.VerifyAllExpectationsHaveBeenMet();
}
public void OrderByWithModifierTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
IDbCommand mockCommand = mocks.NewMock<IDbCommand>();
IDataReader mockReader = mocks.NewMock<IDataReader>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(mockCommand));
Expect.Once.On(mockCommand)
.SetProperty("CommandText").To("SELECT DISTINCT suppliers.id AS supplier_id, suppliers.name AS supplier_name FROM suppliers ORDER BY ModifierFunction(supplier_name);");
Expect.Once.On(mockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(true));
Expect.Once.On(mockReader)
.Get["supplier_id"]
.Will(Return.Value("0"));
Expect.Once.On(mockReader)
.Get["supplier_name"]
.Will(Return.Value("Alice & Co."));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(false));
Expect.Once.On(mockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
SQLBuilder sqlBuilder = new MySQLBuilder();
sqlBuilder.AddSelectTypeClause("suppliers", typeof(Supplier));
sqlBuilder.AddFromClause("suppliers");
LazyDBQueryProvider<Supplier> provider = new LazyDBQueryProvider<Supplier>(() => mockConnection, sqlBuilder, new Dictionary<string, object>());
Query<Supplier> query = new Query<Supplier>(provider);
IQueryable<Supplier> suppliers = from supplier in query
orderby supplier.Name
select supplier;
List<Supplier> suppliersList = suppliers.ToList();
mocks.VerifyAllExpectationsHaveBeenMet();
}
public void OrderByDescendingTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
IDbCommand mockCommand = mocks.NewMock<IDbCommand>();
IDataReader mockReader = mocks.NewMock<IDataReader>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(mockCommand));
Expect.Once.On(mockCommand)
.SetProperty("CommandText").To("SELECT DISTINCT employees.id AS employee_id, employees.name AS employee_name FROM employees ORDER BY employee_name DESC;");
Expect.Once.On(mockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(false));
Expect.Once.On(mockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
// We return an empty result set from the mock reader. This doesn't matter much, since we
// verify that the ORDER BY is set in the SQL query executed.
SQLBuilder builder = new MySQLBuilder();
builder.AddSelectTypeClause("employees", typeof(Employee));
builder.AddFromClause("employees");
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, builder, new Dictionary<string, object>());
Query<Employee> myQuery = new Query<Employee>(provider);
var orderedResults = from x in myQuery
orderby x.Name descending
select x;
List<Employee> resultsList = orderedResults.ToList();
mocks.VerifyAllExpectationsHaveBeenMet();
}
public void OptimisedCountFailureTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
/* We will first try to execute the optimised form of the command, which will fail to return
* any results. This should lead to the default command being executed, which will return
* a correct result set */
IDbCommand optimisedMockCommand = mocks.NewMock<IDbCommand>();
IDataReader optimisedReader = mocks.NewMock<IDataReader>();
IDbCommand defaultMockCommand = mocks.NewMock<IDbCommand>();
IDataReader mockReader = mocks.NewMock<IDataReader>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(optimisedMockCommand));
Expect.Once.On(optimisedMockCommand)
.SetProperty("CommandText").To("SELECT stat FROM pre_calculated_count;");
Expect.Once.On(optimisedMockCommand)
.Method("ExecuteReader")
.Will(Return.Value(optimisedReader));
Expect.Once.On(optimisedReader)
.Method("Read")
.Will(Return.Value(false));
Expect.Once.On(optimisedReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
/* NB: We dispose of the mock connection, then we start using it again. In reality, we've called
* the provider function again, which returns the same value. For more realism, we could have two
* mocks and have a provider function that successively returns one, then the other */
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(defaultMockCommand));
Expect.Once.On(defaultMockCommand)
.SetProperty("CommandText").To("SELECT COUNT(*) AS numrows FROM employees;");
Expect.Once.On(defaultMockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(true));
Expect.Once.On(mockReader)
.Get["numrows"]
.Will(Return.Value("42"));
/* You might expect us to call Read() on the reader until it returns false - but actually, in the
* case of an aggregate function we don't bother doing this. Since we currently don't support
* GROUP BY, there's never going to be more than one row in an aggregate result set */
/*Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(false));*/
Expect.Once.On(mockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
SQLBuilder sqlBuilder = new MySQLBuilder();
sqlBuilder.AddSelectTypeClause("employees", typeof(Employee));
sqlBuilder.AddFromClause("employees");
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, sqlBuilder, new Dictionary<string, object>());
Query<Employee> query = new Query<Employee>(provider);
provider.SetOptimisedCountExpression("SELECT stat FROM pre_calculated_count;");
int count = query.Count();
Assert.AreEqual(42, count);
mocks.VerifyAllExpectationsHaveBeenMet();
}
public void MultipleOrderByTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
IDbCommand mockCommand = mocks.NewMock<IDbCommand>();
IDataReader mockReader = mocks.NewMock<IDataReader>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(mockCommand));
Expect.Once.On(mockCommand)
.SetProperty("CommandText").To("SELECT DISTINCT employees.id AS employee_id, employees.name AS employee_name FROM employees ORDER BY employee_name, employee_id;");
Expect.Once.On(mockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(true));
Expect.Once.On(mockReader)
.Get["employee_id"]
.Will(Return.Value("0"));
Expect.Once.On(mockReader)
.Get["employee_name"]
.Will(Return.Value("Alice"));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(false));
Expect.Once.On(mockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
SQLBuilder sqlBuilder = new MySQLBuilder();
sqlBuilder.AddSelectTypeClause("employees", typeof(Employee));
sqlBuilder.AddFromClause("employees");
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, sqlBuilder, new Dictionary<string, object>());
Query<Employee> query = new Query<Employee>(provider);
IQueryable<Employee> employees = from employee in query
orderby employee.Name,
employee.ID
select employee;
List<Employee> peopleList = employees.ToList();
mocks.VerifyAllExpectationsHaveBeenMet();
}
public void ExpressionOptimisationTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
IDbCommand mockCommand = mocks.NewMock<IDbCommand>();
IDataReader mockReader = mocks.NewMock<IDataReader>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(mockCommand));
Expect.Once.On(mockCommand)
.SetProperty("CommandText").To("SELECT stat FROM pre_calculated_count;");
Expect.Once.On(mockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
Expect.Exactly(1).On(mockReader)
.Method("Read")
.Will(Return.Value(true));
Expect.Once.On(mockReader)
.Get["numrows"]
.Will(Return.Value("42"));
Expect.Once.On(mockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
SQLBuilder sqlBuilder = new MySQLBuilder();
sqlBuilder.AddSelectTypeClause("employees", typeof(Employee));
sqlBuilder.AddFromClause("employees");
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, sqlBuilder, new Dictionary<string, object>());
Query<Employee> query = new Query<Employee>(provider);
provider.SetOptimisedCountExpression("SELECT stat FROM pre_calculated_count;");
int count = query.Count();
Assert.AreEqual(42, count);
mocks.VerifyAllExpectationsHaveBeenMet();
}
public void TakeAndCastTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
IDbCommand mockCommand = mocks.NewMock<IDbCommand>();
IDataReader mockReader = mocks.NewMock<IDataReader>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(mockCommand));
Expect.Once.On(mockCommand)
.SetProperty("CommandText").To("SELECT DISTINCT employees.id AS employee_id, employees.name AS employee_name FROM employees LIMIT 10;");
Expect.Once.On(mockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(false));
Expect.Once.On(mockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
SQLBuilder sqlBuilder = new MySQLBuilder();
sqlBuilder.AddSelectTypeClause("employees", typeof(Employee));
sqlBuilder.AddFromClause("employees");
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, sqlBuilder, new Dictionary<string, object>());
Query<Employee> query = new Query<Employee>(provider);
List<IPerson> employeeList = query.Take(10).Cast<IPerson>().ToList();
// We've already checked that the correct SQL is sent, so no need to check anything
// further here
}
