Containerizing microservices

 1// tag::copyright[]
 2/*******************************************************************************
 3 * Copyright (c) 2018, 2019 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.Assert.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.core.Response;
22
23import org.junit.After;
24import org.junit.Before;
25import org.junit.BeforeClass;
26import org.junit.Test;
27
28import javax.ws.rs.client.WebTarget;
29import org.apache.cxf.jaxrs.provider.jsrjsonp.JsrJsonpProvider;
30
31public class SystemEndpointTest {
32
33    private static String url;
34
35    private Client client;
36    private Response response;
37
38    @BeforeClass
39    public static void oneTimeSetup() {
40        String port = System.getProperty("sys.http.port");
41        url = "http://localhost:" + port + "/system/properties/";
42    }
43
44    @Before
45    public void setup() {
46        response = null;
47        client = ClientBuilder.newBuilder()
48                    .hostnameVerifier(new HostnameVerifier() {
49                        public boolean verify(String hostname, SSLSession session) {
50                            return true;
51                        }
52                    })
53                    .build();
54    }
55
56    @After
57    public void teardown() {
58        client.close();
59    }
60
61    @Test
62    // tag::testGetProperties[]
63    public void testGetProperties() {
64        Client client = ClientBuilder.newClient();
65        client.register(JsrJsonpProvider.class);
66
67        WebTarget target = client.target(url);
68        Response response = target.request().get();
69
70        assertEquals("Incorrect response code from " + url, 200, response.getStatus());
71        response.close();
72    }
73    // end::testGetProperties[]
74
75}

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