<settings>
	<proxies>
		<proxy>
			<id>lille1-proxy</id>
			<active>true</active>
			<protocol>http</protocol>
			<host>cache.univ-lille.fr</host>
			<port>3128</port>
		</proxy>
		<proxy>
			<id>lille1-proxy-sec</id>
			<active>true</active>
			<protocol>https</protocol>
			<host>cache.univ-lille.fr</host>
			<port>3128</port>
		</proxy>
	</proxies>
</settings>

.
├── pom.xml
└── src
	├── main
	│   ├── java
	│   │   └── fr
	│   │       └── ulille
	│   │           └── iut
	│   │               └── pizzaland
	│   │                   ├── ApiV1.java
	│   │                   ├── BDDFactory.java
	│   │                   ├── beans
	│   │                   ├── dao
	│   │                   ├── dto
	│   │                   └── resources
	│   ├── resources
	│   │   ├── ingredients.json
	│   │   └── logback.xml
	│   └── webapp
	│       └── WEB-INF
	└── test
		├── java
		│   └── fr
		│       └── ulille
		│           └── iut
		│               └── pizzaland
		│                   └── IngredientResourceTest.java
		└── resources
			└── logback-test.xml

{
  "id": 1,
  "name": "mozzarella"
}

{ "name": "mozzarella" }

public class IngredientResourceTest extends JerseyTest {
    
  @Override
  protected Application configure() {
    return new ApiV1();
  }

  @Test
  public void testGetEmptyList() {
    Response response = target("/ingredients").request().get();

    // Vérification de la valeur de retour (200)
    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
  
    // Vérification de la valeur retournée (liste vide)
    List<IngredientDto> ingredients;
    ingredients = response.readEntity(new GenericType<List<IngredientDto>>(){});

    assertEquals(0, ingredients.size());
  }

package fr.ulille.iut.pizzaland.dto;

public class IngredientDto {

  public IngredientDto() {
    
  }
}

$ mvn test
Results :

Failed tests:   testGetEmptyList(fr.ulille.iut.pizzaland.IngredientResourceTest): expected:<200> but was:<404>

Tests run: 1, Failures: 1, Errors: 0, Skipped: 0

@Path("/ingredients")
public class IngredientResource {

@Context
public UriInfo uriInfo;

public IngredientResource() {
}

@GET
public List<IngredientDto> getAll() {

    return new ArrayList<IngredientDto>();
}

$ mvn test

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

 import fr.ulille.iut.pizzaland.beans.Ingredient;
 
 @Test
 public void testGetExistingIngredient() {
   Ingredient ingredient = new Ingredient();
   ingredient.setId(1);
   ingredient.setName("mozzarella");
 
   Response response = target("/ingredients/1").request().get();
   assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());

   Ingredient result  = Ingredient.fromDto(response.readEntity(IngredientDto.class));
   assertEquals(ingredient, result);
}

public class IngredientDto {
  private long id;
  private String name;

  public IngredientDto() {}

  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getName() {
	return name;
  }
}

import javax.ws.rs.PathParam;
import fr.ulille.iut.pizzaland.beans.Ingredient;

@GET
@Path("{id}")
public IngredientDto getOneIngredient(@PathParam("id") long id) {
  Ingredient ingredient = new Ingredient();
  ingredient.setId(1);
  ingredient.setName("mozzarella");
  
  return Ingredient.toDto(ingredient);
}

package fr.ulille.iut.pizzaland.beans;

import fr.ulille.iut.pizzaland.dto.IngredientDto;

public class Ingredient {
  private long id;
  private String name;

  public Ingredient() {
  }

  public Ingredient(long id, String name) {
    this.id = id;
    this.name = name;
  }

  public void setId(long id) {
    this.id = id;
  }

  public long getId() {
    return id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public static IngredientDto toDto(Ingredient i) {
    IngredientDto dto = new IngredientDto();
    dto.setId(i.getId());
    dto.setName(i.getName());

    return dto;
  }

  public static Ingredient fromDto(IngredientDto dto) {
    Ingredient ingredient = new Ingredient();
    ingredient.setId(dto.getId());
    ingredient.setName(dto.getName());

    return ingredient;
  }
  
  @Override
  public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Ingredient other = (Ingredient) obj;
    if (id != other.id)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
  }

  @Override
  public String toString() {
    return "Ingredient [id=" + id + ", name=" + name + "]";
  }
}

$ mvn test

package fr.ulille.iut.pizzaland.dao;

import java.util.List;

import org.jdbi.v3.sqlobject.config.RegisterBeanMapper;
import org.jdbi.v3.sqlobject.statement.GetGeneratedKeys;
import org.jdbi.v3.sqlobject.statement.SqlQuery;
import org.jdbi.v3.sqlobject.statement.SqlUpdate;

import fr.ulille.iut.pizzaland.beans.Ingredient;

public interface IngredientDao {

  @SqlUpdate("CREATE TABLE IF NOT EXISTS ingredients (id INTEGER PRIMARY KEY, name VARCHAR UNIQUE NOT NULL)")
  void createTable();

  @SqlUpdate("DROP TABLE IF EXISTS ingredients")
  void dropTable();

  @SqlUpdate("INSERT INTO ingredients (name) VALUES (:name)")
  @GetGeneratedKeys
  long insert(String name);

  @SqlQuery("SELECT * FROM ingredients")
  @RegisterBeanMapper(Ingredient.class)
  List<Ingredient> getAll();

  @SqlQuery("SELECT * FROM ingredients WHERE id = :id")
  @RegisterBeanMapper(Ingredient.class)
  Ingredient findById(long id);
}

import fr.ulille.iut.pizzaland.dao.IngredientDao;

public class IngredientResourceTest extends JerseyTest {
  private IngredientDao dao;
  
  @Override
  protected Application configure() {
   BDDFactory.setJdbiForTests();

   return new ApiV1();
}

@Before
public void setEnvUp() {
    dao = BDDFactory.buildDao(IngredientDao.class);
    dao.createTable();
}

@After
public void tearEnvDown() throws Exception {
   dao.dropTable();
}

@Test
public void testGetExistingIngredient() {

    Ingredient ingredient = new Ingredient();
    ingredient.setName("Chorizo");

    long id = dao.insert(ingredient.getName());
    ingredient.setId(id);

    Response response = target("/ingredients/" + id).request().get();

    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());

    Ingredient result = Ingredient.fromDto(response.readEntity(IngredientDto.class));
    assertEquals(ingredient, result);
}

import fr.ulille.iut.pizzaland.BDDFactory;
import fr.ulille.iut.pizzaland.dao.IngredientDao;

import java.util.stream.Collectors;

import javax.ws.rs.WebApplicationException;

public class IngredientResource {
  private IngredientDao ingredients;
  
  public IngredientResource() {
    ingredients = BDDFactory.buildDao(IngredientDao.class);
    ingredients.createTable();
  }
  
  @GET
  public List<IngredientDto> getAll() {
    LOGGER.info("IngredientResource:getAll");

    List<IngredientDto> l = ingredients.getAll().stream().map(Ingredient::toDto).collect(Collectors.toList());
    return l;
  }

  @GET
  @Path("{id}")
  public IngredientDto getOneIngredient(@PathParam("id") long id) {
    LOGGER.info("getOneIngredient(" + id + ")");
    try {
        Ingredient ingredient = ingredients.findById(id);
		return Ingredient.toDto(ingredient);
    }
    catch ( Exception e ) {
		// Cette exception générera une réponse avec une erreur 404
        throw new WebApplicationException(Response.Status.NOT_FOUND);
    }
  }
  
}

$ mvn test

Results :

Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

@Test
public void testGetNotExistingPizza() {
  Response response = target("/pizzas/125").request().get();
  assertEquals(Response.Status.NOT_FOUND.getStatusCode(),response.getStatus());
}


$ mvn test

Results :

Tests run: 3, Failures: 0, Errors: 0, Skipped: 0

import fr.ulille.iut.pizzaland.dto.IngredientCreateDto;

@Test
public void testCreateIngredient() {
    IngredientCreateDto ingredientCreateDto = new IngredientCreateDto();
    ingredientCreateDto.setName("Chorizo");

    Response response = target("/ingredients")
            .request()
            .post(Entity.json(ingredientCreateDto));

    // On vérifie le code de status à 201
    assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());

    IngredientDto returnedEntity = response.readEntity(IngredientDto.class);

    // On vérifie que le champ d'entête Location correspond à
    // l'URI de la nouvelle entité
    assertEquals(target("/ingredients/" +
		returnedEntity.getId()).getUri(), response.getLocation());
	
	// On vérifie que le nom correspond
    assertEquals(returnedEntity.getName(), ingredientCreateDto.getName());
}
	
@Test
public void testCreateSameIngredient() {
    IngredientCreateDto ingredientCreateDto = new IngredientCreateDto();
    ingredientCreateDto.setName("Chorizo");
    dao.insert(ingredientCreateDto.getName());

    Response response = target("/ingredients")
            .request()
            .post(Entity.json(ingredientCreateDto));

    assertEquals(Response.Status.CONFLICT.getStatusCode(), response.getStatus());
}

@Test
public void testCreateIngredientWithoutName() {
    IngredientCreateDto ingredientCreateDto = new IngredientCreateDto();

    Response response = target("/ingredients")
            .request()
            .post(Entity.json(ingredientCreateDto));

    assertEquals(Response.Status.NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
}

package fr.ulille.iut.pizzaland.dto;

public class IngredientCreateDto {
	private String name;
	
	public IngredientCreateDto() {}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
}

$ mvn test

Results :

Failed tests:   testCreateSameIngredient(fr.ulille.iut.pizzaland.IngredientResourceTest): expected:<409> but was:<405>
	testCreateIngredientWithoutName(fr.ulille.iut.pizzaland.IngredientResourceTest): expected:<406> but was:<405>
	testCreateIngredient(fr.ulille.iut.pizzaland.IngredientResourceTest): expected:<201> but was:<405>

Tests run: 6, Failures: 3, Errors: 0, Skipped: 0

import javax.ws.rs.POST;

import fr.ulille.iut.pizzaland.dto.IngredientCreateDto;

@POST
public Response createIngredient(IngredientCreateDto ingredientCreateDto) {
    Ingredient existing = ingredients.findByName(ingredientCreateDto.getName());
    if ( existing != null ) {
        throw new WebApplicationException(Response.Status.CONFLICT);
    }
    
    try {
        Ingredient ingredient = Ingredient.fromIngredientCreateDto(ingredientCreateDto);
        long id = ingredients.insert(ingredient.getName());
        ingredient.setId(id);
        IngredientDto ingredientDto = Ingredient.toDto(ingredient);

        URI uri = uriInfo.getAbsolutePathBuilder().path("" + id).build();

        return Response.created(uri).entity(ingredientDto).build();
    }
    catch ( Exception e ) {
        e.printStackTrace();
        throw new WebApplicationException(Response.Status.NOT_ACCEPTABLE);
    }
}

@SqlQuery("SELECT * FROM ingredients WHERE name = :name")
@RegisterBeanMapper(Ingredient.class)
Ingredient findByName(String name);

import fr.ulille.iut.pizzaland.dto.IngredientCreateDto;
	
public static IngredientCreateDto toCreateDto(Ingredient ingredient) {
    IngredientCreateDto dto = new IngredientCreateDto();
    dto.setName(ingredient.getName());
    
    return dto;
}

public static Ingredient fromIngredientCreateDto(IngredientCreateDto dto) {
    Ingredient ingredient = new Ingredient();
    ingredient.setName(dto.getName());

    return ingredient;
}

$ mvn test

Results :

Tests run: 6, Failures: 0, Errors: 0, Skipped: 0

@Test
public void testDeleteExistingIngredient() {
    Ingredient ingredient = new Ingredient();
    ingredient.setName("Chorizo");
    long id = dao.insert(ingredient.getName());
    ingredient.setId(id);

    Response response = target("/ingredients/" + id).request().delete();

    assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatus());

    Ingredient result = dao.findById(id);
	assertEquals(result, null);
}

@Test
public void testDeleteNotExistingIngredient() {
    Response response = target("/ingredients/125").request().delete();
    assertEquals(Response.Status.NOT_FOUND.getStatusCode(),
	response.getStatus());
}

import javax.ws.rs.DELETE;

@DELETE
@Path("{id}")
public Response deleteIngredient(@PathParam("id") long id) {
	if ( ingredients.findById(id) == null ) {
		throw new WebApplicationException(Response.Status.NOT_FOUND);
	}

    ingredients.remove(id);

    return Response.status(Response.Status.ACCEPTED).build();
}

@SqlUpdate("DELETE FROM ingredients WHERE id = :id")
void remove(long id);

@Test
public void testGetIngredientName() {
    Ingredient ingredient = new Ingredient();
    ingredient.setName("Chorizo");
    long id = dao.insert(ingredient.getName());

    Response response = target("ingredients/" + id + "/name").request().get();

    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());

    assertEquals("Chorizo", response.readEntity(String.class));
}

@Test
public void testGetNotExistingIngredientName() {
    Response response = target("ingredients/125/name").request().get();

    assertEquals(Response.Status.NOT_FOUND.getStatusCode(), response.getStatus());
}

@GET
@Path("{id}/name")
public String getIngredientName(@PathParam("id") long id) {
    Ingredient ingredient = ingredients.findById(id);
	if ( ingredient == null ) {
		throw new WebApplicationException(Response.Status.NOT_FOUND);
	}
        
	return ingredient.getName();
}

import fr.ulille.iut.pizzaland.beans.Ingredient;
import fr.ulille.iut.pizzaland.dao.IngredientDao;

import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

import javax.json.bind.Jsonb;
import javax.json.bind.JsonbBuilder;

@ApplicationPath("api/v1/")
public class ApiV1 extends ResourceConfig {
  packages("fr.ulille.iut.pizzaland");

  String environment = System.getenv("PIZZAENV");

  if ( environment != null && environment.equals("withdb") ) {
	LOGGER.info("Loading with database");
    Jsonb jsonb = JsonbBuilder.create();
    try {
		FileReader reader = new FileReader( getClass().getClassLoader().getResource("ingredients.json").getFile() );
        List<Ingredient> ingredients = JsonbBuilder.create().fromJson(reader, new ArrayList<Ingredient>(){}.getClass().getGenericSuperclass());
            
        IngredientDao ingredientDao = BDDFactory.buildDao(IngredientDao.class);
        ingredientDao.dropTable();
        ingredientDao.createTable();
        for ( Ingredient ingredient: ingredients) {
             ingredientDao.insert(ingredient.getName());              
        }
	} catch ( Exception ex ) {
		throw new IllegalStateException(ex);
    }
  } 
}

$ export PIZZAENV=withdb
$ mvn jetty:run

$ curl -i localhost:8080/api/v1/ingredients

HTTP/1.1 200 OK
Date: Sun, 09 Feb 2020 22:08:05 GMT
Content-Type: application/json
Content-Length: 319
Server: Jetty(9.4.26.v20200117)

[{"id":1,"name":"mozzarella"},{"id":2,"name":"jambon"},{"id":3,"name":"champignons"},{"id":4,"name":"olives"},{"id":5,"name":"tomate"},{"id":6,"name":"merguez"},{"id":7,"name":"lardons"},{"id":8,"name":"fromage"},{"id":9,"name":"oeuf"},{"id":10,"name":"poivrons"},{"id":11,"name":"ananas"},{"id":12,"name":"reblochon"}]