nopCommerce Dokumentace

Jednotkové testy

Myslím, že koncept jednotkových (UNIT) testů zná každý. Víme, k čemu se jednotkové testy používají, a shodneme se, že jsou důležitou součástí procesu vývoje spolehlivého softwaru. V tomto článku se těmito otázkami zabývat nebudeme. Všechny potřebné informace snadno najdete na internetu, například pomocí těchto odkazů:

V tomto článku se seznámíme se specifiky testování v projektu nopCommerce a naučíme se přidávat nové testy a ověřovat jejich funkčnost. Nebudeme testovat abstraktní úlohu, ale od nuly napíšeme plnohodnotný test pro existující funkcionalitu. Na konci článku najdete odkaz na příslušný commit se všemi popsanými změnami kódu.

Přehled vlastností

tests-project

Na snímku obrazovky vidíte strukturu projektu Nop.Tests. Složky jako Nop.Core.Tests obsahují testy pro odpovídající projekty řešení. Ostatní soubory zajišťují pomocné a základní třídy. Podívejme se na třídu BaseNopTest.

BaseNopTest

Jde o hlavní statickou třídu, která zpřístupňuje IoC kontejner pro testy a umožňuje nám využívat všech výhod DI.

base-nop-test

Tato třída obsahuje dvě metody dostupné odvozeným třídám:

  • PropertiesShouldEqual, která porovnává všechna pole databázové entity s poli modelu.

  • GetService, která umožňuje využívat výhod DI a ušetří vytváření tříd potřebných pro testování.

Inicializace IoC kontejneru probíhá ve statickém konstruktoru třídy; tento konstruktor obsahuje většinu kódu.

IScheduleTaskService

Jako příklad vytvoříme testy pro třídu, která implementuje rozhraní IScheduleTaskService.

public partial interface IScheduleTaskService
{
    System.Threading.Tasks.Task DeleteTaskAsync(ScheduleTask task);

    Task<ScheduleTask> GetTaskByIdAsync(int taskId);

    Task<ScheduleTask> GetTaskByTypeAsync(string type);

    Task<IList<ScheduleTask>> GetAllTasksAsync(bool showHidden = false);

    System.Threading.Tasks.Task InsertTaskAsync(ScheduleTask task);

    System.Threading.Tasks.Task UpdateTaskAsync(ScheduleTask task);
}

Jak vidíte, jde o jednoduché rozhraní. Zároveň však nopCommerce umožňuje provádět velmi důležité úlohy, jako je odesílání e-mailových zpráv zákazníkům. Musíme si tedy být jisti, že funguje správně. Dále napíšeme testy pro každou z metod rozhraní.

Poznámka

Nepoužíváme TDD, ale nejsme proti tomuto přístupu. Důležitá je pro nás spolehlivost funkcionality, nikoli konkrétní přístup k testování.

Třída ScheduleTaskServiceTests

Přidejte do projektu novou třídu ScheduleTaskServiceTests (Nop.Tests\Nop.Services.Tests\Tasks). Její kód je uveden níže:

using NUnit.Framework;

namespace Nop.Tests.Nop.Services.Tests.Tasks
{
    [TestFixture]
    public class ScheduleTaskServiceTests : ServiceTest
    {
    }
}

Toto je šablona třídy pro testování. Z tohoto kódu vidíme, že nopCommerce používá pro testy framework NUnit. Je třeba si všimnout dvou věcí:

  1. Naše třída má atribut TestFixture, který enginu sděluje, že tato třída obsahuje testy.
  2. Nedědíme přímo od třídy BaseNopTest, ale od jiné abstraktní třídy – ServiceTest, která do konfigurace přidává hlavní pluginy.

Dalším krokem je přidání metody pro inicializaci našich testů. Taková metoda se zpravidla nazývá SetUp. V této metodě získáme instanci třídy implementující rozhraní IScheduleTaskService, kterou budeme testovat.

private IScheduleTaskService _scheduleTaskService;

[OneTimeSetUp]
public void SetUp()
{
    _scheduleTaskService = GetService<IScheduleTaskService>();
}

Jak vidíte, metoda SetUp by měla být deklarována s atributem OneTimeSetUp; můžete však použít i atribut SetUp. Rozdíl mezi těmito dvěma atributy je pouze v počtu volání samotné metody: v prvním případě se metoda SetUp volá jednou pro všechny testy, ve druhém pro každý test zvlášť.

Dále přidejme testy pro metody CRUD. V této službě jde o metody jako: InsertTaskAsync, GetTaskByIdAsync, UpdateTaskAsync a DeleteTaskAsync.

Nejprve však do třídy přidejme ještě jedno pole. Bude to instance třídy ScheduleTask, která bude použita pro testování:

 private ScheduleTask _task;

Upravte metodu SetUp následujícím způsobem:

[OneTimeSetUp]
public void SetUp()
{
   _scheduleTaskService = GetService<IScheduleTaskService>();

   _task = new ScheduleTask { Enabled = true, Name = "Test task", Seconds = 60, Type = "nop.test.task" };
}

Všechny testovací metody CRUD jsou uvedeny níže a jak vidíte, není v nich nic složitého:

#region CRUD tests

[Test]
public async System.Threading.Tasks.Task CanInsertAndGetTask()
{
    _task.Id = 0;
    await _scheduleTaskService.InsertTaskAsync(_task);
    var task = await _scheduleTaskService.GetTaskByIdAsync(_task.Id);
    await _scheduleTaskService.DeleteTaskAsync(_task);

    _task.Id.Should().NotBe(0);
    task.Id.Should().Be(_task.Id);
    task.Name.Should().Be(_task.Name);
}

[Test]
public void InsertTaskShouldRaiseExceptionIfTaskIsNull()
{
    Assert.Throws<AggregateException>(() =>
            _scheduleTaskService.InsertTaskAsync(null).Wait());
}

[Test]
public async System.Threading.Tasks.Task GetTaskByIdShouldReturnNullIfTaskIdIsZero()
{
    var task = await _scheduleTaskService.GetTaskByIdAsync(0);
    task.Should().BeNull();
}

[Test]
public async System.Threading.Tasks.Task GetTaskByIdShouldReturnNullIfTaskIdIsNotExists()
{
    var task = await _scheduleTaskService.GetTaskByIdAsync(int.MaxValue);
    task.Should().BeNull();
}

[Test]
public async System.Threading.Tasks.Task CanUpdateTask()
{
    _task.Id = 0;
    await _scheduleTaskService.InsertTaskAsync(_task);
    var task = await _scheduleTaskService.GetTaskByIdAsync(_task.Id);
    task.Name = "new test name";
    await _scheduleTaskService.UpdateTaskAsync(task);
    var task2 = await _scheduleTaskService.GetTaskByIdAsync(_task.Id);
    await _scheduleTaskService.DeleteTaskAsync(_task);

    task.Id.Should().Be(task2.Id);
    task2.Name.Should().NotBe(_task.Name);
}

[Test]
public void UpdateTaskShouldRaiseExceptionIfTaskIsNull()
{
    Assert.Throws<AggregateException>(() =>
        _scheduleTaskService.UpdateTaskAsync(null).Wait());
}

public async System.Threading.Tasks.Task CanDeleteTask()
{
    _task.Id = 0;
    await _scheduleTaskService.InsertTaskAsync(_task);
    await _scheduleTaskService.DeleteTaskAsync(_task);
    var task = await _scheduleTaskService.GetTaskByIdAsync(_task.Id);
    task.Should().BeNull();
}

[Test]
public void DeleteTaskShouldRaiseExceptionIfTaskIsNull()
{
    Assert.Throws<AggregateException>(() =>
        _scheduleTaskService.DeleteTaskAsync(null).Wait());
}

#endregion

Kromě toho byl změněn seznam připojených jmenných prostorů. Aktualizovaný seznam je uveden níže:

using System;
using FluentAssertions;
using Nop.Core.Domain.Tasks;
using Nop.Services.Tasks;
using NUnit.Framework;

Poznámka

Všechny změny provedené testem musíme z databáze odstranit. V našem případě k tomu používáme metodu DeleteTaskAsync. Všimněte si také, že je třeba to provést těsně předtím, než zavoláme ověřovací metody, jako jsou task.Should().BeNull();, task2.Name.Should().NotBe(_task.Name); atd., protože pokud test selže, zůstanou v databázi data, která mohou ovlivnit další testovací procesy.

Poté otestujme dvě zbývající metody:

[Test]
public async System.Threading.Tasks.Task CanGetTaskByType()
{
    _task.Id = 0;
    var task = await _scheduleTaskService.GetTaskByTypeAsync(_task.Type);
    task.Should().BeNull();
    await _scheduleTaskService.InsertTaskAsync(_task);
    task = await _scheduleTaskService.GetTaskByTypeAsync(_task.Type);
    await _scheduleTaskService.DeleteTaskAsync(_task);
    task.Should().NotBeNull();
}

[Test]
public async System.Threading.Tasks.Task GetTaskByTypeShouldReturnNullIfTypeIsNull()
{
    var task = await _scheduleTaskService.GetTaskByTypeAsync(null);
    task.Should().BeNull();
}

[Test]
public async System.Threading.Tasks.Task GetTaskByTypeShouldReturnNullIfTypeIsEmpty()
{
    var task = await _scheduleTaskService.GetTaskByTypeAsync(string.Empty);
    task.Should().BeNull();
}

[Test]
public async System.Threading.Tasks.Task CanGetAllTasks()
{
    _task.Id = 0;
    var tasks = await _scheduleTaskService.GetAllTasksAsync(true);
    tasks.Count.Should().Be(0);
    tasks = await _scheduleTaskService.GetAllTasksAsync(false);
    tasks.Count.Should().Be(0);

    await _scheduleTaskService.InsertTaskAsync(_task);
    var tasksWithHidden = await _scheduleTaskService.GetAllTasksAsync(true);
    var tasksWitoutHidden = await _scheduleTaskService.GetAllTasksAsync(false);
    await _scheduleTaskService.DeleteTaskAsync(_task);

    tasksWithHidden.Count.Should().Be(1);
    tasksWitoutHidden.Count.Should().Be(1);

    _task.Enabled = false;

    await _scheduleTaskService.InsertTaskAsync(_task);
    tasksWithHidden = await _scheduleTaskService.GetAllTasksAsync(true);
    tasksWitoutHidden = await _scheduleTaskService.GetAllTasksAsync(false);
    await _scheduleTaskService.DeleteTaskAsync(_task);
    _task.Enabled = true;

    tasksWithHidden.Count.Should().Be(1);
    tasksWitoutHidden.Count.Should().Be(0);
}

Nakonec přidejme ještě jednu standardní metodu, kterou má mnoho testů a která se obvykle nazývá TearDown. V této metodě provedeme závěrečné vyčištění databáze od případných změn, které jsme provedli během testování. Tato metoda musí mít atribut OneTimeTearDown nebo TearDown, obdobně jako atributy metody SetUp.

[OneTimeTearDown]
public async System.Threading.Tasks.Task TearDown()
{
    var tasks = await _scheduleTaskService.GetAllTasksAsync(true);

    foreach (var task in tasks.Where(t=>t.Type.Equals(_task.Type, StringComparison.InvariantCultureIgnoreCase))) 
        await _scheduleTaskService.DeleteTaskAsync(task);
}

A je to, naše testovací třída je hotová! Jak jsme slíbili na začátku, všechny materiály najdete na odkazech níže: