Mostrando postagens com marcador isTest. Mostrar todas as postagens
Mostrando postagens com marcador isTest. Mostrar todas as postagens

sexta-feira, 9 de novembro de 2018

Testando métodos com anotação @future no Salesforce

Ao chamar um método com a anotação @future uma nova thread é criada e enfileirada para ser executada de forma assíncrona à chamada original. Dessa forma, não há qualquer garantia que o conteúdo do método futuro será executado antes ou depois do contexto que o chamou. 

No cenário de método assíncrono surge um "problema": Como criar um método de teste unitário para esse método? Bem, a solução é mais simples do que se imagina: Basta utilizar o Test.StartTest() e o Test.StopTest() e o método assíncrono entre eles. 

A princípio mostro o método que desejo testar (coloquei uma método de espera ocupada só para comprovar a eficácia):


public class ClasseComMetodoFuturo {
    @future
    public static void metodoAssincrono(id idCaso){
        ClasseComMetodoFuturo.sleep(5000);
        
        Case caso = new Case(id = idCaso);
        Caso.Origin = 'Web';
        update caso;
    }
    
    private static void sleep(integer milliseconds){
        Long timeDiff = 0;
        DateTime firstTime = System.now();
        do{
            timeDiff = System.now().getTime() - firstTime.getTime();
        }while(timeDiff <= milliseconds);
    }
}


Agora minha classe de teste:


@isTest
public class ClasseComMetodoFuturoTest {
 public static testmethod void testandoFuture(){
        Case c = new Case();
        insert c;
        
        Test.startTest();
        ClasseComMetodoFuturo.metodoAssincrono(c.id);
        Test.stopTest();
        
        c = [SELECT id, Origin FROM Case WHERE id = :c.id];
        System.assertEquals('Web', c.Origin);
    } 
}



Faça um teste agora, removendo Test.StartTest() e o Test.StopTest(). O Resultado será:


System.AssertException: Assertion Failed: Expected: Web, Actual: null


Isso acontence pois, ao executar o Test.StopTest(), o Salesforce aguarda todas as execuções assíncronas que estão na fila de execução, pendentes para execução. Isto é, o StopTest faz com que seu método de teste aguarde do método @future, podendo assim esperar o resultado.



* Precisa de um suporte ou consultoria com seus códigos Apex na plataforma Salesforce? Entre em contato conosco - CbCloud: http://www.cbcloud.com.br/ - Somos parceiros Gold Salesforce.

quinta-feira, 1 de março de 2018

Removendo espaços em branco de Strings

Normalmente, quando se deseja remover espaços em branco das extremidadas de uma String no Apex, da Salesforce, usamos o método .trim() no objeto string. Porém, caso deseje remover TODOS os espaços em branco da sua String, o trim não resolve. Essa nota metal é exatamente para resolver essa situação e ela é bem simples: Basta usar o replaceAll, substituindo a string \\s+ por vazio. Veja:


String strSemEspaco = 'a b    c d  e'.replaceAll('\\s+', '');



Agora veja um método de teste, como se comportaria:


String strComEspaco = 'a b    c d  e';
String strSemEspaco = 'abcde';
System.assert(strComEspaco != strSemEspaco);
strComEspaco = strComEspaco.replaceAll('\\s+', '');
strSemEspaco = strComEspaco.replaceAll('\\s+', '');
System.assert(strComEspaco == strSemEspaco);



Por hoje é isso!




* Precisa de um suporte ou consultoria nos códigos APEX da Salesforce? Entre em contato conosco - CbCloud: http://www.cbcloud.com.br/ - Somos parceiros gerenciado Salesforce. 

segunda-feira, 5 de junho de 2017

Métodos visíveis apenas para classes de test no Apex - Salesforce

Uma coisa que pode ser muito complicada na execução de um trabalho que envolve codificação Apex no ambiente Salesforce é a necessidade de cobertura de teste (de pelo menos 75% do código). Dependendo do nível de complexidade da classe que se deseja testar, o trabalho de se gerar as condições para cobrir o todo o código, pode ser bem mais desgastante. É quase um consenso entre eu e meus amigos desenvolvedores Salesforce, que é rápido construir a classe, do que sua cobertura de teste! ;) Talvez esteja sendo dramático... mas é quase isso. 

Pensando nesse cenário, suponhamos que tenhamos que testar a classe abaixo (supondo que ela fosse uma classe com uma complexa lógica):


public class LogicaComplexa {
    
    public LogicaComplexa(){}
    
    public void metodoComplexo(){
        //lógica muito complexa e no meio dela você chama um método privado
        this.metodoPrivado();
    }
    
    private void metodoPrivado(){
        //código que precisa ser coberto
    }
}


Veja que no exemplo acima, temos um método privado e um público. Suponhamos que precise testar o método privado, sem ter que passar por toda lógica do método público, que possui uma lógica complexa. O que podemos fazer? Colocar o método público? Nada disso... Para ajudar nesse árduo trabalho que é cobrir 100% de todo o código, temos uma anotação para método Apex, que permite acessarmos um método (para realizar a cobertura de teste) mesmo ele sendo privado (private method). Essa anotação é o @TestVisible. Com ele, mesmo o método sendo privado, é possível acessá-lo por uma classe de teste Apex. Veja com fica esse método:


@TestVisible private void metodoPrivado(){
    //código que precisa ser coberto
}

Com essa annotation @TestVisible, é possível acessar um método privado em uma classe de teste: 


@isTest
private class LogicaComplexaTest {
    @isTest static void teste() {
        LogicaComplexa logica = new LogicaComplexa();
        logica.metodoPrivado();
    }
}


Bem, essa é a dica rápida de hoje.



* Está precisando de um suporte ou uma consultoria nos desenvolvimentos de classes teste Apex dentro da sua plataforma Salesforce? Entre em contato conosco - CbCloud: http://www.cbcloud.com.br/