Merge branch 'master' into feature-asoc

Author: lpatino10

core/src/main/java/com/ibm/watson/developer_cloud/http/RequestBuilder.java

@@ -12,24 +12,28 @@
  */
 package com.ibm.watson.developer_cloud.http;
 
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
 import com.google.gson.JsonObject;
+import com.ibm.watson.developer_cloud.service.WatsonService;
+import com.ibm.watson.developer_cloud.util.GsonSingleton;
 import com.ibm.watson.developer_cloud.util.Validator;
+
 import okhttp3.FormBody;
 import okhttp3.HttpUrl;
 import okhttp3.MediaType;
 import okhttp3.Request;
 import okhttp3.RequestBody;
 
-import java.util.ArrayList;
-import java.util.List;
-
 /**
  * Convenience class for constructing HTTP/HTTPS requests.
  */
 public class RequestBuilder {
 
   private enum HTTPMethod {
-    DELETE, GET, POST, PUT
+    DELETE, GET, POST, PUT, PATCH
   }
 
   /**
@@ -55,8 +59,8 @@ public static RequestBuilder get(HttpUrl url) {
   }
 
   /**
-   * The POST request method is designed to request that a web server accept the data enclosed in the request message's
-   * body for storage. It is often used when uploading a file or submitting a completed web form.
+   * The POST request method is designed to request that a web server accept the data enclosed in the request
+   * message's body for storage. It is often used when uploading a file or submitting a completed web form.
    *
    * @param url the URL
    *
@@ -77,6 +81,17 @@ public static RequestBuilder put(HttpUrl url) {
     return new RequestBuilder(HTTPMethod.PUT, url);
   }
 
+  /**
+   * The PUT method requests that the enclosed entity be stored under the supplied Request-URI.
+   *
+   * @param url the URL
+   *
+   * @return this
+   */
+  public static RequestBuilder patch(HttpUrl url) {
+    return new RequestBuilder(HTTPMethod.PATCH, url);
+  }
+
   /**
    * Creates a properly encoded HttpUrl object with no path parameters.
    *
@@ -146,8 +161,8 @@ private RequestBuilder(HTTPMethod method, HttpUrl url) {
    *
    * @param params the parameters
    * @param name the parameter name
-   * @param value the value to set, will be obtained via {@link String#valueOf(boolean)}. If null, only the parameter is
-   *          set. It can also be a collection or array, in which case all elements are added as query parameters
+   * @param value the value to set, will be obtained via {@link String#valueOf(boolean)}. If null, only the parameter
+   * is set. It can also be a collection or array, in which case all elements are added as query parameters
    *
    * @return this
    */
@@ -221,8 +236,8 @@ public Request build() {
    */
   @Override
   public String toString() {
-    return "RequestBuilder [method=" + method + ", formParams=" + formParams + ", headers=" + headers + ", queryParams="
-        + queryParams + ", httpUrl=" + httpUrl.toString() + "]";
+    return "RequestBuilder [method=" + method + ", formParams=" + formParams + ", headers=" + headers
+        + ", queryParams=" + queryParams + ", httpUrl=" + httpUrl.toString() + "]";
   }
 
   /**
@@ -277,13 +292,52 @@ public RequestBuilder body(RequestBody body) {
    * @return this
    */
   public RequestBuilder bodyContent(String content, String contentType) {
-    body = RequestBody.create(MediaType.parse(contentType), content);
+    return body(RequestBody.create(MediaType.parse(contentType), content));
+  }
+
+  /**
+   * Sets the file content (InputStream) to the request (used with POST/PUT).
+   *
+   * @param stream the InputStream to read the request body content from
+   * @param contentType the contentType associated with the data read from the InputStream
+   * @return this
+   */
+  public RequestBuilder bodyContent(InputStream stream, String contentType) {
+    return body(InputStreamRequestBody.create(MediaType.parse(contentType), stream));
+  }
+
+  /**
+   * Sets the request body content from one of three different sources, based on the content type.
+   *
+   * @param contentType
+   *      the value of the "Content-Type" header associated with the outgoing request
+   * @param jsonContent
+   *      the body content to be used if the content type indicates JSON
+   * @param jsonPatchContent
+   *      the body content to be used if the content type indicates JsonPatch
+   * @param nonJsonContent
+   *      the body content to be used if the content type indicates non-JSON content
+   * @return this
+   */
+  public RequestBuilder bodyContent(String contentType, Object jsonContent, Object jsonPatchContent,
+    InputStream nonJsonContent) {
+    if (contentType != null) {
+      if (WatsonService.isJsonMimeType(contentType)) {
+        this.bodyContent(
+          GsonSingleton.getGson().toJsonTree(jsonContent).getAsJsonObject().toString(), contentType);
+      } else if (WatsonService.isJsonPatchMimeType(contentType)) {
+        this.bodyContent(
+          GsonSingleton.getGson().toJsonTree(jsonPatchContent).getAsJsonObject().toString(), contentType);
+      } else {
+        this.bodyContent(nonJsonContent, contentType);
+      }
+    }
     return this;
   }
 
   /**
-   * Adds a JSON content to the request (used with POST/PUT). This will encapsulate the json into a {@link RequestBody}
-   * encoded with UTF-8 and use {@code "application/json"} as Content-Type
+   * Adds a JSON content to the request (used with POST/PUT). This will encapsulate the json into a
+   * {@link RequestBody} encoded with UTF-8 and use {@code "application/json"} as Content-Type
    *
    * @param json the JsonObject json
    *
@@ -293,6 +347,19 @@ public RequestBuilder bodyJson(JsonObject json) {
     return bodyContent(json.toString(), HttpMediaType.APPLICATION_JSON);
   }
 
+  /**
+   * Adds a JSON content to the request (used with POST/PUT/PATCH). This will encapsulate the json into a
+   * {@link RequestBody} encoded with UTF-8 and use {@code "application/json"} as Content-Type
+   *
+   * @param json the JsonObject json
+   * @param mediaType the contentType value
+   *
+   * @return this
+   */
+  public RequestBuilder bodyJson(JsonObject json, String mediaType) {
+    return bodyContent(json.toString(), mediaType);
+  }
+
   /**
    * Adds form parameters.
    *

core/src/main/java/com/ibm/watson/developer_cloud/service/WatsonService.java

@@ -54,6 +54,7 @@
 import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.regex.Pattern;
 
 /**
  * Watson service abstract common functionality of various Watson Services. It handle authentication and default url.
@@ -70,6 +71,7 @@ public abstract class WatsonService {
   private static final String BASIC = "Basic ";
   private static final String BEARER = "Bearer ";
   private static final String APIKEY_AS_USERNAME = "apikey";
+  private static final String ICP_PREFIX = "icp-";
   private static final Logger LOG = Logger.getLogger(WatsonService.class.getName());
   private static final String AUTH_HEADER_DEPRECATION_MESSAGE = "Authenticating with the X-Watson-Authorization-Token"
       + "header is deprecated. The token continues to work with Cloud Foundry services, but is not supported for "
@@ -100,6 +102,13 @@ public abstract class WatsonService {
   /** The Constant VERSION. */
   protected static final String VERSION = "version";
 
+
+  // Regular expression for JSON-related mimetypes.
+  protected static final Pattern JSON_MIME_PATTERN =
+    Pattern.compile("(?i)application\\/((json)|(merge\\-patch\\+json))(;.*)?");
+  protected static final Pattern JSON_PATCH_MIME_PATTERN =
+    Pattern.compile("(?i)application\\/json\\-patch\\+json(;.*)?");
+
   /**
    * Instantiates a new Watson service.
    *
@@ -126,6 +135,26 @@ public WatsonService(final String name) {
     client = configureHttpClient();
   }
 
+  /**
+   * Returns true iff the specified mimeType indicates a JSON-related content type.
+   * (e.g. application/json, application/json-patch+json, application/merge-patch+json, etc.).
+   * @param mimeType the mimetype to consider
+   * @return true if the mimeType indicates a JSON-related content type
+   */
+  public static boolean isJsonMimeType(String mimeType) {
+    return mimeType != null && JSON_MIME_PATTERN.matcher(mimeType).matches();
+  }
+
+  /**
+   * Returns true iff the specified mimeType indicates a "Json Patch"-related content type.
+   * (e.g. application/json-patch+json)).
+   * @param mimeType the mimetype to consider
+   * @return true if the mimeType indicates a JSON-related content type
+   */
+  public static boolean isJsonPatchMimeType(String mimeType) {
+    return mimeType != null && JSON_PATCH_MIME_PATTERN.matcher(mimeType).matches();
+  }
+
   /**
    * Configure the {@link OkHttpClient}. This method will be called by the constructor and can be used to customize the
    * client that the service will use to perform the http calls.
@@ -350,7 +379,8 @@ public void setEndPoint(final String endPoint) {
    * @param password the password
    */
   public void setUsernameAndPassword(final String username, final String password) {
-    if (username.equals(APIKEY_AS_USERNAME)) {
+    // we'll perform the token exchange for users UNLESS they're on ICP
+    if (username.equals(APIKEY_AS_USERNAME) && !password.startsWith(ICP_PREFIX)) {
       IamOptions iamOptions = new IamOptions.Builder()
           .apiKey(password)
           .build();

core/src/main/java/com/ibm/watson/developer_cloud/util/StringHelper.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2017 IBM Corp. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package com.ibm.watson.developer_cloud.util;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+/**
+ * Helper class used by java code generated by the SDK codegen tool.
+ */
+public class StringHelper {
+
+    private StringHelper() {
+    }
+
+    /**
+     * Returns an InputStream that can be used to read the bytes of the specified String.
+     * @param s the String that will back the InputStream
+     * @return an InputStream to read the specified String
+     */
+    public static InputStream toInputStream(String s) {
+        // TODO - check to see if we need to be concerned with the encoding of the string!
+        return new ByteArrayInputStream(s.getBytes());
+    }
+}

core/src/test/java/com/ibm/watson/developer_cloud/service/AuthenticationTest.java

@@ -3,9 +3,12 @@
 import org.junit.Test;
 
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
 
 public class AuthenticationTest {
+  private static final String APIKEY_USERNAME = "apikey";
   private static final String APIKEY = "12345";
+  private static final String ICP_APIKEY = "icp-12345";
 
   public class TestService extends WatsonService {
     private static final String SERVICE_NAME = "test";
@@ -18,7 +21,14 @@ public TestService() {
   @Test
   public void authenticateWithApiKeyAsUsername() {
     TestService service = new TestService();
-    service.setUsernameAndPassword("apikey", APIKEY);
+    service.setUsernameAndPassword(APIKEY_USERNAME, APIKEY);
     assertTrue(service.isTokenManagerSet());
   }
+
+  @Test
+  public void authenticateWithIcp() {
+    TestService service = new TestService();
+    service.setUsernameAndPassword(APIKEY_USERNAME, ICP_APIKEY);
+    assertFalse(service.isTokenManagerSet());
+  }
 }

core/src/test/java/com/ibm/watson/developer_cloud/service/WatsonServiceTest.java

@@ -0,0 +1,50 @@
+/**
+ * Copyright 2018 IBM Corp. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package com.ibm.watson.developer_cloud.service;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Unit tests associated with the WatsonService core class.
+ *
+ */
+public class WatsonServiceTest {
+
+
+    @Test
+    public void testMimeTypes() {
+        assertTrue(WatsonService.isJsonMimeType("application/json"));
+        assertTrue(WatsonService.isJsonMimeType("application/json; charset=utf-8"));
+        assertTrue(WatsonService.isJsonMimeType("application/json;charset=utf-8"));
+        assertTrue(WatsonService.isJsonMimeType("APPLICATION/JSON;charset=utf-16"));
+        assertFalse(WatsonService.isJsonMimeType("application/notjson"));
+        assertFalse(WatsonService.isJsonMimeType("application/json-patch+json"));
+        assertFalse(WatsonService.isJsonMimeType("APPlication/JSON-patCH+jSoN;charset=utf-8"));
+        assertTrue(WatsonService.isJsonPatchMimeType("APPlication/JSON-patCH+jSoN;charset=utf-8"));
+        assertTrue(WatsonService.isJsonMimeType("application/merge-patch+json"));
+        assertTrue(WatsonService.isJsonMimeType("application/merge-patch+json;charset=utf-8"));
+        assertFalse(WatsonService.isJsonMimeType("application/json2-patch+json"));
+        assertFalse(WatsonService.isJsonMimeType("application/merge-patch+json-blah"));
+        assertFalse(WatsonService.isJsonMimeType("application/merge patch json"));
+
+        assertTrue(WatsonService.isJsonPatchMimeType("application/json-patch+json"));
+        assertTrue(WatsonService.isJsonPatchMimeType("application/json-patch+json;charset=utf-8"));
+        assertFalse(WatsonService.isJsonPatchMimeType("application/json"));
+        assertFalse(WatsonService.isJsonPatchMimeType("APPLICATION/JsOn; charset=utf-8"));
+        assertFalse(WatsonService.isJsonPatchMimeType("application/merge-patch+json"));
+        assertFalse(WatsonService.isJsonPatchMimeType("application/merge-patch+json;charset=utf-8"));
+    }
+}