Apache ANT com Selenium: tutorial completo

O que é formiga Apache?

Ao criar um produto de software completo, é necessário cuidar de diferentes APIs de terceiros, seu caminho de classe, limpeza de arquivos binários executáveis ​​anteriores, compilação de nosso código-fonte, execução de código-fonte, criação de relatórios e base de código de implantação, etc. feito um por um manualmente, levará muito tempo e o processo estará sujeito a erros.

Aí vem a importância de uma ferramenta de construção como o Ant. Ele armazena, executa e automatiza todos os processos em uma ordem sequencial mencionada no arquivo de configuração do Ant (geralmente build.xml).

Formiga Apache

Benefício da construção Ant

  1. Ant cria o ciclo de vida do aplicativo, ou seja, limpar, compilar, definir dependências, executar, relatar, etc.
  2. A dependência da API de terceiros pode ser definida pelo Ant, ou seja, o caminho de classe de outro arquivo Jar é definido pelo arquivo de construção Ant.
  3. Um aplicativo completo é criado para entrega e implantação ponta a ponta.
  4. É uma ferramenta de construção simples onde todas as configurações podem ser feitas usando arquivo XML e que pode ser executada a partir da linha de comando.
  5. Isso torna seu código limpo, pois a configuração é separada da lógica real do aplicativo.

Como instalar o Ant

Steps to install Ant in Windows é o seguinte

Passo 1) Acesse https://ant.apache.org/bindownload.cgi Ou baixe o arquivo .zip de apache-ant-1.9.4-bin.zip

Instalar formiga

Passo 2) Descompacte a pasta e copie o caminho para a raiz da pasta descompactada

Instalar formiga

Passo 3) Vá em Iniciar -> Computador -> clique com o botão direito aqui e selecione 'Propriedades' e clique em Configurações Avançadas do Sistema

Instalar formiga

Passo 4) Uma nova janela é aberta. Clique no botão 'Variável de ambiente…'.

Instalar formiga

Passo 5) Clique no botão 'Novo…' e defina o nome da variável como 'ANT_HOME' e o valor da variável como o caminho raiz para a pasta descompactada e clique em OK.

Instalar formiga

Passo 6) agora selecione a variável 'Path' na lista e clique em 'Editar' e anexe; %ANT_HOME%\bin.

Instalar formiga

Reinicie o sistema uma vez e você estará pronto para usar a ferramenta de construção Ant agora.

Passo 7) Para verificar a versão do seu Ant usando a linha de comando:

Versão Ant

Instalar formiga

Compreendendo o Build.xml

Build.xml é o componente mais importante da ferramenta de construção Ant. Para Java projeto, todas as tarefas relacionadas à limpeza, configuração, compilação e implantação são mencionadas neste arquivo em formato XML. Quando executamos este arquivo XML usando linha de comando ou qualquer plugin IDE, todas as instruções escritas neste arquivo serão executadas de maneira sequencial.

Vamos entender o código em um exemplo build.XML

  • A tag do projeto é usada para mencionar o nome do projeto e o atributo basedir. O basedir é o diretório raiz de um aplicativo
    <project name="YTMonetize" basedir=".">
  • Tags de propriedade são usadas como variáveis ​​no arquivo build.XML para serem usadas em etapas posteriores
<property name="build.dir" value="${basedir}/build"/>
		<property name="external.jars" value=".\resources"/>
	<property name="ytoperation.dir" value="${external.jars}/YTOperation"/>
<property name="src.dir"value="${basedir}/src"/>
  • Tags de destino usadas como etapas que serão executadas em ordem sequencial. O atributo Name é o nome do destino. Você pode ter vários destinos em um único build.xml
    <target name="setClassPath">
  • tag path é usada para agrupar logicamente todos os arquivos que estão no local comum
    <path id="classpath_jars">
  • A tag pathelement definirá o caminho para a raiz do local comum onde todos os arquivos são armazenados
    <pathelement path="${basedir}/"/>
  • Tag pathconvert usada para converter caminhos de todos os arquivos comuns dentro da tag path para o formato de caminho de classe do sistema
    <pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
  • tag de conjunto de arquivos usada para definir o caminho de classe para diferentes jars de terceiros em nosso projeto
    <fileset dir="${ytoperation.dir}" includes="*.jar"/>
  • A tag Echo é usada para imprimir texto no console
<echo message="deleting existing build directory"/>
  • Excluir tag limpará os dados de determinada pasta
<delete dir="${build.dir}"/>
  • A tag mkdir criará um novo diretório
	<mkdir dir="${build.dir}"/>
  • Tag javac usada para compilar o código-fonte java e mover arquivos .class para uma nova pasta
        <javac destdir="${build.dir}" srcdir="${src.dir}">
	<classpath refid="classpath_jars"/>
</javac>
  • tag jar criará um arquivo jar a partir de arquivos .class
	<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">
  • tag de manifesto definirá sua classe principal para execução
<manifest>
		<attribute name="Main-Class" value="test.Main"/>
</manifest>
  • Atributo 'depends' usado para fazer com que um alvo dependa de outro alvo
<target name="run" depends="compile">
  • A tag java executará a função principal do jar criado na seção de destino de compilação
<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>

Execute o Ant usando Eclipse plug-in

Para executar o Ant de eclipse vá para o arquivo build.xml -> clique com o botão direito no arquivo -> Executar como… -> clique em Construir arquivo

Execute o Ant usando Eclipse Plugin

Exemplo

Tomaremos um pequeno programa de amostra que explicará a funcionalidade do Ant de forma muito clara. Nossa estrutura de projeto será semelhante a -

Execute o Ant usando Eclipse Plugin

Aqui neste exemplo temos 4 alvos

  1. Definir caminho de classe para jars externos,
  2. Limpe o código previamente cumprido
  3. Compilar código java existente
  4. Execute o código

Guru99AntClass.class

package testAnt;		
import java.util.Date;		

public class Guru99AntClass {				
   public static void main(String...s){									       
		System.out.println("HELLO GURU99 ANT PROGRAM");					        
		System.out.println("TODAY's DATE IS->"+ currentDate() );					  
}		    		   
public static String currentDate(){					        
	return new Date().toString();					  
	}		
}

Construir.xml

 
<?xml version="1.0" encoding="UTF-8"	standalone="no"?>									
<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->	

<project name="YTMonetize" basedir=".">								
     <!--Property tags will be used as variables in build.xml file to use in further steps-->		

	<property name="build.dir" value="${basedir}/build"/>								
    <property name="external.jars" value=".\resources"/>								
		<property name="ytoperation.dir" value="${external.jars}/YTOperation"/>
<property name="src.dir"value="${basedir}/src"/>
<!--Target tags used as steps that will execute in sequential order. name attribute will be the name  of the target and < a name=OLE_LINK1 >'depends' attribute used to make one target to depend on another target -->		
	       <target name="setClassPath">					
			<path id="classpath_jars">						
				<pathelement	path="${basedir}/"/>					
			</path>				         
<pathconvert	pathsep=";"property="test.classpath" refid="classpath_jars"/>	
</target>				
	<target name="clean">						
		<!--echo tag will use to print text on console-->		
		<echo message="deleting existing build directory"/>						
		<!--delete tag will clean data from given folder-->		
		<delete dir="${build.dir}"/>						
	</target>				
<target name="compile" depends="clean,setClassPath">								
	<echo message="classpath:${test.classpath}"/>					
			<echo message="compiling.........."/>						
	<!--mkdir tag will create new director-->							
	<mkdir dir="${build.dir}"/>						
		<echo message="classpath:${test.classpath}"/>						
		<echo message="compiling.........."/>						
	<!--javac tag used to compile java source code and move .class files to a new folder-->		
	<javac destdir="${build.dir}" srcdir="${src.dir}">								
			<classpath refid="classpath_jars"/>						
	</javac>				
	<!--jar tag will create jar file from .class files-->		
	<jar	destfile="${ytoperation.dir}/YTOperation.jar"basedir="${build.dir}">								
	            <!--manifest tag will set your main class for execution-->		
						<manifest>				
							<attribute name="Main-Class" value="testAnt.Guru99AntClass"/>  
</manifest>		
</jar>				
    </target>				
	<target name="run" depends="compile">								
		<!--java tag will execute main function from the jar created in compile target section-->	
<java jar="${ytoperation.dir}/YTOperation.jar"fork="true"/>			
</target>				
	</project>				

Execute o Ant usando Eclipse plug-in

Como executar o código TestNG usando Ant

Execute o código TestNG usando Ant

Aqui vamos criar uma classe com Teste métodos e definir o caminho da classe para ensaio em build.xml.

Agora, para executar o método testng, criaremos outro arquivo testng.xml e chamaremos esse arquivo do arquivo build.xml.

Passo 1) Nós criamos um “Guru99AntClass.class” no pacote testeAnt

Guru99AntClass.class

package testAnt;
import java.util.Date;
import org.testng.annotations.Test;		
public class Guru99AntClass {				
    @Test		  
	public void Guru99AntTestNGMethod(){					     
		System.out.println("HELLO GURU99 ANT PROGRAM");					
		System.out.println("TODAY's DATE IS->"+ currentDate() );					
	}		
	public static String currentDate(){					
		return new Date().toString();					
	}		
}		

Etapa 2) Crie um destino para carregar esta classe em Build.xml

<!-- Load testNG and add to the class path of application -->
	<target name="loadTestNG" depends="setClassPath">
<!—using taskdef  tag we can add a task to run on the current project. In below line, we are adding testing task in this project. Using testing task here now we can run testing code using the ant script -->
		<taskdef resource="testngtasks" classpath="${test.classpath}"/>
</target>

Passo 3) Crie testng.xml

testeng.xml

<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="YT"thread-count="1">
			<test name="GURU99TestNGAnt">
			<classes>
			   <class name="testAnt.Guru99AntClass">
	</class>
</classes>
</test>
</suite>

Passo 4) Crie um destino em Build.xml para executar este código TestNG

<target name="runGuru99TestNGAnt" depends="compile">
<!-- testng tag will be used to execute testng code using corresponding testng.xml file. Here classpath attribute is setting classpath for testng's jar to the project-->
	<testng classpath="${test.classpath};${build.dir}">
<!—xmlfileset tag is used here to run testng's code using testing.xml file. Using includes tag we are mentioning path to testing.xml file-->
	 <xmlfileset dir="${basedir}" includes="testng.xml"/>
</testng>				

Passo 5) O Build.xml completo

<?xml version="1.0"encoding="UTF-8"standalone="no"?>
<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->
			<project name="YTMonetize" basedir=".">
		       <!--Property tags will be used as variables in build.xml file to use in further steps-->
			<property name="build.dir"value="${basedir}/build"/>
<!-- put  testng related jar in the resource  folder -->
	      <property name="external.jars" value=".\resource"/>
				<property name="src.dir" value="${basedir}/src"/>
<!--Target tags used as steps that will execute in  sequential order. name attribute will be the name
    of the target and 'depends' attribute used to make one target to depend on another target-->
<!-- Load testNG and add to the class path of application -->
         <target name="loadTestNG"depends="setClassPath">
				<taskdef resource="testngtasks"classpath="${test.classpath}"/>
		</target>
		<target name="setClassPath">
		       <path id="classpath_jars">
					<pathelement path="${basedir}/"/>
					<fileset dir="${external.jars}" includes="*.jar"/>
         </path>
        <pathconvert pathsep=";"property="test.classpath"refid="classpath_jars"/>
	</target>
	<target name="clean">
              <!--echo tag will use to print text on console-->
	               <echo message="deleting existing build directory"/>
               <!--delete tag will clean data from given folder-->
	               <delete				dir="${build.dir}"/>
			</target>
<target name="compile"depends="clean,setClassPath,loadTestNG">
	         <echo message="classpath:${test.classpath}"/>
	               <echo	message="compiling.........."/>
		       <!--mkdir tag will create new director-->
		        <mkdir dir="${build.dir}"/>
					<echo message="classpath:${test.classpath}"/>
			<echo message="compiling.........."/>
	<!--javac tag used to compile java source code and move .class files to a new folder-->
	        <javac destdir="${build.dir}"srcdir="${src.dir}">
	             <classpath refid="classpath_jars"/>
		</javac>
  </target>
<target name="runGuru99TestNGAnt"depends="compile">
		<!-- testng tag will be used to execute testng code using corresponding testng.xml file -->
			<testng classpath="${test.classpath};${build.dir}">
               <xmlfileset dir="${basedir}"includes="testng.xml"/>
	</testng>
</target>
</project>

Passo 6) saída

Execute o código TestNG usando Ant

Baixe o arquivo acima

Formiga com Selenium Webdriver

Até agora, aprendemos que usando o ANT podemos colocar todos os jars de terceiros em um local específico do sistema e definir seu caminho para o nosso projeto. Usando este método, estamos definindo todas as dependências do nosso projeto em um único local e tornando-o mais confiável para compilação, execução e implantação.

Da mesma forma, para nossos projetos de teste usando Selenium, podemos facilmente mencionar a dependência de Selenium em build.xml e não precisamos adicionar um caminho de classe manualmente em nosso aplicativo.

Portanto, agora você pode ignorar a maneira tradicional mencionada abaixo de definir caminhos de classe para o projeto.

Formiga com Selenium Webdriver

Exemplo:

Vamos modificar o exemplo anterior

Passo 1) Defina a propriedade selenium.jars como jar relacionado ao selênio na pasta de recursos

		<property name="selenium.jars" value=".\selenium"/>

Passo 2) No setClassPath de destino, adicione os arquivos Selenium

<target name="setClassPath">
	        <path id="classpath_jars">
				<pathelement path="${basedir}/"/>	
				<fileset dir="${external.jars}" includes="*.jar"/>
	            <!-- selenium jar added here -->
  		            <fileset dir="${selenium.jars}" includes="*.jar"/>
         </path>		

Passo 3) Complete Build.xml:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->
			<project name="YTMonetize" basedir=".">
                  <!--Property tags will be used as variables in build.xml file to use in further steps-->
				<property name="build.dir" value="${basedir}/build"/>
      <!-- put  testng related jar in the resource  folder -->
	       <property name="external.jars" value=".\resource"/>
<!-- put  selenium related jar in resource  folder -->
     <property name="selenium.jars" value=".\selenium"/>
			<property name="src.dir" value="${basedir}/src"/>
				<!--Target tags used as steps that will execute in  sequential order. name attribute will be the name 
of the target and 'depends' attribute used to make one target to depend on another target-->
      <!-- Load testNG and add to the class path of application -->
       <target name="loadTestNG" depends="setClassPath">
				<taskdef resource="testngtasks" classpath="${test.classpath}"/>
		</target>
<target name="setClassPath">
	        <path id="classpath_jars">
				<pathelement path="${basedir}/"/>
					<fileset dir="${external.jars}" includes="*.jar"/>
			<!-- selenium jar added here -->
	            <fileset dir="${selenium.jars}"includes="*.jar"/>
        </path>
   <pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
</target>
<target name="clean">
<!--echo tag will use to print text on console-->
               <echo message="deleting existing build directory"/>
	                <!--delete tag will clean data from given folder-->
		               <delete dir="${build.dir}"/>
				</target>
<target name="compile" depends="clean,setClassPath,loadTestNG">
         <echo message="classpath:${test.classpath}"/>
                <echo message="compiling.........."/>
        <!--mkdir tag will create new director-->
	        <mkdir dir="${build.dir}"/>
          			<echo message="classpath:${test.classpath}"/>
			<echo message="compiling.........."/>
	<!--javac tag used to compile java source code and move .class files to new folder-->
     <javac destdir="${build.dir}"srcdir="${src.dir}">
             <classpath refid="classpath_jars"/>
	</javac>
</target>
<target name="runGuru99TestNGAnt" depends="compile">
		<!-- testng tag will be used to execute testng code using corresponding testng.xml file -->
			<testng classpath="${test.classpath};${build.dir}">
               <xmlfileset dir="${basedir}" includes="testng.xml"/>
		</testng>
	</target>
</project>

Passo 4) Agora altere a classe Guru99AntClass.java criada anteriormente com o novo código.

Aqui neste exemplo, nossas etapas usando Selenium são:

  1. Acesse http://demo.guru99.com/test/guru99home/
  2. Leia todos os links dos cursos um por um
  3. Imprima o hiperlink de todos os cursos no console.

Guru99AntClass.java:

package testAnt;		
import java.util.List;		
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;	
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.annotations.Test;

public class Guru99AntClass {

	@Test		
		public void Guru99AntTestNGMethod(){
	      WebDriver driver = new FirefoxDriver();	
		  driver.get("http://demo.guru99.com/test/guru99home/");
		  List<WebElement> listAllCourseLinks = driver.findElements(By.xpath("//div[@class='canvas-middle']//a"));							        
          for(WebElement webElement : listAllCourseLinks) {
			System.out.println(webElement.getAttribute("href"));
      	  }
		}
}		

Passo 5) Após a execução bem-sucedida, a saída será semelhante a:

Formiga com Selenium Webdriver

Baixe o arquivo de exemplo acima

Resumo

Ant é uma ferramenta de construção para Java.

Ant usado para compilação de código, implantação e processo de execução.

Ant pode ser baixado em apache .

Arquivo Build.xml usado para configurar destinos de execução usando Ant.

Ant pode ser executado a partir da linha de comando ou de um plugin IDE adequado como eclipse.