Containerizing microservices

 1// tag::copyright[]
 2/*******************************************************************************
 3 * Copyright (c) 2018, 2020 IBM Corporation and others.
 4 * All rights reserved. This program and the accompanying materials
 5 * are made available under the terms of the Eclipse Public License v1.0
 6 * which accompanies this distribution, and is available at
 7 * http://www.eclipse.org/legal/epl-v10.html
 8 *
 9 * Contributors:
10 *     IBM Corporation - Initial implementation
11 *******************************************************************************/
12// end::copyright[]
13package it.io.openliberty.guides.system;
14
15import static org.junit.jupiter.api.Assertions.assertEquals;
16
17import javax.net.ssl.HostnameVerifier;
18import javax.net.ssl.SSLSession;
19import javax.ws.rs.client.Client;
20import javax.ws.rs.client.ClientBuilder;
21import javax.ws.rs.client.WebTarget;
22import javax.ws.rs.core.Response;
23
24import org.apache.cxf.jaxrs.provider.jsrjsonp.JsrJsonpProvider;
25import org.junit.jupiter.api.AfterEach;
26import org.junit.jupiter.api.BeforeAll;
27import org.junit.jupiter.api.BeforeEach;
28import org.junit.jupiter.api.Test;
29
30public class SystemEndpointIT {
31
32    private static String clusterUrl;
33
34    private Client client;
35
36    @BeforeAll
37    public static void oneTimeSetup() {
38        String nodePort = System.getProperty("system.http.port");
39        clusterUrl = "http://localhost:" + nodePort + "/system/properties/";
40    }
41
42    @BeforeEach
43    public void setup() {
44        client = ClientBuilder.newBuilder()
45                    .hostnameVerifier(new HostnameVerifier() {
46                        public boolean verify(String hostname, SSLSession session) {
47                            return true;
48                        }
49                    })
50                    .build();
51    }
52
53    @AfterEach
54    public void teardown() {
55        client.close();
56    }
57
58    // tag::testGetProperties[]
59    @Test
60    public void testGetProperties() {
61        Client client = ClientBuilder.newClient();
62        client.register(JsrJsonpProvider.class);
63
64        WebTarget target = client.target(clusterUrl);
65        Response response = target.request().get();
66
67        assertEquals(200, response.getStatus(),
68            "Incorrect response code from " + clusterUrl);
69        response.close();
70    }
71    // end::testGetProperties[]
72
73}

  1// tag::copyright[]
  2/*******************************************************************************
  3 * Copyright (c) 2018, 2020 IBM Corporation and others.
  4 * All rights reserved. This program and the accompanying materials
  5 * are made available under the terms of the Eclipse Public License v1.0
  6 * which accompanies this distribution, and is available at
  7 * http://www.eclipse.org/legal/epl-v10.html
  8 *
  9 * Contributors:
 10 *     IBM Corporation - Initial implementation
 11 *******************************************************************************/
 12// end::copyright[]
 13package it.io.openliberty.guides.inventory;
 14
 15import static org.junit.jupiter.api.Assertions.assertEquals;
 16import static org.junit.jupiter.api.Assertions.assertTrue;
 17
 18import javax.json.JsonObject;
 19import javax.net.ssl.HostnameVerifier;
 20import javax.net.ssl.SSLSession;
 21import javax.ws.rs.client.Client;
 22import javax.ws.rs.client.ClientBuilder;
 23import javax.ws.rs.core.MediaType;
 24import javax.ws.rs.core.Response;
 25
 26import org.apache.cxf.jaxrs.provider.jsrjsonp.JsrJsonpProvider;
 27import org.junit.jupiter.api.AfterAll;
 28import org.junit.jupiter.api.BeforeAll;
 29import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
 30import org.junit.jupiter.api.Order;
 31import org.junit.jupiter.api.Test;
 32import org.junit.jupiter.api.TestMethodOrder;
 33
 34@TestMethodOrder(OrderAnnotation.class)
 35public class InventoryEndpointIT {
 36
 37    private static String invUrl;
 38    private static String sysUrl;
 39    private static String systemServiceIp;
 40
 41    private static Client client;
 42
 43    @BeforeAll
 44    public static void oneTimeSetup() {
 45
 46        String invServPort = System.getProperty("inventory.http.port");
 47        String sysServPort = System.getProperty("system.http.port");
 48
 49        // tag::systemServiceIp[]
 50        systemServiceIp = System.getProperty("system.ip");
 51        // end::systemServiceIp[]
 52
 53        invUrl = "http://localhost" + ":" + invServPort + "/inventory/systems/";
 54        sysUrl = "http://localhost" + ":" + sysServPort + "/system/properties/";
 55
 56        client = ClientBuilder.newBuilder().hostnameVerifier(new HostnameVerifier() {
 57            public boolean verify(String hostname, SSLSession session) {
 58                return true;
 59            }
 60        }).build();
 61
 62        client.register(JsrJsonpProvider.class);
 63        client.target(invUrl + "reset").request().post(null);
 64    }
 65
 66    @AfterAll
 67    public static void teardown() {
 68        client.close();
 69    }
 70
 71    // tag::tests[]
 72    // tag::testEmptyInventory[]
 73    @Test
 74    @Order(1)
 75    public void testEmptyInventory() {
 76        Response response = this.getResponse(invUrl);
 77        this.assertResponse(invUrl, response);
 78
 79        JsonObject obj = response.readEntity(JsonObject.class);
 80
 81        int expected = 0;
 82        int actual = obj.getInt("total");
 83        assertEquals(expected, actual,
 84                        "The inventory should be empty on application start but it wasn't");
 85
 86        response.close();
 87    }
 88    // end::testEmptyInventory[]
 89
 90    // tag::testHostRegistration[]
 91    @Test
 92    @Order(2)
 93    public void testHostRegistration() {
 94        this.visitSystemService();
 95
 96        Response response = this.getResponse(invUrl);
 97        this.assertResponse(invUrl, response);
 98
 99        JsonObject obj = response.readEntity(JsonObject.class);
100
101        int expected = 1;
102        int actual = obj.getInt("total");
103        assertEquals(expected, actual,
104                        "The inventory should have one entry for " + systemServiceIp);
105
106        boolean serviceExists = obj.getJsonArray("systems").getJsonObject(0)
107                        .get("hostname").toString().contains(systemServiceIp);
108        assertTrue(serviceExists,
109                        "A host was registered, but it was not " + systemServiceIp);
110
111        response.close();
112    }
113    // end::testHostRegistration[]
114
115    // tag::testSystemPropertiesMatch[]
116    @Test
117    @Order(3)
118    public void testSystemPropertiesMatch() {
119        Response invResponse = this.getResponse(invUrl);
120        Response sysResponse = this.getResponse(sysUrl);
121
122        this.assertResponse(invUrl, invResponse);
123        this.assertResponse(sysUrl, sysResponse);
124
125        JsonObject jsonFromInventory = (JsonObject) invResponse
126                        .readEntity(JsonObject.class).getJsonArray("systems")
127                        .getJsonObject(0).get("properties");
128
129        JsonObject jsonFromSystem = sysResponse.readEntity(JsonObject.class);
130
131        String osNameFromInventory = jsonFromInventory.getString("os.name");
132        String osNameFromSystem = jsonFromSystem.getString("os.name");
133        this.assertProperty("os.name", systemServiceIp, osNameFromSystem,
134                        osNameFromInventory);
135
136        String userNameFromInventory = jsonFromInventory.getString("user.name");
137        String userNameFromSystem = jsonFromSystem.getString("user.name");
138        this.assertProperty("user.name", systemServiceIp, userNameFromSystem,
139                        userNameFromInventory);
140
141        invResponse.close();
142        sysResponse.close();
143    }
144    // end::testSystemPropertiesMatch[]
145
146    // tag::testUnknownHost[]
147    @Test
148    @Order(4)
149    public void testUnknownHost() {
150        Response response = this.getResponse(invUrl);
151        this.assertResponse(invUrl, response);
152
153        Response badResponse = client.target(invUrl + "badhostname")
154                        .request(MediaType.APPLICATION_JSON).get();
155
156        String obj = badResponse.readEntity(String.class);
157
158        boolean isError = obj.contains("error");
159        assertTrue(isError,
160                        "badhostname is not a valid host but it didn't raise an error");
161
162        response.close();
163        badResponse.close();
164    }
165    // end::testUnknownHost[]
166    // end::tests[]
167
168    // Returns response information from the specified URL.
169    private Response getResponse(String url) {
170        return client.target(url).request().get();
171    }
172
173
174    // Asserts that the given URL has the correct response code of 200.
175    private void assertResponse(String url, Response response) {
176        assertEquals(200, response.getStatus(), "Incorrect response code from " + url);
177    }
178
179    // Asserts that the specified JVM system property is equivalent in both the
180    // system and inventory services.
181    private void assertProperty(String propertyName, String hostname, String expected,
182                    String actual) {
183        assertEquals(expected, actual, "JVM system property [" + propertyName + "] "
184                        + "in the system service does not match the one stored in "
185                        + "the inventory service for " + hostname);
186    }
187
188    // Makes a simple GET request to inventory/localhost.
189    private void visitSystemService() {
190        Response response = this.getResponse(sysUrl);
191        this.assertResponse(sysUrl, response);
192        response.close();
193
194        Response targetResponse = client.target(invUrl + systemServiceIp).request()
195                        .get();
196
197        targetResponse.close();
198    }
199}