<?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[Bee Lab Academy - Medium]]></title>
        <description><![CDATA[A Bee Lab poliniza o conhecimento através de eventos, mentoria e treinamentos presenciais e online no universo da tecnologia. - Medium]]></description>
        <link>https://medium.com/beelabacademy?source=rss----fa1ab4e43c0---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Bee Lab Academy - Medium</title>
            <link>https://medium.com/beelabacademy?source=rss----fa1ab4e43c0---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 23:02:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/beelabacademy" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Desenvolvendo Testes Mais Coesos e Sem Code Smells]]></title>
            <link>https://medium.com/beelabacademy/desenvolvendo-testes-mais-coesos-e-sem-code-smells-26f508e81cc4?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/26f508e81cc4</guid>
            <category><![CDATA[code-smells]]></category>
            <category><![CDATA[test]]></category>
            <category><![CDATA[sonar]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[clean-code]]></category>
            <dc:creator><![CDATA[Chrystian Costa da Rosa]]></dc:creator>
            <pubDate>Thu, 01 Oct 2020 08:23:12 GMT</pubDate>
            <atom:updated>2020-10-01T08:23:12.171Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nMakryUgMGVicqHZ.png" /><figcaption><a href="https://www.geeksforgeeks.org/7-tips-to-write-clean-and-better-code-in-2020/">geeksforgeeks.org</a></figcaption></figure><p>Muito se discute hoje em dia a respeito das diversas formas de se codificar os testes automatizados, independente da linguagem de programação. Em meio as regras e convenções, encontram-se alguns costumes disfarçados de padrões.</p><blockquote>Mas até aonde nossos costumes nos ajudam?</blockquote><blockquote>Será que realmente fazem sentido ou são apenas pretextos para evitarmos as mudanças?</blockquote><blockquote>Com o que estamos em conformidade exatamente?</blockquote><p>Foram esses questionamentos que me levaram a pesquisar um pouco mais sobre o assunto e, entre as diversas fontes que encontrei, escolhi a base de regras do <a href="https://rules.sonarsource.com/">SonarSource</a> como parâmetro para abordar alguns tópicos.<br>SonarSource é uma empresa que desenvolve <em>software </em>de código aberto para a qualidade e segurança de código, detectando problemas de manutenção, confiabilidade e vulnerabilidade em mais de 20 linguagens de programação. Entre seus principais produtos estão o <a href="https://www.sonarsource.com/products/sonarlint/">SonarLint</a>, o <a href="https://www.sonarsource.com/products/sonarqube/">SonarQube </a>e o <a href="https://sonarcloud.io/">SonarCloud</a>, que você provavelmente deve conhecer pelo menos um deles.</p><p>Como foco para o artigo escolhi testes na liguagem Java, filtrei as regras que mais se encaixam em meu contexto e selecionei as mais relevantes (no ponto de vista) e adicionei alguns outros tópicos importantes.</p><h4>Regras de desenvolvimento de testes anti<em> code smells</em></h4><ul><li><strong>As classes de teste devem seguir uma convenção de nomenclatura (</strong>RSPEC-3577<strong>)<br></strong>Busque definir um padrão “universal” para as classes de testes em todos os seus projetos, preferencialmente, adicionando um sufixo no nome das classes. Os padrões comumente usados e muitas vezes reconhecidos automaticamente pelos frameworks são *Test, *Tests e *TestCase. Por exemplo, se a classe a ser testada é <strong><em>Account.java</em></strong> use algo como <strong><em>AccountTest.java.</em></strong></li><li><strong><em>TestCases </em>devem conter testes (</strong>RSPEC-2187<strong>)<br></strong>Como mencionado anteriormente, entende-se por convenção que as classes com sufixo Test, Tests, ou TestCase são classes de testes(ou test cases), sendo assim, não utilize esse padrão para nomear classes que não contenham testes. Mas se for realmente necessário, prefira colocar Test como prefixo.</li><li><strong>Os métodos de teste devem seguir uma convenção de nomenclatura (</strong>RSPEC-3578<strong>)<br></strong>Assim como as classes, os métodos também precisam seguir um padrão de nomenclatura. Se você ainda não tem um, experimente adotar. Não só deixa seus testes em conformidade, como também ajuda na compreensão do seu código. Por exemplo:<br>Ao invés de usar <strong><em>createAccount()</em></strong> tente <strong><em>testCreateAccount()</em></strong> ou então <strong><em>mustCreateAccount().</em></strong></li><li><strong>Testes devem conter asserções (</strong>RSPEC-2699<strong>)<br></strong>Parace besteira, mas não é.<br>Sim, existem situações em que pessoas desenvolvem testes sem asserções. Na verdade, se não tem validações, não é bem um teste, está mais é para um “robô”.</li><li><strong>Argumentos de asserção devem ser passados na ordem correta (</strong>RSPEC-3415<strong>)<br></strong>Verifique sempre a ordem dos argumentos esperado e atual para não gerar falsos positivos/negativos.</li><li><strong>Valores booleanos literais não devem ser usados ​​em asserções (</strong>RSPEC-2701<strong>)<br></strong>Não use assertTrue(true) ou similares, a não ser que você queira enganar a si mesmo. rsrs</li><li><strong>Matenha os testes nas classes de testes (</strong>RSPEC-2186<strong>)<br></strong>As asserções não devem ser usadas nos métodos que não são de testes como “<em>run</em>”, por exemplo, porque as asserções com falha resultam em <em>AssertionErrors</em>, se o erro for lançado de uma <em>thread </em>diferente daquela que executou o <em>assert</em>, a <em>thread </em>será encerrada, mas a asserção não falhará.</li><li><strong><em>Thread.sleep</em> não devem estar presentes nos testes (</strong>RSPEC-2925<strong>)<br></strong>Por favor, remova imediatamente!<br>Usar Thread.sleep em um teste geralmente é uma má ideia. Ele fragiliza os testes que podem falhar de forma imprevisível, dependendo do ambiente, ou da carga.<br>Uma ótima alternativa é usar o <a href="https://github.com/awaitility/awaitility"><em>Awaitility</em></a>, uma biblioteca gratuita, prática e muito útil para implementar esperas e condições em testes assíncronos.</li><li><strong>Não use mais de um test runner framework (TestNg, JUnit, etc)<br></strong>Isso pode facilmente causar erros nos seus testes, você pode se confundir na utilização e importação e quando o erro acontecer, você vai demorar uma vida para identificar o que está causando.</li><li><strong>Para fechar com chave de ouro: Utilize o padrão AAA(Arrange-Act-Assert)<br></strong>Arrange-Act-Assert no bom português seria “Organizar, Agir e Verificar”. É um padrão para formatar o código nos métodos de testes de forma que fiquem organizados, limpo e de fácil entendimento:<br><br>//Arrange: Organize todas as condições e entradas necessárias.<br>//Act: Atue no objeto ou método que irá gerar o resultado.<br>//Assert: Verifique se estão de acordo com os resultados esperados.<br> <br>* Cada método deve agrupar essas seções funcionais, separadas por linhas em branco.</li></ul><h4>Palavras finais</h4><p>É de suma importância que tenhamos embasamento nos padrões adotados em nossos projetos, buscando sempre seguir boas práticas de desenvolvimento.</p><p>Uma excelente dica que lhe ajudará a seguir essas e outras regras, adicionar <em>plugins </em>às suas <em>IDEs </em>que façam essa análise no código, como o <em>plugin </em>do <em>SonarLint</em>, por exemplo.</p><p>Ficamos por aqui. Até o próximo!<br><em>Peace!</em></p><p><a href="https://www.linkedin.com/in/chrystiancr/"><strong><em>Chrystian C. Rosa</em></strong></a></p><h4>Referências</h4><p><a href="https://rules.sonarsource.com/java/tag/tests">Rules explorer</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26f508e81cc4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/desenvolvendo-testes-mais-coesos-e-sem-code-smells-26f508e81cc4">Desenvolvendo Testes Mais Coesos e Sem Code Smells</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte IV]]></title>
            <link>https://medium.com/beelabacademy/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-iv-bfe1937cd5cc?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/bfe1937cd5cc</guid>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[restsharp]]></category>
            <category><![CDATA[automation-testing]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Breno Ferreira]]></dc:creator>
            <pubDate>Thu, 02 Jul 2020 12:25:09 GMT</pubDate>
            <atom:updated>2020-06-22T16:14:51.356Z</atom:updated>
            <content:encoded><![CDATA[<h3><a href="https://medium.com/beelabsolutions/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-iii-88bbe351fa77?source=your_stories_page---------------------------">Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte I</a>V</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/578/1*OICaHvjcxhpFofj6Bai6aA.jpeg" /></figure><p>Galera, chegamos a nossa última publicação sobre testes de API utilizando RestSharp com C#, conforme mencionei na publicação <a href="https://medium.com/beelabsolutions/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-iii-88bbe351fa77">anterior </a>vamos abordar o método POST.</p><p>Criaremos um um novo teste no mesmo projeto que haviamos criado anteriormente onde validávamos o método GET.</p><p>Então teremos a seguinte estrutura conforme a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/511/1*9wl0-PPfFwjRhuS_CqgUqg.png" /></figure><p>Temos dois pontos de atenção nesse trecho marcado em vermelho.</p><ol><li>No nosso Method devemos indicar que estamos enviando um POST;</li><li>Devemos informar que estamos enviando uma requisição no formato Json pois caso não venhamos informar ocorrerá um erro;</li></ol><p>Obs.: Alguns pontos da estrutura do nosso teste não irei explicar nessa publicação galera porque já descrevi linha a linha na publicação anterior que pode ser vista <a href="https://medium.com/beelabsolutions/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-iii-88bbe351fa77">aqui</a>.</p><p>Dando continuidade, após criarmos nossa estrutura inicial vamos criar uma pasta no nosso projeto e dentro dessa pasta iremos criar uma nova classe com o nome de MethodPost (talvez não seja o melhor nome de classe, mas não se preocupem com isso no momento).</p><p>Botão direito do mouse em cima da pasta Model → Add → Class iremos criar uma nova classe e então teremos o seguinte resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3oiHcqGu0PmaZ7ZkqdXK9Q.png" /></figure><p>Nossa classe será pública pois iremos consumir três valores que iremos adicionar nela de acordo com nosso POST, esses três valores são ID, MARCA e CARRO, portanto teremos a estrutra abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*avYx8KvSdAdV3I-aSJnaNQ.png" /></figure><p>No nosso teste precisamos fazer uma referência para a classe que criamos pois queremos utilizar todas as propriedades existentes na classe essa referência está em destaque, então iremos criar algo do tipo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/478/1*wkWlLOPjOHMaIfV1xCcMUw.png" /></figure><p>Após fazermos essa referência é hora de passar nossos valores que serão enviados no nosso POST, então teremos a estrutura:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*0UFctCRURgaBtn1i7VnJPw.png" /></figure><p>Após criarmos nosso código deveremos ter uma estrutura similar a essa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/904/1*vmDMIWrzaPYN_MEpiLpnzA.png" /></figure><p>Galera, tenham atenção na linha 55 onde eu alterei nosso StatusCode para 201 pois indica que fizemos uma criação e outro ponto alterado foi nosso Assert pois nesse ponto estamos validando nosso ID.</p><p>Iremos executar nosso servidor JSON e iremos executar nossos testes, caso tenha ocorrido tudo com sucesso teremos os seguintes resultados:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aE72fEsqY-Qlxen4ZNjg_g.png" /></figure><p>Como podem ver os testes foram executados com sucesso e se acessarmos o endereço <a href="http://localhost:3000/tests">http://localhost:3000/tests</a> que no caso esta especificado no nosso servidor JSON teremos um novo ID com marca e carro e seus respectivos valores atribuídos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xEzkeLpCfCbFrLfZ2WUxEA.png" /></figure><p>Galera, chegamos ao final dessa série de publicações envolvendo automação de testes de API com RestSharp e C#, foi algo bem simples, mas que acredito que possa agregar algum valor, espero que tenham gostado e caso tenham algum feedback fiquem a vontade.</p><p>Caso tenham interesse disponibilizei o código do nosso projeto no meu github: <a href="https://github.com/BRodrigo/RestSharp/tree/master/RestSharpDemo">https://github.com/BRodrigo/RestSharp/tree/master/RestSharpDemo</a></p><p>That’s all folks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfe1937cd5cc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-iv-bfe1937cd5cc">Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte IV</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automatize testes do seu projeto sem escrever uma única linha de código.]]></title>
            <link>https://medium.com/beelabacademy/automatize-testes-do-seu-projeto-sem-escrever-uma-%C3%BAnica-linha-de-c%C3%B3digo-b972a56a8588?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/b972a56a8588</guid>
            <category><![CDATA[qa-testing]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[automation-testing]]></category>
            <dc:creator><![CDATA[Demis Meneghetti]]></dc:creator>
            <pubDate>Thu, 18 Jun 2020 19:34:58 GMT</pubDate>
            <atom:updated>2020-06-19T09:12:28.854Z</atom:updated>
            <content:encoded><![CDATA[<h3>Automatize testes do seu projeto sem escrever uma linha de código.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/952/0*ZX0Oj6TLchYETkS5.png" /></figure><p>Já imaginou automatizar diversos testes do seu projeto, sem escrever uma linha de código? Pois é, isso é possível e vou contar com detalhes como fazer isso.</p><p>Você, como Engenheiro de Qualidade, possivelmente já passou por uma dessas situações:</p><ul><li>Foi contratado para uma vaga onde exigia que você fosse “automatizador de testes”, e depois da contratação, só atuou com testes manuais por não ter tempo para automatizá-los;</li><li>Não conseguiu essa mesma oportunidade, por não saber automatizar testes; e,</li><li>Não aprendeu automação na posição atual, por não tido “tempo” ou “oportunidade” para aprender (entre outros motivos).</li></ul><p>Esses são alguns exemplos da realidade no mercado de desenvolvimento de software, que reage rapidamente às mudanças, entretanto, nem sempre isso é feito de forma organizada e planejada para garantir a qualidade do que está sendo desenvolvido.</p><p>Diante disso, esse problema afeta o bolso dos clientes e nosso também, pois investimos em cursos e treinamentos nos preparando para um ambiente que não está maduro o suficiente para nos receber e é esse ponto que vamos trabalhar.</p><blockquote>Resiliência é a chave do sucesso em nossa profissão.</blockquote><p>Antes de iniciármos, é importante que você esteja aberto para novos conhecimentos sobre testes, paciência, muita dedicação e mudança no seu modo de agir e pensar.</p><p>É importante lembrar da velha frase, “…<strong>quanto mais tarde testamos, mais lento e caro será o projeto para o cliente…”</strong>. Esse é um excelente argumento para convencer seus gestores e aplicar o que abordaremos adiante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*Xv1v3tQ21UULJI3cS-Ih8Q.png" /><figcaption>The Test Pyramid</figcaption></figure><p>Na imagem acima, vemos a famosa pirâmide de testes, onde os unitários e componentes são os que mais necessitam de esforços, é por lá que começaremos automatizando sem escrever uma só linha de código.</p><p>Você deve estar se perguntando: Como programar meus testes, sem ao menos colocar a mão no código? E a resposta para esse questionamento é: Aplicando <a href="https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_pareada"><strong>Pair Programming (Programação pareada ou em pares)</strong></a> com os desenvolvedores do seu time.</p><blockquote>A programação pareada é uma técnica de desenvolvimento de software ágil em que dois programadores trabalham juntos em uma estação de trabalho. Um deles, o “controlador”, escreve o código, enquanto o outro, chamado de “observador”, analisa cada linha do código.</blockquote><blockquote>Evitando distrações e criando um ambiente colaborativo, em geral, a programação pareada se prova mais produtiva do que a isolada. Enquanto está analisando, o observador também considera a orientação estratégica do trabalho, dando ideias para melhorias e comenta sobre possíveis problemas futuros que devem ser resolvidos. Isso libera o controlador para concentrar toda a sua atenção nos aspectos táticos da tarefa atual. — <a href="https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_pareada">Wikipedia</a></blockquote><blockquote>Dado que vivemos em meio a uma onda de transformação ágil, se você não aprendeu a surfar, a hora é agora.</blockquote><p>Na minha experiência, pouco mais de 10 anos, atuando com qualidade de software, pude perceber que, a maior dificuldade dos desenvolvedores nessa tarefa, está na concepção dos cenários e escrita dos testes. Para resolver essa questão, quem é o cara que tem esse domínio? Isso mesmo: <strong>Você, </strong><a href="https://www.amazon.com/Agile-Testing-Practical-Guide-Testers/dp/0321534468"><strong>Agile Tester</strong></a><strong>!</strong></p><p>Descobrimos quem vai automatizar os testes com você, ok? Vamos para os passos onde descobriremos com aplicar isso?</p><p>Partindo da premissa que atue no modelo ágil de desenvolvimento de software, podemos nos organizar com o time, apresentando o projeto de melhoria na qualidade, agendando uma reunião ou utilizando a cerimônia de retrospectiva para levantar essas ações.</p><p>As métricas da cobertura de testes do momento atual, também, são artefatos importantes para, depois de um determinado período, mensurar a evolução.</p><p>Dado os alinhamentos com a gestão e com o time, é hora de começar!</p><p>Agora, nesse primeiro momento, você e o desenvolvedor escolhido focarão na atividade, a medida em que necessitarem criar um método ou componente, farão primeiro a automação dos testes, conforme apresentado abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-meRkFpYdeQav7g8.png" /><figcaption>Test-Driven Development</figcaption></figure><p>Nesse momento você implementará a técnica de <a href="https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=pd_sbs_14_6/145-8756424-8067561"><strong>TDD “Test-Driven Development”</strong></a> (Desenvolvimento guiado por testes) na sua equipe:</p><ul><li>Criando cenários de testes automatizados que falhem, numa primeira execução;</li><li>Implementando os métodos da aplicação, fazendo com que os testes passem; e,</li><li>Refatorando os dois códigos até que estejam de maneira aceitável, garantindo o funcionamento do software da melhor maneira possível.</li></ul><blockquote><strong>Pronto, você já deu seu primeiro passo rumo a um projeto com automação de testes sem escrever uma só linha de código.</strong></blockquote><p>Após a execução dessa técnica, durante algumas iterações do time, você avaliará se estão prontos para dar o próximo passo, podendo ser uma das duas opções abaixo (muito parecidas) e ambas exigirão mudança cultural da empresa.</p><p>A primeira prática que podemos utilizar nesse segundo momento, é a implementação do <a href="https://www.amazon.com/Specification-Example-Successful-Deliver-Software/dp/1617290084"><strong>BDD “Behavior-Driven Development”</strong></a> (Desenvolvimento guiado por comportamento), contribuindo com o time para um maior entendimento sobre o comportamento da aplicação de acordo com o negócio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Slv4WevUNAoKoIFztSugwQ.png" /><figcaption>BDD and TDD Hybrid Cycle</figcaption></figure><p>A segunda prática que podemos utilizar é o <a href="http://testobsessed.com/2008/12/acceptance-test-driven-development-atdd-an-overview/"><strong>ATDD “Acceptance Test-Driven Development”</strong></a> (Desenvolvimento Orientado à Testes de Aceitação).</p><p>Os <strong>testes de aceitação</strong> são executados para validar a funcionalidade da aplicação. Imagine que você queira comprar um carro, você tem conhecimento sobre motores, no entanto, quer que o carro te leve de um lado para outro. Assim são os testes de aceitação, eles nos conduzem a realizar uma revisão das partes individuais, que funcionam corretamente trabalhando juntas, geralmente são <a href="https://pt.wikipedia.org/wiki/Teste_de_caixa-preta">testes de caixa preta</a>, escritos em cenários especificados pelo cliente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*29HJ0TILkJf6kfu1.png" /><figcaption>ATDD and TDD Hybrid Cycle</figcaption></figure><p><strong>Discutir (Discuss):</strong></p><ul><li>Durante a preparação do Backlog o PO (Product Owner), Desenvolvedores e QA (Quality Assurance) discutem a história do usuário usando exemplos de como ela será desenvolvida e quais são os possíveis cenários;</li><li>O PO deverá registrar esses exemplos acordados como critério de aceitação para a história do usuário;</li><li>O PO atualizará a história do usuário com os critérios de aceitação;</li><li>O time de negócios analisará a história do usuário para verificar se atende aos requisitos;</li><li>O PO buscará aprovação do cliente na história do usuário;</li></ul><p><strong>Refinar (Destill):</strong></p><ul><li>O QA deverá refinar os exemplos descritos nos teste de aceitação;</li><li>O QA apresentará casos de teste adicionais para aumentar a cobertura do teste.</li></ul><p><strong>Desenvolver (Develop):</strong></p><ul><li>O desenvolvedor deverá desenvolver os recursos, colaborando com o QA para garantir que a funcionalidade esteja sendo construída de acordo com às expectativas dos casos de teste que estão sendo criados.</li></ul><p><strong>Demonstrar (Demo):</strong></p><ul><li>Após, ou mesmo durante o desenvolvimento, o Desenvolvedor e o QA farão a demonstração do produto ao PO para validar novamente os testes de aceitação.</li></ul><p>Um misto dessas 3 práticas (ATDD, BDD e TDD) também é possível, mas isso exigirá uma maior experiência e maturidade de toda a equipe.</p><p>Assim como o BDD, o ATDD poderá ser escrito utilizando o formato DADO, QUANDO e ENTÃO (Given, When e Then):</p><blockquote><em>“DADO um contexto definido, </em><strong><em>QUANDO</em></strong><em> uma ação definida é realizada, </em><strong><em>ENTÃO</em></strong><em> espera-se que o sistema responda de uma forma definida.”</em></blockquote><pre><strong>Cenário:</strong> Realizar cadastro <br><strong>DADO</strong> que eu realize o meu cadastro na aplicação<br><strong>QUANDO</strong> eu submeter o formulário<br><strong>ENTÃO</strong> serei direcionado para o dashboard da aplicação</pre><p>Os benefícios das atividades são inúmeros, citarei alguns aqui:</p><ul><li>Passagem do conhecimento de negócio por parte do Tester para o Desenvolvedor;</li><li>Criação da cultura de responsabilidade da qualidade por parte de todos;</li><li>O time passa a atuar na prevenção ao invés de correção de bugs;</li><li>Cobertura de testes de acordo com as boas práticas apresentadas pela pirâmide de testes;</li><li>Melhor qualidade dos testes automáticos, com a criação de cenários mais bem definidos e escritos;</li><li>Testers que não automatizam, passarão a ter um contato próximo com o código e aprenderão a lógica da programação, principal conhecimento quando falamos em programação de softwares e testes, para posteriormente criar e dar manutenção;</li><li>Desenvolvedores que não praticavam a criação de testes, aprendem a pensar com uma nova visão, a do testador/usuário da funcionalidade;</li><li>Entrega de software que agregue valor ao cliente;</li><li>Dar o primeiro passo, rumo a entrega contínua de software.</li></ul><p>Para concluir, <strong>você não tem mais desculpas para projetos sem automação de testes</strong>, sabendo ou não programar, você poderá dar o primeiro passo, seguindo as sugestões acima.</p><p>Bibliografias:</p><ul><li><a href="https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=pd_sbs_14_6/145-8756424-8067561">Test-Driven Development</a>;</li><li><a href="https://www.amazon.com/Specification-Example-Successful-Deliver-Software/dp/1617290084">Specification by Example</a>;</li><li><a href="https://www.amazon.com/Cucumber-Book-Behaviour-Driven-Development-Programmers/dp/1934356808">The Cucumber Book</a>;</li><li><a href="https://www.amazon.com/ATDD-Example-Test-Driven-Development-Addison-Wesley-ebook-dp-B008G1H3EG/dp/B008G1H3EG">ATDD by Example</a>; e,</li><li><a href="https://www.amazon.com/Agile-Testing-Practical-Guide-Testers/dp/0321534468">Agile Testing</a>.</li></ul><p>Ficou com dúvidas, tem sugestões ou reclamações? Me procure nos canais da Bee Lab:</p><ul><li><a href="https://linktr.ee/beelabsolutions">https://linktr.ee/beelabsolutions</a></li></ul><p>Ficarei grato por seu feedback!</p><p>Agradeço aos meus amigos que revisaram esse conteúdo: <a href="https://medium.com/u/edcd4487592">Bruno Nascimento de Figueiredo</a>, <a href="https://medium.com/u/1b12fbdcb2f9">Deborah Zavistanavicius</a>, <a href="https://medium.com/u/ba8ad13dabf7">Ramilo Neves</a> e minha esposa <a href="https://medium.com/u/c1233488b878">Camila Cardoso Meneghetti</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b972a56a8588" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/automatize-testes-do-seu-projeto-sem-escrever-uma-%C3%BAnica-linha-de-c%C3%B3digo-b972a56a8588">Automatize testes do seu projeto sem escrever uma única linha de código.</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como automatizar seus testes usando um Modelo de Testes de API em JavaScript]]></title>
            <link>https://medium.com/beelabacademy/como-automatizar-seus-testes-usando-um-modelo-de-testes-de-api-em-javascript-6467e59faf45?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/6467e59faf45</guid>
            <category><![CDATA[testes-de-software]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[star-wars]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[automação-de-testes]]></category>
            <dc:creator><![CDATA[Bruno Nascimento de Figueiredo]]></dc:creator>
            <pubDate>Tue, 16 Jun 2020 13:28:32 GMT</pubDate>
            <atom:updated>2020-06-16T13:29:05.934Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*_1MG7tAVaCUvzN-N.png" /></figure><p>Neste post, criaremos um projeto modelo para que você possa fazer <em>requests </em>em uma API usando JavaScript e para isso consumiremos a API <a href="https://swapi.dev/">Star Wars</a> para nossos testes.</p><p>Vamos lá!</p><p>Pré requisitos:</p><p>— Conhecimento básico sobre <a href="https://pt.wikipedia.org/wiki/Interface_de_programa%C3%A7%C3%A3o_de_aplica%C3%A7%C3%B5es">API’s</a> e métodos <a href="https://pt.wikipedia.org/wiki/Hypertext_Transfer_Protocol">HTTP</a><br> — NodeJS instalado (Para baixar, clique <a href="https://nodejs.org/en/download/">aqui</a>).</p><p>Para verificar se o node e o npm foram instalados, abra o terminal e digite:</p><pre>node -v</pre><p>e depois</p><pre>npm -v</pre><p>Se tiver tudo correto, o terminal, como a imagem a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/0*PmmI-XzRdf3ETQTE" /></figure><p><strong>Criando a estrutura do projeto:</strong></p><p>1- Crie uma pasta para adicionar os testes, configurações e outros arquivos necessários para testarmos a API, no meu caso, criei em</p><pre>C:\git\template_project_tests_api_js</pre><p><strong>Configurar Mocha</strong></p><p>1- Na pasta do projeto, crie um arquivo [.<em>mocha.opts</em>];</p><p>2- Insira os dados abaixo no arquivo <em>.mocha.opts</em>e salve:</p><p>Basicamente configuramos alguns parâmetros do mocha, como adicionar e configurar um reporter para exibir os resultado dos testes, e configurar um timeout para execução dos testes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/349/0*BfIcVQN7ujJzzk5z" /><figcaption><a href="https://github.com/brunonf15/template_project_tests_api_js/blob/master/mocha.opts">https://github.com/brunonf15/template_project_tests_api_js/blob/master/mocha.opts</a></figcaption></figure><p><strong>Configurando o Babel para JS:</strong><br>1- Na pasta do projeto, crie um arquivo [.babelrc];</p><p>2- Insira os dados abaixo no arquivo <em>.babelrc</em> e salve:</p><p>Essa configuração vai permitir usar JavaScript se preocupar muito com sintaxe.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/547/0*fRx2M7Sk3497iSUb" /><figcaption><a href="https://github.com/brunonf15/template_project_tests_api_js/blob/master/package.json">https://github.com/brunonf15/template_project_tests_api_js/blob/master/package.json</a></figcaption></figure><p><strong>Continuando a construir a estrutura do projeto:</strong><br>1- Na pasta do projeto, crie um arquivo [package.json] nos testes da pasta;<br>2- Insira os dados abaixo no arquivo <em>package.json</em> e salve:</p><p>Esse arquivo é responsável principalmente por configurar as dependências do projeto assim como alguns scripts, neste caso inclusive adicionamos o script de teste que será usado para executar os testes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/659/1*V0ck1ipm6AgYqXGjEKoL_A.png" /><figcaption><a href="https://github.com/brunonf15/template_project_tests_api_js/blob/master/package.json">https://github.com/brunonf15/template_project_tests_api_js/blob/master/package.json</a></figcaption></figure><p>4- Abra o terminal na API da pasta do projeto e execute o comando:</p><pre>npm install</pre><p><strong>Crie uma estrutura de configuração</strong></p><p><strong>Config</strong><br>Crie uma pasta [config] na pasta do projeto; os arquivos nesta pasta são o endereço do servidor para o qual você deseja enviar as <em>requests</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/1*wJ-TLoJriYJL6EFlnzL6IA.png" /><figcaption><a href="https://github.com/brunonf15/template_project_tests_api_js/blob/master/config/settings.js">https://github.com/brunonf15/template_project_tests_api_js/blob/master/config/settings.js</a></figcaption></figure><p>URL_BASE — O servidor que você vai testar, neste caso, é <a href="https://swapi.dev/api">https://swapi.dev/api</a></p><p><strong>Modelo</strong></p><p>Então, aqui começamos efetivamente o projeto, usando <a href="https://www.npmjs.com/package/superagent">superagent</a>, para fazer <em>requests </em>simples e reutilizáveis.</p><p>Crie uma pasta [models] na pasta do projeto, os arquivos nessa pasta serão os modelos que você enviará <em>requests</em>, basicamente, estamos criando uma classe abstrata chamada API e, em seguida, estendendo essa classe.</p><p>Crie um arquivo [api.js] nos testes da pasta [models];<br>Insira os dados abaixo no arquivo <em>api.js</em> e salve:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/409/1*v5m4HvojWMX0gYNY_o4MmA.png" /><figcaption><a href="https://github.com/brunonf15/template_project_tests_api_js/blob/master/models/api.js">https://github.com/brunonf15/template_project_tests_api_js/blob/master/models/api.js</a></figcaption></figure><p>Vamos fazer as <em>requests</em>, queremos testar a API de duas maneiras:</p><p>A primeira maneira é: <br>Enviar um get para <a href="https://swapi.dev/api/people/">https://swapi.dev/api/people/</a></p><p>e o segunda é enviar um get para <a href="https://swapi.dev/api/people/1">https://swapi.dev/api/people/1</a> (neste caso permitindo passar o número 1 por parametro)</p><p>Usando dois métodos diferentes, o primeiro método é um getAll, obtendo todo o caractere da API e o segundo método pesquisará um caractere específico pelo seu ID, também estamos definindo o tipo de conteúdo como <em>application/JSON</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/705/1*Xqqdu3LGwfpyQp1OF2UNyw.png" /><figcaption><a href="https://github.com/brunonf15/template_project_tests_api_js/blob/master/models/starWarsPeople.api.js">https://github.com/brunonf15/template_project_tests_api_js/blob/master/models/starWarsPeople.api.js</a></figcaption></figure><p><strong>Specs</strong></p><p>Crie uma pasta [specs] na pasta do projeto, os arquivos nesta pasta são testes que você enviará em <em>requests </em>e usando a biblioteca <a href="https://www.chaijs.com/">Chai</a> para fazer as afirmações.</p><p>Vamos fazer três testes:</p><p>O primeiro é obter todas as pessoas e verificar se a resposta de status é 200, o segundo para verificar se o Luke Skywalker é a pessoa número um e o ultimo teste pesquisa por Harry Potter na API de Guerra nas Estrelas e verifica se ele é listado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*ePWAhbjo0ClZhVqJ3AYQnQ.png" /><figcaption><a href="https://github.com/brunonf15/template_project_tests_api_js/blob/master/specs/starWars.spec.js">https://github.com/brunonf15/template_project_tests_api_js/blob/master/specs/starWars.spec.js</a></figcaption></figure><p>Terminando a escrita dos testes, devemos ter essa estrutura de projeto</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/220/1*9SD6XmtbJbgSxiEgpORzNg.png" /></figure><p>Para <em>finalmente </em>executar os testes: abra o terminal na pasta do projeto e execute o comando:</p><pre>npm test</pre><p>Veja o resultado dos testes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-SCOX_BEhggyGXGho14Zg.png" /><figcaption>Testes executados</figcaption></figure><p>É isto!</p><p>Espero que tenham aprendido a montar este projeto model de testes de API, para este caso só foi apresentado get, mas pode ser testado todos os métodos HTTP.</p><p>Além disso também é possível integrar esses testes com outras bibliotecas de banco de dados, assim como essa estrutura pode ser usada para validar mocks e até mesmo integrar-se com pipelines. Pode ser que depois eu mostre isso no futuro, mas para já é isso.</p><p>Quero agradecer a <a href="https://medium.com/u/edd486136e5d">Demis Meneghetti</a> por todo o apoio para fazer este projeto.</p><p>Se você deseja baixar ou contribuir com este projeto, segue o link do GitHub</p><p><strong>Test model API using JavaScript:</strong></p><ul><li><a href="https://github.com/brunonf15/template_project_tests_api_js">Test model API using JavaScript</a></li></ul><p><strong>Referências:</strong></p><ul><li><a href="https://www.npmjs.com/package/superagent">Superagent</a></li><li><a href="https://mochajs.org/index.html">Mocha</a></li><li><a href="https://www.chaijs.com/">Chai</a></li><li><a href="https://nodejs.org/en/">NodeJS</a></li><li><a href="https://www.npmjs.com/">NPM</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6467e59faf45" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/como-automatizar-seus-testes-usando-um-modelo-de-testes-de-api-em-javascript-6467e59faf45">Como automatizar seus testes usando um Modelo de Testes de API em JavaScript</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando na prática Rest API com conceitos de DDD + .NET]]></title>
            <link>https://medium.com/beelabacademy/implementando-na-pr%C3%A1tica-rest-api-com-conceitos-de-ddd-net-2160291a44b7?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/2160291a44b7</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[net-core]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[ddd]]></category>
            <dc:creator><![CDATA[Daniel Jesus]]></dc:creator>
            <pubDate>Tue, 16 Jun 2020 10:25:54 GMT</pubDate>
            <atom:updated>2020-06-15T19:54:41.249Z</atom:updated>
            <content:encoded><![CDATA[<h3>Implementando na prática Rest API com conceitos de DDD + .NET CORE + SQL no Docker + IoC -[Parte Técnica]</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dtuVVqJwKoFqFH4W3bwGFw.png" /></figure><p>Dando continuidade nesse tema interessante que é o <strong>Domain Driven Design</strong>, agora entraremos na parte que todo desenvolvedor gosta que é a parte técnica.</p><p>Caso esteja vendo esse post e não chegou a ver o post que trata de assuntos teóricos, eu aconselho a você dar uma lida no post anterior clicando <a href="https://medium.com/@djesus.net/implementando-na-pr%C3%A1tica-rest-api-com-conceitos-de-ddd-net-core-sql-no-docker-ioc-2cb3a2e7c649">aqui</a>, lá explico como funciona a arquitetura que iremos montar do zero neste post usando os conceitos de Domain Driven Design.</p><h3>Ambiente de Desenvolvimento</h3><p>A seguir vamos utilizar a linguagem <strong>C#</strong>, onde todos os projetos foram criados em <strong>.NET Core </strong>versão<strong> 3.0</strong> no Visual Studio <strong>2019</strong>. Também é importante ressaltar que conhecimentos de polimorfismo e encapsulamento são premissas para este artigo, uma vez que iremos criar classes genéricas para poupar muita repetição de código.</p><p>Portanto vale ressaltar as outras ferramentas que iremos usar no nosso ambiente de Desenvolvimento que são:</p><ul><li><strong><em>Docker + Kitematic.</em></strong></li><li><strong><em>Visual Studio 2019.</em></strong></li><li><strong><em>Framework 3.0 do .Net Core.</em></strong></li><li><strong><em>Microsoft Sql Management</em></strong></li></ul><h4>Configuração do SQL Server no Docker</h4><p>Agora entraremos no tema de configuração da virtualização do SQL que iremos realizar dentro do Docker.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rsT7LXqHadebJm6S.png" /></figure><p>No meu caso que uso a plataforma Windows, irei abrir o Windows Power Shell e digitar o comando a baixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P-ePe3u0n3TZ5bbFpwi6Tg.png" /></figure><p>Comando:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d60bd78fe86211e754dac0d2eb603fdd/href">https://medium.com/media/d60bd78fe86211e754dac0d2eb603fdd/href</a></iframe><h4>Sugestão:</h4><p>O comando está com a senha “ <strong>yourStrong(!)Password’</strong> ”, mas fique a vontade de mudar!</p><h3>Executar o SQL no Docker</h3><p>Iremos abrir o software Kitematic para visualizar a virtualização do SQL que realizamos a configuração no tópico de cima.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nVTPjQomgXDv9Z7Ps1GT0A.png" /></figure><p>Como vimos existe uma imagem que se refere a sql, isso iremos clicar em cima e executar o container informado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o2gYU3GUvZMyF1fLoExBFA.png" /></figure><p>Depois de deixarmos o ambiente pronto, vamos partir para a montagem da arquitetura usando .Net Core 3.0.</p><h3>Montando a Arquitetura .Net Core</h3><p>Depois de entendermos no conceito o que é DDD (Domain Drive Design), entraremos agora na parte técnica de como realizar uma Arquitetura em Rest API aplicando tudo que vimos até momento.</p><p>Primeiramente iremos criar uma solução Asp Net Core Web Application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o79IBpTIFVYTJaHHTZJe6g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fld91TCJSGIWW9d47H-2dw.png" /></figure><h4>Camadas</h4><p>A partir da criação da solução Rest API, iremos aplicar os conceitos de DDD em nosso código.</p><p>Primeiramente iremos realizar a organização por pastas que representará as camadas que vimos no DDD, que serão:</p><ul><li><strong><em>Presentation (Apresentação).</em></strong></li><li><strong><em>Application (Aplicação).</em></strong></li><li><strong><em>Domain (Domínio).</em></strong></li><li><strong><em>Infrastructure (Infraestrutura).</em></strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/546/1*4dnebKL-K866MvOA46HZkw.png" /></figure><h4>Camada de Domínio</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/871/1*5MTCDnfNy-F47hxS7c0gQg.png" /></figure><p>Primeiramente iremos iniciar codificando pela camada de domínio, pois como vimos anteriormente essa camada é o única que não depende das outras camadas.</p><p><strong>Atenção</strong>: Portanto Nerds, reparem bem aos códigos, pois estamos criando classes “<strong><em>Base</em></strong>” para tudo, isso nos permite reaproveitar propriedades e métodos de forma genérica.</p><p>Como iremos criar um serviço de ecommerce, iremos começar a modelar as nossas entidades e pra isso precisamos criar um projeto “<strong><em>DDDWebAPI.Domain</em></strong>” do tipo Class Libray (.Net Core) em C#.</p><p>Depois crie uma pasta chamada “Models” que existirá entidades do nosso projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/280/1*b7vlVxfAJPqK0BA8bJWFaA.png" /></figure><p><strong>Entidades:</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3efa35c8322deb6055dd2805c7286018/href">https://medium.com/media/3efa35c8322deb6055dd2805c7286018/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5fafdf664e1cb86d7935427b5140740f/href">https://medium.com/media/5fafdf664e1cb86d7935427b5140740f/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6f222397521b7d665e95571364197457/href">https://medium.com/media/6f222397521b7d665e95571364197457/href</a></iframe><p>Agora iremos criar um novo projeto na camada de domínio do tipo do tipo Class Libray (.Net Core) em C#.</p><p>Esse projeto se refere uma camada de domínio que armazenará as interfaces dos repositórios patterns e do services do domínio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/292/1*Asjqpkghych4-zYx6ij8dg.png" /></figure><p>As interfaces que criaremos a seguir, são as mesmas que serão implementadas nas classes de repositórios patterns e do services do domínio na camada <strong>Infraestrutura</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/402/1*1KS2mm5afXm-eCMf1YfzRQ.png" /></figure><p><strong>Interfaces dos repositórios</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b97b17891052e450248e71188d8ab851/href">https://medium.com/media/b97b17891052e450248e71188d8ab851/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c3e083327c6ebacd448bb21bd92656f7/href">https://medium.com/media/c3e083327c6ebacd448bb21bd92656f7/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b793e6cc5e1796478b7bb64db4e2e643/href">https://medium.com/media/b793e6cc5e1796478b7bb64db4e2e643/href</a></iframe><p>Por último para finalizarmos a nossa camada de domínio com chave de ouro, iremos implementar um novo projeto chamado “DDDWebAPI.Domain.Services” do tipo Class Libray (.Net Core) em C#.</p><p>Esse projeto se refere a classes que que terão métodos genéricos que são comuns em cadastro de cliente e produto como inclusão, remoção e atualização. Portanto perceba que abaixo é esperado como parâmetro a interface do tipo de repositório que criamos acima, mas não vamos falar sobre esse poderoso pattern de repositório agora, isso é assunto que iremos tratar na camada de Infraestrutura, que vamos ver mais abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/304/1*5a__TqoFTp1jhQONT_IWLg.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e933cfbf20b7a66bc38cec5c1f422e8/href">https://medium.com/media/1e933cfbf20b7a66bc38cec5c1f422e8/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/354b8a676b925f32a12f4aaace0762d9/href">https://medium.com/media/354b8a676b925f32a12f4aaace0762d9/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a3353364e195c4e3abbf3d73dbc0fe4b/href">https://medium.com/media/a3353364e195c4e3abbf3d73dbc0fe4b/href</a></iframe><h4>Camada de Aplicação</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/885/1*c8mgrrbdW2DqJpYR3sT-5Q.png" /></figure><p>Após preparar a camada Domínio, vamos agora criar a estrutura da camada de Aplicação, a qual se comunicará diretamente com o Domínio. Então criaremos dois projetos um chamado “DDDWebAPI.Application” e outro chamado DDDWebAPI.Application.DTO do tipo Class Libray (.Net Core) em C# e esses projetos terão a dependência do projeto “DDDWebAPI.Domain.Core”, para que tenhamos acesso as informações das classes desse projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/508/1*HeR_rGY_e3TGeybWcOA2RQ.png" /></figure><p>No projeto “<strong><em>DDDWebAPI.Application.DTO</em></strong>” será responsável por armazenar nossos DTOs que serão utilizados nessa solução que estamos criando.</p><p><strong>DTO</strong>: Objeto de Transferência de Dados (do inglês, <strong>Data transfer object</strong>, ou simplesmente DTO), é um padrão de projeto de software usado para transferir dados entre subsistemas de um software. DTOs são frequentemente usados em conjunção com objetos de acesso a dados para obter dados de um banco de dados.</p><p>Criaremos classes como ClienteDTO e ProdutoDTO que serão alimentados via requisição do nosso Rest API e trafegados na camadas da solução.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/375/1*LTYn39cm9YHfA6RKb87DFw.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/514498f3c957486fcba45670786b0d58/href">https://medium.com/media/514498f3c957486fcba45670786b0d58/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/445074d6862b7d3f0be6e99574bf59a2/href">https://medium.com/media/445074d6862b7d3f0be6e99574bf59a2/href</a></iframe><p>No projeto “<strong><em>DDDWebAPI.Application</em></strong>” será responsável por armazenar nosso service e as interfaces que serão utilizados nessa solução que estamos criando.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/358/1*wOsio4QHOCc1MNZn8TWGuA.png" /></figure><p><strong>Interfaces</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/01075f67e209c906b7d691956ca1b692/href">https://medium.com/media/01075f67e209c906b7d691956ca1b692/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3530969505066da44916820568812e9a/href">https://medium.com/media/3530969505066da44916820568812e9a/href</a></iframe><p><strong>Implementação dessas Interfaces Services</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fbd5d755494cce17d08c68b29b281791/href">https://medium.com/media/fbd5d755494cce17d08c68b29b281791/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1222c4570954e9aafd3e8bf02d22b17d/href">https://medium.com/media/1222c4570954e9aafd3e8bf02d22b17d/href</a></iframe><h4>Camada de Infraestrutura</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*jjilqP9jcTCUTPk2FUcVbA.png" /></figure><p>Como vimos já deixamos pronto as camadas <strong>Domínio </strong>e <strong>Aplicação </strong>e<strong> </strong>agora iremos dar início a preparação da camada Infraestrutura que se divide em <strong>IoC </strong>e <strong>Data</strong>.</p><p><strong>Data</strong></p><p>Esta subcamada é praticamente o coração da camada Data, é onde persistiremos todas as informações, onde comunicaremos com o banco de dados propriamente dito.</p><p><strong>DDDWebAPI.Infrastructure.Data: </strong>Este projeto se refere o contexto de informações que são tratadas via banco de dados .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/439/1*ut66NdcHEdj7iRZVI9yk4A.png" /></figure><p><strong>SqlContexto: </strong>Classe que herdamos o DbContext do EntityFrameWork, responsável por abrir transações e commita-las após término da persistência.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee1fb27d92a9a4298fb8e835b7ea1290/href">https://medium.com/media/ee1fb27d92a9a4298fb8e835b7ea1290/href</a></iframe><p><strong>DDDWebAPI.Infrastruture.Repository: </strong>Esta subcamada é praticamente é a implementação do pattern repositório.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/1*ESdlC0XyjMYdM3f7zexEBQ.png" /></figure><p>Como vamos usar recursos da camada <strong>Domínio </strong>e da subcamada<strong> Data </strong>, vamos adicionar essas <strong>dependências </strong>neste projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/495/1*nZG7aHxNp187OY-uDelF0g.png" /></figure><p><strong>Pacotes NuGet</strong>: vamos precisar instalar 2 pacotes do NuGet:</p><ul><li><em>Microsoft.EntityFrameworkCore (3.0).</em></li><li><em>Microsoft.EntityFrameworkCore.Sql (3.0).</em></li></ul><p><strong>Repositorios: </strong>onde são realizadas as consultas, inserções e atualizações nas tabelas do banco de dados, tudo isso usando o contexto, que criamos acima.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/28087cd435ff0d7ae486114c30ed350a/href">https://medium.com/media/28087cd435ff0d7ae486114c30ed350a/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cfd22404c52f90993b14f47198cea41e/href">https://medium.com/media/cfd22404c52f90993b14f47198cea41e/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/65c0b87593d6e61f1a00c40051f300c6/href">https://medium.com/media/65c0b87593d6e61f1a00c40051f300c6/href</a></iframe><h4><strong>CrossCutting</strong></h4><p>Nessa pasta de CrossCutting, iremos criar dois projetos e um deles será chamado “DDDWebAPI.Infrastruture.CrossCutting.Adapter” e outro chamado DDDWebAPI.Infrastruture.CrossCutting.IOC do tipo Class Libray (.Net Core) em C# e esses projetos terão a dependência dos outros projetos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/513/1*csbxFkZg8NtpT4dd4RNH7Q.png" /></figure><p><strong>DDDWebAPI.Infrastruture.CrossCutting.Adapter: </strong>Este projeto terá interfaces e classes que serve para que registrar no AutoMapper as classes Entidade e DTO, para que seja possível realizar a conversão de uma para a outra.</p><h4>Interfaces</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/09bdd329f32d3615084e9a5f666c89e8/href">https://medium.com/media/09bdd329f32d3615084e9a5f666c89e8/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d0ff6cbc3cdd75c6858f40fe2d0d6182/href">https://medium.com/media/d0ff6cbc3cdd75c6858f40fe2d0d6182/href</a></iframe><h4>Implementação das Interfaces Mappers</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d23926b55637175e7b7668464b8adfda/href">https://medium.com/media/d23926b55637175e7b7668464b8adfda/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/982b1534aae3bab7601f0585f43c1ee2/href">https://medium.com/media/982b1534aae3bab7601f0585f43c1ee2/href</a></iframe><p><strong>DDDWebAPI.Infrastruture.CrossCutting.IOC: </strong>Este projeto terá o papel de implementar <strong>dependency injection</strong> ou em português <strong>injeção de dependências.</strong></p><p><strong>Pacotes NuGet</strong>: vamos precisar instalar 1 pacote do NuGet:</p><ul><li><em>AutoFac(4.9.4).</em></li></ul><p>Agora criaremos a classe ConfigurationIOC que será responsável por realizar a criação de um container IoC para registrar todas as instâncias das classes do nosso projeto.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/252e9e0c92aad80fafef00341e249653/href">https://medium.com/media/252e9e0c92aad80fafef00341e249653/href</a></iframe><p>Agora criaremos a classe ModuleIOC que será responsável por realizar a criação de um módulo que realizará leitura do meu container IoC para ler todas as instâncias das classes do nosso projeto.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f5e886c04d78b240ece2813b50b28522/href">https://medium.com/media/f5e886c04d78b240ece2813b50b28522/href</a></iframe><h4>Camada de Apresentação — Serviço Rest API</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/0*amTwix0zTLxg5buA.jpeg" /></figure><p>Acabamos de terminar de codificar as camadas <strong>Domínio</strong>, <strong>Aplicação </strong>e <strong>Infra</strong>, agora vamos fazer a nossa última camada.<br>Como escolhemos fazer uma API para a camada de Apresentação, como sabemos que é através dela que as aplicações se comunicarão com a nossa arquitetura, para que possamos buscar ou persistir informações.</p><p><strong>Pacotes NuGet</strong>: vamos precisar instalar 1 pacote do NuGet:</p><ul><li><em>AutoFac(4.9.4).</em></li><li>AutoFac.Extensions.DependencyInjection (5.0.1)</li><li><em>Microsoft.EntityFrameworkCore (3.0).</em></li><li><em>Microsoft.EntityFrameworkCore.Sql (3.0).</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/547/1*vMQYiajl-n_M80tsgPhv8A.png" /></figure><p>Caso você nunca criou um projeto Rest API em .Net Core, não se preocupe. Agora iremos criar as controllers do nosso serviço. Então abaixo temos as implementaççoes dos Controllers que iremos usar, conforme imagem abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/127bffdb43383a4d7d64ca8022369a12/href">https://medium.com/media/127bffdb43383a4d7d64ca8022369a12/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e6468a1cac4f5e69aeff30a223658e98/href">https://medium.com/media/e6468a1cac4f5e69aeff30a223658e98/href</a></iframe><h4>Classe Startup</h4><p>Iremos realizar abaixo a configuração do contexto de conexão a base de dados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/697/1*eAt7fB-jbC3f8N9vmWYnVg.png" /></figure><p>Abaixo realizamos o registro do Módulo do Container IoC na inicialização do serviço Rest Api.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/515/1*45fHsxw0kWTApupqdlVeNQ.png" /></figure><h3>Arquitetura em camadas utilizando o conceito de DDD está pronta !!!</h3><p>Depois de termos feito tudo isso, precisamos tentar entender de forma mais prática como o fluxo do conceito de Domain Driven Design funciona.</p><p>Portanto, de maneira mais direta e resumida, a imagem abaixo mostra fielmente como o fluxo do conceito de Domain Driven Design .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/0*3LCl6RxN9cyYyl8z.jpeg" /></figure><p>Vendo a figura acima, podemos ver que uma camada chama a outra, atendendo de forma clara as suas responsabilidades únicas, assim como vimos no <a href="https://medium.com/@djesus.net/implementando-na-pr%C3%A1tica-rest-api-com-conceitos-de-ddd-net-core-sql-no-docker-ioc-2cb3a2e7c649">post anterior</a> .</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fvideoseries%3Flist%3DPLfpYVugeLJLZMwhCbQVLJ_OGUPLDNqKkN&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DplS-rf2UIPI&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FplS-rf2UIPI%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/b21dee8614f7def57212fae170c2cfcf/href">https://medium.com/media/b21dee8614f7def57212fae170c2cfcf/href</a></iframe><h3>Conclusão</h3><p>O grande objetivo deste artigo foi mostrar e explicar um pouco sobre DDD e criar uma arquitetura robusta e escalável em camadas que consiga aplicar os paradigmas impostos pelo Domain Driven Design.</p><p>Espera-se que este artigo tenha contribuído com o conhecido que foi passado aqui e ter ajudado muitas pessoas que tem dúvidas ou dificuldades para implementar um arquitetura com DDD que realmente atenda.</p><p>Recomendo que leiam o livro “Domain Driven Design” escrito por <strong><em>Eric Evans </em></strong>para que possam abranger o conhecimento nesse assunto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/0*-k_QV7mARy-qCRDH.png" /></figure><h3>Referências:</h3><p><strong>Domain-Driven Design: Tackling Complexity in the Heart of Software</strong></p><p><a href="https://medium.com/@renato.groffe/net-core-3-0-e-asp-net-core-3-0-guia-de-refer%C3%AAncia-c2e88341f285"><strong>.NET Core 3.0 e ASP.NET Core 3.0: Guia de Referência</strong></a></p><p><a href="https://mderriey.com/2018/08/02/autofac-integration-in-asp-net-core-generic-hosts/"><strong>AutoFac</strong></a></p><p><a href="https://github.com/djesusnet/ExampleMediumDDDAPI">djesusnet/ExampleMediumDDDAPI</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2160291a44b7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/implementando-na-pr%C3%A1tica-rest-api-com-conceitos-de-ddd-net-2160291a44b7">Implementando na prática Rest API com conceitos de DDD + .NET</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando na prática Rest API com conceitos de DDD + .NET CORE + SQL no Docker + IoC]]></title>
            <link>https://medium.com/beelabacademy/implementando-na-pr%C3%A1tica-rest-api-com-conceitos-de-ddd-net-core-sql-no-docker-ioc-2cb3a2e7c649?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/2cb3a2e7c649</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[ddd]]></category>
            <category><![CDATA[rest-api]]></category>
            <dc:creator><![CDATA[Daniel Jesus]]></dc:creator>
            <pubDate>Tue, 16 Jun 2020 10:25:17 GMT</pubDate>
            <atom:updated>2019-10-27T20:15:33.766Z</atom:updated>
            <content:encoded><![CDATA[<h3>Implementando na prática Rest API com conceitos de DDD + .NET CORE + SQL no Docker + IoC</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dtuVVqJwKoFqFH4W3bwGFw.png" /></figure><p>Todo desenvolvedor já se perguntou, como implementar o conceito de DDD em seu código?. Portanto se você entrou neste artigo, provavelmente é porque está procurando algum artigo que explique no detalhe uma arquitetura usando o conceito de DDD(Domain Drive Design).Neste post, falaremos de como implementar esses conceitos em uma solução de <strong><em>Rest API</em></strong> com <strong><em>.Net Core 3.0</em></strong> e com <strong><em>SQL Server</em></strong> como virtualização no <strong><em>Docker</em></strong>.</p><p>Antes de mais nada, vamos iniciar uma pequena introdução ao conceito de Domain Drive Design para que possamos entrar no conteúdo técnico.</p><h3>O que é DDD (Domain Drive Design)?</h3><p>Domain Driven Design significa Projeto Orientado a Domínio. Ele veio do título do livro escrito por Eric Evans, dono da DomainLanguage, uma empresa especializada em treinamento e consultoria para desenvolvimento de software. O livro de Evans é um grande catálogo de Padrões, baseados em experiências do autor ao longo de mais de 20 anos desenvolvendo software utilizando técnicas de Orientação a Objetos. O que seria um Padrão?</p><p>Um padrão é uma regra de três partes que expressa a relação entre um contexto (1), um problema (2) e uma solução (3).</p><p>DDD pode ser visto por alguns como a volta da orientação a objetos. É verdade que o livro é um chamado às boas práticas de programação que já existem desde a época remota do SmallTalk. Quando se fala em Orientação a Objetos pensa-se logo em classes, heranças, polimorfismo, encapsulamento. Mas a essência da Orientação a Objetos também tem coisas como:</p><ul><li><strong>Alinhamento do código com o negócio:</strong> o contato dos desenvolvedores com os especialistas do domínio é algo essencial quando se faz DDD (o pessoal de métodos ágeis já sabe disso faz tempo);</li><li><strong>Favorecer reutilização:</strong> os blocos de construção, que veremos adiante, facilitam aproveitar um mesmo conceito de domínio ou um mesmo código em vários lugares;</li><li><strong>Mínimo de acoplamento:</strong> Com um modelo bem feito, organizado, as várias partes de um sistema interagem sem que haja muita dependência entre módulos ou classes de objetos de conceitos distintos;</li><li><strong>Independência da Tecnologia:</strong> DDD não foca em tecnologia, mas sim em entender as regras de negócio e como elas devem estar refletidas no código e no modelo de domínio. Não que a tecnologia usada não seja importante, mas essa não é uma preocupação de DDD.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/657/1*e4i7T1IFAoHWnPUT6Mk9pA.png" /></figure><h3>Principais coisas que você precisa saber sobre o DDD</h3><h4>Não é uma arquitetura</h4><p>Muitos programadores entendem que Domain Driven Design é uma arquitetura, embora existam vários textos e tutoriais falando de como se criar uma “Arquitetura DDD”, o Domain Drive Design (DDD) não é uma <strong><em>arquitetura</em> </strong>por si só e sim um paradigma que é aplicado à arquitetura a qual você desejar criar ou seguir, e é isso que torna o DDD tão fantástico assim.</p><h4>Não é uma tecnologia</h4><p>Para você aplicar o DDD não é preciso nenhuma ferramente de terceiros para realizar essa implementação.</p><h4>Caso use os conceitos de DDD, você terá um software…</h4><ul><li><strong>R</strong>esponsável.</li><li><strong>E</strong>scalável.</li><li><strong>T</strong>estável.</li><li><strong>C</strong>om uma manutenção fácil e tranquila.</li><li><strong>E </strong>escrito com boas práticas.</li></ul><h3>Entendimento de uma arquitetura com os conceitos DDD</h3><p>A imagem abaixo representa um ilustração de como será todas as camadas usando o conceito de DDD:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*-Tg0op_X4upT76nMCFogbw.png" /></figure><h4>01- Camada de Apresentação</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/0*TFd7_3JiAIptWO2e.jpeg" /></figure><p>A camada de apresentação que é responsável por abranger tudo o que diz respeito as interações com o cliente. Nela pode ser:</p><ul><li><strong><em>Aplicação Desktop (WinForms)</em></strong>.</li><li><strong><em>Aplicação Web (Angular, React, Vue).</em></strong></li><li><strong><em>Aplicação Mobile (Android).</em></strong></li><li><strong><em>Aplicação de serviço (WCF, Rest Api).</em></strong></li></ul><h4>02 - Camada de Aplicação</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/0*LWzC9nlkPtnzpev2.png" /></figure><p>A camada de aplicação que é responsável por realizar a(s) aplicação(s) se comunicar diretamente com o Domínio. Nela são implementados:</p><ul><li><strong><em>Classes dos Serviços da aplicação</em></strong>.</li><li><strong><em>Interfaces (contratos).</em></strong></li><li><strong><em>DataTransferObjects (DTO).</em></strong></li><li><strong><em>AutoMapper</em></strong></li></ul><blockquote>Defines the jobs the software is supposed to do and directs the expressive domain objects to work out problems. The tasks this layer is responsible for are meaningful to the business or necessary for interaction with the application layers of other systems.<em> </em><strong><em>This layer is kept in thin. It does not contain business rules or knowledge, but only coordinates tasks and delegates work to collaborations of domain objects in the next layer down</em></strong><em>.</em> It does not have state reflecting the business situation, but it can have state that reflects the progress of task for the user program.</blockquote><blockquote><em>Domain Driven Design, página 70.</em></blockquote><p>A definição acima, foi retirada do livro e descreve o que é a camada de aplicação dentro do DDD. O ponto em negrito é extremamente importante quando se tenta entender as responsabilidades dos objetos que ali residem. Resumindo: Na camada de aplicação não é implementada nenhuma regra de negócio, ela somente coordena a execução de uma tarefa e delega para os objetos de domínio na camada inferior.</p><h4>04 - Domínio</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/0*PQvGeQw8PQgsOeeW.png" /></figure><p>A camada de domínio que é responsável por ter um uma modelagem sólida e aqui que a mágica do <strong>DDD(Domain Drive Design)</strong> acontece. Nessa camada temos:</p><ul><li><strong><em>Entidades.</em></strong></li><li><strong><em>Interfaces (contratos) para Serviços e Repositórios.</em></strong></li><li><strong><em>Classes dos Serviços do domínio.</em></strong></li><li><strong><em>Validações (caso seja necessário).</em></strong></li></ul><h4>04 - Infraestrutura</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/0*xzJ9VERdEyzYzW7h.png" /></figure><p>A camada de infraestrutura é responsável por dar o suporte as demais camadas. Que atualmente é dividida por duas camadas com seus respectivos conteúdos:</p><p><strong><em>Data:</em></strong></p><ul><li><strong><em>Repositórios.</em></strong></li><li><strong><em>DataModel (Mapeamento).</em></strong></li><li><strong><em>Persistência de dados.</em></strong></li></ul><p><strong><em>CrossCutting (camada que atravessa todas as outras, portando possui referência de todas elas):</em></strong></p><p>A camada <strong>CrossCutting </strong>pode realizar a inversão de controle e <strong>injeção de dependências. </strong>Isso significa que você não precisará instanciar todas as classes manualmente.</p><ul><li><strong><em>IoC (Inversão de controle).</em></strong></li></ul><h3>Comunicação das Camadas</h3><p>Após de ter o entendimento do funcionamento das camadas do conceito de DDD, agora iremos mostrar de forma de ilustração como que as camadas se comunicam :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/1*YSICeozBGWT8WjBSLIXEaw.png" /></figure><p>Como podemos ver o que já foi explicado, todas as camadas possuem uma numeração sequencial, que se trata da forma em que o fluxo da arquitetura funciona, desde a camada de apresentação até a persistência de informações no banco de dados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/529/1*ddzQeVGh6OQOAANE-Fo8Fg.png" /></figure><p>Bom Nerds, depois de entendermos o conceito do <strong><em>Domain Driven Design </em></strong>em uma teoria um pouco cansativa, espero que vocês tenham um entendido claro de como é o funcionamento do <strong>DDD </strong>e usando esses conceitos que vimos que iremos implementar uma solução de <strong><em>Rest API</em></strong> com <strong><em>.Net Core 3.0</em></strong> e com <strong><em>SQL Server</em></strong> como virtualização no <strong><em>Docker</em></strong>. Agora entraremos no conceito mais técnico para ver na prática como tudo isso funciona no link abaixo:</p><p><a href="https://medium.com/@djesus.net/implementando-na-pr%C3%A1tica-rest-api-com-conceitos-de-ddd-netcore-2160291a44b7"><strong>Implementando na prática Rest API com conceitos de DDD + .NET CORE + SQL no Docker + IoC -[Parte Técnica]</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2cb3a2e7c649" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/implementando-na-pr%C3%A1tica-rest-api-com-conceitos-de-ddd-net-core-sql-no-docker-ioc-2cb3a2e7c649">Implementando na prática Rest API com conceitos de DDD + .NET CORE + SQL no Docker + IoC</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte III]]></title>
            <link>https://medium.com/beelabacademy/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-iii-88bbe351fa77?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/88bbe351fa77</guid>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[fluentassertions]]></category>
            <category><![CDATA[restsharp]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[api]]></category>
            <dc:creator><![CDATA[Breno Ferreira]]></dc:creator>
            <pubDate>Wed, 13 May 2020 08:27:07 GMT</pubDate>
            <atom:updated>2020-05-12T08:45:49.044Z</atom:updated>
            <content:encoded><![CDATA[<h3><a href="https://medium.com/beelabsolutions/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-ii-c531fafbed74?source=your_stories_page---------------------------">Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte II</a>I</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/578/1*OICaHvjcxhpFofj6Bai6aA.jpeg" /></figure><p>Retomando nossa série de publicações a respeito de testes de API utilizando RestSharp com C#, iremos executar uma simples requisição do método GET. Para realizarmos essa simples operação sugiro que já tenham o ambiente configurado conforme descrito nessa <a href="https://medium.com/beelabsolutions/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-ii-c531fafbed74">última </a>publicação.</p><p>Para um breve entendimento irei separar em blocos nosso código para ficar de fácil compreensão.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/589/1*x9rVh2xlA0BbrsTSFIlAlw.png" /></figure><p>Vamos utilizar a classe chamada RestClient, essa classe nós podemos obter usando a referência que instalamos em nossa postagem anterior, que nada mais é do que o RestSharp do NuGet que fizemos Download. Como podemos ver ,nesse construtor podemos fornecer nossa URL que iremos utilizar para realizar nossos testes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*v5vuchSsxu0ZqNj4t8nFrw.png" /></figure><p>Nosso bloco acima vamos utilizar uma classe de requisição, e dentro dessa classe de requisição de serviço podemos passar a URL e também o método que queremos fazer a nossa requisição, lembrando que pode ser um GET, POST, DELETE entre outros métodos existentes.</p><p>1. Nesse trecho estamos fornecendo o segmento da nossa URL, nesse caso estamos informando nosso ID que desejamos retornar, então ele irá passar o valor de 1;</p><p>2. No seguinte estamos fornecendo qual o método que iremos utilizar para nossos testes que no caso será o GET;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/490/1*JD3-t8iT_zbe44BgvFpeRg.png" /></figure><p>Nesse ponto acima conseguimos executar nossa requisição e obter nosso conteúdo que nada mais é do que a resposta do método GET.</p><p>1. Content se trata da propriedade responsável por recuperar nossos dados e assim fazermos nossas validações;</p><h4>Executando nosso teste</h4><p>Para realizar a execução dos nossos testes nossa classe necessita ter alguns requisitos mínimos como:</p><ul><li>O atributo [<strong>TestClass</strong>] pois é obrigatório para qualquer classe que contenha métodos de testes unitários que desejamos rodar no Test Explorer, para saber mais a respeito do Test Explorer clique <a href="https://docs.microsoft.com/en-us/visualstudio/test/run-unit-tests-with-test-explorer?view=vs-2019">aqui</a>;</li><li>Escrevemos métodos de testes e caso desejamos executar no Test Explorer nossa classe deverá também ter o atributo [<strong>TestMethod</strong>];</li></ul><p>Para visualizarem o Test Explore cliquem em View → Test Explorer ou vocês podem utilizar o atalho Ctrl + E.</p><p>Para executarmos nosso teste basta clicarmos na opção marcada na imagem e nosso teste será executado, caso não tenhamos nenhum problema veremos que nosso teste ficará verde.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LjpWpTJE-qVcWJq19lwxyw.png" /></figure><p>O simples fato do nosso teste ter sido executado com sucesso não quer dizer que retornou os dados que gostaríamos para isso vamos validar que nossa requisição está de acordo com o desejado.</p><p>Para validarmos o que está sendo retornado antes de executarmos o nosso teste, primeiro adicionei um breakpoint na linha 28 do nosso código e executei nosso teste em Debug, para quem não conhece a respeito de breakpoint clique <a href="https://docs.microsoft.com/en-us/visualstudio/debugger/using-breakpoints?view=vs-2019">aqui</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*81tc1cHOlU2TIToWWKsWjQ.png" /></figure><p>Quando executarmos nosso teste notaremos que a execução irá parar na linha 28 e com isso poderemos visualizar o que está sendo retornado do nosso método GET.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NE5fw4tLW06LsQae_1xdlg.png" /></figure><p>Mas para conseguirmos visualizar isso é necessário fazermos a deserialização ou seja precisamos informar que queremos visualizar em um formato JSON e com isso conseguiremos fazer nossas asserções para garantir que o conteúdo retornado está de acordo com o desejado.</p><p>No nosso primeiro artigo temos uma breve explicação sobre desserialização, caso não visualizaram podem clicar <a href="https://medium.com/beelabsolutions/restsharp-com-c-da-teoria-a-pr%C3%A1tica-parte-i-bc21c624d706">aqui</a>. Seguindo para nossas validações finais realizei a instalação de mais um framework o <strong>FluentAssertions</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UTWE8vVGhg60LzU7qSUsqg.png" /></figure><p>Bom, para garantirmos que nossa requisição ocorreu com sucesso ela deverá nos retornar o código HTTP 200 isso indica que a requisição foi bem sucedida, mas prestem atenção pois não garante que nossos dados estão corretos, então o nosso trecho de código responsável por essa validação está logo abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/396/1*SKDiCbPx4G8KBFl3rx7XsQ.png" /></figure><p>Nossa próxima validação será a “marca” que será retornada, lembram que mais acima colocamos um breakpoint para visualizarmos nossos dados, pensem que não teremos um breakpoint ali para sempre pois nosso testes precisam ficar sendo validados de forma automatizada e com um breakpoint ali não será possível, pois toda vez que passar por aquele ponto irá parar a nossa execução.</p><p>Para nossa outra validação usaremos o <strong>TestTools </strong>do Visual Studio. Agora eu quero garantir que nosso método GET está retornando na marca por exemplo o valor “Audi”, então se olharmos para o trecho de código abaixo estou praticamente dizendo que é verdadeiro que na “marca” contém uma informação que corresponde ao nome de “Audi”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/394/1*g5S3rffRVmo1RQd-M2g0cw.png" /></figure><p>Vamos então executar nosso código e ver o que acontece? Caso não tenhamos cometido nenhum erro no momento de escrevermos nosso teste deveremos visualizar o seguinte resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J14M4BBWk_1KLSYZsor78Q.png" /></figure><p>Legal né? Nossa validação ocorreu de acordo com o esperado, mas podemos inserir um outro valor ao invés de “Audi” para ver se nosso teste irá falhar, então vamos lá.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lw9Ab194EdWvArQEDD4SPw.png" /></figure><p>Reparem que coloquei um valor totalmente diferente “fdasfsdfasd” e a execução do nosso teste falhou inclusive nos indicando a linha 32 onde possivelmente estará nosso erro.</p><p>Galera, espero que tenham compreendido e se divertido. Teremos mais um próximo artigo e último onde falaremos do método POST.</p><p>That’s all folks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=88bbe351fa77" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-iii-88bbe351fa77">Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte III</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A minha evolução de Tester Manual para Tester de Automação]]></title>
            <link>https://medium.com/beelabacademy/a-minha-evolu%C3%A7%C3%A3o-de-tester-manual-para-tester-de-automa%C3%A7%C3%A3o-efba8330b479?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/efba8330b479</guid>
            <category><![CDATA[test]]></category>
            <category><![CDATA[testers]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[test-engineer]]></category>
            <dc:creator><![CDATA[Sofia Trindade]]></dc:creator>
            <pubDate>Thu, 07 May 2020 15:01:28 GMT</pubDate>
            <atom:updated>2021-10-20T17:33:29.143Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tr8auU1iGmzttYgN.png" /></figure><p>Olá a todos!</p><p>Fico muito feliz por ter despertado a vossa atenção para lerem este meu artigo…</p><p>Em primeiro lugar, quero contar-vos que eu vim parar à área da TI e mais propriamente à área de Testes de Software por acaso, mas… estou a adorar 😊</p><p>E vocês perguntam-se, por que será?</p><p>Porque, em 2013, tive que decidir que licenciatura queria frequentar… Não tinha qualquer ideia porque eu gostava da área da saúde e de matemática, mas não tinha certezas de nada… Foi então, que familiares meus, que estão na área de TI, convenceram-me a candidatar-me à Licenciatura em Engenharia Informática…</p><p>E, assim aconteceu, entrei sem saber ao certo do que se tratava… No primeiro semestre pensei em mudar de curso várias vezes. Mas, apenas não o fiz por causa da matemática. Fui fazendo as disciplinas e consegui concluir a licenciatura no tempo expectável.</p><p>Depois, em 2016, comecei à procura de emprego e a primeira oportunidade que surgiu (coincidência ou não) foi logo para testes de software. Como eu não gostava muito de programação juntei o útil ao agradável e aceitei.</p><p>Estive cerca de 1 ano e meio a fazer apenas testes manuais, mas como trabalhava num ambiente <em>agile</em> e convivia todos os dias com os <em>developers</em>, comecei a despertar em mim o bichinho da programação…</p><blockquote>A primeira interação com algum automatismo de testes foi com o <strong>Selenium IDE</strong> (na altura apenas estava integrado com o Mozilla, agora já dá com outros browsers) e a primeira sensação que tive foi de alívio por conseguir reduzir todos os clicks repetitivos que dava numa interface num único click que era no play da execução da suite de testes…</blockquote><p>Foi aqui que o meu <em>mindset</em> começou a mudar, comecei a explorar mais a área de automação e a gostar cada vez mais do poder que ela me dava.</p><blockquote>A segunda interação, foi começar a exportar todas as suites que tinha no Selenium IDE para scripts em C# para integrar numa solução de desenvolvimento. Mas, algumas coisas não eram compatíveis e tive que começar a mexer no código de alguns scripts.</blockquote><p>E aqui comecei a pensar: “e se fosse eu a fazer, desde o início, estes <em>scripts</em>? Será que não é mais vantajoso?” A resposta na altura foi claramente que sim, já que tinha acesso à solução de desenvolvimento, comecei a trabalhar com o <strong>selenium webdriver em c# </strong>e a construir tudo de início. Segundo as boas práticas como <em>BDD</em> e <em>Gherkin Syntax</em>, <em>Page Object Pattern</em>…</p><p>E, pronto este foi ponto de partida na automação… A partir deste momento foi sempre uma evolução constante, não só por minha vontade, mas também, porque a tecnologia está sempre a evoluir e nós temos que acompanhar.</p><blockquote>Neste momento, eu já consigo automatizar testes de integração em APIs com o<strong> JEST e Supertest</strong> (se tiverem curiosidade em aprender podem espreitar o meu artigo <a href="https://medium.com/@sofia.trindade_68014/testes-automatizados-de-apis-com-jest-supertest-8aa6a96f61d1">aqui</a>) explorei também o <strong>WiremockJs </strong>para não ter dependências de serviços externos. Ainda neste nível, uso o <strong>Postman </strong>com ferramenta de auxílio nos testes de API manuais. E, também, tive interações com o <strong>JMETER </strong>para testes de performance. No nível acima nos testes de end-to-end uso, neste momento, o <strong>WebdriverIO com Cucumber e o JEST.</strong></blockquote><p>Como podem reparar <em>mudei também a linguagem de programação de </em><strong><em>c#</em></strong><em> para </em><strong><em>javascript</em></strong> isto foi outra vitória… Eu passei a adorar <em>javascript</em>, porque na minha opinião, é uma linguagem menos burocrática e muito mais rápida de aprender!</p><p>Todo o processo desde o <em>setup</em> do projeto de testes até à parte de configurar os comandos de teste a serem executados durante de um processo <em>deploy</em> nas <em>pipelines</em> são coisas que eu nunca imaginei fazer… Porque pensava que a automação era um bicho de 7 cabeças 👻</p><p>Mas garanto-vos que não é, e este foi o único motivo que me levou à escrita deste artigo, porque quero inspirar e incentivar todos os <em>testers</em> que apenas fazem testes manuais a experimentar a automação.</p><p>É minha intenção continuar a escrever artigos com as ferramentas que uso, por isso fiquem atentos 😉</p><p>Espero que tenham gostado!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=efba8330b479" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/a-minha-evolu%C3%A7%C3%A3o-de-tester-manual-para-tester-de-automa%C3%A7%C3%A3o-efba8330b479">A minha evolução de Tester Manual para Tester de Automação</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testes Automatizados de APIs com JEST & SUPERTEST]]></title>
            <link>https://medium.com/beelabacademy/testes-automatizados-de-apis-com-jest-supertest-8aa6a96f61d1?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/8aa6a96f61d1</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[jest]]></category>
            <category><![CDATA[supertest]]></category>
            <category><![CDATA[api]]></category>
            <dc:creator><![CDATA[Sofia Trindade]]></dc:creator>
            <pubDate>Thu, 07 May 2020 14:59:57 GMT</pubDate>
            <atom:updated>2020-04-05T22:12:56.285Z</atom:updated>
            <content:encoded><![CDATA[<p>Como estamos numa constante evolução tecnológica já existem diversas ferramentas/frameworks open source que ajudam na escrita automatizada de testes. E, já começa a ser difícil saber qual a que melhor se adequa à nossa situação.</p><p>Os testes automatizados a APIs, como todos já devem saber, enquadram-se na camada intermédia da piramide de testes, que é onde se fazem os testes de integração.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/560/0*QYpCbu0ZMNXgds_a.png" /><figcaption>Pirâmide ideal de testes segundo <a href="https://martinfowler.com/bliki/TestPyramid.html">Martin Fowler</a></figcaption></figure><p><em>Da pirâmide retira-se, que é muito mais rápido e barato fazer testes de baixo nível do que testes de alto nível. Logo, se queremos poupar tempo e dinheiro devemos investir mais nos testes de baixo nível. A quantidade de testes deve diminuir á medida que subimos para os níveis superiores.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/444/0*kA7gMyffuxpupOXa.gif" /><figcaption><a href="https://www.google.com/url?sa=i&amp;url=https%3A%2F%2Fgfycat.com%2Fdizzyhandsomejohndory&amp;psig=AOvVaw3z0sOZFWy3hGg31OtFsElX&amp;ust=1585583357923000&amp;source=images&amp;cd=vfe&amp;ved=0CAIQjRxqFwoTCOiU8LiEwOgCFQAAAAAdAAAAABAD">Testes unitários vs testes de integração.</a></figcaption></figure><p><em>Os Testes de Integração visam (como o próprio nome diz) a integração das partes isoladas do sistema, um exemplo prático deste tipo de testes é o da “porta e da fechadura” em que o requisito é a fechadura trancar a porta. Como apenas foram feitos testes unitários aos componentes isoladamente, quando houve a integração dos mesmos não cumpriam o requisito, porque aquele tipo de fechaduras não trancam portas de deslizar. Assim, através dos testes de integração conseguimos perceber se os componentes que foram desenvolvidos isoladamente quando interligados cumprem ou não com os requisitos do negócio.</em></p><p>Após a análise do que já existia no mercado foram escolhidas as seguintes ferramentas/frameworks open source para proceder à automatização de testes de APIs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/1*M0tzk-tfDQP3mrVGcoT5-A.png" /></figure><p>Para se proceder á instalação, primeiramente tem que se instalar o <strong>node.js</strong> na máquina pretendida, para isso basta fazer o download do executável.</p><p>De seguida, através da linha de comandos aceder a uma pasta onde se queira guardar os testes e executar os seguintes comandos:<br> •<strong> <em>npm init </em></strong>— para inicializarmos a utilização do npm e definirmos algumas informações sobre os testes/projeto, nomeadamente a parte em que definimos qual o comando que vai fazer com que corram os testes, neste caso colocou-se “test”. Após a execução deste comando vamos ter na pasta selecionada um ficheiro cujo nome é “package.json” que serve para guardar algumas definições, como scritps de execução de comandos, caminhos de diretorias onde são guardados outputs dos resultados dos testes, dependências, etc;<br> • <strong><em>npm install jest supertest</em></strong> — para instalarmos os packages do jest e supertest. Após a execução deste comando vamos ter uma pasta chamada “node_modules” que é onde estão guardados os packages instalados. Também os ficheiros “package.json” e “package-lock.json” são alterados para incluírem as informações dos novos packages instalados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*7TB3O9km5XYY4-GwaWnOZQ.png" /></figure><p>Após executarmos os dois comandos anteriores, e caso necessitemos de colocar o repositório dos testes noutra máquina apenas temos de fazer:<br> • <strong><em>npm install ou npm i</em></strong>– para instalar o npm, os packages das dependências e as definições contidas no ficheiro “package.json”.<br>O ficheiro “package.json” deve ficar com as mesmas configurações ilustradas de seguida:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/301/1*JL7rm9TIxlUSkfTrsLrUqg.png" /></figure><p>Após o término da instalação estamos prontos para iniciar a escrita dos testes. Para isso, apenas precisamos de um editor de texto (até o bloco de notas que vem com o windows serve, mas existem outros mais adaptados para a programação, por isso eu gosto mais de usar o Visual Studio Code).</p><p>Dentro do editor vamos começar a escrever num ficheiro. Primeiramente teremos que importar o package que instalamos do supertest para uma constante (porque vai ser reutilizada ao longo do teste para se acessar aos seus métodos).<br>Depois vamos passar-lhe o URL da API (por exemplo “<a href="http://localhost:8082/">http://localhost:808</a>0”) e definir o request:<br> • se é um <strong>.GET/.POST/.PUT/.DELETE</strong><br> • se precisamos de atribuir <em>headers</em> através do “<strong>.set</strong>”<br> • se precisamos de passar alguma <em>query </em>através do método “<strong>.query</strong>”;<br> • e definir o status code esperado através do método “<strong>.expect</strong>”.<br>Existem mais métodos que podemos usar, para isso deveremos consultar a <a href="https://www.npmjs.com/package/supertest">documentação do supertest</a>.<br>Como, por vezes, precisamos também de validar o <strong><em>body </em></strong>das respostas podemos usar o “<strong>.then</strong>” para analisar o que retorna a resposta e fazer “<strong>expect</strong>” (mas este expect é diferente do que usamos para o status code do supertest, porque este é do JEST) podendo, com este utilizar outros métodos que nos ajudam a fazer melhores validações, para saber quais outros métodos usar devemos consultar a <a href="https://jestjs.io/docs/en/expect">documentação do JEST</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/548/1*bd-6eegwbzKXruG36_hBsg.png" /></figure><p>Para além deste expect o JEST tem mais alguns métodos que nos vão ser úteis na escrita dos testes, tais como:<br> • <strong>describe</strong>: é como se fosse uma suite de testes, ou seja um describe pode ter um conjunto de testes. Dentro dos describes podemos ainda colocar outros describes com outros conjuntos de testes como se pode visualizar no “Summary” da figura abaixo;<br> • <strong>it</strong> ou <strong>test: </strong>são os nossos testes, cada it é um teste, logo os describes aglomeram um conjunto de its;<br> •<strong> beforeAll/beforeEach: </strong>estes dois métodos conseguem executar coisas antes de todos os testes (beforeAll) ou antes de cada teste (beforeEach). Exemplos práticos dos dois casos podem ser:<br>&gt; No beforeAll iniciar a conexão a uma base de dados;<br>&gt; E no beforeEach a execução de um script de inserção de algum dado que iremos precisar nos testes;<br> • <strong>afterAll/afterEach:</strong> estes dois métodos (que são o contrário dos de cima) conseguem executar coisas depois de todos os testes (afterAll) ou antes de cada teste (afterEach). Exemplos práticos dos dois casos podem ser:<br>&gt; No afterAll fechar a conexão a uma base de dados;<br>&gt; E no afterEach a execução de um script de remoção de algum dado que apenas foi utilizado nos testes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/607/1*2lve3uJb7dFT72dNWVaAPw.png" /></figure><p>Depois de termos os testes todos automatizados precisamos de saber se estão a funcionar, para isso precisamos de os executar.</p><p>Para executar estes testes apenas basta correr um comando no terminal que é “<strong><em>npm test</em></strong>”. Porquê este comando? Porque foi o que nós definimos no passo da instalação quando fizemos “<strong><em>npm init</em></strong>”. Mas, para confirmar podemos aceder ao ficheiro “<em>package.json</em>” que tem na secção dos <em>scritps</em> o comando de “<strong><em>test</em></strong>” definido. Este comando vai chamar o nosso <em>test runner</em> , o JEST, que compreende todos os ficheiros com a seguinte nomenclatura <em>“</em><strong><em>&lt;nome&gt;.test.js</em></strong>” e vai executar todos os testes que estiverem dentro deles. Como se observa na próxima imagem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/769/1*MER3t4Cdqn1VwbSCpRyIlg.png" /></figure><p>Por fim, para qualquer sistema de <a href="https://configr.com/blog/deploy-em-4-passos-para-desenvolvedores-iniciantes/"><strong><em>deploy</em></strong> </a>apenas é necessário executar os seguintes comandos dentro da pasta onde estiver o ficheiro do package.json.</p><ul><li><strong><em>npm i</em></strong></li><li><strong><em>npm test</em></strong></li></ul><p>Podem ver o meu repositório no git hub que contém alguns exemplos destes testes.</p><p>📌 <a href="https://github.com/sofiatrindade/APITesting_JEST_SUPERTEST">https://github.com/sofiatrindade/APITesting_JEST_SUPERTEST</a> 📌</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8aa6a96f61d1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/testes-automatizados-de-apis-com-jest-supertest-8aa6a96f61d1">Testes Automatizados de APIs com JEST &amp; SUPERTEST</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte II]]></title>
            <link>https://medium.com/beelabacademy/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-ii-c531fafbed74?source=rss----fa1ab4e43c0---4</link>
            <guid isPermaLink="false">https://medium.com/p/c531fafbed74</guid>
            <category><![CDATA[csharp]]></category>
            <dc:creator><![CDATA[Breno Ferreira]]></dc:creator>
            <pubDate>Tue, 28 Apr 2020 17:04:22 GMT</pubDate>
            <atom:updated>2020-04-28T17:58:46.412Z</atom:updated>
            <content:encoded><![CDATA[<h3><a href="https://medium.com/beelabsolutions/restsharp-com-c-da-teoria-a-pr%C3%A1tica-parte-i-bc21c624d706?source=your_stories_page---------------------------">Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte I</a>I</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/578/1*OICaHvjcxhpFofj6Bai6aA.jpeg" /></figure><p>Retomando a série de testes com RestSharp, vamos dar continuidade instalando e configurando nossas ferramentas para iniciar a parte prática, para isso será necessário instalar as seguintes ferramentas:</p><p>· Visual Studio (Community);</p><p>· Versão mais recente do .Net framework;</p><p>· Specflow;</p><p>· Nunit;</p><p>· RestSharp;</p><p>· Json-Server;</p><p>Iremos navegar até o site do Visual Studio para fazermos o <a href="https://visualstudio.microsoft.com/vs/">download</a> da nossa IDE. Para os nossos testes a versão Community atende perfeitamente e é uma versão gratuita.</p><p>Download concluído, iremos ao VS e clicaremos em File → New → Project ou para quem estiver utilizando Windows Crtl+Shift+N, escolheremos a opção Unit Test Project (.NET Framework).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j82gOHVlV-qPxA6OD5z6nw.png" /></figure><p>Vamos agora informar o nome do nosso Projeto, nessa opção é possível escolher seu diretório de preferência e também a versão do framework, no caso estou utiizando a versão mais recente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yNPFOD8JQyJIKpsilc6u1w.png" /></figure><p>Após criarmos nosso projeto será possível visualizarmos a seguinte estrutura:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m5f-CnwOysJFagCKiehTCQ.png" /></figure><p>Segundo passo iremos instalar o RestSharp, clicaremos com o botão direito em References → Manage NuGet Packages, em seguinda iremos pesquisar por RestSharp e clicar em Install.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*31rukenZv1GwDljZAYvcNA.png" /></figure><p>Próximo passo adicionaremos ao nosso projeto o SpecFlow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5bA2twOm1pjcgtCWg0tZhQ.png" /></figure><p>Como nosso foco nesse momento não está relacionado ao SpecFlow sugiro que deem uma lida sobre clicando <a href="https://specflow.org/">aqui</a>.</p><p>Mas basicamente o Specflow é um framework inspirado no Cucumber, porém para ser utilizado em um ambiente .NET, com ele é possível descrever cenários reais de uma forma estruturada.</p><h4>Obtendo dados para testar nossa API</h4><p>Para executarmos nossos testes necessitamos de uma API, para quem não compreende muito bem o termo API pode acessar <a href="https://www.redhat.com/pt-br/topics/api/what-are-application-programming-interfaces">aqui</a> e obter mais informações.</p><p>Navegando pela web me deparei com o <a href="https://github.com/typicode/json-server">Json-Server</a>, com ele é possivel criarmos um arquivo <strong>.json</strong> e passarmos os dados que irão compor nossa API para executarmos os nossos testes.</p><p>Na figura abaixo é possível vermos o comando para inicialização do nosso servidor e os endereços HTTP para consultarmos nossos dados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1017/1*OEipvI5Ep3i37X-NcZ0GfQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t5I--7wTk8rU5xBZQJthFQ.png" /></figure><p>Galera, ambiente configurado e pronto para criarmos nossa automatização de testes de api com RestSharp, para quem não leu o post anterior pode clicar <a href="https://medium.com/beelabsolutions/restsharp-com-c-da-teoria-a-pr%C3%A1tica-parte-i-bc21c624d706">aqui</a>. No próximo post vamos para a prática.</p><p>That’s all folks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c531fafbed74" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beelabacademy/automatizando-os-testes-da-sua-api-da-teoria-a-pr%C3%A1tica-com-restsharp-e-c-parte-ii-c531fafbed74">Automatizando os testes da sua API, da teoria a prática com RestSharp e C# — Parte II</a> was originally published in <a href="https://medium.com/beelabacademy">Bee Lab Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>