public void ShouldNotThrowIfConvetionsCollectionIsEmpty()
        {
            // Arrange
            // Act
            var sut = new PropertyNamingConventionsBucket(new List <IPropertyNameConvention>(),
                                                          Substitute.For <ILogger <PropertyNamingConventionsBucket> >());

            // Assert
            Assert.IsType <PropertyNamingConventionsBucket>(sut);
        }
Esempio n. 2
0
        private PropertyNamingConventionsBucket GetDefaultPropertyNamingConventions()
        {
            var conventions = new PropertyNamingConventionsBucket(new List <IPropertyNameConvention>
            {
                new NameWithNoNumberAtStartConvention(),
                new ReplaceAmperstandWithNConvention(),
                new RemoveNonLetterAndDigitCharactersConvention()
            }, _loggerFactory.CreateLogger <PropertyNamingConventionsBucket>());

            return(conventions);
        }
        public void ShouldReturnUnchangedValueIfNoPropertyNamingConvetionsFound()
        {
            // Arrange
            var sut = new PropertyNamingConventionsBucket(new List <IPropertyNameConvention>(),
                                                          Substitute.For <ILogger <PropertyNamingConventionsBucket> >());

            // Act
            var result = sut.ApplyConvention("OriginalPropertyName");

            // Assert
            Assert.Equal("OriginalPropertyName", result);
        }
        public void ShouldCorrectlyRenameProperty(string sourceValue, string expectedValue)
        {
            // Arrange
            var sut = new PropertyNamingConventionsBucket(new List <IPropertyNameConvention>
            {
                new NameWithNoNumberAtStartConvention(),
                new ReplaceAmperstandWithNConvention(),
                new RemoveNonLetterAndDigitCharactersConvention()
            }, Substitute.For <ILogger <PropertyNamingConventionsBucket> >());

            // Act
            var result = sut.ApplyConvention(sourceValue);

            // Assert
            Assert.Equal(expectedValue, result);
        }
        public void ShouldApplyAllConvetionsOnce()
        {
            // Arrange
            var firstConvention  = Substitute.For <IPropertyNameConvention>();
            var secondConvention = Substitute.For <IPropertyNameConvention>();
            var sut = new PropertyNamingConventionsBucket(new List <IPropertyNameConvention>
            {
                firstConvention,
                secondConvention
            }, Substitute.For <ILogger <PropertyNamingConventionsBucket> >());

            // Act
            sut.ApplyConvention("PropertyName");

            // Assert
            firstConvention.Received(1).ApplyConvention(Arg.Any <string>());
            secondConvention.Received(1).ApplyConvention(Arg.Any <string>());
        }
        public void ShouldReturnResultFromLastConvention()
        {
            // Arrange
            var firstConvention  = Substitute.For <IPropertyNameConvention>();
            var secondConvention = Substitute.For <IPropertyNameConvention>();
            var sut = new PropertyNamingConventionsBucket(new List <IPropertyNameConvention>
            {
                firstConvention,
                secondConvention
            }, Substitute.For <ILogger <PropertyNamingConventionsBucket> >());

            secondConvention.ApplyConvention(Arg.Any <string>()).Returns("ModifiedPropertyName");

            // Act
            var result = sut.ApplyConvention("PropertyName");

            // Assert
            Assert.Equal("ModifiedPropertyName", result);
        }