Code Analysis and Code Coverage using NetCore + VS Code & publishing to Sonarqube (sonarcloud.io)

En el post anterior (Runing Tests and Code Coverage without Visual Studio. OpenCover con coverlet y ReportGenerator), hablamos sobre la ejecución de Test Unitarios y de la cobertura de código e incluso de la generación de reports desde línea de comandos. En este Post y continuando con la línea de comandos (CLI) y con el foco/roadmap en DevOps (Jenkins, Azure DevOps, Travis, etc.), veremos como realizar un análisis estático de código y publicarlo en Sonarqube junto a la cobertura de código.

Para este caso usaremos https://SonarCloud.io como servidor gratuito y publico de SonarQube donde crearemos una organización, por ejemplo “juanluelguerre-github” y generaremos un token, que usaremos para la publicación

Partiremos del siguiente Script (Shell y Cmd) similar al del post anterior, al que hemos añadadio algunas sentencias adicionales. En concreto, y las que merecen especial atención para la publicación en Sonarqube, son las que hacen referencia a “dotnet sonarScanner”, es decir, las líneas: 15, 18 y 25.

En el parámetro “/d:sonar.exclusions”, podremos incluir todas aquellas exclusiones

Recuerda que en este post, puedes encontrar mas detalle sobre el resto de líneas de estos scrips

En post sucesivos, continuaremos trasladando todo esto a Jenkins, Azure DevOps, Travis, etc. ¡Espero una vez más que sea de ayuda!

Happy testing and good Coverage
Juanlu

New Monitor 2k for Windows & Mac with HiDPI.

Mi nuevo monitor BenQ BL2420PT de 2k

Llegó Navidad, y con ella, un nuevo monitor con el que extender mi zona ya obsoleta de trabajo como developer.

Tras conectar el monitor Full HD (1920×1080), lo primero que noté fué cambio bastante importante en la resolución y, principalmente, frente a las pantallas de los portatiles, tanto de mi Dell con Windows 10 como de mi Macbook Pro 15″, que claro cuenta con la pantalla retina de 2560×1600. Aunque parece ser que una mayoría de desarrolladores usan este tipo de pantallas, a mi, sinceramente no me convenció, por lo que inmediatamente lo cambié por uno nuevo Ultrawide 1080p, conocido como 2k ( de 2560×1440), que además, presenta la regulación de altura como otra mejora importante, entre otras. Cualquier otra monitor supuerior hubiera sido también una buena opción, si bien, el precio comenzaba a dispararse y no iba a sacarle partido, como desarrollador. ¡Eso sí, ahora que ya lo tengo, aprovecharé para alguna que otra edición de foto, vídeo e incluso diseño 🙂 !

Lo que verdaderamente me preocupaba, era el poder aprovechar esta resolución adecuando Windows a unos tamaños de ventanas, textos, menus, etc, idóneos y no excesivamente pequeños (2560×1440). Es aquí donde Windows 10 hace la magia. Basta con establecer el % de escalado y seleccionar la resolución. ¡Mantengo la resolución más optima y recomendada y Windows 10 hace un escalado para adecuar los tamaños. !

Ahora que en Windows estaba todo bien, ¿Que pasaría en Mac?. Pues bien, aquí no todo es mágia. O aprovechamos la máxima resolución del monitor viendolo todo más pequeño, o bajamos la resolución perdiendo calidad. ¡La sospecha inicial era una realiada en Mac! Sin embargo, y como no podía creermelo, finalmente encontré SwitchResX , que nos permite lo mismo que de manera nativa nos aporta Windows 10, pero, siguiendo previamente algunos pasos manuales:

  • Descargar e Instalar SwitchResX.
  • Iniciar el Mac en modo recovery, pulsando Cmd + R al reiniciar.
  • Abrir el terminal desde el menu Utilities y escribir “csrutil disable“.

  • Reiniciar nuevamente el Mac.
  • Abrir las preferencias del sistema y pulsar sobre el nuevo icono “SwitchResx”.
  • Acceder a la pestaña “Custom Resolutions” y añadir (pulsando “+”, hasta un máximo de dos nuevas resoluciones (en la versión gratuita). En concreto, estas resoluciones se corresponderán con el doble de las resoluciones buscadas. Ej: Para la resolución deseada de 1920×1080, crear una de 3840×2160.

Creando resolución tipo “Escalado” de 3849×2160

Nueva resoluciones

  • Una vez creadas la resoluciones desadas, seleccionar la pestaña “Current Resolutions”.
  • Finalmente, marcar la nueva resolución 1920×1080 (HiDPI), que se corresponde con la creada en el punto anterior.

Seleccionando nuevas resolución (HiDPI)

Esto es debido a que Mac solo permite un conjunto de resoluciones HiDPI para nuestro segundo monitor y entre ellas no se encuentra la que realmente queremos. ¡Es decir, la mágia de Windows 10!

Referencias:

Happy New Year 2019 coding with high resolution
Juanlu

Runing Tests and Code Coverage without Visual Studio. OpenCover con coverlet y ReportGenerator.

imageMuy buenas,

Llevo ya un tiempo con ganas de escribir sobre este tema y, principalmente por el impacto que causa en DevOps, en donde últimamente estoy un poco más inmerso de lo habitual.

En primer lugar, me gustaría hacer mención a este post del compañero @snavarropino, donde nos habla de la Cobertura de Código y Azure DevOps (anteriormente conocido como VSTS).

Y, en segundo lugar quiero hacer mención también a esta reseña de Wikipedia:

La cobertura de código es una medida (porcentual) en las pruebas de software que mide el grado en que el código fuente de un programa ha sido comprobado. Sirve para determinar la calidad del test que se lleve a cabo y para determinar las partes críticas del código que no han sido comprobadas y las partes que ya lo fueron.

Cuando desarrollamos con Visual Studio, y ejecutamos tests, en la mayoría de las ocasiones hacemos uso del tooling integrado en Visual Studio, si bien, tenemos que reconocer que para poder lanzar la cobertura de código entre otras acciones que brinda, necesitamos disponer de la edición Enterprise, lo que supone un coste adicional, que en muchas ocasiones es tal que da lugar a evaluar y analizar el mismo frente al beneficio que aporta.

A continuación veremos como ejecutar los Tests y la Cobertura de código desde Visual Studio, tal y como estamos acostumbrados y también, desde la línea de comandos, con .Net Core.

Desde Visual Studio (Enterprise Edition)

Lanzamos la cobertura de código bien desde la opción de menú “Test – Analyze Code Coverage” o bien, desde el Test Explorer, “Analyze Code Coverage for Selected Tests”:

image

El resultado es el siguiente:

image

Donde, por ejemplo, para la clase ProjectService.cs, podemos ver que parte del código está cubierto (en azul) por los tests y que partes no.

image

Teniendo en cuenta esto, podemos ir afinando nuestros tests para cubrir más y más código. Existen indicadores referentes a este dato que sirven de orientación para medir la calidad de nuestros desarrollos, si bien, no olvidemos que la cobertura determina la calidad del test, (no la del código). Eso si, podremos conocer el porcentaje de código que es cubierto y en consecuencia asegurar que tal %, al menos está “testeado”, lo que supone una garantía de calidad.

Conseguir un 100% de cobertura, evidentemente supone un esfuerzo y un coste, y es aquí donde debemos poner especial atención. Tenemos que valorar el porcentaje a cubrir en base a este coste y tiempo. Un valor de este porcentaje orientativo puede estar entre el 60% y el 70%, pero va a depender de cada caso en particular.  Dejo aquí una referencia de Wikipedia, a: El Triangulo de Hierro (o Iron Triangle), para profundizar en este tema, al que quizás, otro día le dedique un post.

Desde Línea de Comandos (Sin Visual Studio)

Antes de continuar, es importante recordar que los tests han de ser excluidos de la cobertura indicándolo mediante el atributo [ExcludeFromCodeCoverage] a nivel de clase en los tests.  De igual forma, podemos también excluirlos haciendo uso del fichero “.runsettings”. Visitar este enlace, para más detalle.

Adicionalmente, añadir el paquete Nuget: “coverlet.msbuild”.

image

A continuación, en el siguiente fragmento de código, (“coverage.cmd”) contamos con todas las instrucciones para ejecutar los tests y visualizar la cobertura de código de forma similar a como lo hace Visual Studio.

Las líneas [19-24, se corresponden con el comando “dotnet test” que ejecuta los tests unitarios. Habilitan la cobertura de código, especifican el formato en el que generar la cobertura (“Open Cover”) y la ruta en la que se generará el fichero “.xml” con el resultado de la cobertura.

Si ejecutamos este comando, obtendremos la siguiente salida en relación a la cobertura de código:

image

Donde, podemos ver la cobertura para cada módulo y diferenciada por:

  • Línea. Número de líneas de código que son cubiertas.
  • Branch. Número de caminos diferentes que toma el código (para instrucciones, if, switch, etc.), que son cubiertos.
  • Método. Número de métodos que son invocados desde los tests.

Adicionalmente, podríamos utilizar el parámetro /p:Exclude=\”[].Models.*\”, para excluir del análisis, cualquier clase cuyo namespace coincida con el filtro indicado. Mas detalle aquí: coverlet.msbuild.

La línea 27. Instala la herramienta Report Generator, que va a permitirnos generar un informe similar al utilizado por Visual Studio.

La línea 28.  Ejecuta la herramienta, tomando como entrada uno o más ficheros (en formato .xml) generado tras la ejecución de los tests, indicado por el parámetro “p:/CoverletOutput” y como salida, –targetdir, la ruta en la que se generan los ficheros de informes en el formato especificado por el parámetro –reporttypes (Html y HtmlSummary).

Finalmente, la línea 30, lanza el navegador y muestra el fichero “index.htm” tal y como podemos ver en la siguiente imagen, con el resumen y el detalle de la cobertura.

image

¡Ahora ya no hay argumentos para no “cubrir” bien el código!

En siguientes posts, veremos como aplica todo esto a la Integración Continua dentro del mundo de DevOps, tanto en Jenkins, como en Travis, como en Azure DevOps.

Happy testing and good Coverage
Juanlu

Logging/Traces in NetCore projects with Serilog

imageBuenas,

Como en cualquier desarrollo, un buen sistema de Logging o Trazas para diagnósticos y detección de problemas, es una buena práctica que va a salvarnos de un aprieto más de una vez. En La mayoría de los casos, creamos un ApplicationBlock, un Helper, o similar para trabajar con un sistema de estas características, cuyo objetivo es escribir trazas en un repositorio: Consola, fichero y/o base de datos entre otros, con la intención de poder consultarlo a posteriori, ante cualquier problema, que como sabemos, siempre recurrimos a el en entornos Productivos.

Con NetCore, podemos hacer lo mismo como no podía ser de otra manera, si bien, una peculiaridad y gran ventaja, es la posibilidad de usar el Interfaz ILogger (Microsoft.Extensions.Logging), tanto en nuestro controladores como en nuestros servicios o cualquier clase, mediante Injección de dependencias, lo que nos permitirá codificar sin pensar el framework o factoría encargada de escribir trazas en un repositorio: consola, fichero, base de datos, etc.

Existen muchos frameworks, que nos permiten llevar a cabo esta tarea de manera muy facil: Serilog, NLog y Log4Net, entre otros. ¡Atrás quedo Enterprise Libray  ! Cada uno tiene sus particularidades, si bien, Serilog, es considerado como uno de los mejores, además, cuenta con un elevado número de extensiones para el guardo de trazas en diferentes repositorios: consola, fichero, RollingFile, base de datos, Azure ApplicationInsight, Azure App Service, etc., lo que lo hacen aun más potente.

Por tanto, veamos como trabajar con Serilog:

Por ejemplo, podríamos tener el siguiente código en nuestro Controller:

Donde “_logger”, dejará dos trazas en nuestro/s repositorio/s.  Podríamos codificar de esta misma forma todas aquellas de nuestras clases: Servicios, Repositories, etc., sin preocupación adicional, por el momento.

A continuación, en el fichero Program.cs, incluiremos la siguiente configuración:

Como buena práctica, dejaremos en manos del fichero “appSettings.json”, la configuración de el/los repositorio/s.

Otra ventaja de Serilog, como puede verse en el código anterior, es la capacidad de ejecución en modo “asíncrono”. Es decir, la escritura de trazas en un hilo adicional para no afectar a la ejecución normal del programa.

ver-github

Y ahora, veamos todo esto en ejecución:

Referencias:

Un saludo & Happy Logging
Juanlu

 

SQL Server and SQL Cliente Application on Mac

imageContinuo aprendiendo y “cacharraenado” con el MAC para trabajar de la misma forma que lo hago con Windows. Así que, como SQL Server está en mi día a día, ¿Por que no en el MAC? Pues bien, veamos a continuación que necesitamos para poder disponer de un SQL Server en MAC y como consumirlo, también desde MAC, con una herramienta cliente, SQL Operation Studio.

Instalar y Configurar SQL Server

En primer lugar y gracias a que contamos con SQL Server On Linx configuraremos un servidor SQL como sigue:

docker pull microsoft/mssql-server-linux

  • A continuación iniciar el contenedor basado en la imagen anterior con el siguiente comando:

sudo docker run -e ‘ACCEPT_EULA=Y’ -e ‘SA_PASSWORD=P@ssw0rd1’ \
-p 1433:1433 –name sql1 \
-d microsoft/mssql-server-linux:2017-latest

Donde:

  • P@ssword1, ser corresponde con el password asignada al usuario administrador “sa”.
  • 1433, es el puerto donde estableceremos la comunicación con nuestro SQL Server. Este puerto es el utilizado de manera predeterminada.

Para más detalles sobre estos pasos, leer este Quickstart.

Instalar y ejecutar SQL Operation Studio

Como no disponemos de SQL Management Studio para Mac, vamos a hacer uso de una reciente herramienta Cliente “SQL Operation Studio”. Una herramienta muy sencilla y con una interfaz muy similar a Visual Studio Code, que también es Cross Platform y, que por tanto, también podemos instalar in Windows. ¡Creo que es buen momento para probarla!

  • Crear una nueva conexión, indicando el servidor “localhost” (en este caso), usuario (“sa”) y el password antes especificada, es decir: “P@ssw0rd1”.
  • Tras establecer la conexión, podremos comenzar a realizar consultas, incluso sus planes de ejecución para analizarlas.

image

  • Así mismo y al igual que Visual Studio Code, SQL Operation Studio, permite la instalación de extensiones, dando una mayor funcionalidad a la aplicación. En la imagen anterior, podemos ver SQL Server Profiler”. Extensión que nos permitirá conocer todas las consultas realizadas al servidor SQL desde cualquiera de las aplicaciones durante su ejecución.

Y, para conocer todo esto en funcionamiento (en MAC), como viene siendo habitual, podemos verlo en este vídeo:

https://youtu.be/N_iYM6RmhiI 

Un saludo y a seguir jugando con el MAC y Microsoft 😉
Juanlu

[Material] Evento Blazor (C# en el Browser)

image

Buenas,

Ayer 28 de Junio he vuelto a poder compartir conocimiento y muy buenos momentos con los compañeros de SVQDotNet, hablando de #Blazor en el evento: BLAZOR: Browser + Razor (C# en el Navegador) ¿Adios a JavaScript?

Dejo aquí el material empleado en la misma:

ver-github

En esta otra entrada puedes continuar profundizando.

Un saludo
Juanlu

Blazor 0.3.0/0.4.0-preview1-10286 ready!

image

El pasado 2 de mayo Blazor aparecía con su versión 0.3.0, y hoy, ya tenemos la versión 0.4.0-preview1-10286 lista para ser probada. Como ya sabemos, (según post anterior) al tratarse de un proyecto experimental requiere cambios constantes en nuestros proyectos (aun no recomendados para entornos de Producción).

Estos cambios, por tanto, nos obligan a realizar modificaciones en nuestra aplicación Taskin, que ya vimos en el post anterior (“¿Javascript ha muerto? .NET Web Assembly con Blazor”).

Según la release 0.3.0 e incluso para la 0.4.0-preview1, estas son las novedades:

    1. Project templates updated to use Bootstrap 4
    2. Async event handlers
    3. New component lifecycle events: OnAfterRender / OnAfterRenderAsync
    4. Component and element refs
    5. Better encapsulation of component parameters
    6. Simplified layouts

Y para hacer el Upgrade de 0.2.0 a 0.3.0:

  1. Instalar .NET Core 2.1 SDK (2.1.300-preview2-008533 o superior).
  2. instalar Visual Studio 2017 (15.7 Preview 5 or superior) con ASP.NET and web development workload selected.
  3. Instalar la última versión de la extensión “Blazor Language Services” del Marketplace de Visual Studio
  4. Actualizar el paquete Blazor y la Tool CLI a 0.3.0.
  5. Eliminar cualquier referencia al paquete: “Microsoft.AspNetCore.Razor.Design” asi como cualquier dependendencia.
  6. Actaulizar los proyectos a C# 7.3.
  7. Actualizar los parámetros usado en os componentes para que incluyan el atributo [Parameter].
  8. Actualizar los layouts para que hereden de “BlazorLayoutComponent” y eliminar la implementación de ILayoutComponent incluso la propiedad Body.

Tras la actualización, a continuación podemos una muestra de ello:

image

Y aquí, el código en Github: https://github.com/juanluelguerre/Taskin

Un saludo and happy Blazor coding
Juanlu

[Material] “.Net LOVE Open Source”

imageDurante el día de hoy ha tenido lugar l “I Jornada de conocimiento abierto“, en Huelva.

Ha sido un día interesante en lo que respecta al Software y Hardware libre así como en lo referente al Open Source, donde he tenido la oportunidad de participar, y, como no podía ser de otra manera con esta presentación “.Net LOVE Open Source“, en la que he tratado los siguientes puntos:

  • Free Software VS Open Source
  • Microsoft y el Open Source
  • .NET Open source
  • .NET Core
  • Azure, Dockery más…

A continuación dejo la presentación.

 

Un saludo & happy Open weekend

Juanlu

OpenAPI en mi API REST .NET Core con “Swashbuckle”

imageOpenAPI es un estándar para crear, administrar y consumir API REST. Conocido previamente como Swagger, en el último año ha sido adoptado por la Linux Foundation y obtuvo el apoyo de compañías como Google, Microsoft, IBM, Paypal, etc. para convertirse en un estándar para las API REST.

Cuando creamos un API Rest, tenemos varias opciones durante el desarrollo para comprobar que ésta funciona.  Quizás la más ocurrente es utilizar directamente el navegador e ir cambiando la url de cada uno de nuestros servicios u operaciones.  El principal problema con esto es que en un equipo de trabajo, no nos acordaremos de las urls, por lo que se comparten o anotan en alguna wiki o se contemplan otras opciones muy similares.

Dentro de estas otras opciones nos encontramos con: Fiddler, Avadced REST Client (extensión de Chrome), o Postman entre otras herramientas, que nos facilitan esta labor en alguna u otra medida. Por supuesto, y al margen de los Test Integrados, que veremos en algún otro post (con xUnit), Postman es realmente la que mas me gusta y, en mi opinión, la más útil de todas. Además de hacer estas pruebas de las que comentamos, nos permite: diseñar APIs, crear Mocks, test automáticos, documentarlas y mucho más.

image

De igual forma, Open API, como estándar es la opción que estamos buscando, tanto para el “testeo” del que hablamos, como para ayudarnos con la documentación, para la exploración de APIs, e incluso para la auto-generación de SDKs.

Tanto Postman como OpenAPI, son herramientas complementarias, si bien, al crear nuestras propias API, el hecho de utilizar OpenAPI nos va a proporcionar:

  • Definición y documentación
  • Cumplimiento del standard
  • Auto-generar SDKs para que terceros puedan comunicarse
  • Personalización
  • Visualización
  • Ejecución y pruebas
  • Gratis para su uso
  • Y además, muy fácil de implementar en .NET

Al hablar de diseño de API y refiriéndonos a OpenAPI, implícitamente estamos hablando de JSON o YAML, dos formatos de ficheros también estándares, que van a permitirnos definir y diseñar las mimas. La versión actual de la especificación es la 3.0.1 y orientada a YAML y la versión previa la 2.0, que es idéntica a la especificación 2.0 de Swagger antes de ser renombrada a “Open API Specification”.

En el momento de escribir el post, el tooling para trabajar con la versión 3.0, aún es limitado.

Diseñando un API

Veamos como diseñar un API :

image

  • Una vez concluido el diseño, estamos en el momento de auto-generar, para diferentes lenguajes, el servidor: haskell, rails5, rust-server, spring, asp.net core, etc., y el cliente: eiffel, java, html, groovy, go, jmeter, scala, javascript, typescript-jquery, angular, C#,  etc.

image

  • Con el código resultante tras la auto-generación, tendríamos prácticamente, desde el día 1 de desarrollo, un API desplegada a modo de Mock. Importante, principalmente para desarrolladores Front, que necesitan un API, que probablemente no será desarrollada hasta una fase posterior. ¡IMPORTANTE Evitemos bloqueos entre equipos y tareas. Diseñemos APIs!

Nota: En esta URL: https://app.swaggerhub.com/apis/juanluelguerre/Taskin/v1, he publicado la versión 1.0 (muy sencilla) de Taskin, sobre la que podremos probar.

Creando APIs con NET Core y OpenAPI

Otra de las opciones, también importante es que si comenzamos un desarrollo desde cero, en base a una arquitectura propia y dependiente de cada proyecto, necesitaremos que el código auto-generado, se adecúe a la misma.  Para ello, tendremos dos alternativas:

  1. Trabajar con el SDK de OpenAPI y modificar las plantillas de auto-generación.
  2. Integrar OpenApi directamente en nuestro código .NET.

De acuerdo al objetivo de este Post, optaremos por la alternativa 2, donde para ellos seguiremos los siguientes pasos:

  • Crear un proyecto “ASP.NET Core Web Application”
  • Seleccionar el tipo de aplicación: API. Por el momento, no marcaremos la opción de Docker.
  • Para .NET Core 2.1, por defecto usamos HTTS, por lo que incluimos una nueva variable de entorno ASPNETCORE_HTTPS_PORT con el valor del puerto HTTS (ej: 5003) o bien la instrucción services.AddHttpsRedirection(options => options.HttpsPort = 5003);
  • Añadir la referencia al paquete NuGet: Swashbuckle.AspNetCore
  • Añadir el siguiente código al final del método “ConfigureServices(IServiceCollection services)” del fichero Startup.cs
  • Añadir el siguiente código al final del método “Configure(IApplicationBuilder app, IHostingEnvironment env)” del fichero Startup.cs.

image

  • En este punto podremos probar nuestra aplicación, sin necesidad de recordar la url de cada operación. Comprobaremos que de un simple string “[“value1”, “value2”]”  como resultado, pasamos a visualizar, navegar, ejecutar y depurar fácilmente.

image

Nota: Si navegamos al json “/swagger/v1/swagger.json”, es decir, a la url: https://localhost:5003/swagger/v1/swagger.json, obtenemos el “.JSON” correspondiente a la especificación OpenAPI, y,  al utilizarlo en el editor Online de Swagger, como vimos al principio del post, verificaremos, que nuestra API REST es correcta y por tanto cumple con el estándar.

image

Otra alternativa para la generación de Servidor y/o Cliente es “NSwag Studio”, que ya comentamos brevemente en un post anterior, se trata de una aplicación de escritorio, con ciertas opciones de personalización. Así mismo, también podemos utilizarla al igual que “Swashbuckle”, para integrarla en nuestra API REST .NET Core.

Y, para finalizar, si estas pensando en migrar tu especificación OpenAPI 2.0 a la versión 3.0, puedes utilizar esta herramienta: https://openapi-converter.herokuapp.com/

Espero que haya sido de utilidad

Saludos & Happy Coding!
Juanlu