docs: documentation, test, and some model changes

Author: dpopp07

assistant/v1.ts

@@ -5336,8 +5336,9 @@ namespace AssistantV1 {
     message_to_human_agent?: string;
     /** The text of the search query. This can be either a natural-language query or a query that uses the Discovery
      *  query language syntax, depending on the value of the **query_type** property. For more information, see the
-     *  [Discovery service documentation](https://cloud.ibm.com/docs/discovery?topic=discovery-query-operators#query-operators).
-     *  Required when **response_type**=`search_skill`.
+     *  [Discovery service
+     *  documentation](https://cloud.ibm.com/docs/discovery?topic=discovery-query-operators#query-operators). Required
+     *  when **response_type**=`search_skill`.
      */
     query?: string;
     /** The type of the search query. Required when **response_type**=`search_skill`. */
@@ -5662,6 +5663,25 @@ namespace AssistantV1 {
   export interface MessageInput {
     /** The text of the user input. This string cannot contain carriage return, newline, or tab characters. */
     text?: string;
+    /** Whether to use spelling correction when processing the input. This property overrides the value of the
+     *  **spelling_suggestions** property in the workspace settings.
+     */
+    spelling_suggestions?: boolean;
+    /** Whether to use autocorrection when processing the input. If spelling correction is used and this property is
+     *  `false`, any suggested corrections are returned in the **suggested_text** property of the message response. If
+     *  this property is `true`, any corrections are automatically applied to the user input, and the original text is
+     *  returned in the **original_text** property of the message response. This property overrides the value of the
+     *  **spelling_auto_correct** property in the workspace settings.
+     */
+    spelling_auto_correct?: boolean;
+    /** Any suggested corrections of the input text. This property is returned only if spelling correction is
+     *  enabled and autocorrection is disabled.
+     */
+    suggested_text?: string;
+    /** The original user input text. This property is returned only if autocorrection is enabled and the user input
+     *  was corrected.
+     */
+    original_text?: string;
     /** MessageInput accepts additional properties. */
     [propName: string]: any;
   }
@@ -6073,6 +6093,14 @@ namespace AssistantV1 {
     disambiguation?: WorkspaceSystemSettingsDisambiguation;
     /** For internal use only. */
     human_agent_assist?: JsonObject;
+    /** Whether spelling correction is enabled for the workspace. */
+    spelling_suggestions?: boolean;
+    /** Whether autocorrection is enabled for the workspace. If spelling correction is enabled and this property is
+     *  `false`, any suggested corrections are returned in the **suggested_text** property of the message response. If
+     *  this property is `true`, any corrections are automatically applied to the user input, and the original text is
+     *  returned in the **original_text** property of the message response.
+     */
+    spelling_auto_correct?: boolean;
     /** Workspace settings related to the behavior of system entities. */
     system_entities?: WorkspaceSystemSettingsSystemEntities;
     /** Workspace settings related to detection of irrelevant input. */

discovery/v2.ts

@@ -689,6 +689,9 @@ class DiscoveryV2 extends BaseService {
    * **Note:** This operation only works on collections created to accept direct file uploads. It cannot be used to
    * modify a collection that connects to an external source such as Microsoft SharePoint.
    *
+   * **Note:** If an uploaded document is segmented, all segments will be overwritten, even if the updated version of
+   * the document has fewer segments.
+   *
    * @param {Object} params - The parameters to send to the service.
    * @param {string} params.projectId - The ID of the project. This information can be found from the deploy page of the
    * Discovery administrative tooling.
@@ -785,6 +788,9 @@ class DiscoveryV2 extends BaseService {
    * **Note:** This operation only works on collections created to accept direct file uploads. It cannot be used to
    * modify a collection that connects to an external source such as Microsoft SharePoint.
    *
+   * **Note:** Segments of an uploaded document cannot be deleted individually. Delete all segments by deleting using
+   * the `parent_document_id` of a segment result.
+   *
    * @param {Object} params - The parameters to send to the service.
    * @param {string} params.projectId - The ID of the project. This information can be found from the deploy page of the
    * Discovery administrative tooling.

natural-language-understanding/v1.ts

@@ -744,6 +744,10 @@ namespace NaturalLanguageUnderstandingV1 {
     /** ID of the Watson Knowledge Studio workspace that deployed this model to Natural Language Understanding. */
     workspace_id?: string;
     /** The model version, if it was manually provided in Watson Knowledge Studio. */
+    model_version?: string;
+    /** (Deprecated — use `model_version`) The model version, if it was manually provided in Watson Knowledge
+     *  Studio.
+     */
     version?: string;
     /** The description of the version, if it was manually provided in Watson Knowledge Studio. */
     version_description?: string;

secrets.tar.enc

@@ -84,6 +84,20 @@ describe('assistant v2 integration', () => {
       });
   });
 
+  it('should messageStateless', done => {
+    const params = {
+      assistantId,
+      input: { text: 'Hello' },
+    };
+
+    assistant.messageStateless(params, (err, res) => {
+      expect(err).toBeNull();
+      const { result } = res || {};
+      expect(result).toBeDefined();
+      done();
+    });
+  });
+
   it('should deleteSession', done => {
     if (!sessionId) {
       // We cannot run this test when session creation failed.

test/integration/assistant.v2.test.js

@@ -29,7 +29,7 @@ describe('visual recognition v4 integration', () => {
   const visualRecognition = new VisualRecognitionV4(options);
 
   // testing collections
-  const { giraffesCollectionId } = options;
+  const { testCollectionId } = options;
 
   let collectionId;
   let imageId;
@@ -40,7 +40,7 @@ describe('visual recognition v4 integration', () => {
   describe('analysis', () => {
     test('analyze', async done => {
       const params = {
-        collectionIds: [giraffesCollectionId],
+        collectionIds: [testCollectionId],
         features: 'objects',
         imagesFile: [{ data: fs.createReadStream(__dirname + '/../resources/potato.jpeg') }],
       };
@@ -58,6 +58,27 @@ describe('visual recognition v4 integration', () => {
       expect(result.images).toBeDefined();
       done();
     });
+
+    test('getModelFile', async done => {
+      const params = {
+        collectionId: testCollectionId,
+        feature: 'objects',
+        modelFormat: 'rscnn',
+      };
+
+      let res;
+      try {
+        res = await visualRecognition.getModelFile(params);
+      } catch (err) {
+        return done(err);
+      }
+
+      expect(res).toBeDefined();
+      const { result } = res || {};
+      expect(result).toBeDefined();
+      expect(isStream(result)).toBe(true);
+      done();
+    });
   });
 
   describe('collections', () => {

test/integration/visual-recognition.v4.test.js

@@ -279,4 +279,84 @@ describe('AssistantV2', () => {
       });
     });
   });
+  describe('messageStateless', () => {
+    describe('positive tests', () => {
+      test('should pass the right params to createRequest', () => {
+        // parameters
+        const assistantId = 'fake_assistantId';
+        const input = 'fake_input';
+        const context = 'fake_context';
+        const params = {
+          assistantId,
+          input,
+          context,
+        };
+
+        const messageStatelessResult = assistant.messageStateless(params);
+
+        // all methods should return a Promise
+        expectToBePromise(messageStatelessResult);
+
+        // assert that create request was called
+        expect(createRequestMock).toHaveBeenCalledTimes(1);
+
+        const options = getOptions(createRequestMock);
+
+        checkUrlAndMethod(options, '/v2/assistants/{assistant_id}/message', 'POST');
+        const expectedAccept = 'application/json';
+        const expectedContentType = 'application/json';
+        checkMediaHeaders(createRequestMock, expectedAccept, expectedContentType);
+        expect(options.body['input']).toEqual(input);
+        expect(options.body['context']).toEqual(context);
+        expect(options.path['assistant_id']).toEqual(assistantId);
+      });
+
+      test('should prioritize user-given headers', () => {
+        // parameters
+        const assistantId = 'fake_assistantId';
+        const userAccept = 'fake/header';
+        const userContentType = 'fake/header';
+        const params = {
+          assistantId,
+          headers: {
+            Accept: userAccept,
+            'Content-Type': userContentType,
+          },
+        };
+
+        assistant.messageStateless(params);
+        checkMediaHeaders(createRequestMock, userAccept, userContentType);
+      });
+    });
+
+    describe('negative tests', () => {
+      test('should enforce required parameters', async done => {
+        // required parameters for this method
+        const requiredParams = ['assistantId'];
+
+        let err;
+        try {
+          await assistant.messageStateless({});
+        } catch (e) {
+          err = e;
+        }
+
+        expect(err.message).toMatch(/Missing required parameters/);
+        done();
+      });
+
+      test('should reject promise when required params are not given', done => {
+        // required parameters for this method
+        const requiredParams = ['assistantId'];
+
+        const messageStatelessPromise = assistant.messageStateless();
+        expectToBePromise(messageStatelessPromise);
+
+        messageStatelessPromise.catch(err => {
+          expect(err.message).toMatch(/Missing required parameters/);
+          done();
+        });
+      });
+    });
+  });
 });

test/unit/assistant.v2.test.js

@@ -3,7 +3,7 @@
 const Authorization = require('../../dist/authorization/v1');
 const { BasicAuthenticator, IamAuthenticator } = require('ibm-cloud-sdk-core');
 
-describe('authorization', function () {
+describe('authorization', function() {
   const url = 'http://ibm.com:80/text-to-speech-beta/api/foo/bar';
   const service = {
     url,
@@ -30,38 +30,38 @@ describe('authorization', function () {
   createRequestMock.mockImplementation(params => Promise.resolve(mockToken));
 
   function missingParameter(done) {
-    return function (err) {
+    return function(err) {
       expect(err).toBeInstanceOf(Error);
       expect(/required parameters/.test(err)).toBe(true);
       done();
     };
   }
 
   function checkToken(done) {
-    return function (err, res) {
+    return function(err, res) {
       expect(err).toBeNull();
       expect(res).toBe(mockToken);
       done();
     };
   }
 
-  describe('getToken()', function () {
-    it('should check for missing url param', function (done) {
+  describe('getToken()', function() {
+    it('should check for missing url param', function(done) {
       const params = {
         noturl: url,
       };
       authorization.getToken(params, missingParameter(done));
     });
 
-    it('should generate a valid token payload', function (done) {
+    it('should generate a valid token payload', function(done) {
       authorization.getToken({ url: 'http://ibm.com/myservice/myresource' }, checkToken(done));
     });
 
-    it('should default to url from credentials', function (done) {
+    it('should default to url from credentials', function(done) {
       authorization.getToken(checkToken(done));
     });
 
-    it('should return an iam access token if given iam_api_key', function (done) {
+    it('should return an iam access token if given iam_api_key', function(done) {
       expect(authorizationIam.tokenManager).not.toBeNull();
 
       // mock the token manager request method

test/unit/authorization.test.js

@@ -468,6 +468,91 @@ describe('VisualRecognitionV4', () => {
       });
     });
   });
+  describe('getModelFile', () => {
+    describe('positive tests', () => {
+      test('should pass the right params to createRequest', () => {
+        // parameters
+        const collectionId = 'fake_collectionId';
+        const feature = 'fake_feature';
+        const modelFormat = 'fake_modelFormat';
+        const params = {
+          collectionId,
+          feature,
+          modelFormat,
+        };
+
+        const getModelFileResult = visualRecognition.getModelFile(params);
+
+        // all methods should return a Promise
+        expectToBePromise(getModelFileResult);
+
+        // assert that create request was called
+        expect(createRequestMock).toHaveBeenCalledTimes(1);
+
+        const options = getOptions(createRequestMock);
+
+        checkUrlAndMethod(options, '/v4/collections/{collection_id}/model', 'GET');
+        const expectedAccept = 'application/octet-stream';
+        const expectedContentType = undefined;
+        checkMediaHeaders(createRequestMock, expectedAccept, expectedContentType);
+        expect(options.qs['feature']).toEqual(feature);
+        expect(options.qs['model_format']).toEqual(modelFormat);
+        expect(options.path['collection_id']).toEqual(collectionId);
+        expect(options.responseType).toBe('stream');
+      });
+
+      test('should prioritize user-given headers', () => {
+        // parameters
+        const collectionId = 'fake_collectionId';
+        const feature = 'fake_feature';
+        const modelFormat = 'fake_modelFormat';
+        const userAccept = 'fake/header';
+        const userContentType = 'fake/header';
+        const params = {
+          collectionId,
+          feature,
+          modelFormat,
+          headers: {
+            Accept: userAccept,
+            'Content-Type': userContentType,
+          },
+        };
+
+        visualRecognition.getModelFile(params);
+        checkMediaHeaders(createRequestMock, userAccept, userContentType);
+      });
+    });
+
+    describe('negative tests', () => {
+      test('should enforce required parameters', async done => {
+        // required parameters for this method
+        const requiredParams = ['collectionId', 'feature', 'modelFormat'];
+
+        let err;
+        try {
+          await visualRecognition.getModelFile({});
+        } catch (e) {
+          err = e;
+        }
+
+        expect(err.message).toMatch(/Missing required parameters/);
+        done();
+      });
+
+      test('should reject promise when required params are not given', done => {
+        // required parameters for this method
+        const requiredParams = ['collectionId', 'feature', 'modelFormat'];
+
+        const getModelFilePromise = visualRecognition.getModelFile();
+        expectToBePromise(getModelFilePromise);
+
+        getModelFilePromise.catch(err => {
+          expect(err.message).toMatch(/Missing required parameters/);
+          done();
+        });
+      });
+    });
+  });
   describe('addImages', () => {
     describe('positive tests', () => {
       test('should pass the right params to createRequest', () => {