Introdução

Neste tutorial, iremos explorar o framework Magik e como ele pode ser utilizado para implementar práticas ágeis de desenvolvimento em projetos de software. O Magik é um framework projetado para facilitar a integração e a automação de fluxos de trabalho, permitindo que equipes desenvolvam software de maneira mais eficiente e colaborativa. Ao longo deste guia, abordaremos as etapas necessárias para configurar um projeto com Magik, integrá-lo com Spring Boot e aplicar metodologias ágeis. Vamos mergulhar nas práticas recomendadas e no ciclo de desenvolvimento ágil, proporcionando uma base sólida para otimizar suas operações de desenvolvimento de software.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Para começar, certifique-se de que você tem o Java Development Kit (JDK) 11 ou superior e o Maven instalados. Confirme as versões instaladas usando os comandos `java -version` e `mvn -version`. Além disso, instale o framework Magik no seu ambiente de desenvolvimento.

    commands
    # Verificar versões instaladas
    java -version
    mvn -version

  2. Criação do Projeto Spring Boot

    Utilize o Spring Initializr para gerar um novo projeto Spring Boot. Selecione as seguintes opções: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão estável, **Packaging**: Jar, **Java**: 11 ou superior. Adicione as dependências ‘Spring Web’, ‘Spring Data JPA’ e ‘Magik’. Faça o download do projeto e extraia-o em sua máquina.

    pom.xml
    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example.magikproject</groupId>
  <artifactId>magik-project</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>magik-project</name>
  <description>Projeto com Magik e Spring Boot</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>com.example</groupId>
      <artifactId>magik-spring-boot-starter</artifactId>
      <version>1.0.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

  3. Configuração do Banco de Dados

    Edite o arquivo `application.properties` para configurar as propriedades do banco de dados (H2, por exemplo) e habilitar o console web, caso deseje visualizar os dados gerados. O Magik facilitara essa configuração automática no contexto Spring.

    application.properties
    spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update

  4. Implementação de uma Classe de Serviço com Práticas Ágeis

    Crie a classe de serviço que utilizará o Magik para gerenciar tarefas e fluxos de trabalho. Essa classe implementará métodos para executar operações que aproveitam a automação proporcionada pelo Magik.

    TaskService.java
    package com.example.magikproject.service;

import org.magik.core.annotations.Automatic;
import org.springframework.stereotype.Service;

@Service
public class TaskService {

    @Automatic
    public void executeWorkflow() {
        // Implementar a lógica de execução do fluxo de trabalho automatizado
        System.out.println("Fluxo de trabalho executado com sucesso.");
    }
}

  5. Criação do Controlador para Gerenciar Tarefas

    Implemente um controlador que expose as APIs para interagir com o serviço de gerenciamento de tarefas. Este controlador receberá requisições HTTP e utilizará o serviço para processar os fluxos de trabalho.

    TaskController.java
    package com.example.magikproject.controller;

import com.example.magikproject.service.TaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/tarefas")
public class TaskController {

    @Autowired
    private TaskService taskService;

    @PostMapping
    public ResponseEntity<String> runTask() {
        taskService.executeWorkflow();
        return ResponseEntity.ok("Tarefa executada");
    }
}

  6. Testando o EndPoint com JUnit

    Crie uma classe de testes JUnit para validar o controlador e garantir que ele chama corretamente os serviços. Utilize o Mockito para simular comportamentos esperados.

    TaskControllerTest.java
    package com.example.magikproject.controller;

import com.example.magikproject.service.TaskService;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

import static org.mockito.Mockito.verify;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

public class TaskControllerTest {

    @InjectMocks
    private TaskController taskController;

    @Mock
    private TaskService taskService;

    private MockMvc mockMvc;

    public TaskControllerTest() {
        MockitoAnnotations.openMocks(this);
        this.mockMvc = MockMvcBuilders.standaloneSetup(taskController).build();
    }

    @Test
    public void testRunTask() throws Exception {
        mockMvc.perform(post("/api/tarefas")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk());

        verify(taskService).executeWorkflow();
    }
}

  7. Executando a Aplicação e Testes

    Use o Maven para compilar e executar a aplicação. Utilize ferramentas como Postman ou cURL para testar os endpoints da API. Confirme que o fluxo de trabalho organizado pelo Magik funcionou como esperado.

    commands
    # Compilar e executar a aplicação
    mvn spring-boot:run
    # Executar os testes unitários
    mvn test
    # Teste a API via cURL
    curl -X POST http://localhost:8080/api/tarefas

Conclusão

Neste tutorial, você aprendeu a implementar práticas ágeis de desenvolvimento utilizando o framework Magik em um projeto com Spring Boot. Desde a configuração do ambiente até a criação de APIs e testes unitários, você adquiriu uma compreensão sólida de como otimizar fluxos de trabalho e facilitar a automação em seus projetos. O Magik oferece ferramentas valiosas para melhorar a colaboração e a eficiência, tornando-se um poderoso aliado no desenvolvimento ágil de software.

Hashtags

#Java #SpringBoot #Magik #DesenvolvimentoÁgil #TestesUnitários #Automação