diff --git a/pom.xml b/pom.xml index 3169308..9b1a475 100644 --- a/pom.xml +++ b/pom.xml @@ -1,153 +1,201 @@ - - 4.0.0 - - - org.springframework.boot - spring-boot-starter-parent - 1.5.18.RELEASE - - - - br.com.grupomult - grupomult-api - 0.0.1-SNAPSHOT - Implementação de referência - Esta aplicação é uma implementação de referência para auxiliar na avaliação técnica de candidatos. - - - UTF-8 - 1.8 - 1.8 - 1.8 - 1.5.13 - 1.7.0 - 2.3.1 - - - - - - org.springframework.boot - spring-boot-starter-data-jpa - - - org.springframework.boot - spring-boot-starter-jdbc - - - org.springframework.boot - spring-boot-starter-validation - - - org.springframework.boot - spring-boot-starter-web - - - - javax.servlet - javax.servlet-api - provided - - - - io.swagger - swagger-annotations - ${swagger.annotations.version} - - - - com.h2database - h2 - runtime - - - - org.projectlombok - lombok - - - - org.springframework.boot - spring-boot-starter-test - test - - - - org.powermock - powermock-core - ${powermock.version} - test - - - org.powermock - powermock-api-mockito - ${powermock.version} - test - - - org.powermock - powermock-module-junit4 - ${powermock.version} - test - - - - - - - - org.springframework.boot - spring-boot-maven-plugin - - - org.codehaus.mojo - build-helper-maven-plugin - - - add-source - generate-sources - - add-source - - - - ${project.build.directory}/generated/swagger/src/main/java - - - - - - - io.swagger - swagger-codegen-maven-plugin - ${swagger.codegen.maven.plugin.version} - - - api-generate-sources-animal - generate-sources - - generate - - - ${project.basedir}/src/main/resources/swagger/api-animal.yaml - spring - false - false - - java8 - true - true - - ${project.build.directory}/generated/swagger - br.com.grupomult.api.animal.models - br.com.grupomult.api.animal.controllers - false - - - - - - - + + 4.0.0 + + + org.springframework.boot + spring-boot-starter-parent + 1.5.18.RELEASE + + + + br.com.grupomult + grupomult-api + 0.0.1-SNAPSHOT + Implementação de referência + Esta aplicação é uma implementação de referência para auxiliar na avaliação técnica de candidatos. + + + UTF-8 + 1.8 + 1.8 + 1.8 + 1.5.13 + 1.7.0 + 2.3.1 + + + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + org.springframework.boot + spring-boot-starter-jdbc + + + org.springframework.boot + spring-boot-starter-validation + + + org.springframework.boot + spring-boot-starter-web + + + + javax.servlet + javax.servlet-api + provided + + + + io.swagger + swagger-annotations + ${swagger.annotations.version} + + + + com.h2database + h2 + runtime + + + + org.projectlombok + lombok + + + + org.springframework.boot + spring-boot-starter-test + test + + + + org.powermock + powermock-core + ${powermock.version} + test + + + org.powermock + powermock-api-mockito + ${powermock.version} + test + + + org.powermock + powermock-module-junit4 + ${powermock.version} + test + + + + + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + org.apache.maven.plugins + maven-antrun-plugin + [1.8,) + + run + + + + + + + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + org.codehaus.mojo + build-helper-maven-plugin + + + add-source + generate-sources + + add-source + + + + ${project.build.directory}/generated/swagger/src/main/java + + + + + + + io.swagger + swagger-codegen-maven-plugin + ${swagger.codegen.maven.plugin.version} + + + api-generate-sources-animal + generate-sources + + generate + + + ${project.basedir}/src/main/resources/swagger/api-animal.yaml + spring + false + false + + java8 + true + true + + ${project.build.directory}/generated/swagger + br.com.grupomult.api.animal.models + br.com.grupomult.api.animal.controllers + false + + + + api-generate-sources-carro + generate-sources + + generate + + + ${project.basedir}/src/main/resources/swagger/api-carro.yaml + spring + false + false + + java8 + true + true + + ${project.build.directory}/generated/swagger + br.com.grupomult.api.carro.models + br.com.grupomult.api.carro.controllers + false + + + + + + + \ No newline at end of file diff --git a/src/main/java/br/com/grupomult/api/carro/controllers/CarrosApiController.java b/src/main/java/br/com/grupomult/api/carro/controllers/CarrosApiController.java new file mode 100644 index 0000000..2be31b2 --- /dev/null +++ b/src/main/java/br/com/grupomult/api/carro/controllers/CarrosApiController.java @@ -0,0 +1,68 @@ +package br.com.grupomult.api.carro.controllers; + +import static br.com.grupomult.constants.ApiConstants.GET_LIST_CARROS_BY_ID_PATH_ID; + +import javax.validation.Valid; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RestController; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.ResponseGetCarros; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.flows.carro.DeleteCarrosById; +import br.com.grupomult.flows.carro.InsertCarrosValidate; +import br.com.grupomult.flows.carro.ListCarrosByIdValidate; +import br.com.grupomult.flows.carro.ListCarrosValidate; +import br.com.grupomult.flows.carro.UpdateCarrosValidate; +import io.swagger.annotations.ApiParam; + +@RestController +public class CarrosApiController implements CarrosApi { + + @Autowired + private InsertCarrosValidate insertCarrosValidate; + + @Autowired + private UpdateCarrosValidate updateCarrosValidate; + + @Autowired + private DeleteCarrosById deleteCarrosById; + + @Autowired + private ListCarrosValidate listCarrosFlow; + + @Autowired + private ListCarrosByIdValidate listCarrosByIdFlow; + + @Override + public ResponseEntity detail( @PathVariable(value = GET_LIST_CARROS_BY_ID_PATH_ID, required = true) Long id) { + return listCarrosByIdFlow.execute(id); + } + + @Override + public ResponseEntity list() { + return listCarrosFlow.execute(); + } + + @Override + public ResponseEntity adicionarCarro(@ApiParam(value = "Objeto carro a ser adicionado no estoque" ) @Valid @RequestBody Carro body) { + return insertCarrosValidate.execute(body); + } + + @Override + public ResponseEntity atualizarCarro(@ApiParam(value = "Objeto carro a ser atualizado no estoque" ) @Valid @RequestBody Carro body) { + return updateCarrosValidate.execute(body); + } + + @Override + public ResponseEntity deletarCarro( @PathVariable(value = GET_LIST_CARROS_BY_ID_PATH_ID, required = true) Long id) { + return deleteCarrosById.execute(id); + } + + + +} diff --git a/src/main/java/br/com/grupomult/configurations/LoadDatabase.java b/src/main/java/br/com/grupomult/configurations/LoadDatabase.java index dff3e21..c71c97d 100644 --- a/src/main/java/br/com/grupomult/configurations/LoadDatabase.java +++ b/src/main/java/br/com/grupomult/configurations/LoadDatabase.java @@ -2,34 +2,79 @@ import static br.com.grupomult.api.animal.models.Animal.SpeciesEnum.CANINE; import static br.com.grupomult.api.animal.models.Animal.SpeciesEnum.FELINE; -import static br.com.grupomult.utils.DateUtils.ISO8601_COMPLETE_DATE; +import static br.com.grupomult.api.carro.models.Carro.TipoCarroEnum.PASSEIO; +import static br.com.grupomult.api.carro.models.Carro.TipoCarroEnum.UTILITARIO; +import static br.com.grupomult.utils.DateUtils.ISO8601_COMPLETE_DATE_HOUR; import static br.com.grupomult.utils.DateUtils.stringToDate; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.CommandLineRunner; -import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import br.com.grupomult.api.animal.models.Animal.SpeciesEnum; import br.com.grupomult.entities.Animal; +import br.com.grupomult.entities.Carro; +import br.com.grupomult.entities.CarroPK; import br.com.grupomult.entities.Species; +import br.com.grupomult.entities.TipoCarro; import br.com.grupomult.repositories.AnimalRepository; +import br.com.grupomult.repositories.CarroRepository; +import br.com.grupomult.repositories.TipoCarroRepository; import lombok.extern.slf4j.Slf4j; @Configuration @Slf4j -public class LoadDatabase { - - @Bean - public CommandLineRunner initDatabase(AnimalRepository repository) { - return args -> { - log.info("Preloading " + repository.save(createAnimal("Janis", "2015-02-09", CANINE)).toString()); - log.info("Preloading " + repository.save(createAnimal("Rocky", "2014-10-15", FELINE)).toString()); - }; +public class LoadDatabase implements CommandLineRunner { + + private static final String PRELOADING = "Preloading "; + + @Autowired + private AnimalRepository animalRepository; + + @Autowired + private CarroRepository carroRepository; + + @Autowired + private TipoCarroRepository tipoCarroRepository; + + @Override + public void run(String... args) throws Exception { + initDatabaseAnimal(); + initDatabaseCarro(); + } + + public void initDatabaseAnimal() { + log.info( + PRELOADING + animalRepository.save(createAnimal("Janis", "2015-02-09 11:00:00", CANINE)).toString()); + log.info( + PRELOADING + animalRepository.save(createAnimal("Rocky", "2014-10-15 11:00:00", FELINE)).toString()); + } + + public void initDatabaseCarro() { + TipoCarro tipoCarroPasseio = tipoCarroRepository.save(TipoCarro.builder().code(PASSEIO).build()); + TipoCarro tipoCarroUtilitario = tipoCarroRepository.save(TipoCarro.builder().code(UTILITARIO).build()); + + Carro carroPasseio = createCarro("PLR1235", "Hiunday i30", "2017-01-01 11:00:00", "2017-02-01 11:00:00", tipoCarroPasseio); + carroPasseio = carroRepository.save(carroPasseio); + log.info(PRELOADING + carroPasseio.toString()); + + Carro carroUtilitario = createCarro("PLR1235", "Hiunday ix35", "2018-01-01 11:00:00", "2018-02-01 11:00:00", tipoCarroUtilitario); + carroUtilitario = carroRepository.save(carroUtilitario); + log.info(PRELOADING + carroUtilitario.toString()); } private static Animal createAnimal(String name, String dob, SpeciesEnum species) { - return Animal.builder().name(name).dob(stringToDate(dob, ISO8601_COMPLETE_DATE)) + return Animal.builder().name(name).dob(stringToDate(dob, ISO8601_COMPLETE_DATE_HOUR)) .species(Species.builder().code(species).build()).build(); } + private static Carro createCarro(String codigo, String descricao, String dataCriacao, String dataAtualizacao, + TipoCarro tipoCarro) { + return Carro.builder().codigo(codigo).descricao(descricao) + .dataCriacao(stringToDate(dataCriacao, ISO8601_COMPLETE_DATE_HOUR)) + .dataAtualizacao(stringToDate(dataAtualizacao, ISO8601_COMPLETE_DATE_HOUR)) + .tipoCarro(tipoCarro) + .carroPK(new CarroPK(tipoCarro)).build(); + } + } \ No newline at end of file diff --git a/src/main/java/br/com/grupomult/constants/ApiConstants.java b/src/main/java/br/com/grupomult/constants/ApiConstants.java index 4d86b88..b3899b9 100644 --- a/src/main/java/br/com/grupomult/constants/ApiConstants.java +++ b/src/main/java/br/com/grupomult/constants/ApiConstants.java @@ -3,6 +3,7 @@ public final class ApiConstants { public static final String GET_LIST_ANIMALS_BY_ID_PATH_ID = "id"; + public static final String GET_LIST_CARROS_BY_ID_PATH_ID = "id"; private ApiConstants() { diff --git a/src/main/java/br/com/grupomult/constants/MessageConstants.java b/src/main/java/br/com/grupomult/constants/MessageConstants.java index 9e49393..e8cb5c5 100644 --- a/src/main/java/br/com/grupomult/constants/MessageConstants.java +++ b/src/main/java/br/com/grupomult/constants/MessageConstants.java @@ -7,6 +7,11 @@ public final class MessageConstants { public static final String ERROR_GET_ANIMALS_BY_ID_INVALID_ID = "Identificador inválido"; public static final String ERROR_GET_ANIMALS_BY_ID_NOT_FOUND = "Animal não encontrado"; + public static final String ERROR_GET_CARROS_BY_ID_INVALID_ID = "Identificador inválido"; + public static final String ERROR_GET_CARROS_BY_ID_NOT_FOUND = "Carro não encontrado"; + public static final String ERROR_INSERT_CARRO_INVALID_OBJECT = "Carro com dado nulo ou inválido"; + public static final String ERROR_INSERT_CARRO_OBJECT_NOT_FOUND = "Carro inserido não encontrado"; + private MessageConstants() { } diff --git a/src/main/java/br/com/grupomult/converter/CarroConverter.java b/src/main/java/br/com/grupomult/converter/CarroConverter.java new file mode 100644 index 0000000..96e97c2 --- /dev/null +++ b/src/main/java/br/com/grupomult/converter/CarroConverter.java @@ -0,0 +1,54 @@ +package br.com.grupomult.converter; + +import static br.com.grupomult.utils.DateUtils.ISO8601_COMPLETE_DATE_HOUR; +import static br.com.grupomult.utils.DateUtils.dateToString; +import static br.com.grupomult.utils.DateUtils.stringToDate; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.entities.CarroPK; +import br.com.grupomult.entities.TipoCarro; + +public abstract class CarroConverter { + + protected static final Carro convertEntityToDomain(br.com.grupomult.entities.Carro entity) { + if (entity == null) { + return null; + } + + Carro domain = new Carro(); + domain.setId(entity.getId()); + domain.setCodigo(entity.getCodigo()); + domain.setDescricao(entity.getDescricao()); + domain.setDataCriacao(dateToString(entity.getDataCriacao(), ISO8601_COMPLETE_DATE_HOUR)); + domain.setDataAtualizacao(dateToString(entity.getDataAtualizacao(), ISO8601_COMPLETE_DATE_HOUR)); + domain.setTipoCarro(entity.getTipoCarro().getCode()); + + return domain; + } + + protected static final br.com.grupomult.entities.Carro convertDomainToEntity(Carro domain) { + if (domain == null || domain.getTipoCarro() == null) { + return null; + } + + br.com.grupomult.entities.Carro entity = new br.com.grupomult.entities.Carro(); + entity.setId(domain.getId()); + entity.setCodigo(domain.getCodigo()); + entity.setDescricao(domain.getDescricao()); + entity.setDataCriacao(stringToDate(domain.getDataCriacao(), ISO8601_COMPLETE_DATE_HOUR)); + entity.setDataAtualizacao(stringToDate(domain.getDataAtualizacao(), ISO8601_COMPLETE_DATE_HOUR)); + entity.setTipoCarro(criarTipoCarro(domain.getTipoCarro())); + entity.setCarroPK(new CarroPK(domain.getId(), criarTipoCarro(domain.getTipoCarro()))); + + return entity; + } + + private static TipoCarro criarTipoCarro(TipoCarroEnum tipoCarroEnum) { + if (tipoCarroEnum == null) { + return null; + } + return TipoCarro.builder().code(tipoCarroEnum).build(); + } + +} diff --git a/src/main/java/br/com/grupomult/entities/Animal.java b/src/main/java/br/com/grupomult/entities/Animal.java index 7dc837d..f3f3347 100644 --- a/src/main/java/br/com/grupomult/entities/Animal.java +++ b/src/main/java/br/com/grupomult/entities/Animal.java @@ -1,5 +1,6 @@ package br.com.grupomult.entities; +import java.io.Serializable; import java.util.Date; import javax.persistence.CascadeType; @@ -24,7 +25,9 @@ @NoArgsConstructor @AllArgsConstructor @Entity -public class Animal { +public class Animal implements Serializable { + + private static final long serialVersionUID = 4944015990569194437L; @Id @GeneratedValue diff --git a/src/main/java/br/com/grupomult/entities/Carro.java b/src/main/java/br/com/grupomult/entities/Carro.java new file mode 100644 index 0000000..3b0b1d9 --- /dev/null +++ b/src/main/java/br/com/grupomult/entities/Carro.java @@ -0,0 +1,63 @@ +package br.com.grupomult.entities; + +import java.io.Serializable; +import java.util.Date; + +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; +import javax.persistence.Transient; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import lombok.ToString; + +@Getter +@Setter +@Builder +@ToString +@NoArgsConstructor +@AllArgsConstructor +@Entity +public class Carro implements Serializable { + + private static final long serialVersionUID = -2756126323782207245L; + + @EmbeddedId + private CarroPK carroPK; + + @Transient + private Long id; + + @Transient + private TipoCarro tipoCarro; + + private String codigo; + + private String descricao; + + @Temporal(TemporalType.TIMESTAMP) + private Date dataCriacao; + + @Temporal(TemporalType.TIMESTAMP) + private Date dataAtualizacao; + + public Long getId(){ + if(this.getCarroPK() == null){ + return null; + } + return this.getCarroPK().getId(); + } + + public TipoCarro getTipoCarro(){ + if(this.getCarroPK() == null){ + return null; + } + return this.getCarroPK().getTipoCarro(); + } + +} diff --git a/src/main/java/br/com/grupomult/entities/CarroPK.java b/src/main/java/br/com/grupomult/entities/CarroPK.java new file mode 100644 index 0000000..b26422e --- /dev/null +++ b/src/main/java/br/com/grupomult/entities/CarroPK.java @@ -0,0 +1,46 @@ +package br.com.grupomult.entities; + +import java.io.Serializable; +import java.util.Date; + +import javax.persistence.Embeddable; +import javax.persistence.ManyToOne; + +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +@Getter +@Setter +@Builder +@ToString +@Embeddable +public class CarroPK implements Serializable { + + private static final long serialVersionUID = -6909015604206875054L; + + private Long id; + + @ManyToOne + private TipoCarro tipoCarro; + + public CarroPK(){ + this.id = generateId(); + } + + public CarroPK(TipoCarro tipoCarro) { + this.id = generateId() ; + this.tipoCarro = tipoCarro; + } + + public CarroPK(Long id, TipoCarro tipoCarro){ + this.id = id; + this.tipoCarro = tipoCarro; + } + + private Long generateId() { + return new Date().getTime(); + } + +} diff --git a/src/main/java/br/com/grupomult/entities/Species.java b/src/main/java/br/com/grupomult/entities/Species.java index 8793a11..c756ea5 100644 --- a/src/main/java/br/com/grupomult/entities/Species.java +++ b/src/main/java/br/com/grupomult/entities/Species.java @@ -1,5 +1,7 @@ package br.com.grupomult.entities; +import java.io.Serializable; + import javax.persistence.Entity; import javax.persistence.EnumType; import javax.persistence.Enumerated; @@ -21,7 +23,9 @@ @NoArgsConstructor @AllArgsConstructor @Entity -public class Species { +public class Species implements Serializable { + + private static final long serialVersionUID = 5217289358964051431L; @Id @GeneratedValue diff --git a/src/main/java/br/com/grupomult/entities/TipoCarro.java b/src/main/java/br/com/grupomult/entities/TipoCarro.java new file mode 100644 index 0000000..dff3272 --- /dev/null +++ b/src/main/java/br/com/grupomult/entities/TipoCarro.java @@ -0,0 +1,37 @@ +package br.com.grupomult.entities; + +import java.io.Serializable; + +import javax.persistence.Entity; +import javax.persistence.EnumType; +import javax.persistence.Enumerated; +import javax.persistence.GeneratedValue; +import javax.persistence.Id; + +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import lombok.ToString; + +@Getter +@Setter +@Builder +@ToString +@NoArgsConstructor +@AllArgsConstructor +@Entity +public class TipoCarro implements Serializable { + + private static final long serialVersionUID = -3644009450956415689L; + + @Id + @GeneratedValue + private Integer id; + + @Enumerated(EnumType.STRING) + private TipoCarroEnum code; + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/DeleteCarrosById.java b/src/main/java/br/com/grupomult/flows/carro/DeleteCarrosById.java new file mode 100644 index 0000000..cdcd778 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/DeleteCarrosById.java @@ -0,0 +1,23 @@ +package br.com.grupomult.flows.carro; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.repositories.CarroRepository; + +public class DeleteCarrosById { + + @Autowired + private CarroRepository repository; + + public ResponseEntity execute(Long id) { + try{ + repository.delete(repository.findById(id)); + return new ResponseEntity( HttpStatus.OK ); + }catch (Exception e) { + return new ResponseEntity( HttpStatus.NOT_FOUND ); + } + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/InsertCarrosConverter.java b/src/main/java/br/com/grupomult/flows/carro/InsertCarrosConverter.java new file mode 100644 index 0000000..7d5aa35 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/InsertCarrosConverter.java @@ -0,0 +1,16 @@ +package br.com.grupomult.flows.carro; + +import br.com.grupomult.converter.CarroConverter; +import br.com.grupomult.entities.Carro; + +public class InsertCarrosConverter extends CarroConverter { + + public br.com.grupomult.api.carro.models.Carro executeConvertEntityToDomain(Carro carro) { + return convertEntityToDomain(carro); + } + + public Carro executeConvertDomainToEntity(br.com.grupomult.api.carro.models.Carro domain) { + return convertDomainToEntity(domain); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/InsertCarrosLoadValidate.java b/src/main/java/br/com/grupomult/flows/carro/InsertCarrosLoadValidate.java new file mode 100644 index 0000000..3799ed9 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/InsertCarrosLoadValidate.java @@ -0,0 +1,26 @@ +package br.com.grupomult.flows.carro; + +import static br.com.grupomult.constants.MessageConstants.ERROR_INSERT_CARRO_OBJECT_NOT_FOUND; + +import java.util.Optional; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.entities.Carro; +import br.com.grupomult.exceptions.HttpNotFoundException; + +public class InsertCarrosLoadValidate { + + @Autowired + private ListCarrosByIdConverter converter; + + public ResponseEntity execute(Carro carroEntity) { + if (Optional.ofNullable(carroEntity).isPresent()) { + return converter.execute(carroEntity); + } else { + throw new HttpNotFoundException(ERROR_INSERT_CARRO_OBJECT_NOT_FOUND); + } + } +} diff --git a/src/main/java/br/com/grupomult/flows/carro/InsertCarrosReal.java b/src/main/java/br/com/grupomult/flows/carro/InsertCarrosReal.java new file mode 100644 index 0000000..4c8ebf8 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/InsertCarrosReal.java @@ -0,0 +1,39 @@ +package br.com.grupomult.flows.carro; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.entities.Carro; +import br.com.grupomult.entities.CarroPK; +import br.com.grupomult.entities.TipoCarro; +import br.com.grupomult.repositories.CarroRepository; +import br.com.grupomult.repositories.TipoCarroRepository; + +public class InsertCarrosReal { + + @Autowired + private CarroRepository carroRepository; + + @Autowired + private TipoCarroRepository tipoCarroRepository; + + @Autowired + private InsertCarrosConverter insertCarrosConverter; + + @Autowired + private InsertCarrosLoadValidate insertCarrosLoadValidate; + + + public ResponseEntity execute(br.com.grupomult.api.carro.models.Carro carro) { + Carro carroEntity = insertCarrosConverter.executeConvertDomainToEntity(carro); + TipoCarro tipoCarro = tipoCarroRepository.findByCode(carroEntity.getTipoCarro().getCode()); + carroEntity.setCarroPK(new CarroPK(tipoCarro)); + return insertCarrosLoadValidate.execute(salvarCarro(carroEntity)); + } + + + private Carro salvarCarro(Carro carroEntity) { + return carroRepository.save(carroEntity); + } +} diff --git a/src/main/java/br/com/grupomult/flows/carro/InsertCarrosValidate.java b/src/main/java/br/com/grupomult/flows/carro/InsertCarrosValidate.java new file mode 100644 index 0000000..1dca0f2 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/InsertCarrosValidate.java @@ -0,0 +1,32 @@ +package br.com.grupomult.flows.carro; + +import static br.com.grupomult.constants.MessageConstants.ERROR_INSERT_CARRO_INVALID_OBJECT; + +import java.util.Optional; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.exceptions.HttpBadRequestException; + +public class InsertCarrosValidate { + + @Autowired + private InsertCarrosReal insertCarrosReal; + + public ResponseEntity execute(Carro carro) { + if (!Optional.ofNullable(carro).isPresent() + || carro.getCodigo() == null + || carro.getDescricao() == null + || carro.getTipoCarro() == null + || carro.getDataCriacao() == null + || carro.getDataAtualizacao() == null + ) { + throw new HttpBadRequestException(ERROR_INSERT_CARRO_INVALID_OBJECT); + } + return insertCarrosReal.execute(carro); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdConverter.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdConverter.java new file mode 100644 index 0000000..7aa506e --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdConverter.java @@ -0,0 +1,19 @@ +package br.com.grupomult.flows.carro; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.converter.CarroConverter; +import br.com.grupomult.entities.Carro; + +public class ListCarrosByIdConverter extends CarroConverter { + + @Autowired + private ListCarrosByIdResponse response; + + public ResponseEntity execute(Carro carro) { + return response.execute(convertEntityToDomain(carro)); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdLoad.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdLoad.java new file mode 100644 index 0000000..367fa60 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdLoad.java @@ -0,0 +1,21 @@ +package br.com.grupomult.flows.carro; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.repositories.CarroRepository; + +public class ListCarrosByIdLoad { + + @Autowired + private CarroRepository repository; + + @Autowired + private ListCarrosByIdLoadValidate validate; + + public ResponseEntity execute(Long id) { + return validate.execute(repository.findById(id)); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadValidate.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadValidate.java new file mode 100644 index 0000000..114ce1f --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadValidate.java @@ -0,0 +1,27 @@ +package br.com.grupomult.flows.carro; + +import static br.com.grupomult.constants.MessageConstants.ERROR_GET_CARROS_BY_ID_NOT_FOUND; + +import java.util.Optional; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.entities.Carro; +import br.com.grupomult.exceptions.HttpNotFoundException; + +public class ListCarrosByIdLoadValidate { + + @Autowired + private ListCarrosByIdConverter converter; + + public ResponseEntity execute(Carro carro) { + if (Optional.ofNullable(carro).isPresent()) { + return converter.execute(carro); + } else { + throw new HttpNotFoundException(ERROR_GET_CARROS_BY_ID_NOT_FOUND); + } + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdResponse.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdResponse.java new file mode 100644 index 0000000..f7d4f27 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdResponse.java @@ -0,0 +1,14 @@ +package br.com.grupomult.flows.carro; + +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; + +public class ListCarrosByIdResponse { + + public ResponseEntity execute(Carro carro) { + return ResponseEntity.ok(new ResponseGetCarrosById().carro(carro)); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdValidate.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdValidate.java new file mode 100644 index 0000000..b989e16 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosByIdValidate.java @@ -0,0 +1,25 @@ +package br.com.grupomult.flows.carro; + +import static br.com.grupomult.constants.MessageConstants.ERROR_GET_CARROS_BY_ID_INVALID_ID; + +import java.util.Optional; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.exceptions.HttpBadRequestException; + +public class ListCarrosByIdValidate { + + @Autowired + private ListCarrosByIdLoad load; + + public ResponseEntity execute(Long id) { + if (!Optional.ofNullable(id).isPresent() || id < 0) { + throw new HttpBadRequestException(ERROR_GET_CARROS_BY_ID_INVALID_ID); + } + return load.execute(id); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosConverter.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosConverter.java new file mode 100644 index 0000000..1ef8bbd --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosConverter.java @@ -0,0 +1,35 @@ +package br.com.grupomult.flows.carro; + +import static br.com.grupomult.utils.OptionalUtils.ofNullableAndEmpty; + +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.ResponseGetCarros; +import br.com.grupomult.converter.CarroConverter; + +public class ListCarrosConverter extends CarroConverter { + + @Autowired + private ListCarrosResponse response; + + public ResponseEntity execute(List carros) { + + /* + * Se a consulta do banco retornar uma lista nula ou vazia apenas é criada uma + * lista vazia do tipo de resposta da API, caso contrário é gerada uma lista com + * objetos de resposta da API baseados nos objetos do banco. + */ + List carrosApi = ofNullableAndEmpty(carros).orElse(Collections.emptyList()).stream() + .map(ListCarrosConverter::convertEntityToDomain).collect(Collectors.toList()); + + return response.execute(carrosApi); + + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosLoad.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosLoad.java new file mode 100644 index 0000000..524905b --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosLoad.java @@ -0,0 +1,24 @@ +package br.com.grupomult.flows.carro; + +import java.util.List; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarros; +import br.com.grupomult.entities.Carro; +import br.com.grupomult.repositories.CarroRepository; + +public class ListCarrosLoad { + + @Autowired + private CarroRepository repository; + + @Autowired + private ListCarrosConverter converter; + + public ResponseEntity execute() { + return converter.execute((List) repository.findAll()); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosResponse.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosResponse.java new file mode 100644 index 0000000..70ec749 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosResponse.java @@ -0,0 +1,20 @@ +package br.com.grupomult.flows.carro; + +import java.util.List; + +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.ResponseGetCarros; + +public class ListCarrosResponse { + + public ResponseEntity execute(List carrosApi) { + if (carrosApi.isEmpty()) { + return ResponseEntity.noContent().build(); + } else { + return ResponseEntity.ok(new ResponseGetCarros().carros(carrosApi)); + } + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/ListCarrosValidate.java b/src/main/java/br/com/grupomult/flows/carro/ListCarrosValidate.java new file mode 100644 index 0000000..4087957 --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/ListCarrosValidate.java @@ -0,0 +1,18 @@ +package br.com.grupomult.flows.carro; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarros; + +public class ListCarrosValidate { + + @Autowired + private ListCarrosLoad load; + + public ResponseEntity execute() { + // Nothing to validate + return load.execute(); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/UpdateCarrosReal.java b/src/main/java/br/com/grupomult/flows/carro/UpdateCarrosReal.java new file mode 100644 index 0000000..c10261f --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/UpdateCarrosReal.java @@ -0,0 +1,39 @@ +package br.com.grupomult.flows.carro; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.entities.Carro; +import br.com.grupomult.entities.CarroPK; +import br.com.grupomult.entities.TipoCarro; +import br.com.grupomult.repositories.CarroRepository; +import br.com.grupomult.repositories.TipoCarroRepository; + +public class UpdateCarrosReal { + + @Autowired + private CarroRepository carroRepository; + + @Autowired + private TipoCarroRepository tipoCarroRepository; + + @Autowired + private InsertCarrosConverter insertCarrosConverter; + + @Autowired + private InsertCarrosLoadValidate insertCarrosLoadValidate; + + + public ResponseEntity execute(br.com.grupomult.api.carro.models.Carro carro) { + Carro carroEntity = insertCarrosConverter.executeConvertDomainToEntity(carro); + TipoCarro tipoCarro = tipoCarroRepository.findByCode(carroEntity.getTipoCarro().getCode()); + carroEntity.setCarroPK(new CarroPK(tipoCarro)); + return insertCarrosLoadValidate.execute(salvarCarro(carroEntity)); + } + + private Carro salvarCarro(Carro carroEntity) { + return carroRepository.save(carroEntity); + } + +} diff --git a/src/main/java/br/com/grupomult/flows/carro/UpdateCarrosValidate.java b/src/main/java/br/com/grupomult/flows/carro/UpdateCarrosValidate.java new file mode 100644 index 0000000..41e475a --- /dev/null +++ b/src/main/java/br/com/grupomult/flows/carro/UpdateCarrosValidate.java @@ -0,0 +1,33 @@ +package br.com.grupomult.flows.carro; + +import static br.com.grupomult.constants.MessageConstants.ERROR_INSERT_CARRO_INVALID_OBJECT; + +import java.util.Optional; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.exceptions.HttpBadRequestException; + +public class UpdateCarrosValidate { + + @Autowired + private UpdateCarrosReal updateCarrosReal; + + public ResponseEntity execute(Carro carro) { + if (!Optional.ofNullable(carro).isPresent() + || carro.getId() == null + || carro.getCodigo() == null + || carro.getDescricao() == null + || carro.getTipoCarro() == null + || carro.getDataCriacao() == null + || carro.getDataAtualizacao() == null + ) { + throw new HttpBadRequestException(ERROR_INSERT_CARRO_INVALID_OBJECT); + } + return updateCarrosReal.execute(carro); + } + +} diff --git a/src/main/java/br/com/grupomult/repositories/CarroRepository.java b/src/main/java/br/com/grupomult/repositories/CarroRepository.java new file mode 100644 index 0000000..1a6dbd9 --- /dev/null +++ b/src/main/java/br/com/grupomult/repositories/CarroRepository.java @@ -0,0 +1,17 @@ +package br.com.grupomult.repositories; + +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.CrudRepository; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import br.com.grupomult.entities.Carro; + +@Repository +public interface CarroRepository extends CrudRepository { + + @Query("SELECT carro FROM Carro carro WHERE carro.carroPK.id = :id") + Carro findById(@Param("id") Long id); + + +} diff --git a/src/main/java/br/com/grupomult/repositories/TipoCarroRepository.java b/src/main/java/br/com/grupomult/repositories/TipoCarroRepository.java new file mode 100644 index 0000000..c92f1af --- /dev/null +++ b/src/main/java/br/com/grupomult/repositories/TipoCarroRepository.java @@ -0,0 +1,17 @@ +package br.com.grupomult.repositories; + +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.CrudRepository; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.entities.TipoCarro; + +@Repository +public interface TipoCarroRepository extends CrudRepository { + + @Query("SELECT tc FROM TipoCarro tc WHERE tc.code = :code") + TipoCarro findByCode(@Param("code") TipoCarroEnum code); + +} diff --git a/src/main/java/br/com/grupomult/utils/DateUtils.java b/src/main/java/br/com/grupomult/utils/DateUtils.java index 143618e..a7b53ba 100644 --- a/src/main/java/br/com/grupomult/utils/DateUtils.java +++ b/src/main/java/br/com/grupomult/utils/DateUtils.java @@ -12,6 +12,8 @@ public final class DateUtils { */ public static final String ISO8601_COMPLETE_DATE = "yyyy-MM-dd"; + public static final String ISO8601_COMPLETE_DATE_HOUR = "yyyy-MM-dd hh:mm:ss"; + private DateUtils() { } @@ -23,6 +25,14 @@ public static Date stringToDate(String date, String pattern) { } } + public static Date stringToDate(String date) { + try { + return new SimpleDateFormat(ISO8601_COMPLETE_DATE).parse(date); + } catch (Exception e) { + return null; + } + } + public static String dateToString(Date date, String pattern) { return new SimpleDateFormat(pattern).format(date); } diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 21ce54a..8c0df2b 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -1 +1,14 @@ server.servlet-path=/api/v1 + +# H2 +spring.h2.console.enabled=true +spring.h2.console.path=/h2 + +spring.datasource.initialize=true +spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_ON_EXIT=FALSE; +spring.datasource.username=sa +spring.datasource.password= +spring.datasource.driver-class-name=org.h2.Driver + +spring.jpa.database-platform=org.hibernate.dialect.H2Dialect +spring.jpa.show-sql=true diff --git a/src/main/resources/flow-definition.xml b/src/main/resources/flow-definition.xml index 1f2d2ac..a5eefa3 100644 --- a/src/main/resources/flow-definition.xml +++ b/src/main/resources/flow-definition.xml @@ -1,20 +1,46 @@ - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/main/resources/swagger/api-carro.yaml b/src/main/resources/swagger/api-carro.yaml new file mode 100644 index 0000000..e201d4b --- /dev/null +++ b/src/main/resources/swagger/api-carro.yaml @@ -0,0 +1,179 @@ +swagger: '2.0' + +info: + version: '0.0.1-SNAPSHOT' + title: 'API - Carros' + description: 'API de recursos de manipulação para Carros' + +host: localhost:8080 +basePath: /api/v1 + +schemes: + - http + - https + +produces: + - "application/json" + +paths: + + /carros: + get: + summary: Lista todos os carros cadastrados + description: Lista todos os detalhes dos carros cadastrados. + operationId: list + produces: + - application/json + responses: + "200": + description: Representação dos dados de todos os carros cadastrados. + schema: + $ref: '#/definitions/ResponseGetCarros' + "204": + description: Nenhum carro encontrado + "500": + description: Erro interno + + post: + tags: + - carro + summary: Adicionar um novo carro + description: "Adicionar um novo carro no estoque" + operationId: adicionarCarro + consumes: + - application/json + produces: + - application/json + parameters: + - in: body + name: body + description: Objeto carro a ser adicionado no estoque + required: false + schema: + $ref: "#/definitions/Carro" + responses: + "200": + description: Carro adicionado + schema: + $ref: '#/definitions/ResponseGetCarrosById' + "405": + description: Dados inválidos + + put: + tags: + - carro + summary: Atualiza dados de um carro + description: "Atualiza dados de um carro no estoque" + operationId: atualizarCarro + consumes: + - application/json + produces: + - application/json + parameters: + - in: body + name: body + description: Objeto carro a ser atualizado no estoque + required: false + schema: + $ref: "#/definitions/Carro" + responses: + "200": + description: Carro atualizado + schema: + $ref: '#/definitions/ResponseGetCarrosById' + "400": + description: Id inválido enviado + "404": + description: Carro não encontrado + "405": + description: Dados inválidos + + + + /carros/{id}: + get: + summary: Lista um carro específico + description: Lista os detalhes de um carro específico de acordo com o ID. + operationId: detail + produces: + - application/json + parameters: + - name: id + in: path + type: integer + format: int64 + required: true + responses: + "200": + description: Detalhe do carro encontrado + schema: + $ref: '#/definitions/ResponseGetCarrosById' + "404": + description: Nenhum carro encontrado correspondente ao ID informado + "500": + description: Erro interno + + delete: + summary: Deleta um carro + description: "Deleta um carro do estoque" + operationId: deletarCarro + consumes: + - application/json + produces: + - application/json + parameters: + - name: idCarro + in: path + description: O ID do carro a ser deletado + required: true + type: integer + format: int64 + responses: + "404": + description: Nenhum carro encontrado correspondente ao ID informado + + +definitions: + + ResponseGetCarros: + type: object + properties: + carros: + type: array + items: + $ref: '#/definitions/Carro' + + ResponseGetCarrosById: + type: object + properties: + carro: + $ref: '#/definitions/Carro' + + Carro: + type: object + required: + - codigo + - descricao + - dataCriacao + - dataAtualizacao + - tipo + properties: + id: + type: integer + format: int64 + codigo: + type: string + descricao: + type: string + dataCriacao: + description: Data de criação + type: string + dataAtualizacao: + description: Data de atualização + type: string + tipoCarro: + type: string + enum: + - PASSEIO + - UTILITARIO + \ No newline at end of file diff --git a/src/test-integracao/java/br/com/grupomult/api/carro/controllers/CarrosApiControllerTest.java b/src/test-integracao/java/br/com/grupomult/api/carro/controllers/CarrosApiControllerTest.java new file mode 100644 index 0000000..a840e4d --- /dev/null +++ b/src/test-integracao/java/br/com/grupomult/api/carro/controllers/CarrosApiControllerTest.java @@ -0,0 +1,137 @@ +package br.com.grupomult.api.carro.controllers; + +import static br.com.grupomult.api.carro.models.Carro.TipoCarroEnum.PASSEIO; +import static br.com.grupomult.api.carro.models.Carro.TipoCarroEnum.UTILITARIO; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.autoconfigure.domain.EntityScan; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.EnableAspectJAutoProxy; +import org.springframework.context.annotation.PropertySource; +import org.springframework.data.jpa.repository.config.EnableJpaRepositories; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.annotation.DirtiesContext; +import org.springframework.test.annotation.DirtiesContext.ClassMode; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.api.carro.controllers.CarrosApiController; +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.entities.TipoCarro; +import br.com.grupomult.repositories.TipoCarroRepository; +import br.com.grupomult.api.carro.models.ResponseGetCarros; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.utils.CarroDomainEntityUtil; + + +@TestPropertySource(locations = "classpath:application.properties") +@Configuration +@EnableAutoConfiguration +@EntityScan("br.com.grupomult.entities") +@EnableJpaRepositories("br.com.grupomult.repositories") +@ComponentScan({"br.com.grupomult"}) +@EnableAspectJAutoProxy +@PropertySource("classpath:application.properties") +@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD) +@RunWith(SpringJUnit4ClassRunner.class) +@Ignore +public class CarrosApiControllerTest { + + @Autowired + private CarrosApiController carrosApiController; + + @Autowired + private TipoCarroRepository tipoCarroRepository; + + private Carro carroDadosValidosInserido; + + @Before + public void setUp() throws Exception { + tipoCarroRepository.save(TipoCarro.builder().code(PASSEIO).build()); + tipoCarroRepository.save(TipoCarro.builder().code(UTILITARIO).build()); + + Carro carroDadosValidos = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO); + ResponseEntity response = carrosApiController.adicionarCarro(carroDadosValidos); + assertNotNull(response); + carroDadosValidosInserido = response.getBody().getCarro(); + + Carro carroDadosValido2 = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.UTILITARIO); + response = carrosApiController.adicionarCarro(carroDadosValido2); + assertNotNull(response); + } + + @Test + public void testInsertSuccess() { + Carro carroDadosValidos = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO); + ResponseEntity response = carrosApiController.adicionarCarro(carroDadosValidos); + assertNotNull(response); + assertEquals(HttpStatus.OK, response.getStatusCode()); + + ResponseGetCarrosById body = response.getBody(); + assertNotNull(body); + + Carro carro = body.getCarro(); + assertNotNull(carro); + } + + @Test + public void testUpdateSuccess() { + Carro carroDadosValidos = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO); + ResponseEntity response = carrosApiController.adicionarCarro(carroDadosValidos); + assertNotNull(response); + assertEquals(HttpStatus.OK, response.getStatusCode()); + + ResponseGetCarrosById body = response.getBody(); + assertNotNull(body); + + Carro carroInserido = body.getCarro(); + assertNotNull(carroInserido); + + String descricaoAntes = carroInserido.getDescricao(); + carroInserido.setDescricao(descricaoAntes + "Teste"); + ResponseEntity responseUpdate = carrosApiController.atualizarCarro(carroInserido); + Carro carroAtualizado = responseUpdate.getBody().getCarro(); + + assertNotEquals(descricaoAntes, carroAtualizado.getDescricao()); + } + + + @Test + public void testConsultarSuccess() { + ResponseEntity responseAntes = carrosApiController.list(); + int qtdCarrrosAntes = responseAntes.getBody().getCarros().size(); + assertTrue(qtdCarrrosAntes > 0); + } + + @Test + public void testDeletarSuccess() { + ResponseEntity responseAntes = carrosApiController.list(); + int qtdCarrrosAntes = responseAntes.getBody().getCarros().size(); + + carrosApiController.deletarCarro(carroDadosValidosInserido.getId()); + + ResponseEntity responseDepois = carrosApiController.list(); + int qtdCarrrosDepois = responseDepois.getBody().getCarros().size(); + + assertTrue(qtdCarrrosAntes > qtdCarrrosDepois); + } + + @Test + public void testDetailSuccess() { + ResponseEntity responseAntes = carrosApiController.detail(carroDadosValidosInserido.getId()); + Long idCarroConsultado = responseAntes.getBody().getCarro().getId(); + assertEquals(idCarroConsultado, carroDadosValidosInserido.getId()); + } +} diff --git a/src/test/java/br/com/grupomult/configuration/TestConfiguration.java b/src/test/java/br/com/grupomult/configuration/TestConfiguration.java index 2fbe44a..803adec 100644 --- a/src/test/java/br/com/grupomult/configuration/TestConfiguration.java +++ b/src/test/java/br/com/grupomult/configuration/TestConfiguration.java @@ -1,16 +1,20 @@ -package br.com.grupomult.configuration; - -import org.springframework.boot.test.mock.mockito.MockBean; -import org.springframework.context.annotation.Configuration; -import org.springframework.context.annotation.ImportResource; - -import br.com.grupomult.repositories.AnimalRepository; - -@Configuration -@ImportResource("classpath:application-context-test.xml") -public class TestConfiguration { - - @MockBean - private AnimalRepository animalRepository; - +package br.com.grupomult.configuration; + +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.ImportResource; + +import br.com.grupomult.repositories.AnimalRepository; +import br.com.grupomult.repositories.CarroRepository; + +@Configuration +@ImportResource("classpath:application-context-test.xml") +public class TestConfiguration { + + @MockBean + private AnimalRepository animalRepository; + + @MockBean + private CarroRepository carroRepository; + } \ No newline at end of file diff --git a/src/test/java/br/com/grupomult/flowdefinitions/FlowDefinitionCarroTest.java b/src/test/java/br/com/grupomult/flowdefinitions/FlowDefinitionCarroTest.java new file mode 100644 index 0000000..a7034f3 --- /dev/null +++ b/src/test/java/br/com/grupomult/flowdefinitions/FlowDefinitionCarroTest.java @@ -0,0 +1,117 @@ +package br.com.grupomult.flowdefinitions; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.context.ApplicationContext; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.flows.carro.DeleteCarrosById; +import br.com.grupomult.flows.carro.InsertCarrosConverter; +import br.com.grupomult.flows.carro.InsertCarrosLoadValidate; +import br.com.grupomult.flows.carro.InsertCarrosReal; +import br.com.grupomult.flows.carro.InsertCarrosValidate; +import br.com.grupomult.flows.carro.ListCarrosByIdConverter; +import br.com.grupomult.flows.carro.ListCarrosByIdLoad; +import br.com.grupomult.flows.carro.ListCarrosByIdLoadValidate; +import br.com.grupomult.flows.carro.ListCarrosByIdResponse; +import br.com.grupomult.flows.carro.ListCarrosByIdValidate; +import br.com.grupomult.flows.carro.ListCarrosConverter; +import br.com.grupomult.flows.carro.ListCarrosLoad; +import br.com.grupomult.flows.carro.ListCarrosResponse; +import br.com.grupomult.flows.carro.ListCarrosValidate; +import br.com.grupomult.flows.carro.UpdateCarrosReal; +import br.com.grupomult.flows.carro.UpdateCarrosValidate; +import br.com.grupomult.repositories.TipoCarroRepository; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = TestConfiguration.class) +public class FlowDefinitionCarroTest { + + @Autowired + private ApplicationContext applicationContest; + + @MockBean + private TipoCarroRepository tipoCarroRepository; + + @Test + public void testFlowListCarrosExistsSuccess() { + assertNotNull(applicationContest.getBean("listCarrosValidate")); + assertNotNull(applicationContest.getBean("listCarrosLoad")); + assertNotNull(applicationContest.getBean("listCarrosConverter")); + assertNotNull(applicationContest.getBean("listCarrosResponse")); + } + + @Test + public void testFlowListCarrosInstanceofSuccess() { + assertTrue(applicationContest.getBean("listCarrosValidate") instanceof ListCarrosValidate); + assertTrue(applicationContest.getBean("listCarrosLoad") instanceof ListCarrosLoad); + assertTrue(applicationContest.getBean("listCarrosConverter") instanceof ListCarrosConverter); + assertTrue(applicationContest.getBean("listCarrosResponse") instanceof ListCarrosResponse); + } + + @Test + public void testFlowListCarrosByIdExistsSuccess() { + assertNotNull(applicationContest.getBean("listCarrosByIdValidate")); + assertNotNull(applicationContest.getBean("listCarrosByIdLoad")); + assertNotNull(applicationContest.getBean("listCarrosByIdLoadValidate")); + assertNotNull(applicationContest.getBean("listCarrosByIdConverter")); + assertNotNull(applicationContest.getBean("listCarrosByIdResponse")); + } + + @Test + public void testFlowListCarrosByIdInstanceofSuccess() { + assertTrue(applicationContest.getBean("listCarrosByIdValidate") instanceof ListCarrosByIdValidate); + assertTrue(applicationContest.getBean("listCarrosByIdLoad") instanceof ListCarrosByIdLoad); + assertTrue(applicationContest.getBean("listCarrosByIdLoadValidate") instanceof ListCarrosByIdLoadValidate); + assertTrue(applicationContest.getBean("listCarrosByIdConverter") instanceof ListCarrosByIdConverter); + assertTrue(applicationContest.getBean("listCarrosByIdResponse") instanceof ListCarrosByIdResponse); + } + + @Test + public void testFlowInsertCarrosSuccess() { + assertNotNull(applicationContest.getBean("insertCarrosValidate")); + assertNotNull(applicationContest.getBean("insertCarrosConverter")); + assertNotNull(applicationContest.getBean("insertCarrosReal")); + assertNotNull(applicationContest.getBean("insertCarrosLoadValidate")); + } + + @Test + public void testFlowInsertCarrosInstanceofSuccess() { + assertTrue(applicationContest.getBean("insertCarrosValidate") instanceof InsertCarrosValidate); + assertTrue(applicationContest.getBean("insertCarrosConverter") instanceof InsertCarrosConverter); + assertTrue(applicationContest.getBean("insertCarrosReal") instanceof InsertCarrosReal); + assertTrue(applicationContest.getBean("insertCarrosLoadValidate") instanceof InsertCarrosLoadValidate); + } + + @Test + public void testFlowUpdateCarrosSuccess() { + assertNotNull(applicationContest.getBean("updateCarrosValidate")); + assertNotNull(applicationContest.getBean("updateCarrosReal")); + } + + @Test + public void testFlowUpdateCarrosInstanceofSuccess() { + assertTrue(applicationContest.getBean("updateCarrosValidate") instanceof UpdateCarrosValidate); + assertTrue(applicationContest.getBean("updateCarrosReal") instanceof UpdateCarrosReal); + } + + + @Test + public void testFlowDeleteCarrosSuccess() { + assertNotNull(applicationContest.getBean("deleteCarrosById")); + } + + @Test + public void testFlowDeleteCarrosInstanceofSuccess() { + assertTrue(applicationContest.getBean("deleteCarrosById") instanceof DeleteCarrosById); + } + + +} diff --git a/src/test/java/br/com/grupomult/flowdefinitions/FlowDefinitionTest.java b/src/test/java/br/com/grupomult/flowdefinitions/FlowDefinitionTest.java index 718ac07..4fce128 100644 --- a/src/test/java/br/com/grupomult/flowdefinitions/FlowDefinitionTest.java +++ b/src/test/java/br/com/grupomult/flowdefinitions/FlowDefinitionTest.java @@ -6,6 +6,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.context.ApplicationContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @@ -20,6 +21,7 @@ import br.com.grupomult.flows.animal.ListAnimalsLoad; import br.com.grupomult.flows.animal.ListAnimalsResponse; import br.com.grupomult.flows.animal.ListAnimalsValidate; +import br.com.grupomult.repositories.TipoCarroRepository; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = TestConfiguration.class) @@ -27,6 +29,9 @@ public class FlowDefinitionTest { @Autowired private ApplicationContext applicationContest; + + @MockBean + private TipoCarroRepository tipoCarroRepository; @Test public void testFlowListAnimalsExistsSuccess() { diff --git a/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdConverterTest.java b/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdConverterTest.java index d3ad1c9..c6f00c0 100644 --- a/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdConverterTest.java +++ b/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdConverterTest.java @@ -15,18 +15,19 @@ import org.powermock.modules.junit4.PowerMockRunner; import org.powermock.modules.junit4.PowerMockRunnerDelegate; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import br.com.grupomult.api.animal.models.Animal.SpeciesEnum; -import br.com.grupomult.api.animal.models.ResponseGetAnimalsById; import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.api.animal.models.ResponseGetAnimalsById; import br.com.grupomult.converter.AnimalConverter; import br.com.grupomult.entities.Animal; import br.com.grupomult.entities.Species; -import br.com.grupomult.flows.animal.ListAnimalsByIdConverter; +import br.com.grupomult.repositories.TipoCarroRepository; import br.com.grupomult.utils.DateUtils; @RunWith(PowerMockRunner.class) @@ -46,6 +47,9 @@ public class ListAnimalsByIdConverterTest { @Autowired private ListAnimalsByIdConverter flow; + + @MockBean + private TipoCarroRepository tipoCarroRepository; @Before public void setUp() throws Exception { diff --git a/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdLoadTest.java b/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdLoadTest.java index 591bd77..cc5939f 100644 --- a/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdLoadTest.java +++ b/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdLoadTest.java @@ -21,6 +21,7 @@ import br.com.grupomult.configuration.TestConfiguration; import br.com.grupomult.entities.Animal; import br.com.grupomult.repositories.AnimalRepository; +import br.com.grupomult.repositories.TipoCarroRepository; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = TestConfiguration.class) @@ -32,6 +33,9 @@ public class ListAnimalsByIdLoadTest { @Autowired private AnimalRepository repository; + @MockBean + private TipoCarroRepository tipoCarroRepository; + @MockBean private ListAnimalsByIdLoadValidate validate; diff --git a/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdLoadValidateTest.java b/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdLoadValidateTest.java index 6fff07e..ee32dc5 100644 --- a/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdLoadValidateTest.java +++ b/src/test/java/br/com/grupomult/flows/animal/ListAnimalsByIdLoadValidateTest.java @@ -18,6 +18,7 @@ import br.com.grupomult.configuration.TestConfiguration; import br.com.grupomult.entities.Animal; import br.com.grupomult.exceptions.HttpNotFoundException; +import br.com.grupomult.repositories.TipoCarroRepository; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = TestConfiguration.class) @@ -28,6 +29,9 @@ public class ListAnimalsByIdLoadValidateTest { @MockBean private ListAnimalsByIdConverter converter; + + @MockBean + private TipoCarroRepository tipoCarroRepository; @MockBean private Animal entity; diff --git a/src/test/java/br/com/grupomult/flows/carro/DeleteCarrosByIdTest.java b/src/test/java/br/com/grupomult/flows/carro/DeleteCarrosByIdTest.java new file mode 100644 index 0000000..5119efc --- /dev/null +++ b/src/test/java/br/com/grupomult/flows/carro/DeleteCarrosByIdTest.java @@ -0,0 +1,35 @@ +package br.com.grupomult.flows.carro; + +import java.util.Random; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.repositories.TipoCarroRepository; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = TestConfiguration.class) +public class DeleteCarrosByIdTest { + + @Autowired + private DeleteCarrosById deleteCarrosById; + + @MockBean + private TipoCarroRepository tipoCarroRepository; + + @Before + public void setUp() throws Exception { + } + + @Test + public void testDeleteSuccess() { + deleteCarrosById.execute(new Random().nextLong()); + } + +} diff --git a/src/test/java/br/com/grupomult/flows/carro/InserirCarrosConverterTest.java b/src/test/java/br/com/grupomult/flows/carro/InserirCarrosConverterTest.java new file mode 100644 index 0000000..447fb58 --- /dev/null +++ b/src/test/java/br/com/grupomult/flows/carro/InserirCarrosConverterTest.java @@ -0,0 +1,85 @@ +package br.com.grupomult.flows.carro; + +import static br.com.grupomult.utils.DateUtils.ISO8601_COMPLETE_DATE_HOUR; +import static br.com.grupomult.utils.DateUtils.dateToString; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.mockito.Mockito.when; + +import java.util.Date; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.repositories.TipoCarroRepository; +import br.com.grupomult.utils.CarroDomainEntityUtil; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = TestConfiguration.class) +public class InserirCarrosConverterTest { + + @Autowired + private InsertCarrosConverter insertCarrosConverter; + + @MockBean + private TipoCarroRepository tipoCarroRepository; + + @Before + public void setUp() throws Exception { + when(tipoCarroRepository.findByCode(TipoCarroEnum.PASSEIO)).thenReturn(CarroDomainEntityUtil.criarTipoCarro(TipoCarroEnum.PASSEIO)); + } + + @Test + public void testExecuteConvertDomainToEntity() { + Date data = new Date(); + Carro carroDomain = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO, data, data); + br.com.grupomult.entities.Carro carroDadosValidos = CarroDomainEntityUtil.criarEntityCarro(TipoCarroEnum.PASSEIO, data, data); + br.com.grupomult.entities.Carro carroConverter = insertCarrosConverter.executeConvertDomainToEntity(carroDomain); + assertNotNull(carroConverter); + assertEquals(carroDadosValidos.getCodigo(), carroConverter.getCodigo()); + assertEquals(carroDadosValidos.getDescricao(), carroConverter.getDescricao()); + assertEquals(carroDadosValidos.getTipoCarro().getCode(), carroConverter.getTipoCarro().getCode()); + assertEquals(dateToString(carroDadosValidos.getDataAtualizacao(), ISO8601_COMPLETE_DATE_HOUR) + , dateToString(carroConverter.getDataAtualizacao(), ISO8601_COMPLETE_DATE_HOUR)); + assertEquals(dateToString(carroDadosValidos.getDataAtualizacao(), ISO8601_COMPLETE_DATE_HOUR) + , dateToString(carroConverter.getDataAtualizacao(), ISO8601_COMPLETE_DATE_HOUR)); + } + + + @Test + public void testExecuteConvertEntityToDomain() { + Date data = new Date(); + br.com.grupomult.entities.Carro carroEntity = CarroDomainEntityUtil.criarEntityCarro(TipoCarroEnum.PASSEIO, data, data); + Carro carroDadosValidos = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO, data, data); + Carro carroConverter = insertCarrosConverter.executeConvertEntityToDomain(carroEntity); + assertNotNull(carroConverter); + assertEquals(carroDadosValidos.getCodigo(), carroConverter.getCodigo()); + assertEquals(carroDadosValidos.getDescricao(), carroConverter.getDescricao()); + assertEquals(carroDadosValidos.getTipoCarro(), carroConverter.getTipoCarro()); + assertEquals(carroDadosValidos.getDataAtualizacao(), carroConverter.getDataAtualizacao()); + assertEquals(carroDadosValidos.getDataAtualizacao(), carroConverter.getDataAtualizacao()); + } + + @Test() + public void testConvertDomainToEntityNull() { + br.com.grupomult.entities.Carro carroConverter = insertCarrosConverter.executeConvertDomainToEntity(null); + assertNull(carroConverter); + } + + @Test() + public void testConvertEntityToDomainNull() { + Carro carroConverter = insertCarrosConverter.executeConvertEntityToDomain(null); + assertNull(carroConverter); + } + + +} diff --git a/src/test/java/br/com/grupomult/flows/carro/InserirCarrosRealTest.java b/src/test/java/br/com/grupomult/flows/carro/InserirCarrosRealTest.java new file mode 100644 index 0000000..6fe4e24 --- /dev/null +++ b/src/test/java/br/com/grupomult/flows/carro/InserirCarrosRealTest.java @@ -0,0 +1,80 @@ +package br.com.grupomult.flows.carro; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.when; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.repositories.CarroRepository; +import br.com.grupomult.repositories.TipoCarroRepository; +import br.com.grupomult.utils.CarroDomainEntityUtil; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = TestConfiguration.class) +public class InserirCarrosRealTest { + + @Autowired + private InsertCarrosReal insertCarrosReal; + + @Autowired + private CarroRepository carroRepository; + + @MockBean + private TipoCarroRepository tipoCarroRepository; + + @MockBean + private Carro domain; + + @Before + public void setUp() throws Exception { + domain = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO); + when(carroRepository.save(any(br.com.grupomult.entities.Carro.class))).thenReturn(CarroDomainEntityUtil.criarEntityCarro(TipoCarroEnum.PASSEIO)); + when(tipoCarroRepository.findByCode(TipoCarroEnum.PASSEIO)).thenReturn(CarroDomainEntityUtil.criarTipoCarro(TipoCarroEnum.PASSEIO)); + when(insertCarrosReal.execute(domain)).thenReturn( createResponseEntityResponseGetCarrosById() ); + } + + @Test + public void testValidateWithCarroFillSuccess() { + Carro carroDadosValidos = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO); + ResponseEntity response = insertCarrosReal.execute(carroDadosValidos); + assertNotNull(response); + assertEquals(HttpStatus.OK, response.getStatusCode()); + + ResponseGetCarrosById body = response.getBody(); + assertNotNull(body); + + Carro carro = body.getCarro(); + assertNotNull(carro); + } + + @Test(expected = NullPointerException.class) + public void testValidateWithCarroNullHttpBadRequestException() { + insertCarrosReal.execute(null); + } + + @Test(expected = NullPointerException.class) + public void testValidateWithCarroFaltandoDadosHttpBadRequestException() { + insertCarrosReal.execute(new Carro()); + } + + private ResponseEntity createResponseEntityResponseGetCarrosById() { + ResponseGetCarrosById response = new ResponseGetCarrosById(); + response.setCarro(domain); + return ResponseEntity.ok(response); + } + +} diff --git a/src/test/java/br/com/grupomult/flows/carro/InserirCarrosValidateTest.java b/src/test/java/br/com/grupomult/flows/carro/InserirCarrosValidateTest.java new file mode 100644 index 0000000..b997756 --- /dev/null +++ b/src/test/java/br/com/grupomult/flows/carro/InserirCarrosValidateTest.java @@ -0,0 +1,71 @@ +package br.com.grupomult.flows.carro; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Mockito.when; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.exceptions.HttpBadRequestException; +import br.com.grupomult.repositories.TipoCarroRepository; +import br.com.grupomult.utils.CarroDomainEntityUtil; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = TestConfiguration.class) +public class InserirCarrosValidateTest { + + @Autowired + private InsertCarrosValidate insertCarrosValidate; + + @MockBean + private InsertCarrosReal insertCarrosReal; + + @MockBean + private Carro domain; + + @MockBean + private TipoCarroRepository tipoCarroRepository; + + @Before + public void setUp() throws Exception { + domain = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO); + when(insertCarrosReal.execute(domain)).thenReturn( CarroDomainEntityUtil.createResponseEntityResponseGetCarrosById(domain) ); + } + + @Test + public void testValidateWithCarroFillSuccess() { + Carro carroDadosValidos = CarroDomainEntityUtil.criarDomainCarro(TipoCarroEnum.PASSEIO); + ResponseEntity response = insertCarrosValidate.execute(carroDadosValidos); + assertNotNull(response); + assertEquals(HttpStatus.OK, response.getStatusCode()); + + ResponseGetCarrosById body = response.getBody(); + assertNotNull(body); + + Carro carro = body.getCarro(); + assertNotNull(carro); + } + + @Test(expected = HttpBadRequestException.class) + public void testValidateWithCarroNullHttpBadRequestException() { + insertCarrosValidate.execute(null); + } + + @Test(expected = HttpBadRequestException.class) + public void testValidateWithCarroFaltandoDadosHttpBadRequestException() { + insertCarrosValidate.execute(new Carro()); + } + +} diff --git a/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdConverterTest.java b/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdConverterTest.java new file mode 100644 index 0000000..1f94f71 --- /dev/null +++ b/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdConverterTest.java @@ -0,0 +1,72 @@ +package br.com.grupomult.flows.carro; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Mockito.when; +import static org.powermock.api.mockito.PowerMockito.mockStatic; + +import java.time.LocalDate; +import java.time.Month; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.powermock.modules.junit4.PowerMockRunnerDelegate; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.converter.CarroConverter; +import br.com.grupomult.repositories.TipoCarroRepository; +import br.com.grupomult.utils.CarroDomainEntityUtil; + +@RunWith(PowerMockRunner.class) +@PowerMockRunnerDelegate(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = TestConfiguration.class) +@PrepareForTest({ CarroConverter.class, LocalDate.class }) +public class ListCarrosByIdConverterTest { + + private static final LocalDate MOCK_LOCAL_DATE_NOW = LocalDate.of(2016, Month.FEBRUARY, 9); + + private static final String CODIGO = "DRF1220"; + private static final String DATA_CRIACAO = "2015-02-09 12:00:00"; + private static final String DATA_ATUALIZACAO = "2018-02-09 13:00:00"; + private static final TipoCarroEnum TIPO_CARRO = TipoCarroEnum.PASSEIO; + + @Autowired + private ListCarrosByIdConverter flow; + + @MockBean + private TipoCarroRepository tipoCarroRepository; + + @Before + public void setUp() throws Exception { + mockStatic(LocalDate.class); + when(LocalDate.now()).thenReturn(MOCK_LOCAL_DATE_NOW); + } + + @Test + public void testConvertSuccess() { + ResponseEntity response = flow.execute(CarroDomainEntityUtil.createEntityCarro(CODIGO,DATA_CRIACAO, DATA_ATUALIZACAO, TIPO_CARRO)); + assertNotNull(response); + assertEquals(HttpStatus.OK, response.getStatusCode()); + + ResponseGetCarrosById body = response.getBody(); + assertNotNull(body); + + br.com.grupomult.api.carro.models.Carro carro = body.getCarro(); + assertNotNull(carro); + assertEquals(CODIGO, carro.getCodigo()); + assertEquals(DATA_CRIACAO, carro.getDataCriacao()); + assertEquals(TIPO_CARRO, carro.getTipoCarro()); + } + +} diff --git a/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadTest.java b/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadTest.java new file mode 100644 index 0000000..44d7f27 --- /dev/null +++ b/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadTest.java @@ -0,0 +1,69 @@ +package br.com.grupomult.flows.carro; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Mockito.when; + +import java.util.Random; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.entities.Carro; +import br.com.grupomult.repositories.CarroRepository; +import br.com.grupomult.repositories.TipoCarroRepository; +import br.com.grupomult.utils.CarroDomainEntityUtil; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = TestConfiguration.class) +public class ListCarrosByIdLoadTest { + + @Autowired + private ListCarrosByIdLoad flow; + + @Autowired + private CarroRepository repository; + + @MockBean + private TipoCarroRepository tipoCarroRepository; + + @MockBean + private ListCarrosByIdLoadValidate validate; + + @MockBean + private Carro entity; + + @MockBean + private br.com.grupomult.api.carro.models.Carro domain; + + @Before + public void setUp() throws Exception { + when(repository.findById(anyLong())).thenReturn(entity); + when(validate.execute(entity)).thenReturn(CarroDomainEntityUtil.createResponseEntityResponseGetCarrosById(domain)); + } + + @Test + public void testLoadSuccess() { + ResponseEntity response = flow.execute(new Random().nextLong()); + assertNotNull(response); + assertEquals(HttpStatus.OK, response.getStatusCode()); + + ResponseGetCarrosById body = response.getBody(); + assertNotNull(body); + + br.com.grupomult.api.carro.models.Carro carro = body.getCarro(); + assertNotNull(carro); + } + +} diff --git a/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadValidateTest.java b/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadValidateTest.java new file mode 100644 index 0000000..51c6c32 --- /dev/null +++ b/src/test/java/br/com/grupomult/flows/carro/ListCarrosByIdLoadValidateTest.java @@ -0,0 +1,66 @@ +package br.com.grupomult.flows.carro; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Mockito.when; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.configuration.TestConfiguration; +import br.com.grupomult.entities.Carro; +import br.com.grupomult.exceptions.HttpNotFoundException; +import br.com.grupomult.repositories.TipoCarroRepository; +import br.com.grupomult.utils.CarroDomainEntityUtil; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = TestConfiguration.class) +public class ListCarrosByIdLoadValidateTest { + + @Autowired + private ListCarrosByIdLoadValidate flow; + + @MockBean + private ListCarrosByIdConverter converter; + + @MockBean + private Carro entity; + + @MockBean + private br.com.grupomult.api.carro.models.Carro domain; + + @MockBean + private TipoCarroRepository tipoCarroRepository; + + @Before + public void setUp() throws Exception { + when(converter.execute(entity)).thenReturn(CarroDomainEntityUtil.createResponseEntityResponseGetCarrosById(domain)); + } + + @Test + public void testValidateWithCarroFillSuccess() { + ResponseEntity response = flow.execute(entity); + assertNotNull(response); + assertEquals(HttpStatus.OK, response.getStatusCode()); + + ResponseGetCarrosById body = response.getBody(); + assertNotNull(body); + + br.com.grupomult.api.carro.models.Carro carro = body.getCarro(); + assertNotNull(carro); + } + + @Test(expected = HttpNotFoundException.class) + public void testValidateWithCarroNullExpectedHttpNotFoundException() { + flow.execute(null); + } + +} diff --git a/src/test/java/br/com/grupomult/utils/CarroDomainEntityUtil.java b/src/test/java/br/com/grupomult/utils/CarroDomainEntityUtil.java new file mode 100644 index 0000000..c8ec061 --- /dev/null +++ b/src/test/java/br/com/grupomult/utils/CarroDomainEntityUtil.java @@ -0,0 +1,67 @@ +package br.com.grupomult.utils; + +import static br.com.grupomult.utils.DateUtils.ISO8601_COMPLETE_DATE_HOUR; +import static br.com.grupomult.utils.DateUtils.dateToString; +import static br.com.grupomult.utils.DateUtils.stringToDate; + +import java.util.Date; + +import org.springframework.http.ResponseEntity; + +import br.com.grupomult.api.carro.models.Carro; +import br.com.grupomult.api.carro.models.Carro.TipoCarroEnum; +import br.com.grupomult.api.carro.models.ResponseGetCarrosById; +import br.com.grupomult.entities.CarroPK; +import br.com.grupomult.entities.TipoCarro; + +public class CarroDomainEntityUtil { + + public static Carro criarDomainCarro(TipoCarroEnum tipoCarroEnum) { + return criarDomainCarro(tipoCarroEnum, new Date(), new Date()); + } + + public static br.com.grupomult.entities.Carro criarEntityCarro(TipoCarroEnum tipoCarroEnum) { + return criarEntityCarro(tipoCarroEnum, new Date(), new Date()); + } + + public static Carro criarDomainCarro(TipoCarroEnum tipoCarroEnum, Date dataCriacao, Date dataAtualizacao) { + Carro carro = new Carro(); + carro.setCodigo("PLR4532"); + carro.setDataAtualizacao(dateToString(dataAtualizacao, ISO8601_COMPLETE_DATE_HOUR)); + carro.setDataCriacao(dateToString(dataCriacao, ISO8601_COMPLETE_DATE_HOUR)); + carro.setDescricao("Hyunday i30"); + carro.setTipoCarro(tipoCarroEnum); + return carro; + } + + public static br.com.grupomult.entities.Carro criarEntityCarro(TipoCarroEnum tipoCarroEnum, Date dataCriacao, Date dataAtualizacao) { + br.com.grupomult.entities.Carro carro = br.com.grupomult.entities.Carro.builder().codigo("PLR4532") + .dataAtualizacao(dataAtualizacao) + .dataCriacao(dataCriacao) + .descricao("Hyunday i30") + .carroPK(new CarroPK( criarTipoCarro(tipoCarroEnum))).build(); + return carro; + } + + public static br.com.grupomult.entities.Carro createEntityCarro(String codigo, String dataCriacao, String dataAtualizacao, TipoCarroEnum tipoCarro) { + return br.com.grupomult.entities.Carro.builder() + .codigo(codigo) + .dataCriacao(DateUtils.stringToDate(dataCriacao, DateUtils.ISO8601_COMPLETE_DATE_HOUR)) + .dataAtualizacao(DateUtils.stringToDate(dataAtualizacao, DateUtils.ISO8601_COMPLETE_DATE_HOUR)) + .carroPK(new CarroPK(TipoCarro.builder().code(tipoCarro).build())).build(); + } + + + public static TipoCarro criarTipoCarro(TipoCarroEnum tipoCarroEnum) { + TipoCarro tipoCarro = TipoCarro.builder().id(tipoCarroEnum.ordinal()+1).code(tipoCarroEnum).build(); + return tipoCarro; + } + + public static ResponseEntity createResponseEntityResponseGetCarrosById(Carro domain) { + ResponseGetCarrosById response = new ResponseGetCarrosById(); + response.setCarro(domain); + return ResponseEntity.ok(response); + } + + +}