diff --git a/Testing/Basic/Homework/1. ObjectComparison/ObjectComparison.cs b/Testing/Basic/Homework/1. ObjectComparison/ObjectComparison.cs index d544c47..56747d6 100644 --- a/Testing/Basic/Homework/1. ObjectComparison/ObjectComparison.cs +++ b/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,10 @@ 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.Should().BeEquivalentTo(expectedTsar, options => options + .Excluding(t => t.DeclaringType == typeof(Person) && t.Name == nameof(Person.Id))); + //избегаем падения теста при добавлении предков, не сравнивая Id любого объекта класса Person } [Test] @@ -35,7 +29,9 @@ public void CheckCurrentTsar_WithCustomEquality() new Person("Vasili III of Russia", 28, 170, 60, null)); // Какие недостатки у такого подхода? - ClassicAssert.True(AreEqual(actualTsar, expectedTsar)); + ClassicAssert.True(AreEqual(actualTsar, expectedTsar));//нет информации о провале в тесте, неизвестно, где ошибка + //Если добавить новое поле в Person придётся менять AreEqual, а не только данные для проверки. + //В моём варианте нужно добавить только поля не требующие проверки (что происходит реже) } private bool AreEqual(Person? actual, Person? expected) diff --git a/Testing/Basic/Homework/2. NumberValidator/NumberValidator.cs b/Testing/Basic/Homework/2. NumberValidator/NumberValidator.cs index 327ce9c..920a183 100644 --- a/Testing/Basic/Homework/2. NumberValidator/NumberValidator.cs +++ b/Testing/Basic/Homework/2. NumberValidator/NumberValidator.cs @@ -16,8 +16,8 @@ public NumberValidator(int precision, int scale = 0, bool onlyPositive = false) this.onlyPositive = onlyPositive; if (precision <= 0) throw new ArgumentException("precision must be a positive number"); - if (scale < 0 || scale >= precision) - throw new ArgumentException("precision must be a non-negative number less or equal than precision"); + if (scale < 0 || scale >= precision) + throw new ArgumentException("scale must be a non-negative number less than precision"); numberRegex = new Regex(@"^([+-]?)(\d+)([.,](\d+))?$", RegexOptions.IgnoreCase); } diff --git a/Testing/Basic/Homework/2. NumberValidator/NumberValidatorTests.cs b/Testing/Basic/Homework/2. NumberValidator/NumberValidatorTests.cs index 950c9bc..735b9b5 100644 --- a/Testing/Basic/Homework/2. NumberValidator/NumberValidatorTests.cs +++ b/Testing/Basic/Homework/2. NumberValidator/NumberValidatorTests.cs @@ -1,31 +1,200 @@ - +using FluentAssertions; using NUnit.Framework; -using NUnit.Framework.Legacy; namespace HomeExercise.Tasks.NumberValidator; [TestFixture] public class NumberValidatorTests { + private const string PrecisionExceptionMessage = "precision must be a positive number"; + private const string ScaleExceptionMessage = "scale must be a non-negative number less than precision"; + [Test] - public void Test() - { - Assert.Throws(() => new NumberValidator(-1, 2, true)); - Assert.DoesNotThrow(() => new NumberValidator(1, 0, true)); - Assert.Throws(() => 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")); + [TestCase(-1)] + [TestCase(0)] + public void Should_ThrowException_WhenNotPositivePrecision(int precision) + { + + var action = () => new NumberValidator(precision, 2, true); + + action.Should().Throw() + .WithMessage(PrecisionExceptionMessage); + } + + [Test] + [TestCase(1, 2)] + [TestCase(1, 1)] + public void Should_ThrowException_WhenPositivePrecisionLessOrEqualScale(int precision, int scale) + { + + var action = () => new NumberValidator(precision, scale, true); + + action.Should().Throw() + .WithMessage(ScaleExceptionMessage); + } + + [Test] + public void Should_ThrowException_WhenNegativeScale() + { + var action = () => new NumberValidator(1, -1, true); + + action.Should().Throw() + .WithMessage(ScaleExceptionMessage); + } + + [Test] + [TestCase(1, 0, true)] + [TestCase(5, 2, false)] + [TestCase(4, 3, true)] + public void ShouldNot_ThrowException_WhenValidParameters(int precision, int scale, bool onlyPositive) + { + var action = () => new NumberValidator(precision, scale, onlyPositive); + + action.Should().NotThrow(); + } + + [Test] + [TestCase(4, 2, true, "12.34")] + [TestCase(4, 3, true, "+2.34")] + [TestCase(4, 3, true, "1.345")] + public void Should_BeTrue_WhenValidNumber(int precision, int scale, bool onlyPositive, string testNumber) + { + var testNum = new NumberValidator(4, 2, true); + + var res = testNum.IsValidNumber("12.34"); + + res.Should().BeTrue(); + } + + [Test] + public void Should_BeFalse_WhenNegativeNumberWithOnlyPositiveTrue() + { + var testNum = new NumberValidator(4, 2, true); + + var res = testNum.IsValidNumber("-2.34"); + + res.Should().BeFalse(); + } + + [Test] + public void Should_BeTrue_WhenNegativeNumberWithOnlyPositiveFalse() + { + var testNum = new NumberValidator(4, 2, false); + + var res = testNum.IsValidNumber("-2.34"); + + res.Should().BeTrue(); + } + + [Test] + [TestCase(4, 2, true, "512.34")] + [TestCase(4, 3, true, "12.345")] + public void Should_BeFalse_WhenNumberLongerThanPrecision(int precision, int scale, bool onlyPositive, string testNumber) + { + var testNum = new NumberValidator(precision, scale, onlyPositive); + + var res = testNum.IsValidNumber(testNumber); + + res.Should().BeFalse(); + } + + [Test] + public void Should_BeFalse_WhenNumberWithFracLongerThanScaleButValidPrecision() + { + var testNum = new NumberValidator(5, 2, true); + + var res = testNum.IsValidNumber("12.345"); + + res.Should().BeFalse(); + } + + [Test] + public void Should_BeFalse_WhenString() + { + var testNum = new NumberValidator(4, 2, true); + + var res = testNum.IsValidNumber("ab.cd"); + + res.Should().BeFalse(); + } + + [Test] + public void Should_BeTrue_WhenInt() + { + var testNum = new NumberValidator(4, 2, true); + + var res = testNum.IsValidNumber("52"); + + res.Should().BeTrue(); + } + + [Test] + [TestCase("")] + [TestCase(null)] + public void Should_BeFalse_WhenNullOrEmpty(string testNumber) + { + var testNum = new NumberValidator(4, 2, true); + + var res = testNum.IsValidNumber(testNumber); + + res.Should().BeFalse(); + } + + [Test] + [TestCase("12.43")] + [TestCase("12,43")] + public void Should_BeTrue_WhenDifferentSeparator(string testNumber) + { + var testNum = new NumberValidator(4, 2, true); + + var res = testNum.IsValidNumber(testNumber); + + res.Should().BeTrue(); + } + + [Test] + public void Should_BeFalse_WhenNumberWithinInt() + { + var testNum1 = new NumberValidator(4, 2, true).IsValidNumber(".5"); + var testNum2 = new NumberValidator(4, 2, true).IsValidNumber(",5"); + + testNum1.Should().BeFalse(); + testNum2.Should().BeFalse(); + } + + [Test] + [TestCase("1.")] + [TestCase("1,")] + public void Should_BeFalse_WhenNumberWithSeparatorButWithinFrac(string testNumber) + { + var testNum = new NumberValidator(4, 2, true); + + var res = testNum.IsValidNumber(testNumber); + + res.Should().BeFalse(); + } + + [Test] + [TestCase("1.2.3")] + [TestCase("1,,3")] + public void Should_BeFalse_WhenIncorrectNum(string testNumber) + { + var testNum = new NumberValidator(4, 2, true); + + var res = testNum.IsValidNumber(testNumber); + + res.Should().BeFalse(); + } + + [Test] + [TestCase(" 12")] + [TestCase("12 ")] + [TestCase("1 2")] + public void Should_BeFalse_WhenNumWithWhitespaces(string testNumber) + { + var testNum = new NumberValidator(4, 2, true); + var res = testNum.IsValidNumber(testNumber); + res.Should().BeFalse(); + } } \ No newline at end of file