Merge pull request #15 from exceptionless/testing

Added unit tests for services package

Author: pc9795

src/main/java/com/exceptionless/exceptionlessclient/models/services/EnvironmentInfo.java

@@ -11,19 +11,19 @@
 @NonFinal
 @EqualsAndHashCode(callSuper = true)
 public class EnvironmentInfo extends Model {
-  private int processorCount;
-  private long totalPhysicalMemory;
-  private long availablePhysicalMemory;
-  private String commandLine;
-  private String processName;
-  private String processId;
-  private long processMemorySize;
-  private String threadid;
-  private String architecture;
-  private String osName;
-  private String osVersion;
-  private String ipAddress;
-  private String machineName;
-  private String installId;
-  private String runtimeVersion;
+  Integer processorCount;
+  Long totalPhysicalMemory;
+  Long availablePhysicalMemory;
+  String commandLine;
+  String processName;
+  String processId;
+  Long processMemorySize;
+  String threadId;
+  String architecture;
+  String osName;
+  String osVersion;
+  String ipAddress;
+  String machineName;
+  String installId;
+  String runtimeVersion;
 }

src/main/java/com/exceptionless/exceptionlessclient/models/services/RequestInfo.java

@@ -1,11 +1,13 @@
 package com.exceptionless.exceptionlessclient.models.services;
 
 import com.exceptionless.exceptionlessclient.models.base.Model;
+import lombok.Builder;
 import lombok.EqualsAndHashCode;
 import lombok.Value;
 import lombok.experimental.NonFinal;
 import lombok.experimental.SuperBuilder;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -14,15 +16,19 @@
 @NonFinal
 @EqualsAndHashCode(callSuper = true)
 public class RequestInfo extends Model {
-  private String userAgent;
-  private String httpMethod;
-  private boolean isSecure;
-  private String host;
-  private int port;
-  private String path;
-  private String referrer;
-  private String clientIpAddress;
-  private Map<String, String> cookies;
-  private Object postData;
-  private Map<String, List<String>> queryString;
+  String userAgent;
+  String httpMethod;
+  Boolean secure;
+  String host;
+  Integer port;
+  String path;
+  String referrer;
+  String clientIpAddress;
+  @Builder.Default Map<String, String> cookies = new HashMap<>();
+  Object postData;
+  @Builder.Default Map<String, List<String>> queryString = new HashMap<>();
+
+  public Boolean isSecure() {
+    return secure;
+  }
 }

src/main/java/com/exceptionless/exceptionlessclient/services/DefaultEnvironmentInfoCollector.java

@@ -54,7 +54,7 @@ public EnvironmentInfo getEnvironmentInfo(EnvironmentInfoGetArgs args) {
             .processName(defaultEnvironmentInfo.getProcessName())
             .processId(defaultEnvironmentInfo.getProcessId())
             .processMemorySize(ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed())
-            .threadid(String.valueOf(Thread.currentThread().getId()))
+            .threadId(String.valueOf(Thread.currentThread().getId()))
             .architecture(defaultEnvironmentInfo.getArchitecture())
             .osName(defaultEnvironmentInfo.getOsName())
             .osVersion(defaultEnvironmentInfo.getOsVersion())

src/main/java/com/exceptionless/exceptionlessclient/services/DefaultRequestInfoCollector.java

@@ -24,8 +24,8 @@ public DefaultRequestInfoCollector() {}
   public RequestInfo getRequestInfo(HttpRequest request, RequestInfoGetArgs args) {
     RequestInfo.RequestInfoBuilder<?, ?> builder =
         RequestInfo.builder()
-            .userAgent(request.headers().firstValue("user-agent").orElse(null))
-            .isSecure(isSecure(request.uri()))
+            .userAgent(request.headers().firstValue("User-Agent").orElse(null))
+            .secure(isSecure(request.uri()))
             .httpMethod(request.method())
             .host(request.uri().getHost())
             .path(request.uri().getPath())
@@ -59,7 +59,7 @@ private <X> Map<String, X> filterExclusions(Map<String, X> map, Set<String> excl
     return map.entrySet().stream()
         .filter(
             entry ->
-                exclusions.stream().anyMatch(exclusion -> !Utils.match(entry.getKey(), exclusion)))
+                exclusions.stream().noneMatch(exclusion -> Utils.match(entry.getKey(), exclusion)))
         .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
   }
 

src/main/java/com/exceptionless/exceptionlessclient/services/EnvironmentInfoGetArgs.java

@@ -8,6 +8,14 @@
 @Value
 @NonFinal
 public class EnvironmentInfoGetArgs {
-  private boolean includeMachineName;
-  private boolean includeIpAddress;
+  @Builder.Default Boolean includeMachineName = false;
+  @Builder.Default Boolean includeIpAddress = false;
+
+  public Boolean isIncludeMachineName() {
+    return includeIpAddress;
+  }
+
+  public Boolean isIncludeIpAddress() {
+    return includeIpAddress;
+  }
 }

src/main/java/com/exceptionless/exceptionlessclient/services/RequestInfoGetArgs.java

@@ -4,15 +4,28 @@
 import lombok.Value;
 import lombok.experimental.NonFinal;
 
+import java.util.HashSet;
 import java.util.Set;
 
 @Builder
 @Value
 @NonFinal
 public class RequestInfoGetArgs {
-  private boolean includeIpAddress;
-  private boolean includeCookies;
-  private boolean includeQueryString;
-  private boolean includePostData;
-  private Set<String> exclusions;
+  @Builder.Default Boolean includeIpAddress = false;
+  @Builder.Default Boolean includeCookies = false;
+  @Builder.Default Boolean includeQueryString = false;
+  @Builder.Default Boolean includePostData = false;
+  @Builder.Default Set<String> exclusions = new HashSet<>();
+
+  public Boolean isIncludeIpAddress() {
+    return includeIpAddress;
+  }
+
+  public Boolean isIncludeCookies() {
+    return includeCookies;
+  }
+
+  public Boolean isIncludeQueryString() {
+    return includeQueryString;
+  }
 }

src/test/java/com/exceptionless/exceptionlessclient/services/DefaultEnvironmentInfoCollectorTest.java

@@ -0,0 +1,39 @@
+package com.exceptionless.exceptionlessclient.services;
+
+import com.exceptionless.exceptionlessclient.models.services.EnvironmentInfo;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultEnvironmentInfoCollectorTest {
+
+  @Test
+  public void itShouldNotIncludeMachineNameAndIpAddressUntilExplicitlyTold() {
+    EnvironmentInfo info =
+        DefaultEnvironmentInfoCollector.builder()
+            .build()
+            .getEnvironmentInfo(EnvironmentInfoGetArgs.builder().build());
+
+    assertThat(info.getMachineName()).isNull();
+    assertThat(info.getIpAddress()).isNull();
+
+    assertThat(info.getProcessorCount()).isNotNull();
+  }
+
+  @Test
+  public void itCanIncludeMachineNameAndIpAddress() {
+    EnvironmentInfo info =
+        DefaultEnvironmentInfoCollector.builder()
+            .build()
+            .getEnvironmentInfo(
+                EnvironmentInfoGetArgs.builder()
+                    .includeIpAddress(true)
+                    .includeMachineName(true)
+                    .build());
+
+    assertThat(info.getMachineName()).isNotNull();
+    assertThat(info.getIpAddress()).isNotNull();
+
+    assertThat(info.getProcessorCount()).isNotNull();
+  }
+}

src/test/java/com/exceptionless/exceptionlessclient/services/DefaultErrorParserTest.java

@@ -0,0 +1,19 @@
+package com.exceptionless.exceptionlessclient.services;
+
+import com.exceptionless.exceptionlessclient.models.services.error.Error;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultErrorParserTest {
+  @Test
+  public void itCanParseAnException() {
+    Error error = DefaultErrorParser.builder().build().parse(new RuntimeException("test"));
+
+    assertThat(error.getType()).isEqualTo("java.lang.RuntimeException");
+    assertThat(error.getMessage()).isEqualTo("test");
+    assertThat(error.getStackTrace()).isNotEmpty();
+    // dependent on test file name
+    assertThat(error.getStackTrace().get(0).getFilename()).isEqualTo("DefaultErrorParserTest.java");
+  }
+}

src/test/java/com/exceptionless/exceptionlessclient/services/DefaultModuleCollectorTest.java

@@ -0,0 +1,17 @@
+package com.exceptionless.exceptionlessclient.services;
+
+import com.exceptionless.exceptionlessclient.models.services.Module;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultModuleCollectorTest {
+  @Test
+  public void itCanGetModules() {
+    List<Module> modules = DefaultModuleCollector.builder().build().getModules();
+
+    assertThat(modules).isNotEmpty();
+  }
+}

src/test/java/com/exceptionless/exceptionlessclient/services/DefaultRequestInfoCollectorTest.java

@@ -0,0 +1,134 @@
+package com.exceptionless.exceptionlessclient.services;
+
+import com.exceptionless.exceptionlessclient.models.services.RequestInfo;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.net.URI;
+import java.net.http.HttpRequest;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultRequestInfoCollectorTest {
+  private DefaultRequestInfoCollector defaultRequestInfoCollector;
+
+  @BeforeEach
+  public void setup() {
+    defaultRequestInfoCollector = DefaultRequestInfoCollector.builder().build();
+  }
+
+  @Test
+  public void itCanGetARequestInfoFromAHttpRequest() {
+    HttpRequest httpRequest =
+        HttpRequest.newBuilder().uri(URI.create("http://localhost:5000/test-path")).GET().build();
+
+    RequestInfo requestInfo =
+        defaultRequestInfoCollector.getRequestInfo(
+            httpRequest, RequestInfoGetArgs.builder().build());
+
+    assertThat(requestInfo.getUserAgent()).isNull();
+    assertThat(requestInfo.isSecure()).isFalse();
+    assertThat(requestInfo.getHttpMethod()).isEqualTo("GET");
+    assertThat(requestInfo.getHost()).isEqualTo("localhost");
+    assertThat(requestInfo.getPath()).isEqualTo("/test-path");
+    assertThat(requestInfo.getPort()).isEqualTo(5000);
+  }
+
+  @Test
+  public void itCanGetAnUserAgentFromAHttpRequest() {
+    HttpRequest httpRequest =
+        HttpRequest.newBuilder()
+            .uri(URI.create("http://localhost:5000/test-path"))
+            .GET()
+            .header("User-Agent", "test-user-agent")
+            .build();
+
+    RequestInfo requestInfo =
+        defaultRequestInfoCollector.getRequestInfo(
+            httpRequest, RequestInfoGetArgs.builder().build());
+
+    assertThat(requestInfo.getUserAgent()).isEqualTo("test-user-agent");
+  }
+
+  @Test
+  public void itCanIdentifyASecuredUri() {
+    HttpRequest httpRequest =
+        HttpRequest.newBuilder().uri(URI.create("https://localhost:5000/test-path")).GET().build();
+
+    RequestInfo requestInfo =
+        defaultRequestInfoCollector.getRequestInfo(
+            httpRequest, RequestInfoGetArgs.builder().build());
+
+    assertThat(requestInfo.isSecure()).isTrue();
+  }
+
+  @Test
+  public void itShouldNotIncludeIpAddressCookiesQueryStringByDefault() {
+    HttpRequest httpRequest =
+        HttpRequest.newBuilder().uri(URI.create("https://localhost:5000/test-path")).GET().build();
+
+    RequestInfo requestInfo =
+        defaultRequestInfoCollector.getRequestInfo(
+            httpRequest, RequestInfoGetArgs.builder().build());
+
+    assertThat(requestInfo.getClientIpAddress()).isNull();
+    assertThat(requestInfo.getCookies()).isEmpty();
+    assertThat(requestInfo.getQueryString()).isEmpty();
+  }
+
+  @Test
+  public void itCanGetIpAddressCookiesAndQueryStringFromAHttpRequest() {
+    HttpRequest httpRequest =
+        HttpRequest.newBuilder()
+            .uri(URI.create("https://localhost:5000/test-path?query-param-key=query-param-value"))
+            .header("Cookie", "cookie1=value1;cookie2=value2")
+            .GET()
+            .build();
+
+    RequestInfo requestInfo =
+        defaultRequestInfoCollector.getRequestInfo(
+            httpRequest,
+            RequestInfoGetArgs.builder()
+                .includeCookies(true)
+                .includeIpAddress(true)
+                .includeQueryString(true)
+                .build());
+
+    assertThat(requestInfo.getClientIpAddress()).isNotNull();
+    assertThat(requestInfo.getCookies())
+        .isEqualTo(Map.of("cookie1", "value1", "cookie2", "value2"));
+    assertThat(requestInfo.getQueryString())
+        .isEqualTo(Map.of("query-param-key", List.of("query-param-value")));
+  }
+
+  @Test
+  public void itCanExcludeData() {
+    HttpRequest httpRequest =
+        HttpRequest.newBuilder()
+            .uri(
+                URI.create(
+                    "https://localhost:5000/test-path?query-param-key=query-param-value&exclude-query-param=exclude-value"))
+            .header("Cookie", "cookie1=value1;cookie2=value2;exclude-cookie=exclude-value")
+            .GET()
+            .build();
+
+    RequestInfo requestInfo =
+        defaultRequestInfoCollector.getRequestInfo(
+            httpRequest,
+            RequestInfoGetArgs.builder()
+                .includeCookies(true)
+                .includeIpAddress(true)
+                .includeQueryString(true)
+                .exclusions(Set.of("exclude-query-param", "exclude-cookie"))
+                .build());
+
+    assertThat(requestInfo.getClientIpAddress()).isNotNull();
+    assertThat(requestInfo.getCookies())
+        .isEqualTo(Map.of("cookie1", "value1", "cookie2", "value2"));
+    assertThat(requestInfo.getQueryString())
+        .isEqualTo(Map.of("query-param-key", List.of("query-param-value")));
+  }
+}