public void TestGetOneToManyListWithInverse()
        {
            var conn = Utils.CreateConnection();
            conn.DropTable<O2MClassC>();
            conn.DropTable<O2MClassD>();
            conn.CreateTable<O2MClassC>();
            conn.CreateTable<O2MClassD>();

            // Use standard SQLite-Net API to create the objects
            var objectsD = new List<O2MClassD>
            {
                new O2MClassD {
                    Foo = string.Format("1- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("2- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("3- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("4- Foo String {0}", new Random().Next(100))
                }
            };
            conn.InsertAll(objectsD);

            var objectC = new O2MClassC();
            conn.Insert(objectC);

            Assert.Null(objectC.DObjects);

            // Fetch (yet empty) the relationship
            conn.GetChildren(objectC);
            Assert.NotNull(objectC.DObjects);
            Assert.AreEqual(0, objectC.DObjects.Count);

            // Set the relationship using IDs
            foreach (var objectD in objectsD)
            {
                objectD.ClassCKey = objectC.Id;
                conn.Update(objectD);
            }

            Assert.NotNull(objectC.DObjects);
            Assert.AreEqual(0, objectC.DObjects.Count);

            // Fetch the relationship
            conn.GetChildren(objectC);

            Assert.NotNull(objectC.DObjects);
            Assert.AreEqual(objectsD.Count, objectC.DObjects.Count);
            var foos = objectsD.Select(objectB => objectB.Foo).ToList();
            foreach (var objectD in objectC.DObjects)
            {
                Assert.IsTrue(foos.Contains(objectD.Foo));
                Assert.AreEqual(objectC.Id, objectD.ObjectC.Id);
                Assert.AreEqual(objectC.Bar, objectD.ObjectC.Bar);
                Assert.AreSame(objectC, objectD.ObjectC); // Not only equal, they are the same!
            }
        }
Exemplo n.º 2
0
        public void TestUpdateSetOneToManyListWithInverse()
        {
            var conn = Utils.CreateConnection();

            conn.DropTable <O2MClassC>();
            conn.DropTable <O2MClassD>();
            conn.CreateTable <O2MClassC>();
            conn.CreateTable <O2MClassD>();

            // Use standard SQLite-Net API to create the objects
            var objectsD = new List <O2MClassD>
            {
                new O2MClassD {
                    Foo = string.Format("1- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("2- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("3- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("4- Foo String {0}", new Random().Next(100))
                }
            };

            conn.InsertAll(objectsD);

            var objectC = new O2MClassC();

            conn.Insert(objectC);

            Assert.Null(objectC.DObjects);

            objectC.DObjects = new ObservableCollection <O2MClassD>(objectsD);

            foreach (var objectD in objectsD)
            {
                Assert.AreEqual(0, objectD.ClassCKey, "Foreign keys shouldn't have been updated yet");
            }


            conn.UpdateWithChildren(objectC);

            foreach (var objectD in objectC.DObjects)
            {
                Assert.AreEqual(objectC.Id, objectD.ClassCKey, "Foreign keys haven't been updated yet");
                Assert.AreSame(objectC, objectD.ObjectC, "Inverse relationship hasn't been set");

                // Check database values
                var newObjectD = conn.Get <O2MClassD>(objectD.Id);
                Assert.AreEqual(objectC.Id, newObjectD.ClassCKey, "Database stored value is not correct");
            }
        }
        public void TestUpdateSetOneToManyListWithInverse()
        {
            var conn = Utils.CreateConnection();
            conn.DropTable<O2MClassC>();
            conn.DropTable<O2MClassD>();
            conn.CreateTable<O2MClassC>();
            conn.CreateTable<O2MClassD>();

            // Use standard SQLite-Net API to create the objects
            var objectsD = new List<O2MClassD>
            {
                new O2MClassD {
                    Foo = string.Format("1- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("2- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("3- Foo String {0}", new Random().Next(100))
                },
                new O2MClassD {
                    Foo = string.Format("4- Foo String {0}", new Random().Next(100))
                }
            };
            conn.InsertAll(objectsD);

            var objectC = new O2MClassC();
            conn.Insert(objectC);

            Assert.Null(objectC.DObjects);

            objectC.DObjects = new ObservableCollection<O2MClassD>(objectsD);

            foreach (var objectD in objectsD)
            {
                Assert.AreEqual(0, objectD.ClassCKey, "Foreign keys shouldn't have been updated yet");
            }


            conn.UpdateWithChildren(objectC);

            foreach (var objectD in objectC.DObjects)
            {
                Assert.AreEqual(objectC.Id, objectD.ClassCKey, "Foreign keys haven't been updated yet");
                Assert.AreSame(objectC, objectD.ObjectC, "Inverse relationship hasn't been set");

                // Check database values
                var newObjectD = conn.Get<O2MClassD>(objectD.Id);
                Assert.AreEqual(objectC.Id, newObjectD.ClassCKey, "Database stored value is not correct");
            }

        }