Esempio n. 1
0
        public void TestDbHelperForQueryViaTableName()
        {
            // Prepare
            var dbHelper   = GetMockedDbHelper();
            var connection = new DbHelperDbConnection();

            // Act
            CommandTextCache.Flush();
            DbFieldCache.Flush();
            DbHelperMapper.Add(typeof(DbHelperDbConnection), dbHelper.Object, true);

            // Act
            connection.Query(ClassMappedNameCache.Get <DbHelperDataEntity>(),
                             (object)null);

            // Assert
            dbHelper.Verify(builder =>
                            builder.GetFields(
                                It.Is <IDbConnection>(s => s == connection),
                                It.Is <string>(s => s == ClassMappedNameCache.Get <DbHelperDataEntity>()),
                                It.IsAny <IDbTransaction>()), Times.Exactly(1));
        }
Esempio n. 2
0
        public void TestDbHelperForInsertAllViaTableName()
        {
            // Prepare
            var dbHelper   = GetMockedDbHelper();
            var connection = new DbHelperDbConnection();

            // Act
            CommandTextCache.Flush();
            DbFieldCache.Flush();
            DbHelperMapper.Add <DbHelperDbConnection>(dbHelper.Object, true);

            // Act
            connection.InsertAll(ClassMappedNameCache.Get <DbHelperDataEntity>(),
                                 new[] { new { Id = 1, Name = "Name" } });

            // Assert
            dbHelper.Verify(builder =>
                            builder.GetFields(
                                It.Is <IDbConnection>(s => s == connection),
                                It.Is <string>(s => s == ClassMappedNameCache.Get <DbHelperDataEntity>()),
                                It.IsAny <IDbTransaction>()), Times.Exactly(1));
        }
Esempio n. 3
0
        public void TestDbHelperForInsert()
        {
            // Prepare
            var dbHelper   = new Mock <IDbHelper>();
            var connection = new DbHelperDbConnection();

            // Act
            CommandTextCache.Flush();
            DbFieldCache.Flush();
            DbHelperMapper.Add(typeof(DbHelperDbConnection), dbHelper.Object, true);

            // Act
            connection.Insert <DbHelperDataEntity>(new DbHelperDataEntity {
                Id = 1, Name = "Name"
            });

            // Assert
            dbHelper.Verify(builder =>
                            builder.GetFields(
                                It.Is <IDbConnection>(s => s == connection),
                                It.Is <string>(s => s == ClassMappedNameCache.Get <DbHelperDataEntity>()),
                                It.IsAny <IDbTransaction>()), Times.Exactly(1));
        }
Esempio n. 4
0
        public void TestDbHelperForInsert()
        {
            // Prepare
            var dbHelper   = new Mock <IDbHelper>();
            var connection = new CustomDbConnectionForDbHelper();

            // Act
            CommandTextCache.Flush();
            DbFieldCache.Flush();
            StatementBuilderMapper.Add(typeof(CustomDbConnectionForDbHelper), new SqlStatementBuilder(), true);
            DbHelperMapper.Add(typeof(CustomDbConnectionForDbHelper), dbHelper.Object, true);

            // Act
            connection.Insert <DataEntityForDbHelper>(new DataEntityForDbHelper {
                Id = 1, Name = "Name"
            });

            // Assert
            dbHelper.Verify(builder =>
                            builder.GetFields(
                                It.Is <string>(s => s == connection.ConnectionString),
                                It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>())), Times.Exactly(1));
        }
Esempio n. 5
0
        public void TestDbHelperForBatchQuery()
        {
            // Prepare
            var dbHelper   = GetMockedDbHelper();
            var connection = new DbHelperDbConnection();

            // Act
            CommandTextCache.Flush();
            DbFieldCache.Flush();
            DbHelperMapper.Add(typeof(DbHelperDbConnection), dbHelper.Object, true);

            // Act
            connection.BatchQuery <DbHelperDataEntity>(0,
                                                       10,
                                                       OrderField.Ascending <DbHelperDataEntity>(e => e.Id).AsEnumerable(),
                                                       e => e.Id == 1);

            // Assert
            dbHelper.Verify(builder =>
                            builder.GetFields(
                                It.Is <IDbConnection>(s => s == connection),
                                It.Is <string>(s => s == ClassMappedNameCache.Get <DbHelperDataEntity>()),
                                It.IsAny <IDbTransaction>()), Times.Exactly(1));
        }
 public void Initialize()
 {
     DbSettingMapper.Add <CacheDbConnection>(new CustomDbSetting(), true);
     DbHelperMapper.Add <CacheDbConnection>(new CustomDbHelper(), true);
     StatementBuilderMapper.Add <CacheDbConnection>(new CustomStatementBuilder(), true);
 }
 public void Initialize()
 {
     DbSettingMapper.Add(typeof(PropertyHandlerConnection), new CustomDbSetting(), true);
     DbHelperMapper.Add(typeof(PropertyHandlerConnection), new CustomDbHelper(), true);
     StatementBuilderMapper.Add(typeof(PropertyHandlerConnection), new CustomStatementBuilder(), true);
 }
Esempio n. 8
0
 public static void ClassInitialize(TestContext context)
 {
     DbSettingMapper.Add(typeof(TraceDbConnection), new CustomDbSetting(), true);
     DbHelperMapper.Add(typeof(TraceDbConnection), new CustomDbHelper(), true);
     StatementBuilderMapper.Add(typeof(TraceDbConnection), new CustomStatementBuilder(), true);
 }
 public static void ClassInitialize(TestContext context)
 {
     DbHelperMapper.Add(typeof(CustomDbConnectionForBaseRepositoryITrace), new BaseRepositoryCustomDbHelper(), true);
     DbOperationMapper.Add(typeof(CustomDbConnectionForBaseRepositoryITrace), new BaseRepositoryCustomDbOperationProvider(), true);
 }