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
 57        client = ClientBuilder.newBuilder().hostnameVerifier(new HostnameVerifier() {
 58            public boolean verify(String hostname, SSLSession session) {
 59                return true;
 60            }
 61        }).build();
 62
 63        client.register(JsrJsonpProvider.class);
 64        client.target(invUrl + "reset").request().post(null);
 65    }
 66
 67    @AfterAll
 68    public static void teardown() {
 69        client.close();
 70    }
 71
 72    // tag::tests[]
 73    // tag::testEmptyInventory[]
 74    @Test
 75    @Order(1)
 76    public void testEmptyInventory() {
 77        Response response = this.getResponse(invUrl);
 78        this.assertResponse(invUrl, response);
 79
 80        JsonObject obj = response.readEntity(JsonObject.class);
 81
 82        int expected = 0;
 83        int actual = obj.getInt("total");
 84        assertEquals(expected, actual,
 85                        "The inventory should be empty on application start but it wasn't");
 86
 87        response.close();
 88    }
 89    // end::testEmptyInventory[]
 90
 91    // tag::testHostRegistration[]
 92    @Test
 93    @Order(2)
 94    public void testHostRegistration() {
 95        this.visitSystemService();
 96
 97        Response response = this.getResponse(invUrl);
 98        this.assertResponse(invUrl, response);
 99
100        JsonObject obj = response.readEntity(JsonObject.class);
101
102        int expected = 1;
103        int actual = obj.getInt("total");
104        assertEquals(expected, actual,
105                        "The inventory should have one entry for " + systemServiceIp);
106
107        boolean serviceExists = obj.getJsonArray("systems").getJsonObject(0)
108                        .get("hostname").toString().contains(systemServiceIp);
109        assertTrue(serviceExists,
110                        "A host was registered, but it was not " + systemServiceIp);
111
112        response.close();
113    }
114    // end::testHostRegistration[]
115
116    // tag::testSystemPropertiesMatch[]
117    @Test
118    @Order(3)
119    public void testSystemPropertiesMatch() {
120        Response invResponse = this.getResponse(invUrl);
121        Response sysResponse = this.getResponse(sysUrl);
122
123        this.assertResponse(invUrl, invResponse);
124        this.assertResponse(sysUrl, sysResponse);
125
126        JsonObject jsonFromInventory = (JsonObject) invResponse
127                        .readEntity(JsonObject.class).getJsonArray("systems")
128                        .getJsonObject(0).get("properties");
129
130        JsonObject jsonFromSystem = sysResponse.readEntity(JsonObject.class);
131
132        String osNameFromInventory = jsonFromInventory.getString("os.name");
133        String osNameFromSystem = jsonFromSystem.getString("os.name");
134        this.assertProperty("os.name", systemServiceIp, osNameFromSystem,
135                        osNameFromInventory);
136
137        String userNameFromInventory = jsonFromInventory.getString("user.name");
138        String userNameFromSystem = jsonFromSystem.getString("user.name");
139        this.assertProperty("user.name", systemServiceIp, userNameFromSystem,
140                        userNameFromInventory);
141
142        invResponse.close();
143        sysResponse.close();
144    }
145    // end::testSystemPropertiesMatch[]
146
147    // tag::testUnknownHost[]
148    @Test
149    @Order(4)
150    public void testUnknownHost() {
151        Response response = this.getResponse(invUrl);
152        this.assertResponse(invUrl, response);
153
154        Response badResponse = client.target(invUrl + "badhostname")
155                        .request(MediaType.APPLICATION_JSON).get();
156
157        String obj = badResponse.readEntity(String.class);
158
159        boolean isError = obj.contains("ERROR");
160        assertTrue(isError,
161                        "badhostname is not a valid host but it didn't raise an error");
162
163        response.close();
164        badResponse.close();
165    }
166    // end::testUnknownHost[]
167    // end::tests[]
168
169    // Returns response information from the specified URL.
170    private Response getResponse(String url) {
171        return client.target(url).request().get();
172    }
173
174
175    // Asserts that the given URL has the correct response code of 200.
176    private void assertResponse(String url, Response response) {
177        assertEquals(200, response.getStatus(), "Incorrect response code from " + url);
178    }
179
180    // Asserts that the specified JVM system property is equivalent in both the
181    // system and inventory services.
182    private void assertProperty(String propertyName, String hostname, String expected,
183                    String actual) {
184        assertEquals(expected, actual, "JVM system property [" + propertyName + "] "
185                        + "in the system service does not match the one stored in "
186                        + "the inventory service for " + hostname);
187    }
188
189    // Makes a simple GET request to inventory/localhost.
190    private void visitSystemService() {
191        Response response = this.getResponse(sysUrl);
192        this.assertResponse(sysUrl, response);
193        response.close();
194
195        Response targetResponse = client.target(invUrl + systemServiceIp).request()
196                        .get();
197
198        targetResponse.close();
199    }
200}