android-client/src/test/java/io/split/android/client/fallback/FallbackTreatmentsCalculatorTest.java at 03165b8bb9435b143a46ee6e2cfb312f342aef3d · splitio/android-client · 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
118
119
120
121
122
123
124
125
package io.split.android.client.fallback;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;

import org.junit.Test;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import io.split.android.client.TreatmentLabels;

public class FallbackTreatmentsCalculatorTest {

    @Test
    public void flagLevelOverrideTakesPrecedence() {
        FallbackTreatment global = new FallbackTreatment("off", "{\"g\":true}");
        FallbackTreatment byFlag = new FallbackTreatment("on", "{\"f\":true}");
        Map<String, FallbackTreatment> map = new HashMap<>();
        map.put("my_flag", byFlag);
        FallbackConfiguration config = FallbackConfiguration.builder()
                .global(global)
                .byFlag(map)
                .build();

        FallbackTreatmentsCalculator calculator = new FallbackTreatmentsCalculatorImpl(config);
        FallbackTreatment resolvedExisting = calculator.resolve("my_flag");
        FallbackTreatment resolvedOther = calculator.resolve("other_flag");

        assertNotNull(resolvedExisting);
        assertEquals(byFlag, resolvedExisting);
        assertNotNull(resolvedOther);
        assertEquals(global, resolvedOther);
    }

    @Test
    public void globalFallbackIsReturnedWhenNoFlagOverride() {
        FallbackTreatment global = new FallbackTreatment("off");
        FallbackConfiguration config = FallbackConfiguration.builder()
                .global(global)
                .byFlag(Collections.emptyMap())
                .build();

        FallbackTreatmentsCalculator calculator = new FallbackTreatmentsCalculatorImpl(config);
        FallbackTreatment resolved = calculator.resolve("any_flag");

        assertNotNull(resolved);
        assertEquals(global, resolved);
    }

    @Test
    public void flagLevelFallbackIsReturnedWhenConfigured() {
        FallbackTreatment byFlag = new FallbackTreatment("on");
        Map<String, FallbackTreatment> map = new HashMap<>();
        map.put("flagA", byFlag);
        FallbackConfiguration config = FallbackConfiguration.builder()
                .byFlag(map)
                .build();

        FallbackTreatmentsCalculator calculator = new FallbackTreatmentsCalculatorImpl(config);
        FallbackTreatment resolved = calculator.resolve("flagA");

        assertNotNull(resolved);
        assertEquals(byFlag, resolved);
    }

    @Test
    public void returnsControlWhenNoFallbackConfigured() {
        FallbackConfiguration config = FallbackConfiguration.builder()
                .build();

        FallbackTreatmentsCalculator calculator = new FallbackTreatmentsCalculatorImpl(config);
        FallbackTreatment resolved = calculator.resolve("nope");

        assertNotNull(resolved);
        assertEquals(new FallbackTreatment("control", null, null), resolved);
    }

    @Test
    public void nonexistentFlagFallsBackToGlobal() {
        FallbackTreatment global = new FallbackTreatment("off");
        Map<String, FallbackTreatment> map = new HashMap<>();
        map.put("flagA", new FallbackTreatment("on"));
        FallbackConfiguration config = FallbackConfiguration.builder()
                .global(global)
                .byFlag(map)
                .build();

        FallbackTreatmentsCalculator calculator = new FallbackTreatmentsCalculatorImpl(config);
        FallbackTreatment resolved = calculator.resolve("flagB");

        assertNotNull(resolved);
        assertEquals(global, resolved);
    }

    @Test
    public void labelIsPrefixed() {
        FallbackTreatment global = new FallbackTreatment("off");
        FallbackConfiguration config = FallbackConfiguration.builder()
                .global(global)
                .build();

        FallbackTreatmentsCalculator calculator = new FallbackTreatmentsCalculatorImpl(config);
        FallbackTreatment resolved = calculator.resolve("flagA", TreatmentLabels.EXCEPTION);

        assertNotNull(resolved);
        assertEquals("fallback - exception", resolved.getLabel());
    }

    @Test
    public void noLabelReturnsNull() {
        FallbackTreatment global = new FallbackTreatment("off");
        FallbackConfiguration config = FallbackConfiguration.builder()
                .global(global)
                .build();

        FallbackTreatmentsCalculator calculator = new FallbackTreatmentsCalculatorImpl(config);
        FallbackTreatment resolved = calculator.resolve("flagA", null);

        assertNotNull(resolved);
        assertNull(resolved.getLabel());
    }
}