ibm_watson 1.0.0.rc3 → 1.0.0

data/test/integration/test_discovery_v1.rb

@@ -104,7 +104,7 @@ if !ENV["DISCOVERY_APIKEY"].nil? && !ENV["DISCOVERY_URL"].nil?
 
       fields = @service.list_fields(
         environment_id: @environment_id,
-        collection_ids: [new_collection_id]
+        collection_ids: [new_collection_id, @collection_id]
       )
       refute(fields.nil?)
 

data/test/integration/test_speech_to_text_v1.rb

@@ -80,7 +80,7 @@ if !ENV["SPEECH_TO_TEXT_APIKEY"].nil? && !ENV["SPEECH_TO_TEXT_URL"].nil?
           content_type: "audio/l16; rate=44100",
           timestamps: true,
           word_alternatives_threshold: 0.9,
-          keywords: %w"[colorado tornado]",
+          keywords: %w[colorado tornado],
           keywords_threshold: 0.5
         )
         refute_nil(output.result["results"][0]["alternatives"][0]["transcript"])

data/test/integration/test_tone_analyzer_v3.rb

@@ -26,19 +26,19 @@ if !ENV["TONE_ANALYZER_APIKEY"].nil? && !ENV["TONE_ANALYZER_URL"].nil?
     end
 
     def test_tone
-      tone_text = File.read(Dir.getwd + "/resources/personality.txt")
+      tone_text = File.read(Dir.getwd + "/resources/tone-example.json")
       service_response = service.tone(
         tone_input: tone_text,
-        content_type: "text/plain"
+        content_type: "application/json"
       )
       assert((200..299).cover?(service_response.status))
     end
 
     def test_tone_with_args
-      tone_text = File.read(Dir.getwd + "/resources/personality.txt")
+      tone_text = File.read(Dir.getwd + "/resources/tone-example.json")
       service_response = service.tone(
         tone_input: tone_text,
-        content_type: "text/plain",
+        content_type: "application/json",
         sentences: false
       )
       assert((200..299).cover?(service_response.status))

data/test/integration/test_visual_recognition_v4.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require("json")
+require_relative("./../test_helper.rb")
+require("minitest/hooks/test")
+
+if !ENV["VISUAL_RECOGNITION_APIKEY"].nil? && !ENV["VISUAL_RECOGNITION_URL"].nil?
+  # Integration tests for the Visual Recognition V3 Service
+  class VisualRecognitionV4Test < Minitest::Test
+    include Minitest::Hooks
+    attr_accessor :service, :classifier_id
+    def before_all
+      authenticator = IBMWatson::Authenticators::IamAuthenticator.new(
+        apikey: ENV["VISUAL_RECOGNITION_APIKEY"]
+      )
+      @service = IBMWatson::VisualRecognitionV4.new(
+        version: "2018-03-19",
+        url: ENV["VISUAL_RECOGNITION_URL"],
+        authenticator: authenticator
+      )
+      @collection_id = ENV["VISUAL_RECOGNITION_COLLECTION_ID"]
+      @service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+    end
+
+    def test_analyze
+      image_file = File.open(Dir.getwd + "/resources/dog.jpg")
+      image_file_1 = File.open(Dir.getwd + "/resources/face.jpg")
+      result = @service.analyze(
+        images_file: [
+          {
+            "data": image_file,
+            "filename": "dog.jpg",
+            "content_type": "image/jpeg"
+          },
+          {
+            "data": image_file_1,
+            "filename": "face.jpg",
+            "content_type": "image/jpeg"
+          }
+        ],
+        collection_ids: [@collection_id],
+        features: ["objects"]
+      ).result
+      assert_equal(2, result["images"].length)
+      refute(result.nil?)
+    end
+
+    def test_list_collections
+      result = @service.list_collections.result
+      refute(result.nil?)
+    end
+
+    def test_get_collection
+      result = @service.get_collection(
+        collection_id: @collection_id
+      ).result
+      refute(result.nil?)
+    end
+
+    def test_list_images
+      result = @service.list_images(
+        collection_id: @collection_id
+      ).result
+      refute(result.nil?)
+    end
+  end
+else
+  class VisualRecognitionV4Test < Minitest::Test
+    def test_missing_credentials_skip_integration
+      skip "Skip visual recognition integration tests because credentials have not been provided"
+    end
+  end
+end

data/test/unit/test_discovery_v1.rb

@@ -1029,6 +1029,31 @@ class DiscoveryV1Test < Minitest::Test
     assert_equal({ "received" => "true" }, service_response.result)
   end
 
+  def test_get_autocompletion
+    authenticator = IBMWatson::Authenticators::BasicAuthenticator.new(
+      username: "username",
+      password: "password"
+    )
+    service = IBMWatson::DiscoveryV1.new(
+      version: "2018-03-05",
+      authenticator: authenticator
+    )
+    stub_request(:get, "https://gateway.watsonplatform.net/discovery/api/v1/environments/envid/collections/collid/autocompletion?prefix=hi&version=2018-03-05")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: { "received" => "true" }.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.get_autocompletion(
+      environment_id: "envid",
+      collection_id: "collid",
+      prefix: "hi"
+    )
+    assert_equal({ "received" => "true" }, service_response.result)
+  end
+
   def test_list_training_examples
     authenticator = IBMWatson::Authenticators::BasicAuthenticator.new(
       username: "username",

data/test/unit/test_visual_recognition_v4.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+require("json")
+require_relative("./../test_helper.rb")
+require("webmock/minitest")
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+# Unit tests for the Visual Recognition V3 Service
+class VisualRecognitionV4Test < Minitest::Test
+  def test_analyze
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    file = File.open(Dir.getwd + "/resources/cnc_test.pdf")
+    stub_request(:post, "https://gateway.watsonplatform.net/visual-recognition/api/v4/analyze?version=2018-03-19").with do |req|
+      assert_equal(req.headers["Accept"], "application/json")
+      assert_match(%r{\Amultipart/form-data}, req.headers["Content-Type"])
+      assert_match(/Content-Disposition: form-data/, req.body)
+      assert_match(/Content-Disposition: form-data; name="images_file"; filename="dog.jpg"/, req.body)
+    end
+    service.analyze(
+      images_file: [
+        {
+          "data": file,
+          "filename": "dog.jpg",
+          "content_type": "image/jpeg"
+        }
+      ],
+      collection_ids: ["collid"],
+      features: ["animal"]
+    )
+  end
+
+  def test_analyze_url
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    stub_request(:post, "https://gateway.watsonplatform.net/visual-recognition/api/v4/analyze?version=2018-03-19").with do |req|
+      assert_equal(req.headers["Accept"], "application/json")
+      assert_match(%r{\Amultipart/form-data}, req.headers["Content-Type"])
+      assert_match(/Content-Disposition: form-data; name="image_url"/, req.body)
+    end
+    service.analyze(
+      image_url: [
+        "www.somethingfunny.com"
+      ],
+      collection_ids: ["collid"],
+      features: ["animal"]
+    )
+  end
+
+  def test_create_collection
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collection_id" => "collid",
+      "name" => "Dog Breeds",
+      "owner" => "58b61352-678c-44d1-9f40-40edf4ea8d19",
+      "status" => "passed",
+      "created" => "2017-08-25T06:39:01.968Z",
+      "classes" => [
+        {
+          "class" => "goldenretriever"
+        }
+      ]
+    }
+    stub_request(:post, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.create_collection
+    assert_equal(response, service_response.result)
+  end
+
+  def test_list_collections
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collections" => []
+    }
+    stub_request(:get, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.list_collections
+    assert_equal(response, service_response.result)
+  end
+
+  def test_get_collection
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collection_id" => "collid",
+      "name" => "Dog Breeds",
+      "owner" => "58b61352-678c-44d1-9f40-40edf4ea8d19",
+      "status" => "failed",
+      "created" => "2017-08-25T06:39:01.968Z",
+      "classes" => [
+        {
+          "class" => "goldenretriever"
+        }
+      ]
+    }
+    stub_request(:get, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.get_collection(
+      collection_id: "collid"
+    )
+    assert_equal(response, service_response.result)
+  end
+
+  def test_update_collection
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collection_id" => "collid",
+      "name" => "Dog Breeds",
+      "owner" => "58b61352-678c-44d1-9f40-40edf4ea8d19",
+      "status" => "failed",
+      "created" => "2017-08-25T06:39:01.968Z",
+      "classes" => [
+        {
+          "class" => "goldenretriever"
+        }
+      ]
+    }
+    stub_request(:post, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.update_collection(
+      collection_id: "collid"
+    )
+    assert_equal(response, service_response.result)
+  end
+
+  def test_delete_collection
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {}
+    stub_request(:delete, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.delete_collection(
+      collection_id: "collid"
+    )
+    assert_nil(service_response)
+  end
+
+  def test_add_images
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collection_id" => "collid"
+    }
+    file = File.open(Dir.getwd + "/resources/cnc_test.pdf")
+    stub_request(:post, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid/images?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.add_images(
+      collection_id: "collid",
+      images_file: [
+        {
+          "data": file,
+          "filename": "dog.jpg",
+          "content_type": "image/jpeg"
+        }
+      ]
+    )
+    assert_equal(response, service_response.result)
+  end
+
+  def test_list_images
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collections" => []
+    }
+    stub_request(:get, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid/images?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.list_images(
+      collection_id: "collid"
+    )
+    assert_equal(response, service_response.result)
+  end
+
+  def test_get_image_details
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collection_id" => "collid"
+    }
+    stub_request(:get, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid/images/imageid?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.get_image_details(
+      collection_id: "collid",
+      image_id: "imageid"
+    )
+    assert_equal(response, service_response.result)
+  end
+
+  def test_delete_image
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {}
+    stub_request(:delete, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid/images/imageid?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.delete_image(
+      collection_id: "collid",
+      image_id: "imageid"
+    )
+    assert_nil(service_response)
+  end
+
+  def test_get_jpeg_image
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collection_id" => "collid"
+    }
+    stub_request(:get, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid/images/imageid/jpeg?version=2018-03-19")
+      .with(
+        headers: {
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.get_jpeg_image(
+      collection_id: "collid",
+      image_id: "imageid"
+    )
+    assert_equal(response, service_response.result)
+  end
+
+  def test_train
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collection_id" => "collid"
+    }
+    stub_request(:post, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid/train?version=2018-03-19")
+      .with(
+        headers: {
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.train(
+      collection_id: "collid"
+    )
+    assert_equal(response, service_response.result)
+  end
+
+  def test_add_image_training_data
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {
+      "collection_id" => "collid"
+    }
+    stub_request(:post, "https://gateway.watsonplatform.net/visual-recognition/api/v4/collections/collid/images/imageid/training_data?version=2018-03-19")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.add_image_training_data(
+      collection_id: "collid",
+      image_id: "imageid"
+    )
+    assert_equal(response, service_response.result)
+  end
+
+  def test_delete_user_data
+    authenticator = IBMWatson::Authenticators::BearerTokenAuthenticator.new(
+      bearer_token: "bogus_access_token"
+    )
+    service = IBMWatson::VisualRecognitionV4.new(
+      version: "2018-03-19",
+      authenticator: authenticator
+    )
+    response = {}
+    stub_request(:delete, "https://gateway.watsonplatform.net/visual-recognition/api/v4/user_data?version=2018-03-19&customer_id=customer")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Host" => "gateway.watsonplatform.net",
+          "Authorization" => "Bearer bogus_access_token"
+        }
+      ).to_return(status: 200, body: response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.delete_user_data(
+      customer_id: "customer"
+    )
+    assert_nil(service_response)
+  end
+end