public void AccessInvalidForeignKeyRelation()
        {
            var id = new ObjectID(typeof(ClassWithInvalidRelation), new Guid("{AFA9CF46-8E77-4da8-9793-53CAA86A277C}"));
            var objectWithInvalidRelation = (ClassWithInvalidRelation)id.GetObject <TestDomainBase> ();

            Assert.That(objectWithInvalidRelation.ClassWithGuidKey.State, Is.Not.EqualTo(StateType.Invalid));

            Assert.That(() => objectWithInvalidRelation.ClassWithGuidKey.EnsureDataAvailable(), Throws.TypeOf <ObjectsNotFoundException>());

            Assert.That(objectWithInvalidRelation.ClassWithGuidKey.State, Is.EqualTo(StateType.Invalid));

            // Overwriting the invalid ID is possible!
            var classWithGuidKey = ClassWithGuidKey.NewObject();

            classWithGuidKey.ClassWithValidRelationsNonOptional = ClassWithValidRelations.NewObject();
            objectWithInvalidRelation.ClassWithGuidKey          = classWithGuidKey;

            SetDatabaseModifyable();
            TestableClientTransaction.Commit();

            using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
            {
                var reloadedObject = (ClassWithInvalidRelation)id.GetObject <TestDomainBase> ();
                reloadedObject.ClassWithGuidKey.EnsureDataAvailable();
                Assert.That(reloadedObject.ClassWithGuidKey.State, Is.Not.EqualTo(StateType.Invalid));
            }

            // Note: See also NotFoundObjectsTest
        }
Example #2
0
        public void LoadObjectsOverRelationTest()
        {
            const int numberOfTests = 10;

            Console.WriteLine("Expected average duration of LoadObjectsOverRelationTest on reference system: ~230 ms (release build), ~313 ms (debug build)");

            Stopwatch stopwatch = new Stopwatch();

            for (int i = 0; i < numberOfTests; i++)
            {
                using (ClientTransaction.CreateRootTransaction().EnterScope(AutoRollbackBehavior.None))
                {
                    Client client = _clientID.GetObject <Client>();

                    stopwatch.Start();

                    DomainObjectCollection files = client.Files;

                    stopwatch.Stop();

                    Assert.That(files.Count, Is.EqualTo(6000));
                }
            }

            double averageMilliSeconds = stopwatch.ElapsedMilliseconds / numberOfTests;

            Console.WriteLine("LoadObjectsOverRelationTest (executed {0}x): Average duration: {1} ms", numberOfTests, averageMilliSeconds.ToString("n"));
        }
        public void LoadObjectsWithSamePropertyNameInDifferentInheritanceBranches()
        {
            TIFolder rootFolder = _rootFolderID.GetObject <TIFolder> ();

            Assert.That(rootFolder.CreatedAt, Is.EqualTo(new DateTime(2006, 2, 1)));

            TIFile fileInRootFolder = _fileInRootFolderID.GetObject <TIFile> ();

            Assert.That(fileInRootFolder.CreatedAt, Is.EqualTo(new DateTime(2006, 2, 3)));
        }
        public void CompositePatternNavigateOneToMany()
        {
            TIFolder rootFolder = _rootFolderID.GetObject <TIFolder> ();

            Assert.That(rootFolder.FileSystemItems.Count, Is.EqualTo(2));
            Assert.That(rootFolder.FileSystemItems[0].ID, Is.EqualTo(_fileInRootFolderID));
            Assert.That(rootFolder.FileSystemItems[1].ID, Is.EqualTo(_folder1ID));

            TIFolder folder1 = _folder1ID.GetObject <TIFolder> ();

            Assert.That(folder1.FileSystemItems.Count, Is.EqualTo(1));
            Assert.That(folder1.FileSystemItems[0].ID, Is.EqualTo(_fileInFolder1ID));
        }
        public void UnidirectionalRelationProperty_ShouldReturnInvalidObject()
        {
            SetDatabaseModifyable();

            // Need to disable the foreign key constraints so that the property is allowed to point to an invalid ID in the database
            var clientTable = (TableDefinition)GetTypeDefinition(typeof(Client)).StorageEntityDefinition;

            DisableConstraints(clientTable);

            ObjectID clientID = null;

            try
            {
                clientID = CreateClientWithNonExistingParentClient();

                var    client   = clientID.GetObject <Client> ();
                Client instance = null;
                Assert.That(() => instance = client.ParentClient, Throws.Nothing);
                Assert.That(instance.State, Is.EqualTo(StateType.NotLoadedYet));

                Assert.That(() => instance.EnsureDataAvailable(), Throws.TypeOf <ObjectsNotFoundException>());
                CheckObjectIsMarkedInvalid(instance.ID);
            }
            finally
            {
                if (clientID != null)
                {
                    CleanupClientWithNonExistingParentClient(clientID);
                }

                EnableConstraints(clientTable);
            }
        }
        public void ObjectHierarchyNavigateManyToOne()
        {
            DerivedClassWithEntityWithHierarchy derivedClassWithEntity2 = _derivedClassWithEntity2ID.GetObject <DerivedClassWithEntityWithHierarchy>();

            Assert.That(derivedClassWithEntity2.ParentAbstractBaseClassWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity1ID));
            Assert.That(derivedClassWithEntity2.ParentDerivedClassWithEntityWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity1ID));

            DerivedClassWithEntityWithHierarchy derivedClassWithEntity3 = _derivedClassWithEntity3ID.GetObject <DerivedClassWithEntityWithHierarchy>();

            Assert.That(derivedClassWithEntity3.ParentAbstractBaseClassWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity1ID));
            Assert.That(derivedClassWithEntity3.ParentDerivedClassWithEntityWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity1ID));

            DerivedClassWithEntityFromBaseClassWithHierarchy derivedClassWithEntityFromBaseClass1 =
                _derivedClassWithEntityFromBaseClass1ID.GetObject <DerivedClassWithEntityFromBaseClassWithHierarchy> ();

            Assert.That(derivedClassWithEntityFromBaseClass1.ParentAbstractBaseClassWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity1ID));
            Assert.That(derivedClassWithEntityFromBaseClass1.ParentDerivedClassWithEntityWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity1ID));

            DerivedClassWithEntityFromBaseClassWithHierarchy derivedClassWithEntityFromBaseClass2 =
                _derivedClassWithEntityFromBaseClass2ID.GetObject <DerivedClassWithEntityFromBaseClassWithHierarchy> ();

            Assert.That(derivedClassWithEntityFromBaseClass2.ParentAbstractBaseClassWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity2ID));
            Assert.That(derivedClassWithEntityFromBaseClass2.ParentDerivedClassWithEntityWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity2ID));
            Assert.That(derivedClassWithEntityFromBaseClass2.ParentDerivedClassWithEntityFromBaseClassWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass1ID));

            DerivedClassWithEntityFromBaseClassWithHierarchy derivedClassWithEntityFromBaseClass3 =
                _derivedClassWithEntityFromBaseClass3ID.GetObject <DerivedClassWithEntityFromBaseClassWithHierarchy> ();

            Assert.That(derivedClassWithEntityFromBaseClass3.ParentAbstractBaseClassWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity3ID));
            Assert.That(derivedClassWithEntityFromBaseClass3.ParentDerivedClassWithEntityWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntity3ID));
            Assert.That(derivedClassWithEntityFromBaseClass3.ParentDerivedClassWithEntityFromBaseClassWithHierarchy.ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass1ID));
        }
        public void SaveHierarchy()
        {
            Employee supervisor  = Employee.NewObject();
            Employee subordinate = Employee.NewObject();

            ObjectID supervisorID  = supervisor.ID;
            ObjectID subordinateID = subordinate.ID;

            supervisor.Name  = "Slartibartfast";
            subordinate.Name = "Zarniwoop";
            supervisor.Subordinates.Add(subordinate);

            TestableClientTransaction.Commit();
            ReInitializeTransaction();

            supervisor  = supervisorID.GetObject <Employee> ();
            subordinate = subordinateID.GetObject <Employee> ();

            Assert.That(supervisor, Is.Not.Null);
            Assert.That(subordinate, Is.Not.Null);

            Assert.That(supervisor.ID, Is.EqualTo(supervisorID));
            Assert.That(subordinate.ID, Is.EqualTo(subordinateID));

            Assert.That(supervisor.Name, Is.EqualTo("Slartibartfast"));
            Assert.That(subordinate.Name, Is.EqualTo("Zarniwoop"));
        }
        public void OnLoadedInParentAndSubTransaction()
        {
            var id = new ObjectID("ClassWithAllDataTypes", new Guid("{3F647D79-0CAF-4a53-BAA7-A56831F8CE2D}"));

            ClassWithAllDataTypes classWithAllDataTypes = id.GetObject <ClassWithAllDataTypes> ();

            Assert.That(classWithAllDataTypes.OnLoadedCalled, Is.True);
            Assert.That(classWithAllDataTypes.OnLoadedCallCount, Is.EqualTo(1));
            Assert.That(classWithAllDataTypes.OnLoadedLoadMode, Is.EqualTo(LoadMode.WholeDomainObjectInitialized));

            using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
            {
                id.GetObject <ClassWithAllDataTypes> ();

                Assert.That(classWithAllDataTypes.OnLoadedCallCount, Is.EqualTo(2));
                Assert.That(classWithAllDataTypes.OnLoadedLoadMode, Is.EqualTo(LoadMode.DataContainerLoadedOnly));
            }
        }
 private void ModifyAndCommitInOtherTransaction(ObjectID objectID)
 {
     using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
     {
         var domainObject = objectID.GetObject <ClassWithAllDataTypes> ();
         ++domainObject.Int32Property;
         ClientTransaction.Current.Commit();
     }
 }
 private void CleanupClientWithNonExistingParentClient(ObjectID clientID)
 {
     using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
     {
         var client = clientID.GetObject <Client> ();
         client.Delete();
         ClientTransaction.Current.Commit();
     }
 }
        public void OnLoaded()
        {
            var id = new ObjectID("ClassWithAllDataTypes", new Guid("{3F647D79-0CAF-4a53-BAA7-A56831F8CE2D}"));

            ClassWithAllDataTypes classWithAllDataTypes = id.GetObject <ClassWithAllDataTypes> ();

            Assert.That(classWithAllDataTypes.OnLoadedCalled, Is.True);
            Assert.That(classWithAllDataTypes.OnLoadedCallCount, Is.EqualTo(1));
            Assert.That(classWithAllDataTypes.OnLoadedLoadMode, Is.EqualTo(LoadMode.WholeDomainObjectInitialized));
        }
Example #12
0
        private Order LoadOrderWithRelations(ObjectID objectID)
        {
            var order = objectID.GetObject <Order> ();

            order.EnsureDataAvailable();
            ClientTransaction.Current.EnsureDataComplete(RelationEndPointID.Resolve(order, o => o.OrderTicket));
            ClientTransaction.Current.EnsureDataComplete(RelationEndPointID.Resolve(order, o => o.OrderItems));
            ClientTransaction.Current.EnsureDataComplete(RelationEndPointID.Resolve(order, o => o.Customer));
            return(order);
        }
 protected void CheckIfObjectIsDeleted(ObjectID id)
 {
     try
     {
         DomainObject domainObject = id.GetObject <TestDomainBase> (includeDeleted: true);
         Assert.IsNull(domainObject, string.Format("Object '{0}' was not deleted.", id));
     }
     catch (ObjectsNotFoundException)
     {
     }
 }
        public void RootToSubDeletedThrowsWhenReloadingTheObject()
        {
            Order    obj = GetDeleted();
            ObjectID id  = obj.ID;

            using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
            {
                Assert.That(obj.State, Is.EqualTo(StateType.Invalid));
                id.GetObject <Order> ();
            }
        }
Example #15
0
        public bool MoveNext()
        {
            if (nextObjectId == null || nextObjectId.IsNull)
            {
                return(false);
            }

            Current          = nextObjectId.GetObject(data);
            Current.ObjectID = nextObjectId;
            nextObjectId     = new ObjectID(Current.NextObjectID);
            return(true);
        }
        public void CompositePatternNavigateManyToOne()
        {
            TIFolder folder1 = _folder1ID.GetObject <TIFolder> ();

            Assert.That(folder1.ParentFolder.ID, Is.EqualTo(_rootFolderID));

            TIFile fileInRootFolder = _fileInRootFolderID.GetObject <TIFile> ();

            Assert.That(fileInRootFolder.ParentFolder.ID, Is.EqualTo(_rootFolderID));

            TIFile fileInFolder1 = _fileInFolder1ID.GetObject <TIFile> ();

            Assert.That(fileInFolder1.ParentFolder.ID, Is.EqualTo(_folder1ID));
        }
        public void GetObject_True_ShouldThrow_AndMarkObjectNotFound()
        {
            Assert.That(() => _nonExistingObjectID.GetObject <Order> (includeDeleted: true), ThrowsObjectNotFoundException(_nonExistingObjectID));

            CheckObjectIsMarkedInvalid(_nonExistingObjectID);

            // After the object has been marked invalid
            Assert.That(() => _nonExistingObjectID.GetObject <Order> (includeDeleted: true), ThrowsObjectInvalidException(_nonExistingObjectID));
        }
        public void ObjectHierarchyNavigateOneToMany()
        {
            DerivedClassWithEntityWithHierarchy derivedClassWithEntity1 = _derivedClassWithEntity1ID.GetObject <DerivedClassWithEntityWithHierarchy>();

            Assert.That(derivedClassWithEntity1.ChildAbstractBaseClassesWithHierarchy.Count, Is.EqualTo(3));
            Assert.That(derivedClassWithEntity1.ChildAbstractBaseClassesWithHierarchy[0].ID, Is.EqualTo(_derivedClassWithEntity3ID));
            Assert.That(derivedClassWithEntity1.ChildAbstractBaseClassesWithHierarchy[1].ID, Is.EqualTo(_derivedClassWithEntity2ID));
            Assert.That(derivedClassWithEntity1.ChildAbstractBaseClassesWithHierarchy[2].ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass1ID));

            Assert.That(derivedClassWithEntity1.ChildDerivedClassesWithEntityWithHierarchy.Count, Is.EqualTo(3));
            Assert.That(derivedClassWithEntity1.ChildDerivedClassesWithEntityWithHierarchy[0].ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass1ID));
            Assert.That(derivedClassWithEntity1.ChildDerivedClassesWithEntityWithHierarchy[1].ID, Is.EqualTo(_derivedClassWithEntity2ID));
            Assert.That(derivedClassWithEntity1.ChildDerivedClassesWithEntityWithHierarchy[2].ID, Is.EqualTo(_derivedClassWithEntity3ID));

            DerivedClassWithEntityWithHierarchy derivedClassWithEntity2 = _derivedClassWithEntity2ID.GetObject <DerivedClassWithEntityWithHierarchy>();
            DerivedClassWithEntityWithHierarchy derivedClassWithEntity3 = _derivedClassWithEntity3ID.GetObject <DerivedClassWithEntityWithHierarchy>();

            Assert.That(derivedClassWithEntity2.ChildAbstractBaseClassesWithHierarchy.Count, Is.EqualTo(1));
            Assert.That(derivedClassWithEntity2.ChildAbstractBaseClassesWithHierarchy[0].ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass2ID));
            Assert.That(derivedClassWithEntity2.ChildDerivedClassesWithEntityWithHierarchy.Count, Is.EqualTo(1));
            Assert.That(derivedClassWithEntity2.ChildDerivedClassesWithEntityWithHierarchy[0].ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass2ID));

            Assert.That(derivedClassWithEntity3.ChildAbstractBaseClassesWithHierarchy.Count, Is.EqualTo(1));
            Assert.That(derivedClassWithEntity3.ChildAbstractBaseClassesWithHierarchy[0].ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass3ID));
            Assert.That(derivedClassWithEntity3.ChildDerivedClassesWithEntityWithHierarchy.Count, Is.EqualTo(1));
            Assert.That(derivedClassWithEntity3.ChildDerivedClassesWithEntityWithHierarchy[0].ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass3ID));

            DerivedClassWithEntityFromBaseClassWithHierarchy derivedClassWithEntityFromBaseClass1 =
                _derivedClassWithEntityFromBaseClass1ID.GetObject <DerivedClassWithEntityFromBaseClassWithHierarchy> ();

            Assert.That(derivedClassWithEntityFromBaseClass1.ChildAbstractBaseClassesWithHierarchy, Is.Empty);
            Assert.That(derivedClassWithEntityFromBaseClass1.ChildDerivedClassesWithEntityWithHierarchy, Is.Empty);
            Assert.That(derivedClassWithEntityFromBaseClass1.ChildDerivedClassesWithEntityFromBaseClassWithHierarchy.Count, Is.EqualTo(2));
            Assert.That(derivedClassWithEntityFromBaseClass1.ChildDerivedClassesWithEntityFromBaseClassWithHierarchy[0].ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass2ID));
            Assert.That(derivedClassWithEntityFromBaseClass1.ChildDerivedClassesWithEntityFromBaseClassWithHierarchy[1].ID, Is.EqualTo(_derivedClassWithEntityFromBaseClass3ID));
        }
        public void BidirectionalForeignKeyRelationProperty_ShouldReturnNotLoadedObject()
        {
            var id = new ObjectID(typeof(ClassWithInvalidRelation), new Guid("{AFA9CF46-8E77-4da8-9793-53CAA86A277C}"));
            var objectWithInvalidRelation = (ClassWithInvalidRelation)id.GetObject <TestDomainBase> ();

            DomainObject instance = null;

            Assert.That(() => instance = objectWithInvalidRelation.ClassWithGuidKey, Throws.Nothing);

            Assert.That(instance.State, Is.EqualTo(StateType.NotLoadedYet));

            Assert.That(() => instance.EnsureDataAvailable(), Throws.TypeOf <ObjectsNotFoundException>());
            CheckObjectIsMarkedInvalid(instance.ID);

            // Note: See also ObjectWithInvalidForeignKeyTest
        }
        public void BidirectionalForeignKeyRelationProperty_Subtransaction()
        {
            DomainObject instance = null;

            using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
            {
                var id = new ObjectID(typeof(ClassWithInvalidRelation), new Guid("{AFA9CF46-8E77-4da8-9793-53CAA86A277C}"));

                var objectWithInvalidRelation = (ClassWithInvalidRelation)id.GetObject <TestDomainBase> ();

                Assert.That(() => instance = objectWithInvalidRelation.ClassWithGuidKey, Throws.Nothing);
                Assert.That(instance.State, Is.EqualTo(StateType.NotLoadedYet));

                Assert.That(() => instance.EnsureDataAvailable(), Throws.TypeOf <ObjectsNotFoundException> ());
                CheckObjectIsMarkedInvalid(instance.ID);
            }
            CheckObjectIsMarkedInvalid(instance.ID);
        }
Example #21
0
        public void Loading()
        {
            var newInstanceID = new ObjectID(typeof(SampleBindableDomainObject), Guid.NewGuid());

            try
            {
                StubStorageProvider.LoadDataContainerResult = DataContainer.CreateNew(newInstanceID);
                {
                    var instance       = newInstanceID.GetObject <SampleBindableDomainObject>();
                    var implementation = (BindableDomainObjectImplementation)PrivateInvoke.GetNonPublicField(instance, "_implementation");
                    Assert.That(implementation, Is.Not.Null);
                    Assert.That(implementation.BusinessObjectClass, Is.Not.Null);
                }
            }
            finally
            {
                StubStorageProvider.LoadDataContainerResult = null;
            }
        }
        public void SaveExistingObjectWithRelatedNew()
        {
            Computer computer      = DomainObjectIDs.Computer4.GetObject <Computer> ();
            Employee newEmployee   = Employee.NewObject();
            ObjectID newEmployeeID = newEmployee.ID;

            newEmployee.Computer = computer;
            newEmployee.Name     = "Arthur Dent";

            TestableClientTransaction.Commit();
            ReInitializeTransaction();

            computer    = DomainObjectIDs.Computer4.GetObject <Computer> ();
            newEmployee = newEmployeeID.GetObject <Employee> ();

            Assert.That(newEmployee, Is.Not.Null);
            Assert.That(newEmployee.Name, Is.EqualTo("Arthur Dent"));
            Assert.That(newEmployee.Computer, Is.SameAs(computer));
        }
        public void CreateObjectsAndCommit()
        {
            SetDatabaseModifyable();

            Client   client1  = Client.NewObject();
            Client   client2  = Client.NewObject();
            Location location = Location.NewObject();

            SequenceEventReceiver eventReceiver = new SequenceEventReceiver(new DomainObject[] { location, client1, client2 }, new DomainObjectCollection[0]);

            location.Client = client1;

            Assert.That(client1.State, Is.EqualTo(StateType.New));
            Assert.That(client2.State, Is.EqualTo(StateType.New));
            Assert.That(location.State, Is.EqualTo(StateType.New));

            ObjectID clientID1  = client1.ID;
            ObjectID clientID2  = client2.ID;
            ObjectID locationID = location.ID;


            ChangeState[] expectedStates = new ChangeState[]
            {
                new RelationChangeState(location, "Remotion.Data.DomainObjects.UnitTests.TestDomain.Location.Client", null, client1, "1. Changing event of location"),
                new RelationChangeState(location, "Remotion.Data.DomainObjects.UnitTests.TestDomain.Location.Client", null, null, "2. Changed event of location")
            };

            eventReceiver.Check(expectedStates);

            TestableClientTransaction.Commit();

            using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
            {
                client1  = clientID1.GetObject <Client> ();
                client2  = clientID2.GetObject <Client> ();
                location = locationID.GetObject <Location>();

                Assert.That(client1, Is.Not.Null);
                Assert.That(client2, Is.Not.Null);
                Assert.That(location, Is.Not.Null);
                Assert.That(location.Client, Is.SameAs(client1));
            }
        }
        public void GetObject_Subtransaction()
        {
            using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
            {
                Assert.That(
                    () => _nonExistingObjectIDForSubtransaction.GetObject <TestDomainBase> (includeDeleted: true),
                    ThrowsObjectInvalidException(_nonExistingObjectIDForSubtransaction));

                CheckObjectIsMarkedInvalid(_nonExistingObjectIDForSubtransaction);

                Assert.That(
                    () => _nonExistingObjectID.GetObject <TestDomainBase> (includeDeleted: true),
                    ThrowsObjectNotFoundException(_nonExistingObjectID));

                CheckObjectIsMarkedInvalid(_nonExistingObjectID);
            }

            CheckObjectIsMarkedInvalid(_nonExistingObjectID);
            CheckObjectIsNotMarkedInvalid(_nonExistingObjectIDForSubtransaction);
        }
        public void CreateHierarchy()
        {
            SetDatabaseModifyable();

            Client newClient1 = Client.NewObject();
            Client newClient2 = Client.NewObject();

            newClient2.ParentClient = newClient1;

            ObjectID newClientID1 = newClient1.ID;
            ObjectID newClientID2 = newClient2.ID;

            TestableClientTransaction.Commit();

            using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
            {
                newClient1 = newClientID1.GetObject <Client> ();
                newClient2 = newClientID2.GetObject <Client> ();

                Assert.That(newClient1, Is.Not.Null);
                Assert.That(newClient2, Is.Not.Null);
                Assert.That(newClient2.ParentClient, Is.SameAs(newClient1));
            }
        }
        public void TestAllOperationsWithHierarchy()
        {
            Employee newSupervisor1   = Employee.NewObject();
            ObjectID newSupervisor1ID = newSupervisor1.ID;

            Employee newSubordinate1   = Employee.NewObject();
            ObjectID newSubordinate1ID = newSubordinate1.ID;

            newSubordinate1.Supervisor = newSupervisor1;

            Employee supervisor1  = DomainObjectIDs.Employee1.GetObject <Employee> ();
            Employee subordinate4 = DomainObjectIDs.Employee4.GetObject <Employee> ();

            Employee supervisor2  = DomainObjectIDs.Employee2.GetObject <Employee> ();
            Employee subordinate3 = DomainObjectIDs.Employee3.GetObject <Employee> ();

            supervisor2.Supervisor = supervisor1;
            supervisor2.Name       = "New name of supervisor";
            subordinate3.Name      = "New name of subordinate";

            Employee supervisor6 = DomainObjectIDs.Employee6.GetObject <Employee> ();

            Dev.Null = DomainObjectIDs.Employee7.GetObject <Employee> ();

            Employee newSubordinate2   = Employee.NewObject();
            ObjectID newSubordinate2ID = newSubordinate2.ID;
            Employee newSubordinate3   = Employee.NewObject();
            ObjectID newSubordinate3ID = newSubordinate3.ID;

            newSupervisor1.Supervisor  = supervisor2;
            newSubordinate2.Supervisor = supervisor1;
            newSubordinate3.Supervisor = supervisor6;

            supervisor1.Delete();
            subordinate4.Delete();

            TestableClientTransaction.Commit();
            ReInitializeTransaction();

            newSupervisor1  = newSupervisor1ID.GetObject <Employee> ();
            newSubordinate1 = newSubordinate1ID.GetObject <Employee> ();

            Assert.That(newSubordinate1.Supervisor, Is.SameAs(newSupervisor1));
            Assert.That(newSupervisor1.Subordinates.Contains(newSubordinate1ID), Is.True);

            supervisor2 = DomainObjectIDs.Employee2.GetObject <Employee> ();

            Assert.That(supervisor2.Supervisor, Is.Null);
            Assert.That(supervisor2.Name, Is.EqualTo("New name of supervisor"));

            subordinate3 = DomainObjectIDs.Employee3.GetObject <Employee> ();

            Assert.That(subordinate3.Supervisor, Is.SameAs(supervisor2));
            Assert.That(supervisor2.Subordinates.Contains(DomainObjectIDs.Employee3), Is.True);
            Assert.That(subordinate3.Name, Is.EqualTo("New name of subordinate"));

            Assert.That(newSupervisor1.Supervisor, Is.SameAs(supervisor2));
            Assert.That(supervisor2.Subordinates.Contains(newSupervisor1ID), Is.True);

            newSubordinate2 = newSubordinate2ID.GetObject <Employee> ();

            Assert.That(newSubordinate2.Supervisor, Is.Null);

            supervisor6     = DomainObjectIDs.Employee6.GetObject <Employee> ();
            newSubordinate3 = newSubordinate3ID.GetObject <Employee> ();

            Assert.That(newSubordinate3.Supervisor, Is.SameAs(supervisor6));
            Assert.That(supervisor6.Subordinates.Contains(newSubordinate3ID), Is.True);

            CheckIfObjectIsDeleted(DomainObjectIDs.Employee1);
            CheckIfObjectIsDeleted(DomainObjectIDs.Employee4);
        }
        public void TestAllOperations()
        {
            Order order1 = DomainObjectIDs.Order1.GetObject <Order> ();
            Order order3 = DomainObjectIDs.Order3.GetObject <Order> ();

            Customer customer1 = order1.Customer;
            Customer customer4 = DomainObjectIDs.Customer4.GetObject <Customer> ();

            Order order4 = customer4.Orders[DomainObjectIDs.Order4];

            Dev.Null = customer4.Orders[DomainObjectIDs.Order5];

            OrderTicket orderTicket1 = order1.OrderTicket;
            OrderTicket orderTicket3 = order3.OrderTicket;

            Official official1 = order1.Official;

            var orderItem1 = order1.OrderItems[DomainObjectIDs.OrderItem1];
            var orderItem2 = order1.OrderItems[DomainObjectIDs.OrderItem2];

            Dev.Null = order4.OrderItems[DomainObjectIDs.OrderItem4];

            order1.Delete();
            orderItem1.Delete();
            orderItem2.Delete();

            order4.OrderNumber = 7;

            Order    newOrder   = Order.NewObject();
            ObjectID newOrderID = newOrder.ID;

            newOrder.DeliveryDate = DateTime.Now;
            newOrder.Official     = official1;
            customer1.Orders.Add(newOrder);

            newOrder.OrderTicket  = orderTicket1;
            orderTicket1.FileName = @"C:\NewFile.tif";

            OrderItem newOrderItem1   = OrderItem.NewObject();
            ObjectID  newOrderItem1ID = newOrderItem1.ID;

            newOrderItem1.Position = 1;
            newOrder.OrderItems.Add(newOrderItem1);

            OrderItem newOrderItem2   = OrderItem.NewObject();
            ObjectID  newOrderItem2ID = newOrderItem2.ID;

            newOrderItem2.Position = 2;
            order4.OrderItems.Add(newOrderItem2);

            Customer newCustomer   = Customer.NewObject();
            ObjectID newCustomerID = newCustomer.ID;

            Ceo      newCeo   = Ceo.NewObject();
            ObjectID newCeoID = newCeo.ID;

            newCustomer.Ceo = newCeo;
            order3.Customer = newCustomer;

            orderTicket3.FileName = @"C:\NewFile.gif";

            Order deletedNewOrder = Order.NewObject();

            deletedNewOrder.Delete();

            TestableClientTransaction.Commit();
            ReInitializeTransaction();

            CheckIfObjectIsDeleted(DomainObjectIDs.Order1);
            CheckIfObjectIsDeleted(DomainObjectIDs.OrderItem1);
            CheckIfObjectIsDeleted(DomainObjectIDs.OrderItem2);

            order4 = DomainObjectIDs.Order4.GetObject <Order> ();
            Assert.That(order4.OrderNumber, Is.EqualTo(7));

            newOrder = newOrderID.GetObject <Order> ();
            Assert.That(newOrder, Is.Not.Null);

            official1 = DomainObjectIDs.Official1.GetObject <Official>();
            Assert.That(official1.Orders[newOrderID], Is.Not.Null);
            Assert.That(newOrder.Official, Is.SameAs(official1));
            Assert.That(official1.Orders[DomainObjectIDs.Order1], Is.Null);

            orderTicket1 = DomainObjectIDs.OrderTicket1.GetObject <OrderTicket> ();
            Assert.That(orderTicket1.FileName, Is.EqualTo(@"C:\NewFile.tif"));
            Assert.That(orderTicket1.Order, Is.SameAs(newOrder));
            Assert.That(newOrder.OrderTicket, Is.SameAs(orderTicket1));

            newOrderItem1 = newOrderItem1ID.GetObject <OrderItem>();
            Assert.That(newOrderItem1, Is.Not.Null);
            Assert.That(newOrderItem1.Position, Is.EqualTo(1));
            Assert.That(newOrderItem1.Order, Is.SameAs(newOrder));
            Assert.That(newOrder.OrderItems[newOrderItem1ID], Is.Not.Null);

            newOrderItem2 = newOrderItem2ID.GetObject <OrderItem>();
            Assert.That(newOrderItem2, Is.Not.Null);
            Assert.That(newOrderItem2.Position, Is.EqualTo(2));
            Assert.That(newOrderItem2.Order, Is.SameAs(order4));
            Assert.That(order4.OrderItems[newOrderItem2ID], Is.Not.Null);

            newCustomer = newCustomerID.GetObject <Customer> ();
            newCeo      = newCeoID.GetObject <Ceo> ();

            Assert.That(newCeo.Company, Is.SameAs(newCustomer));
            Assert.That(newCustomer.Ceo, Is.SameAs(newCeo));
            Assert.That(newCustomer.Orders.Contains(DomainObjectIDs.Order3), Is.True);
            Assert.That(newCustomer.Orders[DomainObjectIDs.Order3].Customer, Is.SameAs(newCustomer));

            orderTicket3 = DomainObjectIDs.OrderTicket3.GetObject <OrderTicket> ();
            Assert.That(orderTicket3.FileName, Is.EqualTo(@"C:\NewFile.gif"));
        }
        public void SaveNewRelatedObjects()
        {
            Ceo         ceo         = Ceo.NewObject();
            Customer    customer    = Customer.NewObject();
            Order       order       = Order.NewObject();
            OrderTicket orderTicket = OrderTicket.NewObject(order);
            OrderItem   orderItem   = OrderItem.NewObject();

            ObjectID ceoID         = ceo.ID;
            ObjectID customerID    = customer.ID;
            ObjectID orderID       = order.ID;
            ObjectID orderTicketID = orderTicket.ID;
            ObjectID orderItemID   = orderItem.ID;

            ceo.Name = "Ford Prefect";

            customer.CustomerSince = new DateTime(2000, 1, 1);
            customer.Name          = "Arthur Dent";
            customer.Ceo           = ceo;

            orderItem.Position = 1;
            orderItem.Product  = "Sternenkarte";

            orderTicket.FileName = @"C:\home\arthur_dent\maporder.png";

            order.OrderNumber  = 42;
            order.DeliveryDate = new DateTime(2005, 2, 1);
            order.Official     = DomainObjectIDs.Official1.GetObject <Official>();
            order.Customer     = customer;
            order.OrderItems.Add(orderItem);

            Assert.That(ceo.InternalDataContainer.Timestamp, Is.Null);
            Assert.That(customer.InternalDataContainer.Timestamp, Is.Null);
            Assert.That(order.InternalDataContainer.Timestamp, Is.Null);
            Assert.That(orderTicket.InternalDataContainer.Timestamp, Is.Null);
            Assert.That(orderItem.InternalDataContainer.Timestamp, Is.Null);

            TestableClientTransaction.Commit();
            ReInitializeTransaction();

            ceo         = ceoID.GetObject <Ceo> ();
            customer    = customerID.GetObject <Customer> ();
            order       = orderID.GetObject <Order> ();
            orderTicket = orderTicketID.GetObject <OrderTicket> ();
            orderItem   = orderItemID.GetObject <OrderItem>();
            Official official = DomainObjectIDs.Official1.GetObject <Official>();

            Assert.That(ceo, Is.Not.Null);
            Assert.That(customer, Is.Not.Null);
            Assert.That(order, Is.Not.Null);
            Assert.That(orderTicket, Is.Not.Null);
            Assert.That(orderItem, Is.Not.Null);

            Assert.That(ceo.Company, Is.SameAs(customer));
            Assert.That(customer.Ceo, Is.SameAs(ceo));
            Assert.That(order.Customer, Is.SameAs(customer));
            Assert.That(customer.Orders.Count, Is.EqualTo(1));
            Assert.That(customer.Orders[0], Is.SameAs(order));
            Assert.That(orderTicket.Order, Is.SameAs(order));
            Assert.That(order.OrderTicket, Is.SameAs(orderTicket));
            Assert.That(orderItem.Order, Is.SameAs(order));
            Assert.That(order.OrderItems.Count, Is.EqualTo(1));
            Assert.That(order.OrderItems[0], Is.SameAs(orderItem));
            Assert.That(order.Official, Is.SameAs(official));
            Assert.That(official.Orders.Count, Is.EqualTo(6));
            Assert.That(official.Orders[orderID], Is.Not.Null);

            Assert.That(ceo.Name, Is.EqualTo("Ford Prefect"));
            Assert.That(customer.CustomerSince, Is.EqualTo(new DateTime(2000, 1, 1)));
            Assert.That(customer.Name, Is.EqualTo("Arthur Dent"));
            Assert.That(orderItem.Position, Is.EqualTo(1));
            Assert.That(orderItem.Product, Is.EqualTo("Sternenkarte"));
            Assert.That(orderTicket.FileName, Is.EqualTo(@"C:\home\arthur_dent\maporder.png"));
            Assert.That(order.OrderNumber, Is.EqualTo(42));
            Assert.That(order.DeliveryDate, Is.EqualTo(new DateTime(2005, 2, 1)));

            Assert.That(ceo.InternalDataContainer.Timestamp, Is.Not.Null);
            Assert.That(customer.InternalDataContainer.Timestamp, Is.Not.Null);
            Assert.That(order.InternalDataContainer.Timestamp, Is.Not.Null);
            Assert.That(orderTicket.InternalDataContainer.Timestamp, Is.Not.Null);
            Assert.That(orderItem.InternalDataContainer.Timestamp, Is.Not.Null);
        }
        public void GetObject_LoadsObjectIntoGivenTransaction()
        {
            var result = _orderID1.GetObject <Order> (_clientTransaction);

            CheckDomainObject(result, _clientTransaction, expectedID: _orderID1, expectedState: StateType.Unchanged);
        }