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);
            }
        }
Ejemplo n.º 7
0
        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);
            }
        }
Ejemplo n.º 9
0
        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);
        }
Ejemplo n.º 10
0
        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"));
            }
        }
Ejemplo n.º 11
0
        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)));
        }
Ejemplo n.º 16
0
        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));
            }
        }
Ejemplo n.º 17
0
        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();
            }
        }
Ejemplo n.º 18
0
 public void ShouldBeAbleToTellThatReferenceTypeIsNotDefaultValue()
 {
     MyClass myObj = new MyClass();
     Assert.IsFalse(reflectionUtil.IsDefaultValue(myObj));
 }