public void Test_SetRelationship_WhenHasValue_AndValueRegistered_ShouldSetToRegisteredValue() { //---------------Set up test pack------------------- var bo = new BOTestFactory(typeof(FakeBO)).CreateValidBusinessObject(); var relationship = bo.Relationships["NonCompulsoryRelationship"] as ISingleRelationship; var factory = new BOTestFactory <FakeBO>(); factory.SetRelationshipToValidValue(relationship); var expectedRelationshipValue = new RelatedFakeBo(); //---------------Assert Precondition---------------- Assert.IsNotNull(relationship); var origionalBO = relationship.GetRelatedObject(); Assert.IsNotNull(relationship.GetRelatedObject()); //---------------Execute Test ---------------------- factory.SetValueFor(fakeBO => fakeBO.NonCompulsoryRelationship, expectedRelationshipValue); factory.SetRelationshipToValidValue(relationship); var actualRelatedObject = relationship.GetRelatedObject(); //---------------Test Result ----------------------- Assert.IsNotNull(actualRelatedObject); Assert.AreSame(expectedRelationshipValue, actualRelatedObject); }
public void Test_GetValidPropValue_WhenDateTimeAndMaxValue_WhenPropName_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(DateTime) }; DateTime min = RandomValueGen.GetAbsoluteMin <DateTime>().AddDays(5555.0); DateTime max = RandomValueGen.GetAbsoluteMin <DateTime>().AddDays(5565.0); def.AddPropRule(TestUtilsFactory.CreatePropRuleDateTime(min, max)); var factory = new BOTestFactory(typeof(FakeBO)); //---------------Assert Precondition---------------- Assert.AreSame(typeof(DateTime), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleDate>().ToList()); var propRule = def.PropRules.OfType <PropRuleDate>().First(); Assert.AreEqual(min, propRule.MinValue); Assert.AreEqual(max, propRule.MaxValue.Date); //---------------Execute Test ---------------------- var validPropValue = factory.GetValidPropValue(def); //---------------Test Result ----------------------- Assert.GreaterOrEqual((DateTime)validPropValue, min); Assert.LessOrEqual((DateTime)validPropValue, max); string errMessage = ""; Assert.IsTrue(def.IsValueValid(validPropValue, ref errMessage), errMessage); }
public void Test_GetValidPropValue_WhenStringAndMaxLength_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(string) }; def.AddPropRule(CreatePropRuleString(3, 7)); IBOProp prop = new BOProp(def); var factory = new BOTestFactory(typeof(FakeBO)); //---------------Assert Precondition---------------- Assert.AreSame(typeof(string), prop.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleString>().ToList()); var propRule = def.PropRules.OfType <PropRuleString>().First(); Assert.AreEqual(3, propRule.MinLength); Assert.AreEqual(7, propRule.MaxLength); //---------------Execute Test ---------------------- var validPropValue = factory.GetValidPropValue(prop); //---------------Test Result ----------------------- Assert.IsNotNull(validPropValue); Assert.GreaterOrEqual(validPropValue.ToString().Length, 3); Assert.LessOrEqual(validPropValue.ToString().Length, 7); }
public void Test_GetValidPropValue_WhenStringAndMaxLengthWhenPropName_ShouldRetValidValue() { //---------------Set up test pack------------------- var classDef = ClassDef.Get <FakeBO>(); var def = classDef.PropDefcol.FirstOrDefault(propDef => propDef.PropertyName == "CompulsoryString"); //---------------Assert Precondition---------------- Assert.IsNotNull(def); def.AddPropRule(CreatePropRuleString(3, 7)); var factory = new BOTestFactory(typeof(FakeBO)); Assert.AreSame(typeof(string), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleString>().ToList()); var propRule = def.PropRules.OfType <PropRuleString>().First(); Assert.AreEqual(3, propRule.MinLength); Assert.AreEqual(7, propRule.MaxLength); //---------------Execute Test ---------------------- var validPropValue = factory.GetValidPropValue(typeof(FakeBO), "CompulsoryString").ToString(); //---------------Test Result ----------------------- Assert.IsNotNull(validPropValue); Assert.GreaterOrEqual(validPropValue.Length, 3); Assert.LessOrEqual(validPropValue.Length, 7); string errMessage = ""; Assert.IsTrue(def.IsValueValid(validPropValue, ref errMessage)); }
private BOTestFactory GetTestFactory() { if (_boTestFactory == null) { _boTestFactory = BOTestFactoryRegistry.Instance.Resolve(ClassType); } return(_boTestFactory); }
public BOTester(IBusinessObject businessObject) { if (businessObject == null) { throw new ArgumentNullException("businessObject"); } _boTestFactory = new BOTestFactory(businessObject.GetType()); BusinessObject = businessObject; }
public void Test_Resolve_WithType_WhenNoFactoryRegistered_AndHasSpecialisedFactory_ShouldRetSpecialisedFactory() { //---------------Set up test pack------------------- var boTestFactoryRegistry = new BOTestFactoryRegistry(); //---------------Execute Test ---------------------- BOTestFactory boTestFactory = boTestFactoryRegistry.Resolve(typeof(FakeBO)); Assert.IsInstanceOf <BOTestFactoryFakeBO>(boTestFactory); Assert.IsInstanceOf <BOTestFactory <FakeBO> >(boTestFactory); }
public void Test_Register_WhenCustomBOTestFactory_WithFactoryType_ShouldReturnWhenResolved() { //---------------Set up test pack------------------- BOTestFactoryRegistry registry = new BOTestFactoryRegistry(); registry.Register <FakeBO>(typeof(BOTestFactoryFakeBO)); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- BOTestFactory boTestFactory = registry.Resolve <FakeBO>(); //---------------Test Result ----------------------- Assert.IsInstanceOf <BOTestFactoryFakeBO>(boTestFactory); }
public void Test_RegisterInstance_ShouldRegister() { //---------------Set up test pack------------------- BOTestFactoryRegistry registry = new BOTestFactoryRegistry(); BOTestFactoryFakeBO boTestFactoryFakeBO = new BOTestFactoryFakeBO(); //---------------Assert Precondition---------------- registry.Register <FakeBO>(boTestFactoryFakeBO); //---------------Execute Test ---------------------- BOTestFactory boTestFactory = registry.Resolve <FakeBO>(); Assert.AreSame(boTestFactoryFakeBO, boTestFactory); }
public void Test_CreateValidBusinessObject_ShouldReturnBOWithCompulsoryPropsPopulated() { //---------------Set up test pack------------------- //---------------Assert Precondition---------------- var factory = new BOTestFactory(typeof(FakeBO)); //---------------Execute Test ---------------------- var businessObject = factory.CreateValidBusinessObject() as FakeBO; //---------------Test Result ----------------------- Assert.IsNotNull(businessObject); Assert.IsInstanceOf <FakeBO>(businessObject); Assert.IsNotNull(businessObject.CompulsoryString); }
public void Test_SetDefaultValue_WhenRelationship_ShouldCreateWithValueSet() { //---------------Set up test pack------------------- var relatedBO = new RelatedFakeBo(); var boWithRelFactory = new BOTestFactory(typeof(FakeBOWithRelationship)); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- boWithRelFactory.SetValueFor("SingleRelationship", relatedBO); var boWithRelationship = boWithRelFactory.CreateValidBusinessObject() as FakeBOWithRelationship; //---------------Test Result ----------------------- Assert.IsNotNull(boWithRelationship); Assert.AreSame(relatedBO, boWithRelationship.SingleRelationship); }
public void Test_GetValidValueGenerator_WhenEnum_ShouldRetEnumGenerator() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(FakeEnum) }; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var generator = new BOTestFactory <FakeBOWithRules>().GetValidValueGenerator(def); //---------------Test Result ----------------------- Assert.IsNotNull(generator); Assert.IsInstanceOf <ValidValueGeneratorEnum>(generator); }
public void Test_SetDefaultValue_WhenProperty_ShouldReturnSetValue() { //---------------Set up test pack------------------- const string expectedPropValue = "SomeValue"; const string propName = "SomeProp"; var boWithRelFactory = new BOTestFactory(typeof(FakeBO)); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- boWithRelFactory.SetValueFor(propName, expectedPropValue); var actualValue = boWithRelFactory.GetValidPropValue(typeof(FakeBOWithRelationship), propName); //---------------Test Result ----------------------- Assert.AreSame(expectedPropValue, actualValue); }
public void Test_RegisterTwice_WhenInstanceThenType_ShouldStoreSecond() { //---------------Set up test pack------------------- BOTestFactoryRegistry registry = new BOTestFactoryRegistry(); BOTestFactoryFakeBO origFactory = new BOTestFactoryFakeBO(); registry.Register <FakeBO>(origFactory); //---------------Assert Precondition---------------- Assert.IsNotNull(registry.Resolve <FakeBO>()); //---------------Execute Test ---------------------- registry.Register <FakeBO, BOTestFactory <FakeBO> >(); BOTestFactory boTestFactory = registry.Resolve <FakeBO>(); Assert.AreNotSame(origFactory, boTestFactory); }
public void Test_SetRelationship_WhenNull_ShouldSetValue() { //---------------Set up test pack------------------- var bo = new BOTestFactory(typeof(FakeBO)).CreateValidBusinessObject(); var relationship = bo.Relationships["NonCompulsoryRelationship"] as ISingleRelationship; var factory = new BOTestFactory <FakeBO>(); //---------------Assert Precondition---------------- Assert.IsNotNull(relationship); Assert.IsNull(relationship.GetRelatedObject()); //---------------Execute Test ---------------------- factory.SetRelationshipToValidValue(relationship); //---------------Test Result ----------------------- Assert.IsNotNull(relationship.GetRelatedObject()); }
public void Test_GetValidRelationshipValue_ShouldRetValidValue() { //---------------Set up test pack------------------- var relationship = new BOTestFactory(typeof(FakeBO)).CreateValidBusinessObject().Relationships["NonCompulsoryRelationship"] as ISingleRelationship; var factory = new BOTestFactory(typeof(FakeBO)); //---------------Assert Precondition---------------- Assert.IsNotNull(relationship); Assert.IsNull(relationship.GetRelatedObject()); //---------------Execute Test ---------------------- var validRelationshipValue = factory.GetValidRelationshipValue(relationship.RelationshipDef as ISingleValueDef); //---------------Test Result ----------------------- Assert.IsNotNull(validRelationshipValue); Assert.AreSame(validRelationshipValue.ClassDef, relationship.RelatedObjectClassDef); }
public void Test_GetValidRelationshipValue_ShouldCreateRelatedBO() { //---------------Set up test pack------------------- var boTestFactory = new BOTestFactory(typeof(FakeBO)); var businessObject = (FakeBO)boTestFactory.CreateValidBusinessObject(); var relationship = businessObject.Relationships["NonCompulsoryRelationship"] as ISingleRelationship; //---------------Assert Precondition---------------- Assert.IsNotNull(relationship); Assert.IsNull(relationship.GetRelatedObject()); //---------------Execute Test ---------------------- IRelationshipDef relationshipDef = relationship.RelationshipDef; IBusinessObject validRelationshipValue = boTestFactory.GetValidRelationshipValue(relationshipDef as ISingleValueDef); //---------------Test Result ----------------------- Assert.IsNotNull(validRelationshipValue); Assert.IsTrue(validRelationshipValue.Status.IsNew); }
public void Test_GetValidValueGenerator_WhenHasLookup_ShouldRetLookupGenerator() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(string), LookupList = MockRepository.GenerateStub <IBusinessObjectLookupList>() }; //---------------Assert Precondition---------------- Assert.IsTrue(def.HasLookupList()); //---------------Execute Test ---------------------- var generator = new BOTestFactory <FakeBOWithRules>().GetValidValueGenerator(def); //---------------Test Result ----------------------- Assert.IsNotNull(generator); Assert.IsInstanceOf <ValidValueGeneratorLookupList>(generator); }
public void Test_GetValidPropValue_WhenClassNotInClassDefs_ShouldRaiseError() { //---------------Assert Precondition---------------- Type type = typeof(Unmapped); var factory = new BOTestFactory(typeof(FakeBO)); Assert.IsFalse(ClassDef.ClassDefs.Contains(type)); //---------------Execute Test ---------------------- try { factory.GetValidPropValue(type, "SomeProp"); Assert.Fail("Expected to throw an HabaneroDeveloperException"); } catch (HabaneroDeveloperException ex) { StringAssert.Contains(string.Format("The ClassDef for '{0}' does not have any classDefs Loaded", type), ex.Message); StringAssert.Contains("The BOTestFactory class is designed to be used in Testing so it is likely that your classdefs are not being loaded as part of your testing process", ex.DeveloperMessage); } }
public void Test_GetdataPage_WhenRecordsInDataSource_ShouldReturnRecords() { //---------------Set up test pack------------------- BindingListRequest <FakeBO> request = new BindingListRequest <FakeBO>(); PageProvider <FakeBO> pageProvider = new PageProvider <FakeBO>(request); BOTestFactory <FakeBO> assetFactory = BOTestFactoryRegistry.Instance.Resolve <FakeBO>(); assetFactory.CreateManySavedBusinessObject(40); //---------------Assert Precondition---------------- Assert.IsNullOrEmpty(pageProvider.Filter); Assert.AreEqual(0, request.PageNumber); Assert.AreEqual(20, request.RowsPerPage); //---------------Execute Test ---------------------- IList <FakeBO> dataPage = pageProvider.GetDataPage(0); //---------------Test Result ----------------------- Assert.AreEqual(request.RowsPerPage, dataPage.Count); //dataPage. }
public void Test_GetValidValue_WhenNotRelOrProp_ShouldRaiseError() { //---------------Set up test pack------------------- var factory = new BOTestFactory(typeof(FakeBO)); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- try { factory.GetValidValue("InvalidProp"); Assert.Fail("Expected to throw an HabaneroApplicationException"); } //---------------Test Result ----------------------- catch (HabaneroDeveloperException ex) { const string message = "is not defined as either a SingleRelationshipDef or a PropertyDef"; StringAssert.Contains(message, ex.Message); } }
public void Test_GetValidPropValue_WhenNoPropDefForClassDef_ShouldRaiseError() { //---------------Set up test pack------------------- Type type = typeof(FakeBO); var factory = new BOTestFactory(typeof(FakeBO)); //---------------Assert Precondition---------------- Assert.IsTrue(ClassDef.ClassDefs.Contains(type)); //---------------Execute Test ---------------------- try { factory.GetValidPropValue(type, "InvalidProp"); Assert.Fail("Expected to throw an HabaneroDeveloperException"); } catch (HabaneroDeveloperException ex) { StringAssert.Contains(string.Format("The property '{0}' for the ClassDef for '{1}' is not defined", "InvalidProp", type), ex.Message); StringAssert.Contains("The BOTestFactory class is designed to be used in Testing so it is likely that your classdefs are not being loaded as part of your testing process.", ex.DeveloperMessage); } }
public void Test_SetRelationship_WhenHasValue_ShouldNotChange() { //---------------Set up test pack------------------- var bo = new BOTestFactory(typeof(FakeBO)).CreateValidBusinessObject(); var relationship = bo.Relationships["NonCompulsoryRelationship"] as ISingleRelationship; var factory = new BOTestFactory <FakeBO>(); factory.SetRelationshipToValidValue(relationship); //---------------Assert Precondition---------------- Assert.IsNotNull(relationship); var origionalBO = relationship.GetRelatedObject(); Assert.IsNotNull(relationship.GetRelatedObject()); //---------------Execute Test ---------------------- factory.SetRelationshipToValidValue(relationship); var actualRelatedObject = relationship.GetRelatedObject(); //---------------Test Result ----------------------- Assert.IsNotNull(actualRelatedObject); Assert.AreSame(origionalBO, actualRelatedObject); }
public void Test_GetValidValue_WithBO_WhenIsRelationship_ShouldRetValidValue() { //---------------Set up test pack------------------- const string relName = "NonCompulsoryRelationship"; Type boType = typeof(FakeBO); var relationship = new BOTestFactory(boType).CreateValidBusinessObject().Relationships[relName] as ISingleRelationship; var factory = new BOTestFactory(boType); //---------------Assert Precondition---------------- Assert.IsNotNull(relationship); Assert.IsNull(relationship.GetRelatedObject()); //---------------Execute Test ---------------------- object validValue = factory.GetValidValue(new FakeBO(), relName); //---------------Test Result ----------------------- Assert.IsNotNull(validValue); Assert.IsInstanceOf <IBusinessObject>(validValue); var validRelationshipValue = validValue as IBusinessObject; Assert.IsNotNull(validRelationshipValue); Assert.AreSame(validRelationshipValue.ClassDef, relationship.RelatedObjectClassDef); }
public void Test_GetValidValue_WithBO_WhenIsProp_ShouldRetValidValue() { //---------------Set up test pack------------------- var classDef = ClassDef.Get <FakeBO>(); var factory = new BOTestFactory(typeof(FakeBO)); IPropDef def = classDef.PropDefcol.FirstOrDefault(propDef => propDef.PropertyName == "CompulsoryString"); //---------------Assert Precondition---------------- Assert.IsNotNull(def); def.AddPropRule(CreatePropRuleString(3, 7)); //---------------Execute Test ---------------------- var validPropValue = factory.GetValidValue(new FakeBO(), "CompulsoryString"); //---------------Test Result ----------------------- Assert.IsNotNull(validPropValue); string validPropStringValue = validPropValue.ToString(); Assert.GreaterOrEqual(validPropStringValue.Length, 3); Assert.LessOrEqual(validPropStringValue.Length, 7); string errMessage = ""; Assert.IsTrue(def.IsValueValid(validPropStringValue, ref errMessage)); }
private BOTestFactory GetTestFactory() { if (_boTestFactory == null) { _boTestFactory = BOTestFactoryRegistry.Instance.Resolve(ClassType); } return _boTestFactory; }
public BOTester(IBusinessObject businessObject) { if (businessObject == null) throw new ArgumentNullException("businessObject"); _boTestFactory = new BOTestFactory(businessObject.GetType()); BusinessObject = businessObject; }