public void Test_GetReference_Async()
        {
            using (LogGroup logGroup = LogGroup.Start("Testing the GetReference function with an asynchronous reference to ensure it retrieves the correct reference.", NLog.LogLevel.Debug))
            {
                EntityFive e5 = new EntityFive();
                e5.ID   = Guid.NewGuid();
                e5.Name = "Test Entity 5";

                EntitySix e6 = new EntitySix();
                e6.ID   = Guid.NewGuid();
                e6.Name = "Test Entity 6";

                e5.ReferencedEntities = new EntitySix[] { e6 };

                DataAccess.Data.Saver.Save(e6);
                DataAccess.Data.Saver.Save(e5);

                EntityReference reference = DataAccess.Data.Referencer.GetReference(e5.GetType(),
                                                                                    e5.ID,
                                                                                    "ReferencedEntities",
                                                                                    e6.GetType(),
                                                                                    e6.ID,
                                                                                    String.Empty,
                                                                                    false);

                Assert.IsNotNull(reference, "The return value is null.");

                Assert.IsTrue(reference.Includes(e5.ID, "ReferencedEntities"), "The returned reference is invalid. (#1)");
                Assert.IsTrue(reference.Includes(e6.ID, ""), "The returned reference is invalid. (#2)");

                DataAccess.Data.Deleter.Delete(e5);
                DataAccess.Data.Deleter.Delete(e6);
            }
        }
        public void Test_Includes_Match()
        {
            Guid id1 = Guid.NewGuid();
            Guid id2 = Guid.NewGuid();

            string propertyName1 = "Property1";
            string propertyName2 = "Property2";

            string type1 = "Type1";
            string type2 = "Type2";

            EntityReference reference = new EntityReference();

            reference.Entity1ID     = id1;
            reference.Entity2ID     = id2;
            reference.Type1Name     = type1;
            reference.Type2Name     = type2;
            reference.Property1Name = propertyName1;
            reference.Property2Name = propertyName2;

            bool includes = reference.Includes(id1, propertyName1);

            Assert.IsTrue(includes, "Returned false when it should have returned true");

            includes = reference.Includes(id2, propertyName2);

            Assert.IsTrue(includes, "Returned false when it should have returned true");
        }
        public void Test_Includes_Match()
        {
            Guid id1 = Guid.NewGuid();
            Guid id2 = Guid.NewGuid();

            string propertyName1 = "Property1";
            string propertyName2 = "Property2";

            string type1 = "Type1";
            string type2 = "Type2";

            EntityReference reference = new EntityReference();
            reference.Entity1ID = id1;
            reference.Entity2ID = id2;
            reference.Type1Name = type1;
            reference.Type2Name = type2;
            reference.Property1Name = propertyName1;
            reference.Property2Name = propertyName2;

            bool includes = reference.Includes(id1, propertyName1);

            Assert.IsTrue(includes, "Returned false when it should have returned true");

            includes = reference.Includes(id2, propertyName2);

            Assert.IsTrue(includes, "Returned false when it should have returned true");
        }
        public void Test_GetReferences_2References()
        {
            using (LogGroup logGroup = LogGroup.Start("Testing the retrieval of references for an entity.", NLog.LogLevel.Debug))
            {
                TestUser user   = new TestUser();
                Guid     userID = user.ID = Guid.NewGuid();
                user.FirstName = "Test";
                user.LastName  = "User";

                TestRole role   = new TestRole();
                Guid     roleID = role.ID = Guid.NewGuid();
                role.Name = "Test Role";

                TestRole role2   = new TestRole();
                Guid     role2ID = role2.ID = Guid.NewGuid();
                role2.Name = "Test Role 2 ";

                user.Roles = new TestRole[] { role, role2 };

                DataAccess.Data.Saver.Save(role);
                DataAccess.Data.Saver.Save(role2);
                DataAccess.Data.Saver.Save(user);

                EntityReferenceCollection referenceEntities = DataAccess.Data.Referencer.GetReferences("TestUser", "TestRole");

                Assert.AreEqual(2, referenceEntities.Count, "Incorrect number of references found in the store after saving entities.");

                EntityReferenceCollection references = DataAccess.Data.Referencer.GetReferences(user.GetType(), user.ID, "Roles", typeof(TestRole), false);

                Assert.IsNotNull(references, "The references object returned was null.");

                if (references != null)
                {
                    Assert.AreEqual(2, references.Count, "Wrong number of references returned.");

                    EntityReference reference1 = references[0];
                    EntityReference reference2 = references[1];

                    // Switch the references around if necessary to match (so they can be found in any order)
                    if (!reference1.Includes(role.ID, "Users"))
                    {
                        EntityReference tmp = reference1;
                        reference1 = reference2;
                        reference2 = tmp;
                    }

                    Assert.IsTrue(reference1.Includes(userID, "Roles"), "The user ID wasn't found on the reference.");
                    Assert.IsTrue(reference1.Includes(roleID, "Users"), "The role ID wasn't found on the reference.");

                    Assert.IsTrue(reference2.Includes(userID, "Roles"), "The user ID wasn't found on the second reference.");
                    Assert.IsTrue(reference2.Includes(role2ID, "Users"), "The role2 ID wasn't found on the second reference.");
                }
            }
        }
Beispiel #5
0
        public void Test_Save_2ConvergingReferences()
        {
            TestUser user = new TestUser();

            user.ID = Guid.NewGuid();
            Guid userID = user.ID;

            user.FirstName = "Test";
            user.LastName  = "User";

            TestRole role = new TestRole();

            role.ID = Guid.NewGuid();
            Guid roleID = role.ID;

            role.Name = "Test Role";

            TestUser user2 = new TestUser();

            user.ID = Guid.NewGuid();
            Guid user2ID = user.ID;

            user2.FirstName = "Test2";
            user2.LastName  = "User2";

            TestRole role2 = new TestRole();

            role2.ID = Guid.NewGuid();
            Guid role2ID = role2.ID;

            role2.Name = "Test Role2";

            user.Roles = new TestRole[] { role, role2 };

            DataAccess.Data.Saver.Save(role2);
            DataAccess.Data.Saver.Save(role);
            DataAccess.Data.Saver.Save(user);

            EntityReferenceCollection references = DataAccess.Data.Referencer.GetReferences("TestUser", "TestRole");

            Assert.AreEqual(2, references.Count, "Incorrect number of references found.");

            EntityReference reference1 = (EntityReference)references[0];
            EntityReference reference2 = (EntityReference)references[1];

            // Switch the references around if necessary to match (so they can be found in any order)
            if (!reference1.Includes(role.ID, "Users"))
            {
                EntityReference tmp = reference1;
                reference1 = reference2;
                reference2 = tmp;
            }

            Assert.IsTrue(reference1.Includes(user.ID, "Roles"), "First reference does not include expected user.");
            Assert.IsTrue(reference1.Includes(role.ID, "Users"), "First reference does not include expected role.");

            Assert.IsTrue(reference2.Includes(user.ID, "Roles"), "Second reference does not include expected user.");
            Assert.IsTrue(reference2.Includes(role2.ID, "Users"), "Second reference does not include expected role.");

            Assert.IsFalse(reference1.Includes(role2.ID, "Users"), "First reference includes unexpected role.");

            Assert.IsFalse(reference2.Includes(role.ID, "Users"), "Second reference includes unexpected role.");
        }