Unit-тесты в C#: библиотека NUnit, Assert и тестовый проект

По-хорошему, все для стабильной работы надо тестировать. Как и люди пинают роботов в Boston Dynamics чтобы посмотреть, насколько они стабильны, так и мы должны придумать всевозможные тесты на проверку стабильности и вариативности написанного нами кода. Сделать это можно при помощи библиотеки NUnit и отдельного проекта.

Я не научу вас как правильно составлять тест-кейсы, видам тестирования и прочему огромному теоретическому бекграунду тестирования, так как это очень большой пласт информации, который нужно рассматривать в отдельных курсах. Но, я кратко покажу вам, каким образом можно тестировать свой код на C#

Настройка главного проекта #

У меня есть маленькое приложение, которое ничего не делает, просто имеет пустой класс Program.cs

…один класс TestData который хранит в себе тестовые данные некоторых файлов

1
namespace тесты
2
{
3
    public class TestData
4
    {
5
        //тут имитация того, что код берет файлы
6
        //на самом деле - просто возвращает лист с названиями рандомных файлов
7
        public List<string> GetFiles()
8
        {
9
            List<string> list = new List<string>
10
            {
11
                "file.txt",
12
                "file2.log",
13
                "file3.exe"
14
            };
15
            return list;
16
        }
17
    }
18
}

…и один класс FileManager, который берет все «файлы» из первого класса, а потом смотрит, есть ли в этом листе запрошенный файл.

1
namespace тесты
2
{
3
    class FileManager
4
    {
5
        //метод, который берет все файлы из первого класса
6

7
        public bool FindFileByName(string fileName)
8
        {
9
            //вот тут берет
10
            TestData obj = new TestData();
11
            List<string> files = obj.GetFiles();
12

13
            //a потом ищет нужный файл и возвращает true если нашел
14
            foreach (var file in files)
15
            {
16
                if (file.Contains(fileName))
17
                    return true;
18
            }
19

20
            //false если не нашел
21
            return false;
22
        }
23
    }
24
}

Мне и не требуется иметь код в Program.cs либо в любой другой основной программе. Тестируем мы именно отдельные классы (модули), а это значит, что приложение должно быть модульным (разделенным на классы).

Создание тестового проекта #

Чтобы начать тестирование, нам необходимо создать отдельный проект. Для этого ПКМ нажмем по решению -> добавить -> создать проект

Перед нами появится то же самое окно, которое появляется, когда мы создаем новый проект. В поиске мы должны написать NUnit – это библиотека, при помощи которой мы будем создавать тесты. Выберем самый первый появившийся вариант, для C#

Далее мы как-либо называем проект, снова выбираем версию, и создаем. Все как при создании любого другого приложения

При создании перед нами появится класс с ошибками. Это нормально, ошибки появляются потому, что проект пока что только строится и докачивает пакет NUnit (этот пакет вы, кстати, можете найти в управление пакетами Nuget). Как только он все докачает, то все станет зеленым. Важно: для того, чтобы все загрузилось, у вас должен быть интернет

Разберем подробнее что здесь что

Внутри класса Tests хранятся 2 метода – Setup и Test1. Эти два метода помечены какой-то штукой в квадратных скобках – атрибутами. Этот атрибут задает поведение для метода:

• Атрибут SetUp говорит методу запустится перед всеми тестами, чтобы их настроить (создать переменные, задать первоначальные значения и прочее)
• Атрибут Test говорит методу, ну, быть тестом. Без этого атрибута Visual Studio подумает, что это самый обычный метод, как и все те, что мы делали до этого, и не сможет запустить тест. Так что в каждом методе, который должен быть тестом, должен быть этот атрибут Test

Внутри метода Test1 мы видим одну строчку кода – Assert.Pass(); - это, на данный момент, заглушка. При помощи класса Assert проводятся тесты, а Pass – просто метод, который сделает тест намеренно пройденным, не проверяя ничего.

Работа с тестами #

Внутри Assert есть огромное количество проверок: IsNull – равна ли переменная Null, Less – меньше ли переменная n-ому значению, Negative – является ли значение меньше нуля и прочее прочее прочее. Опять же, список огромен, все что нам требуется – написать Assert. и искать в появившемся списке интересный нам тест

Я верну Assert.Pass(); чтобы показать, как работают тесты

Чтобы запустить все тесты внутри решения, нужно перейти во вкладку «Тест» и выбрать «Запуск всех тестов»

Все решение соберется и перед нами появится вот такое вот окошко, где галочкой будут показаны все пройденные тесты, крестиком – непройденные, а окружность – тест, который не запустился

За тест будет считаться каждый метод. Если внутри одного метода есть, например, 5 Assert-ов, и один из них не выполнился, весь тест считается за невыполненный.

Теперь, я хочу протестировать свои два класса, которые я показала в самом начале лекции. Для этого мне нужно сначала подключить проект (Зависимости\Ссылки у проекта с тестами -> Добавить ссылку на проект и галочку у нужного проекта)

А потом нужно создать переменные с ними, их я буду делать в SetUp

1
using тесты;
2
{
3
    namespace TestProj
4
    {
5
        public class Tests
6
        {
7
            TestData testData;
8
            FileManager fileManager;
9

10
            [SetUp]
11
            public void Setup()
12
            {
13
                testData = new TestData();
14
                fileManager = new FileManager();
15
            }
16
        }
17
    }
18
}

Напомню, что TestData отвечает за файлы, а FileManager – за поиск файлов из TestData

Напишу три теста для TestData – создался ли лист (не null), не пустой ли он (лист.count > 0) и точно ли там названия файлов (элемент листа имеет точку)

Точно также для FileManager – три теста – находится ли нужный файл, найдется ли пустое название (не должно), и найдется ли что-то если я передам null (опять же, не должно)

Заметьте, что каждый тест помечен атрибутом Test, а сами тесты сделаны через Assert в отдельном методе

1
using тесты;
2
{
3
    namespace TestProj
4
    {
5
        public class Tests
6
        {
7
            TestData testData;
8
            FileManager fileManager;
9

10
            [SetUp]
11
            public void Setup()
12
            {
13
                testData = new TestData();
14
                fileManager = new FileManager();
15
            }
16

17
            [Test]
18
            public void ListTest1()
19
            {
20
                Assert.IsNotNull(testData.GetFiles());
21
            }
22

23
            [Test]
24
            public void ListTest2()
25
            {
26
                Assert.Greater(0, testData.GetFiles().Count);
27
            }
28

29
            [Test]
30
            public void ListTest3()
31
            {
32
                var list = testData.GetFiles();
33

34
                foreach (var item in list)
35
                {
36
                    Assert.IsTrue(item.Contains("."));
37
                }
38
            }
39
            [Test]
40
            public void FileTest1()
41
            {
42
                Assert.IsTrue(fileManager.FindFileByName("file2.log"));
43
            }
44

45
            [Test]
46
            public void FileTest2()
47
            {
48
                Assert.IsFalse(fileManager.FindFileByName(""));
49
            }
50

51
            [Test]
52
            public void FileTest3()
53
            {
54
                Assert.IsFalse(fileManager.FindFileByName(null));
55
            }
56
        }
57
    }
58
}

Запущу все тесты и увижу следующее. Во первых – когда он искал пустоту, он нашел такой файл, хотя не должен был. А также, когда мы отправили туда null, код выдал ошибку, хотя опять же, не должен был.

Работа тестировщика на этом этапе заканчивается, снова включается разработчик. При помощи таких тестов мы можем понять поведение нашего кода и исправить его. Например, я поправлю код в FileManager так, чтобы все тесты были пройдены

Тогда, код в FileManager.cs будет выглядеть вот так

1
namespace тесты
2
{
3
    class FileManager
4
    {
5
        public bool FindFileByName(string fileName)
6
        {
7
            //добавлю строку для null
8
            if (fileName == null) return false;
9

10
            TestData obj = new TestData();
11
            List<string> files = obj.GetFiles();
12

13
            //a потом ищет нужный файл и возвращает true если нашел
14
            foreach (var file in files)
15
            {
16
                //изменю условие с Contains на ==
17
                if (file == fileName)
18
                    return true;
19
            }
20

21
            //false если не нашел
22
            return false;
23
        }
24
    }
25
}

И снова попробую запустить тесты. Теперь мой код будет готов к любым непреднамеренным передачам данных, не будет кидать ошибки, и будет работать корректно

Модульное тестирование обеспечивает проверку кода на отрабатывание во всех ситуациях - хороших, плохих и даже странных. Такое покрытие, которые мы прописали выше, позволяет проверять внесенные изменения и всегда знать - корректно ли работает новый\старый код, или нужно внести правки