public void removing_a_handler_causes_members_of_that_type_to_not_be_named() { var myClass = new MyClass(); target.DontName<string>(); target.SetValuesOf(myClass); Assert.That(myClass.StringOne, Is.Null); }
public void nullable_members_are_set_using_the_specifc_nullable_handler_and_not_the_non_nullable_one_for_te_same_type() { var myClass = new MyClass(); target.NameWith<int?>(() => 500); target.SetValuesOf(myClass); Assert.That(myClass.NullableInt, Is.EqualTo(500)); }
public void replace_a_default_handler_names_with_new_handler() { var myClass = new MyClass(); const int intValue = 234; target.NameWith(() => GetRandom.Int(intValue, intValue)); target.SetValuesOf(myClass); Assert.That(myClass.Int, Is.EqualTo(intValue)); }
public void can_set_values_of() { using (mocks.Playback()) { var myClass = new MyClass(); target.SetValuesOf(myClass); } }
public void adding_handler_for_complex_type_names_using_the_added_handler() { // Arrange var myClass = new MyClass(); target.NameWith<SimpleClass>(SimpleClassBuilder.New.Build); // Act target.SetValuesOf(myClass); // Assert Assert.AreEqual(SimpleClassBuilder.String1Length, myClass.SimpleClassProperty.String1.Length); Assert.AreEqual(SimpleClassBuilder.String2Length, myClass.SimpleClassProperty.String2.Length); }
public void ShouldBeAbleToPersistAnObject_Update() { var obj = new MyClass(); PersistenceService persistenceService = new PersistenceService(); persistenceService.SetPersistenceUpdateMethod<MyClass>(x => repository.Save(x)); using (mocks.Record()) { repository.Expect(x => x.Save(obj)); } using (mocks.Playback()) { persistenceService.Update(obj); } }
public void RandomItemPickerShouldHitRandomGeneratorEveryTimeAnItemIsPicked() { var zero = new MyClass(); var one = new MyClass(); var theList = new List<MyClass> { zero, one }; int endIndex = theList.Count; randomGenerator.Stub(x => x.Next(0, endIndex)).Return(0).Repeat.Once(); randomGenerator.Stub(x => x.Next(0, endIndex)).Return(1).Repeat.Once(); var picker = new RandomItemPicker<MyClass>(theList, randomGenerator); Assert.That(picker.Pick(), Is.EqualTo(zero)); Assert.That(picker.Pick(), Is.EqualTo(one)); }
public void ShouldBeAbleToPersistUsingSingleObjectBuilder() { var obj = new MyClass(); using (mocks.Record()) { singleObjectBuilder.Expect(x => x.Build()).Return(obj); persistenceService.Expect(x => x.Create(obj)); } BuilderSetup.SetPersistenceService(persistenceService); using (mocks.Playback()) { PersistenceExtensions.Persist(singleObjectBuilder); } }
public void AddToMaster_AddsEachItemToTheList() { var masterList = new MyClass[listSize]; objectBuilder.Stub(x => x.Construct(Arg<int>.Is.Anything)).Return(new MyClass()).Repeat.Times(amount); uniqueRandomGenerator.Stub(x => x.Next(start, end)).Return(0).Repeat.Once(); uniqueRandomGenerator.Stub(x => x.Next(start, end)).Return(2).Repeat.Once(); uniqueRandomGenerator.Stub(x => x.Next(start, end)).Return(4).Repeat.Once(); declaration.Construct(); // Act declaration.AddToMaster(masterList); // Assert Assert.That(masterList[0], Is.Not.Null); Assert.That(masterList[2], Is.Not.Null); Assert.That(masterList[4], Is.Not.Null); }
public void ShouldBeAbleToUseWith_WithAnIndex() { using (mocks.Record()) { } using (mocks.Playback()) { var myClass = new MyClass(); builder.With((x, idx) => x.StringOne = "String" + (idx + 5)); builder.CallFunctions(myClass, 9); Assert.That(myClass.StringOne, Is.EqualTo("String14")); } }
public void ShouldReplaceExistingUpdatePersister() { var obj = new MyClass(); PersistenceService persistenceService = new PersistenceService(); persistenceService.SetPersistenceUpdateMethod<MyClass>(x => repository.Save(x)); persistenceService.SetPersistenceUpdateMethod<MyClass>(x => repository2.Save(x)); using (mocks.Record()) { repository2.Expect(x => x.Save(obj)); } using (mocks.Playback()) { persistenceService.Update(obj); } }
public void ShouldOnlyNamePropertiesThatAreNullOrDefault() { var myClass = new MyClass(); var reflectionUtil = MockRepository.GenerateMock<IReflectionUtil>(); reflectionUtil.Expect(x => x.IsDefaultValue(myClass.HasADefaultValue)).Return(false).Repeat.Times(listSize); reflectionUtil.Expect(x => x.IsDefaultValue(Arg<object>.Is.NotEqual(myClass.HasADefaultValue))). IgnoreArguments().Return(true).Repeat.AtLeastOnce(); theList = new List<MyClass>(); for (int i = 0; i < listSize; i++) theList.Add(new MyClass()); new SequentialPropertyNamer(reflectionUtil,new BuilderSetup()).SetValuesOfAllIn(theList); Assert.That(theList[0].HasADefaultValue, Is.EqualTo(myClass.HasADefaultValue)); Assert.That(theList[9].HasADefaultValue, Is.EqualTo(myClass.HasADefaultValue)); reflectionUtil.VerifyAllExpectations(); }
public void nullable_members_are_set_using_the_non_nullable_handler_when_no_nullable_handler_exists() { var myClass = new MyClass(); target.SetValuesOf(myClass); Assert.That(myClass.NullableInt, Is.Not.Null); }
public void when_naming_with_handler_that_takes_memeberinfo_parameter__the_member_info_parameter_will_be_received() { var foo = new MyClass(); MemberInfo simpleClassMemberInfo = null; target.NameWith(m => { simpleClassMemberInfo = m; return new SimpleClass(); }); MemberInfo dateTimeMemberInfo = null; target.NameWith(m => { dateTimeMemberInfo = m; return DateTime.UtcNow; }); target.SetValuesOf(foo); Assert.That(simpleClassMemberInfo.Name, Is.EqualTo("SimpleClassProperty")); Assert.That(simpleClassMemberInfo.DeclaringType, Is.EqualTo(typeof(MyClass))); Assert.That(dateTimeMemberInfo.Name, Is.EqualTo("DateTime")); Assert.That(dateTimeMemberInfo.DeclaringType, Is.EqualTo(typeof(MyClass))); }
public void SetValuesOf_IgnoredProperty_HonorsIgnore() { // Arrange var myClass = new MyClass(); builderSettings.DisablePropertyNamingFor<MyClass, long>(x => x.Long); target.NameWith<long>(() => 50); // Act target.SetValuesOf(myClass); // Assert Assert.That(myClass.Long, Is.EqualTo(default(long))); }
public void ShouldBeAbleToUseWith() { using (mocks.Record()) { } using (mocks.Playback()) { var myClass = new MyClass(); builder.With(x => x.Float = 2f); builder.CallFunctions(myClass); Assert.That(myClass.Float, Is.EqualTo(2f)); } }
public void ShouldBeAbleToUseBuild() { var myClass = new MyClass(); IPropertyNamer propertyNamer = MockRepository.GenerateMock<IPropertyNamer>(); using (mocks.Record()) { reflectionUtil.Expect(x => x.CreateInstanceOf<MyClass>()).Return(myClass); propertyNamer.Expect(x => x.SetValuesOf(Arg<MyClass>.Is.TypeOf)); } using (mocks.Playback()) { builder.WithPropertyNamer(propertyNamer); builder.With(x => x.Float = 2f); builder.Build(); } }
public void ShouldBeAbleToTellThatReferenceTypeIsNotDefaultValue() { MyClass myObj = new MyClass(); Assert.IsFalse(reflectionUtil.IsDefaultValue(myObj)); }