Галичев Артем

Testing/Basic/Homework/1. ObjectComparison/ObjectComparison.cs

@@ -1,4 +1,5 @@
-using NUnit.Framework;
+using FluentAssertions;
+using NUnit.Framework;
 using NUnit.Framework.Legacy;
 
 namespace HomeExercise.Tasks.ObjectComparison;
@@ -13,17 +14,8 @@ public void CheckCurrentTsar()
 
         var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
             new Person("Vasili III of Russia", 28, 170, 60, null));
-
-        // Перепишите код на использование Fluent Assertions.
-        ClassicAssert.AreEqual(actualTsar.Name, expectedTsar.Name);
-        ClassicAssert.AreEqual(actualTsar.Age, expectedTsar.Age);
-        ClassicAssert.AreEqual(actualTsar.Height, expectedTsar.Height);
-        ClassicAssert.AreEqual(actualTsar.Weight, expectedTsar.Weight);
-
-        ClassicAssert.AreEqual(expectedTsar.Parent!.Name, actualTsar.Parent!.Name);
-        ClassicAssert.AreEqual(expectedTsar.Parent.Age, actualTsar.Parent.Age);
-        ClassicAssert.AreEqual(expectedTsar.Parent.Height, actualTsar.Parent.Height);
-        ClassicAssert.AreEqual(expectedTsar.Parent.Parent, actualTsar.Parent.Parent);
+
+        actualTsar.IsEqual(expectedTsar);
     }
 
     [Test]
@@ -35,6 +27,14 @@ public void CheckCurrentTsar_WithCustomEquality()
             new Person("Vasili III of Russia", 28, 170, 60, null));
 
         // Какие недостатки у такого подхода? 
+        /*
+         * 1) Если у класса изменять поля (удалять или добавлять), то также придется изменять
+         * логику проверки на соответствие сущностей. В случае с удалением поля программа вообще не скомпилируется
+         * 2) Возможна бесконечная рекурсия
+         * 3) При падении теста не поймем в чем была причина. Ожидался True, а получили False, вот и вся инфа(
+         * 4) Использование FluentAssertion ускоряет понимание логики секции проверки, за счет использования
+         * method chaining. В данном тесте вникнуть в логику проверки теста сложнее, чем в первом.
+         */
         ClassicAssert.True(AreEqual(actualTsar, expectedTsar));
     }
 
@@ -50,3 +50,16 @@ private bool AreEqual(Person? actual, Person? expected)
             && AreEqual(actual.Parent, expected.Parent);
     }
 }
+
+internal static class ObjectComparisonAssertExtensions
+{
+    public static void IsEqual(this Person actualTsar, Person expectedTsar)
+    {
+        actualTsar.Should().BeEquivalentTo(
+            expectedTsar,
+            options => options
+                .Excluding(x => x.Name == nameof(Person.Id) && x.DeclaringType == typeof(Person))
+                .AllowingInfiniteRecursion()
+                .IgnoringCyclicReferences());
+    }
+}

Testing/Basic/Homework/2. NumberValidator/NumberValidatorTests.cs

@@ -1,4 +1,5 @@
 
+using FluentAssertions;
 using NUnit.Framework;
 using NUnit.Framework.Legacy;
 
@@ -8,24 +9,148 @@ namespace HomeExercise.Tasks.NumberValidator;
 public class NumberValidatorTests
 {
     [Test]
-    public void Test()
-    {
-        Assert.Throws<ArgumentException>(() => new NumberValidator(-1, 2, true));
-        Assert.DoesNotThrow(() => new NumberValidator(1, 0, true));
-        Assert.Throws<ArgumentException>(() => new NumberValidator(-1, 2, false));
-        Assert.DoesNotThrow(() => new NumberValidator(1, 0, true));
-
-        ClassicAssert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-        ClassicAssert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0"));
-        ClassicAssert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("00.00"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("-0.00"));
-        ClassicAssert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("+0.00"));
-        ClassicAssert.IsTrue(new NumberValidator(4, 2, true).IsValidNumber("+1.23"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("+1.23"));
-        ClassicAssert.IsFalse(new NumberValidator(17, 2, true).IsValidNumber("0.000"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("-1.23"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("a.sd"));
+    public void Should_Throw_ArgumentException_If_Precision_Is_Negative()
+    {
+        var builder = new TestNumberValidatorBuilder().WithPrecision(-1);
+
+        Assert.Throws<ArgumentException>(() => builder.Build());
+    }
+
+    [Test]
+    public void Should_Throw_ArgumentException_If_Scale_Is_Negative()
+    {
+        var builder = new TestNumberValidatorBuilder().WithScale(-1);
+
+        Assert.Throws<ArgumentException>(() => builder.Build());
+    }
+
+    [Test]
+    public void Should_Throw_ArgumentException_If_Scale_Greater_Precision()
+    {
+        var builder = new TestNumberValidatorBuilder().WithScale(5).WithPrecision(2);
+
+        Assert.Throws<ArgumentException>(() => builder.Build());
+    }
+
+    [Test]
+    public void Should_Throw_ArgumentException_If_Scale_Equal_Precision()
+    {
+        var builder = new TestNumberValidatorBuilder().WithScale(2).WithPrecision(2);
+
+        Assert.Throws<ArgumentException>(() => builder.Build());
+    }
+
+    [Test]
+    public void Should_DoesNotThrow_Exception_If_Scale_And_Precision_Is_Correct()
+    {
+        var builder = new TestNumberValidatorBuilder();
+
+        Assert.DoesNotThrow(() => builder.Build());
+    }
+
+    [Test]
+    public void IsValidNumber_Should_Return_False_If_Value_Is_Null()
+    {
+        var numberValidator = new TestNumberValidatorBuilder().Build();
+
+        var actual = numberValidator.IsValidNumber(null);
+
+        actual.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase("")]
+    [TestCase(" ")]
+    [TestCase("    ")]
+    public void IsValidNumber_Should_Return_False_If_Value_Is_Empty(string value)
+    {
+        var numberValidator = new TestNumberValidatorBuilder().Build();
+
+        var actual = numberValidator.IsValidNumber(value);
+
+        actual.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase("a.sd")]
+    [TestCase("0.")]
+    [TestCase(",0")]
+    [TestCase("0*0")]
+    [TestCase("!0,0")]
+    public void IsValidNumber_Should_Return_False_If_Match_With_Value_Fail(string value)
+    {
+        var numberValidator = new TestNumberValidatorBuilder().Build();
+
+        var actual = numberValidator.IsValidNumber(value);
+
+        actual.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase("1,234")]
+    [TestCase("1111")]
+    [TestCase("22,32")]
+    [TestCase("+1,23")]
+    [TestCase("+0,00")]
+    [TestCase("-0,00")]
+    public void IsValidNumber_Should_Return_False_If_Sum_Of_IntPart_And_FracPart_More_Than_Precision(string value)
+    {
+        var numberValidator = new TestNumberValidatorBuilder().WithPrecision(3).WithScale(2).Build();
+
+        var actual = numberValidator.IsValidNumber(value);
+
+        actual.Should().BeFalse();
+    }
+
+    [Test]
+    public void IsValidNumber_Should_Return_False_If_FracPart_More_Than_Scale()
+    {
+        var numberValidator = new TestNumberValidatorBuilder().WithScale(2).Build();
+        var value = "0,000";
+
+        var actual = numberValidator.IsValidNumber(value);
+
+        actual.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase("-0,0")]
+    [TestCase("-0,000")]
+    [TestCase("-0")]
+    public void IsValidNumber_Should_Return_False_If_OnlyPositive_True_And_Value_Contains_Minus(string value)
+    {
+        var numberValidator = new TestNumberValidatorBuilder().Build();
+
+        var actual = numberValidator.IsValidNumber(value);
+
+        actual.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase("-0,0")]
+    [TestCase("-0,000")]
+    [TestCase("-0")]
+    public void IsValidNumber_Should_Return_True_If_OnlyPositive_False_And_Value_Contains_Minus(string value)
+    {
+        var numberValidator = new TestNumberValidatorBuilder().WithOnlyPositive(false).Build();
+
+        var actual = numberValidator.IsValidNumber(value);
+
+        actual.Should().BeTrue();
+    }
+
+    [Test]
+    [TestCase("0.0")]
+    [TestCase("0")]
+    [TestCase("+1.23")]
+    [TestCase("1.444")]
+    [TestCase("+1.444")]
+    public void IsValidNumber_Should_Return_True_If_Value_Correct(string value)
+    {
+        var numberValidator = new TestNumberValidatorBuilder().Build();
+
+        var actual = numberValidator.IsValidNumber(value);
+
+        actual.Should().BeTrue();
     }
 }

Testing/Basic/Homework/2. NumberValidator/TestNumberValidatorBuilder.cs

@@ -0,0 +1,34 @@
+namespace HomeExercise.Tasks.NumberValidator;
+
+public class TestNumberValidatorBuilder
+{
+    public const int DEFAULT_PRECISION = 5;
+    public const int DEFAULT_SCALE = 3;
+    public const bool DEFAULT_ONLY_POSITIVE = true;
+    private int precision = DEFAULT_PRECISION;
+    private int scale = DEFAULT_SCALE;
+    private bool onlyPositive = DEFAULT_ONLY_POSITIVE;
+
+    public TestNumberValidatorBuilder WithPrecision(int precision)
+    {
+        this.precision = precision;
+        return this;
+    }
+
+    public TestNumberValidatorBuilder WithScale(int scale)
+    {
+        this.scale = scale;
+        return this;
+    }
+
+    public TestNumberValidatorBuilder WithOnlyPositive(bool onlyPositive)
+    {
+        this.onlyPositive = onlyPositive;
+        return this;
+    }
+
+    public NumberValidator Build()
+    {
+        return new NumberValidator(precision, scale, onlyPositive);
+    }
+}