Desenvolvimento Código Aberto

A maioria das metodologias disponíveis para o desenvolvimento de software e gerenciamento de projetos incluem como pratica básica essencial o desenvolvimento e execução de testes unitários para que um projeto de desenvolvimento possa passar para próxima fase.

Uma boa execução de um projeto bem elaborado em diversas metodologias utilizam ambientes e exigem que os testes unitários sejam executados no ambiente de desenvolvimento (DEV) utilizando uma ferramenta para este proposito e reexecutados por consultores  funcionais/testadores, na fase de testes unitários no ambiente real de qualidade (QAS) para que só então possam executar a fase de testes integrados antes de aprovarem e homologarem o software para utilização em um ambiente produtivo (PRD).

O teste unitário executado do ponto de vista do setor de qualidade (QAS) é feito validando todas as partes dos software, incluindo, design intuitivo, usabilidade, teclas de atalho, layouts, grafia, links e etc. É claro que existem algumas diferenças sutis entre metodologias, como um ou outro procedimento ou diferentes nomenclaturas mas no final todas possuem o mesmo proposito, um software de qualidade, livre de erros e dentro do orçamento inicial do projeto. Bem! No mundo real, não importa qual a metodologia escolhida, isto nem sempre é possível.

Contudo a SAP possui sua própria metodologia desenvolvida ao longo de 40 anos de experiência no mercado para software corporativo, e muitos destes anos como líder mundial em software empresarial, podemos afirmar que sua metodologia é comprovadamente eficiente e durante a evolução de seu desenvolvimento influenciou muitas outras metodologias de software existentes e vice versa, a nova versão da metodologia SAP também incorporou o DNA dos polêmicos métodos de desenvolvimento ágil e assim o ASAP 8 conta com duas aproximações da metodologia, o  Standard ASAP e Agile ASAP.

ASAP: http://scn.sap.com/community/asap-methodology

ABAP Unit

ABAP Unit é parte do ambiente de teste para programas ABAP. Unidade ABAP permite a implementação de testes de unidade e  execução manual e automática. Testes de unidade ABAP são métodos de classes ABAP especialmente designados. Os métodos de ensaio funcionam como scripts, com o qual o código a ser testado pode ser executado, e com a qual o resultado como em um ensaio pode ser avaliado. ABAP OO é conceitualmente parecido com Java e C++, deste modo os teste unitários ABAP são similares ao JUnit do Java. O ABAP Unit é adequado para desenvolvimento orientado a testes (TDD).

ABAP Unit: Abap Unit Overview

Executando Testes Unitários com  ABAP Unit

Os testes unitários ABAP podem ser escritos para classes ou para funções. Existe dois principais métodos de criar um teste unitário, eles são Global ou Local.

Global :

1 – Abra o Class Builder e crie uma classe chamada ZParticipante, com os seguintes atributos (você pode utilizar o código abaixo para se basear na criação da classe):

2 – Crie os seguintes métodos para a classe:

3 – Na barra de ferramentas clique em Source-Code Based e preencha os métodos para a classe ZParticipante de acordo com  a classe do código abaixo:

4 – Para criar uma classe de testes clique no menu Utilities->Test Class Generation e você será guiado pelo Wizard sobre como criar a classe de teste (Utilize a classe de teste encontrada abaixo para preencher o Wizard e implementar os métodos gerados).

• Para acessar a classe de testes, no menu GO TO->Local Definitions/Implementation-> Local Test Classes.
• Para testar os métodos clique no menu Class Source->Unit Test

Teste Unitário – ABAP Unit – Métodos

Um modo de testar um objeto é testando seus métodos Setters e retornando os métodos Getters como comparação, evitando assim erros de logica no objeto, além destes métodos você pode testar outros métodos do objeto como achar melhor:

1 – Caso não queira utilizar o método Global você pode testar classes locais diretamente de um programa ABAP, entre na transação SE38 e crie um programa chamado ZDAUNITESTE e utilize o código abaixo, compile e teste.

• Para executar o teste unitário na classe, o procedimento é o mesmo do procedimento global, no menu Program->Test->Unit Test.
• Para obter um erro no método substitua o valor de comparação no método ASSERT por um valor diferente do código abaixo:

2 – Corrija o código da classe de teste de acordo com o código abaixo e rode o teste novamente:

Exemplo:

Neste exemplo criamos uma simples classe com métodos Getter e Setter e uma classe de caso de teste para efetuar um teste unitário nos métodos criados.

Obs: O método utilizado para o testar o código abaixo é executado em um programa local, de modo local, caso queira testar classes globais com a classe de teste atrelada a classe testada, utilize os trechos das classes abaixo para criar as classes pelos Wizards do Class Builder como mostra as figuras acima.

ABAP

Classe – Participante

*&---------------------------------------------------------------------*
*& Report  ZDAUNITESTE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Testes unitários - ABAP
*&---------------------------------------------------------------------*

REPORT  ZDAUNITESTE.

* Cria classe Participante
class ZPARTICIPANTE definition.

  public section.

* Declara métodos Getter e Setter

    methods SETNOME importing  !PNOME type STRING .
    methods GETNOME returning value(RESULTADO) type STRING .
    methods SETIDADE importing !PIDADE type I .
    methods GETIDADE returning value(RESULTADO) type I .

  protected section.

* Declara atributos privados
  private section.

    data NOME type STRING .
    data IDADE type I .

ENDCLASS.

* Implementação da classe
CLASS ZPARTICIPANTE IMPLEMENTATION.

*  Metodos Getter e Setter

  METHOD GETIDADE.
    RESULTADO = me->IDADE.
    "Inverta o código acima: me->IDADE = RESULTADO
    "Você vai obter um erro de lógica
    "Passara pelo compilador ABAP
    "Mas não passara pelo teste Unitário
    "Deste modo você previne erros escritos
    "por desatenção ou desenvolvimento emergências
    "como nos Sprints em algumas metodologias

  ENDMETHOD.

  METHOD GETNOME.
    RESULTADO = me->NOME.
  ENDMETHOD.

  METHOD SETIDADE.
    me->IDADE = PIDADE.
  ENDMETHOD.

  METHOD SETNOME.
    me->NOME = PNOME.
  ENDMETHOD.
ENDCLASS.

* testa programa
START-OF-SELECTION.

* Testa Classe
  DATA: p1    TYPE REF TO ZPARTICIPANTE,
        nome  TYPE String,
        idade TYPE i.

* Istancia Objeto
  CREATE OBJECT P1.

* Métodos Setter
  p1->SETNOME( 'Joao da Silva' ).
  p1->SETIDADE( 20 ).

* Métodos Getter
  nome =  P1->GETNOME( ).
  idade = P1->GETIDADE( ).

* Imprime valores
  WRITE: / nome, idade.

* Classe de Teste Unitário.
* Na definição da classe de teste abaixo:
* "#AU Risk_Level Harmless não é um comentário
* e sim um decorador indicando o nível risco do teste
* sem este decorador a classe não testará os métodos.

CLASS ZPARTICIPANTE_TEST DEFINITION FOR TESTING."#AU Risk_Level Harmless

  PUBLIC SECTION.

    METHODS:
      SETNOME FOR TESTING,
      SETIDADE FOR TESTING.

ENDCLASS.

CLASS ZPARTICIPANTE_TEST IMPLEMENTATION.

* Teste unitario para metodos Getter e Setter
  METHOD SETNOME.

    DATA p1 TYPE REF TO ZPARTICIPANTE.
    CREATE OBJECT p1.

    p1->SETNOME('Nome').
    cl_aunit_assert=>ASSERT_EQUALS(
      exporting
        EXP                  =     'Nome'          " Data Object with Expected Type
        ACT                  =     p1->GETNOME( )  " Data Object with Current Value

    ).
  ENDMETHOD.

  METHOD SETIDADE.
    DATA p2 TYPE REF TO ZPARTICIPANTE.
    CREATE OBJECT p2.

    p2->SETIDADE( 20 ).
    cl_aunit_assert=>ASSERT_EQUALS(
      exporting
        EXP                  =     20          " Data Object with Expected Type
        ACT                  =     p2->GETIDADE( )  " Data Object with Current Value

    ).
  ENDMETHOD.

ENDCLASS.