ALOM - TP 2 - Handcraft

$ mkdir -p src/main/java
$ mkdir -p src/test/java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.miage.alom.tp</groupId>
    <artifactId>handcrafting</artifactId>
    <version>0.1.0</version>
    <packaging>war</packaging> (1)

    <properties>
        <maven.compiler.source>21</maven.compiler.source> (2)
        <maven.compiler.target>21</maven.compiler.target> (3)
    </properties>

    <dependencies>
    </dependencies>

</project>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId> (1)
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId> (2)
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.5.0</version>
    <scope>test</scope>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
<pluginManagement>
    <plugins>
        <plugin>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.4.0</version>
        </plugin>
        <plugin>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.1.2</version> (1)
        </plugin>
    </plugins>
</pluginManagement>

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
package com.miage.alom.servlet;

import com.miage.alom.controller.HelloController;
import org.junit.jupiter.api.Test;

import java.util.Map;

import static org.junit.jupiter.api.Assertions.*;

class DispatcherServletTest { (1)

    @Test (2)
    void registerController_throwsIllegalArgumentException_forNonControllerClasses() {
        var servlet = new DispatcherServlet();

        assertThrows(IllegalArgumentException.class,
                () -> servlet.registerController(String.class));
        assertThrows(IllegalArgumentException.class,
                () -> servlet.registerController(SomeEmptyClass.class));
    }

    @Test
    void registerController_doesNotRegisters_nonAnnotatedMethods() {
        var servlet = new DispatcherServlet();

        servlet.registerController(SomeControllerClassWithAMethod.class);

        assertTrue(servlet.getMappings().isEmpty());
    }

    @Test
    void registerController_doesNotRegisters_voidReturningMethods() {
        var servlet = new DispatcherServlet();

        servlet.registerController(SomeControllerClassWithAVoidMethod.class);

        assertTrue(servlet.getMappings().isEmpty());
    }

    @Test (4)
    void registerController_shouldRegisterCorrectyMethods(){
        var servlet = new DispatcherServlet();

        servlet.registerController(SomeControllerClass.class);
        servlet.registerController(SomeOtherControllerClass.class);

        assertEquals("someGoodMethod",
                servlet.getMappingForUri("/test").getName());
        assertEquals("someOtherNiceMethod",
                servlet.getMappingForUri("/otherTest").getName());
    }

    @Test
    void registerHelloController_shouldWorkCorrectly(){
        var servlet = new DispatcherServlet();
        servlet.registerController(HelloController.class);

        assertEquals("sayHello", servlet.getMappingForUri("/hello").getName());
        assertEquals("sayGoodBye", servlet.getMappingForUri("/bye").getName());
        assertEquals("explode", servlet.getMappingForUri("/boum").getName());
    }
}


class SomeEmptyClass{}

(3)
@com.miage.alom.servlet.ServletController
class SomeControllerClassWithAMethod{
    public String myMethod(){
        return "test";
    }
}

@com.miage.alom.servlet.ServletController
class SomeControllerClassWithAVoidMethod{
    @com.miage.alom.servlet.ServletRequestMapping(uri="/test")
    public void myMethod(){}
}

@com.miage.alom.servlet.ServletController
class SomeControllerClass {
    @com.miage.alom.servlet.ServletRequestMapping(uri="/test")
    public String someGoodMethod(){
        return "Hello";
    }

    @com.miage.alom.servlet.ServletRequestMapping(uri="/test-throwing")
    public String someThrowingMethod(){
        throw new RuntimeException("some exception message");
    }

    @com.miage.alom.servlet.ServletRequestMapping(uri="/test-with-params")
    public String someThrowingMethod(Map<String, String[]> params){
        return params.get("id")[0];
    }
}

@com.miage.alom.servlet.ServletController
class SomeOtherControllerClass {
    @com.miage.alom.servlet.ServletRequestMapping(uri="/otherTest")
    public String someOtherNiceMethod(){
        return "Hello again";
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.miage.alom.servlet;

import com.miage.alom.controller.HelloController;

import jakarta.servlet.ServletConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

@WebServlet(urlPatterns = "/*", loadOnStartup = 1)
public class DispatcherServlet extends HttpServlet {

    private Map<String, Method> uriMappings = new HashMap<>(); (1)

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        System.out.println("Getting request for " + req.getRequestURI());
        // TODO (3)
    }

    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        // on enregistre notre controller au démarrage de la servlet
        this.registerController(HelloController.class);
    }

    /**
     * This methods checks the following rules :
     * - The controllerClass is annotated with @ServletController
     * Then all methods are scanned and processed by the registerMethod method
     * @param controllerClass the controller to scan
     */
    protected void registerController(Class controllerClass){
        System.out.println("Analysing class " + controllerClass.getName());
        // TODO (2)
    }

    /**
     * This methods checks the following rules :
     * - The method is annotated with @ServletRequestMapping
     * - The @ServletRequestMapping annotation has a URI
     * - The method does not return void
     * If these rules are followed, the method and its URI are added to the uriMapping map.
     * @param method the method to scan
     */
    protected void registerMethod(Method method) {
        System.out.println("Registering method " + method.getName());
        // TODO (2)
    }

    protected Map<String, Method> getMappings(){
        return this.uriMappings;
    }

    protected Method getMappingForUri(String uri){
        return this.uriMappings.get(uri);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
@Test
void doGet_shouldReturn404_whenNotMethodIsFound() throws IOException {
    var servlet = new DispatcherServlet();

    var req = mock(HttpServletRequest.class);
    var resp = mock(HttpServletResponse.class);
    when(req.getRequestURI()).thenReturn("/test");

    servlet.doGet(req, resp);

    verify(resp).sendError(404, "no mapping found for request uri /test");
}

@Test
void doGet_shouldReturn500WithMessage_whenMethodThrowsException() throws IOException {
    var servlet = new DispatcherServlet();

    servlet.registerController(SomeControllerClass.class);

    var req = mock(HttpServletRequest.class);
    var resp = mock(HttpServletResponse.class);
    when(req.getRequestURI()).thenReturn("/test-throwing");

    servlet.doGet(req, resp);

    verify(resp).sendError(500,
        "exception when calling method someThrowingMethod : some exception message");
}

@Test
void doGet_shouldReturnAResult_whenMethodSucceeds() throws IOException {
    var servlet = new DispatcherServlet();

    servlet.registerController(SomeControllerClass.class);

    var req = mock(HttpServletRequest.class);
    var resp = mock(HttpServletResponse.class);
    var printWriter = mock(PrintWriter.class);

    when(resp.getWriter()).thenReturn(printWriter);
    when(req.getRequestURI()).thenReturn("/test");

    servlet.doGet(req, resp);

    verify(printWriter).print((Object)"Hello");
}

@Test
void doGet_shouldReturnAResult_whenMethodWithParametersSucceeds() throws IOException {
    var servlet = new DispatcherServlet();

    servlet.registerController(SomeControllerClass.class);

    var req = mock(HttpServletRequest.class);
    var resp = mock(HttpServletResponse.class);
    var printWriter = mock(PrintWriter.class);

    when(req.getRequestURI()).thenReturn("/test-with-params");
    when(req.getParameterMap()).thenReturn(Map.of("id", new String[]{"12"}));
    when(resp.getWriter()).thenReturn(printWriter);

    servlet.doGet(req, resp);

    verify(printWriter).print((Object)"12");
}

@Test
void doGet_shouldReturnAResult_forHelloController() throws IOException {
    var servlet = new DispatcherServlet();
    servlet.registerController(HelloController.class);

    var req = mock(HttpServletRequest.class);
    var resp = mock(HttpServletResponse.class);
    var printWriter = mock(PrintWriter.class);

    when(req.getRequestURI()).thenReturn("/hello");
    when(resp.getWriter()).thenReturn(printWriter);

    servlet.doGet(req, resp);

    verify(printWriter).print((Object)"Hello World !");
}

import static org.mockito.Mockito.*;

1
2
3
4
5
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class JacksonDatabindTest {

    public static class Car { (1)
        public String color; (2)
        public String brand;
    }

    @Test
    void testWriteJson() throws JsonProcessingException { (3)
        var objectMapper = new ObjectMapper();
        var car = new Car();
        car.color = "yellow";
        car.brand = "renault";
        var json = objectMapper.writeValueAsString(car);
        assertEquals("{\"color\":\"yellow\",\"brand\":\"renault\"}", json);
    }

    @Test
    void testReadJson() throws IOException { (4)
        var objectMapper = new ObjectMapper();
        var json = "{ \"color\" : \"black\", \"brand\" : \"opel\" }";
        var car = objectMapper.readValue(json, Car.class);
        assertEquals("black", car.color);
        assertEquals("opel", car.brand);
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package com.miage.alom.repository;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class PokemonTypeRepositoryTest {

    private PokemonTypeRepository repository = new PokemonTypeRepository();

    @Test
    void findPokemonById_with25_shouldReturnPikachu(){ (1)
        var pikachu = repository.findPokemonById(25);
        assertNotNull(pikachu);
        assertEquals("pikachu", pikachu.getName());
        assertEquals(25, pikachu.getId());
    }

    @Test
    void findPokemonById_with145_shouldReturnZapdos(){ (1)
        var zapdos = repository.findPokemonById(145);
        assertNotNull(zapdos);
        assertEquals("zapdos", zapdos.getName());
        assertEquals(145, zapdos.getId());
    }

    @Test
    void findPokemonByName_withEevee_shouldReturnEevee(){ (2)
        var eevee = repository.findPokemonByName("eevee");
        assertNotNull(eevee);
        assertEquals("eevee", eevee.getName());
        assertEquals(133, eevee.getId());
    }

    @Test
    void findPokemonByName_withMewTwo_shouldReturnMewTwo(){ (2)
        var mewtwo = repository.findPokemonByName("mewtwo");
        assertNotNull(mewtwo);
        assertEquals("mewtwo", mewtwo.getName());
        assertEquals(150, mewtwo.getId());
    }

    @Test
    void findAllPokemon_shouldReturn151Pokemons(){
        var pokemons = repository.findAllPokemon();
        assertNotNull(pokemons);
        assertEquals(151, pokemons.size());
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.miage.alom.repository;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.miage.alom.bo.PokemonType;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;

public class PokemonTypeRepository {

    private List<PokemonType> pokemons;

    public PokemonTypeRepository() {
        try {
            var pokemonsStream = this.getClass().getResourceAsStream("/pokemons.json"); (1)

            var objectMapper = new ObjectMapper(); (2)
            var pokemonsArray = objectMapper.readValue(pokemonsStream, PokemonType[].class);
            this.pokemons = Arrays.asList(pokemonsArray);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public PokemonType findPokemonById(int id) {
        System.out.println("Loading Pokemon information for Pokemon id " + id);

        // TODO (3)
    }

    public PokemonType findPokemonByName(String name) {
        System.out.println("Loading Pokemon information for Pokemon name " + name);

        // TODO (3)
    }

    public List<PokemonType> findAllPokemon() {
        // TODO (3)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package com.miage.alom.controller;

import com.miage.alom.bo.PokemonType;
import com.miage.alom.repository.PokemonTypeRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.Map;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

class PokemonTypeControllerTest {

    @InjectMocks
    PokemonTypeController controller;

    @Mock
    PokemonTypeRepository pokemonRepository;

    @BeforeEach
    void init(){
        MockitoAnnotations.initMocks(this);
    }

    @Test
    void getPokemon_shouldRequireAParameter(){
        var exception = assertThrows(IllegalArgumentException.class,
                () -> controller.getPokemon(null));
        assertEquals("parameters should not be empty", exception.getMessage());
    }

    @Test
    void getPokemon_shouldRequireAKnownParameter(){
        var parameters = Map.of("test", new String[]{"25"});
        var exception = assertThrows(IllegalArgumentException.class,
                () -> controller.getPokemon(parameters));
        assertEquals("unknown parameter", exception.getMessage());
    }

    @Test
    void getPokemon_withAnIdParameter_shouldReturnAPokemon(){
        var pikachu = new PokemonType();
        pikachu.setId(25);
        pikachu.setName("pikachu");
        when(pokemonRepository.findPokemonById(25)).thenReturn(pikachu);

        var parameters = Map.of("id", new String[]{"25"});
        var pokemon = controller.getPokemon(parameters);
        assertNotNull(pokemon);
        assertEquals(25, pokemon.getId());
        assertEquals("pikachu", pokemon.getName());

        verify(pokemonRepository).findPokemonById(25);
        verifyNoMoreInteractions(pokemonRepository);
    }

    @Test
    void getPokemon_withANameParameter_shouldReturnAPokemon(){
        var zapdos = new PokemonType();
        zapdos.setId(145);
        zapdos.setName("zapdos");
        when(pokemonRepository.findPokemonByName("zapdos")).thenReturn(zapdos);

        var parameters = Map.of("name", new String[]{"zapdos"});
        var pokemon = controller.getPokemon(parameters);
        assertNotNull(pokemon);
        assertEquals(145, pokemon.getId());
        assertEquals("zapdos", pokemon.getName());

        verify(pokemonRepository).findPokemonByName("zapdos");
        verifyNoMoreInteractions(pokemonRepository);
    }

    @Test
    void pokemonTypeController_shouldBeAnnotated(){
        var controllerAnnotation =
                PokemonTypeController.class.getAnnotation(ServletController.class);
        assertNotNull(controllerAnnotation);
    }

    @Test
    void getPokemon_shouldBeAnnotated() throws NoSuchMethodException {
        var getPokemonMethod =
                PokemonTypeController.class.getDeclaredMethod("getPokemon", Map.class);
        var requestMappingAnnotation =
                getPokemonMethod.getAnnotation(ServletRequestMapping.class);

        assertNotNull(requestMappingAnnotation);
        assertEquals("/pokemons", requestMappingAnnotation.uri());
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
package com.miage.alom.controller;

import com.miage.alom.bo.PokemonType;
import com.miage.alom.repository.PokemonTypeRepository;

import java.util.Map;

public class PokemonTypeController {
    private PokemonTypeRepository repository = new PokemonTypeRepository();

    public PokemonType getPokemon(Map<String,String[]> parameters){
        // TODO
    }
}