rules-engine/src/test/java/net/ironoc/rules/engine/controller/FlagControllerTest.java at 2ee414109bf925ee0ebd619c4028919e258e900a · conorheffron/rules-engine · GitHub

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
106
107
108
109
110
111
112
113
114
115
116
117
package net.ironoc.rules.engine.controller;

import module java.base;

import com.fasterxml.jackson.databind.ObjectMapper;
import net.ironoc.rules.engine.domain.ApiResponse;
import net.ironoc.rules.engine.dto.Feature;
import net.ironoc.rules.engine.dto.RuleGroups;
import net.ironoc.rules.engine.enums.FeatureFlag;
import net.ironoc.rules.engine.service.FeatureDetailService;
import net.ironoc.rules.engine.service.RulesService;
import org.camunda.bpm.engine.RuntimeService;
import org.junit.jupiter.api.Test;
import org.springframework.core.env.Environment;
import org.springframework.http.ResponseEntity;

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;

class FlagControllerTest {

    private static ObjectMapper objectMapper() {
        return new ObjectMapper();
    }

    private static FeatureDetailService featureDetailService = new FeatureDetailService();

    private static RulesService rulesService() {
        Environment env = mock(Environment.class);
        return new RulesService(env, objectMapper(), featureDetailService);
    }

    private static FlagController controllerWith(RulesService service) {
        RuntimeService runtimeService = mock(RuntimeService.class);
        return new FlagController(service, runtimeService, featureDetailService);
    }

    @Test
    void evaluateFlags_featureNotFound_returnsBadRequestAndEmptyList() {
        // given
        RulesService service = rulesService(); // empty features map
        FlagController controller = controllerWith(service);

        // when
        ResponseEntity<ApiResponse> response =
                controller.evaluateFlags("missing-feature", "ES", "12", "FREE");

        // then
        assertNotNull(response);
        assertEquals(400, response.getStatusCode().value());
        assertNotNull(response.getBody());
        assertTrue(response.getBody().rules().isEmpty());
    }

    @Test
    void evaluateFlags_featureDisabled_returnsBadRequestAndEmptyList() {
        // given
        featureDetailService.clear();
        RulesService service = rulesService();
        featureDetailService.put("new-checkout", new Feature(false, null));
        FlagController controller = controllerWith(service);

        // when
        ResponseEntity<ApiResponse> response =
                controller.evaluateFlags("new-checkout", "ES", "12", "FREE");

        // then
        assertNotNull(response);
        assertEquals(400, response.getStatusCode().value());
        assertNotNull(response.getBody());
        assertTrue(response.getBody().rules().isEmpty());
    }

    @Test
    void evaluateFlags_matchesFromAllAndAny_returnsOkAndCombinedList() {
        // given
        RulesService service = rulesService();

        Map<String, Map<String, Object>> all = Map.of(
                "r1", Map.of(
                        "attr", "COUNTRY",
                        "op", "IN",
                        "values", Map.of("0", "ES")
                )
        );

        Map<String, Map<String, Object>> any = Map.of(
                "r2", Map.of(
                        "attr", "TIER",
                        "op", "EQ",
                        "values", Map.of("0", "FREE")
                )
        );

        Feature feature = new Feature(true, new RuleGroups(all, any));
        featureDetailService.clear();
        featureDetailService.put("new-checkout", feature);

        FlagController controller = controllerWith(service);

        // when
        ResponseEntity<ApiResponse> response =
                controller.evaluateFlags("new-checkout", "ES", "12", "FREE");


        // then
        assertNotNull(response);
        assertEquals(200, response.getStatusCode().value());
        assertNotNull(response.getBody());
        assertEquals(2, response.getBody().rules().size());

        assertTrue(response.getBody().rules().stream().anyMatch(r -> FeatureFlag.COUNTRY.name().equalsIgnoreCase(r.attr())));
        assertTrue(response.getBody().rules().stream().anyMatch(r -> FeatureFlag.TIER.name().equalsIgnoreCase(r.attr())));
    }
}