Пример #1
0
        public void MappingIgnoreColumn()
        {
            var db = new TestDb();
            var m = db.GetMapping<TestObj>();

            Assert.AreEqual(2, m.Columns.Length);
        }
Пример #2
0
        public void Collate()
        {
            var obj = new TestObj()
            {
                CollateDefault = "Alpha ",
                CollateBinary = "Alpha ",
                CollateRTrim = "Alpha ",
                CollateNoCase = "Alpha ",
            };

            var db = new TestDb(TestPath.GetTempFileName());

            db.Insert(obj);

            Assert.AreEqual(1, (from o in db.Table<TestObj>() where o.CollateDefault == "Alpha " select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateDefault == "ALPHA " select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateDefault == "Alpha" select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateDefault == "ALPHA" select o).Count());

            Assert.AreEqual(1, (from o in db.Table<TestObj>() where o.CollateBinary == "Alpha " select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateBinary == "ALPHA " select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateBinary == "Alpha" select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateBinary == "ALPHA" select o).Count());

            Assert.AreEqual(1, (from o in db.Table<TestObj>() where o.CollateRTrim == "Alpha " select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateRTrim == "ALPHA " select o).Count());
            Assert.AreEqual(1, (from o in db.Table<TestObj>() where o.CollateRTrim == "Alpha" select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateRTrim == "ALPHA" select o).Count());

            Assert.AreEqual(1, (from o in db.Table<TestObj>() where o.CollateNoCase == "Alpha " select o).Count());
            Assert.AreEqual(1, (from o in db.Table<TestObj>() where o.CollateNoCase == "ALPHA " select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateNoCase == "Alpha" select o).Count());
            Assert.AreEqual(0, (from o in db.Table<TestObj>() where o.CollateNoCase == "ALPHA" select o).Count());
        }
Пример #3
0
        public void ContainsQueriedData()
        {
            int n = 20;
            var cq =from i in Enumerable.Range(1, n)
                    select new TestObj() {
                Name = i.ToString()
            };

            var db = new TestDb(Path.GetTempFileName());

            db.InsertAll(cq);

            db.Trace = true;

            var tensq = new string[] { "0", "10", "20" };
            var tens = (from o in db.Table<TestObj>() where tensq.Contains(o.Name) select o).ToList();
            Assert.AreEqual(2, tens.Count);

            var moreq = new string[] { "0", "x", "99", "10", "20", "234324" };
            var more = (from o in db.Table<TestObj>() where moreq.Contains(o.Name) select o).ToList();
            Assert.AreEqual(2, more.Count);

            // https://github.com/praeclarum/sqlite-net/issues/28
            var moreq2 = moreq.ToList ();
            var more2 = (from o in db.Table<TestObj>() where moreq2.Contains(o.Name) select o).ToList();
            Assert.AreEqual(2, more2.Count);
        }
Пример #4
0
        public void SetUp()
        {
            _db = new TestDb();
            _db.CreateTable<Product>();
            _db.CreateTable<Order>();
            _db.CreateTable<OrderLine>();

            var p1 = new Product { Name = "One", };
            var p2 = new Product { Name = "Two", };
            var p3 = new Product { Name = "Three", };
            _db.InsertAll(new[] { p1, p2, p3 });

            var o1 = new Order { PlacedTime = DateTime.Now, };
            var o2 = new Order { PlacedTime = DateTime.Now, };
            _db.InsertAll(new[] { o1, o2 });

            _db.InsertAll(new[] {
                new OrderLine {
                    OrderId = o1.Id,
                    ProductId = p1.Id,
                    Quantity = 1,
                },
                new OrderLine {
                    OrderId = o1.Id,
                    ProductId = p2.Id,
                    Quantity = 2,
                },
                new OrderLine {
                    OrderId = o2.Id,
                    ProductId = p3.Id,
                    Quantity = 3,
                },
            });
        }
Пример #5
0
        public void InsertALot()
        {
            int n = 100000;
            var q =	from i in Enumerable.Range(1, n)
                    select new TestObj() {
                Text = "I am"
            };
            var objs = q.ToArray();
            var db = new TestDb(Path.GetTempFileName());
            db.Trace = false;

            var sw = new Stopwatch();
            sw.Start();

            var numIn = db.InsertAll(objs);

            sw.Stop();

            Assert.AreEqual(numIn, n, "Num inserted must = num objects");

            var inObjs = db.CreateCommand("select * from TestObj").ExecuteQuery<TestObj>().ToArray();

            for (var i = 0; i < inObjs.Length; i++) {
                Assert.AreEqual(i+1, objs[i].Id);
                Assert.AreEqual(i+1, inObjs[i].Id);
                Assert.AreEqual("I am", inObjs[i].Text);
            }

            var numCount = db.CreateCommand("select count(*) from TestObj").ExecuteScalar<int>();

            Assert.AreEqual(numCount, n, "Num counted must = num objects");
        }
Пример #6
0
        public void Setup()
        {
            testObjects = Enumerable.Range(1, 20).Select(i => new TestObj()).ToList();

            db = new TestDb(TestPath.GetTempFileName());
            db.InsertAll(testObjects);
        }
Пример #7
0
        public void Skip()
        {
            var n = 100;

            var cq =	from i in Enumerable.Range(1, n)
                    select new TestObj() {
                Order = i
            };
            var objs = cq.ToArray();
            var db = new TestDb(TestPath.GetTempFileName());

            var numIn = db.InsertAll(objs);
            Assert.AreEqual(numIn, n, "Num inserted must = num objects");

            var q = from o in db.Table<TestObj>()
                    orderby o.Order
                    select o;

            var qs1 = q.Skip(1);
            var s1 = qs1.ToList();
            Assert.AreEqual(n - 1, s1.Count);
            Assert.AreEqual(2, s1[0].Order);

            var qs5 = q.Skip(5);
            var s5 = qs5.ToList();
            Assert.AreEqual(n - 5, s5.Count);
            Assert.AreEqual(6, s5[0].Order);
        }
Пример #8
0
 TestDb CreateDb()
 {
     var db = new TestDb ();
     db.CreateTable<Product> ();
     db.CreateTable<Order> ();
     db.CreateTable<OrderLine> ();
     db.CreateTable<OrderHistory> ();
     return db;
 }
Пример #9
0
        public void InheritanceWorks()
        {
            var db = new TestDb ();

            var mapping = db.GetMapping<Derived> ();

            Assert.AreEqual (3, mapping.Columns.Length);
            Assert.AreEqual ("Id", mapping.PK.Name);
        }
Пример #10
0
		SQLiteConnection CreateDb ()
		{
			var db = new TestDb ();
			db.CreateTable<TestTable> ();
			var items = from i in Enumerable.Range (0, Count)
				select new TestTable { Datum = 1000+i };
			db.InsertAll (items);
			Assert.AreEqual (Count, db.Table<TestTable> ().Count ());
			return db;
		}
Пример #11
0
 private void CheckPK(TestDb db)
 {
     for (int i = 1; i <= 10; i++)
     {
         var na = new NoAttributes { Id = i, AColumn = i.ToString(), IndexedId = 0 };
         db.Insert(na);
     }
     var item = db.Get<NoAttributes>(2);
     Assert.IsNotNull(item);
     Assert.AreEqual(2, item.Id);
 }
Пример #12
0
        public void UpperAndLowerColumnNames()
        {
            using (var db = new TestDb (true) { Trace = true } ) {
                db.CreateTable<LowerId> ();
                db.CreateTable<UpperId> ();

                var cols = db.GetTableInfo ("Test").ToList ();
                Assert.That (cols.Count, Is.EqualTo (1));
                Assert.That (cols[0].Name, Is.EqualTo ("Id"));
            }
        }
Пример #13
0
		public void CreateThem ()
		{
			var db = new TestDb ();
			
			db.CreateTable<Product> ();
			db.CreateTable<Order> ();
			db.CreateTable<OrderLine> ();
			db.CreateTable<OrderHistory> ();
			
			VerifyCreations(db);
		}
Пример #14
0
        public void UpperAndLowerColumnNames()
        {
            using (var db = new TestDb (true) { Trace = true } ) {
                db.CreateTable<LowerId> ();
                db.CreateTable<UpperId> ();

                var cols = db.GetTableInfo ("Test").ToList ();
                Assert.AreEqual (1, cols.Count);
                Assert.AreEqual ("Id", cols[0].Name);
            }
        }
Пример #15
0
        public void CreateAsPassedInTypes ()
        {
            var db = new TestDb();

            db.CreateTable(typeof(Product));
            db.CreateTable(typeof(Order));
            db.CreateTable(typeof(OrderLine));
            db.CreateTable(typeof(OrderHistory));

            VerifyCreations(db);
        }
Пример #16
0
 public void CreateUniqueIndexes()
 {
     using (var db = new TestDb ()) {
         db.CreateTable<TheOne> ();
         var indexes = db.Query<IndexInfo> ("PRAGMA INDEX_LIST (\"TheOne\")");
         Assert.AreEqual (4, indexes.Count, "# of indexes");
         CheckIndex (db, indexes, "UX_Uno", true, "Uno");
         CheckIndex (db, indexes, "UX_Dos", true, "Dos", "Tres");
         CheckIndex (db, indexes, "UX_Uno_bool", true, "Cuatro");
         CheckIndex (db, indexes, "UX_Dos_bool", true, "Cinco", "Seis");
     }
 }
Пример #17
0
        public void HasGoodNames()
        {
            var db = new TestDb ();

            db.CreateTable<AFunnyTableName> ();

            var mapping = db.GetMapping<AFunnyTableName> ();

            Assert.AreEqual ("AGoodTableName", mapping.TableName);

            Assert.AreEqual ("Id", mapping.Columns [0].Name);
            Assert.AreEqual ("AGoodColumnName", mapping.Columns [1].Name);
        }
Пример #18
0
		public void SetUp ()
		{
			db = new TestDb ();
			db.CreateTable<Product> ();
			
			var prods = new[] {
				new Product { Name = "Foo" },
				new Product { Name = "Bar" },
				new Product { Name = "Foobar" },
			};
			
			db.InsertAll (prods);
		}
Пример #19
0
        private static void VerifyCreations(TestDb db)
        {
            var orderLine = db.GetMapping(typeof(OrderLine));
            Assert.AreEqual(6, orderLine.Columns.Length);

            var l = new OrderLine()
            {
                Status = OrderLineStatus.Shipped
            };
            db.Insert(l);
            var lo = db.Table<OrderLine>().First(x => x.Status == OrderLineStatus.Shipped);
            Assert.AreEqual(lo.Id, l.Id);
        }
Пример #20
0
 static void CheckIndex(TestDb db, List<IndexInfo> indexes, string iname, bool unique, params string [] columns)
 {
     if (columns == null)
         throw new Exception ("Don't!");
     var idx = indexes.SingleOrDefault (i => i.name == iname);
     Assert.IsNotNull (idx, String.Format ("Index {0} not found", iname));
     Assert.AreEqual (idx.unique, unique, String.Format ("Index {0} unique expected {1} but got {2}", iname, unique, idx.unique));
     var idx_columns = db.Query<IndexColumns> (String.Format ("PRAGMA INDEX_INFO (\"{0}\")", iname));
     Assert.AreEqual (columns.Length, idx_columns.Count, String.Format ("# of columns: expected {0}, got {1}", columns.Length, idx_columns.Count));
     foreach (var col in columns) {
         Assert.IsNotNull (idx_columns.SingleOrDefault (c => c.name == col), String.Format ("Column {0} not in index {1}", col, idx.name));
     }
 }
Пример #21
0
        public void InheritanceWorks()
        {
            var fluentMapping = new TableBuilder<Derived>()
                .AsPrimaryKey(p => p.Id)
                .Build();

            SQLiteConnection.RegsiterMappings(new List<TableMapping>{ fluentMapping });
            var db = new TestDb();
            db.EnsureRegisteredMappings();
            var mapping = db.GetMapping<Derived>();

            Assert.AreEqual(3, mapping.Columns.Length);
            Assert.AreEqual("Id", mapping.PK.Name);
        }
Пример #22
0
		public void InsertSucceeds ()
		{
			var db = new TestDb ();
			db.CreateTable<TestObj> ();

			var o = new TestObj {
				Text = "Hello",
				IgnoredText = "World",
			};

			db.Insert (o);

			Assert.AreEqual (1, o.Id);
		}
Пример #23
0
        public void ImplicitPK()
        {
            var db = new TestDb();

            db.CreateTable<NoAttributes>(CreateFlags.ImplicitPK);

            var mapping = db.GetMapping<NoAttributes>();

            Assert.IsNotNull(mapping.PK);
            Assert.AreEqual("Id", mapping.PK.Name);
            Assert.IsTrue(mapping.PK.IsPK);
            Assert.IsFalse(mapping.PK.IsAutoInc);

            CheckPK(db);
        }
Пример #24
0
		public void Issue86 ()
		{
			var db = new TestDb ();
			db.CreateTable<Foo> ();

			db.Insert (new Foo { Bar = 42 } );
			db.Insert (new Foo { Bar = 69 } );

			var found42 = db.Table<Foo> ().Where (f => f.Bar == 42).FirstOrDefault();
			Assert.IsNotNull (found42);

			var ordered = new List<Foo>(db.Table<Foo>().OrderByDescending(f => f.Bar));
			Assert.AreEqual(2, ordered.Count);
			Assert.AreEqual(69, ordered[0].Bar);
			Assert.AreEqual(42, ordered[1].Bar);
		}
Пример #25
0
        void TestDateTime(TestDb db)
        {
            db.CreateTable<TestObj> ();

            TestObj o, o2;

            //
            // Ticks
            //
            o = new TestObj {
                ModifiedTime = new DateTime (2012, 1, 14, 3, 2, 1, 234),
            };
            db.Insert (o);
            o2 = db.Get<TestObj> (o.Id);
            Assert.AreEqual (o.ModifiedTime, o2.ModifiedTime);
        }
Пример #26
0
        public void Insert()
        {
            var db = new TestDb ();

            db.CreateTable<Product> ();

            string testString = "\u2329\u221E\u232A";

            db.Insert (new Product {
                Name = testString,
            });

            var p = db.Get<Product> (1);

            Assert.AreEqual (testString, p.Name);
        }
Пример #27
0
        public void WithoutImplicitMapping ()
        {
            var db = new TestDb ();

            db.CreateTable<NoAttributes>();

            var mapping = db.GetMapping<NoAttributes>();

            Assert.IsNull (mapping.PK);

            var column = mapping.Columns[2];
            Assert.AreEqual("IndexedId", column.Name);
            Assert.IsFalse(column.Indices.Any());

            Assert.Throws(typeof(AssertionException), () => CheckPK(db));
        }
Пример #28
0
		public void CreateTableWithNotNullConstraints ()
		{
			using (var db = new TestDb ()) {
				db.CreateTable<NotNullNoPK> ();
				var cols = db.GetTableInfo ("NotNullNoPK");

				var joined = from expected in GetExpectedColumnInfos (typeof (NotNullNoPK))
							 join actual in cols on expected.Name equals actual.Name
							 where actual.notnull != expected.notnull
							 select actual.Name;

				Assert.AreNotEqual (0, cols.Count (), "Failed to get table info");
				Assert.IsTrue (joined.Count () == 0, string.Format ("not null constraint was not created for the following properties: {0}"
					, string.Join (", ", joined.ToArray ())));
			}
		}
Пример #29
0
		SQLiteConnection CreateDbWithOne2Many ()
		{
			var db = new TestDb ()
				.SetForeignKeysPermissions(true);
			db.CreateTable<TestObjWithOne2Many> ();
			db.CreateTable<TestDependentObj> ();
			var items = Enumerable.Range(1,parentCount)
							.Select(i => new TestObjWithOne2Many {Id = i, 
																  ObjList = Enumerable.Range(1,childCount)
																	.Select(x => new TestDependentObj{OwnerId = i})
																										.ToList()}).ToList();
			db.InsertAll (items);
			Assert.AreEqual (parentCount, db.Table<TestObjWithOne2Many> ().Count ());
			Assert.AreEqual (parentCount * childCount , db.Table<TestDependentObj> ().Count ());
			return db;
		}
Пример #30
0
        public void Issue115_MissingPrimaryKey()
        {
            using (var conn = new TestDb()) {
                conn.CreateTable <Issue115_MyObject> ();
                conn.InsertAll(from i in Enumerable.Range(0, 10) select new Issue115_MyObject {
                    UniqueId   = i.ToString(),
                    OtherValue = (byte)(i * 10),
                });

                var query = conn.Table <Issue115_MyObject> ();
                foreach (var itm in query)
                {
                    itm.OtherValue++;
                    Assert.AreEqual(1, conn.Update(itm, typeof(Issue115_MyObject)));
                }
            }
        }
Пример #31
0
        public void SetUp()
        {
            _db = TestDb.GetMemoryDb();
            _db.CreateTable <Product> ();
            _db.CreateTable <Order> ();
            _db.CreateTable <OrderLine> ();

            var p1 = new Product {
                Name = "One",
            };
            var p2 = new Product {
                Name = "Two",
            };
            var p3 = new Product {
                Name = "Three",
            };

            _db.InsertAll(new [] { p1, p2, p3 });

            var o1 = new Order {
                PlacedTime = DateTime.Now,
            };
            var o2 = new Order {
                PlacedTime = DateTime.Now,
            };

            _db.InsertAll(new [] { o1, o2 });

            _db.InsertAll(new [] {
                new OrderLine {
                    OrderId   = o1.Id,
                    ProductId = p1.Id,
                    Quantity  = 1,
                },
                new OrderLine {
                    OrderId   = o1.Id,
                    ProductId = p2.Id,
                    Quantity  = 2,
                },
                new OrderLine {
                    OrderId   = o2.Id,
                    ProductId = p3.Id,
                    Quantity  = 3,
                },
            });
        }
Пример #32
0
        void TestTimeSpan(TestDb db, TimeSpan duration, string expected)
        {
            db.CreateTable <TestObj> ();

            TestObj o, o2;

            o = new TestObj {
                Duration = duration,
            };
            db.Insert(o);
            o2 = db.Get <TestObj> (o.Id);
            Assert.AreEqual(o.Duration, o2.Duration);

            var stored = db.ExecuteScalar <string> ("SELECT Duration FROM TestObj;");

            Assert.AreEqual(expected, stored);
        }
Пример #33
0
        public void Query()
        {
            var db = new TestDb();

            db.CreateTable <Product> ();

            string testString = "\u2329\u221E\u232A";

            db.Insert(new Product {
                Name = testString,
            });

            var ps = (from p in db.Table <Product> () where p.Name == testString select p).ToList();

            Assert.AreEqual(1, ps.Count);
            Assert.AreEqual(testString, ps [0].Name);
        }
        public void WithoutImplicitMapping()
        {
            var db = new TestDb();

            db.CreateTable <NoAttributes>();

            var mapping = db.GetMapping <NoAttributes>();

            Assert.IsNull(mapping.PK);

            var column = mapping.Columns[2];

            Assert.AreEqual("IndexedId", column.Name);
            Assert.IsFalse(column.Indices.Any());

            Assert.Throws(typeof(AssertionException), () => CheckPK(db));
        }
Пример #35
0
        public void WithoutImplicitMapping()
        {
            var db = new TestDb();

            db.CreateTable <NoAttributes>();

            var mapping = db.GetMapping <NoAttributes>();

            Assert.IsNull(mapping.PrimaryKey);

            var column = mapping.Columns[2];

            Assert.AreEqual("IndexedId", column.Name);
            Assert.IsFalse(column.Indices.Any());

            CheckPK(db);
        }
Пример #36
0
		public void Issue115_MissingPrimaryKey ()
		{
			using (var conn = new TestDb ()) {

				conn.CreateTable<Issue115_MyObject> ();
				conn.InsertAll (from i in Enumerable.Range (0, 10) select new Issue115_MyObject {
					UniqueId = i.ToString (),
					OtherValue = (byte)(i * 10),
				});

				var query = conn.Table<Issue115_MyObject> ();
				foreach (var itm in query) {
					itm.OtherValue++;
					Assert.AreEqual (1, conn.Update (itm, typeof(Issue115_MyObject)));
				}
			}
		}
Пример #37
0
		public void OnlyKey ()
		{
			var db = TestDb.GetMemoryDb();
			db.CreateTable<OnlyKeyModel> ();

			db.InsertOrReplace (new OnlyKeyModel { MyModelId = "Foo" });
			var foo = db.Get<OnlyKeyModel> ("Foo");
			Assert.AreEqual (foo.MyModelId, "Foo");

			db.Insert (new OnlyKeyModel { MyModelId = "Bar" });
			var bar = db.Get<OnlyKeyModel> ("Bar");
			Assert.AreEqual (bar.MyModelId, "Bar");

			db.Update (new OnlyKeyModel { MyModelId = "Foo" });
			var foo2 = db.Get<OnlyKeyModel> ("Foo");
			Assert.AreEqual (foo2.MyModelId, "Foo");
		}
Пример #38
0
        public void DerivedIgnore()
        {
            var db = TestDb.GetMemoryDb();

            db.CreateTable <DerivedIgnoreClass> ();

            var o = new DerivedIgnoreClass {
                Ignored    = "Hello",
                NotIgnored = "World",
            };

            db.Insert(o);

            var oo = db.Table <DerivedIgnoreClass> ().First();

            Assert.AreEqual(null, oo.Ignored);
            Assert.AreEqual("World", oo.NotIgnored);
        }
Пример #39
0
        public void GetDoesntHaveIgnores()
        {
            var db = TestDb.GetMemoryDb();

            db.CreateTable <TestObj> ();

            var o = new TestObj {
                Text        = "Hello",
                IgnoredText = "World",
            };

            db.Insert(o);

            var oo = db.Get <TestObj> (o.Id);

            Assert.AreEqual("Hello", oo.Text);
            Assert.AreEqual(null, oo.IgnoredText);
        }
Пример #40
0
        static void CheckIndex(TestDb db, List <IndexInfo> indexes, string iname, bool unique, params string [] columns)
        {
            if (columns == null)
            {
                throw new Exception("Don't!");
            }
            var idx = indexes.SingleOrDefault(i => i.name == iname);

            Assert.IsNotNull(idx, String.Format("Index {0} not found", iname));
            Assert.AreEqual(idx.unique, unique, String.Format("Index {0} unique expected {1} but got {2}", iname, unique, idx.unique));
            var idx_columns = db.Query <IndexColumns> (String.Format("PRAGMA INDEX_INFO (\"{0}\")", iname));

            Assert.AreEqual(columns.Length, idx_columns.Count, String.Format("# of columns: expected {0}, got {1}", columns.Length, idx_columns.Count));
            foreach (var col in columns)
            {
                Assert.IsNotNull(idx_columns.SingleOrDefault(c => c.name == col), String.Format("Column {0} not in index {1}", col, idx.name));
            }
        }
Пример #41
0
        public void BaseIgnores()
        {
            var db = TestDb.GetMemoryDb();

            db.CreateTable <TableClass> ();

            var o = new TableClass {
                ToIgnore = "Hello",
                Name     = "World",
            };

            db.Insert(o);

            var oo = db.Table <TableClass> ().First();

            Assert.AreEqual(null, oo.ToIgnore);
            Assert.AreEqual("World", oo.Name);
        }
Пример #42
0
        public void InsertWithExtra()
        {
            var db   = new TestDb(Path.GetTempFileName());
            var obj1 = new TestObj2()
            {
                Id = 1, Text = "GLaDOS loves testing!"
            };
            var obj2 = new TestObj2()
            {
                Id = 1, Text = "Keep testing, just keep testing"
            };
            var obj3 = new TestObj2()
            {
                Id = 1, Text = "Done testing"
            };

            db.Insert(obj1);


            try {
                db.Insert(obj2);
                Assert.Fail("Expected unique constraint violation");
            }
            catch (SQLiteException) {
            }
            db.Insert(obj2, "OR REPLACE");


            try {
                db.Insert(obj3);
                Assert.Fail("Expected unique constraint violation");
            }
            catch (SQLiteException) {
            }
            db.Insert(obj3, "OR IGNORE");

            var result = db.Query <TestObj>("select * from TestObj2").ToList();

            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(obj2.Text, result.First().Text);


            db.Close();
        }
        public void ExecuteNonQueryWithNullThrowsException()
        {
            using (TestDb db = new TestDb()) {
                TableMapping map;

                db.CreateTable <NotNullNoPK> ();

                try {
                    NotNullNoPK obj = new NotNullNoPK()
                    {
                        AnotherRequiredStringProp = "Another required prop",
                        RequiredIntProp           = 123,
                        RequiredStringProp        = "Required string prop"
                    };
                    db.Insert(obj);

                    map = db.GetMapping <NotNullNoPK> ();
                    map.GetInsertCommand(db, "OR REPLACE").ExecuteNonQuery(new object[] { 1, null, 123, null, null, null });
                }
                catch (NotNullConstraintViolationException) {
                    return;
                }
                catch (SQLiteException ex) {
#if PCLTESTS
                    if (ex.Result == SQLite3.Result.Constraint)
                    {
                        Inconclusive();
                        return;
                    }
#else
                    if (SQLite3.LibVersionNumber() < 3007017 && ex.Result == SQLite3.Result.Constraint)
                    {
                        Inconclusive();
                        return;
                    }
#endif
                }
                catch (Exception ex) {
                    Assert.Fail("Expected an exception of type NotNullConstraintViolationException to be thrown. An exception of type {0} was thrown instead.", ex.GetType().Name);
                }
            }
            Assert.Fail("Expected an exception of type NotNullConstraintViolationException to be thrown. No exception was thrown.");
        }
Пример #44
0
        public void SetUp()
        {
            db = new TestDb();
            db.CreateTable <Product> ();

            var prods = new[] {
                new Product {
                    Name = "Foo"
                },
                new Product {
                    Name = "Bar"
                },
                new Product {
                    Name = "Foobar"
                },
            };

            db.InsertAll(prods);
        }
Пример #45
0
        public void CreateInsertDrop()
        {
            var db = new TestDb();

            db.CreateTable <Product> ();

            db.Insert(new Product {
                Name  = "Hello",
                Price = 16,
            });

            var n = db.Table <Product> ().Count();

            Assert.AreEqual(1, n);

            db.DropTable <Product> ();

            ExceptionAssert.Throws <SQLiteException>(() => db.Table <Product> ().Count());
        }
Пример #46
0
        public void CreateInsertDrop()
        {
            var db = new TestDb();

            db.CreateTable <Product> ();

            db.Insert(new Product {
                Name  = "Hello",
                Price = 16,
            });

            var n = db.Table <Product> ().Count();

            Assert.AreEqual(1, n);

            db.DropTable <Product> ();

            db.Table <Product> ().Count();             // Should throw
        }
Пример #47
0
        void TestDateTime(TestDb db, DateTime dateTime, string expected)
        {
            db.CreateTable <TestObj> ();

            TestObj o, o2;

            //
            // Ticks
            //
            o = new TestObj {
                ModifiedTime = dateTime,
            };
            db.Insert(o);
            o2 = db.Get <TestObj> (o.Id);
            Assert.AreEqual(o.ModifiedTime, o2.ModifiedTime);

            var stored = db.ExecuteScalar <string> ("SELECT ModifiedTime FROM TestObj;");

            Assert.AreEqual(expected, stored);
        }
Пример #48
0
        public void SetUp()
        {
            db       = new TestDb();
            db.Trace = true;
            db.CreateTable <Product> ();
            db.CreateTable <Order> ();
            db.InsertAll(from i in Enumerable.Range(0, 22)
                         select new Product {
                Name = "Thing" + i, Price = (decimal)Math.Pow(2, i)
            });

            changeCount = 0;

            db.TableChanged += (sender, e) => {
                if (e.Table.TableName == "Product")
                {
                    changeCount++;
                }
            };
        }
Пример #49
0
        public void OverrideIgnore()
        {
            var db = new TestDb();

            db.CreateTable <OverrideClass> ();

            var o = new OverrideClass {
                Name   = "Foo",
                Value  = "Bar",
                Values = new List <string> {
                    "hello", "world"
                },
            };

            db.Insert(o);

            var oo = db.Table <OverrideClass> ().First();

            Assert.AreEqual("Foo", oo.Name);
            Assert.AreEqual("Bar", oo.Value);
            Assert.AreEqual(null, oo.Values);
        }
Пример #50
0
        public void InsertWithNullsThrowsException()
        {
            using (TestDb db = new TestDb()) {
                db.CreateTable <NotNullNoPK> ();

                try {
                    NotNullNoPK obj = new NotNullNoPK();
                    db.Insert(obj);
                }
                catch (NotNullConstraintViolationException) {
                    return;
                }
                catch (SQLiteException ex) {
                    if (SQLite3.LibVersionNumber() < 3007017 && ex.Result == SQLite3.Result.Constraint)
                    {
                        Inconclusive();
                        return;
                    }
                }
            }
            Assert.Fail("Expected an exception of type NotNullConstraintViolationException to be thrown. No exception was thrown.");
        }
Пример #51
0
        SQLiteConnection CreateDbWithOne2Many()
        {
            var db = new TestDb()
                     .SetForeignKeysPermissions(true);

            db.CreateTable <TestObjWithOne2Many> ();
            db.CreateTable <TestDependentObj> ();
            var items = Enumerable.Range(1, parentCount)
                        .Select(i => new TestObjWithOne2Many {
                Id      = i,
                ObjList = Enumerable.Range(1, childCount)
                          .Select(x => new TestDependentObj {
                    OwnerId = i
                })
                          .ToList()
            }).ToList();

            db.InsertAll(items);
            Assert.AreEqual(parentCount, db.Table <TestObjWithOne2Many> ().Count());
            Assert.AreEqual(parentCount * childCount, db.Table <TestDependentObj> ().Count());
            return(db);
        }
Пример #52
0
		public void OverrideNames ()
		{
			var db = TestDb.GetMemoryDb();
			db.CreateTable<OverrideNamesClass> ();

			var cols = db.GetTableInfo ("OverrideNamesClass");
			Assert.AreEqual (3, cols.Count);
			Assert.IsTrue (cols.Exists (x => x.Name == "n"));
			Assert.IsTrue (cols.Exists (x => x.Name == "v"));

			var o = new OverrideNamesClass {
				Name = "Foo",
				Value = "Bar",
			};

			db.Insert (o);

			var oo = db.Table<OverrideNamesClass> ().First ();

			Assert.AreEqual ("Foo", oo.Name);
			Assert.AreEqual ("Bar", oo.Value);
		}
Пример #53
0
        public void RedefinedIgnores()
        {
            var db = TestDb.GetMemoryDb();

            db.CreateTable <RedefinedClass> ();

            var o = new RedefinedClass {
                Name   = "Foo",
                Value  = "Bar",
                Values = new List <string> {
                    "hello", "world"
                },
            };

            db.Insert(o);

            var oo = db.Table <RedefinedClass> ().First();

            Assert.AreEqual("Foo", oo.Name);
            Assert.AreEqual("Bar", oo.Value);
            Assert.AreEqual(null, oo.Values);
        }
Пример #54
0
        public void NotNullConstraintExceptionListsOffendingColumnsOnUpdate()
        {
            // Skip this test if the Dll doesn't support the extended SQLITE_CONSTRAINT codes

            using (TestDb db = new TestDb()) {
                db.CreateTable <NotNullNoPK> ();

                try {
                    NotNullNoPK obj = new NotNullNoPK()
                    {
                        AnotherRequiredStringProp = "Another required string",
                        RequiredIntProp           = 123,
                        RequiredStringProp        = "Required string"
                    };
                    db.Insert(obj);
                    obj.RequiredStringProp = null;
                    db.Update(obj);
                }
                catch (NotNullConstraintViolationException ex) {
                    string expected = "RequiredStringProp";
                    string actual   = string.Join(", ", ex.Columns.Where(c => !c.IsPK).OrderBy(p => p.PropertyName).Select(c => c.PropertyName));

                    Assert.AreEqual(expected, actual, "NotNullConstraintViolationException did not correctly list the columns that violated the constraint");

                    return;
                }
                catch (SQLiteException ex) {
                    if (SQLite3.LibVersionNumber() < 3007017 && ex.Result == SQLite3.Result.Constraint)
                    {
                        Inconclusive();
                        return;
                    }
                }
                catch (Exception ex) {
                    Assert.Fail("Expected an exception of type NotNullConstraintViolationException to be thrown. An exception of type {0} was thrown instead.", ex.GetType().Name);
                }
                Assert.Fail("Expected an exception of type NotNullConstraintViolationException to be thrown. No exception was thrown.");
            }
        }
Пример #55
0
        public void UpdateWithPropertySet()
        {
            using (var db = new TestDb()) {
                // Arrange
                db.CreateTable <MyUpdatable> ();
                db.Insert(new MyUpdatable {
                    Text1 = "Message a"
                });

                // Act
                var entity = db.Table <MyUpdatable> ().First();
                entity.Text2 = "updated message";
                int updateCount = db.Update(entity, new[] { nameof(MyUpdatable.Text2) });
                var finalEntity = db.Table <MyUpdatable> ().First();

                // Assert
                Assert.AreEqual(1, updateCount);
                Assert.NotNull(finalEntity);
                Assert.AreEqual("Message a", finalEntity.Text1);
                Assert.AreEqual("updated message", finalEntity.Text2);
            }
        }
Пример #56
0
        public void NullableEnum()
        {
            var db = TestDb.GetMemoryDb();

            db.CreateTable <NullableEnumClass> ();

            var withNull = new NullableEnumClass {
                NullableIntEnum = null, NullableTextEnum = null
            };
            var with1 = new NullableEnumClass {
                NullableIntEnum = TestIntEnum.One, NullableTextEnum = null
            };
            var with2 = new NullableEnumClass {
                NullableIntEnum = TestIntEnum.Two, NullableTextEnum = null
            };
            var withNullA = new NullableEnumClass {
                NullableIntEnum = null, NullableTextEnum = TestTextEnum.Alpha
            };
            var with1B = new NullableEnumClass {
                NullableIntEnum = TestIntEnum.One, NullableTextEnum = TestTextEnum.Beta
            };

            db.Insert(withNull);
            db.Insert(with1);
            db.Insert(with2);
            db.Insert(withNullA);
            db.Insert(with1B);

            var results = db.Table <NullableEnumClass> ().OrderBy(x => x.ID).ToArray();

            Assert.AreEqual(5, results.Length);

            Assert.AreEqual(withNull, results[0]);
            Assert.AreEqual(with1, results[1]);
            Assert.AreEqual(with2, results[2]);
            Assert.AreEqual(withNullA, results[3]);
            Assert.AreEqual(with1B, results[4]);
        }
Пример #57
0
        public void InsertALot()
        {
            int n = 100000;
            var q = from i in Enumerable.Range(1, n)
                    select new TestObj()
            {
                Text = "I am"
            };
            var objs = q.ToArray();
            var db   = new TestDb(Path.GetTempFileName());

            db.Trace = false;

            var sw = new Stopwatch();

            sw.Start();

            var numIn = db.InsertAll(objs);

            sw.Stop();

            Assert.AreEqual(numIn, n, "Num inserted must = num objects");

            var inObjs = db.CreateCommand("select * from TestObj").ExecuteQuery <TestObj>().ToArray();

            for (var i = 0; i < inObjs.Length; i++)
            {
                Assert.AreEqual(i + 1, objs[i].Id);
                Assert.AreEqual(i + 1, inObjs[i].Id);
                Assert.AreEqual("I am", inObjs[i].Text);
            }

            var numCount = db.CreateCommand("select count(*) from TestObj").ExecuteScalar <int>();

            Assert.AreEqual(numCount, n, "Num counted must = num objects");

            db.Close();
        }
Пример #58
0
        public void SetStringKey()
        {
            string path;

            var key = "SecretPassword";

            using (var db = new TestDb(key: key)) {
                path = db.DatabasePath;

                db.CreateTable <TestTable> ();
                db.Insert(new TestTable {
                    Value = "Hello"
                });
            }

            using (var db = new TestDb(path, key: key)) {
                path = db.DatabasePath;

                var r = db.Table <TestTable> ().First();

                Assert.AreEqual("Hello", r.Value);
            }
        }
Пример #59
0
        public void CreateThem()
        {
            var db = new TestDb();

            db.CreateTable <Product> ();
            db.CreateTable <Order> ();
            db.CreateTable <OrderLine> ();
            db.CreateTable <OrderHistory> ();

            var orderLine = db.GetMapping(typeof(OrderLine));

            Assert.AreEqual(6, orderLine.Columns.Length, "Order history has 3 columns");

            var l = new OrderLine()
            {
                Status = OrderLineStatus.Shipped
            };

            db.Insert(l);
            var lo = db.Table <OrderLine>().Where(x => x.Status == CreateTableTest.OrderLineStatus.Shipped).FirstOrDefault();

            Assert.AreEqual(lo.Id, l.Id);
        }
Пример #60
0
        public void Issue86()
        {
            var db = new TestDb();

            db.CreateTable <Foo> ();

            db.Insert(new Foo {
                Bar = 42
            });
            db.Insert(new Foo {
                Bar = 69
            });

            var found42 = db.Table <Foo> ().Where(f => f.Bar == 42).FirstOrDefault();

            Assert.IsNotNull(found42);

            var ordered = new List <Foo>(db.Table <Foo>().OrderByDescending(f => f.Bar));

            Assert.AreEqual(2, ordered.Count);
            Assert.AreEqual(69, ordered[0].Bar);
            Assert.AreEqual(42, ordered[1].Bar);
        }