Beispiel #1
0
        public void CheckCurrentTsar()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            actualTsar.ShouldBeEquivalentTo(expectedTsar, options => options.Excluding(tsarInfo => tsarInfo.SelectedMemberInfo.Name == nameof(Person.Id) &&
                                                                                       tsarInfo.SelectedMemberInfo.DeclaringType == typeof(Person)));
        }
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            Assert.True(AreEqual(actualTsar, expectedTsar));
        }
Beispiel #3
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            actualTsar.Should().BeEquivalentTo(expectedTsar, options =>
                                               options.Excluding(o => o.SelectedMemberInfo.Name == "Id"));
        }
Beispiel #4
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            expectedTsar.Should().BeEquivalentTo(actualTsar,
                                                 option => option.ExcludingMember(nameof(Person.Id)));
        }
Beispiel #5
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Перепишите код на использование Fluent Assertions.
            actualTsar.ShouldBeEquivalentTo(expectedTsar, options => options.Excluding(ctx => ctx.SelectedMemberPath.EndsWith("Id")));
        }
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            Assert.True(AreEqual(actualTsar, expectedTsar));
            //Переписывать метод AreEqual каждый раз при изменении класса(добавлении нового поля/св-ва) Person БОЛЬ
        }
Beispiel #7
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Q: Какие недостатки у такого подхода?
            // A: Легко пропустить поля + Person.parent'ом можно замутить цикл и тест вывалится из-за OOM
            Assert.True(AreEqual(actualTsar, expectedTsar));
        }
Beispiel #8
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            actualTsar.Should().BeEquivalentTo(expectedTsar, compare =>
                                               compare.Excluding(person => person.Id)
                                               .Excluding(person => person.Parent !.Id));
        }
Beispiel #9
0
        public void CheckCurrentTsar()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            actualTsar.ShouldBeEquivalentTo(expectedTsar, options => options
                                            .AllowingInfiniteRecursion()
                                            .Excluding(f => f.SelectedMemberInfo.DeclaringType.Name == typeof(Person).Name &&
                                                       f.SelectedMemberInfo.Name == "Id"));
        }
Beispiel #10
0
        public void GetCurrentTsar_ReturnsExpectedTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Перепишите код на использование Fluent Assertions.
            actualTsar.ShouldBeEquivalentTo(expectedTsar,
                                            options => options.Excluding(info => info.SelectedMemberInfo.Name == "Id"));
        }
Beispiel #11
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            // Может произойти переполнение стека
            // При расширении Person можо забыть изменить Функцю
            Assert.True(AreEqual(actualTsar, expectedTsar));
        }
Beispiel #12
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            actualTsar.Should().BeEquivalentTo(expectedTsar, options => options
                                               .Excluding(person => person.SelectedMemberInfo.Name == nameof(Person.Id))
                                               .IgnoringCyclicReferences());
        }
Beispiel #13
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            var fieldName = nameof(Person.Id);

            actualTsar.Should().BeEquivalentTo(expectedTsar, options => options.ExcludeField(fieldName));
        }
Beispiel #14
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            // Непонятно из-за чего падает тест
            // Плохо расширяемая штука
            Assert.True(AreEqual(actualTsar, expectedTsar));
        }
Beispiel #15
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Перепишите код на использование Fluent Assertions.
            expectedTsar.Should().BeEquivalentTo(actualTsar,
                                                 options => options.Excluding(o => o.Id).Excluding(o => o.Parent.Id));
        }
        public void GetCurrentTsar_IsStubMethod_ReturnsIvanIVTheTerrible()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            actualTsar.Should().BeEquivalentTo(expectedTsar, options => options.Excluding(
                                                   person => person.SelectedMemberInfo.Name == nameof(Person.Id)),
                                               "GetCurrentTsar() is demonstration method which returns Ivan IV");
        }
Beispiel #17
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            Assert.True(AreEqual(actualTsar, expectedTsar));
            // Кто-нибудь может начать использовать этот метод, думая что он проверяет нормальное равество полей, но будет проверять усеченное, что ведет к трудноотлавлеваемым ошибкам.
            // По хорошему нужно перегрузить Equals и GetHashCode, но это при условии, что нам действительно нужно такое рекурстивное сравнение.
        }
Beispiel #18
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            actualTsar.Should().BeEquivalentTo(expectedTsar, options => options
                                               .Excluding(person => person.SelectedMemberInfo.Name.Equals(nameof(Person.Id)))
                                               .AllowingInfiniteRecursion());
        }
Beispiel #19
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // 0 изменений в тесте если появляются новые поля :)
            actualTsar.ShouldBeEquivalentTo(actualTsar, options =>
                                            options.RespectingDeclaredTypes());
        }
Beispiel #20
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            Assert.True(AreEqual(actualTsar, expectedTsar));
            // Если тест упадёт, будет очень сложно обноружить проблемное место,
            // так как это сравнение не даст нам информацию в каком именно месте ломается программа
            // При добавление нового поля в Person, код придётся дорабатывать вносить правки
        }
Beispiel #21
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            // Недостатки у подобного подхода на мой взгляд заключаются в том, что:
            // При добавлении новых свойств легко можно забыть внести изменения в условие
            // По сообщению в случае если тест не пройдет будет не понятно что и где сломалось
            Assert.True(AreEqual(actualTsar, expectedTsar));
        }
Beispiel #22
0
        public void CheckCurrentTsar()
        {
            Person actualTsar   = TsarRegistry.GetCurrentTsar();
            Person expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                             new Person("Vasili III of Russia", 28, 170, 60, null));

            // Перепишите код на использование Fluent Assertions.

            actualTsar.ShouldBeEquivalentTo(expectedTsar, options =>
                                            options.Excluding(o => o.SelectedMemberInfo.Name.Equals(nameof(Person.Id)))
                                            .ExcludingMissingMembers());
        }
Beispiel #23
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            Assert.True(AreEqual(actualTsar, expectedTsar));
            //1.Переписывать метод AreEqual каждый раз при изменении класса(добавлении нового поля/св-ва) Person БОЛЬ
            //2.FluentAssertions даст однозначно более понятный ответ
            //3.У BeEquivalentTo есть регулируемое ограничение по глубине, которое позволит избежать циклов
        }
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            Assert.True(AreEqual(actualTsar, expectedTsar));
            /// Более громоздкое (за счет проверки всех полей в методе AreEqual),
            /// хуже при расширении, т.е. при добавлении или изменении полей -
            /// надо будет и AreEqual править.
        }
Beispiel #25
0
        public void CheckCurrentTsar()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            actualTsar.ShouldBeEquivalentTo(expectedTsar, assertionOptions =>
                                            assertionOptions
                                            .Excluding(x => x.SelectedMemberInfo.Name == "Parent.Parent")
                                            .Excluding(x =>
                                                       x.SelectedMemberPath.EndsWith("Id") && x.SelectedMemberInfo.DeclaringType == typeof(Person)));
        }
Beispiel #26
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            // - Нерасширяемый
            // - Очень много проверок в одном Assert'e
            // - При фейле не удастся получить конкретную информацию, по какой причине тест упал
            Assert.True(AreEqual(actualTsar, expectedTsar));
        }
Beispiel #27
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            // При добавлении полей/свойств в класс Person, можно забыть их добавить в метод AreEqual.
            // Когда тест валится, то он не показывает достаточно информации о том, что пошло не так.
            // При большом количестве атрибутов у класса Person, метод AreEqual будет огромным.
            Assert.True(AreEqual(actualTsar, expectedTsar));
        }
Beispiel #28
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Какие недостатки у такого подхода?
            // 1) Если мы захотим проверять равенство объектов по еще n критериям,
            // то придется добавить n проверок.
            // 2) Не сразу будет ясно, где именно упал тест.
            Assert.True(AreEqual(actualTsar, expectedTsar));
        }
Beispiel #29
0
        public void CheckCurrentTsar()
        {
            var actualTsar = TsarRegistry.GetCurrentTsar();

            var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
                                          new Person("Vasili III of Russia", 28, 170, 60, null));

            // Перепишите код на использование Fluent Assertions.
            actualTsar.Should().BeEquivalentTo(expectedTsar, options => options
                                               .Excluding(e => e.SelectedMemberInfo.DeclaringType == typeof(Person) &&
                                                          e.SelectedMemberInfo.Name == nameof(Person.Id)));
        }
Beispiel #30
0
        public void CheckCurrentTsar_WithCustomEquality()
        {
            var actualTsar   = TsarRegistry.GetCurrentTsar();
            var expectedTsar = new Person("Ivan IV The Terrible", age: 54, height: 170, weight: 70,
                                          parent: new Person("Vasili III of Russia", age: 28, height: 146, weight: 60, parent: null));

            // Какие недостатки у такого подхода?
            Assert.True(AreEqual(actualTsar, expectedTsar));

            /* Не говорит, в каком месте именно несовпадение (только true или false);
             * Плохая расширяемость: при добавлении новых полей в Person нужно доопределять AreEqual */
        }