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 QueryCachingTest()
{
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 id FROM employees;");
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["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 builder = new MySQLBuilder();
// NB: The select clause we're setting here isn't sufficient to instantiate the objects,
// which have two fields. This doesn't matter here since we are using mock objects
// anyway, and in practice it will be up to the author of the SQL statements to get details
// like this right.
builder.AddSelectClause("id");
builder.AddFromClause("employees");
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, builder, new Dictionary<string, object>());
Query<Employee> myQuery = new Query<Employee>(provider);
List<Employee> resultList = myQuery.ToList();
Assert.AreEqual(1, resultList.Count);
Assert.AreEqual(0, resultList[0].ID);
Assert.AreEqual("Alice", resultList[0].Name);
// This shouldn't cause any further DB queries, since we've already evaluated this
// expression once
resultList = myQuery.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 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 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 OrderByCastTest()
{
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 id AS employee_id, name AS employee_name FROM employees ORDER BY employee_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["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.AddSelectClause("id AS employee_id");
sqlBuilder.AddSelectClause("name AS employee_name");
sqlBuilder.AddFromClause("employees");
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, sqlBuilder, new Dictionary<string, object>());
Query<Employee> query = new Query<Employee>(provider);
IQueryable<IPerson> people = query.Cast<IPerson>();
people = from person in people
orderby person.Name
select person;
List<IPerson> peopleList = people.ToList();
Assert.AreEqual(1, peopleList.Count);
Assert.IsInstanceOf<IPerson>(peopleList[0]);
}
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 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 CountExpressionTest()
{
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 COUNT(*) AS numrows FROM employees WHERE name LIKE '%smith' ;");
Expect.Once.On(mockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(true));
// Note that we only call the reader once, rather than iterating through until
// it returns false. This works fine when we know we have only one result,
// which will be the case until we implement GroupBy
/*Expect.Once.On(mockReader)
.Method("Read")
.Will(Return.Value(false));*/
Expect.Once.On(mockReader)
.Get["numrows"]
.Will(Return.Value(16));
Expect.Once.On(mockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("Dispose");
SQLBuilder builder = new MySQLBuilder();
builder.AddSelectClause("id");
builder.AddSelectClause("name");
builder.AddFromClause("employees");
builder.AddWhereClause("name LIKE '%smith'", ExpressionType.And);
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, builder, new Dictionary<string, object>());
Query<Employee> myQuery = new Query<Employee>(provider);
Assert.AreEqual(16, myQuery.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
}
public void SkipTakeTest()
{
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 id AS employee_id, name AS employee_name FROM employees LIMIT 10, 15;");
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.AddSelectClause("id AS employee_id");
sqlBuilder.AddSelectClause("name AS employee_name");
sqlBuilder.AddFromClause("employees");
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, sqlBuilder, new Dictionary<string, object>());
Query<Employee> query = new Query<Employee>(provider);
List<Employee> employeeList = query.Skip(10).Take(15).ToList();
Assert.AreEqual(1, employeeList.Count); // Though we asked for 15 results, there was only one returned
Assert.AreEqual(0, employeeList[0].ID);
Assert.AreEqual("Alice", employeeList[0].Name);
}
public void SetParametersTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
IDbCommand mockCommand = mocks.NewMock<IDbCommand>();
IDataReader mockReader = mocks.NewMock<IDataReader>();
IDbDataParameter mockParameter = mocks.NewMock<IDbDataParameter>();
IDataParameterCollection mockParameterCollection = mocks.NewMock<IDataParameterCollection>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(mockCommand));
Expect.Once.On(mockCommand)
.SetProperty("CommandText").To("SELECT DISTINCT id, name FROM employees WHERE name=@name ;");
Expect.Once.On(mockCommand)
.Method("CreateParameter")
.Will(Return.Value(mockParameter));
Expect.Once.On(mockParameter)
.SetProperty("ParameterName").To("@name");
Expect.Once.On(mockParameter)
.SetProperty("Value").To("smith");
Expect.Once.On(mockCommand)
.GetProperty("Parameters")
.Will(Return.Value(mockParameterCollection));
Expect.Once.On(mockParameterCollection)
.Method("Add").With(mockParameter)
.Will(Return.Value(0));
Expect.Once.On(mockCommand)
.Method("ExecuteReader")
.Will(Return.Value(mockReader));
// We don't return any values, since we don't need to test what we do with
// the returned values. The important thing to test is that the parameter
// methods above get called.
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.AddSelectClause("id");
sqlBuilder.AddSelectClause("name");
sqlBuilder.AddFromClause("employees");
sqlBuilder.AddWhereClause("name=@name", ExpressionType.And);
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters["@name"] = "smith";
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, sqlBuilder, parameters);
Query<Employee> query = new Query<Employee>(provider);
List<Employee> employees = query.ToList();
// The important testing is done in the mock code. Provided the right
// AddParameter stuff is called, we don't care what happens with the results
mocks.VerifyAllExpectationsHaveBeenMet();
}
public void QueryRepeatabilityTest()
{
Mockery mocks = new Mockery();
IDbConnection mockConnection = mocks.NewMock<IDbConnection>();
IDbCommand firstMockCommand = mocks.NewMock<IDbCommand>();
IDbCommand secondMockCommand = mocks.NewMock<IDbCommand>();
IDataReader firstMockReader = mocks.NewMock<IDataReader>();
IDataReader secondMockReader = mocks.NewMock<IDataReader>();
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(firstMockCommand));
Expect.Once.On(firstMockCommand)
.SetProperty("CommandText").To("SELECT COUNT(*) AS numrows FROM employees WHERE id=42 ;");
Expect.Once.On(firstMockCommand)
.Method("ExecuteReader")
.Will(Return.Value(firstMockReader));
Expect.Once.On(firstMockReader)
.Method("Read")
.Will(Return.Value(true));
Expect.Once.On(firstMockReader)
.Get["numrows"]
.Will(Return.Value(1));
Expect.Once.On(firstMockReader)
.Method("Dispose");
Expect.Once.On(mockConnection)
.Method("CreateCommand")
.Will(Return.Value(secondMockCommand));
Expect.Once.On(secondMockCommand)
.SetProperty("CommandText").To("SELECT DISTINCT id AS employee_id, name AS employee_name FROM employees WHERE id=42 ;");
Expect.Once.On(secondMockCommand)
.Method("ExecuteReader")
.Will(Return.Value(secondMockReader));
Expect.Once.On(secondMockReader)
.Method("Read")
.Will(Return.Value(true));
Expect.Once.On(secondMockReader)
.Get["employee_id"]
.Will(Return.Value(1));
Expect.Once.On(secondMockReader)
.Get["employee_name"]
.Will(Return.Value("Bob"));
Expect.Once.On(secondMockReader)
.Method("Read")
.Will(Return.Value(false));
Expect.Once.On(secondMockReader)
.Method("Dispose");
// NB: We're returning the same connection object twice, so we'll dispose it twice. This
// isn't really correct, but since these are mock objects nobody will know that they're
// the same object
Expect.Exactly(2).On(mockConnection)
.Method("Dispose");
SQLBuilder sqlBuilder = new MySQLBuilder();
sqlBuilder.AddSelectClause("id AS employee_id");
sqlBuilder.AddSelectClause("name AS employee_name");
sqlBuilder.AddFromClause("employees");
sqlBuilder.AddWhereClause("id=42", ExpressionType.And);
LazyDBQueryProvider<Employee> provider = new LazyDBQueryProvider<Employee>(() => mockConnection, sqlBuilder, new Dictionary<string, object>());
Query<Employee> query = new Query<Employee>(provider);
int numEmployees = query.Count();
Assert.AreEqual(1, numEmployees);
List<Employee> employees = query.ToList();
}
