C# ContactPersonTestBO类代码示例

 private static ContactPersonTestBO CreateContactPersonTestBO()
 {
     ContactPersonTestBO bo = new ContactPersonTestBO();
     string newSurname = Guid.NewGuid().ToString();
     bo.Surname = newSurname;
     bo.Save();
     return bo;
 }

        public void TestReloadingRelationship()
        {
            ClassDef.ClassDefs.Clear();
            ContactPersonTestBO.LoadClassDefWithAddressesRelationship_DeleteRelated();
            new AddressTestBO();

            ContactPersonTestBO cp = new ContactPersonTestBO();
            IBusinessObjectCollection addresses = cp.Addresses;
            Assert.AreSame(addresses, cp.Addresses);
        }

        public void TestTypeOfMultipleCollection()
        {
            ClassDef.ClassDefs.Clear();
            ContactPersonTestBO.LoadClassDefWithAddressesRelationship_DeleteRelated();
            new AddressTestBO();

            ContactPersonTestBO cp = new ContactPersonTestBO();

            Assert.AreSame(typeof(RelatedBusinessObjectCollection<AddressTestBO>), cp.Addresses.GetType());
        }

 protected void CreateDirtyChildren(BusinessObjectCollection<ContactPersonTestBO> cpCol,
                         out ContactPersonTestBO existingChild,
                         out ContactPersonTestBO editedChild,
                         out ContactPersonTestBO deletedChild,
                         out ContactPersonTestBO createdChildWithEdits,
                         out ContactPersonTestBO createdChild)
 {
     createdChild = CreateCreatedChild(cpCol);
     createdChildWithEdits = CreateCreatedChildWithEdits(cpCol);
     existingChild = CreateExistingChild(cpCol);
     editedChild = CreateEditedChild(cpCol);
     deletedChild = CreateDeletedChild(cpCol);
 }

        public void Test_Constructor()
        {
            //---------------Set up test pack-------------------
            ContactPersonTestBO contactPersonTestBO = new ContactPersonTestBO();
            SingleRelationship<OrganisationTestBO> singleRelationship = contactPersonTestBO.Relationships.GetSingle<OrganisationTestBO>("Organisation");

            //---------------Execute Test ----------------------
            TransactionalSingleRelationship_Added tsr = new TransactionalSingleRelationship_Added(singleRelationship, new OrganisationTestBO());
            //---------------Test Result -----------------------

            Assert.AreSame(singleRelationship, tsr.Relationship);
            //---------------Tear Down -------------------------          
        }

 public void Test_Create_WhenRelatedProp_ShouldCreateBOPropMapper()
 {
     //---------------Set up test pack-------------------
     const string propName = "Organisation.Name";
     var bo = new ContactPersonTestBO();
     //---------------Assert Precondition----------------
     Assert.IsTrue(bo.Relationships.Contains("Organisation"));
     //---------------Execute Test ----------------------
     IBOPropertyMapper propMapper = BOPropMapperFactory.CreateMapper(bo, propName);
     //---------------Test Result -----------------------
     Assert.IsInstanceOf<BOPropertyMapper>(propMapper);
     Assert.AreEqual(propName, propMapper.PropertyName);
     Assert.AreSame(bo, propMapper.BusinessObject);
 }

 public void Test_SetToNull()
 {
     //---------------Set up test pack-------------------
     OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation();
     SingleRelationship<ContactPersonTestBO> relationship = GetAssociationRelationship(organisationTestBO);
     relationship.OwningBOHasForeignKey = false;
     ContactPersonTestBO contactPerson = new ContactPersonTestBO();
     contactPerson.Surname = TestUtil.GetRandomString();
     contactPerson.FirstName = TestUtil.GetRandomString();
     contactPerson.Organisation = organisationTestBO;
     contactPerson.Save();
     //---------------Assert Precondition----------------
     Assert.AreSame(contactPerson, organisationTestBO.ContactPerson);
     //---------------Execute Test ----------------------
     organisationTestBO.ContactPerson = null;
     //---------------Test Result -----------------------
     Assert.IsNull(organisationTestBO.ContactPerson);
 }

        public void Test_BusinessObject()
        {
            //---------------Set up test pack-------------------
            var readOnlyGrid = GetControlFactory().CreateReadOnlyGrid();

            const string propName = "Addresses";
            var mapper = CreateReadOnlyGridMapper(readOnlyGrid, propName);
            ContactPersonTestBO.LoadClassDefWithAddressesRelationship_DeleteRelated();
            ContactPersonTestBO contactPersonTestBO = new ContactPersonTestBO();
            RelatedBusinessObjectCollection<AddressTestBO> addresses = contactPersonTestBO.Addresses;
            //---------------Assert PreConditions---------------        
            Assert.IsNull(mapper.BusinessObject);

            //---------------Execute Test ----------------------
            mapper.BusinessObject = contactPersonTestBO;
            //---------------Test Result -----------------------
            Assert.AreSame(contactPersonTestBO, mapper.BusinessObject);
            Assert.AreSame(addresses, readOnlyGrid.BusinessObjectCollection);
        }

 public void Test_AddMethod()
 {
     //---------------Set up test pack-------------------
     //ContactPersonTestBO.LoadDefaultClassDef();
     BusinessObjectCollection<ContactPersonTestBO> cpCol = new BusinessObjectCollection<ContactPersonTestBO>();
     ContactPersonTestBO myBO = new ContactPersonTestBO();
     _businessObjectCollectionTestHelper.RegisterForAddedEvent(cpCol);
     //---------------Assert Precondition----------------
     Assert.AreEqual(0, cpCol.Count);
     Assert.AreEqual(0, cpCol.AddedBusinessObjects.Count);
     _businessObjectCollectionTestHelper.AssertAddedEventNotFired();
     //---------------Execute Test ----------------------
     cpCol.Add(myBO);
     //---------------Test Result -----------------------
     Assert.AreEqual(1, cpCol.Count, "One object should be in the cpCollection");
     BusinessObjectCollectionTestHelper.AssertOneObjectInCurrentAndCreatedCollection(cpCol);
     _businessObjectCollectionTestHelper.AssertAddedEventFired();
     Assert.AreEqual(myBO, cpCol[0], "Added object should be in the cpCollection");
 }

        public void Test_ConcurrentSave()
        {
            //---------------Set up test pack-------------------
            ClassDef.ClassDefs.Clear();
            var classDef = ContactPersonTestBO.LoadDefaultClassDef();
            FixtureEnvironment.ClearBusinessObjectManager();
            TestUtil.WaitForGC();
            
            //---------------Assert Precondition----------------

            //---------------Execute Test ----------------------
            Parallel.For(0, 1000, i =>
                                  {
                                      var person = new ContactPersonTestBO();
                                      person.Surname = RandomValueGen.GetRandomString(1, 10);
                                      person.Save();
                                  });

            //---------------Test Result -----------------------
        }

        public void Test_BusinessObject_WhenNull()
        {
            //---------------Set up test pack-------------------
            IEditableGridControl editableGrid = GetControlFactory().CreateEditableGridControl();

            const string propName = "Addresses";
            EditableGridControlMapper mapper = new EditableGridControlMapper(editableGrid, propName, false, GetControlFactory());
            ContactPersonTestBO.LoadClassDefWithAddressesRelationship_DeleteRelated();
            ContactPersonTestBO contactPersonTestBO = new ContactPersonTestBO();
            mapper.BusinessObject = contactPersonTestBO;
            RelatedBusinessObjectCollection<AddressTestBO> addresses = contactPersonTestBO.Addresses;
            //---------------Assert PreConditions---------------        
            Assert.AreSame(contactPersonTestBO, mapper.BusinessObject);
            Assert.AreSame(addresses, editableGrid.BusinessObjectCollection);
            //---------------Execute Test ----------------------
            mapper.BusinessObject = null;
            //---------------Test Result -----------------------
            Assert.IsNull(mapper.BusinessObject);
            Assert.AreSame(null, editableGrid.BusinessObjectCollection);
        }

        public void Test_AddedToObjectManager()
        {
            //---------------Set up test pack-------------------
            ContactPersonTestBO.LoadDefaultClassDef();

            ContactPersonTestBO cp = new ContactPersonTestBO();
            BusinessObjectManager boMan = BusinessObjectManager.Instance;
            //---------------Assert Precondition----------------
            Assert.AreEqual(0, boMan.Count);

            //---------------Execute Test ----------------------
            cp.Surname = TestUtil.CreateRandomString();
            boMan.Add(cp);

            //---------------Test Result -----------------------
            Assert.AreEqual(1, boMan.Count);

            Assert.IsTrue(boMan.Contains(cp));
            Assert.IsTrue(boMan.Contains(cp.ID));
            Assert.IsTrue(boMan.Contains(cp.ID.GetObjectId()));
            Assert.AreSame(cp, boMan[cp.ID.GetObjectId()]);
            Assert.AreSame(cp, boMan[cp.ID]);
        }

        public void Test_UpdateStateAsCommitted()
        {
            //---------------Set up test pack-------------------
            ContactPersonTestBO contactPersonTestBO = new ContactPersonTestBO();
            OrganisationTestBO organisationTestBO = new OrganisationTestBO();

            SingleRelationship<OrganisationTestBO> singleRelationship = contactPersonTestBO.Relationships.GetSingle<OrganisationTestBO>("Organisation");
            singleRelationship.SetRelatedObject(organisationTestBO);

            IRelationship relationship = organisationTestBO.Relationships.GetMultiple<ContactPersonTestBO>("ContactPeople");
            TransactionalSingleRelationship_Added tsr = new TransactionalSingleRelationship_Added(relationship, contactPersonTestBO);
            IBOProp relationshipProp = contactPersonTestBO.Props["OrganisationID"];
            
            //---------------Assert PreConditions--------------- 
            Assert.IsTrue(relationshipProp.IsDirty);
            Assert.AreNotEqual(relationshipProp.Value, relationshipProp.PersistedPropertyValue);
            
            //---------------Execute Test ----------------------
            tsr.UpdateStateAsCommitted();
            
            //---------------Test Result -----------------------
            Assert.IsFalse(relationshipProp.IsDirty);
            Assert.AreEqual(relationshipProp.Value, relationshipProp.PersistedPropertyValue);
        }

 public void Test_SetBusinessObject_ShouldSetTextOnExtendedTextBox()
 {
     //--------------- Set up test pack ------------------
     ExtendedTextBoxMapper mapper = CreateExtendedLookupComboBoxMapper("Surname");
     ContactPersonTestBO businessObjectInfo = new ContactPersonTestBO();
     var expectedTextBoxValue = TestUtil.GetRandomString();
     businessObjectInfo.Surname = expectedTextBoxValue;
     //--------------- Test Preconditions ----------------
     Assert.IsNotNullOrEmpty(businessObjectInfo.Surname);
     //--------------- Execute Test ----------------------
     mapper.BusinessObject = businessObjectInfo;
     //--------------- Test Result -----------------------
     Assert.AreSame(businessObjectInfo, mapper.BusinessObject);
     IExtendedTextBox extendedTextBox = (IExtendedTextBox)mapper.Control;
     Assert.AreEqual(expectedTextBoxValue, extendedTextBox.Text, "Text should be set on TextBox");
 }

 public void Test_SetBusinessObject_OnInternalLookupComboBoxMapper()
 {
     //--------------- Set up test pack ------------------
     ExtendedTextBoxMapper mapper = CreateExtendedLookupComboBoxMapper("Surname");
     //--------------- Test Preconditions ----------------
     Assert.IsNull(mapper.BusinessObject);
     Assert.IsNull(mapper.BusinessObject);
     ContactPersonTestBO businessObjectInfo = new ContactPersonTestBO();
     //--------------- Execute Test ----------------------
     mapper.BusinessObject = businessObjectInfo;
     //--------------- Test Result -----------------------
     Assert.AreSame(businessObjectInfo, mapper.BusinessObject);
 }