ColumnFixture

ColumnFixture mapeia as colunas de uma tabela diretamente para propriedades e métodos de uma classe de suporte (fixture). É bastante útil para verificações repetitivas caso o mesmo teste precise ser executado para diferentes combinações de argumentos de entrada.

A primeira linha da tabela é o nome da classe de teste. A segunda linha tem o nome das colunas, especificando uma propriedade ou método com o qual a coluna se relaciona. Valores de saída devem ter um ponto de interrogação ? ou parênteses () depois do nome da propriedade ou método. Todas as linhas subsequentes representam combinações de parâmetros de entrada e valores de saída esperados para os métodos .

!|info.fitnesse.fixturegallery.ColumnFixtureTest|
|firstPart|secondPart|together?|totalLength?|
|Hello|World|Hello, World|10|
|Houston|We Have a Problem|Houston, We Have a Problem|24|

A fixture deve estender fit.ColumnFixture e declarar atributos e métodos públicos equivalentes à segunda linha da tabela.

package info.fitnesse.fixturegallery;

import fit.ColumnFixture;

public class ColumnFixtureTest extends ColumnFixture {
	public String firstPart;
	public String secondPart;
	private int length;
	public String together(){
		length=firstPart.length()+secondPart.length();
		return firstPart+ ", "+secondPart;
	}
	public int totalLength(){
		return length;
	}
}

using System;
using System.Collections.Generic;
using System.Text;

namespace info.fitnesse.fixturegallery
{
    public class ColumnFixtureTest: fit.ColumnFixture
    {
        public String firstPart;
        public String secondPart;
        public String Together
        {
            get
            {
                return firstPart + ", " + secondPart;
            }
        }
        public int TotalLength()
        {
            return firstPart.Length+secondPart.Length;
        }
    }
}

from fit.ColumnFixture import ColumnFixture

class ColumnFixtureTest(ColumnFixture):
    _typeDict = {
        "firstPart":  "String",
        "secondPart": "String"
    }

    def __init__(self):
        ColumnFixture.__init__(self)
        self.firstPart  = ""
        self.secondPart = ""

    # JAVA: public String together(){
    _typeDict["together"] = "String"
    def together(self):
        return "%s, %s" % (self.firstPart, self.secondPart)

    # JAVA: public int totalLength(){
    _typeDict["totalLength"] = "Integer"
    def totalLength(self):
        return len(self.firstPart) + len(self.secondPart)

'From VisualWorks®, 7.6 of March 3, 2008 on June 27, 2008 at 3:36:26 pm'!


Info.Fitnesse.Fixturegallery defineClass: #ColumnFixtureTest
	superclass: #{Fit.ColumnFixture}
	indexedType: #none
	private: false
	instanceVariableNames: 'firstPart secondPart '
	classInstanceVariableNames: ''
	imports: ''
	category: ''!

!Info.Fitnesse.Fixturegallery.ColumnFixtureTest methodsFor: 'accessing'!

firstPart: aString
	firstPart := aString!

secondPart: aString
	secondPart := aString!

together
	^firstPart , ', ' , secondPart!

totalLength
	^firstPart size + secondPart size! !

!Info.Fitnesse.Fixturegallery.ColumnFixtureTest methodsFor: 'type access'!

signatureFor: aSymbol
	aSymbol == #totalLength ifTrue: [^Number].
	^String! !

Na versão Java, os atributos da classe podem ser usados apenas como entrada e métodos podem ser usados apenas como saída. Propriedades de JavaBeans não são suportadas diretamente (getters funcionam como métodos de saída, porém você tem que especificar o nome completo do método como em getCreditLimit). Na versão .Net, ambos atributos e propriedades podem ser usados como entradas ou saídas. Além disso, métodos sem parâmetros podem ser usados como saída também. A implementação em Java deve obedecer maiúsculas e minúsculas, enquanto na versão .Net isso é ignorado para nomes de propriedades. Na versão em Smalltalk, setters precisam são definidos como entrada e getters como saída. Maiúsculas e minúsculas também fazem diferença nesta implementação.

As linhas da tabela são executadas de cima para baixo, com a primeira célula sendo executada da esquerda para direita. Isto significa que os efeitos colaterais de métodos persistem para as próximas células da mesma linha e para as células da próximas linhas também. Se você precisa tornar a chamada de um método independente, sobrescreva o método reset().

A versão .Net de FIT suporta mesclar objetos de domínio com ColumnFixture, o quer permite usar a ColumnFixture sem declarar todas as propriedades e métodos do seu objeto de domínio na fixture. Este conceito é explicado em mais detalhes Target objects.

Deixe a célula de saída vazia para apenas imprimir o valor de saída, sem testar nada.

ColumnFixture é ótima para descrever regras de negócio baseadas em cálculos e máquinas de estado. Deve ser usada quando o mesmo tipo de cálculo precisa ser verificado com uma faixa de diferentes valores de entrada, e você conhece com antecedência todas as diferentes combinações.

Se o teste não é repetitivo (somente um passo), usar ColumnFixture pode não ser a melhor opção. Considere usar uma DoFixture (veja DoFixture ) em flow mode para isso. Se você quer testar uma lista de objetos dinâmica, use ArrayFixture (veja ArrayFixture) ou RowFixture porque elas também verificam o conteúdo da lista.

As pessoas frequentemente erram ao usar ColumnFixture para preparar outros testes, especialmente para criar domain objects ou inserir registros no banco de dados. Um padrão típico para isso é executar métodos adicionals, normalmente chamados Criar, como última coluna da tabela. Este método tipicamente retorna algum código de estado como OK. Isso faz sentido somente se voce quer checar regras de negócio para criação (e códigos de erro que serão retornados em caso de problemas). Se você quer somente preparar o terreno para outros testes, use SetUpFixture (see SetUpFixture ). Isso fará a página mais focada e fácil de ler, e você terá que escrever menos código na fixture também.

Próxima página: ActionFixture Página acima: Fixtures básicas de FIT