Exemplo n.º 1
0
        public void Version_PersistTwice_WithoutVersionColumnEntity_ShouldNotThrowException()
        {
            try
            {
                var          con         = SetupTables();
                ITransaction transaction = CreateTransaction(con);

                int id = 45;
                VersionGeneralTestRootEntity entity = new VersionGeneralTestRootEntity();
                entity.IdCol = id;
                entity.Name  = "Org-Name";
                entity.Persist(transaction);
                transaction.Commit();

                transaction = CreateTransaction(con);
                entity.Persist(transaction);
                transaction.Commit();
                con.Close();
            }
            catch (System.Exception e)
            {
                LogManager.GetLogger(typeof(DbGateVersionTest)).Fatal(e.Message, e);
                Assert.Fail(e.Message);
            }
        }
Exemplo n.º 2
0
        private bool LoadWithoutVersionColumnEntityWithId(ITransaction transaction, VersionGeneralTestRootEntity loadEntity, int id)
        {
            bool loaded = false;

            IDbCommand cmd = transaction.CreateCommand();

            cmd.CommandText = "select * from version_test_root where id_col = ?";

            IDbDataParameter parameter = cmd.CreateParameter();

            cmd.Parameters.Add(parameter);
            parameter.DbType    = DbType.Int32;
            parameter.Direction = ParameterDirection.Input;
            parameter.Value     = id;

            IDataReader dataReader = cmd.ExecuteReader();

            if (dataReader.Read())
            {
                loadEntity.Retrieve(dataReader, transaction);
                loaded = true;
            }

            return(loaded);
        }
Exemplo n.º 3
0
        public void Version_RootUpdateFromAnotherTransaction_WithOutVersionColumnEntity_ShouldThrowException()
        {
            var          con                    = SetupTables();
            ITransaction transaction            = CreateTransaction(con);
            VersionGeneralTestRootEntity entity = null;

            try
            {
                int id = 65;
                entity       = new VersionGeneralTestRootEntity();
                entity.IdCol = id;
                entity.Name  = "Org-Name";
                entity.Persist(transaction);
                transaction.Commit();

                transaction = CreateTransaction(con);
                VersionGeneralTestRootEntity loadedEntity = new VersionGeneralTestRootEntity();
                LoadWithoutVersionColumnEntityWithId(transaction, loadedEntity, id);
                loadedEntity.Name = "New Name";
                loadedEntity.Persist(transaction);
                transaction.Commit();
            }
            catch (System.Exception e)
            {
                LogManager.GetLogger(typeof(DbGateVersionTest)).Fatal(e.Message, e);
                Assert.Fail(e.Message);
            }

            transaction = CreateTransaction(con);
            entity.Name = "New Name2";;
            Assert.Throws <PersistException>(() => entity.Persist(transaction));
            transaction.Commit();
            con.Close();
        }
Exemplo n.º 4
0
        public void Version_PersistWithTwoChanges_WithoutUpdateChangedColumnsOnly_ShouldThrowException()
        {
            var          con         = SetupTables();
            ITransaction transaction = CreateTransaction(con);

            int id = 45;
            VersionGeneralTestRootEntity entity = new VersionGeneralTestRootEntity();

            entity.IdCol   = id;
            entity.Name    = "Org-Name";
            entity.Version = 1;
            entity.Persist(transaction);
            transaction.Commit();

            transaction = CreateTransaction(con);
            VersionGeneralTestRootEntity loadedEntityA = new VersionGeneralTestRootEntity();
            VersionGeneralTestRootEntity loadedEntityB = new VersionGeneralTestRootEntity();

            LoadWithoutVersionColumnEntityWithId(transaction, loadedEntityA, entity.IdCol);
            LoadWithoutVersionColumnEntityWithId(transaction, loadedEntityB, entity.IdCol);
            transaction.Commit();

            transaction        = CreateTransaction(con);
            loadedEntityA.Name = "Mod Name";
            loadedEntityA.Persist(transaction);
            transaction.Commit();

            loadedEntityB.Version = loadedEntityB.Version + 1;
            Assert.Throws <PersistException>(() => loadedEntityB.Persist(transaction));
        }
Exemplo n.º 5
0
        public void Version_One2manyChildUpdateFromAnotherTransaction_WithoutVersionColumnEntity_ShouldThrowException()
        {
            var          con                    = SetupTables();
            ITransaction transaction            = CreateTransaction(con);
            VersionGeneralTestRootEntity entity = null;

            try
            {
                int id = 55;
                entity       = new VersionGeneralTestRootEntity();
                entity.IdCol = id;
                entity.Name  = "Org-Name";
                VersionGeneralTestOne2ManyEntity orgOne2ManyEntityOrg = new VersionGeneralTestOne2ManyEntity();
                orgOne2ManyEntityOrg.Name    = "One2Many";
                orgOne2ManyEntityOrg.IndexNo = 1;
                entity.One2ManyEntities.Add(orgOne2ManyEntityOrg);
                entity.Persist(transaction);
                transaction.Commit();

                transaction = CreateTransaction(con);
                VersionGeneralTestRootEntity loadedEntity = new VersionGeneralTestRootEntity();
                LoadWithoutVersionColumnEntityWithId(transaction, loadedEntity, id);

                IEnumerator <VersionGeneralTestOne2ManyEntity> loadedEnumerator = loadedEntity.One2ManyEntities.GetEnumerator();
                loadedEnumerator.MoveNext();
                VersionGeneralTestOne2ManyEntity loadedOne2ManyEntity = loadedEnumerator.Current;
                loadedOne2ManyEntity.Name = "Modified One2Many";
                loadedEntity.Persist(transaction);
                transaction.Commit();
            }
            catch (System.Exception e)
            {
                LogManager.GetLogger(typeof(DbGateVersionTest)).Fatal(e.Message, e);
                Assert.Fail(e.Message);
            }

            transaction = CreateTransaction(con);
            IEnumerator <VersionGeneralTestOne2ManyEntity> orgEnumerator = entity.One2ManyEntities.GetEnumerator();

            orgEnumerator.MoveNext();
            VersionGeneralTestOne2ManyEntity orgOne2ManyEntity = orgEnumerator.Current;

            orgOne2ManyEntity.Name = "Modified2 One2Many";
            Assert.Throws <PersistException>(() => entity.Persist(transaction));
            transaction.Commit();
            con.Close();
        }
Exemplo n.º 6
0
        public void Version_PersistWithTwoChanges_WithUpdateChangedColumnsOnly_ShouldNotThrowException()
        {
            try
            {
                TransactionFactory.DbGate.Config.UpdateStrategy = UpdateStrategy.ChangedColumns;
                var          con         = SetupTables();
                ITransaction transaction = CreateTransaction(con);

                int id = 45;
                VersionGeneralTestRootEntity entity = new VersionGeneralTestRootEntity();
                entity.IdCol   = id;
                entity.Name    = "Org-Name";
                entity.Version = 1;
                entity.Persist(transaction);
                transaction.Commit();

                transaction = CreateTransaction(con);
                VersionGeneralTestRootEntity loadedEntityA = new VersionGeneralTestRootEntity();
                VersionGeneralTestRootEntity loadedEntityB = new VersionGeneralTestRootEntity();
                LoadWithoutVersionColumnEntityWithId(transaction, loadedEntityA, entity.IdCol);
                LoadWithoutVersionColumnEntityWithId(transaction, loadedEntityB, entity.IdCol);
                transaction.Commit();

                transaction        = CreateTransaction(con);
                loadedEntityA.Name = "Mod Name";
                loadedEntityA.Persist(transaction);

                loadedEntityB.Version = loadedEntityB.Version + 1;
                loadedEntityB.Persist(transaction);
                transaction.Commit();
                con.Close();
            }
            catch (System.Exception e)
            {
                LogManager.GetLogger(typeof(DbGateVersionTest)).Fatal(e.Message, e);
                Assert.Fail(e.Message);
            }
        }