public void TransactionAutoDispose()
        {
            if (GetProvider() == Provider.SQLite)
            {
                return;
            }

            using (var db = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Alice", LastName = "Jones"
                };
                Assert.True(db.Insert(p));

                using (var tran = db.GetTransaction())
                {
                    var gp = db.Get <PersonIdentity>(p.IdentityId);
                    gp.FirstName = "Sally";
                    db.Update(gp);
                }

                var agp = db.Get <PersonIdentity>(p.IdentityId);  //updates should have been rolled back
                Assert.Equal("Alice", agp.FirstName);
            }
        }
        public void InsertIdentity()
        {
            using (var db = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Alice", LastName = "Jones"
                };
                Assert.True(db.Insert(p));
                Assert.True(p.IdentityId > 0);
                var gp = db.Get <PersonIdentity>(p.IdentityId);

                Assert.Equal(p.IdentityId, gp.IdentityId);
                Assert.Equal(p.FirstName, gp.FirstName);
                Assert.Equal(p.LastName, gp.LastName);
            }
        }
        public void DeleteIdentity()
        {
            using (var db = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Alice", LastName = "Jones"
                };
                Assert.True(db.Insert(p));
                Assert.True(p.IdentityId > 0);

                Assert.True(db.Delete <PersonIdentity>(p.IdentityId));

                var gp = db.Get(p);
                Assert.Null(gp);
            }
        }
Beispiel #4
0
        public async Task InsertIdentityAsync()
        {
            using (var connection = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Alice", LastName = "Jones"
                };
                Assert.True(await connection.InsertAsync(p));
                Assert.True(p.IdentityId > 0);
                var gp = await connection.GetAsync <PersonIdentity>(p.IdentityId);

                Assert.Equal(p.IdentityId, gp.IdentityId);
                Assert.Equal(p.FirstName, gp.FirstName);
                Assert.Equal(p.LastName, gp.LastName);
            }
        }
Beispiel #5
0
        public async Task DeleteIdentityAsync()
        {
            using (var connection = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Alice", LastName = "Jones"
                };
                Assert.True(await connection.InsertAsync(p));
                Assert.True(p.IdentityId > 0);

                Assert.True(await connection.DeleteAsync <PersonIdentity>(p.IdentityId));

                var gp = await connection.GetAsync(p);

                Assert.Null(gp);
            }
        }
        public void DeleteWhereClause()
        {
            using (var db = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Delete", LastName = "Me"
                };

                for (var i = 0; i < 10; i++)
                {
                    Assert.True(db.Insert(p));
                }

                Assert.Equal(10, db.Count <PersonIdentity>("where FirstName = 'Delete'"));

                Assert.True(db.Delete <PersonIdentity>("where FirstName = 'Delete'"));

                Assert.Equal(0, db.Count <PersonIdentity>("where FirstName = 'Delete'"));
            }
        }
Beispiel #7
0
        public async Task DeleteWhereClauseAsync()
        {
            using (var connection = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Delete", LastName = "Me"
                };

                for (var i = 0; i < 10; i++)
                {
                    Assert.True(await connection.InsertAsync(p));
                }

                Assert.Equal(10, await connection.CountAsync <PersonIdentity>("where FirstName = 'Delete'"));

                Assert.True(await connection.DeleteAsync <PersonIdentity>("where FirstName = 'Delete'"));

                Assert.Equal(0, await connection.CountAsync <PersonIdentity>("where FirstName = 'Delete'"));
            }
        }
        public void UpdatePartial()
        {
            using (var db = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Alice", LastName = "Jones"
                };
                Assert.True(db.Insert(p));
                Assert.True(p.IdentityId > 0);

                p.FirstName = "Greg";
                p.LastName  = "Smith";
                Assert.True(db.Update(p, new string[] { "LastName" }));

                var gp = db.Get <PersonIdentity>(p.IdentityId);

                Assert.Equal(p.IdentityId, gp.IdentityId);
                Assert.Equal("Alice", gp.FirstName);
                Assert.Equal("Smith", gp.LastName);
            }
        }
        public async Task UpdatePartialAsync()
        {
            using (var connection = GetSqlDatabase())
            {
                var p = new PersonIdentity {
                    FirstName = "Alice", LastName = "Jones"
                };
                Assert.True(await connection.InsertAsync(p));
                Assert.True(p.IdentityId > 0);

                p.FirstName = "Greg";
                p.LastName  = "Smith";
                Assert.True(await connection.UpdateAsync(p, new string[] { "LastName" }));

                var gp = await connection.GetAsync <PersonIdentity>(p.IdentityId);

                Assert.Equal(p.IdentityId, gp.IdentityId);
                Assert.Equal("Alice", gp.FirstName);
                Assert.Equal("Smith", gp.LastName);
            }
        }