DEV Community: Rafael Dias

Iniciando com Entity Framework Core

Rafael Dias — Sun, 26 Jan 2020 18:50:33 +0000

Olá pessoal, este artigo está sendo feito para quem estiver com o intuito de iniciar no EF Core e não faz ideia por onde começar. Deste modo, não estarei trazendo a melhor estrutura e nem me preocupando com boas práticas por questões didáticas. Contudo, o artigo tem a intenção de explicar de forma clara e objetiva sobre o EF Core, assim iniciaremos o projeto.

O que seria o Entity Framework Core? onde habita? o que faz ?. O Entity Framework Core é um dos muitos ORMs (Object-Relational Mapping) que do português seria (Mapeador Objeto Relacional), ele consegue mapear as propriedades da suas entidades em tableas do banco de dados. Com isto, ele aumenta absurdamente a produtividade de seu projeto, o codigo fica bem mais legivel e padronizado trazendo muitos beneficios na manutenção.

Configuração

O ambiente de desenvolvimento está configurado com as seguintes ferramentas:

Com tudo instalado e configurado, está na hora de iniciar o projeto.

Iniciando o Projeto

Escolha uma pasta de sua preferência, eu estarei criando uma pasta chamada EFConsole

Abra o terminal e execute o seguinte comando:

mkdir EFConsole

Navegando até a pasta do projeto:

cd EFConsole

Para este tutorial, estaremos usando uma aplicação console simples.
Para isto, rode o comando:

dotnet new console

Abra o projeto com seu editor favorito, eu estarei usando o Visual Studio code.

code .

Iniciando a Base de Dados

Para o bando de dados estaremos utilizando o Microsoft SQLServer dentro de um container docker.
Na raiz do projeto, crie um arquivo chamado docker-compose.yml:

version: "3"
services:
    db:
        image: microsoft/mssql-server-linux:latest
        container_name: db
        restart: "always"
        ports:
          - "1433:1433"
        environment:
          - ACCEPT_EULA=Y
          - SA_PASSWORD=sa@12345

Vamos iniciar o banco usando o comando:

docker-compose up -d

Com o docker iniciado, abra o Azure Data Studio e conecte com o Server=localhost, User name=sa e senha sa@12345:

Codigo e Dependências

Para trabalhar com EF Core, devemos ter 4 dependências instaladas:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer

dotnet add package Microsoft.EntityFrameworkCore.Design

dotnet add package Microsoft.EntityFrameworkCore.Tools --version 3.1.1

dotnet tool install --global dotnet-ef

Codigo

Com as dependencias instaladas, vamos ao codigo, a primeira classe que iremos desenvolver é a Entidade Pessoa, onde terá os atributos (id, nome e idade):

Models/Pessoa.cs

namespace EFConsole 
{
    public class Pessoa
    {
        public int id { get; set; }
        public string nome { get; set; }
        public int idade { get; set; }
    }
}

Para a manipulação de dados, vamos criar um arquivo chamado MSSQLContext, onde através dessa classe iremos realizar o processo de Migration:

using Microsoft.EntityFrameworkCore;

namespace EFConsole {
    public class MSSQLContext : DbContext
    {
        public DbSet<Pessoa> Pessoa { get; set; }

        // Método de configuração
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) 
        {
            // String de conexão
            optionsBuilder
                .UseSqlServer(@"Server=localhost;Database=dbmodel;User Id=sa;Password=sa@12345;");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder) 
        {
            modelBuilder.Entity<Pessoa>(p => {
                // Tabela
                p.ToTable("pessoa");

                p
                    .Property(v => v.nome)
                    .HasColumnType("varchar(50)");

                // Chave Primaria
                p.HasKey(k => k.id);
            });
        }
    }
}

dotnet ef migrations add Pessoa

dotnet ef database update

Ao realizar a migration, será criado uma tabela chamada "Pessoa", com os campos (id, nome e idade), para consultar no Azure Data Studio, execute o seguinte comando SQL:

USE dbmodel
GO
    SELECT * FROM pessoa

Após isto, se as colunas forem listadas, vamos criar os metodos de CRUD.

Cadastrando uma Pessoa

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;

namespace EFConsole
{
    public class Program
    {
        // Instancia Context
        MSSQLContext db = new MSSQLContext();
        // Context da Entidade Pessoa
        DbSet<Pessoa> pessoaCtx;
        public Program()
        {
            pessoaCtx = db.Set<Pessoa>();
        }
        static void Main(string[] args)
        {
            var p = new Program();
            /// Cadastrar Pessoa
             p.CadastrarPessoa(new Pessoa {
                 nome = "Rafael",
                 idade = 22
             });
        }
        // Metodo de cadastro de Pessoa
        public Pessoa CadastrarPessoa (Pessoa p)
        {
            pessoaCtx.AddAsync(p);
            db.SaveChanges();
            return p;
        }

    }
}

Consultando uma lista de pessoas

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;

namespace EFConsole
{
    public class Program
    {
        // Instancia Context
        MSSQLContext db = new MSSQLContext();
        // Context da Entidade Pessoa
        DbSet<Pessoa> pessoaCtx;
        public Program()
        {
            pessoaCtx = db.Set<Pessoa>();
        }
        static void Main(string[] args)
        {
            var p = new Program();
            .
            .
            .
            /// Consultar Pessoas
             var pessoas = p.ConsultarPessoa(new Pessoa {
                 nome = "Rafael",
                 idade = 22
             });
             pessoas.ToList().ForEach((el) => {
                 Console.WriteLine($"Id: {el.id}, Nome: {el.nome}, Idade: {el.idade}");
             });
            .
            .
            .
        }
        // Metodo de consulta de Pessoas
        public IEnumerable<Pessoa> ConsultarPessoa (Pessoa p)
        {
            var res = pessoaCtx.ToList();
            return res;
        }

    }
}

Editar uma pessoa

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;

namespace EFConsole
{
    public class Program
    {
        // Instancia Context
        MSSQLContext db = new MSSQLContext();
        // Context da Entidade Pessoa
        DbSet<Pessoa> pessoaCtx;
        public Program()
        {
            pessoaCtx = db.Set<Pessoa>();
        }
        static void Main(string[] args)
        {
            var p = new Program();
            .
            .
            .
            /// Consultar Pessoas
            p.EditarPessoa(new Pessoa {
                id = 1,
                nome = "Rafael Dias",
                idade = 22
            });
            .
            .
            .
        }
        .
        .
        .
        // Metodo de edição de Pessoas
        public Pessoa EditarPessoa (Pessoa p)
        {
            pessoaCtx.Update(p);
            db.SaveChanges();
            return p;
        }
    }
}

Deletar uma pessoa

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;

namespace EFConsole
{
    public class Program
    {
        // Instancia Context
        MSSQLContext db = new MSSQLContext();
        // Context da Entidade Pessoa
        DbSet<Pessoa> pessoaCtx;
        public Program()
        {
            pessoaCtx = db.Set<Pessoa>();
        }
        static void Main(string[] args)
        {
            var p = new Program();
            .
            .
            .
            /// Deletar Pessoa
            p.DeletarPessoa(new Pessoa {
                id = 1
            });
            .
            .
            .
        }
        .
        .
        .
        // Metodo de deleção de Pessoas
        public Pessoa DeletarPessoa (Pessoa p)
        {
            pessoaCtx.RemoveRange(p);
            db.SaveChanges();
            return p;
        }
    }
}

A classe Program.cs fica assim:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;

namespace EFConsole
{
    public class Program
    {
        MSSQLContext db = new MSSQLContext();
        DbSet<Pessoa> pessoaCtx;
        public Program()
        {
            pessoaCtx = db.Set<Pessoa>();
        }
        static void Main(string[] args)
        {
            var p = new Program();
            /// Cadastrar Pessoa
            p.CadastrarPessoa(new Pessoa {
                nome = "Rafael",
                idade = 22
            });

            /// Consultar Pessoa
            var pessoas = p.ConsultarPessoa(new Pessoa {
                nome = "Rafael",
                idade = 22
            });
            pessoas.ToList().ForEach((el) => {
                Console.WriteLine($"Id: {el.id}, Nome: {el.nome}, Idade: {el.idade}");
            });

            /// Editar Pessoa
            p.EditarPessoa(new Pessoa {
                id = 1,
                nome = "Rafael Dias",
                idade = 22
            });

            /// Excluir Pessoa
            p.DeletarPessoa(new Pessoa {
                id = 1
            });
        }

        public Pessoa CadastrarPessoa (Pessoa p)
        {
            pessoaCtx.AddAsync(p);
            db.SaveChanges();
            return p;
        }

        public Pessoa DeletarPessoa (Pessoa p)
        {
            pessoaCtx.RemoveRange(p);
            db.SaveChanges();
            return p;
        }

        public IEnumerable<Pessoa> ConsultarPessoa (Pessoa p)
        {
            var res = pessoaCtx.ToList();
            return res;
        }

        public Pessoa EditarPessoa (Pessoa p)
        {
            pessoaCtx.Update(p);
            db.SaveChanges();
            return p;
        }
    }
}

Para realizar os testes, basta descomentar as chamadas dos metodos.

Download do Projeto GitHub

Nodejs Code Evaluation Using Jest e SonarQube + Docker

Rafael Dias — Sun, 29 Dec 2019 22:35:08 +0000

NodeJs + Express + Docker + Jest + Sonarqube

In this article, we talk about a basic example using Nodejs, Express, Docker, Jest and Sonarqube.
Using the wikipedia explanation "SonarQube is an open source platform developed by SonarSource for continuous code quality inspection, to perform automatic reviews with static code analysis to detect bugs, code odors and security vulnerabilities in over 20 languages. programming."
For this tutorial, we'll need:

With node and docker installed, let's start the project

Starting the project

Creating project folder and browsing

mkdir NodeSonarExample
cd ./NodeSonarExample

Starting the project

npm init -y

Installing dependencies

In this session, we will install the dependencies and development dependencies for the project.

Express which allows http requests, widely used in MVC and Restfull applications.
Jest is used to perform unit testing.

npm install --save express jest

sonarqube-scanner is necessary to scan JS code very simply, without needing to install any specific tool or (Java) runtime.
jest-sonar-reporter is a custom results processor for Jest. The processor converts Jest's output into Sonar's generic test data format.
supertest we can test http requests for express routes

npm install -D sonarqube-scanner jest-sonar-reporter supertest

Docker Image SonarQube

Let's start sonarqube by creating the docker-compose.sonar.yml file.

version:  '3'
services:
    sonarqube:
        container_name:  sonarqube
        image:  sonarqube:latest
        ports:
            -  "9000:9000"
            -  "9092:9092"

and execute the file with the command:

docker-compose -f docker-compose.sonar.yml up -d

With sonarqube running, navigate to sonarqube address and authenticate using the default account
login: admin
password: admin
Authenticated, you will notice that there is no project pipeline created as shown in the image below

Simple project example

In this session, I will show the project structure, and all the code involved

Project structure

Code

file: src/index.js

const express =  require('express');
const app =  express();
const port =  process.env.PORT  ||  8080

// Route to be tested
app.get('/', (req, res) => {
    return res.status(200).json({ nome:  'Rafael Dias' });
});

// Application running on the door
let server = app.listen(port, () => {
    console.log(`Application running on ${port}`);
});

module.exports  = server;

file: sonar-project.js

const sonarqubeScanner =  require('sonarqube-scanner');
sonarqubeScanner(
    {
        serverUrl:  'http://localhost:9000',
        options : {
            'sonar.sources':  'src',
            'sonar.tests':  'src',
            'sonar.inclusions'  :  '**', // Entry point of your code
            'sonar.test.inclusions':  'src/**/*.spec.js,src/**/*.spec.jsx,src/**/*.test.js,src/**/*.test.jsx',
            'sonar.javascript.lcov.reportPaths':  'coverage/lcov.info',
            'sonar.testExecutionReportPaths':  'coverage/test-reporter.xml'
        }
    }, () => {});

module.exports  = server;

Include these lines in your package.json file

file: package.json

{
    .
    .
    .
    "scripts": {
        "sonar":  "node sonar-project.js",
        "test":  "jest --coverage"
    },
    "jest": {
        "testEnvironment":  "node",
        "coveragePathIgnorePatterns": [
            "/node_modules/"
        ],
        "testResultsProcessor":  "jest-sonar-reporter"
    },
    "jestSonar": {
        "reportPath":  "coverage",
        "reportFile":  "test-reporter.xml",
        "indent":  4
    }
    .
    .
    .
}

With the project created, just run

node src/index.js

With the project running, open the browser and navigate to http://localhost:8080/
the expected return is

{ name: 'Rafael Dias' }

Now let's go to automated testing to perform sonarqube test coverage

Automated test

let's create a test file. So we will import the index.js file and supertest to get the get request for route '/'.
In the end it is necessary to close the open server connection for the test to be terminated

file: src/test/index.test.js

const request =  require('supertest')
const server =  require('../index')

describe('Get Endpoints', () => {
    it('Get', async (done) => {
        const res =  await  request(server)
        .get('/')
        .send({
            userId:  1,
            title:  'test is cool',
        });
        expect(res.statusCode).toEqual(200);
        expect(res.body).toHaveProperty('nome');
        done();
    })
})
afterAll(async  done  => {
    // close server conection
    server.close();
    done();
});

To perform the tests, it is necessary to execute the command

npm run test

The test results should be successful as in the image below:

After all tests are successfully executed, a folder named "coverage" will be generated.

Coverage folder files are being referenced in sonar-project.js
finally, the command must be executed

npm run sonar

This command is responsible for executing the pipeline and committing SonarQube
As a result, you have 100% of your code covered per test, by default you need at least 80%