public void ErrorsWithContinueTrueDel()
        {
            EmployeeCollection coll = new EmployeeCollection();
            coll.es.Connection.Name = "ForeignKeyTest";
            coll.LoadAll();
            Assert.AreEqual(5, coll.Count, "Initial Load");

            using (esTransactionScope scope = new esTransactionScope())
            {
                // SQLite does not enforce FK constraints
                // So force a concurrency failure instead
                if (coll.es.Connection.ProviderSignature.DataProviderName
                    == "EntitySpaces.SQLiteProvider")
                {
                    Employee empConcurr = new Employee();
                    empConcurr.es.Connection.Name = "ForeignKeyTest";
                    empConcurr.LoadByPrimaryKey(2);
                    empConcurr.MarkAsDeleted();
                    empConcurr.Save();
                }

                // DELETE will fail - FK constraint
                Employee emp4 = coll.FindByPrimaryKey(2);
                emp4.MarkAsDeleted();

                coll.Save(true);

                Assert.AreEqual(1, coll.Errors.Count(), "ErrorsCount");
                Assert.IsNotNull(coll.es.DeletedEntities, "DeletedErrors");

                foreach (Employee e in coll.Errors)
                {
                    Assert.IsTrue(e.es.RowError.Length > 0);
                }

                if (coll.es.Connection.ProviderSignature.DataProviderName
                    != "EntitySpaces.SQLiteProvider")
                {
                    // Confirm same table row count
                    EmployeeCollection coll2 = new EmployeeCollection();
                    coll2.es.Connection.Name = "ForeignKeyTest";
                    coll2.LoadAll();
                    Assert.AreEqual(5, coll2.Count, "Load");

                    // Confirm nothing got DELETEd
                    Employee empDel = new Employee();
                    empDel.es.Connection.Name = "ForeignKeyTest";
                    Assert.IsTrue(empDel.LoadByPrimaryKey(2), "Delete");
                }
            }
        }
        public void ErrorsWithContinueDefaultFalse()
        {
            EmployeeCollection coll = new EmployeeCollection();
            coll.es.Connection.Name = "ForeignKeyTest";
            coll.LoadAll();
            Assert.AreEqual(5, coll.Count, "Initial Load");

            using (esTransactionScope scope = new esTransactionScope())
            {
                try
                {
                    // INSERT would succeed
                    // but should rollback by default
                    Employee emp1 = coll.AddNew();
                    emp1.FirstName = "asdf";
                    emp1.LastName = "adf";

                    // INSERT will fail - LastName required
                    Employee emp2 = coll.AddNew();

                    // UPDATE will fail - LastName required
                    Employee emp3 = coll.FindByPrimaryKey(1);
                    emp3.LastName = null;

                    // DELETE will fail - FK constraint
                    Employee emp4 = coll.FindByPrimaryKey(2);
                    emp4.MarkAsDeleted();

                    coll.Save(false);
                }
                catch (Exception ex)
                {
                    // Save() throws exception on first error encountered
                    Assert.AreEqual(1, coll.Errors.Count(), "ExceptionCount");
                    Assert.IsTrue(ex.ToString().Length > 0, "ExceptionLength");
                }
                finally
                {
                    // Confirm nothing got INSERTed
                    EmployeeCollection coll2 = new EmployeeCollection();
                    coll2.es.Connection.Name = "ForeignKeyTest";
                    coll2.LoadAll();
                    Assert.AreEqual(5, coll2.Count, "LoadInFinally");

                    // Confirm nothing got UPDATEd
                    Employee empUpd = coll2.FindByPrimaryKey(1);
                    Assert.AreEqual("Smith", empUpd.LastName, "Update");

                    // Confirm nothing got DELETEd
                    Employee empDel = new Employee();
                    empDel.es.Connection.Name = "ForeignKeyTest";
                    Assert.IsTrue(empDel.LoadByPrimaryKey(2), "Delete");
                }
            }
        }
        public void ErrorsWithContinueTrueInsUpdDel()
        {
            EmployeeCollection coll = new EmployeeCollection();
            coll.es.Connection.Name = "ForeignKeyTest";
            coll.LoadAll();
            Assert.AreEqual(5, coll.Count, "Initial Load");

            using (esTransactionScope scope = new esTransactionScope())
            {
                // SQLite does not enforce FK constraints
                // So force a concurrency failure instead
                if (coll.es.Connection.ProviderSignature.DataProviderName
                    == "EntitySpaces.SQLiteProvider")
                {
                    Employee empConcurr = new Employee();
                    empConcurr.es.Connection.Name = "ForeignKeyTest";
                    empConcurr.LoadByPrimaryKey(2);
                    empConcurr.MarkAsDeleted();
                    empConcurr.Save();
                }

                // INSERT will succeed
                Employee emp1 = coll.AddNew();
                emp1.FirstName = "First1";
                emp1.LastName = "Last1";

                // INSERT will fail - LastName required
                Employee emp2 = coll.AddNew();

                // UPDATE will fail - LastName required
                Employee emp3 = coll.FindByPrimaryKey(1);
                emp3.LastName = null;

                // DELETE will fail - FK constraint
                Employee emp4 = coll.FindByPrimaryKey(2);
                emp4.MarkAsDeleted();

                // INSERT will succeed
                Employee emp5 = coll.AddNew();
                emp5.FirstName = "First5";
                emp5.LastName = "Last5";

                coll.Save(true);

                Assert.AreEqual(3, coll.Errors.Count(), "ErrorsCount");
                Assert.IsNotNull(coll.es.DeletedEntities, "DeletedErrors");

                foreach (Employee e in coll.Errors)
                {
                    Assert.IsTrue(e.es.RowError.Length > 0);
                }

                // Confirm only 2 rows got INSERTed
                EmployeeCollection coll2 = new EmployeeCollection();
                coll2.es.Connection.Name = "ForeignKeyTest";
                coll2.LoadAll();
                if (coll.es.Connection.ProviderSignature.DataProviderName
                    == "EntitySpaces.SQLiteProvider")
                {
                    Assert.AreEqual(6, coll2.Count, "Load");
                }
                else
                {
                    Assert.AreEqual(7, coll2.Count, "Load");

                    // Confirm nothing got DELETEd
                    Employee empDel = new Employee();
                    empDel.es.Connection.Name = "ForeignKeyTest";
                    Assert.IsTrue(empDel.LoadByPrimaryKey(2), "Delete");
                }

                // Confirm nothing got UPDATEd
                Employee empUpd = new Employee();
                empUpd.es.Connection.Name = "ForeignKeyTest";
                Assert.IsTrue(empUpd.LoadByPrimaryKey(1));
                Assert.AreEqual("Smith", empUpd.LastName, "Update");

                // Confirm auto-incremeting PKs are brought back
                // and delete the 2 successfully inserted rows
                int emp1Id = emp1.EmployeeID.Value;
                Employee emp1Ins = new Employee();
                emp1Ins.es.Connection.Name = "ForeignKeyTest";

                Assert.IsTrue(emp1Ins.LoadByPrimaryKey(emp1Id), "LoadByPK1");
                emp1Ins.MarkAsDeleted();
                emp1Ins.Save();

                int emp5Id = emp5.EmployeeID.Value;
                Employee emp5Ins = new Employee();
                emp5Ins.es.Connection.Name = "ForeignKeyTest";

                Assert.IsTrue(emp5Ins.LoadByPrimaryKey(emp5Id), "LoadByPK2");
                emp5Ins.MarkAsDeleted();
                emp5Ins.Save();
            }
        }
        public void CollectionMixedInsUpdDel()
        {
            using (esTransactionScope scope = new esTransactionScope())
            {
                // Setup
                Employee newEmp = new Employee();
                newEmp.es.Connection.Name = "ForeignKeyTest";
                newEmp.LastName = "new";
                newEmp.FirstName = "new";
                newEmp.Save();

                EmployeeCollection coll = new EmployeeCollection();
                coll.es.Connection.Name = "ForeignKeyTest";
                coll.LoadAll();
                Assert.AreEqual(6, coll.Count, "Initial Load");

                // Insert
                Employee emp1 = coll.AddNew();
                emp1.FirstName = "emp1";
                emp1.LastName = "emp1";

                // Update
                Employee emp3 = coll.FindByPrimaryKey(1);
                emp3.LastName = "emp3";

                // Delete
                Employee emp4 = coll.FindByPrimaryKey(newEmp.EmployeeID.Value);
                emp4.MarkAsDeleted();

                coll.Save();

                // Confirm INSERT
                Employee empIns = new Employee();
                empIns.es.Connection.Name = "ForeignKeyTest";
                Assert.IsTrue(empIns.LoadByPrimaryKey(emp1.EmployeeID.Value), "Insert");

                // Confirm UPDATE
                Employee empUpd = new Employee();
                empUpd.es.Connection.Name = "ForeignKeyTest";
                Assert.IsTrue(empUpd.LoadByPrimaryKey(1), "Update");
                Assert.AreEqual("emp3", empUpd.LastName, "UpdateValue");

                // Confirm DELETE
                Employee empDel = new Employee();
                empDel.es.Connection.Name = "ForeignKeyTest";
                Assert.IsFalse(empDel.LoadByPrimaryKey(newEmp.EmployeeID.Value), "Delete");
            }
        }