Муканов Арман

ObjectPrinting.Tests/BasePerson.cs

@@ -0,0 +1,22 @@
+namespace ObjectPrinting.Tests;
+
+public class BasePerson
+{
+    public Guid Id { get; set; }
+    public string Name { get; set; }
+    public double Height { get; set; }
+    public int Age { get; set; }
+    public int[] Array { get; set; }
+
+    public static BasePerson Get()
+    {
+        return new BasePerson
+        {
+            Id = new Guid(),
+            Age = 20,
+            Height = 183.4,
+            Name = "Peter",
+            Array = new []{2, 3, 4},
+        };
+    }
+}

ObjectPrinting.Tests/ExtendedPerson.cs

@@ -0,0 +1,55 @@
+namespace ObjectPrinting.Tests;
+
+public class ExtendedPerson
+{
+    public Guid Id { get; set; }
+    public int Age { get; set; }
+    public string FirstName { get; set; }
+    public string LastName { get; set; }
+    public List<ExtendedPerson> Children { get; set; }
+    public char[] Array { get; set; }
+    public Dictionary<int, ExtendedPerson> Dict { get; set; }
+
+    public static ExtendedPerson Get()
+    {
+        var person1 = new ExtendedPerson()
+        {
+            Id = new Guid(),
+            Age = 18,
+            FirstName = "Peter",
+            LastName = "Gromov",
+            Children = new List<ExtendedPerson>(),
+            Array = null,
+            Dict = null,
+        };
+
+        var person2 = new ExtendedPerson()
+        {
+            Id = new Guid(),
+            Age = 20,
+            FirstName = "Peter",
+            LastName = "Gromov",
+            Children = new List<ExtendedPerson>(),
+            Array = null,
+            Dict = null,
+        };
+        person1.Children.Add(person2);
+        person2.Children.Add(person1);
+
+
+        return new ExtendedPerson
+        {
+            Id = new Guid(),
+            Age = 22,
+            FirstName = "Peter",
+            LastName = "Gromov",
+            Children = new List<ExtendedPerson>(new[] { person1, person2 }),
+            Array = "fds6".ToCharArray(),
+            Dict = new Dictionary<int, ExtendedPerson>()
+            {
+                [3] = person1,
+                [2] = null,
+            }
+        };
+    }
+}

ObjectPrinting.Tests/ObjectPrinting.Tests.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="FluentAssertions" Version="7.0.0-alpha.3" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0"/>
+        <PackageReference Include="NUnit" Version="3.13.3"/>
+        <PackageReference Include="NUnit3TestAdapter" Version="4.4.2"/>
+        <PackageReference Include="NUnit.Analyzers" Version="3.6.1"/>
+        <PackageReference Include="coverlet.collector" Version="3.2.0"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\ObjectPrinting\ObjectPrinting.csproj" />
+    </ItemGroup>
+
+</Project>

ObjectPrinting.Tests/PrintingConfigTests.cs

@@ -0,0 +1,170 @@
+using System.Globalization;
+using FluentAssertions;
+using ObjectPrinting.Configs;
+using ObjectPrinting.Extensions;
+
+namespace ObjectPrinting.Tests;
+
+[TestFixture]
+[TestOf(typeof(ObjectPrinter))]
+public class PrintingConfigTests
+{
+    private readonly BasePerson basePerson = BasePerson.Get();
+    private PrintingConfig<BasePerson> printingConfig = ObjectPrinter.For<BasePerson>();
+
+    [SetUp]
+    public void SetUp()
+    {
+        printingConfig = ObjectPrinter.For<BasePerson>();
+    }
+
+    [Test]
+    public void Should_NotThrow_WhenInputNull()
+    {
+        var config = ObjectPrinter.For<BasePerson>();
+        Action action = () => config.PrintToString(null);
+
+        action.Should().NotThrow();
+    }
+
+    [Test]
+    public void API_Example()
+    {
+        printingConfig
+            //1. Исключить из сериализации свойства определенного типа
+            .Excluding<Guid>()
+            //2. Указать альтернативный способ сериализации для определенного типа
+            .Printing<int>().Using(i => i.ToString("X"))
+            //3. Для числовых типов указать культуру
+            .Printing<double>().Using(CultureInfo.InvariantCulture)
+            //4. Настроить сериализацию конкретного свойства
+            //5. Настроить обрезание строковых свойств (метод должен быть виден только для строковых свойств)
+            .Printing(p => p.Name).TrimmedToLength(10)
+            //6. Исключить из сериализации конкретного свойства
+            .Excluding(p => p.Age);
+
+        //7. Синтаксический сахар в виде метода расширения, сериализующего по-умолчанию
+        basePerson.PrintToString();
+        //8. ...с конфигурированием
+        basePerson.PrintToString(s => s.Excluding(p => p.Age));
+    }
+
+    [Test]
+    public void Should_UseCultureInfo()
+    {
+        var culture = CultureInfo.GetCultureInfo("ru-RU");
+        printingConfig
+            .Printing<double>()
+            .Using(culture);
+
+        var actual = printingConfig.PrintToString(basePerson);
+
+        actual.Should().Contain(basePerson.Height.ToString(culture));
+    }
+
+    [Test]
+    public void Should_TrimString()
+    {
+        printingConfig
+            .Printing<string>()
+            .TrimmedToLength(2);
+        var actual = printingConfig.PrintToString(basePerson);
+
+        actual.Should().Contain("Name = Pe\r\n");
+    }
+
+    [Test]
+    public void Should_IgnoreExcludedProperty()
+    {
+        printingConfig.Excluding(p => p.Array);
+        var actual = printingConfig.PrintToString(basePerson);
+
+        actual.Should().NotContain(nameof(basePerson.Array));
+    }
+
+
+    [Test]
+    [TestOf(nameof(PrintingConfig<BasePerson>.Excluding))]
+    public void Should_IgnoreExcludedType()
+    {
+        printingConfig.Excluding<Guid>();
+        var actual = printingConfig.PrintToString(basePerson);
+
+        actual.Should().NotContain(nameof(basePerson.Id));
+    }
+
+    [Test]
+    [TestOf(nameof(PrintingConfig<BasePerson>.Excluding))]
+    public void Should_NotThrow_WhenContainsCyclicLinks()
+    {
+        var mock = ExtendedPerson.Get();
+        var config = ObjectPrinter.For<ExtendedPerson>();
+        Action action = () => config.PrintToString(mock);
+
+        action.Should().NotThrow();
+    }
+
+    [Test]
+    [TestOf(nameof(PrintingConfig<BasePerson>.Excluding))]
+    public void Should_SupportCustomPropertySerializer()
+    {
+        printingConfig
+            .Printing(p => p.Age)
+            .Using(v => "123123");
+
+        var actual = printingConfig.PrintToString(basePerson);
+
+        actual.Should().Contain("Age = 123123");
+    }
+
+    [Test]
+    [TestOf(nameof(PrintingConfig<BasePerson>.Excluding))]
+    public void Should_SupportCustomTypeSerializer()
+    {
+        printingConfig
+            .Printing<int>()
+            .Using(v => "123123");
+
+        var actual = printingConfig.PrintToString(basePerson);
+
+        actual.Should().Contain("Age = 123123");
+    }
+
+    [Test]
+    public void Should_SupportArray()
+    {
+        var array = new object[] { 1, 2, 3 };
+
+        var actual = array.PrintToString();
+
+        var expected = "\r\n[\r\n\t1\r\n\t2\r\n\t3\r\n]";
+        actual.Should().Contain(expected);
+    }
+
+    [Test]
+    public void Should_SupportList()
+    {
+        var list = new List<int> { 1, 2, 3 };
+
+        var actual = list.PrintToString();
+
+        var expected = "\r\n[\r\n\t1\r\n\t2\r\n\t3\r\n]";
+        actual.Should().Contain(expected);
+    }
+
+    [Test]
+    public void Should_SupportDictionary()
+    {
+        var dict = new Dictionary<int, string>
+        {
+            [1] = "123",
+            [3] = "345",
+        };
+
+        var actual = dict.PrintToString();
+
+        var expected = "{\r\n\t1: 123\r\n\t3: 345\r\n}";
+
+        actual.Should().Contain(expected);
+    }
+}

ObjectPrinting.Tests/Usings.cs

@@ -0,0 +1 @@
+global using NUnit.Framework;

ObjectPrinting/Configs/IPropertyPrintingConfig.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace ObjectPrinting.Configs
+{
+    public interface IPropertyPrintingConfig<TOwner>
+    {
+        public PrintingConfig<TOwner> PrintingConfig { get; }
+
+        public Func<object, string> Serializer { get; }
+    }
+}

ObjectPrinting/Configs/ITypePrintingConfig.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Globalization;
+
+namespace ObjectPrinting.Configs
+{
+    public interface ITypePrintingConfig<TOwner>
+    {
+        public PrintingConfig<TOwner> PrintingConfig { get; }
+
+        public CultureInfo CultureInfo { get;}
+
+        public Func<object, string> Serializer { get; }
+    }
+}

ObjectPrinting/Configs/PropertyPrintingConfig.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Reflection;
+
+namespace ObjectPrinting.Configs
+{
+    public class PropertyPrintingConfig<TOwner, TPropType> : IPropertyPrintingConfig<TOwner>
+    {
+        private PropertyInfo property;
+        // private Func<object, string> serializer;
+
+        public PrintingConfig<TOwner> PrintingConfig { get; }
+        public Func<object, string> Serializer { get; private set; }
+        // public Func<object, string> IPropertyPrintingConfig<TOwner>.Serializer { get; }
+
+        public PropertyPrintingConfig(PrintingConfig<TOwner> printingConfig, PropertyInfo property)
+        {
+            PrintingConfig = printingConfig;
+            this.property = property;
+        }
+
+        public PrintingConfig<TOwner> Using(Func<TPropType, string> serializer)
+        {
+            Serializer = obj =>
+            {
+                if (obj is TPropType value)
+                    return serializer(value);
+
+                throw new ArgumentException();
+            };
+
+            return PrintingConfig;
+        }
+    }
+}

ObjectPrinting/Configs/TypePrintingConfig.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Globalization;
+
+namespace ObjectPrinting.Configs
+{
+    public class TypePrintingConfig<TOwner, TType> : ITypePrintingConfig<TOwner>
+    {
+        public PrintingConfig<TOwner> PrintingConfig { get; }
+        public CultureInfo CultureInfo { get; private set; }
+        public Func<object, string> Serializer { get; private set; }
+
+        public TypePrintingConfig(PrintingConfig<TOwner> printingConfig)
+        {
+            PrintingConfig = printingConfig;
+        }
+
+        public PrintingConfig<TOwner> Using(CultureInfo cultureInfo)
+        {
+            CultureInfo = cultureInfo;
+
+            return PrintingConfig;
+        }
+
+        public PrintingConfig<TOwner> Using(Func<TType, string> serializer)
+        {
+            Serializer = obj =>
+            {
+                if (obj is TType value)
+                    return serializer(value);
+
+                throw new ArgumentException();
+            };
+
+            return PrintingConfig;
+        }
+    }
+}