<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Renato Felício on Medium]]></title>
        <description><![CDATA[Stories by Renato Felício on Medium]]></description>
        <link>https://medium.com/@renatofsantos?source=rss-92e08f7546ca------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*coxplACHMbgow4zunnu4kA.jpeg</url>
            <title>Stories by Renato Felício on Medium</title>
            <link>https://medium.com/@renatofsantos?source=rss-92e08f7546ca------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 23:20:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@renatofsantos/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Escrevendo testes unitários em cenários caóticos: Uma abordagem prática!]]></title>
            <link>https://medium.com/engineering-idwall/escrevendo-testes-unitarios-em-cenarios-caoticos-uma-abordagem-pratica-e44a2d2d5d85?source=rss-92e08f7546ca------2</link>
            <guid isPermaLink="false">https://medium.com/p/e44a2d2d5d85</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Renato Felício]]></dc:creator>
            <pubDate>Fri, 24 Feb 2023 13:56:21 GMT</pubDate>
            <atom:updated>2023-02-24T13:57:34.969Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Escrevendo testes unitários em cenários caóticos: uma abordagem prática</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NwaynlkuP1X2nYiwGX5Qrw.png" /></figure><p><strong>Alinhando teoria e prática para deixar seu projeto melhor do que você o encontrou.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f1urhN1ySdkTUoS0B8Wj6w.jpeg" /><figcaption>Testes não podem falhar, se você não executar nenhum!</figcaption></figure><h3>Contexto &amp; Motivação</h3><p><strong>Testes automatizados </strong>constituem um pilar muito importante durante o ciclo de desenvolvimento de software. Seu objetivo principal é garantir o funcionamento adequado e resiliente da aplicação. Além disso, eles podem também ajudar a poupar horas e mais horas de testes manuais.</p><p><strong>Logo, desenvolver a habilidade de codificar testes automatizados possibilita que o desenvolvedor torne uma aplicação mais resiliente, segura e robusta.</strong></p><p>Em geral, a comunidade de desenvolvedores de software produz excelentes referências, sendo elas livros clássicos, artigos e palestras técnicas sobre esse assunto tão importante. Basta &quot;dar um Google&quot; que veremos dezenas e dezenas de bons materiais prontos para serem consumidos.</p><p>Porém, percebo uma lacuna na maioria dos materiais mais modernos: a desconexão com <strong>aplicações reais</strong>, <strong>cenários reais</strong> e <strong>problemas reais</strong>. São apresentados bons conceitos, mas em situações de projeto controlados e previsíveis. Cenários assim favorecem a aplicação de conceitos de maneira bem direta e imediata. Mas veja bem, não há <strong>nada</strong> de errado nisso. Nada mesmo. Friso que é uma abordagem muito valiosa.</p><p>Por outro lado, projetos grandes, com anos de duração e que passaram pelos teclados de diversos programadores, podem não possuir padrões bem definidos e ter uma manutenção custosa. Isso é bastante comum. A base de código nesses contextos <strong>costuma conter poucos testes e, principalmente, um código difícil de ser testado</strong>. A esse contexto específico damos o nome de <strong>cenário caótico</strong>.</p><p>Assim,<strong> </strong>conforme o projeto começa a evoluir e receber mais funcionalidades, as dificuldades começam a aparecer e os materiais usuais de referência não resolvem mais os seus problemas como antes. Em momentos assim é preciso contar com desenvolvedores mais experientes para dividir conhecimento prático e habilidades de resolução de problemas nesses contextos. Caso contrário, as lacunas entre teoria e prática tendem a crescer mais e mais, justamente o que não desejamos.</p><p>Dessa forma, o <strong>principal objetivo desse artigo é estreitar essa lacuna</strong>, por meio de uma abordagem bem heurística e pragmática. Conceitos pertinentes serão apresentados quando necessários à discussão. Aprenderemos a como adentrar em um cenário caótico, entender suas necessidades, alinhar teoria e prática e deixar a base de código melhor do que você encontrou :).</p><h3>Qual é o nosso problema, afinal?</h3><p>Digamos que sobrou algum tempo na sua sprint e você decidiu puxar aquele <em>card</em> de testes há muito esquecido. Ou quem sabe você decidiu <a href="https://martinfowler.com/bliki/OpportunisticRefactoring.html">refatorar algum código de maneira oportunista</a>, por conta própria, escrevendo alguns testes. <strong><em>Kudos</em> para você, inclusive!</strong></p><p>Dessa forma você pode, enfim, aplicar diversos conceitos e metodologias de testes, como <a href="https://martinfowler.com/bliki/TestDouble.html"><strong>Dublês de Teste</strong></a><strong>, </strong><a href="https://betterprogramming.pub/swift-tests-tips-tricks-well-designed-test-structure-31dfa2fb5282"><strong><em>AAA</em></strong></a><strong><em> </em></strong><em>e </em><a href="https://martinfowler.com/bliki/GivenWhenThen.html"><strong><em>GivenWhenThen</em></strong></a><strong><em>. </em></strong>Veja abaixo o cenário que será o seu <em>playground</em> a partir daqui!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*qjmva5PPAiQ6y6XwZCMwxA.jpeg" /><figcaption>&quot;Falar é de graça. Me mostre o código&quot;. Linus Torvalds.</figcaption></figure><pre>final class TemplateViewController: UIViewController {<br><br>    var viewModel: TemplateViewModelProtocol?<br><br>    override func loadView() {<br>        super.loadView()<br>        guard let type = viewModel?.getData() else { return }<br>        view = TemplateView(withType: type, delegate: self)<br>    }<br><br>    override func viewDidLoad() {<br>        super.viewDidLoad()<br>        setupNavigation()<br>    }<br><br>    private func setupNavigation() {<br>        title = viewModel?.getData().navigationTitle ?? &quot;&quot;<br>    }<br><br>}<br><br>extension TemplateViewController: TemplateViewDelegate {<br>    internal func didTapOpenButton() {<br>        guard let urlText = viewModel?.getData().clickableText,<br>              let  url = URL(string: urlText.url),<br>              !urlText.url.isEmpty<br>        else { return }<br><br>        if #available(iOS 10.0, *) {<br>            UIApplication.shared.open(url)<br>        } else {<br>            UIApplication.shared.openURL(url)<br>        }<br>    }<br>}</pre><p>Ao mapear as regras de negócio e o comportamento de cada cenário, você sumariza os seguintes pontos a serem testados.</p><ol><li>A TemplateView (TV)</li></ol><p>1.1 Foi instanciada corretamente?</p><p>1.2 Recebeu os parâmetros adequados?</p><p>2. O métodosetupNavigation()da TemplateViewController (TVC) foi executado?</p><p>3. O método didTapOpenButton()</p><p>3.1 Foi chamado com uma URL correta e válida? e</p><p>3.2 O <em>browser default </em>foi aberto?</p><p>SHOW!<strong> </strong>Com todo o cenário mapeado você já pode colocar a mão na massa!</p><h3>Mão na massa: Parte I</h3><p>Se você já possui alguma prática com testes unitários, então você escreveu testes para todos os cenários, replicando os padrões já existentes no seu no seu projeto. O resultado está logo abaixo:</p><pre>final class TemplateViewControllerTests: XCTestCase {<br><br>    private var sut: TemplateViewController!<br>    private var viewModelStub: TemplateViewModelStub!<br>    private var templateViewDataMock: TemplateViewDataProtocol!<br><br>    override func setUp() {<br>        sut = TemplateViewController()<br><br>        templateViewDataMock = TemplateViewData()<br>        viewModelStub = TemplateViewModelStub(withData: templateViewDataMock)<br>        sut.viewModel = viewModelStub<br>    }<br><br>    override func tearDown() {<br>        sut.viewModel = nil<br>        templateViewDataMock = nil<br>        viewModelStub = nil<br>        sut = nil<br>    }<br><br>    func test_loadView_shouldSetTemplateViewSuccessfully() {<br>        XCTAssertTrue(sut.view is TemplateView)<br>    }<br><br>    func test_loadView_shouldNotSetTemplateViewSuccessfully() {<br>        sut.viewModel = nil<br><br>        XCTAssertFalse(sut.view is TemplateView)<br>    }<br><br>    func test_setupNavigation_shoulSetTitleSuccessfully() {<br>        // Accessing sut view in order force it to load (workaround)<br>        let _ = sut.view<br>        let resultTitle = sut.title<br><br>        sut.didTapOpenButton()<br><br>        XCTAssertEqual(templateViewDataMock.navigationTitle!, resultTitle)<br>    }<br><br>    func test_didTapOpenButton_shouldOpenURLSuccessfully() {<br>        let expectedDataCallCount = 1<br><br>        sut.didTapOpenButton()<br><br>        XCTAssertEqual(viewModelStub.dataCallCount, expectedDataCallCount)<br>    }<br>}</pre><p>É isso! Mais uma tarefa finalizada com sucesso. Ao menos você imaginou que sim…</p><blockquote>&quot;Mas a vida é uma caixinha de surpresas…&quot;</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x4xJ1R5OQT8pT1bfeinHlQ.jpeg" /><figcaption><a href="http://www.osmelhoresdomundo.com/">Cia de Comédia &quot;Os melhores do mundo&quot;</a></figcaption></figure><h3>Vivendo e aprendendo</h3><p>Sim, a vida é mesmo uma caixinha de surpresas e você vai precisar ser <em>Joseph Climber </em>(<a href="https://www.youtube.com/watch?v=dM3Wi_DnLpc">vem cá se você não pegou a referência</a>)<em>. </em>Isso porque, ao revisar o seu MR/PR, seu colega mais experiente fez uma série de pedidos de mudança de código, deu várias dicas e indicou uma série de tópicos para estudo.</p><p>Em um primeiro momento você poderia até imaginar que não fez um bom trabalho. Mas acontece que esse é um dos melhores momentos de troca, aprendizado e elevação do conhecimento: em uma situação real, com código de produção.</p><p>Foi sugerido que você focasse no <a href="https://drive.google.com/file/d/0BwhCYaYDn8EgOTViYjJhYzMtMzYxMC00MzFjLWJjMzYtOGJiMDc5N2JkYmJi/view?resourcekey=0-3H2Ld4l-dIZZVRmHSpNLcA"><strong><em>I</em></strong><em>nterface Segregation Principle (ISP)</em></a> e <a href="https://drive.google.com/file/d/0BwhCYaYDn8EgMjdlMWIzNGUtZTQ0NC00ZjQ5LTkwYzQtZjRhMDRlNTQ3ZGMz/view?resourcekey=0-jRJy8Mi4CltX8KX84BqLFQ"><strong><em>D</em></strong><em>ependency Inversion Principle</em></a> do acrônimo <a href="https://dnamic.ai/blog/introduction-of-solid-design-principles-by-uncle-bob/">S.O.L.I.D</a>. Se você ainda não tinha ouvido falar nesse acrônimo, ele é um conjunto de boas práticas para o <em>design</em> de <em>software</em> orientado a objetos. E foi escrito pelo querido <a href="https://pt.wikipedia.org/wiki/Robert_Cecil_Martin">Bob Martin</a><strong> </strong>(<em>Uncle Bob</em> para os íntimos).</p><p>Você compreendeu que a partir desses princípios, e alguns exemplos, você conseguiria entender <a href="https://martinfowler.com/bliki/InversionOfControl.html">Inversão de Controle</a> e <a href="https://martinfowler.com/articles/injection.html">Injeção de Dependência</a>. Após algum tempo de estudo, você chamou seu colega para uma sessão de <em>pair programming</em>, para compartilhar o que você aprendeu.</p><p><em>Começando pelo famoso SOLID!</em></p><h3>S.O.L.I.D.</h3><p>O acrônimo SOLID diz respeito a um conjunto de princípios de boas práticas aplicadas ao design de software orientado a objetos. Esses princípios também objetivam tornar um código <a href="https://en.wikipedia.org/wiki/Cohesion_(computer_science)">coeso</a>,<strong> </strong>e com pouco <a href="https://www.sciencedirect.com/science/article/abs/pii/0164121293900726">acoplamento</a> entre classes. Isso implica em uma base de código com classes reusáveis e boa manutenibilidade.</p><p>Uma boa suíte de testes possui testes independentes e isolados, o que pode ser atribuído a um baixo acoplamento entre classes e isso não quer dizer que acoplamento seja uma característica ruim. É inevitável que classes se comuniquem, mas a forma com que o acoplamento se dá é que pode ser algo danoso ou não.</p><p>O primeiro princípio que possibilita o desacoplamento de código é o:</p><h4><em>Interface Segregation Principle (ISP)</em></h4><p>Também conhecido como Princípio de Segregação de Interfaces, diz resumidamente:</p><blockquote>&quot;Nenhum cliente deve ser forçado a depender de métodos que não utiliza.&quot;</blockquote><p>Implicitamente, esse enunciado incentiva o isolamento de propriedades e comportamentos bem específicos em um protocolo. Isso aumenta a coesão no código, evitando sobrecarga desnecessária a classe e infringindo o primeiro princípio do SOLID — O Princípio de Responsabilidade Única (SRP).</p><p>Tudo isso parece bem abstrato, certo? E de fato está, por enquanto.</p><p>Para ilustrar a ideia acima, note que o cliente TemplateViewController (TVC) possui como dependência o protocolo TemplateViewModelProtocol (TVMP). Como um protocolo expõe apenas suas assinaturas, a TVC “conhece” apenas o necessário: a abstração do protocolo, trazendo consigo uma característica bem interessante chamada de <strong>polimorfismo</strong>. Esse fato aumenta a coesão, separação de responsabilidades e diminui o acoplamento.</p><p><em>Deu pra pegar? Se não, releia bem tranquilo e depois vem comigo!</em></p><p>Por outro lado, a TemplateView (TV) é uma dependência da TVC que não possui nenhum protocolo associado. Dessa forma, a TVC está acoplada a esse tipo concreto. Logo, qualquer refatoração não poderá envolver qualquer tipo de substituição da TV, possibilitada pelo polimorfismo. A menos que envolva herança, o que é um pilar que devemos evitar utilizar, pois é uma prática que pode aumentar rapidamente a complexidade de código, desde que sejam empregados muitos níveis de herança.</p><p>Agora atente-se ao teste test_loadView_shouldSetTemplateViewSuccessfully . Há apenas a verificação do tipo concreto TV, o que não satisfaz completamente os critérios de testes elencados ponto 1, da seção <strong>Pontos a serem testados</strong>.</p><p><em>Mas por quê?</em><strong><br></strong>Para que isso seja possível, é necessário entender um pouco mais sobre a ideia de Inversão de Controle, como ela pode ser posta em prática a partir do Princípio da Inversão de Dependência e como essa prática reduz acoplamento entre estruturas.</p><h4>Dependency Inversion &amp;&amp; Inversion of Control (IoC) &amp;&amp; Dependency Injection (DI)</h4><p>Vamos olhar mais uma vez para a TemplateView (TV). Já sabemos que ela é uma dependência da TemplateViewController (TVC). Atente-se também ao método setUp() da classe de testes TemplateViewControllerTests, ou também imagine que você está escrevendo um classe orquestradora de fluxo de navegação, seguindo o <a href="https://www.youtube.com/watch?v=a1g3k3NObkE"><em>Coordinator Design Pattern</em></a>, por exemplo. Existem <em>n</em> formas de fazer isso e não vamos nos prender a esse ponto (apenas saiba que existem). Seguindo.</p><p>Podemos ver que TV é uma dependência cuja referência (<em>reference type</em>) não é acessível do ponto de vista da estrutura que instancia e utiliza a TVC. É o que podemos chamar de <strong>dependência implícita</strong>. Ela não pode ser controlada. <em>Mas como assim ser controlada?</em> Na prática, não é possível substituir essa dependência para fins de refatoração e testes, por exemplo, sem uma refatoração considerável.</p><p>Dessa forma, há um acoplamento e dependência de uma classe concreta, de modo que mudanças significativas na TV podem introduzir <em>bugs</em> indesejados na TVC.</p><p>Parece bem sério, né? Calma que pode piorar! rs</p><p>Dá uma olhada agora no método didTapOpenButton. Ocorre um comportamento <strong>implícito</strong>, especificamente no escopo do UIApplication.share.open(url: URL). Tal método é exposto pelo <em>Singleton </em>UIApplication<em>. </em>O método open realiza uma chamada externa a aplicação para um <em>browser default</em> do device. Como sabemos, esse comportamento é parte da regra negocial da TVC e deve ser testada.</p><p><em>Mas como?<br></em>É preciso verificar se o método foi chamado, uma ou mais vezes, e se foi passado um parâmetro do tipo URL válido e capaz de ser aberto. <em>Isso é moleza de se fazer, </em>mas<em> </em><strong>manualmente</strong><em> </em>apenas. Note que esse teste não foi feito, pois esse aspecto não pode ser medido ou até mesmo controlado.</p><p>Para resolver esses pontos, lançamos mão dos conceitos de <strong>Inversão de Controle</strong> e <strong>Princípio da Injeção de Dependência</strong>.</p><p>Recapitulando, é sabido que o fluxo de navegação de uma UIViewController pode ser feito através de uma UINavigationController ou até mesmo um <em>Coordinator Pattern</em> que encapsula a última.</p><p>No caso de uma classe de teste, a construção de uma UIViewController pode ser feita pelo método setUp ou por algum método de teste específico. Porém, não há um mecanismo nativo que possibilite extrair informações sobre a chamada e/ou parâmetros passados no método.</p><p>É neste momento que entra a ideia da Inversão de Controle: explicitar as referências implíticas da TemplateView ou abrir uma URL por meio de uma UIApplication.shared.open(url: URL). Essa inversão é feita a partir do <strong>Princípio da Inversão de Dependência</strong>, que faz os seguintes apontamentos:</p><blockquote>“Módulos de alto nível não devem incorporar (ou incluir) nada dos módulos de baixo nível. Ambos devem trabalhar apenas com abstrações, ou seja, interfaces (protocolos)” e…</blockquote><blockquote>“Abstrações não devem depender de detalhes de implementação, mas os detalhes é que devem depender de abstrações.”</blockquote><p>Parece complicado? Veja bem que não é… <br>O que precisamos? Conhecer protocolos, o que já sabemos. A novidade agora passa a ser como essas dependências devem ser inseridas no cliente. A essa técnica de inserção de dependências dá-se o nome de <strong>Injeção de Dependência</strong>.</p><p>Ela, que dá vida a ideia de inversão de controle e ao princípio de inversão de dependência, consiste em injetar instâncias de objetos que conformem com protocolos em um cliente que dependa dessas abstrações para performar. Veja que a ideia é depender de protocolos e não de implementações concretas!</p><p>O que acha de receber uma estrutura que abre um navegador por si só? Não é mais interessante que apenas essa estrutura específica possua essa funcionalidade de maneira isolada e reutilizável? Pegou a visão? Se não, chega mais que vou te mostrar como fazer isso.</p><p>Mas antes, vou te contar que existem duas formas mais usuais de injetar dependências:</p><ol><li><strong>Via propriedade: </strong>você já conhece! Ela acontece com a TemplateViewModelProtocol (TVMP). Note que a TemplateViewController é parametrizada com uma instância de uma classe que conforma com o TVMP.</li><li><strong>Via inicializador</strong>: o método inicializador recebe como parâmetro a de uma dependência. Esse passo vou te mostrar diretamente.</li></ol><p>E essas foram as explicações que você passou ao seu revisor. Assim, podem prosseguir com o <em>pair programming</em>, escrever os testes e refatorar onde for necessário refatorar.</p><p><strong>Mas antes, respira e toma uma água. É hora de colocar a mão na massa!</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*vCtY9aTI1IiDPwNlBwc3TA.jpeg" /><figcaption>É de ~morfar~ refatorar!</figcaption></figure><h3>Mão na massa: Parte II</h3><h4><em>(agora vai)</em></h4><p>Agora vamos sumarizar os pontos que você vai atacar e resolver as problemáticas discutidas nas seguintes classes:</p><ol><li>TemplateView (TV)</li></ol><p>1.1 Isolar seu comportamento e propriedades em um protocolo TemplateViewProtocol ;</p><p>1.2 Inverter sua dependência na TemplateViewController;</p><p>1.3 Injetar a dependência na TemplateViewController via propriedade;</p><p>1.4 Refatorar a TemplateViewController de modo a interagir com a assinatura da TemplateView;</p><p>1.5 Escrever <em>Stubs </em>e</p><p>1.6 Escrever testes!</p><p>2. UIApplication.shared.open(url: URL)</p><p>2.1 Isolar seu comportamento e propriedades em um protocolo URLNavigatorProtocol ;</p><p>2.2 Escrever uma classe que conforme com o protocolo e o implemente;</p><p>2.3 Inverter sua dependência na TemplateViewController;</p><p>2.4 Injetar a dependência na TemplateViewController via inicializador;</p><p>2.5 Escrever um <em>Spy</em> e</p><p>2.6 Escrever testes!</p><h4>Refatorando</h4><p>Tal qual <em>Jack, o Estripador </em>vamos fatiar esse problema por partes rsrs.</p><p>Começando pelo primeiro ponto 1. TemplateView (TV), temos o seguinte resultado:</p><pre>// 1.1 - Isolar comportamento<br>protocol TemplateViewProtocol where Self: UIView {<br>    var delegate: TemplateViewDelegate? { get set }<br>    func show(viewType: TemplateViewData)<br>}<br><br>final class TemplateViewController: UIViewController {<br><br>    // MARK: - Public properties<br>    var templateViewModel: TemplateViewModelProtocol?<br><br>    // 1.2 - Inversão e 1.3 - Injeção de dependência via propriedade<br>    var templateView: TemplateViewProtocol?<br><br>    override func loadView() {<br>        super.loadView()<br>        guard templateView != nil else { return }<br>        view = templateView<br>    }<br><br>    override func viewDidLoad() {<br>        super.viewDidLoad()<br>        // 1.4 - Refatorar<br>        delegateAndPresentView()<br>    }<br><br>    // ...<br><br>    // 1.4 - Refatorar, consumindo apenas das propriedades <br>    // e comportamentos necessários<br>    private func delegateAndPresentView() {<br>        guard let viewType = templateViewModel?.getData()<br>        else { return }<br>        templateView?.delegate = self<br>        templateView?.show(viewType: viewType)<br>    }<br><br>    // ...<br><br>}</pre><p>Já parece outra classe, hein?!</p><p>Vamos mostrar a segunda parte e sentar um pouquinho para refletirmos sobre o que fizemos juntos.</p><pre>// 2.1 - Isolando comportamento<br>protocol URLNavigatorProtocol: AnyObject {<br>    func open(with url: URL) -&gt; Void<br>}<br><br>// 2.2 - Escrevendo um helper que conforme com o protocolo 2.1<br>final class URLNavigator: URLNavigatorProtocol {<br>    func open(with url: URL) {<br>        UIApplication.shared.openURL(url)<br>    }<br>}<br><br>final class TemplateViewController: UIViewController {<br><br>    // MARK: - Private properties<br>    // Inversão de Dependência<br>    private let urlNavigator: URLNavigatorProtocol<br><br>    // 2.3 - Inversão e 2.4 - Injeção de dependência. Por inicializador.<br>    init(withURLNavigator urlNavigator: URLNavigatorProtocol = URLNavigator()) {<br>        self.urlNavigator = urlNavigator<br>        super.init(nibName: nil, bundle: nil)<br>    }<br><br>    // ...<br>}<br><br>extension TemplateViewController: TemplateViewDelegate {<br>    internal func didTapOpenButton() {<br>        guard let urlText = templateViewModel?.getData().clickableText,<br>              let  url = URL(string: urlText.url),<br>              !urlText.url.isEmpty<br>        else { return }<br><br>        urlNavigator.open(with: url)<br>    }<br>}</pre><p>Foram muitos pontos abordados, direta ou indiretamente, por essas mudanças. Já podemos citar os <strong>ganhos </strong>e <strong>benefícios </strong>da nossa abordagem:</p><ul><li>Código mais coeso<strong> </strong>e enxuto</li><li>TemplateViewController com poucas responsabilidades</li><li>Dependências explícitas, o que torna a classe mais flexível a refatorações</li><li>Dependências de protocolos, o que desacopla a classe em relação a detalhes de implementação</li><li>Menos atritos em possíveis manutenções e</li><li>Ótimos ganhos em testabilidade (como veremos a seguir)</li></ul><h4>Escrevendo testes unitários</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f1urhN1ySdkTUoS0B8Wj6w.jpeg" /><figcaption>Testes não podem falhar, se você não executar nenhum!</figcaption></figure><p>Eis o resultado:</p><pre>// 1.5 - Escrevendo um Stub<br>final class TemplateViewStub: UIView, TemplateViewProtocol {<br>    var didCalledShowWithViewType: TemplateViewData?<br>    var showCallCount: Int = 0<br><br>    var delegate: TemplateViewDelegate?<br><br>    func show(viewType: TemplateViewData) {<br>        didCalledShowWith = viewType<br>        showCallCount += 1<br>    }<br>}<br><br>// 2.5 - Escrevendo um Spy<br>final class URLNavigatorSpy: URLNavigatorProtocol {<br>    var didCallOpenWithUrl: URL?<br><br>    func open(with url: URL) {<br>        didCallOpenWithUrl = url<br>    }<br>}<br><br>final class TemplateViewControllerTests: XCTestCase {<br><br>    private var sut: TemplateViewController!<br>    private var viewModelStub: TemplateViewModelStub!<br>    private var viewStub: TemplateViewStub!<br>    private var viewDataMock: TemplateViewData!<br>    private var urlNavigatorSpy: URLNavigatorSpy!<br><br>    override func setUp() {<br>        urlNavigatorSpy = URLNavigatorSpy()<br><br>        sut = TemplateViewController(withURLNavigator: urlNavigatorSpy)<br><br>        viewDataMock = TemplateViewData()<br>        viewModelStub = TemplateViewModelStub(withData: viewDataMock)<br>        viewStub = TemplateViewStub()<br><br>        sut.templateViewModel = viewModelStub<br>        sut.templateView = viewStub<br>    }<br><br>    override func tearDown() {<br>        urlNavigatorSpy = nil<br>        viewDataMock = nil<br>        viewModelStub = nil<br>        viewStub = nil<br>        sut = nil<br>    }<br><br>    func test_loadView_shouldSetTemplateViewSuccessfully() {<br>        let expectedShowCallCount = 1<br>        let showShouldBeCalledWith = viewModelStub.getData()<br>        let expectedTemplateViewDelegateReference = sut<br><br>        // Accessing sut view in order force it to load (workaround)<br>        let _ = sut.view<br><br>        XCTAssertEqual(expectedShowCallCount, viewStub.showCallCount)<br>        XCTAssertEqual(showShouldBeCalledWith, viewStub.didCalledShowWithViewType)<br>        XCTAssertIdentical(expectedTemplateViewDelegateReference, viewStub.delegate)<br>    }<br><br>    func test_loadView_shouldNotSetTemplateViewSuccessfully() {<br>        sut.templateViewModel = nil<br><br>        XCTAssertFalse(sut.view is TemplateView)<br>    }<br><br>    // 1.6 - Testando a interação entre a TVC e a TV<br>    func test_setupNavigation_shoulSetTitleSuccessfully() {<br>        // Accessing sut view in order force it to load (workaround)<br>        let _ = sut.view<br><br>        XCTAssertEqual(viewDataMock.navigationTitle!, sut.title)<br>    }<br><br>    // 2.6 - Testando a interação entre o helper e a TVC<br>    func test_didTapOpenButton_shouldOpenURLSuccessfully() {<br>        let expectedDataCallCount = 1<br>        let expectedUrlToBeOpened = URL(string: viewDataMock.clickableText!.url)!<br><br>        sut.didTapOpenButton()<br><br>        XCTAssertEqual(viewModelStub.dataCallCount, expectedDataCallCount)<br>        XCTAssertEqual(urlNavigatorSpy.didCallOpenWithUrl, expectedUrlToBeOpened)<br>    }<br><br>    // 2.6 - Testando a interação entre o helper e a TVC<br>    func test_didTapOpenButton_shouldNotOpenURLForBadURL() {<br>        let expectedDataCallCount = 1<br>        let dataMockWithBadUrl = TemplateViewData(andClickableText: (string: &quot;Should not open&quot;, url: &quot;bad url&quot;))<br>        viewModelStub = TemplateViewModelStub(withData: dataMockWithBadUrl)<br>        sut.templateViewModel = viewModelStub<br><br>        sut.didTapOpenButton()<br><br>        XCTAssertEqual(viewModelStub.dataCallCount, expectedDataCallCount)<br>        XCTAssertNil(urlNavigatorSpy.didCallOpenWithUrl)<br>    }<br><br>}</pre><blockquote>&quot;Aqui é trabalho, meu filho!&quot; <a href="https://www.youtube.com/watch?v=x6yHgxLYGxw">RAMALHO, Muricy</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/327/1*J0okARTE87vqAIJbDc53Zg.jpeg" /></figure><p>É tempo de refletir (sempre é). Vamos elencar os pontos de melhoria na cobertura de testes da TemplateViewController (TVC):</p><ul><li>Seguimos os padrões de projeto, quanto a criaçãode <em>Stubs</em>;</li><li>Testamos a interação entre a TVC e TV;</li><li>Testamos a reusabilidade de uma classe urlNavigator, que conforma com uma necessidade bem específica (protocolo);</li><li>Testes de erro e sucesso para o método open;</li><li>O método open foi chamado? Quantas vezes?</li><li>Qual o parâmetro com o que o método open fora invocado?</li></ul><h3>Conclusões</h3><p>Se você acompanhou essa saga até aqui,<strong> </strong>é impossível não perceber um código mais testável, em suas minúcias e vários cenários. Ganho notável de controle, observabilidade sobre o sistema sob teste: uma <em>view controller</em> e suas dependências.</p><p>Note também que detalhes da implementação da TemplateView e TemplateViewModel de “produção” sequer são apresentados, de propósito. Eles não fazem diferença alguma para o nosso contexto, uma vez que as boas práticas enunciadas pelo SOLID são bem aplicadas (modéstia a parte, tá?) . Assim temos um código extremamente coeso e desacoplado.</p><p>A base de código agora se encontra em um estado ainda mais resiliente e flexível a mudanças. Alterações em detalhes de implementação não devem quebrar o funcionamento da TemplateViewController (TVC) ou seus testes, desde que as dependências conformem e não alterem os protocolos que a TVC depende. <strong>Isso é fantástico! :)</strong></p><p>Vou finalizar, enfim (rs), com os seguintes conselhos:</p><ul><li>Fortaleça as ideias e conceitos apresentados aqui. Elas se aplicam perfeitamente em qualquer linguagem ou framework (com suporte a orientação a objetos)!</li><li>Como exercício, tente identificar no código do seu trabalho, projetos autorais ou tutoriais, pontos onde eles podem ser aplicados.</li><li>Desenvolver a habilidade de trabalhar em um cenário caótico é muito importante, pois raramente estaremos alocados em projetos começando do zero.</li><li>Se for o seu caso agora, ou até mesmo no futuro, você muito provavelmente já criará um código muito testável. E, se houver tempo, também incluir alguma cobertura de testes.</li><li>Note que conversamos sobre diversas &quot;pontas de icebergs&quot;.<strong> </strong>Sempre busque &quot;águas&quot; e conceitos mais profundos sobre cada um desses temas tão plurais e interessantes.</li></ul><p><em>Até o próximo artigo, continue codando! :)</em></p><p>Autoria: <a href="https://www.linkedin.com/in/renatofsjr/">Renato Felicio</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e44a2d2d5d85" width="1" height="1" alt=""><hr><p><a href="https://medium.com/engineering-idwall/escrevendo-testes-unitarios-em-cenarios-caoticos-uma-abordagem-pratica-e44a2d2d5d85">Escrevendo testes unitários em cenários caóticos: Uma abordagem prática!</a> was originally published in <a href="https://medium.com/engineering-idwall">engineering.idwall</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>