Como aumentar o import da suite de teste no TestLink

Quando tentamos importar uma suite de testes para outro Projeto, muita das vezes a suite é maior que o permitido por padrão. Aconteceu comigo a pouco tempo, devemos fazer as alterações abaixo, para suportar 10 Mbytes e não termos mais problemas.

No config.inc.php, vamos alterar as seguintes linhas:

-> Tamanho Máximo que podemos Importar
/** Maximum uploadfile size to importing stuff in TL */

$tlCfg->import_file_max_size_bytes = ‘409600’;

-> Numero Máximo de Linhas que podem ser importadas
// the maximum allowed file size for each repository entry, default 1MB.

$tlCfg->import_max_row = ‘10000’; // in chars




-> O Máximo tamanho permitido para cada repositório.
// the maximum allowed file size for each repository entry

$tlCfg->repository_max_filesize = 1; //MB 


Para os valores 10485760, 100000, 10  :

$tlCfg->import_file_max_size_bytes = ‘10485760’;
$tlCfg->import_max_row = ‘100000’; // in chars
$tlCfg->repository_max_filesize = 10; //MB

No php.ini, vamos alterar as seguintes linhas, para os valores abaixo:

max_execution_time = 1800
upload_max_filesize = 50M
post_max_size = 50M
memory_limit = 128M

No linux o caminho:
sudo gedit /etc/php5/apache2/php.ini



Por precaução vamos para o serviço do apache e iniciar novamente:

Em Linux:
/etc/init.d/apache2 stop
/etc/init.d/apache2 restart

** Use o sudo caso der problema de permissão.

Python vs Java na Automação de Testes

   A muito tempo quero fazer uma comparação entre Python e Java para automação de testes. Vejo que a maioria dos treinamento são em Java para automação de testes. No entanto as outras linguagens são esquecidas como Python principalmente, é pouco falado e disseminado entre as empresas, sendo que Python é muito mais rápido a linha de aprendizado que Java.  No entanto o aprendizado em Java leva muito mais tempo e treinamento. 

   Vamos falar do ponto mais importante que é produtividade.  Fiz um pequeno teste usando a própria ferramenta do Selenium IDE pra medir a produtividade, medindo pela quantidade de linhas de código gerada pela própria ferramenta, exportando para as devidas linguagem.

Passo 01: 
Foram gravado os seguintes passos:
1. Abrir o google;
2. Pesquisar pelo assunto "Amazon";
3. Selecionar o Link e em seguida pesquisar pelo assunto "Python";
4. Selecionar o livro "Use a Cabeça! Python";
5. Clicar no botão "adicione ao carrinho".

Passo 02:
Agora vamos exportar o script gerado, seguindo as opções "Arquivo - Exportar Teste como..."
Vamos exportar com as opções abaixo:
 Python 2 / unittest / WebDriver
Java / Unit 4 / WebDriver

Passo 03:
Agora vamos abrir com o notepad++ e avaliar a quantidade de linhas de código:
Python - 55 Linhas - 2133 Caracteres
Java - 77 Linhas - 2233 Caracteres

Analisando o código gerado a ferramenta criou o método main do python pra fazer a chamada da classe e no java ela não fez isso, fazendo o mesmo a quantidade de linhas no java ia ser bem maior.

if __name__ == "__main__":
    unittest.main()

Quantidade de imports, vemos que no Python temos 7 linhas de import e no java temos 8 linhas.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import Select
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoAlertPresentException
import unittest, time, re

Otimizado um pouco o nosso código ficaria com 3 linhas e funcionaria de boa, não sendo necessário as outras:

from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException, NoAlertPresentException
import unittest, time, re

No Python não precisamos colocar ; no final das variáveis, pelo que contei no código em java tivemos 38 ponto e vírgula, isso é desvantagem, sem falar dos parentheses. Uma característica marcada no Python é a identação do código é obrigatório que o código esteja alinhado de forma correta, isso facilita muito a manutenção do código, se torna fácil de entender a lógica e os loops, no caso do java a ferramenta fez a organização do código, mas não é assim que os desenvolvedores fazem, dificilmente você vai encontrar um código bem arrumado.

No código abaixo não sei porque a ferramenta criou driver = self.driver, podemos muito bem usar direto self.driver em todas as linhas, não precisando criar driver = self.driver, removemos com isso mais uma linha ficando com 50 linhas / 1970 Caracteres do nosso código, contra 77 linhas / 2233 Caracteres do java, aqui vemos 263 Caracteres que em python podemos ser mais produtivo que em Java. 
   É claro que é meio difícil medir a produtividade, simplesmente porque cada pessoa tem a sua velocidade e existe a IDEs como Eclipse e Pycharm que tem o code completion, Java é uma linguagem muito poderosa, mas na automação de testes não utilizamos nem 30% dela, no entanto Java é muito mais verboso e tem um tempo maior de aprendizado que Python. No meu caso, eu codifico scripts de testes em Python, posso dizer que é muito prático e rápido de codificar, no Python você pode usar o extend em mais de uma classe, no Java você não consegue isso, mas existe outras formas pra contornar em java, mas não de forma prática como no Python.
 

Código em Python:

# -*- coding: utf-8 -*-from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException, NoAlertPresentException
import unittest, time, re

class SeliniumPython(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Firefox()
        self.driver.implicitly_wait(30)
        self.base_url = "https://www.google.com.br/"        self.verificationErrors = []
        self.accept_next_alert = True        def test_selinium_python(self):
        self.driver.get(self.base_url + "/search?q=amazon&ie=utf-8&oe=utf-8&gws_rd=cr&ei=2JXKVZSXDMKXgwSSnLWYAw")
        self.driver.find_element_by_link_text("Amazon.com.br: compre livros, eBooks, e-readers Kindle e ...").click()
        self.driver.find_element_by_id("twotabsearchtextbox").click()
        self.driver.find_element_by_id("twotabsearchtextbox").clear()
        self.driver.find_element_by_id("twotabsearchtextbox").send_keys("python")
        self.driver.find_element_by_css_selector("input.nav-input").click()
        self.driver.find_element_by_xpath("//li[@id='result_3']/div/div/div/div[2]/div/a/h2").click()
        self.driver.find_element_by_id("bb_atc_button").click()
    
    def is_element_present(self, how, what):
        try: self.driver.find_element(by=how, value=what)
        except NoSuchElementException, e: return False 

        return True    

    def is_alert_present(self):
        try: self.driver.switch_to_alert()
        except NoAlertPresentException, e: return False

        return True

    def close_alert_and_get_its_text(self):
        try:
            alert = self.driver.switch_to_alert()
            alert_text = alert.text
            if self.accept_next_alert:
                alert.accept()
            else:
                alert.dismiss()
            return alert_text
        finally: self.accept_next_alert = True

    def tearDown(self):
        self.driver.quit()
        self.assertEqual([], self.verificationErrors)

if __name__ == "__main__":
    unittest.main()

Código em Java:

package com.example.tests;
import java.util.regex.Pattern;
import java.util.concurrent.TimeUnit;
import org.junit.*;
import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.*;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.support.ui.Select;

public class SeleniumJava {
  private WebDriver driver;
  private String baseUrl;
  private boolean acceptNextAlert = true;
  private StringBuffer verificationErrors = new StringBuffer();

  @Before
  public void setUp() throws Exception {
    driver = new FirefoxDriver();
    baseUrl = "https://www.google.com.br/";
    driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
  }

  @Test
  public void testSeleniumJava() throws Exception {
    driver.get(baseUrl + "/search?q=amazon&ie=utf-8&oe=utf-8&gws_rd=cr&ei=2JXKVZSXDMKXgwSSnLWYAw");
    driver.findElement(By.linkText("Amazon.com.br: compre livros, eBooks, e-readers Kindle e ...")).click();
    driver.findElement(By.id("twotabsearchtextbox")).click();
    driver.findElement(By.id("twotabsearchtextbox")).clear();
    driver.findElement(By.id("twotabsearchtextbox")).sendKeys("python");
    driver.findElement(By.cssSelector("input.nav-input")).click();
    driver.findElement(By.xpath("//li[@id='result_3']/div/div/div/div[2]/div/a/h2")).click();
    driver.findElement(By.id("bb_atc_button")).click();
  }

  @After
  public void tearDown() throws Exception {
    driver.quit();
    String verificationErrorString = verificationErrors.toString();
    if (!"".equals(verificationErrorString)) {
      fail(verificationErrorString);
    }
  }

  private boolean isElementPresent(By by) {
    try {
      driver.findElement(by);
      return true;
    } catch (NoSuchElementException e) {
      return false;
    }
  }

  private boolean isAlertPresent() {
    try {
      driver.switchTo().alert();
      return true;
      catch (NoAlertPresentException e)
      return false;
    
  }

  private String closeAlertAndGetItsText() {
    try {
      Alert alert = driver.switchTo().alert();
      String alertText = alert.getText();
      if (acceptNextAlert) {
        alert.accept();
      } else {
        alert.dismiss();
      }
      return alertText;
    } finally {
      acceptNextAlert = true;
    }
  }
}

Criando uma classe Email para Report de problemas nos Testes.

   É muito útil você receber um Relatório mostrando o momento exato que aconteceu o problema/bug nos testes automatizados, para isso vamos fazer uma classe email, enviando para a mesma os parâmetros que desejamos receber, num eventual teste de estresse é essencial saber a duração, o tempo que durou a aplicação em um determinado teste de estresse/carga, para constar em nosso relatório. Como somos fera, vamos criar em Python o código de envio de email, criando uma conexão SMTP (Simple Mail Transfer Protocol) client session, o que quer dizer isso, bom vamos criar uma conta do google e ele  vai retransmitir mensagens enviadas para o nosso destinatário. 

   O legal de enviar um email de erro, você pode receber no celular é você não precisar checar o tempo todo os seus testes e nem parar todos os testes automatizados por causa de um erro.

Para mais detalhes leia a página abaixo:
SMTP Google


# -*- coding: utf-8 -*-
"""
Autor: Reinaldo M. R. J
Data: 08-08-2015
Desc: Classe para enviar o report dos testes.
"""
from utils.common import *
# Import the email modules we'll need
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email import Encoders
from email.mime.text import MIMEText
from email.utils import COMMASPACE, formatdate
from email.mime.image import MIMEImage
# Import smtplib for the actual sending function
import smtplib
import os


class test_Report:

    def __init__(self):
        self.common = FunctionsVariables()

    def email_file(self,path_full, file_name):

        try:
            # Create the container (outer) email message.
            msg = MIMEMultipart()
            # In SUBJECT
            SUBJECT = "Report of Sanity Test"
            msg['Subject'] = SUBJECT
            msg['From'] = "xxxx@gmail.com"
            # Aqui vai conter nosso destinatario.
            msg['To'] = "reinaldo.rossetti@outlook.com"
            msg['Date'] = formatdate(localtime = True)
            # No MIMEText vamos digitar o que vai conter no corpo do email.
            msg.attach(MIMEText('Sanity teste finalizado com Sucesso.,'
                                 ' Verifique o resultado em anexo.'))

            part = MIMEBase('application', "octet-stream")
            part.set_payload(open(path_full, "rb").read())
            Encoders.encode_base64(part)
            part.add_header('Content-Disposition', 'attachment; filename='\
                            + file_name)
            msg.attach(part)
            # Configuração do smtp do gmail e porta.
            server = smtplib.SMTP('smtp.gmail.com', 587)
            server.ehlo()
            server.starttls()
            server.login(msg['From'], 'digite a senha aqui')
            try:
                # Python 3.2.1
                server.send_message(msg)
            except AttributeError:
                # Python 2.7.2
                server.sendmail(msg['From'], [msg['To']], msg.as_string())
                print "Enviado com Sucesso!"
            finally:
                server.quit()
        except (RuntimeError, TypeError, NameError):
                print "Unexpected error:", sys.exc_info()[0]
                raise

    def SendEmailFalha (self, testCaseNumber, testCaseName, \
                        duration, result, path_full, img_name):

        try:
            # Create the container (outer) email message.
            msg = MIMEMultipart()
            destination = ("reinaldo.rossetti@outlook.com", "reiload@gmail.com")
            text = ("Number of Test: " + str(testCaseNumber) + " Result: "\
                    + str(result) + "\nTest Device: " + testCaseName \
                    + "\nDuration DAYS:HOURS:MIN: " + str(duration))

            msg['Subject'] = "Status dos Testes - " + str(testCaseName) +\
                             " Result: " + str(result)
            msg['From'] = "xxxx@gmail.com"
            msg['To'] = ','.join(destination)
            texto = MIMEText(text, 'plain')

            file = path_full
            fp = open(file, 'rb')
            img = MIMEImage(fp.read())
            fp.close()
            img.add_header('Content-Disposition', 'attachment',
                           filename=img_name)
            msg.attach(texto)
            msg.attach(img)

            # Send the email via our own SMTP server.
            s = smtplib.SMTP('smtp.gmail.com', 587)
            s.ehlo()
            s.starttls()
            s.login(msg['From'], 'digite aqui sua senha')

            try:
                # Python 3.2.1
                s.send_message(msg)
            except AttributeError:
                # Python 2.7.2
                s.sendmail(msg['From'], [msg['To']], msg.as_string())
                print "Enviado com Sucesso!"
            finally:
                s.quit()
        except (RuntimeError, TypeError, NameError):
                print "Unexpected error:", sys.exc_info()[0]
                pass

if __name__ == '__main__':
    test = test_Report()
    test.SendEmailFalha("Test-333", "Stress TestX", "00:12:00",
                        "False","D:\Minhas imagens\conferirCONCD006.png", "conferirCONCD006.png")



No nosso código foi incluído um try e um except com pass, isso quer disser se tivemos algum erro, ele vai mostrar o error e vai passar na função não parando o código em eventual erro, outra coisa interessante do nosso código é a versão do Python 2.7.x e 3.x as funções são diferentes, dessa forma feita não vai dar problema com as diferentes versões. Outra boa prática séria usar remover variáveis que podem mudar no nosso código, como os email do Destinatário, podemos colocar todas essas variáveis em FunctionsVariables, e apagamos a linha em nosso código, naquele momento do aperreio temos um única classe com todas as variáveis que podem mudar.

Exemplo in functions_variables.py
class functionsVariables(object):
   global destination
   destination = ("reinaldo.rossetti@outlook.com", "reiload@gmail.com")

O Nosso Resultado Final é esse abaixo:

Grandes ferramentas para o Testador

Criando um Bom Plano de Teste

   Na Engenharia de Testes na fase de Planejamento devemos criar um Plano de Testes conciso e eficaz, adotando a metodologia ágil. O que isso quer dizer?, deve conter no documento aquilo que realmente tem valor para as pessoas interessadas no projeto. Não adianta escrever um documento de 50 páginas aonde ninguém vai ler ou dar valor.
   O plano de testes funciona como um contrato entre os times envolvidos, então deve ser claro e conciso e ao mesmo tempo venha trazer eficácia para o time de testes. Para isso você precisa entender os Artefatos/Documentos gerados no desenvolvimento do sistema, segue os principais abaixo:

• Artefatos de Entrada:

– Plano do projeto ;
– Requisitos funcionais e não-funcionais ;
– Documentação referente aos projetos/sistemas relacionados.



Agora vamos falar de Boas Práticas:

• Sempre usar ferramentas para Gestão dos Testes e Bug Tracker (TestLink, JIRA, TestRail, Mantis, Bugzilla, etc);
• Envolver os profissionais de testes desde a elicitação inicial dos requisitos do software (workshops);
• Definir uma estratégia para priorização dos testes com foco no negócio do software (priorizar requisitos mais importantes);
• Descrever bem o que a área de Testes vai fazer e não vai fazer;
• Descrever bem os Critérios de Suspensão da versão.
• É algo fundamental colocar as Premissas e Acordos entre as áreas envolvidas, um exemplo seria: 

"Fica acordado que o analista de Sistemas/Negócio que conhece bem do sistema e ou arquiteto do projeto deverão prestar consultoria em pelo menos 1h diária, para a equipe de testes em casos de dúvidas geradas na revisão dos documentos, e na criação do Plano de Teste como também na criação do Ambiente para a realização dos Testes."

• Outra coisa muito importante é não esquecer de criar um Plano de Testes que contém os requisitos não funcionais do projeto, como Testes de Segurança e Performance, problema aqui põem todo projeto a perder.

Na minha Pós-graduação em testes de Software o professor pediu para fazer um plano de testes e criar o desenho do sistema. De acordo com professor está de Acordo com o esperado de  um bom  plano de testes, seguindo o que ele faz no Instituto CESAR de Curitiba.

Existe outra forma de fazer um Plano de Teste, Planos de Testes por Iteração, são Planos de Testes enxutos pra cada Iteração do Projeto.

Segue um exemplo do que seria um Plano de Teste em 18 páginas, coloquei referências bibliográficas para melhor aprofundamento no assunto, não sendo necessário colocar no plano de testes:
Plano de Testes - LINK

https://en.wikipedia.org/wiki/Test_plan