<?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[Aurum Tech - Medium]]></title>
        <description><![CDATA[How we do awesome things at Aurum software development team - Medium]]></description>
        <link>https://medium.com/aurum-tech?source=rss----1f417c7a9fba---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Aurum Tech - Medium</title>
            <link>https://medium.com/aurum-tech?source=rss----1f417c7a9fba---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 02:39:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/aurum-tech" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[CI/CD em seu aplicativo React Native com o Microsoft App Center]]></title>
            <link>https://medium.com/aurum-tech/ci-cd-em-seu-aplicativo-react-native-com-o-microsoft-app-center-b18373d6515b?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/b18373d6515b</guid>
            <category><![CDATA[app-store-optimization]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Guilherme Augusto Steinmacher Bublitz]]></dc:creator>
            <pubDate>Thu, 19 Nov 2020 21:04:10 GMT</pubDate>
            <atom:updated>2020-11-19T21:04:09.892Z</atom:updated>
            <content:encoded><![CDATA[<p>Quem já trabalhou com desenvolvimento mobile sabe que uma das maiores dores é o processo burocrático da publicação dos apps nas lojas. Portanto, qualquer ajuda para encurtar essa etapa é bem-vinda. Pensando nisso, aqui na <a href="https://medium.com/aurum-tech">Aurum</a>, decidimos por automatizar a publicação do app <a href="https://www.aurum.com.br/astrea/">Astrea Mobile</a>.</p><p>A ferramenta escolhida foi o <a href="https://appcenter.ms/">Microsoft App Center</a>. Escolhemos essa opção, dentre outras que existem no mercado, pois nosso objetivo final era também termos o <a href="https://pt.wikipedia.org/wiki/Over-the-air">OTA</a> (over-the-air update), e a Microsoft já possui uma boa integração com o <a href="https://microsoft.github.io/code-push/">CodePush</a>.</p><p>Nesse post vou relatar as etapas de integração e um pouco como foi nossa experiência na implementação, indicando alguns dos problemas que passamos.</p><h3>Antes de começar</h3><h4>Github</h4><p>Antes de iniciarmos, é importante salientar que, caso o repositório do seu projeto no Github seja privado, somente o criador desse projeto conseguirá adicioná-lo ao build do App Center.</p><h4>App Center</h4><p>Atualmente, em seu plano gratuito o App Center disponibiliza 4 horas de build por mês. Um valor mais do que o suficiente para projetos médios e pequenos. Mas fique atento pois o consumo desse tempo será da conta que adicionou o projeto, não necessariamente da conta que executou o build.</p><h3>Android</h3><h4>O que é necessário?</h4><ul><li>Um repositório com o projeto de seu app (Github ou Bitbucket);</li><li>Uma conta de desenvolvedor na Google Play;</li><li>Uma conta no Microsoft App Center (é possível logar com o e-mail ou Github);</li></ul><h4>Iniciando</h4><p>Primeiro, vamos criar um app com as seguintes configurações:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JOB-tlSLL2H0Z1o-KKLwPw.png" /></figure><h4>Conexão com a loja</h4><p>Vamos criar a conexão com a Google Play. Para isso, acesse o seu app recém-criado clique na aba <strong>Distribute</strong> e depois em <strong>Stores.</strong></p><p>Depois, clique em<strong> connect to store</strong> e escolha a <strong>Google Play. </strong>Agora será necessária uma chave para realizar a conexão. Essa chave é um arquivo JSON (é possível ver o passo a passo de como consegui-la neste <a href="https://docs.microsoft.com/en-us/appcenter/distribution/stores/googleplay">link</a>). O processo para obter este arquivo só pode ser realizado pelo <strong>dono</strong> da conta de desenvolvedor na Google Play, mesmo com acesso de administrador não foi possível realizá-lo com outra conta.</p><p>Após conseguir o arquivo, é só fazer o upload dele e colocar o package name de seu projeto (o package name dos projetos Android são encontrados no arquivo <em>AndroidManifest.xml).</em></p><h4>Build</h4><p>Agora que já estamos com a conexão com a loja, podemos avançar para a próxima etapa. Clicando em <strong>build</strong> na área do app, podemos escolher qual serviço de repositório queremos (nesse caso utilizamos o Github). Ao selecionar o serviço uma lista com os repositórios disponíveis vai aparecer (tanto da sua conta, quanto de organizações que você esteja participando).</p><p>Selecione o projeto e depois selecione a <strong>branch</strong> com a qual você quer que seu build seja rodado, no nosso caso escolhemos a branch <em>Master</em> (que pode estar como <em>Main,</em> dependendo de quando você criou seu projeto).</p><h4>Configuração do build</h4><p>Nesse passo temos que fazer algumas alterações. A primeira é escolher a versão mais estável do <em>NodeJS (</em>no nosso caso era a versão 12x).</p><p>Em <strong>Build Frequency</strong>, selecionaremos para fazer o build desta branch em cada push. Marque também as opções: <strong>Build Android App Bundle</strong>, para otimizarmos o aplicativo usando o formado <strong>.aab</strong>; e a opção <strong>Automatically increment version code</strong>, para não nos preocuparmos em ter que alterar a versão do bundle em cada build.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*vWYiKsTwLQjkK9fAQli0gw.png" /></figure><p>Além disso, vamos ativar o <strong>Sign Build. </strong>Será necessário fazer o upload de sua <strong>keystore </strong>e de algumas variáveis de ambiente. Caso você não tenha uma keystore, <a href="https://reactnative.dev/docs/signed-apk-android">aqui</a> você encontra como obtê-la.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*WJw16_gbW3BBZgb5sN8IwA.png" /></figure><p>Nessa parte, tivemos falhas em nossos builds. Para que a assinatura do App Center funcione, a assinatura manual do projeto terá que ser removida. Para resolver isso é simples, basta remover (ou comentar) as seguintes linhas no arquivo <strong>android/app/build.gradle </strong>dentro da seção<strong> buildTypes/release</strong>:</p><pre>signingConfig signingConfigs.debug</pre><pre>signingConfig signingConfigs.release</pre><p>Lembrando que, comentando essas linhas, o processo de criar <strong>apk</strong> na sua máquina não funcionará. Sem o <em>signingConfig,</em> o arquivo gerado será um <em>unsigned-app-release.apk.</em></p><p>E, por fim, vamos selecionar a conexão com a loja que realizamos anteriormente, escolher a opção <strong>Production</strong> e escrever uma nova mensagem de atualização.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*lQYZbzf-x1Tvo0neuzZ_Wg.png" /></figure><h3>iOS</h3><h4>O que é necessário?</h4><ul><li>Um repositório com o projeto de seu app (Github ou Bitbucket);</li><li>Uma conta apple ID no programa de desenvolvedores Apple;</li><li>Uma conta no Microsoft App Center (é possível logar com o e-mail ou Github);</li></ul><h4>Iniciando</h4><p>Primeiro, vamos criar um app com as seguintes configurações:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MYnycICY69M2C3zNejeu5Q.png" /></figure><h4>Conexão com a loja</h4><p>Vamos criar a conexão com a App Store. Para isso, acesse o seu app recém-criado, clique na aba <strong>Distribute</strong> e depois em <strong>Stores.</strong></p><p>Depois, clique em<strong> connect to store</strong> e escolha a <strong>App Store Connect. </strong>Agora é necessário informar seu apple ID, será solicitado o código da autenticação de dois fatores<em>, </em>mas existe um porém, a autenticação por SMS não é aceita. Para resolver isso foi simples, é só adicionar um dispositivo ao seu apple ID e pegar o código por lá.</p><p>Logo após, foi solicitado um <strong>app password</strong>, basta acessar a página da Apple e gerar um novo na parte de segurança. Pronto, após conectar com sua conta é só selecionar o seu projeto!</p><h4>Build</h4><p>Aqui é só repetir o processo do Android: selecionar seu repositório e a branch.</p><h4>Configuração do build</h4><p>De novo, a primeira alteração é selecionar a versão mais estável do NodeJS.</p><p>Selecionamos também o <strong>Scheme</strong>, <strong>Xcode Version </strong>e o <strong>Build Frequency. </strong>Aqui o problema foi com relação à versão do Xcode. Com a versão 12, o build demorava mais de 30 minutos o que ocasionava <strong>timeout</strong> e <strong>falha</strong>. Depois de testar diversas opções, a versão estável encontrada foi 11.3, com ela o build foi realizado com sucesso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W6sRZUFZOHFb7cGlj_hkJg.png" /></figure><p>Agora, vamos configurar a assinatura do app. Para isso, é necessário fazer o upload de dois arquivos: o <strong>Provisioning Profile</strong> e o certificado <strong>.p12. </strong>Caso você não saiba como obter esses arquivos, <a href="https://mobincube.zendesk.com/hc/en-us/articles/200511933-How-to-get-the-p12-file-and-provisioning-profile-for-publishing-an-app-on-App-Store">aqui</a> tem um tutorial que pode ajudar nisso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1014/1*nE0JFJGVfDyDDBCJusdJWQ.png" /></figure><p>E, no fim, vamos selecionar a nossa conexão com a App Store, selecionar a versão de produção e escrever as atualizações do app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1014/1*9ChdpxOENfDTTMFScCK7WQ.png" /></figure><h4>Antes do build</h4><p>Um problema encontrado no iOS foi com mudança de versões. Quando mudamos para uma diferente da 1.0, o arquivo <strong>Info.plist </strong>foi atualizado e começou a utilizar a variável<strong> MARKETING_VERSION.</strong></p><pre>&lt;key&gt;CFBundleShortVersionString&lt;/key&gt;</pre><pre>&lt;string&gt;$(MARKETING_VERSION)&lt;/string&gt;</pre><p>O problema com a versão desse jeito é que o App Center não consegue encontrá-la e falha ao tentar construir nosso app. Então, caso isso ocorra, altere seu arquivo manualmente.</p><pre>&lt;key&gt;CFBundleShortVersionString&lt;/key&gt;</pre><pre>&lt;string&gt;1.1&lt;/string&gt;</pre><h3>Uma última coisa!</h3><p>Um outro ponto que o App Center proporciona é uma badge de status do seu projeto, que fica bem legal pra colocar no <strong>README</strong> do seu repositório.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1014/1*nxiNo9DW_sxz4mNPkYB5GQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YvgzAjZj7qUdrncvFCeSCw.png" /></figure><h3>Adeus assembleRelease e archive</h3><p>Pronto! Agora você já tem seus builds configurados. Pode se despedir do comando <em>./gradlew assembleRelease</em> e do <em>archive</em> no XCode. A cada push que você der, na branch escolhida, uma nova versão vai aparecer em sua loja.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b18373d6515b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/ci-cd-em-seu-aplicativo-react-native-com-o-microsoft-app-center-b18373d6515b">CI/CD em seu aplicativo React Native com o Microsoft App Center</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TESTES E2E COM REACT NATIVE E DETOX]]></title>
            <link>https://medium.com/aurum-tech/testes-e2e-com-react-native-e-detox-688201312efa?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/688201312efa</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[e2e-testing]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[test]]></category>
            <dc:creator><![CDATA[Guilherme Augusto Steinmacher Bublitz]]></dc:creator>
            <pubDate>Fri, 14 Aug 2020 16:57:51 GMT</pubDate>
            <atom:updated>2020-08-14T16:57:51.744Z</atom:updated>
            <content:encoded><![CDATA[<h3>TESTES E2E COM REACT NATIVE E DETOX</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rFt0lPvsVFC8vJ1mQ8VrPQ.png" /></figure><h3>O INÍCIO</h3><p>Desde que entrei na Aurum pude perceber que testes são uma parte crucial do processo de desenvolvimento. Os testes unitários sempre foram parte do nosso dia a dia, mas com o tempo fomos buscando outras maneiras de garantir a qualidade do código, e começamos a investir tempo em testes <a href="https://www.katalon.com/resources-center/blog/end-to-end-e2e-testing/">E2E</a>. <br>Para implementar os testes End-to-End na Web foi utilizado Selenium e atualmente usamos o Cypress (é possível conferir como foi a mudança entre essas duas bibliotecas nesse <a href="https://medium.com/aurum-tech/mudando-do-selenium-para-o-cypress-682d0834fc5c">post</a>), mas ainda não tínhamos experimentado nenhuma opção em projetos mobile.</p><p>Sendo membro da equipe Astrea Mobile, não quis deixar nosso app de fora e comecei a pesquisar algumas opções no mercado, após um tempo encontrei o <a href="https://github.com/wix/Detox">Detox</a>, uma biblioteca de código aberto desenvolvida pelo pessoal do Wix. Como já utilizamos algumas ferramentas desenvolvidas por eles, como o <a href="https://wix.github.io/react-native-navigation/docs/before-you-start/">react-native-navigation</a>, resolvi estudar e implementar em nosso projeto.</p><h3>INSTALAÇÃO</h3><h4>CONFIGURANDO O AMBIENTE</h4><p>Aqui vamos seguir as configurações para o MacOS, por isso utilizamos o <a href="https://brew.sh/index_pt-br">homebrew</a> em algumas etapas do processo. Importante checar algumas informações antes de começarmos:</p><ul><li>MacOS High Sierra 10.13.16 ou superior</li><li>Xcode 10.2+</li><li>CLI do Xcode</li></ul><p>Primeiro instalação do Node. O Detox roda com versões 8.3 ou superiores, para checar sua versão use o comando:</p><pre>node -v</pre><p>Caso não tenha instalado ainda:</p><pre>brew update &amp;&amp; brew install node</pre><p>Depois instalamos globalmente a CLI do Detox:</p><pre>npm install -g detox-cli</pre><p>Agora vamos instalar o <a href="https://github.com/wix/AppleSimulatorUtils">applesimutils</a>, que são algumas ferramentas para auxiliar o trabalho com simuladores iOS, o Detox utilizará delas para se comunicar com o emulador:</p><pre>brew tap wix/brew</pre><pre>brew install applesimutils</pre><h4>ADICIONANDO AO PROJETO</h4><p>Primeiro adicionamos o detox ao projeto como dependência de desenvolvimento:</p><pre>yarn add -D detox</pre><p>Como o Detox não executa propriamente as lógicas dos testes, mas delega essa função, precisamos instalar um test runner, e para isso temos duas opções: <a href="https://jestjs.io/">Jest</a> ou <a href="https://mochajs.org/">Mocha</a>. Optamos pelo Jest pois já o utilizamos junto com o <a href="https://testing-library.com/">Testing Library</a> no projeto. Então instalamos o test runner jest-circus:</p><pre>yarn add -D jest-circus</pre><p>Pronto agora já podemos começar a configurar os arquivos do Detox.</p><h4>CONFIGURANDO O DETOX</h4><p>Vamos criar a estrutura base dos arquivos com o comando:</p><pre>detox init -r jest</pre><p>Esse comando deve criar um arquivo <strong>.detoxrc</strong> na raiz de seu projeto e uma pasta e2e com os seguintes arquivos:</p><ul><li>config.json</li><li>environment.js</li><li>firstTest.e2e.js</li></ul><p>Você pode conferir se os arquivos estão corretos no <a href="https://github.com/wix/Detox/tree/master/examples/demo-react-native-jest">repositório demo</a>.</p><p>Dentro do <strong>.detoxrc</strong> vamo fazer algumas alterações:</p><ul><li>binaryPath: esse é o caminho onde será encontrada o arquivo <a href="https://pt.wikipedia.org/wiki/APK">.apk</a> ou <a href="https://en.wikipedia.org/wiki/.ipa">.ipa</a> para executar. Mude onde estiver <strong>example.app</strong> para o <strong>nome do seu projeto</strong>.</li><li>build: o caminho para executar o comando build do detox. Troque onde estiver <strong>example</strong> pelo<strong> nome de seu projeto</strong>. Caso esteja utilizando pods ou React Native 0.60+ substitua a tag <strong>-project</strong> por <strong>-workspace</strong> e <strong>.xcodeproj</strong> por <strong>.xcworkspace</strong>.</li><li>type: o tipo de dispositivo que vai ser utilizado nos testes, deixamos <strong>ios.simulator</strong></li><li>device: por último o dispositivo que vamos utilizar, no iOS passamos o <strong>type</strong> como <strong>iPhone 11 Pro</strong>. Configurando um dispositivo Android passaríamos a propriedade com o nome <strong>avdName</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BKEdnyhkkGXMCBYZu_SzdQ.png" /></figure><p>Agora vamos executar configurações do nosso Detox, esse processo pode durar alguns minutos:</p><pre>detox build</pre><p>Caso você tenha mais de uma configuração, utilize o comando configuration seguido no nome de sua configuração para selecioná-la:</p><pre>detox build — configuration ios</pre><h3>CRIANDO SEU PRIMEIRO TESTE</h3><p>No arquivo firstTest.e2e.js vamos escrever nosso primeiro teste. Como é utilizado o jest a sintaxe não será um problema pra quem já está familiarizado com testes unitários em javascript.</p><p>Para esse teste criei um componente simples que simula uma validação de formulário de login:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qqg10vO33Z4mzCIU24Wx0w.png" /></figure><p>A estrutura do arquivo de testes é composta de um <strong>describe</strong> para criar uma suíte de testes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/554/1*T4W8xUElCmVIYvY4aZfTSw.png" /></figure><p>No início adicionamos um beforeEach, que será responsável por recarregar o aplicativo (o comando cmd + r no simulador iOS ou rr no emulador Android) antes da execução de cada cenário:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/554/1*o4nvUeik8qUAgr6IILT5ow.png" /></figure><p>Depois criamos nossa primeira suíte de testes. Iremos testar a validação do input de senha:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Idg5Gi-fKFw6B0S0nBRoMg.png" /></figure><p>Vamos utilizar o método <strong>element</strong> junto com o <a href="https://github.com/wix/Detox/blob/master/docs/APIRef.Matchers.md">match</a> escolhido para capturar os elementos da tela. Começaremos com o input de email, vamos capturá-lo pelo id, no componente é possível ver uma prop <strong>testID</strong> com o valor que vamos buscar e salvá-lo em uma variável</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/408/1*ZEhIVbjxQwXoRoh162icuA.png" /><figcaption>Componente</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*5HM-jgHLzPhETxu71K1a-g.png" /><figcaption>Buscando componente com Detox</figcaption></figure><p>Depois vamos buscar nosso botão, para localizá-lo podemos utilizar seu texto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*f-3JSMYlAu1D_rK1XFLqHQ.png" /><figcaption>Componente</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*dig3VSxHnt71bDc-UtUwwQ.png" /><figcaption>Buscando componente com Detox</figcaption></figure><p>Agora é a hora de preencher os campos, vamos utilizar a variável que salvamos o component e a <a href="https://github.com/wix/Detox/blob/master/docs/APIRef.ActionsOnElement.md">action</a> <em>typeText()</em> do Detox:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*5nYp9A2SoOWw14kMn0stEg.png" /></figure><p>Com nosso input preenchido é só clicar em no botão, usando a action <em>tap()</em> fazemos isso facilmente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*ITriJyc_xOQ4vTytoZ6L4w.png" /></figure><p>Importante lembrar que as actions do Detox são assíncronas, ou seja, elas retornam <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Usando_promises">Promises</a> e utilizamos o await para esperar a ação finalizar.</p><p>No fim verificamos se a validação ocorreu corretamente buscando um elemento texto na tela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*exW4q3QjALou6FMEdHMdVg.png" /></figure><p>Pronto agora é só rodar seus testes E2E:</p><pre>detox test</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*aSsJdSFgJ-j6_51POicYxA.gif" /></figure><h3>CONCLUSÃO</h3><p>O Detox oferece um leque variado de funcionalidades para realizar testes E2E em sua aplicação móvel, com uma documentação bem completa e utilizando uma sintaxe já conhecida para os programadores da área, o tornando uma opção produtiva e poderosa de ferramenta para aumentar ainda mais a cobertura de testes do seu aplicativo.</p><p>Abaixo deixo alguns link importantes, nos quais esse texto foi baseado, para quem quiser se aprofundar mais nessa biblioteca:</p><ul><li><a href="https://github.com/wix/Detox">Github do Detox</a></li><li><a href="https://github.com/wix/Detox/blob/master/docs/APIRef.Matchers.md">Lista de Matchers</a></li><li><a href="https://github.com/wix/Detox/blob/master/docs/APIRef.ActionsOnElement.md">Lista de Actions</a></li><li><a href="https://github.com/guibas741/react-native-detox-boilerplate">Repositório utilizado no post</a></li><li><a href="https://medium.com/aurum-tech/mudando-do-selenium-para-o-cypress-682d0834fc5c">Mudando do Selenium para o Cypress</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=688201312efa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/testes-e2e-com-react-native-e-detox-688201312efa">TESTES E2E COM REACT NATIVE E DETOX</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como foi palestrar no TDC]]></title>
            <link>https://medium.com/aurum-tech/como-foi-palestrar-no-tdc-bafbeb68d15a?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/bafbeb68d15a</guid>
            <category><![CDATA[the-developers-conference]]></category>
            <category><![CDATA[aurum]]></category>
            <category><![CDATA[lxml]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Alana Domit Bittar]]></dc:creator>
            <pubDate>Thu, 09 May 2019 19:05:34 GMT</pubDate>
            <atom:updated>2019-05-09T19:05:13.255Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*NgokRjzPIrwOCpvs-pBcPQ.png" /><figcaption>source: <a href="http://www.thedevelopersconference.com.br/">The Developer’s Conference</a> via <a href="https://pt-br.facebook.com/TheDevelopersConference/">Facebook</a></figcaption></figure><p>Depois de participar do <em>The Developer’s Conference</em> (TDC) Florianópolis como parte do público em 2017 e 2018, neste ano decidi submeter um <em>paper — </em>uma <em>talk</em>, palestra. O <a href="http://www.thedevelopersconference.com.br/">TDC</a> é um evento relacionado ao desenvolvimento de <em>software </em>que<em> </em>ocorre em Florianópolis e outras cidades do Brasil e contém trilhas de palestras e workshops, além de espaços para debates e crianças. Esta última edição foi do dia 23 ao dia 27 de abril, com <a href="http://www.thedevelopersconference.com.br/tdc/2019/florianopolis/trilhas">várias trilhas simultâneas em cada dia</a>.</p><p>Cada trilha possui um tema específico, sendo que a da minha palestra foi a de <a href="http://www.thedevelopersconference.com.br/tdc/2019/florianopolis/trilha-python">Python</a>. Aqui na Aurum temos um <a href="https://medium.com/aurum-tech/microservices-e-a-complexidade-1342002067ac">time de extração, processamento e análise de dados</a>, do qual participo, apelidado de <em>robôs</em>, que usa principalmente a linguagem Python para desenvolver suas soluções. Ela não é a única, mas devido ao ferramental robusto disponível para nossas atividades em suas bibliotecas padrões e externas, tem sido a de uso mais frequente. Para minha palestra, escolhi como tema uma dessas bibliotecas, a <a href="https://lxml.de/"><em>lxml</em></a>,<em> </em>que utilizamos para parsear HTMLs alguns meses atrás.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*nVV-iDJEj6YK3jWRW5SfXQ.png" /><figcaption>source: <a href="https://www.python.org/">PSF</a></figcaption></figure><p><em>lxml </em>é na verdade um <a href="https://en.wikipedia.org/wiki/Language_binding"><em>binding</em></a><em> </em>para duas outras bibliotecas escritas em C, <a href="http://xmlsoft.org/"><em>libxml2</em></a> e <a href="http://xmlsoft.org/"><em>libxslt</em></a>. Já existiam outros <em>bindings</em> quando a <em>lxml</em> foi criada, porém os criadores os consideravam complexos — incluem gerenciamento de memória manual (!) — e pouco pythônicos. Ela serve para parsear, consertar, construir documentos XML e HTML e para extrair dados dos mesmos. Normalmente algo mais comum como <a href="https://www.crummy.com/software/BeautifulSoup/"><em>Beautiful Soup</em></a> — que, aliás, é construída em cima da <em>lxml — , </em>é o suficiente para parsear com sucesso um HTML, mas não quando seu HTML é <strong>gigante</strong>. Por ser um <em>binding</em> para C, <em>lxml </em>consegue parsear e atravessar a árvore de grandes elementos em poucos segundos. Com um documento de tamanho “comum”, não será sentida grande diferença em relação a <em>Beautiful Soup</em>, mas, para o nosso caso, a adoção do <em>lxml</em> foi necessária.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/317/1*JgKBRRbZ4fs5uPz-Y5Nd7A.png" /><figcaption>source: <a href="https://lxml.de/">lxml</a></figcaption></figure><p>Você pode estar se perguntando por que tínhamos documentos HTML gigantescos para parsear. Na realidade, esses documentos estavam originalmente no formato PDF e foram transformados, de modo que ficasse mais fácil extrair suas informações. Sua estrutura era bem organizada em parágrafos lógicos, então poder navegar por divs e parágrafos ajudava muito na busca das informações desejadas. Na palestra procurei mostrar as principais funções relacionadas a parse e extração de documentos HTML, mas <em>lxml</em> é um <em>toolkit</em> muito completo, e muitas outras funcionalidades estão disponíveis. Se quiser saber mais, a palestra está disponível <a href="https://github.com/alana91/lxml-parse-html">neste repositório</a> do GitHub com instruções no README, e a documentação completa se encontra <a href="https://lxml.de/4.3/lxmldoc-4.3.3.pdf">aqui</a>.</p><p>Voltando para o TDC, durante o período do chamado <a href="http://www.thedevelopersconference.com.br/call4papers"><em>Call4Papers</em></a>, submeti a palestra com esse assunto. Para tal, precisei fornecer uma descrição para o público, uma mini biografia minha, o tempo estimado e uma explicação sobre a motivação da palestra, além de uma foto pessoal. O formulário para submissão é muito simples, e na época que submeti nem tinha nada preparado ainda, apenas uma ideia do que ia falar e quanto tempo levaria.</p><p>Acredito que o essencial seja ter algo que você queira compartilhar. Essa biblioteca foi muito útil para mim, e eu queria que outras pessoas conhecessem o trabalho dos criadores. Talvez elas também precisassem de algo mais rápido para parsear HTML. É muito comum que em algum ponto duvidemos da nossa ideia, pensemos se alguém achará interessante, se teremos capacidade de produzir algo legal. Mas é importante lembrar que seu papel é ter a ideia e submeter, quem vai avaliar é a coordenação da trilha. Claro que você vai criticar seu trabalho, mas a decisão sobre se ele deve fazer parte do TDC ou não está fora do seu controle. Inclusive, junto com essa, submeti outra que não foi aceita, sobre usar containers Docker no processo de exploração de dados.</p><p>Uma coisa que é interessante e acho que poucas pessoas sabem — eu não sabia, pelo menos — é que a submissão de trilhas também é livre. Ou seja, se você acha que tem um assunto que poderia ser uma trilha de palestras, é só <a href="http://www.thedevelopersconference.com.br/call4trilhas">mandar para avaliação</a>.</p><p>No dia da palestra, eu cheguei no TDC bastante nervosa. Comecei a me questionar sobre pontos da <em>talk</em> e a ter a sensação de que tinha esquecido de algo importante. Minha apresentação, que era um HTML gerado a partir de um <a href="https://jupyter.org/">notebook Jupyter</a>, não estava funcionando como no dia anterior, ao testar poucos minutos antes de subir no palco. Até agora não sei por quê. Mas salvei correndo uma nova versão, que, felizmente, funcionou normalmente.</p><p>Quando comecei a falar, ainda estava nervosa e acho que gagajei um pouco. Mas logo a sensação de ansiedade passou e foquei completamente no que eu queria transmitir, tentando lembrar que eu <em>sabia</em> o que estava falando, e por isso estava tudo bem. No fim dos 25 minutos eu estava me divertindo e contente de ver pessoas compenetradas.</p><p>No tempo disponível para perguntas da plateia, ninguém quis o microfone, e confesso que murchei um pouco. Mas, felizmente, depois que me sentei, um moço veio falar comigo. Queria saber se eu tinha tentando usar o <em>Beautiful Soup </em>antes da <em>lxml</em>. Obrigada, moço! Depois dessa experiência, em todas as palestras que ninguém mais fez perguntas, eu fiz pelo menos uma.</p><p>Fiquei para assistir todas as palestras que se seguiram e recomendo muito a todos checar as apresentações, quando forem disponibilizadas. Meus parabéns a todas as pessoas que palestraram e à coordenação.</p><p>Por que palestrar? Por que se dar ao trabalho de criar uma palestra, ensaiar, estudar, etc. e passar por todo o nervosismo?</p><p>Bom, para mim, apesar do nervosismo, é prazeroso. Eu gosto de compartilhar as coisas que sei com as pessoas, especialmente se é algo completamente novo para elas. Até explicar de novo e de novo de formas diferentes por que a pessoa não entendeu pode ser legal. Com certeza, sempre que tiver algo para compartilhar, vou submeter para o TDC e outros eventos. Mas se você não acha que vai ser uma atividade divertida e quer outras razões, aqui vão três:</p><ul><li><strong>Você ganha entrada grátis para uma trilha por dia do evento</strong>. Caso contrário, você teria que pagar por cada uma — caso não seja uma trilha grátis, como a <em>Stadium. </em>Eu tinha algo que queria ver todos os dias, então considero este um grande benefício.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*q1V01pYKL3NyXZkm" /><figcaption>source: <a href="https://unsplash.com/@f7photo?utm_source=medium&amp;utm_medium=referral">Michael Longmire</a> via <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><ul><li><strong>Networking</strong>. Mais pessoas vão saber quem você é, de onde você vem e o que você sabe. Essas pessoas podem virar contatos e até amizades para trocar conhecimentos e saber o que está acontecendo na indústria. No dia do evento, várias pessoas me adicionaram no Linkedin, e algumas pessoas da <a href="http://floripa.sc.python.org.br/">comunidade Python</a> que considero amigas, conheci ou revi durante as edições de que participei.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lpkn3OKV43TdQzS-" /><figcaption>source: <a href="https://unsplash.com/@samuelzeller?utm_source=medium&amp;utm_medium=referral">Samuel Zeller</a> via <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><ul><li><strong>Falar em público é uma habilidade útil</strong>. Mesmo que você não tenha interesse em palestrar em eventos, provavelmente terá que apresentar um conteúdo para um grupo de pessoas em algum momento, e essa parece ser uma habilidade que melhora com a experiência. Em geral, é difícil falar e se fazer compreender para várias pessoas quando não temos o hábito de fazê-lo.</li></ul><p>Concluindo, é o tipo de coisa que tende a trazer mais ganho que perdas. Se você já considerou minimamente a ideia, vai lá, submete. Desejo-lhe sorte!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bafbeb68d15a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/como-foi-palestrar-no-tdc-bafbeb68d15a">Como foi palestrar no TDC</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Aprendendo sobre a importância dos Testes e refletindo em entregas com qualidade]]></title>
            <link>https://medium.com/aurum-tech/aprendendo-sobre-a-import%C3%A2ncia-dos-testes-e-refletindo-em-entregas-com-qualidade-962c4e8c143a?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/962c4e8c143a</guid>
            <category><![CDATA[teste-funcionais]]></category>
            <category><![CDATA[teste-manual]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[teste-de-software]]></category>
            <dc:creator><![CDATA[Laissa Gomes Pereira]]></dc:creator>
            <pubDate>Thu, 02 May 2019 16:24:27 GMT</pubDate>
            <atom:updated>2019-05-02T16:24:27.105Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*wFfCpE5y3X_THKhtBHzj6A.png" /></figure><p>Garantir a qualidade nas entregas através de testes exigiu de mim uma construção de conhecimentos e habilidades de forma contínua, transformando todas as teorias em práticas ao longo da minha caminhada de quase 1 ano de estágio, no qual adquiri um novo <em>mindset</em> em relação a importância e a valorização dos testes, que refletiu diretamente na união e integração do time, resultando na inovação completa do módulo de publicação do Astrea.</p><p><strong>O que aprendi?</strong></p><p>Aprendi que testar software é praticamente uma arte, pois para a criação dos cenários de testes é necessária muita criatividade na combinação de ações, juntamente com aplicação de técnicas de teste, além do domínio das regras de negócios da aplicação.</p><p>Além disto, para exercer esta atividade com proeza se faz necessário também curiosidade, paciência, uma boa memória, e claro, uma boa comunicação com todo o time, no qual o objetivo da equipe seja entregar um produto de qualidade, de forma a deixar seu cliente feliz e satisfeito.</p><p><strong>Onde se inicia o processo de testes?</strong></p><p>No time de inovação, os testes começam logo no começo do desenvolvimento de uma <em>feature</em> quando o <em>Product Owner</em> pensa e descreve as features, logo isto permite que todos da equipe questionem ou revejam os requisitos da <em>feature</em>, durante a <em>Planning</em> é organizado o que será desenvolvido e quanto tempo de teste será necessário durante a <em>sprint</em>, para features mais importantes são criados cenários de testes funcionais inspirados na técnica chamada <em>BDD </em>desenvolvimento orientado ao comportamento.</p><p><strong>Tornando os Testes reais com os tipos e técnicas de testes manuais</strong></p><p>A homologação é quando o processo de testes de sistema se torna real, lapidando e transformando o produto com qualidade, pois nesse momento que são executados os <strong>testes funcionais</strong> através das verificações e validações das funcionalidades requeridas. Durante os testes funcionais são implementadas várias técnicas como o <strong>particionamento de equivalência</strong> com a utilização de valores válidos e inválidos de maneira equivalente, a <strong>análise de valor limite</strong> que corresponde utilização de valores mínimo e máximo dentro de campo numérico, a <strong>validação de campos obrigatórios e não obrigatórios</strong>, a <strong>tabela de decisão ou combinatória</strong> que são combinações diferentes de condições que resulta em determinados resultados, um exemplo seria testar as combinações dos filtros e a <strong>transição de estado </strong>que verifica se fluxos de entrada e saída de uma tela para outra tela ou de campo para outro campo transita normalmente sem congelar ou quebrar algo no sistema.</p><p>Para completar, os <strong>testes de fumaça ou regressão </strong>são a cereja do bolo que complementam o processo de execução de teste, pois são desafiadores exigem pensar além da funcionalidade desenvolvida verificando, analisando e relacionando como é o comportamento da nova funcionalidade com as outras funcionalidades pré-existentes, mapeando como é o reflexo desta em outras regiões do sistema e se as outras funcionalidades anteriores estão com seu fluxo normal.</p><p>Durante os testes de fumaça ou regressão também são verificados a usabilidade e performance da nova <em>feature</em> implementada.</p><p><strong>Descobrindo a importância da comunicação com a equipe de inovação</strong></p><p>Realizar teste vai além de ter habilidades técnicas, teóricas ou práticas, pois é necessário desenvolver uma boa comunicação e relação com o time como por exemplo uma boa relação com <em>Product Owner</em> para sanar dúvidas sobre os requisitos especificados, alinhar sobre a existência de bugs antigos que podem comprometer a nova <em>feature</em>, ajudar na questão de usabilidade.</p><p>Com relação aos Desenvolvedores é importante demonstrar que a correção dos bugs encontrados valoriza o trabalho deles sem a necessidade de retrabalho por reclamação do cliente quando a aplicação entrar em produção, e que como é muito válido e gratificante entregar um produto com qualidade em relação funcionalidade, usabilidade e performance com um mínimo possível de bugs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sdFFLfAO0GLBBhjD0WHN0w.png" /></figure><p><strong>Conclusão</strong></p><p>Os testes portanto vem a complementar todo um ciclo de desenvolvimento que exige a construção e a implementação de um processo com o intuito de aperfeiçoar, refinar e melhorar o produto, permitindo a inovação e garantindo qualidade nas entregas superando as expectativas dos clientes.</p><p>Alguns sites com matéria sobre mundo dos testes:</p><ul><li><a href="https://ministryoftesting.com/">https://ministryoftesting.com/</a></li><li><a href="https://www.softwaretestinghelp.com/">https://www.softwaretestinghelp.com/</a></li><li><a href="https://gutssc.wordpress.com/">https://gutssc.wordpress.com/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=962c4e8c143a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/aprendendo-sobre-a-import%C3%A2ncia-dos-testes-e-refletindo-em-entregas-com-qualidade-962c4e8c143a">Aprendendo sobre a importância dos Testes e refletindo em entregas com qualidade</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mudando do Selenium para o Cypress]]></title>
            <link>https://medium.com/aurum-tech/mudando-do-selenium-para-o-cypress-682d0834fc5c?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/682d0834fc5c</guid>
            <category><![CDATA[end-to-end-testing]]></category>
            <category><![CDATA[cypress]]></category>
            <category><![CDATA[asynchronous]]></category>
            <category><![CDATA[selenium]]></category>
            <dc:creator><![CDATA[Rossini Leite]]></dc:creator>
            <pubDate>Thu, 28 Mar 2019 19:12:54 GMT</pubDate>
            <atom:updated>2019-03-28T19:12:54.374Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NL72a7rPf5bGyefnwQjfmw.png" /></figure><p>Logo que ingressei na Aurum como QA do <a href="https://www.aurum.com.br/themis-para-escritorios-de-advocacia/">Themis</a>, eu recebi um legado de uma suíte de testes E2E baseada no Selenium e feita em Java. Após um período inicial para entender o padrão <a href="https://martinfowler.com/bliki/PageObject.html"><em>Page Object</em></a><em> </em>e adquirir o conhecimento do projeto e da linguagem, comecei a corrigir e criar testes nessa suíte.</p><p>Conforme trabalhei nessa suíte de testes, notei que estava gastando mais tempo corrigindo testes do que criando novos, além de limitações ao lidar com elementos dinâmicos e processos assíncronos, por exemplo, o <em>select2 </em>do framework <em>angular js e a </em>verificação do carregamento da página evitar de selecionar elementos ainda não renderizados.</p><p>No que tange a questão de manutenibilidade da suíte de testes;além de exigir um conhecimento mais técnico, o Selenium necessita de um caminho muito específico para selecionar um elemento, portanto, qualquer pequena alteração de layout quebra muitos testes.</p><p>Devido a essas limitações, essa suíte de testes acabou sendo abandonada e uma nova ferramenta começou a ser estudada: <a href="https://www.cypress.io/">Cypress</a>. Essa ferramenta surgiu principalmente para lidar com as chamadas assíncronas, características das aplicações com client-side rendering, além de ser nativa em javascript, permitindo uma maior flexibilidade na hora de trabalhar com os elementos do front-end, tornando os testes mais robustos e evitando <a href="https://hackernoon.com/flaky-tests-a-war-that-never-ends-9aa32fdef359">flacky test</a>.</p><p>Neste post apresento como instalar o Cypress, rodar os testes e as principais features que permitem lidar melhor com o comportamento assíncrono, manutenibilidade e testes de features isoladas.</p><h4><strong>Instalação</strong></h4><p>O Cypress pode ser instalado facilmente através do terminal a partir da <a href="https://www.npmjs.com/">NPM</a>.</p><blockquote>npm install cypress</blockquote><p>Com a instalação concluída, tudo que separa você de utilizar o framework é abrir o terminal de comando na pasta desejada e digitar o seguinte comando.</p><blockquote>$(npm bin)/cypress open</blockquote><p>Toda vez que você abrir o Cypress em uma pasta vazia, ele criará um projeto <em>default </em>com alguns exemplos, conforme figura 1.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/305/1*vlruhTyp1bYNX3Uk-CMUUg.png" /><figcaption>Figura 1- Estrutura padrão do projeto</figcaption></figure><p><strong>fixtures: </strong>armazena os dados estáticos utilizados nos testes no formato <em>json.</em></p><p><strong>support: </strong>possui as funções e comandos customizados na suíte de testes.</p><p><strong>integration: </strong>onde são criados os testes.</p><p><strong>plugin: </strong>permite a utilização de plugins externos.</p><p>E externamente à pasta principal, um arquivo <strong>cypress.json</strong> também será criado onde permite definir as principais configurações do testes, como : <em>url base</em>, <em>timeout,etc.</em></p><p>Além de abrir uma interface gráfica(fig. 2) onde mostra os testes disponíveis e permite rodar os testes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/1*257zsL8hG-dnrShZmYSnMw.png" /><figcaption>Figura 2- Interface gráfica do Cypress</figcaption></figure><h4><strong>Rodando os testes</strong></h4><p>Os testes podem ser rodados através da interface ou através do seguinte comando executado na pasta onde está localizado o arquivo <em>cypress.json</em></p><blockquote>$(npm bin)/cypress run</blockquote><h3><strong>Principais features</strong></h3><p>Para demonstrar alguma das features e tornar mais claro, dois arquivos de testes foram desenvolvidos para uma aplicação web, desenvolvida com propósitos educacionais. Os testes e a aplicação estão disponíveis neste <a href="https://github.com/RossiniM/Selenium2Cypress">repositório</a> do github. A aplicação consiste de uma página onde é possível cadastrar transações financeiras, importá-las e apaga-las.</p><p>O primeiro arquivo de teste realiza a inserção de transações, buscando demonstrar as funcionalidades mais básicas do framework: obter elementos e <em>assertions.</em> O segundo arquivo testa a funcionalidade de importação de transações e mostra como realizar testes isolados através do <a href="https://pt.wikipedia.org/wiki/Objeto_Mock"><em>mock</em></a> de requisições.</p><h3><strong>Teste de cadastro de transações</strong></h3><p>A execução deste teste está representada pelo gif 1 e possui o código da figura 3 e 4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HISkwmA_v8Oj6P5cMR0eVg.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/1*qHN53VoI6m9peua9NNBDWQ.png" /><figcaption>Figura 3- Teste de cadastro de transações</figcaption></figure><h4>Criação de uma transação</h4><p>Ao olhar o código, nota-se muitas familiaridades com outros frameworks.</p><p>Começando pela estrutura do teste, baseado em <a href="https://mochajs.org/">Mocha</a>. Percebe-se também nos<em> assertion styles</em> que suportam BDD(expect/should) e TDD(assert).</p><p>Outro ponto importante, principalmente em relação ao <strong>comportamento assíncrono, </strong>é a <em>Retry-Ability</em>. Ao analisar o código de teste(fig.3) é possível notar que há basicamente dois tipos de ação: obter o elemento DOM e validar o parâmetro especificado. O <em>Retry-Ability</em> é a combinação deles, ou seja, primeiro captura um elemento, em sequência o valida. Mas então você deve estar se perguntando onde que está a mágica?</p><p>O Retry-Ability permite, caso a validação não passe, tentar obter o elemento novamente até que o <em>timeout</em> seja alcançado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/1*17sH55m57X7d_6voV0wspQ.png" /><figcaption>Figura 4- Teste de cadastro de transações</figcaption></figure><h4>Criação de várias transações</h4><p>Este teste explora outras funcionalidades do framework um pouco mais elaboradas, dentre elas: <em>fixture</em><strong>(</strong>linha 38)<strong>, </strong><em>funções customizadas</em><strong>(</strong>linha 57<strong>)</strong> e a utilização de<strong> </strong><em>closures</em>(linha 56).</p><h4><strong>Fixture</strong></h4><p>Foi utilizado para armazenar as transações, permitindo cadastrar facilmente através da interação sobre os elementos do do JSON.</p><h4><strong>Closures</strong></h4><p>O Cypress não trabalha com atribuição de variáveis, exceto em poucos casos, sendo o acesso feito através de <em>closures, </em>pois garante o carregamento do elemento ao acessar o seu valor. Nota-se o seu uso ao acessar os valores da fixture.</p><h4><strong>Funções customizadas</strong></h4><p>Por último, na linha 60 foi utilizada a função <em>verificaTabela. </em>Essa função foi criada dentro da pasta <em>support(Figura 5) </em>ficando disponível para qualquer teste dentro deste projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*GU2GAnPpoXU0d8ZG5oyQ2g.png" /><figcaption>Figura 5- Função customizada verificaTabela</figcaption></figure><p>Percebe-se no código que é possível interagir diretamente com os elementos, como usar a propriedade <em>length,</em> aproveitando da vantagem do framework ser nativo em js<em>. </em>Essa interação ajuda a tornar o teste mais dinâmico e robusto.</p><h3>Teste de importação de transações</h3><p>O Cypress foi desenvolvido com o intuito para não apenas lidar com o comportamento assíncrono das aplicações client-side-rendering, mas também permitir testar cada feature de maneira mais isolada possível.</p><p>Por exemplo, testar a renderização das transações na tabela(gif 2). O pré-requisito é o cadastro dessas transações, podendo ser através da inserção manual ou importando através de uma requisição.</p><p>Ambas as alternativas utilizam outras partes do sistema, podendo interferir no teste. Portanto, como é possível testar de maneira mais isolada cada <em>feature </em>do sistema?</p><p>Neste caso o cypress permite mockar requisições xhr e sua resposta, tornando o teste mais isolado e possível, mesmo que a url requerida esteja indisponível.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HE-oG37hTC_qE07EOxlyuw.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/1*nLT7ZuiZ1UI_0XZb8guI3Q.png" /><figcaption>Figura 4 — Teste de importação de transações.</figcaption></figure><p>A figura 4 apresenta o código do teste acima. Destaca-se o trecho da linha 22–27.</p><p>Para simular uma requisição(<em>cy.route())</em> é necessário inicialmente inicializar o server(<em>cy.server()). </em>Além disso, também exige-se o tipo de requisição, endereço e a resposta desejada.</p><p>Portanto , toda vez que a requisição for requisitada pela aplicação, o <em>mock</em> será acionado e retornará a resposta desejada.</p><h3><strong>Conclusão</strong></h3><p>Após começar esse processo de mudança de <em>framework</em>, notei que os testes estão mais estáveis e há uma flexibilidade maior na criação dos testes. Contudo o início foi um pouco vagaroso, pois a estrutura dos testes e do próprio projeto difere bastante do padrão page Object utilizado anteriormente com o Selenium.</p><p>O Cypress oferta ainda várias funcionalidades não abordadas, mas espero com este post ter mostrado algumas das suas principais features, mostrando como você poderá realizar testes E2E e lidar com os comportamentos assíncronos da sua aplicação.</p><p>Segue o link do site oficial do Cypress e do repositório com os testes utilizados, respectivamente.</p><p><a href="https://www.cypress.io/">https://www.cypress.io/</a></p><p><a href="https://github.com/RossiniM/Selenium2Cypress">https://github.com/RossiniM/Selenium2Cypress</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=682d0834fc5c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/mudando-do-selenium-para-o-cypress-682d0834fc5c">Mudando do Selenium para o Cypress</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Validação contínua em contratos de API com Postman]]></title>
            <link>https://medium.com/aurum-tech/valida%C3%A7%C3%A3o-cont%C3%ADnua-em-contratos-de-api-com-postman-2984508368?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/2984508368</guid>
            <category><![CDATA[quality-software]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[postman]]></category>
            <dc:creator><![CDATA[Neto Godoi]]></dc:creator>
            <pubDate>Thu, 21 Mar 2019 20:05:07 GMT</pubDate>
            <atom:updated>2019-03-21T20:05:07.038Z</atom:updated>
            <content:encoded><![CDATA[<p>Não vamos a lugar algum sozinhos e <em>softwares</em> também não. Em tecnologia, assim como na vida, relacionamentos são importantes. Sistemas precisam se comunicar uns com os outros para formar uma solução que agregue valor. Imagine o cenário onde você possui um serviço de encomendas mas não possui os meios para entrega-las, então contrata um serviço que faça isso para você, o <em>Deliveryman API</em>. Como garantir que o serviço estará disponível e sempre retornará o que é preciso para prosseguir com sua operação? É no mínimo complicado garantir isso, certo? Pode ocorrer alguma instabilidade ou o serviço pode sofrer alguma alteração.</p><p>Existem algumas alternativas para diminuir a ocorrência de problemas como esses, como: Definir previamente um contrato entre o serviço externo e sua aplicação, o que torna simples a integração e permite a evolução de maneira sustentável com o uso de versionamento, o <a href="https://swagger.io/"><em>Swagger</em></a> pode ajudar com isso. Mas ainda não há a completa certeza de que o serviço vai estar disponível ou o contrato não vai mudar com o tempo, afinal não depende de você. Mas você depende do serviço.</p><p>Podemos antecipar alguns problemas com a ajuda do <a href="https://www.getpostman.com/"><em>Postman</em></a> e suas ferramentas de teste e monitoramento. Então segue com leitura que lhe explico melhor como fazer.</p><h3>Postman e o segredo que não lhe contaram na faculdade</h3><p>Acredito que você já deve conhecer o <em>Postman</em> (caso não, <a href="https://www.getpostman.com/downloads/"><em>get started here</em></a>), talvez até use ele no dia a dia. Mas você conhece a fundo os benefícios dessa plataforma? Que vai além de ser apenas um cliente para execução de requisições HTTP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VHqvpQg6Qvj2wX1AOCI49g.png" /><figcaption>Disponível em: <a href="https://www.getpostman.com/products">https://www.getpostman.com/products</a></figcaption></figure><p>A plataforma possui diversos recursos que ajudam a manter a qualidade de seus serviços desde a validação do contrato e monitoramento até a documentação e publicação. Irei focar nas ferramentas <a href="https://www.getpostman.com/tools#api-monitoring"><em>Monitor</em></a> e <a href="https://www.getpostman.com/tools#test-automation"><em>Automated Testing</em></a> para garantir o funcionamento do serviço de entregadores e antecipar possíveis problemas.</p><h3>Encontrando entregadores com o Deliveryman API</h3><p>Voltando para o nosso serviço: O <em>Deliveryman API</em> é o serviço externo de entregadores, você solicita um entregador informando o endereço de coleta e peso da encomenda e ele lhe disponibiliza o entregador mais próximo que seja capaz de carregar o peso informado, independe do meio de transporte. Pode ser caminhão, carro, moto ou bicicleta, tudo que você precisa é que a encomenda seja coletada para então seguir seu destino.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/471/1*LXTw48MaBAxYfJUZ9V_D7A.png" /><figcaption><strong>Exemplo de resposta: </strong>Ao solicitar um entregador que possa carregar 30 kg no endereço específico o serviço me retorna o carro mais próximo do ponto de coleta e informa a previsão de realização da coleta.</figcaption></figure><p>Vamos reproduzir essa solicitação dentro do <em>Postman </em>(você pode baixar a ferramenta desktop <a href="https://www.getpostman.com/downloads/">aqui</a>) e então executar a requisição. Neste ponto o contrato entre os serviços ajudaria para que possamos saber quais informações devemos enviar (para saber mais sobre contratos recomendo o estudo sobre <em>Swagger</em> e a especificação <em>Open API</em>). Mas neste caso não temos um contrato bem definido, nosso fornecedor apenas informou que precisamos enviar o peso (<em>weight</em>) e o endereço de coleta (<em>address</em>) através de <em>query parameters </em>na URL do serviço deliveryman-api.herokuapp.com/api/v1/deliveryman/find<strong>?address=250&amp;weight=30 </strong>utilizando o verbo GET. O número 250 passado no <em>address </em>é apenas uma representação, poderia ser as informações de latitude e longitude do ponto de coleta por exemplo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/809/1*ddEEyK8saU_YwhvqCyjvkQ.png" /><figcaption>Representação da solicitação de entregador através do Postman.</figcaption></figure><p>Na imagem a cima podemos ver a representação da requisição por um entregador. Utilizamos o verbo GET no serviço de <em>find</em> do <em>deliveryman API, </em>informando os dados necessários e o retorno foi o carro mais próximo com sua posição atual e o tempo que levará para realizar a coleta. Agora vamos validar se o resultado está como esperado através de testes em Javascript.</p><h3>Testes em Javascript com o Postman Sandbox</h3><p>Agora com a requisição criada precisamos validar o resultado dela. Existe a possibilidade de criar testes para cada requisição ou para uma coleção de requisições. Uma <a href="https://learning.getpostman.com/docs/postman/collections/intro_to_collections/"><em>collection</em></a><em> </em>agrupa requisições de mesmo contexto, isso possibilita compartilhar recursos entre elas, nesse caso temos uma <em>collection </em>com apenas uma requisição.</p><p>Com a ajuda do <a href="https://pt.wikipedia.org/wiki/JavaScript">Javascript</a> podemos escrever testes de forma simples e poderosa, podemos manipular a requisição, a resposta e realizar outras requisições.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/699/1*m4o_hvztGuc348W2P5x3jA.png" /><figcaption>Testando o retorno do serviço de entregadores.</figcaption></figure><p>Na aba <em>Tests </em>estão os <a href="https://learning.getpostman.com/docs/postman/scripts/test_scripts/"><em>test scripts</em></a>, o <em>core</em> dos <em>scripts</em> é o objeto pm que roda em um <em>sandbox environment</em> do <em>Postman. </em>Neste ambiente há<em> </em><a href="https://learning.getpostman.com/docs/postman/scripts/postman_sandbox/">diversas funcionalidades</a> como asserções de testes, bibliotecas utilitárias como a l<a href="https://lodash.com/">odash</a>, c<a href="https://code.google.com/archive/p/crypto-js/">rypto-js</a> e outras. Neste exemplo temos dois testes, o primeiro valida se o status da resposta é 200 para verificar se o serviço está no ar, o segundo valida se a resposta do serviço está como esperamos. Conseguimos essas informações acessando o objeto <em>response</em> dentro do pm.</p><p>Para validar se a resposta está correta podemos usar a biblioteca <a href="https://github.com/geraintluff/tv4">tv4</a>. Basta criar o <em>schema</em> do json esperado identificando todas as propriedades, seus tipos e quais atributos são obrigatórios, neste caso consideramos todos os atributos importantes. Caso a resposta sofra qualquer alteração nosso teste irá falhar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/376/1*mcU5Oe-OEYR1FhT1cJvJgA.png" /><figcaption>Serviço estável e testes executados com sucesso.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/503/1*Evw2jnhBNsKQkmbhPuMujg.png" /><figcaption>Houve uma alteração na resposta do serviço e um atributo não está mais sendo retornado o que gerou falha no teste.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n0TQYKmD7JBibv5nFJuSiA.png" /><figcaption>Acessando o console do Postman podemos obter mais detalhes da requisição e execução dos testes.</figcaption></figure><p>Na imagem a cima podemos ver que o serviço parou de retornar a previsão do tempo que o entregador levará para realizar a coleta, informação que consideramos essencial e deve sempre estar disponível, por este motivo o teste falhou e sinalizou o erro. Através dos comandos Ctrl + Alt + C acessamos o console da ferramenta onde teremos mais detalhes da requisição e da execução dos testes.</p><p>Para saber mais sobre scripts de teste há a sessão de <em>snippets</em> no lado direito dos testes, na qual há diversos exemplos de manipulação do pm:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*cZwBx9S632kSFKWfU7cWBA.png" /></figure><h3>Monitor: Se o serviço falhar você é o primeiro a saber</h3><p>Para utilizar monitores no <em>Postman </em>é preciso ter uma conta, pois este recurso possui um <em>web</em> <em>dashboard </em>que<em> </em>só está disponível para usuários autenticados. Mas é possível fazer o cadastro e utilizar todas as funcionalidades de maneira gratuita com pequenas limitações.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NDRcC-pB2Up1RGYxaMZyDw.png" /><figcaption>Configurando um monitor para o serviço de entregadores.</figcaption></figure><p>Na imagem anterior estamos criando o monitor para o serviço de entregadores. Após escolher as requisições que serão executadas automaticamente podemos definir algumas configurações, como:</p><ul><li>O <a href="https://learning.getpostman.com/docs/postman/environments_and_globals/manage_environments/#___gatsby"><em>environment</em></a> para rodar o monitor.</li><li>Frequência e período das execuções.</li><li>Quais regiões geográficas em que será executado o monitor.</li><li>Alertas por <em>email</em> em caso de falha nos testes ou nas requisições.</li><li>Tempo limite da resposta do serviço.</li></ul><p>Há diversas configurações que podem ser feitas com o monitor, ele possibilita a análise de performance e disponibilidade. Após a definição de configurações o monitor começa a rodar conforme a frequência escolhida e o resultado é apresentado no <em>web dashboard</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Znu7RvHizAgxeuggkM4PQA.png" /><figcaption>Histórico de performance do serviço de entregadores.</figcaption></figure><p>O gráfico mostra o histórico de execução do serviço, informando o horário da execução, a região onde foi executado, o tempo decorrido durante a requisição e os resultados dos testes. As três primeiras execuções falharam no teste de validação devido à ausência do atributo <em>deliveryTime </em>que deveria ser obrigatório.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/364/1*MP4pluVvzR78y8AdxELiMA.png" /><figcaption>Notificação de falha no primeiro teste com erro.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*nh8rEnV9MGiPUJihly5VjA.png" /><figcaption>Notificação de estabilidade do serviço após a correção.</figcaption></figure><p>Quando as execuções falham este alerta é disparado para o <em>email</em> informando que houve uma quebra na execução dos testes. Desta forma podemos tomar uma ação antes mesmo que alguma encomenda seja afetada. Neste caso podemos entrar em contato com o fornecedor para entender o motivo dessa mudança.</p><p>Depois de algum tempo o serviço foi corrigido e voltou a responder como esperado. Como houve mudança do estado do serviço o <em>Postman</em> gera outra notificação informando que o serviço está estável novamente.</p><h3><strong>E isso foi só a ponta do iceberg</strong></h3><p>O que vimos aqui é uma pequena parte dos recursos disponíveis na plataforma, existem diversos outros na versão <em>free</em>,<em> </em>como: documentação, <em>mock servers, team workspaces</em>, entre outros<em>. </em>Sem falar nas versões <em>pro</em> e <em>enterprise. </em>Se quiser aprender mais sobre a plataforma basta acessar o <a href="https://learning.getpostman.com/"><em>Learning Center</em></a><em> </em>onde está disponível toda a documentação com diversos exemplos<em>. </em>O serviço de entregadores está disponível neste <a href="https://github.com/godoineto/deliveryman-api">repositório</a> junto com o link para importação da coleção do <em>Postman</em> utilizada como exemplo.</p><p>Isso é tudo pessoal, espero ter ajudado a trazer mais qualidade e segurança em suas integrações entre serviços. Um grande abraço e que a força esteja com você!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2984508368" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/valida%C3%A7%C3%A3o-cont%C3%ADnua-em-contratos-de-api-com-postman-2984508368">Validação contínua em contratos de API com Postman</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testes de componentes React com Jest e Enzyme]]></title>
            <link>https://medium.com/aurum-tech/testes-de-componentes-react-com-jest-e-enzyme-be3921fae8b1?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/be3921fae8b1</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[jest]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[enzyme]]></category>
            <dc:creator><![CDATA[Márcio Santos]]></dc:creator>
            <pubDate>Thu, 07 Feb 2019 18:11:06 GMT</pubDate>
            <atom:updated>2019-02-07T18:59:27.552Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RDpjmL4hXaOT6oBpwdSIMg.jpeg" /></figure><p>Recentemente na <a href="https://www.aurum.com.br/">Aurum</a> iniciamos um processo de migração tecnológica no front end do sistema <a href="https://app.astrea.net.br/">Astrea</a> partindo do framework AngularJS para o tão falado React. Aproveitamos a situação para tomar algumas decisões com a finalidade de aumentar a qualidade do código e consequentemente do produto, para não cairmos nos mesmos problemas que enfrentamos na tecnologia legada, decisões tais como <em>style guide</em>, configuração de <em>lint </em>e o assunto deste post: testes unitários de componentes. Serão apresentados os conceitos das bibliotecas <em>Jest </em>e <em>Enzyme</em>, como configurá-las em um projeto React e um apanhado geral de como abordamos os testes de componentes e soluções utilizadas aqui na Aurum.</p><h3>Jest</h3><p><a href="https://jestjs.io/">Jest</a> é uma biblioteca que fornece utilitários para testes em javascript, criada pelo Facebook e famosa por sua velocidade e facilidade em iniciar os testes de seu código com zero configuração. Para projetos em react criados com create-react-app não é necessária nem mesmo a instalação, pois ela já vem inclusa.</p><h3>Enzyme</h3><p><a href="https://airbnb.io/enzyme/">Enzyme</a> foi criado pelo <a href="https://airbnb.io/">Airbnb</a> e é definido como:</p><blockquote>Utilitário de testes em javascript para React que facilita verificar, manipular, e percorrer as saídas produzidas por seus components React.</blockquote><h3>Criando e configurando um projeto React</h3><p>Como o foco deste post não é demonstrar como uma aplicação React funciona, apenas mostrarei como criar utilizando o comando create-react-app .</p><pre>create-react-app react-enzyme-tests<br>cd react-enzyme-tests</pre><h4>Configurando o Jest</h4><p>Caso o seu projeto React tenha sido criado manualmente e não utilizando create-react-app , basta instalá-lo como dependência de desenvolvimento usando yarn ou npm:</p><pre>yarn add --dev jest</pre><h4>Configurando o Enzyme</h4><p>Para configurar o enzyme, instale a biblioteca como dependência de desenvolvimento utilizando yarn ou npm:</p><pre>yarn add --dev enzyme enzyme-adapter-react-16</pre><p>Você deve ter notado que além da biblioteca do enzyme, instalamos também um <em>adapter</em> cuja versão bate com a versão do React instalada. O Enzyme disponibiliza <em>adapters</em> para todas as versões do React. Você terá acesso a mais informações a respeito dos <em>adapters </em>neste <a href="https://airbnb.io/enzyme/#installation">link</a>.</p><h4>Arquivo de configuração do Enzyme</h4><p>Em src crie um arquivo javascript para conter a configuração do Enzyme.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*B-qh5OQxkrNvMSBITfwuOw.png" /><figcaption>Arquivo de configuração do enzyme</figcaption></figure><p>Mais adiante serão explanados o porquê e o uso das exportações desta configuração.</p><h4>Estrutura do projeto</h4><p>Você pode criar dois diretórios dentro de src components e components/__tests__ e colocar seus componentes no primeiro e os respectivos testes dentro do segundo, ou colocar o arquivo de teste junto com o do componente testado. Aqui na Aurum nós optamos pela segunda opção pelo fato de que fica mais fácil localizar o arquivo de teste de cada componente ao navegar pela estrutura de diretórios do projeto.</p><h3>Métodos de teste com Enzyme</h3><h4>Shallow</h4><p><em>Shallow rendering </em>é a forma básica de testar um componente utilizando Enzyme, pois limita a renderização apenas ao componente que está sendo testado, ou seja, os filhos não são renderizados. Esse método é ótimo quando se deseja testar componentes de apresentação apenas, ou quando a mudança de comportamento em um componente filho não afeta o componente pai.</p><h4>Mount e Render</h4><p>Ambos <em>mount </em>e <em>render </em>efetuam a renderização total do componente incluindo os componentes filhos. A diferença existente entre os dois, é que o método <em>mount </em>executa os ciclos de vida do componente e o segundo apenas a função <em>render</em>.</p><p>Para exemplificar o funcionamento destes métodos, foi criado um componente de classe que representa uma lista de itens a qual mapeia componentes de itens da lista.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/1*5sk2pXQHClsBQc1Z5LEBQA.png" /><figcaption>Componente de lista de itens</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/518/1*L2E4cn78mGpJI8u0VM0F3w.png" /><figcaption>Componente de item da lista</figcaption></figure><p>Desta forma, foram criados para cada um dos componentes seus respectivos arquivos de teste. No caso do componente ListComponent foram criados dois testes, um utilizando shallow e outro mount .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*IqnuDjtquipPJO6IVp1fWw.png" /><figcaption><em>Suit de testes do componente ListComponent</em></figcaption></figure><h3>Execução dos testes</h3><p>Para executar os testes, basta simplesmente executar o comando yarn test e você deverá perceber em seu console uma saída semelhante a esta:</p><pre>Test Suites: 2 passed, 2 total<br>Tests:       4 passed, 4 total<br>Snapshots:   0 total<br>Time:        5.169s<br>Ran all test suites related to changed files.</pre><p>Caso você queira rodar seus testes com cobertura basta acrescentar o parâmetro --coverage e será exibido em seu console um relatório de cobertura além de ser gerado um diretório chamado coverage o qual contém os arquivos para você visualizar o relatório em seu navegador.</p><p>O comando wrapper.debug() contido no trecho de código apresentado anteriormente retorna a árvore do componente que foi renderizada pelo teste. No caso do shallow o resultado impresso no console foi:</p><pre>&lt;div data-test=&quot;list&quot;&gt;<br> &lt;ListItemComponent label=&quot;Aurum&quot; onClick={[Function: bound ]} /&gt;<br> &lt;ListItemComponent label=&quot;Astrea&quot; onClick={[Function: bound ]} /&gt;<br>&lt;/div&gt;</pre><p>Nota-se que a renderização aconteceu de forma raza, não havendo renderização dos nodos filhos, já no caso do mount a saída no console exibe a árvore completa.</p><pre>&lt;ListComponent items={{...}}&gt;<br> &lt;div data-test=&quot;list&quot;&gt;<br>   &lt;ListItemComponent label=&quot;Aurum&quot; onClick={[Function: bound ]}&gt;<br>     &lt;div&gt;<br>       &lt;button data-test=&quot;listItem&quot; onClick={[Function: bound ]}&gt;<br>         Aurum<br>       &lt;/button&gt;<br>     &lt;/div&gt;<br>   &lt;/ListItemComponent&gt;<br>   &lt;ListItemComponent label=&quot;Astrea&quot; onClick={[Function: bound ]}&gt;<br>     &lt;div&gt;<br>       &lt;button data-test=&quot;listItem&quot; onClick={[Function: bound ]}&gt;<br>         Astrea<br>       &lt;/button&gt;<br>     &lt;/div&gt;<br>   &lt;/ListItemComponent&gt;<br> &lt;/div&gt;<br>&lt;/ListComponent&gt;</pre><p>A função find busca cada nodo na árvore de renderização do <em>wrapper</em> que bate com o seletor informado. O Enzyme suporta qualquer tipo de seletor CSS para buscar esses nodos, portanto é possível utilizar seletores de classe, de elemento e por id. Além disso é permitida a composição de seletores.</p><h3>Mock de funções</h3><p>Com Jest, é possível efetuar o <em>mock</em> de funções. Uma das aplicações disto é quando queremos verificar se determinada função foi chamada na ação de um click, por exemplo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*jBY_b4hkMEaD_cxPZh7X-w.png" /><figcaption>Teste utilizando o mock de funções do Jest</figcaption></figure><h3>Snippets</h3><p>Conforme você vai criando testes pros seus componentes, começa a notar que a estrutura do teste é a mesma, que pra começar a escrever um teste você precisa replicar aquela estrutura básica que consistem nos <em>imports</em>, num <em>setup </em>ou <em>beforeEach, </em>no <em>describe </em>e no teste padrão de renderização do componente. Algumas IDE’s dão suporte a <em>snippets</em>, que são templates que facilitam a criação de trechos de códigos com padrão repetitivo. <a href="https://code.visualstudio.com/">Visual Studio Code</a> permite a criação de <em>snippets</em> personalizados e aproveitamos essa funcionalidade para criar um com nosso padrão de testes.</p><pre>&quot;Test snippet&quot;: {<br>    &quot;prefix&quot;: &quot;aut&quot;,<br>    &quot;body&quot;: [<br>      &quot;import React from \&quot;react\&quot;;&quot;,<br>      &quot;import { shallow } from \&quot;enzymeHelper\&quot;;&quot;,<br>      &quot;import ${TM_FILENAME_BASE/\\.test//} from \&quot;./${TM_FILENAME_BASE/\\.test//}\&quot;;&quot;,<br>      &quot;&quot;,<br>      &quot;const setup = () =&gt; {&quot;,<br>      &quot; const props = {};&quot;,<br>      &quot;&quot;,<br>      &quot; return {&quot;,<br>      &quot;   props,&quot;,<br>      &quot;   wrapper: shallow(&lt;${TM_FILENAME_BASE/\\.test//} {...props} /&gt;)&quot;,<br>      &quot; };&quot;,<br>      &quot;};&quot;,<br>      &quot;&quot;,<br>      &quot;describe(\&quot;${TM_FILENAME_BASE/\\.test//} test suit\&quot;, () =&gt; {&quot;,<br>      &quot; it(\&quot;renders without error\&quot;, () =&gt; {&quot;,<br>      &quot;   const { wrapper } = setup();&quot;,<br>      &quot;   expect(wrapper.exists()).toBeTruthy();&quot;,<br>      &quot; });&quot;,<br>      &quot;});&quot;<br>    ],<br>  }</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*ciJlNfcnQruXNWiqwCZVBg.gif" /><figcaption>Execução do snippet e código padrão de teste</figcaption></figure><h3>Conclusão</h3><p>Neste post eu busquei passar apenas uma visão geral a respeito de Jest e Enzyme, nem de perto pude apresentar a maioria das funcionalidades que essas duas bibliotecas trazem e das possibilidades que essas funcionalidades nos fornecem. Além disso, espero que eu tenha ao menos passado a mensagem de que testar um componente React não é algo doloroso pois essas bibliotecas facilitam e muito a nossa vida como desenvolvedor e com a prática você com certeza pegará gosto em entregar seus componentes com uma cobertura de teste adequada.</p><p>Caso esse post tenha despertado seu interesse, seguem alguns links úteis:</p><ul><li><a href="https://devhints.io/enzyme">https://devhints.io/enzyme</a></li><li><a href="https://devhints.io/jest">https://devhints.io/jest</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be3921fae8b1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/testes-de-componentes-react-com-jest-e-enzyme-be3921fae8b1">Testes de componentes React com Jest e Enzyme</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O que eu aprendi facilitando meu primeiro Design Sprint na Aurum]]></title>
            <link>https://medium.com/aurum-tech/o-que-eu-aprendi-facilitando-meu-primeiro-design-sprint-na-aurum-d0c247abf4b6?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/d0c247abf4b6</guid>
            <category><![CDATA[design-sprint]]></category>
            <category><![CDATA[design-sprint-facilitator]]></category>
            <category><![CDATA[creativity]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[saas-marketing]]></category>
            <dc:creator><![CDATA[Joaquim Mitidiero]]></dc:creator>
            <pubDate>Thu, 20 Dec 2018 20:51:10 GMT</pubDate>
            <atom:updated>2018-12-20T20:51:10.888Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jNgvStgj5eUIdcelwNJBrA.jpeg" /></figure><p>Nos últimos anos, parte do meu trabalho como especialista em branding tem sido a facilitação de processos criativos. Por essa razão, não fiquei exatamente surpresa - ainda assim, lisonjeada - quando a Marcela, minha líder, me convidou para facilitar o primeiro Design Sprint da Aurum. Estávamos considerando uma nova estratégia para um produto e esse método parecia ser uma boa maneira de testá-lo.</p><p>Design Sprint é, como descrito no site, “um processo de cinco dias para resolver problemas e testar novas idéias”. Inventado no Google, testado pelo pessoal do Google Ventures e popularizado desde que se lançou pro mundo em forma de um livro.</p><p>Eu tive a oportunidade de estudar sobre o processo e executar o Sprint em um ambiente seguro. Os líderes que confiaram a mim a missão, realmente confiaram a mim a missão, sem microgerenciamento. Todos os membros da equipe eram pessoas que eu conheço e com quem trabalho. A cultura da Aurum realmente incentiva a mentalidade de teste. Por essas razões, tive uma experiência incrível como facilitadora, e aqui estão algumas dicas que gostaria de compartilhar. Vem comigo! ;)</p><h3>Como facilitadora</h3><h4>1. Siga o processo</h4><p>É a primeira vez que você facilita um Design Sprint? Siga o processo! Você tem experiência com muitos outros métodos? Massa! Agora, siga o processo! Eu reproduzi essa conversa na minha cabeça muitas vezes. Antes de iniciar o Design Sprint, se certifique de estar aberta para adotá-lo. Você pode usar seu histórico anterior para ter ajudar em alguns pontos, mas se for sua primeira vez, dê uma chance ao processo.<br>* Eu poderia dizer “siga o livro”, mas o livro não é mais a única fonte de informação sobre o processo. Confira as referências no final deste artigo.</p><h4>2. Lembre-se do que uma facilitadora faz</h4><p>Como facilitadora, você não tem muitas tarefas, mas tem algumas das mais importantes. Eu gosto de lembrar delas como os três grandes Ps: Pessoas, Processos e Problemas. Sobre Pessoas: fique atenta aos níveis de foco e energia das pessoas, crie momentos e espaços para mantê-los em alta. Sobre Processos: fique atenta ao relógio e ao trabalho a ser feito. Você deve ser a única no controle para que todos possam relaxar e criar grandes coisas. Sobre Problemas: tudo o que acontece e de alguma forma prejudica o processo ou as pessoas é sua preocupação. Eu não estou sendo hiperbólica aqui, eu realmente quero dizer TUDO. Se algo pode atrasar ou interromper o processo ou tirar o foco ou a energia das pessoas, resolva logo!</p><h4>3. Compartilhe a responsabilidade</h4><p>É muito provável (e importante) que todos na Sprint queiram estar lá e fazer um ótimo trabalho juntos. Para dar certo, cada um tem um papel a desempenhar e você foi escolhida para cuidar dos três grandes Ps, certo? Sim, mas você não deve estar completamente sozinha. Todos na Sprint devem assumir alguma responsabilidade com o P de Processos. Essa é uma conversa importante para ter na segunda-feira, o compromisso coletivo com o processo. Caso contrário, seu Sprint pode parecer um jardim de infância — e você, uma babá exausta.</p><h4>4. Seja educado, mas firme</h4><p>Design Sprint é um processo com muitas regras e as pessoas vão tentar barganhar o tempo todo. Elas não vão fazer isso porque são mal intencionadas, elas vão fazer isso porque são seres humanos. Algumas pessoas podem não estar acostumadas com regras, outras podem não estar acostumadas a não co-escrever as regras. É por isso que você deve ser firme! Independentemente de a pessoa com quem você está falando ser o novo estagiário ou o CEO, tenha firmeza e faça aquilo que é indicado pelo método. Isso não significa que você deve ser mandona ou arrogante. Fale pacificamente e explique as razões. Então, faça o que você deve fazer.</p><h4>5. Cuide-se</h4><p>A facilitação é um trabalho de entrega, ajuda, é limpar o caminho para outros percorrerem. Se você tem o perfil de uma facilitadora é bem provável que, às vezes, se esqueça de facilitar seu próprio trabalho. Pegue os três grandes Ps e aplique na sua tarefa. Coloque você mesma no P de “Pessoas” e lembre-se de olhar para dentro. Você bebeu água o suficiente? Você está energizada o suficiente para energizar os outros? Você está dando a si mesma tempo de descanso? Se você se deparar com um problema ao olhar para dentro, tente resolver. Se você não puder resolver, informe a sua equipe que você não está no seu melhor dia. Pedir ajuda é difícil para quem está acostumada a ajudar os outros, é também um sinal de maturidade.</p><h3>Sobre o método</h3><h4>1. Ele funciona</h4><p>Em tempos de métodos milagrosos com nomes legais, acho importante dizer: sim, funciona. Design Sprint não é um growth-mindfulness-agile-mindset-wow-purpose-enlightenment, é um método com um passo a passo. O livro e todo o material on-line sobre ele servem para ensinar o processo e alinhar expectativas. Há uma boa quantidade de relatos de muitas partes do mundo que nos mostram que você pode executar o Design Sprint em qualquer lugar. Então, vá em frente!</p><h4>2. Pode ser estranho para algumas culturas</h4><p>Como brasileira, estou acostumada a falar muito e alto, encostar nas pessoas, argumentar e participar de longas discussões. Design Sprint valoriza o silêncio como uma necessidade para a criação; oferece períodos e formatos específicos para a discussão. Tudo tem um momento e uma maneira de acontecer, exceto o caos. Você conhece o <em>caos criativo</em>? Ele não é convidado para o Design Sprint. Eu não estou te dizendo isso para desencorajar você. Mas se você está prestes a começar um Sprint e sua cultura não é tão sistemática, esteja preparada para experimentar algo novo. Você talvez tenha medo de que todo esse silêncio e a presença de um definidor possam tirar o espírito de co-criação. Eu posso te dizer que isso não acontece. É apenas uma maneira diferente de co-criar.</p><h4>3. “Nenhum dispositivo” é realmente necessário</h4><p>Os autores são muito firmes sobre a regra “sem dispositivos eletrônicos”, e eles estão certos em fazer isso. Não apenas o processo do Sprint, mas em qualquer dinâmica ou reunião em que o foco e a criação são essenciais. Tirar os dispositivos das mãos das pessoas vai ser bem penoso no primeiro dia, mas fica melhor ao longo da semana. Eu acredito que as pessoas no fundo querem estar presentes e se desligar do resto, mas elas se sentem culpadas. Culpe o método, culpe o livro, culpe o facilitador e deixe as pessoas livres para se concentrar em uma só coisa, o Sprint.</p><h4>4. Abrange até sexta-feira</h4><p>O método do Design Sprint envolve tudo o que acontece desde o objetivo inicial até o final das entrevistas. O que acontece depois das entrevistas? De acordo com o livro, você deve decidir o que fazer e anotar. É um pouco vago, e foi o ponto onde minha experiência prévia como facilitadora e a experiência do nosso decisor como CEO foram mais necessárias. Eu não estou dizendo que é uma lacuna enorme, conseguimos facilmente lidar com isso. Mas, como o livro é muito meticuloso sobre cada pequeno passo, ele pode deixar as pessoas perdidas aqui.</p><p>Facilitar o primeiro Design Sprint da Aurum foi um desafio incrível. Me estimulou a estudar algo novo e me ensinou a conciliar conhecimentos que eu já tinha com os desafios de uma primeira experiência. Além disso, conviver em imersão com a equipe de áureos foi super intenso. Por mais que todo mundo já se conhecesse, tivemos a oportunidade de ver mais de perto os talentos de cada um — que são muitos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wia3-Xj33Pp03sn_j924Pg.jpeg" /><figcaption>Obrigada, pessoal, vocês foram incríveis! ❤</figcaption></figure><p><em>Espero que você tenha se sentido estimulada a rodar um Sprint por aí também. Se você tiver alguma outra dica que queira compartilhar, tiver perguntas ou perspectivas diferentes sobre o método, vamos falar sobre isso nos comentários abaixo. :]</em></p><p>Mais conteúdo sobre o Design Sprint:</p><blockquote><a href="https://sprintstories.com/">https://sprintstories.com/</a></blockquote><blockquote><a href="https://sprintstories.com/nine-tips-for-successful-sprinting-that-arent-in-the-sprint-book-92c37b498257">https://sprintstories.com/nine-tips-for-successful-sprinting-that-arent-in-the-sprint-book-92c37b498257</a></blockquote><blockquote><a href="https://sprintstories.com/23-facilitation-tips-for-design-sprints-34d876aa5317">https://sprintstories.com/23-facilitation-tips-for-design-sprints-34d876aa5317</a></blockquote><blockquote><a href="https://www.youtube.com/playlist?list=PLxk9zj3EDi0X5CgoFckoheIFAx-uT2i7j">https://www.youtube.com/playlist?list=PLxk9zj3EDi0X5CgoFckoheIFAx-uT2i7j</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0c247abf4b6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/o-que-eu-aprendi-facilitando-meu-primeiro-design-sprint-na-aurum-d0c247abf4b6">O que eu aprendi facilitando meu primeiro Design Sprint na Aurum</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design thinking: um exercício de empatia]]></title>
            <link>https://medium.com/aurum-tech/um-exercicio-de-empatia-65c6b4933fa2?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/65c6b4933fa2</guid>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Eduardo Wichoski]]></dc:creator>
            <pubDate>Thu, 29 Nov 2018 12:29:37 GMT</pubDate>
            <atom:updated>2018-11-29T12:29:37.205Z</atom:updated>
            <content:encoded><![CDATA[<p>Por definição, empatia é a nossa habilidade de conseguir ver o mundo pelos olhos de outra pessoa. Ver o que ela vê, sentir o que ela sente e buscar agir e pensar da mesma forma que ela. <em>A empatia nos permite entender e ajudar outras pessoas e é sobre isso que quero tratar aqui.</em></p><p>A empatia é extremamente importante nas etapas iniciais de qualquer projeto de design, pois é preciso um profundo entendimento das pessoas para as quais nós estamos projetando e do problema que estamos tentando resolver. <strong>A empatia é uma ferramenta de solução de problemas.</strong></p><h3>O contexto</h3><p>Proporcionar uma melhor experiência com o controle das publicações jurídicas no Astrea (nosso software para escritórios de advocacia) era um dos nossos principais objetivos no <strong>Quarter 4/2018.*</strong></p><p><em>*Metodologia OKR: </em><a href="http://qulture.rocks/blog/okrs-o-que-sao-como-implementar/"><em>http://qulture.rocks/blog/okrs-o-que-sao-como-implementar/</em></a></p><p>As publicações jurídicas são de extrema importância para o trabalho de um advogado, uma vez que informam os prazos, as movimentações gerais de cada processo e as sentenças do judiciário.</p><p>Apesar de sua importância, a experiência do controle de publicações jurídicas com o Astrea era inconsistente e possuía muitos problemas:</p><ul><li>Mais de 60 sugestões de melhoria em nossa Central de Sugestões</li><li>Alto volume de chamados de suporte</li><li>Baixo índice de satisfação com a funcionalidade (NPS: <a href="https://satisfacaodeclientes.com/net-promoter-score/">https://satisfacaodeclientes.com/net-promoter-score/</a>)</li></ul><p>Esses indicadores levaram nós do time de produto a querer entender essa insatisfação e agir para proporcionar uma experiência cada vez melhor e mais consistente.</p><h3>Mapeando experiências</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XdZfmuHhbCRijEcWsaYA4A.png" /></figure><p>A melhor maneira de nos aproximar do usuário e entender por completo sua experiência dentro da funcionalidade de publicações jurídicas existente, era realizar um exercício de empatia, através do mapeamento da jornada do advogado nessa funcionalidade com início, meio e fim, e seus sentimentos ao longo de cada etapa.</p><p>O processo utilizado para atingir nosso objetivo foi o <strong>mapa da experiência</strong>, pois este tipo de mapa está preocupado com o modo como o produto se encaixa na experiência de uma pessoa, e não ao contrário. <strong>Eles fornecem uma visão através do ponto de vista do usuário.</strong></p><p>Para este mapeamento, é necessária uma jornada com etapas bem definidas para serem analisadas. Dentro do módulo de publicações jurídicas existe mais de um caminho a ser seguido, mas após algumas pesquisas e conversas com nossos clientes, nós decidimos iniciar o mapeamento pelo principal: <em>a jornada de tratamento</em><strong><em>*</em></strong><em> de uma publicação</em>.</p><p>* T<em>ratar uma publicação é o termo que usamos para quando o usuário lê uma publicação e toma ações, como marcar atividades em sua agenda a partir dela.</em></p><p>Dividimos essa jornada de tratamento em 10 etapas <em>(os post-its rosas na foto abaixo) </em>e começamos a analisar cada uma delas separadamente.</p><p>Para cada etapa, nós definimos algumas key questions (ou seja, o que o usuário se pergunta quando se depara com essa etapa específica), um nível de humor entre três (🙂😐☹️), um sentimento atual, um sentimento desejado e soluções práticas para melhorar a experiência em cada etapa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QZV11JNc78VxBYszN_S47w.png" /><figcaption>Detalhe do mapa: key questions e humor do usuário em cada etapa.</figcaption></figure><p>Por exemplo, na primeira etapa do mapeamento, a <strong>visualização da listagem de publicações jurídicas</strong>, definimos que o usuário se perguntava &quot;<em>será que já chegou tudo?</em>&quot;, que seu humor era<em> neutro, </em>mas que seu sentimento <strong>atual</strong> era de apreensão (pois poderia estar faltando alguma publicação e ele não gostaria de perdê-la). Também definimos que o sentimento <strong>desejado</strong> nesta etapa era o de tranquilidade. Todas essas definições foram guiadas pelas pesquisas e conversas prévias, e com empatia, nos colocando no lugar do usuário.</p><p>Fizemos o mesmo para todas as outras etapas e ao final, nós inserimos mais uma linha (a mais importante) no mapeamento, onde criamos soluções práticas que possibilitariam neutralizar ou inverter os sentimentos negativos.</p><p>Isso quer dizer que, em etapas que identificamos que o usuário poderia estar ansioso e desejamos que ele estivesse tranquilo, propomos ações práticas específicas que poderiam influenciar nesse sentimento.</p><p>O mais legal desse mapeamento é que surgiram ótimas soluções para problemas que nenhum usuário havia reportado anteriormente, mas que todos gostaram após validarmos as ideias. Realizar um extenso exercício de empatia e nos colocar no lugar do usuário nos permitiu identificar ótimas oportunidades para tornar a experiência mais consistente.</p><h3>Considerações</h3><p>Antes de iniciarmos esse exercício houve muita pesquisa, conversa com usuários e validação de problemáticas, caso contrário, correríamos risco de fazer uma análise enviesada. Os dados que surgiram dessas conversas e pesquisas nos permitiram mapear a experiência com a certeza de que estávamos no caminho certo.</p><p>Ao realizar um mapa da experiência, vale lembrar que estamos deixando de lado coisas técnicas como funcionalidades específicas e estamos nos aprofundando em uma análise emocional, ou seja, como o usuário se sente em cada etapa e como deixar essa experiência mais agradável e consistente com soluções práticas.</p><p>Por exemplo, uma solução que surgiu da análise da <em>primeira etapa que comentei lá em cima</em>, foi criar uma área informando ao usuário que a listagem estava 100% atualizada, para deixá-lo tranquilo ao invés de apreensivo (lembra o que falei sobre neutralizar emoções?).</p><p>Ao final do exercício, também achamos incrível como foi importante para alinhar todos da equipe em relação ao módulo de publicações jurídicas, e como isso nos deu insumos e insights para continuarmos o desenvolvimento do novo módulo.</p><h3>Links e referências úteis</h3><p>KALBACH, Jim. Mapeamento de Experiências: Um guia para criar valor por meio de jornadas, blueprints e diagramas. Rio de Janeiro: Alta Books, 2017.</p><p>Rapid Techniques for Mapping Experiences. 2016. Disponível em: &lt;https://www.youtube.com/watch?v=STPzzJCoQcY&gt;.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65c6b4933fa2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/um-exercicio-de-empatia-65c6b4933fa2">Design thinking: um exercício de empatia</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Friendly code review]]></title>
            <link>https://medium.com/aurum-tech/friendly-code-review-541a32545253?source=rss----1f417c7a9fba---4</link>
            <guid isPermaLink="false">https://medium.com/p/541a32545253</guid>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[quality-software]]></category>
            <dc:creator><![CDATA[Neto Godoi]]></dc:creator>
            <pubDate>Thu, 22 Nov 2018 11:57:18 GMT</pubDate>
            <atom:updated>2018-11-23T09:30:27.200Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B7n_4UvE1h5IYF7Li-V75g.jpeg" /></figure><p>A boa e velha revisão de código, popular entre times ágeis e matéria-prima para aquelas piadas na hora do café. Seja você um desenvolvedor experiente ou iniciante, já deve ter tido algum contato com <a href="https://en.wikipedia.org/wiki/Code_review"><em>code review</em></a> e aposto que já sentiu um frio na espinha ao ter o código revisado por outra pessoa. Esse sentimento é natural e muito comum, afinal, tem alguém procurando falhas na sua implementação. Porém, isso pode tornar o processo doloroso, tanto para o desenvolvedor, quanto para o revisor. Aceitar sugestões e aprender com elas ou sugerir melhorias realmente relevantes não é nada trivial. Mas afinal, este processo precisa mesmo gerar incômodo? Como podemos tornar o <em>code review</em> mais amigável sem deixar de ser pragmático?</p><h3>Code Review Driven Development</h3><p>Uma boa alternativa é pedir a opinião de outros desenvolvedores constantemente, antes mesmo do código estar pronto. Faça isso no dia a dia, disponibilize um <a href="https://git-scm.com/book/pt-br/v1/Ramifica%C3%A7%C3%A3o-Branching-no-Git-O-que-%C3%A9-um-Branch"><em>branch</em></a> ou <a href="https://msdn.microsoft.com/en-us/library/ms181403(VS.80).aspx"><em>shelveset</em></a> (dependendo do controlador de versão que estiver usando) com o trecho do código para ser revisado, ou faça <a href="https://en.wikipedia.org/wiki/Pair_programming"><em>pair programming</em></a><em> </em>para obter um <em>feedback</em> imediato. O objetivo é transformar essa prática em um hábito transformando a revisão, antes tensa e burocrática, em uma conversa casual. Essa troca de experiências entre desenvolvedores só agrega valor para o projeto e para os envolvidos. Meio óbvio, eu sei, mas muitas empresas não veem revisão de código como parte essencial no processo de desenvolvimento.</p><p>Outra prática interessante: de tempos em tempos volte seus olhos para seu código antigo, de meses atrás, você terá as duas perspectivas, será revisor e desenvolvedor. Muito provavelmente o feedback será amigável, afinal é o seu trabalho que você está avaliando, e também será receptivo com as sugestões. Claro que não dá pra fazer isso sempre e pode parecer meio bobo, mas vale a tentativa.</p><h3>Friendly and Pragmatic</h3><p>Um code review amigável é algo que pode ser feito tanto pelo desenvolvedor quanto pelo revisor, é uma via de mão dupla. Como desenvolvedor você pode:</p><ol><li>Pedir, constantemente, <em>feedbacks</em> para pequenos trechos de código. Assim o resultado final terá uma melhor qualidade e gerará menos retrabalho;</li><li>Revisar as regras do projeto utilizadas pelo time antes de abrir o <em>pull request</em> (ou <em>merge request</em>). Caso não haja nenhuma, construa isso com seu time;</li><li>Documentar corretamente o que precisa ser avaliado e como validar a implementação. Explique de maneira clara e concisa o objetivo do seu código;</li><li>Garantir o bom funcionamento do código, cobrindo-o com testes unitários (essa pode até ser uma regra para o seu time);</li><li>Evitar ao máximo revisões para trechos gigantes de código, com dezenas de arquivos alterados. Coloque-se no lugar do revisor, você gostaria de avaliar mais de 60 arquivos com alterações? Aposto que não.</li></ol><p>Como revisor, você pode:</p><ol><li>Ser um mentor. Ao revisar um código assuma a postura de mentor, o seu objetivo não é mais procurar por falhas na implementação, e sim mostrar como o desenvolvedor pode fazer melhor. Caso não possua experiência ou conhecimento necessário, peça ajuda para um desenvolvedor mais experiente, ou utilize ferramentas para análise de qualidade de código, como o <a href="https://www.sonarqube.org/"><em>sonarqube</em></a><em> </em>que possui <em>plugins</em> para as principais IDEs em mais de 20 linguagens de programação;</li><li>Não ser chato, evitar revisões do tipo: “<em>Trocar o if (objeto == null) para if (Objects.isNull(objeto))!”</em>. Se você olhar a implementação do <em>isNull</em> dentro da classe <em>Objects</em> verá que é a mesma coisa, procure agregar valor real em suas revisões;</li><li>Revisar rápido e analisar de verdade. Tenha em mente que o tempo dos dois é importante, não desperdice muito tempo revisando e também não faça o desenvolvedor ficar dias esperando seu <em>feedback</em>. Revisar não é apenas passar o olho ou executar os testes, analise de verdade o código. Depois de aprovado, aquele código passa a ser sua responsabilidade também;</li><li>Ter um <em>check list. </em>Tudo na vida funciona melhor quando se sabe o que fazer. Ele vai te ajudar com o que procurar e por onde seguir. Por exemplo:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/1*-_OBdELYOCjrqPJrGke0SA.png" /></figure><h3>Keep going up</h3><p>Revisar o código constantemente ajuda a manter seus projetos, e seus conhecimentos, em constante desenvolvimento. Dessa forma, a qualidade do código é aprimorada e você evolui como profissional. É uma relação ganha-ganha.</p><p>Aqui na <a href="https://www.aurum.com.br/quem-somos/">Aurum</a>, nós temos plena ciência disso e procuramos sempre melhorar a qualidade das revisões e do processo. Possuímos algumas regras para revisão (o código deve possuir uma cobertura razoável de testes unitários) e tornamos a discussão sobre qualidade de software uma <a href="https://medium.com/aurum-tech/clube-da-leitura-clean-code-c63e09e25875">rotina do time</a>.</p><p>Para finalizar, seguem alguns conteúdos que podem melhorar sua <em>coding skill </em>para mandar bem na hora do <em>code review:</em></p><ol><li>Livro: <a href="https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1_sspa?s=books&amp;ie=UTF8&amp;qid=1536592228&amp;sr=1-1-spons&amp;keywords=clean+code&amp;psc=1">Clean Code by Robert C. Martin</a></li><li>Livro: <a href="https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/ref=sr_1_3?s=books&amp;ie=UTF8&amp;qid=1536591252&amp;sr=1-3&amp;keywords=refactoring">Refactoring by Martin Fowler</a></li><li>Livro: <a href="https://www.amazon.com.br/Cabe%C3%A7a-Padr%C3%B5es-Projetos-Eric-Freeman/dp/8576081741">Head Firts - Design Patters by Eric Freeman and Bert Bates</a></li><li>Livro: <a href="https://www.casadocodigo.com.br/products/livro-oo-solid">Orientação a Objetos e SOLID para Ninjas</a> by <a href="https://medium.com/u/8e9549404863">Maurício Aniche</a></li><li>Podcast: <a href="https://www.youtube.com/watch?v=Pt1cskz4iVA">BranasCast - Code Review</a> by <a href="https://medium.com/u/ba8652b319eb">Rodrigo Branas</a></li><li>Blog post: <a href="https://www.atlassian.com/agile/software-development/code-reviews">Why code reviews matter by Dan Radigan</a></li></ol><h4>Que a força esteja com você!</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=541a32545253" width="1" height="1" alt=""><hr><p><a href="https://medium.com/aurum-tech/friendly-code-review-541a32545253">Friendly code review</a> was originally published in <a href="https://medium.com/aurum-tech">Aurum Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>