25/26 - 3bhif - syp - Lecture Notes

services:
  postgres:
    image: postgres:18
    container_name: postgres-db
    environment:
      POSTGRES_DB: db
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql

volumes:
  pgdata:

package org.acme.vehicle.entity;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.SequenceGenerator;
import jakarta.persistence.Table;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import org.eclipse.microprofile.openapi.annotations.media.Schema;

@Entity
@Table(name = "AI_VEHICLE")
@Schema(description = "A vehicle record")
public class Vehicle {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "vehicle_seq")
    @SequenceGenerator(name = "vehicle_seq", sequenceName = "vehicle_id_seq", allocationSize = 1)
    @Column(name = "V_ID")
    @Schema(readOnly = true, example = "1", description = "Server-generated primary key")
    private Long id;

    @NotBlank(message = "Make must not be blank")
    @Column(name = "V_MAKE", nullable = false)
    @Schema(example = "Volkswagen", description = "Manufacturer of the vehicle", required = true)
    private String make;

    @NotBlank(message = "Model must not be blank")
    @Column(name = "V_MODEL", nullable = false)
    @Schema(example = "Golf VII", description = "Model designation", required = true)
    private String model;

    @NotNull(message = "Construction year must not be null")
    @Min(value = 1886, message = "Construction year must be 1886 or later")
    @Column(name = "V_CONSTRUCTION_YEAR", nullable = false)
    @Schema(example = "2015", description = "Year the vehicle was manufactured (>= 1886)", required = true)
    private Integer construction_year;

    public Vehicle() {
    }

    public Vehicle(String make, String model, Integer construction_year) {
        this.make = make;
        this.model = model;
        this.construction_year = construction_year;
    }

    // Getter and Setter
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getMake() { return make; }
    public void setMake(String make) { this.make = make; }
    public String getModel() { return model; }
    public void setModel(String model) { this.model = model; }
    public Integer getConstruction_year() { return construction_year; }
    public void setConstruction_year(Integer construction_year) { this.construction_year = construction_year; }
}

package org.acme.vehicle.repository;

import io.quarkus.hibernate.orm.panache.PanacheRepository;
import jakarta.enterprise.context.ApplicationScoped;
import org.acme.vehicle.entity.Vehicle;

@ApplicationScoped
public class VehicleRepository implements PanacheRepository<Vehicle> {
}

package org.acme.vehicle.resource;

import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import jakarta.validation.Valid;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.core.Response.Status;
import java.net.URI;
import java.util.List;
import org.acme.vehicle.entity.Vehicle;
import org.acme.vehicle.repository.VehicleRepository;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;

@Path("/api/vehicles")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Tag(name = "Vehicles", description = "CRUD operations on vehicles")
public class VehicleResource {

    @Inject
    VehicleRepository repository;

    @GET
    @Operation(summary = "List all vehicles")
    @APIResponse(responseCode = "200", description = "Array of vehicles")
    public List<Vehicle> list() {
        return repository.listAll();
    }

    @GET
    @Path("/{id}")
    @Operation(summary = "Get a vehicle by ID")
    @APIResponse(responseCode = "200", description = "Vehicle found")
    @APIResponse(responseCode = "404", description = "Vehicle not found")
    public Response get(@PathParam("id") Long id) {
        return repository.findByIdOptional(id)
                .map(vehicle -> Response.ok(vehicle).build())
                .orElseGet(() -> Response.status(Status.NOT_FOUND).build());
    }

    @POST
    @Transactional
    @Operation(summary = "Create a vehicle")
    @APIResponse(responseCode = "201", description = "Vehicle created")
    public Response create(@Valid Vehicle vehicle) {
        repository.persist(vehicle);
        return Response.created(URI.create("/api/vehicles/" + vehicle.getId()))
                .entity(vehicle)
                .build();
    }

    @PUT
    @Path("/{id}")
    @Transactional
    @Operation(summary = "Update an existing vehicle")
    public Response update(@PathParam("id") Long id, @Valid Vehicle updatedVehicle) {
        return repository.findByIdOptional(id)
                .map(vehicle -> {
                    vehicle.setMake(updatedVehicle.getMake());
                    vehicle.setModel(updatedVehicle.getModel());
                    vehicle.setConstruction_year(updatedVehicle.getConstruction_year());
                    return Response.ok(vehicle).build();
                })
                .orElseGet(() -> Response.status(Status.NOT_FOUND).build());
    }

    @DELETE
    @Path("/{id}")
    @Transactional
    @Operation(summary = "Delete a vehicle")
    public Response delete(@PathParam("id") Long id) {
        boolean deleted = repository.deleteById(id);
        if (deleted) {
            return Response.noContent().build();
        } else {
            return Response.status(Status.NOT_FOUND).build();
        }
    }
}

# Datasource configuration
quarkus.datasource.db-kind=postgresql
quarkus.datasource.username=app
quarkus.datasource.password=app
quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/db

# Hibernate ORM configuration
quarkus.hibernate-orm.database.generation=drop-and-create
quarkus.hibernate-orm.log.sql=true
quarkus.hibernate-orm.sql-load-script=no-file
%dev.quarkus.hibernate-orm.sql-load-script=import.sql

# OpenAPI / Swagger UI
quarkus.swagger-ui.always-include=true
quarkus.smallrye-openapi.info-title=Vehicle API
quarkus.smallrye-openapi.info-version=1.0.0

INSERT INTO AI_VEHICLE (V_ID, V_MAKE, V_MODEL, V_CONSTRUCTION_YEAR) VALUES (1, 'Volkswagen', 'Golf VII', 2015);
INSERT INTO AI_VEHICLE (V_ID, V_MAKE, V_MODEL, V_CONSTRUCTION_YEAR) VALUES (2, 'BMW', 'M3 E46', 2003);
INSERT INTO AI_VEHICLE (V_ID, V_MAKE, V_MODEL, V_CONSTRUCTION_YEAR) VALUES (3, 'Tesla', 'Model 3', 2022);
ALTER SEQUENCE vehicle_id_seq RESTART WITH 100;

package org.acme.vehicle.resource;

import static io.restassured.RestAssured.given;
import static org.assertj.core.api.Assertions.assertThat;

import io.quarkus.test.junit.QuarkusTest;
import io.restassured.http.ContentType;
import io.restassured.response.Response;
import org.acme.vehicle.entity.Vehicle;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;

@QuarkusTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class VehicleResourceTest {

    private static Long createdId;

    @Test
    @Order(1)
    public void testCreateVehicle() {
        Vehicle vehicle = new Vehicle("Tesla", "Model S", 2022);

        Response response = given()
                .contentType(ContentType.JSON)
                .body(vehicle)
                .when()
                .post("/api/vehicles")
                .then()
                .statusCode(201)
                .extract()
                .response();

        Vehicle created = response.as(Vehicle.class);
        assertThat(created).isNotNull();
        assertThat(created.getId()).isNotNull();
        assertThat(created.getMake()).isEqualTo("Tesla");

        createdId = created.getId();
    }

    @Test
    @Order(2)
    public void testGetVehicle() {
        Response response = given()
                .when()
                .get("/api/vehicles/" + createdId)
                .then()
                .statusCode(200)
                .extract()
                .response();

        Vehicle vehicle = response.as(Vehicle.class);
        assertThat(vehicle.getMake()).isEqualTo("Tesla");
    }

    @Test
    @Order(3)
    public void testCreateValidationFail() {
        Vehicle invalid = new Vehicle("", "Model 3", 1800); // Fails due to blank make and year < 1886
        given()
                .contentType(ContentType.JSON)
                .body(invalid)
                .when()
                .post("/api/vehicles")
                .then()
                .statusCode(400);
    }
}

package org.acme.vehicle.repository;

import io.quarkus.test.junit.QuarkusTest;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import javax.sql.DataSource;
import org.acme.vehicle.entity.Vehicle;
import org.assertj.db.type.AssertDbConnection;
import org.assertj.db.type.AssertDbConnectionFactory;
import org.assertj.db.type.Table;
import static org.assertj.db.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;

@QuarkusTest
public class VehicleDatabaseTest {

    @Inject
    DataSource dataSource;

    @Inject
    VehicleRepository repository;

    @Test
    @Transactional
    public void testDatabaseState() {
        AssertDbConnection connection = AssertDbConnectionFactory.of(dataSource).create();

        Table table = connection.table("AI_VEHICLE").build();
        int initialRows = table.getRowsList().size();

        Vehicle vehicle = new Vehicle("Audi", "A4", 2021);
        repository.persistAndFlush(vehicle);

        Table updatedTable = connection.table("AI_VEHICLE").build();

        assertThat(updatedTable)
                .hasNumberOfRows(initialRows + 1)
                .row(initialRows)
                .value("V_MAKE").isEqualTo("Audi")
                .value("V_MODEL").isEqualTo("A4")
                .value("V_CONSTRUCTION_YEAR").isEqualTo(2021);

        repository.delete(vehicle);
    }
}