Testes orientados a dados no Nunit?

Question

No Mstest, você pode fazer algo como:

[TestMethod]
[DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", 
            "testdata.csv", "testdata#csv", DataAccessMethod.Sequential)]
public void TestSomething()
{
    double column1 = Convert.ToDouble(TestContext.DataRow["column1"]);
    ...
    Assert.AreEqual(...);
}

Qual é o código equivalente no NUNIT 2.5?

Answer 1

Eu olharia para o Testes parametrizados Documentação no Nunit 2.5 E veja se você pode fazer algo como o que está fazendo lá. Não me lembro de Nunit ter um atributo de leitura de CSV integrado para conduzir testes parametrizados. Pode haver um plug-in da comunidade em algum lugar.

Devo também salientar que, se você estiver apenas procurando por bibliotecas de estrutura de teste de unidade não-MS para ajudá-lo, o Xunit.net possui essa funcionalidade. Veja isso Postagem do blog de Ben Hall

Answer 2

Recebi testes orientados a dados baseados em CSV no Nunit trabalhando da seguinte forma:

Use o CSV Reader do Código Projeto, embrulhado em um método privado que retornando IENUMELENCIAL na sua aula de teste e, em seguida, faça referência a um atributo TestCasesource em seus casos de teste. Inclua seu arquivo CSV em seu projeto e defina "Copiar para o diretório de saída" para "Copiar sempre ".

using System.Collections.Generic;
using System.IO;
using LumenWorks.Framework.IO.Csv;
using NUnit.Framework;

namespace mytests
{
    class MegaTests
    {
        [Test, TestCaseSource("GetTestData")]
        public void MyExample_Test(int data1, int data2, int expectedOutput)
        {
            var methodOutput = MethodUnderTest(data2, data1);
            Assert.AreEqual(expectedOutput, methodOutput, string.Format("Method failed for data1: {0}, data2: {1}", data1, data2));
        }

        private int MethodUnderTest(int data2, int data1)
        {
            return 42; //todo: real implementation
        }

        private IEnumerable<int[]> GetTestData()
        {
            using (var csv = new CsvReader(new StreamReader("test-data.csv"), true))
            {
                while (csv.ReadNextRecord())
                {
                    int data1 = int.Parse(csv[0]);
                    int data2 = int.Parse(csv[1]);
                    int expectedOutput = int.Parse(csv[2]);
                    yield return new[] { data1, data2, expectedOutput };
                }
            }
        }
    }
}

Postagem original em: http://timise.blogspot.com/2011/05/data-driven-test-innit-with-csv.html

Answer 3

Aqui está outro exemplo muito semelhante ao de Tim Abell, no entanto, não está usando uma estrutura para o leitor de CSV e mostrando as especificidades do teste. NOTA Quando você usa o teste TestCASEAttribute, o TestAttribute pode ser omitido.

        [TestCaseSource("GetDataFromCSV")]
    public void TestDataFromCSV(int num1,int num2,int num3)
    {
        Assert.AreEqual(num1 + num2 ,num3);
    }

    private IEnumerable<int[]> GetDataFromCSV()
    {
        CsvReader reader = new CsvReader(path);
        while (reader.Next())
        {
            int column1 = int.Parse(reader[0]);
            int column2 = int.Parse(reader[1]);
            int column3 = int.Parse(reader[2]);
            yield return new int[] { column1, column2, column3 };
        }
    }


public class CsvReader : IDisposable
{
    private string path;
    private string[] currentData;
    private StreamReader reader;

    public CsvReader(string path)
    {
        if (!File.Exists(path)) throw new InvalidOperationException("path does not exist");
        this.path = path;
        Initialize();
    }

    private void Initialize()
    {
        FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read);
        reader = new StreamReader(stream);
    }

    public bool Next()
    {
        string current = null;
        if ((current = reader.ReadLine()) == null) return false;
        currentData = current.Split(',');
        return true;
    }

    public string this[int index]
    {
        get { return currentData[index]; }
    }


    public void Dispose()
    {
        reader.Close();
    }
}

Dados do CSV:

10,200,210 20,190,210 30,180,210 40,170,210 50,160,210 60,150,210 70,140,210 80,130,210 90,120,210 100,110,210

Nota: A 3ª coluna é uma soma das duas primeiras colunas e isso será afirmado no teste de unidade.

Resultados:

Encontre abaixo uma alternativa usando objetos TestCasedata e definir um tipo de retorno (que fora do curso é obrigatório)

        [TestCaseSource("GetDataFromCSV2")]
    public int TestDataFromCSV2(int num1, int num2)
    {
        return num1 + num2;
    }

    private IEnumerable GetDataFromCSV2()
    {
        CsvReader reader = new CsvReader(path);
        while (reader.Next())
        {
            int column1 = int.Parse(reader[0]);
            int column2 = int.Parse(reader[1]);
            int column3 = int.Parse(reader[2]);
            yield return new TestCaseData(column1, column2).Returns(column3);
        }
    }

Answer 4

O teste MS fornece um mecanismo para ter seus dados de teste de diferentes fontes. No entanto, isso não está disponível na caixa da Nunit.

Sou a favor do uso da separação dos dados e do código para testes de algum tamanho considerável. Quando eu separo ambos, minha expectativa é 1. Legabilidade dos dados de teste 2. Os dados de teste devem ser fáceis de modificar 3. Os testes de unidade devem ser executados confortavelmente no ambiente local e de construção

o JSOnsectionReader Abaixo tem todos os recursos que eu gostaria de ter. A ferramenta é capaz de ler seções de dados de arquivos JSON incorporados. Ele também fornece um mecanismo muito confortável para deseralizar.

https://www.nuget.org/packages/wondertools.jsonsectionReader/

PS Eu sou o mantenedor deste projeto, e este projeto foi criado porque não encontrei nenhuma outra ferramenta que resolva esse problema na medida em que eu queria.

Answer 5

Eu acho que o Nunit equivilent é marcar um método como um método de configuração e, em seguida, carregar os dados em um campo a ser usado nos testes subsequentes.

Você tem que codificar você mesmo, mais ou menos.