Adding health reports to microservices

 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 jakarta.json.JsonArray;
 19import jakarta.json.JsonObject;
 20import jakarta.ws.rs.client.Client;
 21import jakarta.ws.rs.client.ClientBuilder;
 22import jakarta.ws.rs.core.MediaType;
 23import jakarta.ws.rs.core.Response;
 24
 25import org.junit.jupiter.api.AfterEach;
 26import org.junit.jupiter.api.BeforeAll;
 27import org.junit.jupiter.api.BeforeEach;
 28import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
 29import org.junit.jupiter.api.Order;
 30import org.junit.jupiter.api.Test;
 31import org.junit.jupiter.api.TestMethodOrder;
 32
 33@TestMethodOrder(OrderAnnotation.class)
 34public class InventoryEndpointIT {
 35
 36  private static String port;
 37  private static String baseUrl;
 38
 39  private Client client;
 40
 41  private final String SYSTEM_PROPERTIES = "system/properties";
 42  private final String INVENTORY_SYSTEMS = "inventory/systems";
 43
 44  @BeforeAll
 45  public static void oneTimeSetup() {
 46    port = System.getProperty("http.port");
 47    baseUrl = "http://localhost:" + port + "/";
 48  }
 49
 50  @BeforeEach
 51  public void setup() {
 52    client = ClientBuilder.newClient();
 53  }
 54
 55  @AfterEach
 56  public void teardown() {
 57    client.close();
 58  }
 59
 61  @Test
 62  @Order(1)
 64  public void testHostRegistration() {
 65    this.visitLocalhost();
 66
 67    Response response = this.getResponse(baseUrl + INVENTORY_SYSTEMS);
 68    this.assertResponse(baseUrl, response);
 69
 70    JsonObject obj = response.readEntity(JsonObject.class);
 71
 72    JsonArray systems = obj.getJsonArray("systems");
 73
 74    boolean localhostExists = false;
 75    for (int n = 0; n < systems.size(); n++) {
 76      localhostExists = systems.getJsonObject(n).get("hostname").toString()
 77          .contains("localhost");
 78      if (localhostExists) {
 79        break;
 80      }
 81    }
 82    assertTrue(localhostExists, "A host was registered, but it was not localhost");
 83
 84    response.close();
 85  }
 87
 88  @Test
 89  @Order(2)
 91  public void testSystemPropertiesMatch() {
 92    Response invResponse = this.getResponse(baseUrl + INVENTORY_SYSTEMS);
 93    Response sysResponse = this.getResponse(baseUrl + SYSTEM_PROPERTIES);
 94
 95    this.assertResponse(baseUrl, invResponse);
 96    this.assertResponse(baseUrl, sysResponse);
 97
 98    JsonObject jsonFromInventory = (JsonObject) invResponse.readEntity(JsonObject.class)
 99                                                           .getJsonArray("systems")
100                                                           .getJsonObject(0)
101                                                           .get("properties");
102
103    JsonObject jsonFromSystem = sysResponse.readEntity(JsonObject.class);
104
105    String osNameFromInventory = jsonFromInventory.getString("os.name");
106    String osNameFromSystem = jsonFromSystem.getString("os.name");
107    this.assertProperty("os.name", "localhost", osNameFromSystem,
108                        osNameFromInventory);
109
110    String userNameFromInventory = jsonFromInventory.getString("user.name");
111    String userNameFromSystem = jsonFromSystem.getString("user.name");
112    this.assertProperty("user.name", "localhost", userNameFromSystem,
113                        userNameFromInventory);
114
115    invResponse.close();
116    sysResponse.close();
117  }
119
120  @Test
121  @Order(3)
123  public void testUnknownHost() {
124    Response response = this.getResponse(baseUrl + INVENTORY_SYSTEMS);
125    this.assertResponse(baseUrl, response);
126
127    Response badResponse = client.target(baseUrl + INVENTORY_SYSTEMS + "/"
128        + "badhostname").request(MediaType.APPLICATION_JSON).get();
129
130    String obj = badResponse.readEntity(String.class);
131
132    boolean isError = obj.contains("error");
133    assertTrue(isError,
134        "badhostname is not a valid host but it didn't raise an error");
135
136    response.close();
137    badResponse.close();
138  }
139
144  /**
145   * <p>
146   * Returns response information from the specified URL.
147   * </p>
148   *
149   * @param url
150   *          - target URL.
151   * @return Response object with the response from the specified URL.
152   */
154  private Response getResponse(String url) {
155    return client.target(url).request().get();
156  }
157
159  /**
160   * <p>
161   * Asserts that the given URL has the correct response code of 200.
162   * </p>
163   *
164   * @param url
165   *          - target URL.
166   * @param response
167   *          - response received from the target URL.
168   */
170  private void assertResponse(String url, Response response) {
171    assertEquals(200, response.getStatus(), "Incorrect response code from " + url);
172  }
173
175  /**
176   * Asserts that the specified JVM system property is equivalent in both the
177   * system and inventory services.
178   *
179   * @param propertyName
180   *          - name of the system property to check.
181   * @param hostname
182   *          - name of JVM's host.
183   * @param expected
184   *          - expected name.
185   * @param actual
186   *          - actual name.
187   */
189  private void assertProperty(String propertyName, String hostname,
190      String expected, String actual) {
191    assertEquals(expected, actual, "JVM system property [" + propertyName + "] "
192        + "in the system service does not match the one stored in "
193        + "the inventory service for " + hostname);
194  }
195
197  /**
198   * Makes a simple GET request to inventory/localhost.
199   */
201  private void visitLocalhost() {
202    Response response = this.getResponse(baseUrl + SYSTEM_PROPERTIES);
203    this.assertResponse(baseUrl, response);
204    response.close();
205
206    Response targetResponse = client.target(baseUrl + INVENTORY_SYSTEMS
207        + "/localhost").request().get();
208    targetResponse.close();
209  }
211}
213

12package it.io.openliberty.guides.system;
13
14import static org.junit.jupiter.api.Assertions.assertEquals;
15
16import jakarta.json.JsonObject;
17import jakarta.ws.rs.client.Client;
18import jakarta.ws.rs.client.ClientBuilder;
19import jakarta.ws.rs.client.WebTarget;
20import jakarta.ws.rs.core.Response;
21
22import org.junit.jupiter.api.Test;
23
24public class SystemEndpointIT {
25
26  @Test
27  public void testGetProperties() {
28    String port = System.getProperty("http.port");
29    String url = "http://localhost:" + port + "/";
30
31    Client client = ClientBuilder.newClient();
32
33    WebTarget target = client.target(url + "system/properties");
34    Response response = target.request().get();
35
36    assertEquals(200, response.getStatus(), "Incorrect response code from " + url);
37
38    JsonObject obj = response.readEntity(JsonObject.class);
39
40    assertEquals(System.getProperty("os.name"), obj.getString("os.name"),
41        "The system property for the local and remote JVM should match");
42
43    response.close();
44    client.close();
45  }
46}47