Como realizar teste unitário em Excel VBA

A realização de teste unitário em qualquer software é algo que deveria ser realizado com frequência, mas não é o que tenho visto nestes anos de programação. Neste artigo é demonstrado como realizar testes unitários em Excel VBA.

O que é teste de software?

“Teste de software é o processo de execução de um produto para determinar se ele atingiu suas especificações e funcionou corretamente no ambiente para o qual foi projetado. O seu objetivo é revelar falhas em um produto, para que as causas dessas falhas sejam identificadas e possam ser corrigidas pela equipe de desenvolvimento antes da entrega final. Por conta dessa característica das atividades de teste, dizemos que sua natureza é “destrutiva”, e não “construtiva”, pois visa ao aumento da confiança de um produto através da exposição de seus problemas, porém antes de sua entrega ao usuário final.” Veja mais em DevMedia.

A área de teste de software é portanto responsável por garantir a qualidade do software que está sendo entregue ao cliente, precavendo de falhas de programação e também de conceito, regras de negócio aplicadas.

O que é teste unitário?

“O teste unitário tem por objetivo testar a menor parte testável do sistema (unidade), geralmente um método.
Idealmente, o teste unitário é independente de outros testes, validando assim cada parte ou funcionalidade individualmente.
Nos casos em que existe dependência de métodos ou classes que não estão sob teste, são usados mocks (objetos criados para simular o comportamento de objetos reais nos testes) para simular estes objetos ou métodos que são usados pela unidade, desacoplando a unidade sob teste dos componentes dos quais ela é dependente.” Veja mais em Mobiltec.

Quando criamos uma função ou procedimento em Excel/VBA temos diversas situações que devem ser testadas para que o código criado atenda aos requisitos da regra de negócio e que não irá apresentar erros na tela do cliente.

O teste unitário tem esta finalidade, de testar a menor unidade do programa que são as funções e procedimentos mitigando erros e aumentando a qualidade do programa.

Programa de teste unitário Excel VBA gratuito

O programa que iremos utilizar para realização dos testes unitários é um sistema de código aberto criado pela comunidade Rubberduck, que possui uma paleta com um conjunto de ferramentas que auxiliam no desenvolvimento profissional de programas em Excel VBA.

Para iniciarmos faça o download do programa seguindo o seguinte caminho:

1. Abra a página http://rubberduckvba.com/ e clique no botão Download.

2. Clique na última versão do software e baixe clicando no link no final da página correspondente.

3. Instale o programa seguindo os passos, e ao final o Excel já estará com o software instalado. Ao abrir o VBE você já terá ele na sua barra de ferramentas.

Criando um programa para teste

Agora que já temos o programa de testes unitários instalados vamos criar um programa que será testado por meio deste software.

Como nosso objetivo é testar um programa e não desenvolver um, iremos utilizar o código disponibilizado pela página do Julio Battisti para a validação de números de CPF.

1. Abra uma planilha no Excel e abra o VBE Editor.

2. Crie um módulo e cole o seguinte código fonte que realiza a validação de CPF e que iremos testar. Esta função irá receber o uma string de caracteres e irá retornar True se o CPF for validado e False se o CPF estiver incorreto.

'Desenvolvido por http://juliobattisti.com.br/cursos/excelavancado/modulo6/09.asp
'Algumas alterações para retornar boolean
Public Function ValidaCPF(CPF As String) As Boolean

    'Função para cálculo do dígito verificador do CPF
    'Iniciamos a função com a declaração das variáveis que serão utilizadas.
    ' As variáveis d1 até d11, conterão os dígitos individuais
    ' do CPF. Por exemplo, ao digitar o CPF: 123.456.789-11, essas
    ' variáveis conterão os seguintes valores:
    ' d1=1 d2=2 d3=3 d4=4 d5=5 d6=5 d7=7 d8=8 d9=9 d10=1 d11=1
    
    Dim d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11 As Integer
    
    ' Demais variáveis que serão utilizadas para o cálculo do DV.
    
    Dim Soma1, Soma2, Resto As Integer
    Dim Resto1, Resto2 As Integer
    Dim DV1, DV2 As Integer
    
    ' Em primeiro lugar testo se a célula com o CPF contém um valor
    ' válido, isto é, um valor Não Nulo.
    
    If Not (IsNull(CPF)) Then
        '*************************************************************************
        ' Os comandos a seguir desmembram o CPF um a um , atribuindo os valores *
        ' de d1 ... d11 , usando as funções Mid$ e Val *
        ' Como o CPF está no formato de Texto, vamos extrair os dígitos do CPF *
        ' um a um, converter o respectivo valor de texto para número e atribuir *
        ' esse valor para as variáveis d1 até d11. *
        '*************************************************************************
        
        d1 = Val(Mid$(CPF, 1, 1))
        d2 = Val(Mid$(CPF, 2, 1))
        d3 = Val(Mid$(CPF, 3, 1))
        d4 = Val(Mid$(CPF, 5, 1))
        d5 = Val(Mid$(CPF, 6, 1))
        d6 = Val(Mid$(CPF, 7, 1))
        d7 = Val(Mid$(CPF, 9, 1))
        d8 = Val(Mid$(CPF, 10, 1))
        d9 = Val(Mid$(CPF, 11, 1))
        d10 = Val(Mid$(CPF, 13, 1))
        d11 = Val(Mid$(CPF, 14, 1))
        
        '*************************************************************************
        ' A partir de agora passo a utilizar os valores anteriores para cálculo *
        ' do dígito verificador do CPF *
        '*************************************************************************
        
        ' Cálculo do primeiro DV
        
        Soma1 = ((d1 * 10) + (d2 * 9) + (d3 * 8) + (d4 * 7) + (d5 * 6) + (d6 * 5) + (d7 * 4) + (d8 * 3) + (d9 * 2))
        Resto1 = (Soma1 Mod 11)
    
        If (Resto1 <= 1) Then
            DV1 = 0
        Else
            DV1 = 11 - Resto1
        End If
    
        ' Agora inicio o cálculo do segundo DV, já incorporando
        ' o segundo DV como parte do CPF, para o cálculo.
        Soma2 = (d1 * 11) + (d2 * 10) + (d3 * 9) + (d4 * 8) + (d5 * 7) + (d6 * 6) + (d7 * 5) + (d8 * 4) + (d9 * 3) + (DV1 * 2)
        Resto2 = (Soma2 Mod 11)
        
        If (Resto2 <= 1) Then
            DV2 = 0
        Else
            DV2 = 11 - Resto2
        End If
        
        ' Agora faço o teste para saber se os DVs calculados (DV1 e DV2)
        ' conferem com os DVs do CPF - d10 e d11
        If ((DV1  d10) Or (DV2  d11)) Then
            ' Atribuo a palavra "Inválido" para uma variável com o mesmo
            ' nome da função - ValidaCPF.
            ' Essa é a maneira de fazer com que a função retorne um valor,
            ' ou seja, atribuindo o valor a ser retornado, à uma variável
            ' com o mesmo nome da função.
            ValidaCPF = False
        Else
            ' Atribuo a palavra "Válido" para uma variável com o mesmo
            ' nome da função - ValidaCPF.
            ' Essa é a maneira de fazer com que a função retorne um valor,
            ' ou seja, atribuindo o valor a ser retornado, à uma variável
            ' com o mesmo nome da função.
            ValidaCPF = True
        End If
    End If
End Function

Criada a nossa função ou procedimento o próximo passo é criar o teste unitário para verificarmos se o mesmo funciona corretamente.

Inserindo o módulo de teste unitário

Agora já estamos prontos para criar nosso primeiro teste unitário e entendermos seu funcionamento.

1. Clique em Rubberduck->Unit Tests->Text Explorer

2. Na janela que abre clique em Add->Test Module, o sistema irá criar um novo módulo no seu projeto nomeado como TestModule1

3. Agora está criado o módulo de teste.

Perceba que foram criados vários procedimentos no módulo, mas não se preocupe se não entender para que servem estes códigos neste momento, não serão necessários para o nosso teste unitário.

Criando o teste unitário

Agora iremos criar o nosso teste para a função de validação de CPF.

1. Clique em Rubberduck->Unit Tests->Text Explorer

2. Na janela que abre clique em Add->Test Method, o sistema irá criar um novo método de teste.

Os métodos criados serão sempre encontrados pelo nome @TestMethod, você pode renomear o teste e como não vamos utilizar neste momento os blocos Arrange, Act e Assert, você pode apagar todos estes valores inclusive, o Assert.Inconclusive.

Criando nosso próprio teste unitário

Agora iremos alterar o teste unitário padrão que foi criado pelo sistema para que ele atenda as situações que iremos criar.

O nosso CPF pode ser preenchido com valores numéricos ou não numéricos, gerando erros, então vamos criar as seguintes situações e os retornos das funções:

488.162.388-52->True
488.162.388-51->False
023.870.776-87->True
1->False

Com as situações definidas iremos implementar elas no nosso procedimento de testes TestValidarCPF.

Para inserir os testes você deve sempre iniciar eles pelo método do Rubberduck chamado Assert. Ao digitar ele irá mostrar uma gama de testes que ele pode realizar, iremos utilizar IsFalse e IsTrue para os nossos testes.

Agora insira os seguintes códigos:

    Assert.IsTrue ValidaCPF("488.162.388-52"), "Teste 1"
    Assert.IsFalse ValidaCPF("488.162.388-51"), "Teste 2"
    Assert.IsTrue ValidaCPF("023.870.776-87"), "Teste 3"
    Assert.IsFalse ValidaCPF("1"), "Teste 4"

Note que ao inserir o intelisense demostra que também pode ser colocada uma mensagem para cada teste, ela é opcional mas pode ser interessante de se colocar em algumas situações.

Aplicando o teste unitário

Já estamos prontos para realizar o teste e verificar se o nosso procedimento de validação de CPF funciona como deveria.

1. Clique em Rubberduck->Unit Tests->Text Explorer, se não aparecer a linhar com o teste clique no primeiro ícone de Refresh em azul.

2. Clique em Run e selecione a opção Run All Tests. O sistema irá realizar todos os testes e caso haja algum erro na validação ele irá retornar um erro.

Perceba que ao haver um erro o sistema apresenta a descrição do teste em que houve a falha, neste caso forçamos a validação do item 3 como IsFalse ao invés de IsTrue apenas para demonstrar o erro.

Conclusão

A realização de testes unitários é uma ferramenta sensacional para aumentar a qualidade de seus projetos em Excel VBA.

Pela minha experiência a forma mais simples de se criar os testes unitários é criá-los á medida que o sistema vai sendo criado, a cada nova função ou método, pois os requisitos estão frescos e você evitará debugar código tentando localizar erros no projeto final que poderiam ter sido evitados e principalmente que possam surgir para o cliente.

Abraço

Macos Rieper

Referências: BernardVukas.com, Rubberduckvba.com

Curso Excel Completo – Do Básico ao VBA

Quer aprender Excel do Básico, passando pela Avançado e chegando no VBA? Clique na imagem abaixo:

Avalie este post