ibm_watson 0.1.0

data/test/unit/test_natural_language_classifier_v1.rb

@@ -0,0 +1,187 @@
+# 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 Natural Language Classifier V1 Service
+class NaturalLanguageClassifierV1Test < Minitest::Test
+  def test_success
+    service = IBMWatson::NaturalLanguageClassifierV1.new(
+      username: "username",
+      password: "password"
+    )
+    list_response = {
+      "classifiers" => [
+        {
+          "url" => "https://gateway.watsonplatform.net/natural-language-classifier-experimental/api/v1/classifiers/497EF2-nlc-00",
+          "classifier_id" => "497EF2-nlc-00"
+        }
+      ]
+    }
+    stub_request(:get, "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: list_response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.list_classifiers
+    assert_equal(list_response, service_response.result)
+
+    status_response = {
+      "url" => "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers/497EF2-nlc-00",
+      "status" => "Available",
+      "status_description" => "The classifier instance is now available and is ready to take classifier requests.",
+      "classifier_id" => "497EF2-nlc-00"
+    }
+    stub_request(:get, "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers/497EF2-nlc-00")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: status_response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.get_classifier(
+      classifier_id: "497EF2-nlc-00"
+    )
+    assert_equal(status_response, service_response.result)
+
+    classify_response = {
+      "url" => "https://gateway.watsonplatform.net/natural-language-classifier/api/v1",
+      "text" => "test",
+      "classes" =>
+      [
+        {
+          "class_name" => "conditions",
+          "confidence" => 0.6575315710901418
+        },
+        {
+          "class_name" => "temperature",
+          "confidence" => 0.3424684289098582
+        }
+      ],
+      "classifier_id" => "497EF2-nlc-00",
+      "top_class" => "conditions"
+    }
+    stub_request(:post, "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers/497EF2-nlc-00/classify")
+      .with(
+        body: "{\"text\":\"test\"}",
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "application/json",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: classify_response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.classify(
+      classifier_id: "497EF2-nlc-00",
+      text: "test"
+    )
+    assert_equal(classify_response, service_response.result)
+
+    create_response = {
+      "url" => "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers/497EF2-nlc-00",
+      "status" => "Available",
+      "status_description" => "The classifier instance is now available and is ready to take classifier requests.",
+      "classifier_id" => "497EF2-nlc-00"
+    }
+    stub_request(:post, "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: create_response.to_json, headers: { "Content-Type" => "application/json" })
+    training_data = File.open(Dir.getwd + "/resources/weather_data_train.csv")
+    service_response = service.create_classifier(
+      training_data: training_data,
+      training_data_filename: "weather_data_train.csv",
+      metadata: { "language" => "en" },
+      metadata_filename: "metadata"
+    )
+    assert_equal(create_response, service_response.result)
+
+    service_response = service.create_classifier(
+      training_data: { "training" => "data" },
+      metadata: { "language" => "en" }
+    )
+    assert_equal(create_response, service_response.result)
+
+    stub_request(:delete, "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers/497EF2-nlc-00")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: "", headers: {})
+    service_response = service.delete_classifier(
+      classifier_id: "497EF2-nlc-00"
+    )
+    assert_nil(service_response)
+  end
+
+  def test_classify_collection
+    service = IBMWatson::NaturalLanguageClassifierV1.new(
+      username: "username",
+      password: "password"
+    )
+    classify_collection_response = {
+      "classifier_id" => "497EF2-nlc-00",
+      "url" => "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers/10D41B-nlc-1",
+      "collection" => [
+        {
+          "text" => "How hot will it be today?",
+          "top_class" => "temperature",
+          "classes" => [
+            {
+              "class_name" => "temperature",
+              "confidence" => 0.9930558798985937
+            },
+            {
+              "class_name" => "conditions",
+              "confidence" => 0.006944120101406304
+            }
+          ]
+        },
+        {
+          "text" => "Is it hot outside?",
+          "top_class" => "temperature",
+          "classes" => [
+            {
+              "class_name" => "temperature",
+              "confidence" => 1
+            },
+            {
+              "class_name" => "conditions",
+              "confidence" => 0
+            }
+          ]
+        }
+      ]
+    }
+    classifier_id = "497EF2-nlc-00"
+    collection = [{ "text" => "How hot will it be today?" }, { "text" => "Is it hot outside?" }]
+    stub_request(:post, "https://gateway.watsonplatform.net/natural-language-classifier/api/v1/classifiers/497EF2-nlc-00/classify_collection")
+      .with(
+        body: "{\"collection\":[{\"text\":\"How hot will it be today?\"},{\"text\":\"Is it hot outside?\"}]}",
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "application/json",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: classify_collection_response.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.classify_collection(
+      classifier_id: classifier_id,
+      collection: collection
+    )
+    assert_equal(classify_collection_response, service_response.result)
+  end
+end

data/test/unit/test_natural_language_understanding_v1.rb

@@ -0,0 +1,132 @@
+# 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 Natural Language Understanding V1 Service
+class NaturalLanguageUnderstandingV1Test < Minitest::Test
+  def test_text_analyze
+    service = IBMWatson::NaturalLanguageUnderstandingV1.new(
+      version: "2018-03-16",
+      username: "username",
+      password: "password"
+    )
+    stub_request(:post, "https://gateway.watsonplatform.net/natural-language-understanding/api/v1/analyze?version=2018-03-16")
+      .with(
+        body: "{\"features\":{\"sentiment\":{}},\"text\":\"hello this is a test\"}",
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "application/json",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: { resulting_key: true }.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.analyze(
+      features: {
+        sentiment: {}
+      },
+      text: "hello this is a test"
+    )
+    assert_equal({ "resulting_key" => true }, service_response.result)
+  end
+
+  def test_html_analyze
+    service = IBMWatson::NaturalLanguageUnderstandingV1.new(
+      version: "2018-03-16",
+      username: "username",
+      password: "password"
+    )
+    stub_request(:post, "https://gateway.watsonplatform.net/natural-language-understanding/api/v1/analyze?version=2018-03-16")
+      .with(
+        body: "{\"features\":{\"sentiment\":{},\"emotion\":{\"document\":false}},\"html\":\"<span>hello this is a test </span>\"}",
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "application/json",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: { resulting_key: true }.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.analyze(
+      features: {
+        sentiment: {},
+        emotion: {
+          document: false
+        }
+      },
+      html: "<span>hello this is a test </span>"
+    )
+    assert_equal({ "resulting_key" => true }, service_response.result)
+  end
+
+  def test_url_analyze
+    service = IBMWatson::NaturalLanguageUnderstandingV1.new(
+      version: "2018-03-16",
+      username: "username",
+      password: "password"
+    )
+    stub_request(:post, "https://gateway.watsonplatform.net/natural-language-understanding/api/v1/analyze?version=2018-03-16")
+      .with(
+        body: "{\"features\":{\"sentiment\":{},\"emotion\":{\"document\":false}},\"url\":\"http://cnn.com\",\"xpath\":\"/bogus/xpath\",\"language\":\"en\"}",
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "application/json",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: { resulting_key: true }.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.analyze(
+      features: {
+        sentiment: {},
+        emotion: {
+          document: false
+        }
+      },
+      url: "http://cnn.com",
+      xpath: "/bogus/xpath",
+      language: "en"
+    )
+    assert_equal({ "resulting_key" => true }, service_response.result)
+  end
+
+  def test_list_models
+    service = IBMWatson::NaturalLanguageUnderstandingV1.new(
+      version: "2018-03-16",
+      username: "username",
+      password: "password"
+    )
+    stub_request(:get, "https://gateway.watsonplatform.net/natural-language-understanding/api/v1/models?version=2018-03-16")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: { resulting_key: true }.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.list_models
+    assert_equal({ "resulting_key" => true }, service_response.result)
+  end
+
+  def test_delete_model
+    model_id = "invalid_model_id"
+    service = IBMWatson::NaturalLanguageUnderstandingV1.new(
+      version: "2018-03-16",
+      username: "username",
+      password: "password"
+    )
+    stub_request(:delete, "https://gateway.watsonplatform.net/natural-language-understanding/api/v1/models/invalid_model_id?version=2018-03-16")
+      .with(
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: { deleted: model_id }.to_json, headers: { "Content-Type" => "application/json" })
+    service_response = service.delete_model(
+      model_id: model_id
+    )
+    assert_equal({ "deleted" => model_id }, service_response.result)
+  end
+end

data/test/unit/test_personality_insights_v3.rb

@@ -0,0 +1,172 @@
+# 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 Personality Insights V3 Service
+class PersonalityInsightsV3Test < Minitest::Test
+  def test_plain_to_json
+    profile_response = File.read(Dir.getwd + "/resources/personality-v3-expect1.txt")
+    personality_text = File.read(Dir.getwd + "/resources/personality-v3.txt")
+    headers = {
+      "Content-Type" => "application/json"
+    }
+    expected_response = DetailedResponse.new(status: 200, body: JSON.parse(profile_response), headers: headers)
+    stub_request(:post, "https://gateway.watsonplatform.net/personality-insights/api/v3/profile?version=2017-10-13")
+      .with(
+        body: personality_text,
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "text/plain;charset=utf-8",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: profile_response, headers: headers)
+    service = IBMWatson::PersonalityInsightsV3.new(
+      version: "2017-10-13",
+      username: "username",
+      password: "password"
+    )
+    service_response = service.profile(
+      content: personality_text,
+      content_type: "text/plain;charset=utf-8"
+    )
+    assert_equal(expected_response.status, service_response.status)
+    assert_equal(expected_response.result, service_response.result)
+    expected_response.headers.each_key do |key|
+      assert(service_response.headers.key?(key))
+      assert(expected_response.headers[key] == service_response.headers[key])
+    end
+
+    stub_request(:post, "https://gateway.watsonplatform.net/personality-insights/api/v3/profile?version=2017-10-13")
+      .with(
+        body: { "personality" => "text" }.to_json,
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "application/json",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: { "profile" => "response" }.to_json, headers: headers)
+    service_response = service.profile(
+      content: { "personality" => "text" },
+      content_type: "application/json"
+    )
+    assert_equal({ "profile" => "response" }, service_response.result)
+  end
+
+  def test_json_to_json
+    profile_response = File.read(Dir.getwd + "/resources/personality-v3-expect2.txt")
+    personality_text = File.read(Dir.getwd + "/resources/personality-v3.json")
+    headers = {
+      "Content-Type" => "applicaiton/json"
+    }
+    expected_response = DetailedResponse.new(status: 200, body: profile_response, headers: headers)
+    stub_request(:post, "https://gateway.watsonplatform.net/personality-insights/api/v3/profile?consumption_preferences=true&raw_scores=true&version=2017-10-13")
+      .with(
+        body: personality_text,
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "application/json",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: profile_response, headers: headers)
+    service = IBMWatson::PersonalityInsightsV3.new(
+      version: "2017-10-13",
+      username: "username",
+      password: "password"
+    )
+    service_response = service.profile(
+      content: personality_text,
+      content_type: "application/json",
+      raw_scores: true,
+      consumption_preferences: true
+    )
+    assert_equal(expected_response.status, service_response.status)
+    assert_equal(expected_response.result, service_response.result)
+    expected_response.headers.each_key do |key|
+      assert(service_response.headers.key?(key))
+      assert(expected_response.headers[key] == service_response.headers[key])
+    end
+  end
+
+  def test_json_to_csv
+    profile_response = File.read(Dir.getwd + "/resources/personality-v3-expect3.txt")
+    personality_text = File.read(Dir.getwd + "/resources/personality-v3.json")
+    headers = {
+      "Content-Type" => "application/json"
+    }
+    expected_response = DetailedResponse.new(status: 200, body: profile_response, headers: headers)
+    stub_request(:post, "https://gateway.watsonplatform.net/personality-insights/api/v3/profile?consumption_preferences=true&csv_headers=true&raw_scores=true&version=2017-10-13")
+      .with(
+        body: personality_text,
+        headers: {
+          "Accept" => "application/json",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Type" => "application/json",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: profile_response.to_json, headers: headers)
+    service = IBMWatson::PersonalityInsightsV3.new(
+      version: "2017-10-13",
+      username: "username",
+      password: "password"
+    )
+    service_response = service.profile(
+      content: personality_text,
+      content_type: "application/json",
+      accept: "text/csv",
+      csv_headers: true,
+      raw_scores: true,
+      consumption_preferences: true
+    )
+    assert_equal(expected_response.status, service_response.status)
+    assert_equal(expected_response.result, service_response.result)
+    expected_response.headers.each_key do |key|
+      assert(service_response.headers.key?(key))
+      assert(expected_response.headers[key] == service_response.headers[key])
+    end
+  end
+
+  def test_plain_to_json_es
+    profile_response = JSON.parse(File.read(Dir.getwd + "/resources/personality-v3-expect4.txt"))
+    personality_text = File.read(Dir.getwd + "/resources/personality-v3-es.txt")
+    headers = {
+      "Content-Type" => "application/json"
+    }
+    expected_response = DetailedResponse.new(status: 200, body: profile_response, headers: headers)
+    stub_request(:post, "https://gateway.watsonplatform.net/personality-insights/api/v3/profile?version=2017-10-13")
+      .with(
+        body: personality_text,
+        headers: {
+          "Accept" => "application/json",
+          "Accept-Language" => "es",
+          "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+          "Content-Language" => "es",
+          "Content-Type" => "text/plain;charset=utf-8",
+          "Host" => "gateway.watsonplatform.net"
+        }
+      ).to_return(status: 200, body: profile_response.to_json, headers: headers)
+    service = IBMWatson::PersonalityInsightsV3.new(
+      version: "2017-10-13",
+      username: "username",
+      password: "password"
+    )
+    service_response = service.profile(
+      content: personality_text,
+      content_type: "text/plain;charset=utf-8",
+      content_language: "es",
+      accept_language: "es"
+    )
+    assert_equal(expected_response.status, service_response.status)
+    assert_equal(expected_response.result, service_response.result)
+    expected_response.headers.each_key do |key|
+      assert(service_response.headers.key?(key))
+      assert(expected_response.headers[key] == service_response.headers[key])
+    end
+  end
+end