public void ShouldHaveCorrectRowsAffectedAfterInsertCommand()
{
int count = -1;
SqlCeResultSet reader = null;
DbCommand command = null;
try
{
SqlCeDatabase db = (SqlCeDatabase)this.db;
command = db.GetSqlStringCommand(insertString);
reader = db.ExecuteResultSet(command);
count = reader.RecordsAffected;
}
finally
{
if (reader != null)
{
reader.Close();
}
if (command != null)
{
command.Connection.Close();
command.Dispose();
}
string deleteString = "Delete from Region where RegionId = 99";
DbCommand cleanupCommand = this.db.GetSqlStringCommand(deleteString);
this.db.ExecuteNonQuery(cleanupCommand);
}
Assert.AreEqual(1, count);
}
public void ExecuteResultSetWithBadCommandCallsInstrumentationFireCommandFailedEvent()
{
int executeCount = 0;
int failedCount = 0;
var mockProvider = new Mock <IDataInstrumentationProvider>();
mockProvider.Setup(p => p.FireCommandExecutedEvent(It.IsAny <DateTime>()))
.Callback <DateTime>(dt => ++ executeCount);
mockProvider.Setup(
p => p.FireCommandFailedEvent(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Exception>()))
.Callback <string, string, Exception>((c, cs, ex) => ++ failedCount);
SqlCeDatabase ceDb = GetDatabase(mockProvider.Object);
try
{
using (DbCommand command = ceDb.GetSqlStringCommand("select * from junk"))
{
SqlCeResultSet reader = ceDb.ExecuteResultSet(command);
reader.Close();
}
}
catch { }
Assert.AreEqual(0, executeCount);
Assert.AreEqual(1, failedCount);
}
public void TablesNotNullTest()
{
SqlCeDatabase target = new SqlCeDatabase(connectionString);
Assert.IsNotNull(target.Tables);
CollectionAssert.AllItemsAreNotNull(target.Tables);
}
public static void Setup()
{
TearDown();
SqlCeDatabase.CreateDatabaseFile(_sqlceDB.ConnectionString);
_sqliteDB.BuildTextCommand(_createTableSql).Execute();
_sqlceDB.BuildTextCommand(_createTableSql).Execute();
}
public void DatabaseConstructorWithConnectionStringAndNamespaceTest()
{
string defaultNamespace = "SqlCeCodeGenTest";
SqlCeDatabase target = new SqlCeDatabase(defaultNamespace, connectionString);
Assert.AreEqual(defaultNamespace, target.Namespace);
}
public void TestInitialize()
{
testConnection = new TestConnectionString();
testConnection.CopyFile();
db = new SqlCeDatabase(testConnection.ConnectionString);
base.SetUp();
}
public override void Initialize()
{
ConnectionStringsSection section = (ConnectionStringsSection)base.ConfigurationSource.GetSection("connectionStrings");
connStr = section.ConnectionStrings["SqlCeTest"].ConnectionString;
db = new SqlCeDatabase(connStr);
SqlCeConnection conn = new SqlCeConnection();
conn.ConnectionString = connStr;
conn.Open();
SqlCeCommand cmd = null;
cmd = new SqlCeCommand("Delete from Items where itemId > 3 ", conn);
cmd.ExecuteNonQuery();
cmd = new SqlCeCommand("Update Items set ItemDescription='Digital Image Pro',QtyInHand = 25, QtyRequired=100, Price = 38.95 where ItemId = 1", conn);
cmd.ExecuteNonQuery();
cmd = new SqlCeCommand("Update Items set ItemDescription='Excel 2003',QtyInHand = 95, QtyRequired=100, Price = 98.95 where ItemId = 2", conn);
cmd.ExecuteNonQuery();
cmd = new SqlCeCommand("Update Items set ItemDescription='Infopath',QtyInHand = 34, QtyRequired=100, Price = 89 where ItemId = 3", conn);
cmd.ExecuteNonQuery();
cmd = new SqlCeCommand("delete from Items where ItemId > 3", conn);
cmd.ExecuteNonQuery();
cmd = new SqlCeCommand("delete from CustomersOrders where CustomerId > 3 ", conn);
cmd.ExecuteNonQuery();
cmd = new SqlCeCommand("Update CustomersOrders set QtyOrdered=100", conn);
cmd.ExecuteNonQuery();
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory(), false);
}
public void ExecuteResultSetWithBadCommandCallsInstrumentationFireCommandFailedEvent()
{
SqlCeDatabase db = (SqlCeDatabase)this.db;
int executeCount = 0;
int failedCount = 0;
DataInstrumentationProvider instrumentation = (DataInstrumentationProvider)db.GetInstrumentationEventProvider();
instrumentation.commandExecuted += delegate(object sender, CommandExecutedEventArgs e) { executeCount++; };
instrumentation.commandFailed += delegate(object sender, CommandFailedEventArgs e) { failedCount++; };
try
{
using (DbCommand command = db.GetSqlStringCommand("select * from junk"))
{
SqlCeResultSet reader = db.ExecuteResultSet(command);
reader.Close();
command.Connection.Close();
}
}
catch
{
}
Assert.AreEqual(0, executeCount);
Assert.AreEqual(1, failedCount);
}
public void RecordIsInsertedWhenNonQueryWithText()
{
string connectionString;
string filename = "TestDb.sdf";
bool isPresent = false;
filename = System.IO.Path.Combine(Environment.CurrentDirectory, filename);
connectionString = "Data Source='{0}'";
connectionString = String.Format(connectionString, filename);
Database db = new SqlCeDatabase(connectionString);
StringBuilder readerDataActual = new StringBuilder();
string sqlText = "Insert into CustomersOrders Values(14, 'Lee', 1, 233)";
db.ExecuteNonQuery(CommandType.Text, sqlText);
SqlCeConnection conn = new SqlCeConnection();
conn.ConnectionString = connStr;
conn.Open();
SqlCeCommand cmd = new SqlCeCommand("Select CustomerName from CustomersOrders where CustomerId = 14", conn);
SqlCeDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
Assert.AreEqual("Lee", dr["CustomerName"].ToString());
isPresent = true;
}
dr.Close();
conn.Close();
Assert.AreEqual(true, isPresent);
}
public void TestInitialize()
{
testConnection = new TestConnectionString();
testConnection.CopyFile();
db = new SqlCeDatabase(testConnection.ConnectionString);
base.SetUp();
}
public void ExecuteQueryThroughDataReaderUsingNullCommandAndNullTransactionThrows()
{
SqlCeDatabase db = (SqlCeDatabase)this.db;
using (SqlCeResultSet reader = db.ExecuteResultSet(null, (DbTransaction)null))
{
}
}
public void ExecuteResultSetUsingNullCommandThrows()
{
SqlCeDatabase db = (SqlCeDatabase)this.db;
using (SqlCeResultSet reader = db.ExecuteResultSet((DbCommand)null))
{
}
}
public UnitOfWork()
{
SqlConnection = new SqlCeConnection(sdfPath);
Database = new SqlCeDatabase(SqlConnection);
Database.Init();
AppSettingRepository = new AppSettingRepository(Database);
MstItemRepository = new MstItemRepository(Database);
}
public void CreateNewDatabaseThrowsWhenFileAlreadyExists()
{
TestConnectionString file = new TestConnectionString();
Assert.IsTrue(File.Exists(file.Filename));
SqlCeDatabase database = new SqlCeDatabase(file.ConnectionString);
database.CreateFile();
}
public void CannotGetCommandForStoredProcedure()
{
TestConnectionString testConnection = new TestConnectionString();
testConnection.CopyFile();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
db.GetStoredProcCommand("CustOrdersOrders");
}
public static void AddTestData(Database database)
{
SqlCeDatabase db = (SqlCeDatabase)database;
db.ExecuteNonQuerySql("insert into Region values (99, 'Midwest');");
db.ExecuteNonQuerySql("insert into Region values (100, 'Central Europe');");
db.ExecuteNonQuerySql("insert into Region values (101, 'Middle East');");
db.ExecuteNonQuerySql("insert into Region values (102, 'Australia')");
}
public void EmptyQueryStringTest()
{
SqlCeDatabase db = (SqlCeDatabase)this.db;
using (DbCommand myCommand = db.GetSqlStringCommand(String.Empty))
{
IDataReader reader = db.ExecuteResultSet(myCommand);
}
}
public void SetUp()
{
testConnection = new TestConnectionString();
testConnection.CopyFile();
db = new SqlCeDatabase(testConnection.ConnectionString);
DbCommand command = db.GetSqlStringCommand("Select count(*) from region");
baseFixture = new ExecuteScalarFixture(db, command);
}
public void PoolShouldCloseSharedConnection()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) {}
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
SqlCeConnectionPool.CloseSharedConnection(db);
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public void DatabaseShouldCloseSharedConnection()
{
TestConnectionString file = new TestConnectionString();
SqlCeDatabase database = new SqlCeDatabase(file.ConnectionString);
using (DbConnection connection = SqlCeConnectionPool.CreateConnection(database)) {}
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
database.CloseSharedConnection();
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public void ConnectionShouldRemainInPoolAfterReturnedConnectionDisposed()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DbConnection connection = SqlCeConnectionPool.CreateConnection(db)) {}
DbConnection keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreEqual(ConnectionState.Open, keepAlive.State);
}
public void CanOpenSqlCeDatabase()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase database = new SqlCeDatabase(testConnection.ConnectionString);
using (DbConnection connection = database.CreateConnection())
{
connection.Open();
Assert.AreEqual(ConnectionState.Open, connection.State);
}
}
public void GetConnectionOpensConnectionInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreEqual(ConnectionState.Open, keepAlive.Connection.State);
}
}
public void GetConnectionReturnsDifferentConnectionThanOneInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreNotSame(connection, keepAlive);
}
}
public void ShouldNotAddConnectionToPoolIfOpenFails()
{
SqlCeDatabase db = new SqlCeDatabase("Data Source='invalid.sdf'");
try
{
DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db);
}
catch (SqlCeException) {}
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public void GetConnectionAddsConnectionToPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
Assert.IsNotNull(connection);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
}
public void ExecuteSqlCreatesConnectionInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
DbCommand command = db.GetSqlStringCommand("select count(*) from region");
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
int result = (int)db.ExecuteScalar(command);
Assert.AreEqual(4, result);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
void CreateSqlCeDatabase()
{
string databasePath = GetFreeDatabase("TestDatabase{0}.MyMoney.sdf");
createNewDatabaseDialog.CreateSqlCeDatabase(databasePath);
isLoaded = true;
createNewDatabaseDialog = null;
Database = new SqlCeDatabase()
{
DatabasePath = databasePath
};
}
public void UnitTestCodeGeneratorFactoryStaticCreateNUnitTest()
{
var defaultNamespace = typeof(CodeGenTest).Namespace;
var connectionString = "Data Source=TestDatabase.sdf";
var database = new SqlCeDatabase(defaultNamespace, connectionString);
var codeGenerator = UnitTestCodeGeneratorFactory.Create(database, "NUnit");
Assert.IsNotNull(codeGenerator);
Assert.IsInstanceOfType(codeGenerator, typeof(CodeGenerator));
Assert.IsInstanceOfType(codeGenerator, typeof(CSharpCodeGenerator));
Assert.IsInstanceOfType(codeGenerator, typeof(CSharpUnitTestCodeGenerator));
Assert.IsInstanceOfType(codeGenerator, typeof(NUnitTestCodeGenerator));
}
public void ExecuteResultSet_ShouldNotCloseConnection()
{
SqlCeDatabase db = (SqlCeDatabase)this.db;
using (DbCommand command = db.GetSqlStringCommand(queryString))
{
SqlCeResultSet reader = db.ExecuteResultSet(command);
reader.Close();
Assert.AreEqual(ConnectionState.Open, command.Connection.State);
command.Connection.Close();
}
}
public void GetConnectionWithPoolingReturnsSameConnection()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db, true))
{
using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db, true))
{
Assert.AreSame(connection1, connection2);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
}
}
/// <summary>
/// Sets the database.
/// </summary>
/// <param name="main">The main.</param>
public static void SetDatabase(SqlCeDatabase main)
{
_database = main;
}
