public void TestDontGetTheFreshestObject_Strategy() { //------------------------------Setup Test ClassDef.ClassDefs.Clear(); SetupDefaultContactPersonBO(); ContactPersonTestBO originalContactPerson = new ContactPersonTestBO(); originalContactPerson.Surname = "FirstSurname"; originalContactPerson.Save(); IPrimaryKey origCPID = originalContactPerson.ID; BORegistry.BusinessObjectManager = new BusinessObjectManagerSpy();//Ensures a new BOMan is created and used for each test //load second object from DB to ensure that it is now in the object manager ContactPersonTestBO myContact2 = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <ContactPersonTestBO>(origCPID); //-----------------------------Execute Test------------------------- //Edit first object and save originalContactPerson.Surname = "SecondSurname"; originalContactPerson.Save(); ContactPersonTestBO myContact3 = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <ContactPersonTestBO>(origCPID); //-----------------------------Assert Result----------------------- Assert.AreSame(myContact3, myContact2); //The two surnames should be equal since the myContact3 was refreshed // when it was loaded. Assert.AreNotEqual(originalContactPerson.Surname, myContact3.Surname); //Just to check the myContact2 should also match since it is physically the // same object as myContact3 Assert.AreNotEqual(originalContactPerson.Surname, myContact2.Surname); }
public void Test_Refresh_AfterLoadIsCalled_IfObjectUpdatedInLoading() { //---------------Set up test pack--------------------- ClassDef.ClassDefs.Clear(); SetupDefaultContactPersonBO(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = Guid.NewGuid().ToString(); cp.Save(); FixtureEnvironment.ClearBusinessObjectManager(); ContactPersonTestBO cpLoaded = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <ContactPersonTestBO>(cp.ID); string newFirstname = cp.FirstName = TestUtil.GetRandomString(); cp.Save(); cpLoaded.AfterLoadCalled = false; //---------------Assert Precondition------------------ Assert.IsFalse(cpLoaded.AfterLoadCalled); //---------------Execute Test ------------------------ BORegistry.DataAccessor.BusinessObjectLoader.Refresh(cpLoaded); //---------------Test Result ------------------------- Assert.IsTrue(cpLoaded.AfterLoadCalled); Assert.AreNotSame(cp, cpLoaded); Assert.AreEqual(cp.FirstName, cpLoaded.FirstName); Assert.AreEqual(newFirstname, cpLoaded.FirstName); }
public void Test_Refresh_UpdatedEventIsFired_IfObjectUpdatedInLoading() { //---------------Set up test pack--------------------- ClassDef.ClassDefs.Clear(); SetupDefaultContactPersonBO(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = Guid.NewGuid().ToString(); cp.Save(); FixtureEnvironment.ClearBusinessObjectManager(); ContactPersonTestBO cpLoaded = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <ContactPersonTestBO>(cp.ID); string newFirstname = cp.FirstName = TestUtil.GetRandomString(); cp.Save(); bool updatedEventFired = false; cpLoaded.Updated += (sender, args) => updatedEventFired = true; //---------------Assert Precondition------------------ Assert.IsFalse(updatedEventFired); //---------------Execute Test ------------------------ BORegistry.DataAccessor.BusinessObjectLoader.Refresh(cpLoaded); //---------------Test Result ------------------------- Assert.IsTrue(updatedEventFired); }
public void Test_SavedObject_Twice_AddedToObjectManager_Once() { //---------------Set up test pack------------------- ContactPersonTestBO.LoadDefaultClassDef(); BusinessObjectManager boMan = BusinessObjectManager.Instance; ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = TestUtil.CreateRandomString(); cp.Save(); //---------------Assert Precondition---------------- Assert.AreEqual(1, boMan.Count); Assert.IsTrue(boMan.Contains(cp)); //---------------Execute Test ---------------------- cp.Surname = TestUtil.CreateRandomString(); cp.Save(); //---------------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 TestFindAll_UsingClassDef() { //---------------Set up test pack------------------- BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory()); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); OrganisationTestBO.LoadDefaultClassDef(); DataStoreInMemory dataStore = new DataStoreInMemory(); DateTime now = DateTime.Now; ContactPersonTestBO cp1 = new ContactPersonTestBO(); cp1.DateOfBirth = now; cp1.Surname = TestUtil.GetRandomString(); cp1.Save(); dataStore.Add(cp1); ContactPersonTestBO cp2 = new ContactPersonTestBO(); cp2.DateOfBirth = now; cp2.Surname = TestUtil.GetRandomString(); cp2.Save(); dataStore.Add(cp2); Criteria criteria = new Criteria("DateOfBirth", Criteria.ComparisonOp.Equals, now); dataStore.Add(OrganisationTestBO.CreateSavedOrganisation()); //---------------Execute Test ---------------------- IBusinessObjectCollection col = dataStore.FindAll(ClassDef.Get <ContactPersonTestBO>(), criteria); //---------------Test Result ----------------------- Assert.AreEqual(2, col.Count); Assert.Contains(cp1, col); Assert.Contains(cp2, col); }
public void TestFind_UsingGuidCriteriaString_Typed() { //---------------Set up test pack------------------- BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory()); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef_WOrganisationID(); OrganisationTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO { Surname = Guid.NewGuid().ToString("N") }; cp.OrganisationID = OrganisationTestBO.CreateSavedOrganisation().OrganisationID; cp.Save(); DataStoreInMemory dataStore = new DataStoreInMemory(); dataStore.Add(cp); Criteria criteria = CriteriaParser.CreateCriteria("OrganisationID = " + cp.OrganisationID); //---------------Assert Precondtions--------------- Assert.IsNotNull(cp.OrganisationID); //---------------Execute Test ---------------------- ContactPersonTestBO loadedCP = dataStore.Find <ContactPersonTestBO>(criteria); //---------------Test Result ----------------------- Assert.IsNotNull(loadedCP); Assert.AreSame(cp.ID, loadedCP.ID); }
public void Test_ResetParent_NewChild_SetToNull() { //A tyre can be removed from its car. This test is removing via the reverse relationship //---------------Set up test pack------------------- OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation(); BusinessObjectCollection <ContactPersonTestBO> cpCol; GetAggregateRelationship(organisationTestBO, out cpCol); ContactPersonTestBO contactPerson = ContactPersonTestBO.CreateUnsavedContactPerson(TestUtil.GetRandomString(), TestUtil.GetRandomString()); contactPerson.OrganisationID = organisationTestBO.OrganisationID; contactPerson.Save(); cpCol.LoadAll(); util.RegisterForAddedAndRemovedEvents(cpCol); //---------------Assert Precondition---------------- util.AssertOneObjectInCurrentPersistedCollection(cpCol); //---------------Execute Test ---------------------- contactPerson.Organisation = null; //---------------Test Result ----------------------- Assert.IsNull(contactPerson.Organisation); util.AssertOneObjectInRemovedAndPersisted(cpCol); util.AssertRemovedEventFired(); }
public void Test_LoadMultiplerelationship_TimeOutExceeded_WhenTimeOutZero_UsingRelationship_DoesReloadFromDB() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); IClassDef orgClassDef = OrganisationTestBO.LoadDefaultClassDef(); ContactPersonTestBO.LoadClassDefOrganisationTestBORelationship_MultipleReverse(); OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation(); IBusinessObjectCollection collection = organisationTestBO.ContactPeople; DateTime?initialTimeLastLoaded = collection.TimeLastLoaded; //---------------Assert Precondition---------------- Assert.IsNotNull(collection.TimeLastLoaded); Assert.AreEqual(initialTimeLastLoaded, collection.TimeLastLoaded); Assert.AreEqual(0, collection.Count); MultipleRelationship <ContactPersonTestBO> relationship = (MultipleRelationship <ContactPersonTestBO>)organisationTestBO.Relationships["ContactPeople"]; Assert.AreEqual(0, relationship.TimeOut); //---------------Execute Test ---------------------- ContactPersonTestBO contactPerson = organisationTestBO.ContactPeople.CreateBusinessObject(); contactPerson.Surname = TestUtil.GetRandomString(); contactPerson.FirstName = TestUtil.GetRandomString(); contactPerson.Save(); TestUtil.Wait(100); IBusinessObjectCollection secondCollectionCall = organisationTestBO.ContactPeople; //---------------Test Result ----------------------- Assert.AreSame(collection, secondCollectionCall); Assert.IsNotNull(secondCollectionCall.TimeLastLoaded); Assert.AreEqual(1, secondCollectionCall.Count); Assert.AreNotEqual(initialTimeLastLoaded, secondCollectionCall.TimeLastLoaded); }
public void Test_LoadMultiplerelationship_TimeOutNotExceeded_DoesNotReloadFromDB() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); IClassDef orgClassDef = OrganisationTestBO.LoadDefaultClassDef(); ContactPersonTestBO.LoadClassDefOrganisationTestBORelationship_MultipleReverse(); OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation(); RelationshipDef relationshipDef = (RelationshipDef)orgClassDef.RelationshipDefCol["ContactPeople"]; IMultipleRelationship rel = new MultipleRelationship <ContactPersonTestBO>(organisationTestBO, relationshipDef, organisationTestBO.Props, 30000); IBusinessObjectCollection collection = rel.BusinessObjectCollection; DateTime?initialTimeLastLoaded = collection.TimeLastLoaded; //---------------Assert Precondition---------------- Assert.AreEqual(initialTimeLastLoaded, collection.TimeLastLoaded); Assert.AreEqual(0, collection.Count); //---------------Execute Test ---------------------- ContactPersonTestBO contactPerson = organisationTestBO.ContactPeople.CreateBusinessObject(); contactPerson.Surname = TestUtil.GetRandomString(); contactPerson.FirstName = TestUtil.GetRandomString(); contactPerson.Save(); TestUtil.Wait(100); IBusinessObjectCollection secondCollectionCall = rel.BusinessObjectCollection; //---------------Test Result ----------------------- Assert.AreSame(collection, secondCollectionCall); Assert.AreEqual(0, secondCollectionCall.Count); Assert.AreEqual(initialTimeLastLoaded, secondCollectionCall.TimeLastLoaded); }
public void Test_UpdateStateAsCommitted_Removed_UpdatesCols() { //---------------Set up test pack------------------- ContactPersonTestBO contactPersonTestBO = ContactPersonTestBO.CreateSavedContactPerson(); OrganisationTestBO organisationTestBO = new OrganisationTestBO(); SingleRelationship <OrganisationTestBO> singleRelationship = contactPersonTestBO.Relationships.GetSingle <OrganisationTestBO>("Organisation"); BusinessObjectCollection <ContactPersonTestBO> people = organisationTestBO.ContactPeople; organisationTestBO.Save(); contactPersonTestBO.Organisation = organisationTestBO; contactPersonTestBO.Save(); contactPersonTestBO.Organisation = null; IRelationship relationship = organisationTestBO.Relationships.GetMultiple <ContactPersonTestBO>("ContactPeople"); TransactionalSingleRelationship_Removed tsr = new TransactionalSingleRelationship_Removed(relationship, contactPersonTestBO); //---------------Assert PreConditions--------------- Assert.AreEqual(1, people.RemovedBusinessObjects.Count); Assert.AreEqual(1, people.PersistedBusinessObjects.Count); Assert.IsTrue(singleRelationship.IsRemoved); //---------------Execute Test ---------------------- tsr.UpdateStateAsCommitted(); //---------------Test Result ----------------------- Assert.AreEqual(0, people.RemovedBusinessObjects.Count); Assert.AreEqual(0, people.PersistedBusinessObjects.Count); // Assert.IsFalse(singleRelationship.IsRemoved); //---------------Tear Down ------------------------- }
public void Test_Refresh_W_CreatedBOs_CreatedObjectsStillRespondToEvents() { //---------------Set up test pack------------------- BusinessObjectCollection <ContactPersonTestBO> cpCol = CreateCollectionWith_OneBO(); ContactPersonTestBO createdCp = cpCol.CreateBusinessObject(); createdCp.Surname = BOTestUtils.RandomString; RegisterForAddedAndRemovedEvents(cpCol); //---------------Assert Precondition---------------- Assert.AreEqual(2, cpCol.Count); Assert.AreEqual(1, cpCol.CreatedBusinessObjects.Count); Assert.AreEqual(1, cpCol.PersistedBusinessObjects.Count); //---------------Execute Test ---------------------- cpCol.Refresh(); createdCp.Save(); //---------------Test Result ----------------------- Assert.AreEqual(2, cpCol.Count); Assert.AreEqual(0, cpCol.CreatedBusinessObjects.Count); Assert.AreEqual(2, cpCol.PersistedBusinessObjects.Count); AssertAddedAndRemovedEventsNotFired(); }
public void Test_CreatedBusinessObject_SaveBO() { //Saving a created business object should remove the business // object from the created col. it should still exist in // the main collection and should be added to the persisted collection //---------------Set up test pack------------------- //ContactPersonTestBO.LoadDefaultClassDef(); BusinessObjectCollection <ContactPersonTestBO> cpCol = new BusinessObjectCollection <ContactPersonTestBO>(); cpCol.LoadAll(); ContactPersonTestBO newCP = cpCol.CreateBusinessObject(); newCP.Surname = TestUtil.GetRandomString(); RegisterForAddedEvent(cpCol); //---------------Assert Preconditions -------------- Assert.IsFalse(_addedEventFired); AssertOneObjectInCurrentAndCreatedCollection(cpCol); //---------------Execute Test ---------------------- newCP.Save(); //---------------Test Result ----------------------- Assert.IsFalse(_addedEventFired); Assert.Contains(newCP, cpCol); AssertOneObjectInCurrentAndPersistedCollection(cpCol); }
public void Test3LayerLoadRelated() { //---------------Set up test pack------------------- BusinessObjectManager.Instance.ClearLoadedObjects(); ContactPersonTestBO.DeleteAllContactPeople(); BORegistry.DataAccessor = new DataAccessorDB(); OrganisationTestBO.LoadDefaultClassDef(); TestUtil.WaitForGC(); Address address; ContactPersonTestBO contactPersonTestBO = ContactPersonTestBO.CreateContactPersonWithOneAddress_CascadeDelete(out address); OrganisationTestBO org = new OrganisationTestBO(); contactPersonTestBO.SetPropertyValue("OrganisationID", org.OrganisationID); org.Save(); contactPersonTestBO.Save(); //---------------Assert Preconditions -------------- Assert.AreEqual(3, BusinessObjectManager.Instance.Count); //---------------Execute Test ---------------------- IBusinessObjectCollection colContactPeople = org.Relationships["ContactPeople"].GetRelatedBusinessObjectCol(); ContactPersonTestBO loadedCP = (ContactPersonTestBO)colContactPeople[0]; IBusinessObjectCollection colAddresses = loadedCP.Relationships["Addresses"].GetRelatedBusinessObjectCol(); Address loadedAdddress = (Address)colAddresses[0]; //---------------Test Result ----------------------- Assert.AreEqual(3, BusinessObjectManager.Instance.Count); Assert.AreEqual(1, colAddresses.Count); Assert.AreSame(contactPersonTestBO, loadedCP); Assert.AreSame(address, loadedAdddress); }
public void Test_CreatedBusinessObject_SaveBO() { //Saving a created business object should remove the business // object from the created col. it should still exist in // the main collection and should be added to the persisted collection //---------------Set up test pack------------------- OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation(); IMultipleRelationship cpRelationship = (IMultipleRelationship)organisationTestBO.Relationships["ContactPeople"]; RelatedBusinessObjectCollection <ContactPersonTestBO> cpCol = new RelatedBusinessObjectCollection <ContactPersonTestBO>(cpRelationship); cpCol.LoadAll(); ContactPersonTestBO newCP = cpCol.CreateBusinessObject(); newCP.Surname = TestUtil.GetRandomString(); newCP.FirstName = TestUtil.GetRandomString(); RegisterForAddedEvent(cpCol); //---------------Assert Preconditions -------------- Assert.IsFalse(_addedEventFired); AssertOneObjectInCurrentAndCreatedCollection(cpCol); //---------------Execute Test ---------------------- newCP.Save(); //---------------Test Result ----------------------- Assert.IsFalse(_addedEventFired); Assert.Contains(newCP, cpCol); AssertOneObjectInCurrentAndPersistedCollection(cpCol); }
public void Test_RemoveCreatedBo_DeregistersForSaveEvent() { //If you remove a created business object that is not yet persisted then //-- remove from the restored and saved event. //-- when the object is saved it should be independent of the collection. //---------------Set up test pack------------------- RelatedBusinessObjectCollection <ContactPersonTestBO> cpCol = CreateCollectionWith_OneBO(); ContactPersonTestBO createdCp = cpCol.CreateBusinessObject(); createdCp.Surname = BOTestUtils.RandomString; createdCp.FirstName = BOTestUtils.RandomString; cpCol.Remove(createdCp); RegisterForAddedAndRemovedEvents(cpCol); //---------------Assert Precondition---------------- AssertOneObjectInCurrentAndPersistedCollection(cpCol); Assert.IsFalse(cpCol.Contains(createdCp)); //---------------Execute Test ---------------------- createdCp.Save(); //---------------Test Result ----------------------- AssertOneObjectInCurrentAndPersistedCollection(cpCol); Assert.IsFalse(cpCol.Contains(createdCp)); AssertAddedAndRemovedEventsNotFired(); }
public void Test_SetParentNull_PersistedChild() { //---------------Set up test pack------------------- OrganisationTestBO organisation = OrganisationTestBO.CreateSavedOrganisation(); ISingleRelationship compositionRelationship = (ISingleRelationship)organisation.Relationships["ContactPerson"]; RelationshipDef relationshipDef = (RelationshipDef)compositionRelationship.RelationshipDef; relationshipDef.RelationshipType = RelationshipType.Composition; ContactPersonTestBO contactPerson = ContactPersonTestBO.CreateUnsavedContactPerson(); contactPerson.Organisation = organisation; contactPerson.Save(); //---------------Assert Precondition---------------- Assert.IsNotNull(contactPerson.Organisation); //---------------Execute Test ---------------------- try { contactPerson.Organisation = null; Assert.Fail("expected Err"); } //---------------Test Result ----------------------- catch (HabaneroDeveloperException ex) { StringAssert.Contains("The " + compositionRelationship.RelationshipDef.RelatedObjectClassName, ex.Message); StringAssert.Contains("could not be removed since the " + compositionRelationship.RelationshipName + " relationship is set up as ", ex.Message); } }
public void Test_PersistParent_PersistsDirtyChildren() { //---------------Set up test pack------------------- OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation(); RelationshipCol relationships = organisationTestBO.Relationships; BusinessObjectCollection <ContactPersonTestBO> cpCol; MultipleRelationship <ContactPersonTestBO> aggregateRelationship = GetAggregationRelationship (organisationTestBO, out cpCol); ContactPersonTestBO myBO = cpCol.CreateBusinessObject(); myBO.Surname = TestUtil.GetRandomString(); myBO.FirstName = TestUtil.GetRandomString(); myBO.Save(); myBO.FirstName = TestUtil.GetRandomString(); //---------------Assert Precondition---------------- Assert.IsTrue(aggregateRelationship.IsDirty); Assert.IsTrue(myBO.Status.IsDirty); Assert.IsTrue(relationships.IsDirty); Assert.IsTrue(organisationTestBO.Status.IsDirty); //---------------Execute Test ---------------------- organisationTestBO.Save(); //---------------Test Result ----------------------- Assert.IsFalse(myBO.Status.IsDirty); Assert.IsFalse(aggregateRelationship.IsDirty); Assert.IsFalse(relationships.IsDirty); Assert.IsFalse(organisationTestBO.Status.IsDirty); }
public void Test_ParentDirtyIfHasDirtyChildren() { //---------------Set up test pack------------------- OrganisationTestBO organisation = OrganisationTestBO.CreateSavedOrganisation(); SingleRelationship <ContactPersonTestBO> relationship = GetCompositionRelationship(organisation); ContactPersonTestBO contactPerson = ContactPersonTestBO.CreateUnsavedContactPerson(); relationship.SetRelatedObject(contactPerson); contactPerson.Surname = TestUtil.GetRandomString(); contactPerson.FirstName = TestUtil.GetRandomString(); contactPerson.Save(); //---------------Assert Precondition---------------- Assert.IsFalse(contactPerson.Status.IsDirty); Assert.IsFalse(relationship.IsDirty); Assert.IsFalse(organisation.Relationships.IsDirty); Assert.IsFalse(organisation.Status.IsDirty); //---------------Execute Test ---------------------- contactPerson.FirstName = TestUtil.GetRandomString(); //---------------Test Result ----------------------- Assert.IsTrue(contactPerson.Status.IsDirty); Assert.IsTrue(relationship.IsDirty); Assert.IsTrue(organisation.Relationships.IsDirty); Assert.IsTrue(organisation.Status.IsDirty); }
public virtual void Test_RemovedChild_UpdatesRelatedPropertiesOnlyWhenParentSaves() { //---------------Set up test pack------------------- OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation(); RelationshipDef relationshipDef = (RelationshipDef)organisationTestBO.Relationships["ContactPeople"].RelationshipDef; relationshipDef.RelationshipType = RelationshipType.Association; ContactPersonTestBO contactPerson = organisationTestBO.ContactPeople.CreateBusinessObject(); contactPerson.Surname = TestUtil.GetRandomString(); contactPerson.FirstName = TestUtil.GetRandomString(); contactPerson.Save(); contactPerson.Surname = TestUtil.GetRandomString(); organisationTestBO.ContactPeople.Remove(contactPerson); //---------------Assert PreConditions--------------- Assert.IsTrue(contactPerson.Status.IsDirty); Assert.IsTrue(contactPerson.Props["OrganisationID"].IsDirty); Assert.IsNull(contactPerson.Props["OrganisationID"].Value); Assert.IsTrue(organisationTestBO.Status.IsDirty); //---------------Execute Test ---------------------- organisationTestBO.Save(); //---------------Test Result ----------------------- Assert.IsTrue(contactPerson.Status.IsDirty); Assert.IsFalse(contactPerson.Props["OrganisationID"].IsDirty); Assert.IsNull(contactPerson.Props["OrganisationID"].Value); Assert.IsFalse(organisationTestBO.Status.IsDirty); }
public void TestBoLoader_RefreshBusinessObjectDeletedByAnotherUser() { //-------------Setup Test Pack------------------ SetupDefaultContactPersonBO(); ContactPersonTestBO cpTemp = ContactPersonTestBO.CreateSavedContactPerson(); FixtureEnvironment.ClearBusinessObjectManager(); ContactPersonTestBO cpLoaded = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <ContactPersonTestBO>(cpTemp.ID); cpTemp.MarkForDelete(); cpTemp.Save(); //-------------Execute Test --------------------- try { BORegistry.DataAccessor.BusinessObjectLoader.Refresh(cpLoaded); Assert.Fail(); } //-------------Test Result --------------------- catch (BusObjDeleteConcurrencyControlException ex) { StringAssert.Contains ("A Error has occured since the object you are trying to refresh has been deleted by another user.", ex.Message); StringAssert.Contains("There are no records in the database for the Class", ex.Message); StringAssert.Contains("ContactPersonTestBO", ex.Message); StringAssert.Contains(cpLoaded.ID.ToString(), ex.Message); } }
public void TestGetTheFreshestObject_Strategy() { //------------------------------Setup Test---------------------------- SetupDefaultContactPersonBO(); ContactPersonTestBO originalContactPerson = new ContactPersonTestBO(); originalContactPerson.Surname = "FirstSurname"; originalContactPerson.Save(); FixtureEnvironment.ClearBusinessObjectManager(); //load second object from DB to ensure that it is now in the object manager ContactPersonTestBO myContact2 = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <ContactPersonTestBO> (originalContactPerson.ID); //-----------------------------Assert Precondition ----------------- Assert.AreNotSame(originalContactPerson, myContact2); IPrimaryKey id = myContact2.ID; Assert.IsTrue(BORegistry.BusinessObjectManager.Contains(id)); IBusinessObject boFromAllLoadedObjects = BORegistry.BusinessObjectManager[id]; Assert.AreSame(boFromAllLoadedObjects, myContact2); Assert.IsFalse(myContact2.Status.IsEditing); //-----------------------------Execute Test------------------------- //Edit first object and save originalContactPerson.Surname = "SecondSurname"; originalContactPerson.Save(); ContactPersonTestBO myContact3 = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <ContactPersonTestBO> (originalContactPerson.ID); //-----------------------------Assert Result----------------------- Assert.IsFalse(myContact3.Status.IsEditing); Assert.AreNotSame(originalContactPerson, myContact3); Assert.IsTrue(BORegistry.BusinessObjectManager.Contains(myContact3)); Assert.AreSame(myContact3, myContact2); //The two surnames should be equal since the myContact3 was refreshed // when it was loaded. Assert.AreEqual(originalContactPerson.Surname, myContact3.Surname); //Just to check the myContact2 should also match since it is physically the // same object as myContact3 Assert.AreEqual(originalContactPerson.Surname, myContact2.Surname); }
private static ContactPersonTestBO CreateContactPersonTestBO() { ContactPersonTestBO bo = new ContactPersonTestBO(); string newSurname = Guid.NewGuid().ToString(); bo.Surname = newSurname; bo.Save(); return bo; }
private static void CreateContactPersonInDB_With_SSSSS_InSurname() { ContactPersonTestBO contactPersonTestBO = new ContactPersonTestBO(); contactPersonTestBO.Surname = Guid.NewGuid().ToString("N") + "SSSSS"; contactPersonTestBO.Save(); return; }
private static ContactPersonTestBO CreateContactPersonTestBO() { var bo = new ContactPersonTestBO(); var newSurname = Guid.NewGuid().ToString(); bo.Surname = newSurname; bo.Save(); return(bo); }
private static ContactPersonTestBO CreateSavedCP() { ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = TestUtil.CreateRandomString(); cp.FirstName = TestUtil.CreateRandomString(); cp.Save(); return(cp); }
private ContactPersonTestBO CreateContactPerson(DateTime now) { ContactPersonTestBO cp1 = new ContactPersonTestBO(); cp1.DateOfBirth = now; cp1.Surname = Guid.NewGuid().ToString("N"); cp1.Save(); return(cp1); }
protected static ContactPersonTestBO CreateExistingChild(BusinessObjectCollection <ContactPersonTestBO> cpCol) { ContactPersonTestBO existingChildEdited = cpCol.CreateBusinessObject(); existingChildEdited.Surname = TestUtil.GetRandomString(); existingChildEdited.FirstName = TestUtil.GetRandomString(); existingChildEdited.Save(); return(existingChildEdited); }
private ContactPersonTestBO CreateContactPerson(string surname) { var cp1 = new ContactPersonTestBO(); cp1.Surname = surname; cp1.FirstName = Guid.NewGuid().ToString("N"); cp1.Save(); return(cp1); }
private static ContactPersonTestBO CreateSavedContactPerson(OrganisationTestBO organisation) { MultipleRelationship <ContactPersonTestBO> relationship = GetContactPersonRelationship(organisation); ContactPersonTestBO cp = relationship.BusinessObjectCollection.CreateBusinessObject(); cp.Surname = TestUtil.GetRandomString(); cp.FirstName = TestUtil.GetRandomString(); cp.Save(); return(cp); }
public void Test_CreatedBusinessObject_SavedTwice() { //---------------Set up test pack------------------- //ContactPersonTestBO.LoadDefaultClassDef(); BusinessObjectCollection <ContactPersonTestBO> cpCol = new BusinessObjectCollection <ContactPersonTestBO>(); ContactPersonTestBO newCP = cpCol.CreateBusinessObject(); newCP.Surname = TestUtil.GetRandomString(); newCP.Save(); //---------------Assert Precondition---------------- AssertOneObjectInCurrentAndPersistedCollection(cpCol); //---------------Execute Test ---------------------- newCP.Surname = TestUtil.GetRandomString(); newCP.Save(); //---------------Test Result ----------------------- AssertOneObjectInCurrentAndPersistedCollection(cpCol); }
public void TestNowDateStringCriteria() { DeleteAllContactPeople(); BusinessObjectCollection <ContactPersonTestBO> myCol = new BusinessObjectCollection <ContactPersonTestBO>(); myCol.LoadAll(); Assert.AreEqual(0, myCol.Count); ContactPersonTestBO contactPerson1 = new ContactPersonTestBO(); contactPerson1.Surname = "aaa"; contactPerson1.DateOfBirth = DateTime.Now.AddMinutes(-1); contactPerson1.Save(); ContactPersonTestBO contactPerson2 = new ContactPersonTestBO(); contactPerson2.Surname = "bbb"; contactPerson2.DateOfBirth = DateTime.Now.AddMinutes(-1); contactPerson2.Save(); ContactPersonTestBO contactPerson3 = new ContactPersonTestBO(); contactPerson3.Surname = "ccc"; contactPerson3.DateOfBirth = DateTime.Now.AddMinutes(-1); contactPerson3.Save(); //ContactPersonTestBO.ClearObjectManager(); BusinessObjectLookupList businessObjectLookupList = new BusinessObjectLookupList("Habanero.Test.BO", "ContactPersonTestBO", "DateOfBirth < 'Now'", ""); businessObjectLookupList.PropDef = new PropDef("name", typeof(string), PropReadWriteRule.ReadWrite, null); Dictionary <string, string> col = businessObjectLookupList.GetLookupList(DatabaseConnection.CurrentConnection); Assert.AreEqual(3, col.Count); Assert.IsTrue(col.ContainsValue(GuidToString(contactPerson1.ID.GetAsGuid()))); Assert.IsTrue(col.ContainsValue(GuidToString(contactPerson2.ID.GetAsGuid()))); Assert.IsTrue(col.ContainsValue(GuidToString(contactPerson3.ID.GetAsGuid()))); businessObjectLookupList = new BusinessObjectLookupList("Habanero.Test.BO", "ContactPersonTestBO", "DateOfBirth > 'now'", "") { PropDef = new PropDef("name", typeof(string), PropReadWriteRule.ReadWrite, null) }; col = businessObjectLookupList.GetLookupList(DatabaseConnection.CurrentConnection); Assert.AreEqual(0, col.Count); ContactPersonTestBO contactPerson4 = new ContactPersonTestBO(); contactPerson4.Surname = "ddd"; contactPerson4.DateOfBirth = DateTime.Now.AddMinutes(5); contactPerson4.Save(); businessObjectLookupList = new BusinessObjectLookupList("Habanero.Test.BO", "ContactPersonTestBO", "DateOfBirth > NOW", ""); businessObjectLookupList.PropDef = new PropDef("name", typeof(string), PropReadWriteRule.ReadWrite, null); col = businessObjectLookupList.GetLookupList(DatabaseConnection.CurrentConnection); Assert.AreEqual(1, col.Count); Assert.IsTrue(col.ContainsValue(GuidToString(contactPerson4.ID.GetAsGuid()))); }
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_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 ShouldMapValuesToCorrectType_WhenPropertyIsNotStringAndDatabaseTypeIs() { //---------------Set up test pack------------------- var classDef = ContactPersonTestBO.LoadDefaultClassDef(); classDef.PropDefcol["FirstName"].PropertyType = typeof(int); var cp1 = new ContactPersonTestBO(); cp1.Surname = Guid.NewGuid().ToString("N"); var firstNameValue = 20; cp1.SetPropertyValue("FirstName", firstNameValue); cp1.Save(); var selectQuery = QueryBuilder.CreateSelectQuery(classDef); selectQuery.Fields.Clear(); selectQuery.Fields.Add("FirstName", QueryBuilder.CreateQueryField(classDef, "FirstName")); //---------------Execute Test ---------------------- var resultSet = _queryResultLoader.GetResultSet(selectQuery); //---------------Test Result ----------------------- var rows = resultSet.Rows.ToList(); Assert.AreEqual(firstNameValue, rows[0].Values[0]); }
public void TestNotIsMatch_OneProp_NotLike_ValuesEndsWith_CriteriaEndsWith() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = "surname is MyValue"; cp.Save(); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- Criteria criteria = new Criteria("Surname", Criteria.ComparisonOp.NotLike, "%MyValue"); bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsFalse(isMatch, "The object should not be a match since it matches the criteria given."); }
public void Test_SaveDuplicateObject_DoesNotAddItselfToObjectManager() { //This scenario is unlikely to ever happen in normal use but is frequently hit during testing. //An object that has a reference to it is removed from the object manager (usually via ClearLoadedObjects). // A second instance of the same object is now loaded. This new instance is therefore added to the object manager. // The first object is saved. This must not remove the second instance of the object from the object manager // and insert a itself. //---------------Set up test pack------------------- SetupDefaultContactPersonBO(); var boMan = BusinessObjectManager.Instance; var originalContactPerson = new ContactPersonTestBO {Surname = "FirstSurname"}; originalContactPerson.Save(); var origCPID = originalContactPerson.ID; FixtureEnvironment.ClearBusinessObjectManager(); //---------------Assert Precondition---------------- Assert.AreEqual(0, boMan.Count); Assert.IsFalse(boMan.Contains(originalContactPerson)); //---------------Execute Test Step 1---------------------- var myContact2 = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject<ContactPersonTestBO>(origCPID); //---------------Test Result Step 1----------------------- Assert.AreEqual(1, boMan.Count); Assert.IsTrue(boMan.Contains(myContact2)); //---------------Execute Test Step 2---------------------- originalContactPerson.Surname = TestUtil.GetRandomString(); originalContactPerson.Save(); //---------------Test Result Step 1----------------------- Assert.AreNotSame(originalContactPerson, myContact2); Assert.AreEqual(1, boMan.Count); Assert.IsFalse (boMan.Contains(originalContactPerson), "This object should not have been added to the object manager"); Assert.IsTrue(boMan.Contains(myContact2), "This object should still b in the object manager"); }
private static ContactPersonTestBO CreateSavedCP() { var cp = new ContactPersonTestBO {Surname = TestUtil.GetRandomString(), FirstName = TestUtil.GetRandomString()}; cp.Save(); return cp; }
public void TestRefreshWithRemovedChild_DereferenceChild() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); AddressTestBO address; ContactPersonTestBO cp = ContactPersonTestBO.CreateContactPersonWithOneAddress_DeleteDoNothing(out address); ContactPersonTestBO cp2 = new ContactPersonTestBO(); cp2.Surname = Guid.NewGuid().ToString("N"); cp2.FirstName = Guid.NewGuid().ToString("N"); cp2.Save(); //---------------Assert Precondition---------------- Assert.AreEqual(1, cp.Addresses.Count); //---------------Execute Test ---------------------- address.ContactPersonID = cp2.ContactPersonID; address.Save(); address.SetDeletable(false); RelatedBusinessObjectCollection<AddressTestBO> addresses = cp.Addresses; //---------------Test Result ----------------------- Assert.AreEqual(0, addresses.Count); }
public void Test_GetDirtyChildren_Edited() { //---------------Set up test pack------------------- OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation(); SingleRelationship<ContactPersonTestBO> relationship = GetAggregationRelationshipContactPerson(organisationTestBO, "ContactPerson"); ContactPersonTestBO contactPerson = new ContactPersonTestBO(); contactPerson.Surname = TestUtil.GetRandomString(); contactPerson.FirstName = TestUtil.GetRandomString(); contactPerson.Organisation = organisationTestBO; contactPerson.Save(); contactPerson.FirstName = TestUtil.GetRandomString(); //---------------Execute Test ---------------------- IList<ContactPersonTestBO> dirtyChildren = relationship.GetDirtyChildren(); //---------------Test Result ----------------------- Assert.Contains(contactPerson, (ICollection) dirtyChildren); Assert.AreEqual(1, dirtyChildren.Count); }
public void Test_DirtyIfHasDirtyChildren() { //---------------Set up test pack------------------- OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation(); SingleRelationship<ContactPersonTestBO> relationship = GetAggregationRelationshipContactPerson(organisationTestBO, "ContactPerson"); ContactPersonTestBO contactPerson = new ContactPersonTestBO(); contactPerson.Surname = TestUtil.GetRandomString(); contactPerson.FirstName = TestUtil.GetRandomString(); contactPerson.Organisation = organisationTestBO; contactPerson.Save(); //---------------Assert Precondition---------------- Assert.IsFalse(relationship.IsDirty); //---------------Execute Test ---------------------- contactPerson.FirstName = TestUtil.GetRandomString(); //---------------Test Result ----------------------- Assert.IsTrue(relationship.IsDirty); }
public void TestIsMatch_DateTimeToday_GreaterThan() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = Guid.NewGuid().ToString("N"); DateTimeToday dateTimeToday = new DateTimeToday(); cp.DateOfBirth = DateTime.Today.AddDays(1); cp.Save(); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- Criteria criteria = new Criteria("DateOfBirth", Criteria.ComparisonOp.GreaterThan, dateTimeToday); bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsTrue(isMatch, "The object should be a match since it matches the criteria given."); //---------------Tear Down ------------------------- }
public void TestIsMatch_OneProp_GreaterThan() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.DateOfBirth = DateTime.Now; cp.Surname = TestUtil.GetRandomString(); cp.Save(); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- Criteria criteria = new Criteria("DateOfBirth", Criteria.ComparisonOp.GreaterThan, DateTime.Now.AddDays(-1)); bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsTrue(isMatch, "The object should be a match since it matches the criteria given."); //---------------Tear Down ------------------------- }
public void TestIsMatch_OneProp_Equals() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = Guid.NewGuid().ToString("N"); cp.Save(); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- Criteria criteria = new Criteria("Surname", Criteria.ComparisonOp.Equals, cp.Surname); bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsTrue(isMatch, "The object should be a match since it matches the criteria given."); //---------------Tear Down ------------------------- }
public void TestNotIsMatch_OneProp_NotIn_Null() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = "Surname1"; cp.FirstName = null; cp.Save(); object[] values = new object[] { null, "FirstName1" }; Criteria.CriteriaValues criteriaValues = new Criteria.CriteriaValues(values); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- Criteria criteria = new Criteria("FirstName", Criteria.ComparisonOp.NotIn, criteriaValues); bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsFalse(isMatch, "The object should not be a match since it doesn't match the criteria given."); //---------------Tear Down ------------------------- }
public void TestFindAll_UsingClassDef_BUGFIX_ShouldBeThreadsafe(string aaa) { //---------------Set up test pack------------------- BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory()); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); OrganisationTestBO.LoadDefaultClassDef(); var dataStore = new DataStoreInMemory(); var now = DateTime.Now; var cp1 = new ContactPersonTestBO {DateOfBirth = now, Surname = TestUtil.GetRandomString()}; cp1.Save(); dataStore.Add(cp1); var cp2 = new ContactPersonTestBO {DateOfBirth = now, Surname = TestUtil.GetRandomString()}; cp2.Save(); dataStore.Add(cp2); //var criteria = MockRepository.GenerateStub<Criteria>("DateOfBirth", Criteria.ComparisonOp.Equals, now); //criteria.Stub(o => o.IsMatch(Arg<IBusinessObject>.Is.Anything)).WhenCalled(invocation => //{ // Thread.Sleep(100); // invocation.ReturnValue = true; //}).Return(true); var criteria = new Criteria("DateOfBirth", Criteria.ComparisonOp.Equals, now); for (int i1 = 0; i1 < 1000; i1++) { dataStore.Add(OrganisationTestBO.CreateSavedOrganisation()); } var threads = new List<Thread>(); threads.Add(new Thread(() => { for (int i1 = 0; i1 < 1000; i1++) { dataStore.Add(OrganisationTestBO.CreateSavedOrganisation()); } })); var exceptions = new List<Exception>(); threads.Add(new Thread(() => { try { for (int i = 0; i < 10; i++) { dataStore.FindAll(ClassDef.Get<ContactPersonTestBO>(), criteria); } } catch (Exception ex) { exceptions.Add( ex); } })); //---------------Execute Test ---------------------- threads.AsParallel().ForAll(thread => thread.Start()); threads.AsParallel().ForAll(thread => thread.Join()); //Assert.DoesNotThrow(() => //{ //var col = dataStore.FindAll(ClassDef.Get<ContactPersonTestBO>(), criteria); //thread.Join(); //}); //---------------Test Result ----------------------- if (exceptions.Count > 0) { Assert.Fail("Has an Exception: " + exceptions[0].ToString()); } }
public void TestIsMatch_OneProp_In() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = "Surname1"; cp.Save(); object[] values = new object[] { "Surname1", "Surname2" }; Criteria.CriteriaValues criteriaValues = new Criteria.CriteriaValues(values); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- Criteria criteria = new Criteria("Surname", Criteria.ComparisonOp.In, criteriaValues); bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsTrue(isMatch, "The object should be a match since it matches the criteria given."); //---------------Tear Down ------------------------- }
public void Test_SavedObjectInObjectManager() { //---------------Set up test pack------------------- FixtureEnvironment.ClearBusinessObjectManager(); SetupDefaultContactPersonBO(); var contactPersonTestBO = new ContactPersonTestBO {Surname = TestUtil.GetRandomString()}; //---------------Assert Precondition---------------- Assert.IsTrue(contactPersonTestBO.Status.IsNew); Assert.AreEqual(1, BusinessObjectManager.Instance.Count); Assert.IsTrue(BusinessObjectManager.Instance.Contains(contactPersonTestBO)); //---------------Execute Test ---------------------- contactPersonTestBO.Save(); //---------------Test Result ----------------------- Assert.IsFalse(contactPersonTestBO.Status.IsNew); Assert.AreEqual(1, BusinessObjectManager.Instance.Count); Assert.IsTrue(BusinessObjectManager.Instance.Contains(contactPersonTestBO)); Assert.IsTrue(BusinessObjectManager.Instance.Contains(contactPersonTestBO.ID)); }
public void TestSaveUsesFactoryGeneratedTransactionCommitter() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); BORegistry.DataAccessor = new DataAccessorInMemory(); SetupDefaultContactPersonBO(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = Guid.NewGuid().ToString("N"); //---------------Execute Test ---------------------- cp.Save(); //---------------Test Result ----------------------- ContactPersonTestBO loadedCP = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject<ContactPersonTestBO>(cp.ID); Assert.IsNotNull(loadedCP); Assert.AreSame(cp, loadedCP); //---------------Tear Down ------------------------- }
public void Test_SavedObject_Twice_AddedToObjectManager_Once() { //---------------Set up test pack------------------- SetupDefaultContactPersonBO(); var boMan = BusinessObjectManager.Instance; var cp = new ContactPersonTestBO {Surname = TestUtil.GetRandomString()}; cp.Save(); //---------------Assert Precondition---------------- Assert.AreEqual(1, boMan.Count); Assert.IsTrue(boMan.Contains(cp)); //---------------Execute Test ---------------------- cp.Surname = TestUtil.GetRandomString(); cp.Save(); //---------------Test Result ----------------------- Assert.AreEqual(1, boMan.Count); Assert.IsTrue(boMan.Contains(cp)); Assert.IsTrue(boMan.Contains(cp.ID)); Assert.IsTrue(boMan.Contains(cp.ID.ObjectID)); //Assert.AreSame(cp, boMan[cp.ID.AsString_CurrentValue()]); Assert.AreSame(cp, boMan[cp.ID.ObjectID]); Assert.AreSame(cp, boMan[cp.ID]); }
public void TestBOLookupListWithString() { //ContactPersonTestBO.CreateSampleData(); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); var classDef = MyBO.LoadClassDefWithBOStringLookup(); //var criteria = new Criteria("Surname", Criteria.ComparisonOp.Equals, "abc"); //var cp = // BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject<ContactPersonTestBO>(criteria); var cp = new ContactPersonTestBO(); const string expectedSurname = "abc"; cp.Surname = expectedSurname; cp.Save(); var bo = (BusinessObject) classDef.CreateNewBusinessObject(); bo.SetPropertyValue("TestProp2", "abc"); Assert.IsNotNull(cp, "ContactPerson should not be null"); Assert.AreEqual(cp.ContactPersonID.ToString(), bo.GetPropertyValue("TestProp2")); Assert.AreEqual("abc", bo.GetPropertyValueToDisplay("TestProp2")); }
public void TestIsMatch_NotLike_Incomparable() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadClassDefWithImageProperty(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.SetPropertyValue("Image", new System.Drawing.Bitmap(10, 10)); Criteria nameCriteria = new Criteria("Image", Criteria.ComparisonOp.NotLike, new System.Drawing.Bitmap(20, 20)); cp.Surname = TestUtil.GetRandomString(); cp.Save(); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- try { nameCriteria.IsMatch(cp); Assert.Fail("expected InvalidOperationException because you Bitmap does not implement IComparable"); //---------------Test Result ----------------------- } catch (InvalidOperationException ex) { StringAssert.Contains("does not implement IComparable and cannot be matched", ex.Message); } }
public void TestNotIsMatch_OneProp_IS() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = "MyValue"; cp.Save(); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- Criteria criteria = new Criteria("Surname", Criteria.ComparisonOp.Is, "NULL"); bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsFalse(isMatch, "The object should not be a match since its surname is not null."); }
public void TestIsMatch_OneProp_Like_ValuesIdentical_CriteriaEndsWith() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = "MyValue"; cp.Save(); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- Criteria criteria = new Criteria("Surname", Criteria.ComparisonOp.Like, "%MyValue"); bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsTrue(isMatch, "The object should be a match since surname ends with MyValue."); //---------------Tear Down ------------------------- }
public void TestFind() { //---------------Set up test pack------------------- BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory()); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); cp.Surname = Guid.NewGuid().ToString("N"); cp.Save(); DataStoreInMemory dataStore = new DataStoreInMemory(); dataStore.Add(cp); Criteria criteria = new Criteria("Surname", Criteria.ComparisonOp.Equals, cp.Surname); //---------------Execute Test ---------------------- ContactPersonTestBO loadedCP = dataStore.Find<ContactPersonTestBO>(criteria); //---------------Test Result ----------------------- Assert.AreSame(cp.ID, loadedCP.ID); //---------------Tear Down ------------------------- }
private ContactPersonTestBO CreateContactPerson(string surname) { var cp1 = new ContactPersonTestBO(); cp1.Surname = surname; cp1.FirstName = Guid.NewGuid().ToString("N"); cp1.Save(); return cp1; }
public void TestFind_UsingGuidCriteria_Untyped() { //---------------Set up test pack------------------- BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory()); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef_WOrganisationID(); OrganisationTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO {Surname = Guid.NewGuid().ToString("N")}; cp.OrganisationID = OrganisationTestBO.CreateSavedOrganisation().OrganisationID; cp.Save(); DataStoreInMemory dataStore = new DataStoreInMemory(); dataStore.Add(cp); Criteria criteria = new Criteria("OrganisationID", Criteria.ComparisonOp.Equals, cp.OrganisationID); //---------------Execute Test ---------------------- ContactPersonTestBO loadedCP = (ContactPersonTestBO) dataStore.Find(typeof(ContactPersonTestBO), criteria); //---------------Test Result ----------------------- Assert.AreSame(cp.ID, loadedCP.ID); }
public void TestFind_UsingGuidCriteriaString_Typed() { //---------------Set up test pack------------------- BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory()); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef_WOrganisationID(); OrganisationTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO { Surname = Guid.NewGuid().ToString("N") }; cp.OrganisationID = OrganisationTestBO.CreateSavedOrganisation().OrganisationID; cp.Save(); DataStoreInMemory dataStore = new DataStoreInMemory(); dataStore.Add(cp); Criteria criteria = CriteriaParser.CreateCriteria("OrganisationID = " + cp.OrganisationID); //---------------Assert Precondtions--------------- Assert.IsNotNull(cp.OrganisationID); //---------------Execute Test ---------------------- ContactPersonTestBO loadedCP = dataStore.Find<ContactPersonTestBO>(criteria); //---------------Test Result ----------------------- Assert.IsNotNull(loadedCP); Assert.AreSame(cp.ID, loadedCP.ID); }
public void TestFindAll_UsingClassDef() { //---------------Set up test pack------------------- BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory()); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); OrganisationTestBO.LoadDefaultClassDef(); DataStoreInMemory dataStore = new DataStoreInMemory(); DateTime now = DateTime.Now; ContactPersonTestBO cp1 = new ContactPersonTestBO(); cp1.DateOfBirth = now; cp1.Surname = TestUtil.GetRandomString(); cp1.Save(); dataStore.Add(cp1); ContactPersonTestBO cp2 = new ContactPersonTestBO(); cp2.DateOfBirth = now; cp2.Surname = TestUtil.GetRandomString(); cp2.Save(); dataStore.Add(cp2); Criteria criteria = new Criteria("DateOfBirth", Criteria.ComparisonOp.Equals, now); dataStore.Add(OrganisationTestBO.CreateSavedOrganisation()); //---------------Execute Test ---------------------- IBusinessObjectCollection col = dataStore.FindAll(ClassDef.Get<ContactPersonTestBO>(), criteria); //---------------Test Result ----------------------- Assert.AreEqual(2, col.Count); Assert.Contains(cp1, col); Assert.Contains(cp2, col); }
public void Test_IsMatch_GuidCriteriaAsString_UserPersistedValueTrue() { //---------------Set up test pack------------------- BORegistry.DataAccessor = new DataAccessorInMemory(); ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef_WOrganisationID(); OrganisationTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO { Surname = Guid.NewGuid().ToString("N") }; cp.OrganisationID = OrganisationTestBO.CreateSavedOrganisation().OrganisationID; cp.Save(); Criteria criteria = CriteriaParser.CreateCriteria("OrganisationID = " + cp.OrganisationID); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- bool isMatch = criteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsTrue(isMatch); }
public void TestIsMatch_TwoProps_And() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); DateTime dob = DateTime.Now; cp.DateOfBirth = dob; string surname = Guid.NewGuid().ToString("N"); cp.Surname = surname; cp.Save(); Criteria dobCriteria = new Criteria("DateOfBirth", Criteria.ComparisonOp.Equals, dob); Criteria nameCriteria = new Criteria("Surname", Criteria.ComparisonOp.Equals, surname); //---------------Execute Test ---------------------- Criteria twoPropCriteria = new Criteria(dobCriteria, Criteria.LogicalOp.And, nameCriteria); bool isMatch = twoPropCriteria.IsMatch(cp); //---------------Test Result ----------------------- Assert.IsTrue(isMatch, "The object should be a match since it matches the criteria given."); //---------------Tear Down ------------------------- }