<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sergio Rubio on Medium]]></title>
        <description><![CDATA[Stories by Sergio Rubio on Medium]]></description>
        <link>https://medium.com/@sfrmack?source=rss-285382f13528------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*jsS9q4USAZYSig4v-GpY2w.jpeg</url>
            <title>Stories by Sergio Rubio on Medium</title>
            <link>https://medium.com/@sfrmack?source=rss-285382f13528------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 16:31:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sfrmack/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Automação de testes para Mainframe: Padrões de projeto com f3270]]></title>
            <link>https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-padr%C3%B5es-de-projeto-com-f3270-e10aba302f03?source=rss-285382f13528------2</link>
            <guid isPermaLink="false">https://medium.com/p/e10aba302f03</guid>
            <category><![CDATA[ibm]]></category>
            <category><![CDATA[automation-testing]]></category>
            <category><![CDATA[junit]]></category>
            <category><![CDATA[ibm-z]]></category>
            <category><![CDATA[ibm-i]]></category>
            <dc:creator><![CDATA[Sergio Rubio]]></dc:creator>
            <pubDate>Wed, 18 Aug 2021 02:24:28 GMT</pubDate>
            <atom:updated>2021-08-18T02:24:28.424Z</atom:updated>
            <content:encoded><![CDATA[<h4>Implementando os padrões Terminal Factory e Page Objects para a criação de projetos de automação para Mainframe mais escaláveis e robustos.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/0*L2rtAT5ouygM4xW5" /><figcaption>Servidor IBM z. Fonte: <a href="https://www.solutions-magazine.com/ibm-z-12-milliards-transactions-cryptees/">IBM Z, plus de 12 milliards de transactions cryptées par jour ! (solutions-magazine.com)</a></figcaption></figure><p>No artigo anterior, quando foi explicado sobre <a href="https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-utilizando-a-biblioteca-f3270-44fa03bc0b4b">automação de testes para Mainframe utilizando f3270</a>, implementei um exemplo bem simplificado de automação, e foram observadas diversas semelhanças com uma automação de testes para Web utilizando Selenium.</p><p>Neste artigo, desenvolverei melhor este projeto, indo além do simples exemplo da tela de login, e vamos utilizar os padrões de projetos <em>Driver Factory </em>(trataremos aqui como <em>Terminal Factory</em>) e <em>Page Objects</em>.</p><h3>Implementação do Terminal Factory</h3><p>Vou utilizar o exemplo descrito neste ótimo artigo: <a href="https://santiautomation.github.io/framework/2020/08/14/Driver-Factory.html">Driver Factory (santiautomation.github.io)</a>, aonde temos o seguinte diagrama de classes que resume a implementação do Driver Factory:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6C2YFYOHwkpeuDgA.PNG" /><figcaption>Diagrama de classes para implementação do Driver Factory. Fonte: <a href="https://santiautomation.github.io/framework/2020/08/14/Driver-Factory.html">Driver Factory (santiautomation.github.io)</a></figcaption></figure><p>Traduzindo para a implementação do que chamarei aqui de <em>Terminal Factory</em>, utilizando a classe <em>Terminal</em> do f3270 ao invés da classe <em>WebDriver</em> do Selenium, o diagrama de classes fica da seguinte maneira:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/421/1*RcQz65lgwvS3AWPxAYlOyA.png" /><figcaption>Diagrama de classes para implementação do <em>Terminal Factory</em></figcaption></figure><p>Implementarei as classes partindo do projeto criado no artigo <a href="https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-utilizando-a-biblioteca-f3270-44fa03bc0b4b">Automação de testes para Mainframe: Utilizando a biblioteca f3270</a>, Todas as classes descritas no diagrama serão criadas no pacote <em>terminal</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/312/1*VzO4Mv3pTX8ONXVSYIpNcA.png" /><figcaption>Pacote “terminal”, contendo as classes descritas no diagrama de classes</figcaption></figure><p>Segue abaixo a implementação da classe abstrata <em>TerminalManager</em>, contendo os métodos necessários para criar, finalizar e obter o <em>Terminal</em>:</p><pre>package terminal;<br><br>import net.sf.f3270.Terminal;<br><br>public abstract class TerminalManager {<br><br>    protected ThreadLocal&lt;Terminal&gt; terminalThread = new ThreadLocal&lt;&gt;();<br>    protected abstract Terminal createTerminal();<br><br>    public void quitTerminal() {<br>        if (terminalThread.get() != null) {<br>            try {<br>                terminalThread.get().disconnect();<br>                terminalThread.remove();<br>            } catch (Exception e) {<br>                System.<em>out</em>.println(&quot;Não foi possivel finalizar o terminal.\n&quot; + e);<br>            }<br>        }<br>    }<br><br>    public Terminal getTerminal() {<br>        if (terminalThread.get() == null) {<br>            terminalThread.set(this.createTerminal());<br>        }<br><br>        return terminalThread.get();<br>    }<br>}</pre><p>Em seguida, a implementação do enumerador <em>TerminalFactory</em>, que retornará o terminal a ser criado (Sim390 ou pub400):</p><pre>package terminal;<br><br>public enum TerminalFactory {<br><br>    <em>SIM390 </em>{<br>        @Override<br>        public TerminalManager getTerminalManager() {<br>            return new Sim390TerminalManager();<br>        }<br>    },<br>    <em>PUB400 </em>{<br>        @Override<br>        public TerminalManager getTerminalManager() {<br>            return new Pub400TerminalManager();<br>        }<br>    };<br><br>    public abstract TerminalManager getTerminalManager();<br>}</pre><p>Por fim, vamos implementar as classes concretas <em>Sim390TerminalManager </em>e <em>Pub400TerminalManager</em>. Ambas farão extensão a classe abstrata <em>TerminalManager</em>:</p><pre>package terminal;<br><br>import net.sf.f3270.*;<br><br>public class Sim390TerminalManager extends TerminalManager {<br><br>    @Override<br>    protected Terminal createTerminal() {<br>        System.<em>out</em>.println(&quot;Starting SIM390 Terminal&quot;);<br>        Terminal terminal = new Terminal(<br>                &quot;s3270/s3270&quot;,<br>                &quot;127.0.0.1&quot;,<br>                23,<br>                TerminalType.<em>TYPE_3279</em>,<br>                TerminalModel.<em>MODE_80_24</em>,<br>                HostCharset.<em>US_INTL</em>,<br>                true);<br>        terminal.connect();<br><br>        return terminal;<br>    }<br>}</pre><p>Exemplifiquei acima somente a classe <em>Sim390TerminalManager</em>, pois a classe que tratará do pub400 é semelhante, somente com a diferença nos parâmetros de conexão.</p><p>Vamos agora efetuar a alteração na classe de testes em questão. Vamos substituir a implementação no método <em>setUp</em>, aonde a conexão ficará a cargo do <em>TerminalFactory</em>. Abaixo, a implementação antes do <em>TerminalFactory</em>:</p><pre>@BeforeAll<br>public static void setUp() {<br>    <em>terminal </em>= new Terminal(<br>            &quot;s3270/s3270&quot;,<br>            &quot;127.0.0.1&quot;,<br>            23,<br>            TerminalType.<em>TYPE_3279</em>,<br>            TerminalModel.<em>MODE_80_24</em>,<br>            HostCharset.<em>US_INTL</em>,<br>            true);<br>    <em>terminal</em>.connect();<br>}</pre><p>Agora, a alteração feita para a utilização do <em>TerminalFactory</em>:</p><pre>@BeforeAll<br>public static void setUp() {<br>    <em>terminal </em>= <em>SIM390</em>.getTerminalManager().getTerminal();<br>}</pre><h3>Implementação dos Page Objects</h3><p>Podemos também tratar cada uma das páginas do sistema como uma classe, assim como fazemos com o padrão <em>Page Objects</em> para o Selenium. Vamos utilizar os exemplos obtidos no seguinte artigo: <a href="https://www.browserstack.com/guide/page-object-model-in-selenium">Page Object Model and Page Factory in Selenium | BrowserStack</a>.</p><p>Para exemplificar a criação de Page Objects com o f3270, vamos primeiro ver a navegação de telas até o acesso ao menu de usuários do Sim390, passando pela tela de login e pelo menu principal:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*No4gsk2fQIDA4p0LiAPGhg.png" /><figcaption>Sequência de telas para o menu de usuários do Sim390</figcaption></figure><p>Como vimos no artigo anterior (<a href="https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-utilizando-a-biblioteca-f3270-44fa03bc0b4b">Automação de testes para Mainframe: Utilizando a biblioteca f3270</a>), podemos utilizar localizadores de elementos da tela, com a declaração de uma variável com o tipo de referência <em>FieldIdentifier</em>. Vide abaixo a implementação da tela de login mais o acesso ao menu de usuários do Sim390, sem a implementação de <em>Page Objects</em>:</p><pre>@Test<br>public void workingWithUserIds() {<br>    //tela inicial<br>    <em>terminal</em>.enter();</pre><pre>    //tela de login e mensagem de confirmação<br>    FieldIdentifier userId = new FieldIdentifier(&quot;MUSIC Userid:&quot;);<br>    <em>terminal</em>.write(userId, &quot;$000&quot;);<br>    FieldIdentifier password = new FieldIdentifier(&quot;Password:&quot;);<br>    <em>terminal</em>.write(password, &quot;music&quot;);<br>    <em>terminal</em>.enter();<br>    <em>terminal</em>.enter();</pre><pre>    //Acesso a tela de usuários pela tela inicial<br>    FieldIdentifier option = new FieldIdentifier(&quot;SELECT OPTION&quot;, 2);<br>    <em>terminal</em>.write(option, &quot;2&quot;);<br>    <em>terminal</em>.enter();<br> <br>    //validação na tela de usuários<br>    Assertions.<em>assertTrue</em>(<em>terminal</em>.getLine(0).contains(&quot;Userid Tasks&quot;));<br>}</pre><p>Vamos criar quatro classes de <em>Page Objects</em>, que ficarão dentro do pacote <em>pages</em>:</p><ul><li><em>SplashScreenPage</em> (Para a tela inicial do Sim390)</li><li><em>LoginPage</em> (Para a tela de login)</li><li><em>MainMenuPage</em> (Para o menu inicial)</li><li><em>UserIdsPage</em> (Para o menu principal de usuários)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*AJreeXj0xpngeT1t3LFZ_Q.png" /><figcaption>Pacote “pages” e classes de Page Objects</figcaption></figure><p>Começando com o <em>SplashScreenPage</em>, aonde deveremos somente digitar “enter”. Obteremos o terminal através do construtor da classe, e utilizar este terminal para executar as ações:</p><pre>public class SplashScreenPage {<br><br>    private Terminal terminal;<br><br>    public SplashScreenPage(Terminal terminal) {<br>        this.terminal = terminal;<br>    }<br><br>    public void goToLoginPage() {<br>        terminal.enter();<br>    }<br>}</pre><p>Na classe <em>LoginPage</em> já utilizamos melhor os conceitos do <em>Page Objects</em>, aonde os atributos das classes serão os localizadores dos elementos da tela:</p><pre>public class LoginPage {<br><br>    private Terminal terminal;<br>    private FieldIdentifier userId = new FieldIdentifier(&quot;MUSIC Userid:&quot;);<br>    private FieldIdentifier password = new FieldIdentifier(&quot;Password:&quot;);<br><br>    public LoginPage(Terminal terminal) {<br>        this.terminal = terminal;<br>    }<br><br>    public void accessSim390() {<br>        terminal.write(userId, &quot;$000&quot;);<br>        terminal.write(password, &quot;music&quot;);<br>        terminal.enter();<br>        terminal.enter();<br>    }<br>}</pre><p>A implementação da classe <em>MainMenuPage</em> segue os mesmos conceitos de localizadores da tela:</p><pre>public class MainMenuPage {<br><br>    private Terminal terminal;<br>    private FieldIdentifier option = new FieldIdentifier(&quot;SELECT OPTION&quot;, 2);<br><br>    public MainMenuPage(Terminal terminal) {<br>        this.terminal = terminal;<br>    }<br><br>    public void accessUserIds() {<br>        terminal.write(option, &quot;2&quot;);<br>        terminal.enter();<br>    }<br>}</pre><p>Por fim, na classe <em>UserIdsPage</em>, implementamos o método para retornar o título da página, com o intuito de efetuar a asserção:</p><pre>public class UserIdsPage {<br><br>    private Terminal terminal;<br><br>    public UserIdsPage(Terminal terminal) {<br>        this.terminal = terminal;<br>    }<br><br>    public String getPageTitle() {<br>        return terminal.getLine(0);<br>    }<br>}</pre><p>Iniciaremos agora a refatoração da classe <em>Sim390Test</em>, movendo o método <em>setUp</em> para a classe abstrata <em>BaseTest</em>, aonde também vamos declarar atributos para cada um dos <em>Page Objects</em>:</p><pre>public abstract class BaseTest {<br>    static SplashScreenPage <em>splashScreenPage</em>;<br>    static LoginPage <em>loginPage</em>;<br>    static MainMenuPage <em>mainMenuPage</em>;<br>    static UserIdsPage <em>userIdsPage</em>;<br><br>    @BeforeAll<br>    public static void setUp() {<br>        Terminal terminal = <em>SIM390</em>.getTerminalManager().getTerminal();<br>        <em>splashScreenPage </em>= new SplashScreenPage(terminal);<br>        <em>loginPage </em>= new LoginPage(terminal);<br>        <em>mainMenuPage </em>= new MainMenuPage(terminal);<br>        <em>userIdsPage </em>= new UserIdsPage(terminal);<br>    }<br>}</pre><p>Por fim, a refatoração da classe <em>Sim390Test</em>. Faremos a extensão para a classe BaseTest, e utilizar os métodos criados nas classes de Page Objects para a execução do teste. Podemos perceber que o método de teste ficou menos procedural e mais legível:</p><pre>public class Sim390Test extends BaseTest {<br><br>    @Test<br>    public void workingWithUserIds() {<br>        <em>splashScreenPage</em>.goToLoginPage();<br>        <em>loginPage</em>.accessSim390();<br>        <em>mainMenuPage</em>.accessUserIds();<br>        String pageTitle = <em>userIdsPage</em>.getPageTitle();<br>        Assertions.<em>assertTrue</em>(pageTitle.contains(&quot;Userid Tasks&quot;));<br>    }<br>}</pre><h3>Repositório de testes</h3><p>Os códigos criados durante esta série de 3 artigos estão publicados no seguinte repositório: <a href="https://github.com/sfrubio/f3270-poc">https://github.com/sfrubio/f3270-poc</a>.</p><h3>Conclusão</h3><p>A utilização de padrões de projetos como o <em>Terminal Factory</em> e <em>Page Objects</em> permite a definição de arquiteturas de teste mais robustas e escaláveis. Por serem padrões bastante disseminados, também permitem a participação de QAs com conhecimentos em automação Web a participar de projetos envolvendo sistemas de Alta Plataforma, trazendo assim práticas mais contemporâneas para os testes de sistemas legados.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e10aba302f03" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automação de testes para Mainframe: Utilizando a biblioteca f3270]]></title>
            <link>https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-utilizando-a-biblioteca-f3270-44fa03bc0b4b?source=rss-285382f13528------2</link>
            <guid isPermaLink="false">https://medium.com/p/44fa03bc0b4b</guid>
            <category><![CDATA[junit]]></category>
            <category><![CDATA[automation-testing]]></category>
            <category><![CDATA[ibm-i]]></category>
            <category><![CDATA[ibm-z]]></category>
            <category><![CDATA[ibm]]></category>
            <dc:creator><![CDATA[Sergio Rubio]]></dc:creator>
            <pubDate>Thu, 12 Aug 2021 02:23:20 GMT</pubDate>
            <atom:updated>2021-08-12T02:23:20.245Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Utilizando uma biblioteca </em>open-source para a automação de testes para terminais 3270 e 5250.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/375/0*quBtFdOtVOoqeZMJ.jpg" /><figcaption>Servidor IBM zEnterprise 196. Fonte: <a href="https://www.itpro.co.uk/625477/analysis-new-ibm-mainframe-targets-the-bankers">Analysis: New IBM mainframe targets the bankers | IT PRO</a></figcaption></figure><p>Dando continuidade ao artigo publicado a respeito de <a href="https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-ambientes-para-prova-de-conceito-f83c3112aa0a">ambientes Mainframe para prova de conceito</a>, será explicado com mais detalhes a utilização do f3270, uma biblioteca <em>open-source</em> que permite a automação de testes para terminais 3270 e 5250.</p><h3>O que é o f3270?</h3><p>De acordo com o descrito no README do repositório <a href="https://github.com/r5v9/f3270">r5v9/f3270</a>:</p><blockquote>f3270 é um framework Java simples e fácil de usar para automatizar testes funcionais de mainframe. Consiste em uma API para lidar com campos em telas, e um terminal GUI para depuração.</blockquote><p>O repositório original do projeto não fornece demais informações de como utilizar a biblioteca, porém avaliando a estrutura do projeto, trata-se de um projeto Java com a gestão de <em>build and deploy</em> ficando a cargo do Apache Ant.</p><p>Outro aspecto desta biblioteca, é que a mesma utiliza o <a href="http://x3270.bgp.nu/Unix/s3270-man.html">s3270</a>, uma ferramenta de <em>screen scrapping</em>, emulando comandos do terminal por instruções enviadas via prompt de comando.</p><p><em>Screen scrapping</em> é o processo de acessar dados em um mainframe por meio de um programa que controla o comportamento de um emulador de terminal. Ou seja, o mainframe acredita que está interagindo com um usuário humano operando um terminal, mas o usuário na verdade é um programa. O programa envia dados para o Mainframe digitado em um teclado virtual e lê os resultados em uma tela virtual.</p><p>Fazendo um comparativo com automação Web, o s3270 poderia ser comparado a um ChromeDriver ou GeckoDriver, e o f3270 seria comparado a um Selenium, aonde é possível a execução de comandos que simulam as ações de um usuário.</p><p>Ficaria muito mais simples a configuração de um projeto com uma ferramenta de gestão de dependências, como Maven ou Gradle. Por sorte, um dos forks do projeto original, o <a href="https://github.com/vebqa/f3270">vebqa/f3270</a>, já possui esta configuração, tendo inclusive a versão compilada no <a href="https://mvnrepository.com/artifact/com.github.vebqa/f3270">Mvn Repository</a>. Isso facilita bastante a criação de um novo projeto baseado em Maven.</p><h3>Pré-condições para a utilização do f3270</h3><ul><li>A execução de um projeto com f3270 exige a utilização do Windows como sistema operacional, devido ao s3270 ser um arquivo executável (ou “.exe”). Este artigo considera a utilização do Windows 10.</li><li>JDK instalado e configurado. Neste artigo, considerarei o OpenJDK 11. Vide <a href="https://jdk.java.net/java-se-ri/11">link para download</a> e <a href="https://www.codejava.net/java-se/download-and-install-java-11-openjdk-and-oracle-jdk">instruções para a instalação</a> para maiores detalhes.</li><li>Maven instalado e configurado. Neste artigo, utilizarei a versão 3.8.3. Vide <a href="http://maven.apache.org/download.cgi">link para download</a> e <a href="http://maven.apache.org/install.html">instruções para a instalação</a> para maiores detalhes.</li><li>Como IDE para o desenvolvimento da automação com f3270, utilizarei o <a href="https://www.jetbrains.com/pt-br/idea/download">IntelliJ IDEA</a>. O artigo considerou a versão 2021.1.3 - Community Edition</li><li>Também será necessário o download do wc3270, pacote de programas que contém o s3270. O download pode ser efetuado através <a href="https://x3270.miraheze.org/wiki/Downloads">deste link</a>. O artigo considera a versão “4.0ga14 stable”.</li><li>Por fim, precisamos de um ambiente para a automação dos testes. Utilizaremos o Sim390, que descrevi no artigo <a href="https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-ambientes-para-prova-de-conceito-f83c3112aa0a">Automação de testes para Mainframe: Ambientes para prova de conceito</a>. Basta seguir as etapas descritas no artigo para a execução do Sim390, e mantê-lo em execução na máquina local.</li></ul><h3>Configurando um projeto com o f3270</h3><p>Criarei um novo projeto Maven utilizando o <a href="https://www.jetbrains.com/pt-br/idea/download">IntelliJ IDEA</a> para a utilização do f3270. Na tela inicial do IntelliJ, clicar em “New Project”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CH_MO8Z48F22WwxUml-XPA.png" /><figcaption>Tela inicial do IntelliJ IDEA</figcaption></figure><p>Selecionar o tipo de projeto “Maven” e clicar em “Next”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p7PiqqQ8bPJlVQFmB1Frcw.png" /><figcaption>Seleção do tipo de projeto no IntelliJ IDEA</figcaption></figure><p>Inserir um nome para o projeto (no caso, darei o nome de “f3270-poc”) e clicar em “Finish”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*todwzo5HKgzvNwglOmrPAg.png" /><figcaption>Dados do novo projeto e finalização</figcaption></figure><p>Logo após a criação do projeto, será aberto o projeto no IntelliJ IDEA, já com o arquivo “pom.xml” aberto. Será neste arquivo aonde colocaremos as dependências do f3270 e do JUnit (framework que utilizaremos para a implementação de testes). Basta adicionar as seguintes linhas ao arquivo, dentro da tag <em>&lt;project&gt;</em>:</p><pre>&lt;dependencies&gt;<br>    &lt;!-- f3270 --&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;com.github.vebqa&lt;/groupId&gt;<br>        &lt;artifactId&gt;f3270&lt;/artifactId&gt;<br>        &lt;version&gt;1.5.0&lt;/version&gt;<br>    &lt;/dependency&gt;<br>    &lt;!-- junit --&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;org.junit.jupiter&lt;/groupId&gt;<br>        &lt;artifactId&gt;junit-jupiter-api&lt;/artifactId&gt;<br>        &lt;version&gt;5.7.2&lt;/version&gt;<br>        &lt;scope&gt;test&lt;/scope&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;org.junit.jupiter&lt;/groupId&gt;<br>        &lt;artifactId&gt;junit-jupiter-engine&lt;/artifactId&gt;<br>        &lt;version&gt;5.7.2&lt;/version&gt;<br>        &lt;scope&gt;test&lt;/scope&gt;<br>    &lt;/dependency&gt;<br>&lt;/dependencies&gt;</pre><p>Não esquecer de atualizar as dependências do projeto, clicando no botão indicado abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5KFRBZ5upJ2OSfs6WWepow.png" /><figcaption>Dependências incluídas no pom.xml e botão para a atualização das dependências</figcaption></figure><p>Após a configuração das dependências, vamos criar a pasta <em>s3270</em> na raiz do projeto. Após o download do pacote <a href="https://x3270.miraheze.org/wiki/Downloads">wc3270</a> (descrito na seção “Pré-condições para a utilização do f3270”), extrair os arquivos, e copiar o executável “s3270.exe” para dentro da pasta criada no projeto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*XEbfPrOcRKS8GWVBRysS4g.png" /><figcaption>Arquivos contidos no pacote “wc3270”</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/475/1*21rwfHS2GswKo3wn5kmqYQ.png" /><figcaption>Executável “s3270.exe” copiado para a estrutura do projeto de automação</figcaption></figure><h3>Instanciando e conectando a um terminal</h3><p>Agora, vamos criar uma classe de testes do JUnit5, para a automação de algumas das telas do Sim390. Criarei um <em>package</em> chamado <em>sim390</em>, e dentro deste <em>package</em> criarei a classe <em>Sim390Test</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*EM0jY7noVddk4sq2bD4Qqg.png" /><figcaption>Classe “Sim390Test” criada dentro da estrutura “src/test/java/sim390”</figcaption></figure><p>Dentro desta classe, vamos criar um método de setup, que instanciará um atributo estático, do tipo <em>Terminal</em>. Este método terá a anotação <em>@BeforeAll</em>, para que este método seja executado ao iniciar os testes contidos na classe:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*3SeXvxxJ0Fcy5eyAbul4sQ.png" /><figcaption>Implemetação do atributo estático “terminal” e do método “setUp()”</figcaption></figure><p>Dentro do método, vamos instanciar o atributo <em>terminal</em>. Olhando para a <a href="https://github.com/vebqa/f3270/blob/fbf5adcd97c59132050f848030f1ca2ff37fb4ae/src/main/java/net/sf/f3270/Terminal.java#L56">implementação da classe Terminal</a>, temos os seguintes atributos:</p><ul><li><strong>s3270Path </strong>-&gt; caminho para o executável “s3270.exe”.</li><li><strong>hostname</strong> -&gt; endereço ip do servidor Mainframe.</li><li><strong>port</strong> -&gt; porta para o servidor Mainframe.</li><li><strong>type</strong> -&gt; tipo de emulação do Terminal. “TerminalType.TYPE_3278” trará um terminal monocromático, e “TerminalType.TYPE_3279” trará um terminal colorido.</li><li><strong>mode</strong> -&gt; modo de emulação, ou a quantidade de linhas e colunas do Terminal. Opções disponíveis: MODE_80_24, MODE_80_32, MODE_80_43 e MODE_132_27.</li><li><strong>charset</strong> -&gt; charset do terminal.</li><li><strong>showTerminalWindow</strong> -&gt; caso informado “true”, exibirá uma janela com o terminal em execução.</li></ul><p>A implementação para acesso ao Sim390 ficou da seguinte maneira:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*PJBAYAIjTLGA88jW04A-6A.png" /><figcaption>Implementação para acesso e conexão ao terminal do Sim390</figcaption></figure><pre><em>terminal </em>= new Terminal(<br>        &quot;s3270/s3270&quot;,<br>        &quot;127.0.0.1&quot;,<br>        23,<br>        TerminalType.<em>TYPE_3279</em>,<br>        TerminalModel.<em>MODE_80_24</em>,<br>        HostCharset.<em>US_INTL</em>,<br>        true);</pre><p>Por fim, definido o atributo <em>terminal</em>, podemos conectar a ele utilizando o método <em>connect()</em>, ficando a implementação do método <em>setUp</em> da seguinte maneira:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/341/1*6ip04jTEhrx2KGxHeJOaSg.png" /><figcaption>Implementação para acesso e conexão ao terminal do Sim390</figcaption></figure><h3>Ações e informações de elementos de tela</h3><p>O atributo <em>terminal</em> será utilizado também para efetuar ações no terminal, assim como obter informações presentes em tela. Vamos utilizar como exemplo o login, composto de duas telas: a primeira para acessar o login teclando “Enter”, depois a informação de login e senha, seguido novamente da tecla “Enter”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5ucxcuIkaqdOnRihylEa_A.png" /><figcaption>Sequência de telas para login no Sim390</figcaption></figure><p>Vamos implementar uma classe de teste, que executará as ações na tela. Vide na implementação abaixo que os métodos disponíveis pelo atributo <em>terminal</em> são bem intuitivos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/316/1*kZSoquxZYn6COE4nr9Zqnw.png" /><figcaption>Implementação da classe de teste para a efetivação do login</figcaption></figure><p>Neste momento, podemos executar os testes e avaliar os primeiros resultados. O primeiro que podemos notar são as telas, que são apresentadas no console da execução do JUnit:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*g2KY-jiIx-EaPB1ejKDIgA.png" /><figcaption>Telas apresentadas no console da execução do JUnit</figcaption></figure><p>Durante a execução dos testes, é apresentada uma tela para o acompanhamento da execução dos testes. Vide exemplo extraído da tela apresentada após efetuar um login válido:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*hUpy7UgxGww5o7Fg882hdQ.png" /><figcaption>Janela do terminal apresentada durante a execução dos testes</figcaption></figure><p>Algumas das ações disponíveis para utilização: <em>enter</em>, <em>tab</em>, <em>moveCursor</em>, <em>pf</em>, <em>pa</em>, <em>write</em> e <em>clearScreen</em>.</p><p>Podemos também extrair informações presentes na tela. Por exemplo, vide abaixo a implementação da extração do challenge exibido na tela de login, através do método <em>getLine</em>:</p><pre>String challenge = <em>terminal</em>.getLine(6);<br>System.<em>out</em>.println(challenge.trim());</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*V5u501wHsrSBHis2b1H47Q.png" /><figcaption>Informação do challenge impressa no log do JUnit</figcaption></figure><p>Os seguintes métodos podem ser utilizados para a extração das informações da tela: <em>getScreenText</em>, <em>getLine</em>, <em>getWidth</em>, <em>getHeight</em>, <em>printFields</em>, <em>printScreen</em> e <em>screenHasLabel</em>.</p><h3>Elementos de uma tela do Terminal</h3><p>Cada tela do Terminal é dividida em campos de leitura e escrita. Para demonstrar esta divisão de campos da tela, vamos utilizar o método <em>printFields, </em>para retornar os campos presentes na tela de login:</p><pre>@Test<br>public void printFields() throws InterruptedException {<br>    <em>terminal</em>.enter();<br>    <em>terminal</em>.printFields();<br>    Thread.<em>sleep</em>(60000);<br>}</pre><p>Após a execução, a informação dos campos existentes na tela é impressa no log de execução do JUnit. Vide extrações do log do JUnit abaixo, com exemplos de campos de leitura e escrita extraídos pelo método <em>printFields</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jy75ix0GMZAgzzK9i50zbg.png" /><figcaption>Exemplos de campos de leitura e escrita no console do JUnit</figcaption></figure><p>Os mesmos campos também são listados na janela do terminal, exibida durante a execução de um teste com o f3270. Para esta demonstração, inclui um <em>Thread.sleep</em> (nota do autor: somente para demonstração, <strong>sempre</strong> evite o <em>Thread.sleep</em>!!!), aonde podemos obter os campos de leitura e escrita:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1LbKE8Em-g2sRHOGxr48IQ.png" /><figcaption>Exemplos de campos de leitura e escrita exibida na execução do f3270</figcaption></figure><h3>Localizando elementos na tela</h3><p>Assim como o Selenium possui localizadores de elementos de tela, o f3270 permite a utilização de localizadores, que podem tanto ser utilizados para a escrita de dados em campos da tela (método <em>write</em>) como para obter dados de campos da tela (método <em>screenHasLabel</em>).</p><p>Cada campo pode ser identificado com a utilização da classe <em>FieldIdentifier</em>. Ao instanciar uma variável com a classe, devo informar o texto do campo imediatamente anterior ao campo que quero digitar. Trazendo novamente o exemplo da tela de login:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/675/1*d0-DbyCKW-hjCPJjGwy4Uw.png" /><figcaption>Exemplo dos campos de leitura e escrita na tela de login</figcaption></figure><p>O identificador do campo pode ser implementado da seguinte maneira:</p><pre>FieldIdentifier userId = new FieldIdentifier(&quot;MUSIC Userid&quot;);</pre><p>Por fim, a escrita no campo é feita com o método write:</p><pre><em>terminal</em>.write(userId, &quot;$000&quot;);</pre><p>A implementação do login completo no método de teste fica da seguinte maneira:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/591/1*TXv27dM7DflICiNXe9ns4A.png" /></figure><p>O <em>FieldIdentifier </em>também permite com que eu “pule” para o campo que eu quero digitar. Vamos trazer o exemplo da tela a seguir para experimentar esta funcionalidade:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/675/1*ZejveS4J-1B-7ivSj__TFA.png" /><figcaption>Exemplo da tela de administrador do Sim390</figcaption></figure><p>Para digitar a opção no campo , podemos implementar a variável com <em>FieldIdentifier</em> da seguinte maneira:</p><pre>FieldIdentifier option = new FieldIdentifier(&quot;SELECT OPTION&quot;, 2);</pre><h3>Escrevendo testes para terminal 5250</h3><p>Apesar da biblioteca f3270 permitir a automação em terminais 3270, também existe a possibilidade de implementar a mesma automação para terminais 5250, utilizado pela arquitetura AS/400, atualmente conhecida como IBM i. O seguinte artigo da IBM descreve um “de x para” entre as operações do terminal 3270 e 5250: <a href="https://www.ibm.com/docs/en/i/7.2?topic=sessions-3270-keyboard-mapping-telnet-servers">3270 keyboard mapping for Telnet servers — IBM Documentation</a>.</p><p>Na prática, os métodos do f3270 podem ser utilizados para os terminais 5250, com a diferença para as teclas de função. O artigo da IBM descreve o seguinte:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4m-S4kTJCikQkgfEbfCzzA.png" /><figcaption>Extração do artigo da IBM, explicando o mapeamento para teclas de função</figcaption></figure><p>Para exemplificar a utilização do f3270 para terminais 5250, vamos utilizar o servidor <a href="https://pub400.com/cgi/signup.nd/start">pub400.com</a>, cuja configuração expliquei no artigo <a href="https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-ambientes-para-prova-de-conceito-f83c3112aa0a">Automação de testes para Mainframe: Ambientes para prova de conceito</a>. No mesmo projeto de automação, vamos criar um pacote com o nome <em>pub400</em>, contendo a classe <em>Pub400Test</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*qLoRgw-rMFQg7gEkJWg5dA.png" /><figcaption>Classe Pub400Test criada no projeto</figcaption></figure><p>A implementação, como mencionado anteriormente, é semelhante ao descrito nas seções anteriores, somente com a diferença para o hostname:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/518/1*JRNUDjMQwGB2J8GGXqZ83Q.png" /><figcaption>Implementação da classe para testes no pub400.com</figcaption></figure><h3>Conclusão</h3><p>Explicamos neste artigo a implementação do f3270 para a automação de testes para sistemas baseados em Mainframe. Olhando com uma maior atenção, temos diversas semelhanças com a implementação de testes Web utilizando Selenium, aonde o <em>Terminal</em> é semelhante a um <em>WebDriver</em>, e o <em>FieldIdentifier</em> tem funcionalidade análoga a um <em>By</em>.</p><p>Dadas estas semelhanças, podemos trabalhar a implementação de uma automação utilizando padrões de projeto conhecidos de testes Web, como <em>DriverFactory</em> e <em>PageObjects</em>. No próximo artigo, explicarei a implementação de uma arquitetura prevendo a utilização destes dois padrões.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44fa03bc0b4b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automação de testes para Mainframe: Ambientes para prova de conceito]]></title>
            <link>https://medium.com/@sfrmack/automa%C3%A7%C3%A3o-de-testes-para-mainframe-ambientes-para-prova-de-conceito-f83c3112aa0a?source=rss-285382f13528------2</link>
            <guid isPermaLink="false">https://medium.com/p/f83c3112aa0a</guid>
            <category><![CDATA[ibm-z]]></category>
            <category><![CDATA[automation-tools]]></category>
            <category><![CDATA[mainframe]]></category>
            <category><![CDATA[ibm-i]]></category>
            <category><![CDATA[automation-testing]]></category>
            <dc:creator><![CDATA[Sergio Rubio]]></dc:creator>
            <pubDate>Sat, 31 Jul 2021 22:42:38 GMT</pubDate>
            <atom:updated>2021-07-31T22:42:38.369Z</atom:updated>
            <content:encoded><![CDATA[<h4>Preparando um ambiente de testes para a validação de ferramentas de automação de testes para mainframe</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n-HkAvC9ffQdz1xu" /><figcaption>Servidor IBM 360. Fonte: <a href="https://www.cfo.com/applications/2014/03/mainframe-deficiencies-burden-big-companies/">Mainframe IT Debt Averages $11 Million, says Micro Focus (cfo.com)</a></figcaption></figure><p>Submeti recentemente a intenção de apresentar uma palestra sobre automação de testes para Mainframe, por uma experiência recente que tive de implementar esta abordagem nos processos de validação de programas desenvolvidos para Alta Plataforma. Porém, após a aprovação da submissão da palestra, já não mais trabalhava na empresa aonde desenvolvi os testes automatizados, e não tinha mais acesso a um ambiente de Mainframe para os testes.</p><p>Com isso, passei a observar as possibilidades para a execução de testes automatizados em um ambiente de testes de Alta Plataforma.</p><h3>1a opção: Servidor 3270 instalado na máquina local.</h3><p>O repositório do <a href="https://github.com/vebqa/f3270/">f3270</a>, biblioteca Java no qual pretendo desenvolver a prova de conceito, possui em sua <a href="https://github.com/vebqa/f3270/wiki/Getting-started">wiki</a> uma série de instruções para a instalação de um “test system”, que trata-se de um emulador de Mainframe chamado <a href="https://www.canpub.com/teammpg/de/sim390/">Sim390</a>, que roda em Windows e emula um subset da arquitetura ESA/390.</p><p>De acordo com a <a href="https://en.wikipedia.org/wiki/IBM_System/390">Wikipedia</a>, a arquitetura ESA/390 é precursora da arquitetura Z, utilizada até hoje em empresas que mantém o sistemas legados em Mainframe. O fato mais interessante está na página inicial, que descreve:</p><blockquote>It is very easy to install. It is possible to run it on a very small machine such as a Pentium 75 MHz with 16 MB memory (Windows 95).</blockquote><p><em>Nota do autor: se não funcionar, sem problemas! Resgatei um CD de instalação q eu tinha aqui em casa… </em>👴</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bdr_xoMVYcJc6KcJ03vmvQ.jpeg" /><figcaption>CD de instalação do Win95, uma das relíquias daqui de casa…</figcaption></figure><p>Juntamente com o Sim390, é necessária a instalação de um sistema operacional chamado <a href="https://www.canpub.com/teammpg/de/sim390/musnotes.htm">MUSIC/SP</a>, ou <em>Multi-User System for Interactive Computing / System Product</em>, que contém aplicativos como um editor para 3270, utilitários para TCP/IP (servidor Web, cliente e servidor FTP etc.).</p><p>Para rodar o Sim390 com o MUSIC/SP instalado, foi necessário seguir os seguintes passos:</p><ul><li>Baixar o Sim390 <a href="https://www.canpub.com/teammpg/de/sim390/sim390_17.zip">neste link</a>, e descompactar os arquivos para o diretório C:\sim390dm</li><li>Baixar o MUSIC/SP <a href="https://www.canpub.com/teammpg/de/mcgweb/musdemo_b.zip">neste link</a>, e descompactar os arquivos para o mesmo diretório C:\sim390dm</li><li>Alterar as seguintes linhas contidas no arquivo “musicxdm.cfg”:</li></ul><pre>* Retirar o comentário da linha abaixo:<br>autoipl 201 blankcmd <br>* Alterar a porta listada abaixo para a porta &quot;23&quot;<br>remote3270port 23</pre><ul><li>Acessar o Prompt de Comando, entrar no diretório C:\sim390dm e executar o comando “sim390_17 musicxdm.cfg”:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r7X15F-rEjStf2IjfAibRA.png" /><figcaption>Execução do Sim390 via Prompt de Comando</figcaption></figure><p>Serão exibidas duas janelas. Um console do Sim390 e um painel de controle:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/908/1*VyHsZJe9nwWlTsUOinjLpg.png" /><figcaption>Console do Sim390</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*lLhQ_o-77-WPZwHhZ54Ccw.png" /><figcaption>Painel de controle do Sim390</figcaption></figure><p>No painel de controle do Sim390 pode ser executado também um emulador de terminal, para testar o correto funcionamento do sistema operacional MUSIC/SP:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*NNNqySp-v3qXqADkbJXCTQ.png" /><figcaption>Opção para a execução de um terminal 3270</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*HlfIvA9OxDUoSv55n9KI8g.png" /><figcaption>Tela inicial do MUSIC/SP, aberta no terminal 3270</figcaption></figure><h4>Primeiros testes de acesso ao Sim390</h4><p>O ambiente local configurado possibilitou a criação de um projeto para a validação de ferramenta de automação de testes para Mainframe. Neste artigo, farei a automação utilizando o <a href="https://junit.org/junit5/">JUnit5</a> como framework de teste e a biblioteca <a href="https://github.com/vebqa/f3270/">f3270</a> sendo o driver de automação para Mainframe. Criei um novo projeto Maven, incluindo as dependências ao JUnit5 e f3270 e copiando o s3270 na raiz do projeto. Após a configuração do projeto, criei uma classe simples de teste para testar o acesso ao MUSIC/SP:</p><pre>public class MusicSpTest {</pre><pre>    private static Terminal <em>terminal</em>;</pre><pre>    @BeforeAll<br>    public static void setUp() {<br>        <em>terminal </em>= new Terminal(<br>                &quot;s3270/s3270&quot;,&quot;127.0.0.1&quot;, 23,<br>                TerminalType.<em>TYPE_3279</em>, TerminalModel.<em>MODE_80_24</em>,<br>                HostCharset.<em>US_INTL</em>, true);<br>        <em>terminal</em>.connect();<br>    }</pre><pre>    @Test<br>    public void logOnMusicSp() {<br>        <em>terminal</em>.enter();<br>        <em>terminal</em>.write(&quot;$000&quot;);<br>    }<br>}</pre><p>Após a execução do teste, sucesso ao utilizar o f3270!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NH5WM7dKp7eLP1S4JLeEfA.png" /><figcaption>Execução do teste de acesso ao MUSIC/SP através do f3270</figcaption></figure><h3>2a opção: servidor IBM i de acesso público</h3><p>Ferramentas de automação de testes para mainframe baseadas em terminal 3270 também podem ser utilizadas para terminais 5250, como AS/400 ou IBM i. Para possibilitar o teste, existe um mapeamento descrito na seguinte página: <a href="https://www.ibm.com/docs/en/i/7.2?topic=sessions-3270-keyboard-mapping-telnet-servers">3270 keyboard mapping for Telnet servers — IBM Documentation</a>.</p><p>Este mapeamento abriu a possibilidade de trabalhar também com sistemas baseados em IBM i. De acordo com a <a href="https://en.wikipedia.org/wiki/IBM_i">Wikipedia</a>, o IBM i foi originalmente lançado em 1988 como OS/400, junto com a linha de sistemas IBM AS/400. Foi renomeado para i5/OS em 2004, antes de ser renomeado pela segunda vez para IBM i em 2008.</p><p>Fui informado por um colega de trabalho (obrigado <a href="https://www.linkedin.com/in/eduardo-alberto-marc%C3%B3-5a03465/">Eduardo Marcó</a>!) da existência de um servidor público no endereço pub400.com. Acesssando o <a href="https://pub400.com/cgi/signup.nd/start">seguinte link</a>, será solicitado o cadastramento de um usuário, que posteriormente é criado neste servidor, juntamente com um workspace próprio para o desenvolvimento de programas. O cadastramento deste usuário foi concluído rapidamente, e logo em seguida já recebi um email com as instruções para o acesso e a redefinição da senha.</p><p>O próximo passo foi a instalação de um terminal para acesso ao terminal local. Para tal, fiz a instalação do <a href="https://www.ibm.com/support/pages/ibm-i-access-client-solutions">IBM i Access Client Solutions</a>, um pacote de funcionalidades de acesso a servidores IBM i, incluindo um terminal 5250. Primeiro, é necessário o cadastramento de uma nova sessão 5250 na seguinte opção:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/731/1*gQQHibNdVdJ63B9k0VH5TQ.png" /><figcaption>Acessando uma terminal 5250 pelo Access Client Solution</figcaption></figure><p>Após clicar em “Nova Sessão de Exibição”, será apresentada uma tela para informar os dados de conexão. Neste momento, basta informar os dados para a conexão recebidos no email recebido do pub400.com:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nRSFIFbC_paaimnhyDYODA.png" /><figcaption>Configurando uma nova sessão 5250 para acesso ao pub400.com</figcaption></figure><p>Clicando em OK, será exibida a tela do terminal, seguida do login. O primeiro login exigirá a redefinição da senha. Após a redefinição da senha, o acesso é efetuado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kABETKsIhN3QB3x9BwfcuA.png" /><figcaption>Tela inicial do pub400.com na sessão 5250</figcaption></figure><p>Neste momento, informar o mesmo login e senha e digitar &lt;enter&gt;. Com isso, já conseguimos o acesso para a utilização do servidor IBM i:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IyRlIps8H854Ikzsou0gQw.png" /><figcaption>Tela inicial do pub400.com após o login bem sucedido</figcaption></figure><h4>Primeiros testes de acesso ao servidor IBM i</h4><p>Estas telas já possibilitaram nova validação da ferramenta de automação de testes para Mainframe que selecionamos anteriormente, o <a href="https://github.com/vebqa/f3270/">f3270</a>. Na mesma estrutura do projeto, criei uma classe simples de teste para testar o acesso ao IBM i:</p><pre>public class Pub400Test {<br><br>    private static Terminal <em>terminal</em>;<br><br>    @BeforeAll<br>    public static void setUp() {<br>        <em>terminal </em>= new Terminal(<br>                &quot;s3270/s3270&quot;,&quot;pub400.com&quot;, 23,<br>                TerminalType.<em>TYPE_3279</em>, TerminalModel.<em>MODE_80_24</em>, <br>                HostCharset.<em>US_INTL</em>, true);<br>        <em>terminal</em>.connect();<br>    }<br><br>    @Test<br>    public void logOnPub400() {<br>        <em>terminal</em>.write(&quot;SFRUBIO&quot;);<br>    }<br>}</pre><p>Após a execução do teste, o acesso foi efetuado corretamente ao IBM i. Bingo!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vidXua6FAOnIVscWZCKhsA.png" /><figcaption>Execução do teste de acesso ao pub400.com através do f3270</figcaption></figure><h3>Outras opções de ambientes</h3><p>Existe também a possibilidade de criação de um servidor IBM i localmente, com a utilização de uma máquina virtual com o <a href="https://www.proxmox.com/en/">Proxmob</a>, um sistema operacional baseado em Debian, que permite a utilização de Linux Containers (LXC). No caso, um container LXC contendo o IBM i pode ser encontrado <a href="https://esselware.com.mx/IBMi_en_Espanol/LXC/">neste link</a>. Todo o passo-a-passo para a configuração e utilização pode ser encontrado neste artigo: <a href="https://www.linkedin.com/pulse/ibm-i-novnc-containers-access-client-solutions-5250-diego-kesselman/?trackingId=L5PcaVK56LltDaeYItkb7Q%3D%3D">IBM i : noVNC + Containers + IBM i Access Client Solutions — 5250 on ANY browser (with HTML5) | LinkedIn</a>.</p><p>Existe também um servidor pago, aonde um servidor IBM i é ofertado em diversas configurações, disponível <a href="https://cockpit.rzkh.de/cgi-bin/db2www/config.nd/start">neste link</a>.</p><h3>Conclusão</h3><p>Ao contrário do que eu pensava, temos também alguns “sandboxes” para a prática de desenvolvimento de mainframe, tanto para sistemas operacionais baseados em terminais 3270 (ESA/390, IBM Z series) como para os baseados em terminais 5250 (AS/400, IBM i).</p><p>Com estas duas opções, podemos prosseguir com a realização de uma prova de conceito para a automação de testes para mainframe. Em breve, postarei a respeito de como montar a arquitetura para a automação de testes, utilizando o f3270 e padrões de projetos como <em>driver factory</em> e <em>page objects</em>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f83c3112aa0a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>