summaryrefslogtreecommitdiffstats
path: root/container-core/src/test/java/com/yahoo/restapi/JsonTest.java
blob: 0ef4872c908755eb7df83dba5426b63e191e9a30 (plain) (blame)
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
126
package com.yahoo.restapi;

import org.junit.jupiter.api.Test;

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

/**
 * @author bjorncs
 */
class JsonTest {

    @Test
    void parses_json_correctly() {
        var text =
                """
                {
                    "string": "bar",
                    "integer": 42,
                    "floaty": 8.25,
                    "bool": true,
                    "array": [1, 2, 3],
                    "quux": {
                        "corge": "grault"
                    }
                }
                """;
        var json = Json.of(text);

        // Primitive members
        assertEquals("bar", json.f("string").asString());
        assertTrue(json.f("string").asOptionalString().isPresent());
        assertEquals("bar", json.f("string").asOptionalString().get());
        assertEquals(42L, json.f("integer").asLong());
        assertEquals(42D, json.f("integer").asDouble());
        assertEquals(8.25D, json.f("floaty").asDouble());
        assertEquals(8L, json.f("floaty").asLong());
        assertTrue(json.f("bool").asBool());

        // Array member
        assertEquals(3, json.f("array").length());
        assertEquals(1L, json.f("array").entry(0).asLong());
        assertEquals(2L, json.f("array").entry(1).asLong());
        assertEquals(3L, json.f("array").entry(2).asLong());
        json.f("array").forEachEntry((i, entry) -> assertEquals(i + 1, entry.asLong()));
        int counter = 0;
        for (var entry : json.f("array")) {
            assertEquals(++counter, entry.asLong());
        }

        // Object member
        assertEquals("grault", json.f("quux").f("corge").asString());
        json.f("quux").forEachField((name, child) -> {
            assertEquals("corge", name);
            assertEquals("grault", child.asString());
        });
    }

    @Test
    void throws_on_missing_and_invalid_members() {
        var text =
                """
                {
                    "string": "bar"
                }
                """;
        var json = Json.of(text);

        var exception = assertThrows(RestApiException.BadRequest.class, () -> json.f("unknown").asString());
        assertEquals("Missing JSON member 'unknown'", exception.getMessage());

        exception = assertThrows(RestApiException.BadRequest.class, () -> json.a(0));
        assertEquals("Expected JSON to be a 'array' but got 'object'", exception.getMessage());

        exception = assertThrows(RestApiException.BadRequest.class, () -> json.f("string").f("unknown"));
        assertEquals("Expected JSON member 'string' to be a 'object' but got 'string'", exception.getMessage());

        exception = assertThrows(RestApiException.BadRequest.class, () -> json.f("string").asLong());
        assertEquals("Expected JSON member 'string' to be a 'integer' or 'float' but got 'string'", exception.getMessage());
    }

    @Test
    void fallback_to_default_if_field_missing() {
        var text =
                """
                {
                    "string": "bar"
                }
                """;
        var json = Json.of(text);
        assertEquals("foo", json.f("unknown").asString("foo"));
        assertEquals("foo", json.f("unknown").asOptionalString().orElse("foo"));
        assertEquals("bar", json.f("string").asString("foo"));
        assertEquals("bar", json.f("string").asOptionalString().orElse("foo"));
    }

    @Test
    void builds_expected_json() {
        var expected =
                """
                {
                  "string": "bar",
                  "integer": 42,
                  "floaty": 8.25,
                  "bool": true,
                  "array": [
                    1,
                    2,
                    3
                  ],
                  "quux": {
                    "corge": "grault"
                  }
                }
                """;
        var json = Json.Builder.newObject()
                .set("string", "bar")
                .set("integer", 42)
                .set("floaty", 8.25)
                .set("bool", true)
                .set("array", Json.Builder.newArray().add(1).add(2).add(3))
                .set("quux", Json.Builder.newObject().set("corge", "grault"))
                .build()
                .toJson(true);
        assertEquals(expected, json);
    }
}