[Fork] Mapping test creator | C# Online Compiler

[Fork] Mapping test creator by Matramos

using System;
using System.Globalization;		
using System.Collections.Generic;
public class Program
{
	public static void Main()
	{
		var fromClassName = "AddOfferCommand";
		var toClassName = "OfferContent";
		
		var fromClassVariable = fromClassName.Substring(0, 1).ToLower() + fromClassName.Substring(1);
		var toClassVariable = toClassName.Substring(0, 1).ToLower() + toClassName.Substring(1);
		
		var header = $@"
			[TestFixture]
			public class {toClassName}MappingFixture
			{{
				private {fromClassName} _{fromClassVariable};
				private IMapper _mapper;

				[SetUp]
				public void SetUp()
				{{
					_{fromClassVariable} = new AutoFaker<{fromClassName}>()
						.Generate();

					var config = new MapperConfiguration(opts =>
					{{
						opts.AddProfile<AutoMapperProfile>();
					}});
					_mapper = config.CreateMapper();
				}}";
			Console.WriteLine(header);
		
		foreach (var p in typeof(FromClass).GetProperties())
		{
			var propertyName = p.Name;
			var compareText = p.PropertyType.IsValueType ? "Be" : "BeEquivalentTo";
			
			var test = $@"
			[Test]
			public void {propertyName}_should_get_mapped()
			{{
				// Arrange
				// Act
				var actual = _mapper.Map<{toClassName}>(_{fromClassVariable});

				// Assert
				actual.{propertyName}.Should().{compareText}(_{fromClassVariable}.{propertyName},                 
					$""{{nameof({toClassName}.{propertyName})}} should be mapped from {{nameof({fromClassName})}} to {{nameof({toClassName})}}"");
			}}";

			Console.WriteLine(test);
		}	
		
		Console.WriteLine("}");
	}
	
    public class FromClass 
    {
public int BaseDiscount { get; set; }

        public int Brand { get; set; }

        public int OfferType { get; set; }

        public DateTime BookingStart { get; set; }

        public DateTime BookingEnd { get; set; }

        public DateTime ArrivalStart { get; set; }

        public DateTime ArrivalEnd { get; set; }

        public string OfferExtraCode { get; set; }

        public string InvoiceDescription { get; set; }

        public int MinimumNights { get; set; }

        public int MaximumNights { get; set; }

        public bool CombineAndSaveOffered { get; set; }

        public IList<string> LocalizedOfferContents { get; set; }

        public IList<string> OfferDetails { get; set; }

        public IList<string> ExcludedDateRanges { get; set; }

        public IList<int> LocaleIds { get; set; }

	}
}

​x
 
using System;
using System.Globalization;     
using System.Collections.Generic;
public class Program
{
    public static void Main()
    {
        var fromClassName = "AddOfferCommand";
        var toClassName = "OfferContent";
        
        var fromClassVariable = fromClassName.Substring(0, 1).ToLower() + fromClassName.Substring(1);
        var toClassVariable = toClassName.Substring(0, 1).ToLower() + toClassName.Substring(1);
        
        var header = $@"
            [TestFixture]
            public class {toClassName}MappingFixture
            {{
                private {fromClassName} _{fromClassVariable};
                private IMapper _mapper;
​
                [SetUp]
                public void SetUp()
                {{
                    _{fromClassVariable} = new AutoFaker<{fromClassName}>()
                        .Generate();
​
                    var config = new MapperConfiguration(opts =>
                    {{
                        opts.AddProfile<AutoMapperProfile>();
                    }});
                    _mapper = config.CreateMapper();
                }}";
            Console.WriteLine(header);
        
        foreach (var p in typeof(FromClass).GetProperties())
        {
            var propertyName = p.Name;
            var compareText = p.PropertyType.IsValueType ? "Be" : "BeEquivalentTo";
            
            var test = $@"
            [Test]
            public void {propertyName}_should_get_mapped()
            {{
                // Arrange
                // Act
                var actual = _mapper.Map<{toClassName}>(_{fromClassVariable});
​
                // Assert
                actual.{propertyName}.Should().{compareText}(_{fromClassVariable}.{propertyName},                 
                    $""{{nameof({toClassName}.{propertyName})}} should be mapped from {{nameof({fromClassName})}} to {{nameof({toClassName})}}"");
            }}";
​
            Console.WriteLine(test);
        }   
        
        Console.WriteLine("}");
    }
    
    public class FromClass 
    {
public int BaseDiscount { get; set; }
​
        public int Brand { get; set; }
​
        public int OfferType { get; set; }
​
        public DateTime BookingStart { get; set; }
​
        public DateTime BookingEnd { get; set; }
​
        public DateTime ArrivalStart { get; set; }
​
        public DateTime ArrivalEnd { get; set; }
​
        public string OfferExtraCode { get; set; }
​
        public string InvoiceDescription { get; set; }
​
        public int MinimumNights { get; set; }
​
        public int MaximumNights { get; set; }
​
        public bool CombineAndSaveOffered { get; set; }
​
        public IList<string> LocalizedOfferContents { get; set; }
​
        public IList<string> OfferDetails { get; set; }
​
        public IList<string> ExcludedDateRanges { get; set; }
​
        public IList<int> LocaleIds { get; set; }
​
    }
}

            [TestFixture]
            public class OfferContentMappingFixture
            {
                private AddOfferCommand _addOfferCommand;
                private IMapper _mapper;

                [SetUp]
                public void SetUp()
                {
                    _addOfferCommand = new AutoFaker<AddOfferCommand>()
                        .Generate();

                    var config = new MapperConfiguration(opts =>
                    {
                        opts.AddProfile<AutoMapperProfile>();
                    });
                    _mapper = config.CreateMapper();
                }

            [Test]
            public void BaseDiscount_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.BaseDiscount.Should().Be(_addOfferCommand.BaseDiscount,
                    $"{nameof(OfferContent.BaseDiscount)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void Brand_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.Brand.Should().Be(_addOfferCommand.Brand,
                    $"{nameof(OfferContent.Brand)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void OfferType_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.OfferType.Should().Be(_addOfferCommand.OfferType,
                    $"{nameof(OfferContent.OfferType)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void BookingStart_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.BookingStart.Should().Be(_addOfferCommand.BookingStart,
                    $"{nameof(OfferContent.BookingStart)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void BookingEnd_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.BookingEnd.Should().Be(_addOfferCommand.BookingEnd,
                    $"{nameof(OfferContent.BookingEnd)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void ArrivalStart_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.ArrivalStart.Should().Be(_addOfferCommand.ArrivalStart,
                    $"{nameof(OfferContent.ArrivalStart)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void ArrivalEnd_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.ArrivalEnd.Should().Be(_addOfferCommand.ArrivalEnd,
                    $"{nameof(OfferContent.ArrivalEnd)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void OfferExtraCode_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.OfferExtraCode.Should().BeEquivalentTo(_addOfferCommand.OfferExtraCode,
                    $"{nameof(OfferContent.OfferExtraCode)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void InvoiceDescription_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.InvoiceDescription.Should().BeEquivalentTo(_addOfferCommand.InvoiceDescription,
                    $"{nameof(OfferContent.InvoiceDescription)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void MinimumNights_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.MinimumNights.Should().Be(_addOfferCommand.MinimumNights,
                    $"{nameof(OfferContent.MinimumNights)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void MaximumNights_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.MaximumNights.Should().Be(_addOfferCommand.MaximumNights,
                    $"{nameof(OfferContent.MaximumNights)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void CombineAndSaveOffered_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.CombineAndSaveOffered.Should().Be(_addOfferCommand.CombineAndSaveOffered,
                    $"{nameof(OfferContent.CombineAndSaveOffered)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void LocalizedOfferContents_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.LocalizedOfferContents.Should().BeEquivalentTo(_addOfferCommand.LocalizedOfferContents,
                    $"{nameof(OfferContent.LocalizedOfferContents)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void OfferDetails_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.OfferDetails.Should().BeEquivalentTo(_addOfferCommand.OfferDetails,
                    $"{nameof(OfferContent.OfferDetails)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void ExcludedDateRanges_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.ExcludedDateRanges.Should().BeEquivalentTo(_addOfferCommand.ExcludedDateRanges,
                    $"{nameof(OfferContent.ExcludedDateRanges)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }

            [Test]
            public void LocaleIds_should_get_mapped()
            {
                // Arrange
                // Act
                var actual = _mapper.Map<OfferContent>(_addOfferCommand);

                // Assert
                actual.LocaleIds.Should().BeEquivalentTo(_addOfferCommand.LocaleIds,
                    $"{nameof(OfferContent.LocaleIds)} should be mapped from {nameof(AddOfferCommand)} to {nameof(OfferContent)}");
            }
}

Cached Result
Last Run:	3:53:24 pm
Compile:	0.015s
Execute:	0.08s
Memory:	4.69Mb
CPU:	0.095s

View IL Code