merge release/v1.0.0 into feat/User

src/main/java/edu/group5/app/App.java

@@ -1,15 +1,24 @@
 package edu.group5.app;
 
+import java.util.HashMap;
+
 import edu.group5.app.control.OrgAPIWrapper;
+import tools.jackson.core.type.TypeReference;
+import tools.jackson.databind.ObjectMapper;
 
 /**
  * Hello world!
  */
 public class App {
-  public static void main(String[] args) {
+  public static void main(String[] args) throws InterruptedException {
     OrgAPIWrapper orgWrap = new OrgAPIWrapper("https://app.innsamlingskontrollen.no/api/public/v1/all");
     System.out.println();
     System.out.println();
     orgWrap.importData();
+    Object[] imports = orgWrap.getData();
+    ObjectMapper objectMapper = new ObjectMapper();
+    HashMap<String, Object> map = objectMapper.convertValue(imports[0], new TypeReference<HashMap<String, Object>>() {
+    });
+    System.out.println(map.get("org_number"));
   }
 }

src/main/java/edu/group5/app/control/OrgAPIWrapper.java

@@ -1,37 +1,49 @@
 package edu.group5.app.control;
 
+import java.io.IOException;
 import java.net.URI;
 import java.net.http.HttpClient;
 import java.net.http.HttpRequest;
 import java.net.http.HttpResponse;
 
+import tools.jackson.core.exc.StreamReadException;
 import tools.jackson.databind.ObjectMapper;
 
 public class OrgAPIWrapper extends Wrapper {
-  private String urlString;
   private Object[] data;
+  private HttpClient client;
+  private HttpRequest request;
 
   public OrgAPIWrapper(String urlString) {
-    this.urlString = urlString;
+    if (urlString == null) {
+      throw new IllegalArgumentException("url can't be null");
+    } else if (urlString.isBlank()) {
+      throw new IllegalArgumentException("url can't be blank");
+    }
+    try {
+      URI uri = URI.create(urlString);
+      this.client = HttpClient.newHttpClient();
+      this.request = HttpRequest.newBuilder()
+          .uri(uri)
+          .GET()
+          .build();
+    } catch (IllegalArgumentException IAe) {
+      throw new IllegalArgumentException("url has to be valid");
+    }
+
   }
 
   @Override
-  public boolean importData() {
-    URI uri = URI.create(this.urlString);
-    HttpClient client = HttpClient.newHttpClient();
-    HttpRequest request = HttpRequest.newBuilder()
-        .uri(uri)
-        .GET()
-        .build();
-
+  public boolean importData() throws InterruptedException {
     try {
-      HttpResponse<String> response = client.send(
-          request, HttpResponse.BodyHandlers.ofString());
+      HttpResponse<String> response = this.client.send(
+          this.request, HttpResponse.BodyHandlers.ofString());
       this.data = new ObjectMapper().readValue(response.body(), Object[].class);
       return true;
-    } catch (Exception e) {
-      e.printStackTrace();
+    } catch (IOException IOe) {
       return false;
+    } catch (StreamReadException e) {
+      throw new StreamReadException("The URL leads to a website that can't be parsed");
     }
   }
 

src/main/java/edu/group5/app/control/Wrapper.java

@@ -5,7 +5,7 @@ abstract class Wrapper {
   protected Wrapper() {
   }
 
-  public abstract boolean importData();
+  public abstract boolean importData() throws InterruptedException;
 
   public abstract Object getData();
 }

src/main/java/edu/group5/app/model/organization/Organization.java

@@ -5,14 +5,16 @@
 /**
  * Represents an organization.
  *
- * <p>An organization is identified by an organization number, a name,
+ * <p>
+ * An organization is identified by an organization number, a name,
  * trust status, website URL, pre-approval status, and a textual description.
  *
- * <p>Instances are validated on creation:
+ * <p>
+ * Instances are validated on creation:
  * <ul>
- *   <li>orgNumber must be non-negative</li>
- *   <li>name and websiteURL must not be null or blank</li>
- *   <li>description must not be null</li>
+ * <li>orgNumber must be non-negative</li>
+ * <li>name and websiteURL must not be null or blank</li>
+ * <li>description must not be null</li>
  * </ul>
  */
 public record Organization(
@@ -21,21 +23,24 @@ public record Organization(
     boolean trusted,
     String websiteURL,
     boolean isPreApproved,
-    String description
-) {
+    String description) {
   /**
    * Creates a new organization.
    *
-   * @param orgNumber the organization number; must be non-negative
-   * @param name the organization name; must not be null or blank
-   * @param trusted whether the organization is trusted
-   * @param websiteURL the organization's website URL; must not be null or blank
+   * @param orgNumber     the organization number; must be non-negative
+   * @param name          the organization name; must not be null or blank
+   * @param trusted       whether the organization is trusted
+   * @param websiteURL    the organization's website URL; must not be null or
+   *                      blank
    * @param isPreApproved whether the organization is pre-approved
-   * @param description a textual description of the organization; must not be null
-   * @throws NullPointerException if name, websiteURL or description is null
-   * @throws IllegalArgumentException if orgNumber is negative, or if name or websiteURL is blank
+   * @param description   a textual description of the organization; must not be
+   *                      null
+   * @throws NullPointerException     if name, websiteURL or description is null
+   * @throws IllegalArgumentException if orgNumber is negative, or if name or
+   *                                  websiteURL is blank
    */
-  public Organization(int orgNumber, String name, boolean trusted, String websiteURL, boolean isPreApproved, String description) {
+  public Organization(int orgNumber, String name, boolean trusted, String websiteURL, boolean isPreApproved,
+      String description) {
     if (orgNumber < 0) {
       throw new IllegalArgumentException("orgNumber cannot be negative");
     }

src/test/java/edu/group5/app/control/OrgAPIWrapperTest.java

@@ -0,0 +1,74 @@
+package edu.group5.app.control;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import tools.jackson.core.exc.StreamReadException;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.lang.IllegalArgumentException;
+
+public class OrgAPIWrapperTest {
+  String testURL;
+  String wrongURL;
+  String wrongURL2;
+
+  @BeforeEach
+  void init() {
+    this.testURL = "https://app.innsamlingskontrollen.no/api/public/v1/all";
+    this.wrongURL = "This is not a URL";
+    this.wrongURL2 = "https://www.google.com";
+  }
+
+  @Test
+  public void nullURLThrowsException() {
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> new OrgAPIWrapper(null));
+    assertEquals("url can't be null", exception.getMessage());
+  }
+
+  @Test
+  public void emptyURLThrowsException() {
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> new OrgAPIWrapper(""));
+    assertEquals("url can't be blank", exception.getMessage());
+  }
+
+  @Test
+  public void faultyURLThrowsException() {
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> new OrgAPIWrapper(this.wrongURL));
+    assertEquals("url has to be valid", exception.getMessage());
+  }
+
+  // @Test
+  // public void noConnectionReturnsFalseImport() {
+  // assertDoesNotThrow(() -> {
+  // OrgAPIWrapper api = new OrgAPIWrapper(this.testURL);
+  // assertFalse(api.importData());
+  // });
+  // }
+
+  @Test
+  public void importsNonEmptyData() {
+    assertDoesNotThrow(() -> {
+      OrgAPIWrapper api = new OrgAPIWrapper(testURL);
+      assertTrue(api.importData());
+      assertFalse(api.getData().length == 0);
+    });
+  }
+
+  @Test
+  public void nonParseableSiteThrowsExceptionWhenImporting() {
+    assertDoesNotThrow(() -> {
+      OrgAPIWrapper api = new OrgAPIWrapper(this.wrongURL2);
+      StreamReadException exception = assertThrows(StreamReadException.class, () -> api.importData());
+      assertEquals("The URL leads to a website that can't be parsed", exception.getMessage());
+    });
+  }
+
+}