[PT-BR] GitHub Actions para .Net Full Framework: Build e Teste
Published: 2021-06-07 14:35:35

English version / Versão em inglês: ["GitHub Actions for .Net Full Framework: Build and Test"](https://dev.to/felipetofoli/github-actions-for-net-full-framework-build-and-test-299h).
___

## É possível criar GitHub Actions de Build e Test para projetos .Net Full Framework?
:white_check_mark: Sim, é possível! E vou te mostrar como eu fiz.


## Mas antes, um pouco de contexto. :thought_balloon:

Recentemente tive que mexer em uma base de código legado de um projeto em .Net Full Framework.

O código estava versionado no GitHub e apresentava um fluxo de pull request e code review para integração de código na branch principal. Porém, não havia checks para verificação do código que estava sendo integrado, o que permitiria que códigos que não compilassem, ou que quebrassem os testes unitários, fossem incluídos na nossa branch principal sem nenhum alerta.

A ausência do feedback rápido sobre a saúde do código integrado gerava insegurança nos desenvolvedores durante a aprovação dos pull requests, pois problemas inseridos por meio da adição de novos códigos poderiam demorar muito mais tempo do que o desejado para serem identificados.

Com o intuito de melhorar nosso fluxo de trabalho, pensei em criar um workflow de CI com [GitHub Actions](https://docs.github.com/en/actions) para acelerar o fluxo de feedback durante as nossas integrações de código.

Ao verificar a [documentação](https://docs.github.com/en/actions/guides/building-and-testing-net) das GitHub Actions, percebi que não havia nenhum template para a criação de um fluxo voltado ao .Net Full Framework. E então fiz a mesma pergunta do início do texto:
> &nbsp;
> É possível criar GitHub Actions de Build e Test para projetos .Net Full Framework?
> &nbsp;

Ao longo de minha jornada de pesquisa, descobri alguns recursos, oficiais e da comunidade: 
- [setup-msbuild](https://github.com/marketplace/actions/setup-msbuild);
- [setup-nuget](https://github.com/marketplace/actions/setup-nuget-exe-for-use-with-actions);
- [Setup-VSTest](https://github.com/marketplace/actions/setup-vstest-console-exe).

A utilização destas actions me possibilitou criar o fluxo de CI para .Net Full Framework que é disparado a cada nova integração via push ou pull request na branch main, conforme arquivo `ci.yml` abaixo:

{% gist https://gist.github.com/felipetofoli/f94ec0edfe074220c5448d9cc9671b09 %}

&nbsp;

## Entendendo a action criada

Abaixo, explicação passo-a-passo do arquivo `ci.yml`:

1. Nome da GitHub Action.
    ```yml
     name: Build and Tests
    ```

2. Estabelecendo que as actions devem ser executadas quando houver pushes e criação de pull requests para a branch main (branch default deste projeto).
    ```yml
     on:  
       push:
         branches: [ main ]
       pull_request:
         branches: [ main ]
    ```

3. O build e teste serão executados em um sistema operacional Windows, afinal estamos lidando com .Net Full Framework (que não oferece suporte a outros sistemas operacionais).
    ```yml
     jobs:  
       build:    
         runs-on: windows-latest
    ```

4. É definida a seção que vai agrupar todos os passos executados, detalhados nos próximos items.
    ```yml
         steps:      
    ```

5. Faz o checkout do código.
    ```yml
           - uses: actions/checkout@v2
    ```

6. Faz o setup do MSBuild para uso posterior.
    ```yml
           - name: Setup MSBuild
             uses: microsoft/setup-msbuild@v1
    ```

7. Faz o setup do Nuget para uso posterior.
    ```yml
           - name: Setup NuGet
             uses: NuGet/setup-nuget@v1.0.5
    ```

8. Faz o setup do VSTest para uso posterior.
    ```yml
           - name: Setup VSTest
             uses: darenm/Setup-VSTest@v1
    ```

9. Navega para o workspace do GitHub para iniciar o restore, build e teste da aplicação.
    ```yml
           - name: Navigate to Workspace
             run: cd $GITHUB_WORKSPACE
    ```

10. Usa o nuget para fazer restore dos pacotes utilizados pela aplicação.
    ```yml
           - name: Restore Packages
             run: nuget restore Sandbox.sln
    ```

11. Compila o código do projeto com o msbuild, em modo release.
    ```yml
           - name: Build Solution
             run: |
               msbuild.exe Sandbox.sln /p:platform="Any CPU" /p:configuration="Release"
    ```

12. Executa os testes do projeto `Sandbox.Tests.dll`, utilizando o vstest.console.exe.
    ```yml
           - name: Run Tests
             run: vstest.console.exe .\tests\Sandbox.Tests\bin\Release\Sandbox.Tests.dll
    ```

## Resultados
Após a implantação do nosso CI, basta abrirmos um PR para ver o resultado da nossa implementação.

### PR aberto, actions pendentes de execução
Ao abrir um PR, agora podemos ver que alguns checks estão pendentes de execução.
![Imagem com actions pendentes de execução](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/i31470sqc7nq55njimb8.png)

### PR aberto, actions executadas
Após a execução dos nossos checks, o resultado já é mostrado na própria página do PR. Dá pra perceber que após verificar que os checks estão ok, o botão de `Merge pull request` ganhou até um destaque.
![Imagem com action executada e resultado ok](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dj9fc848hq5ld86y118l.png)

### Detalhes das actions executadas
Ao analisar a aba de checks, é possível verificar passo-a-passo a execução. Se houvesse qualquer falha, nessa página seria possível verificar qual passo quebrou e analisar os logs para identificar o erro.
![Imagem apresentando a tela de detalhe da execução da action](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7yh5ny7wi4gq99h9wo9s.PNG)

Se ficou curioso pra navegar em uma página com os detalhes das execuções das actions, [aqui você encontra uma execução com sucesso](https://github.com/felipetofoli/dotnet-full-framework-ci-sandbox/pull/6/checks), e [aqui encontra uma execução com falhas](https://github.com/felipetofoli/dotnet-full-framework-ci-sandbox/runs/2357988527?check_suite_focus=true).

## Projeto completo
Ficou curioso sobre o projeto? Este aqui é o repositório onde todo o código está disponível:
{% github felipetofoli/dotnet-full-framework-ci-sandbox %} 

Por favor, considere deixar uma :star: no repositório se ele te ajudar! :heart:

## Conclusão :dart:
Lidar com código legado pode ser muito complicado, então propor melhorias no fluxo de trabalho pode nos ajudar a mudar drasticamente a realidade do projeto, ao incentivar o feedback rápido e mitigar pontos de insegurança que prejudicam o time de desenvolvimento.

As GitHub Actions são ferramentas muito úteis para automação de processos de CI. Apesar de não conter um template inicial na documentação oficial, é possível criar workflows com GitHub Actions para .Net Full Framework, graças às actions oficiais e também às criadas e disponibilizadas pela comunidade.

Eu tive algum trabalho para conseguir viabilizar meu pipeline de CI, se você tiver qualquer problema na implementação do seu e quiser compartilhar nos comentários deste post, ficarei feliz em poder ajudá-lo.

Um abraço! :wink: :kissing_heart:

…

:warning: Vale lembrar que, antes de utilizar o workflow, é importante consultar se ele e as suas dependências estão de acordo com as políticas do projeto onde você deseja aplicá-los. :warning: