ibm_watson 0.1.0 → 0.1.1

data/test/integration/test_language_translator_v3.rb

@@ -4,78 +4,80 @@ require("json")
 require_relative("./../test_helper.rb")
 require("minitest/hooks/test")
 
-# Integration tests for the Language Translator V3 Service
-class LanguageTranslatorV3Test < Minitest::Test
-  include Minitest::Hooks
-  attr_accessor :service
-  def before_all
-    @service = IBMWatson::LanguageTranslatorV3.new(
-      username: ENV["LANGUAGE_TRANSLATOR_V3_USERNAME"],
-      password: ENV["LANGUAGE_TRANSLATOR_V3_PASSWORD"],
-      version: "2018-05-01"
-    )
-    @service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-  end
+unless ENV["LANGUAGE_TRANSLATOR_V3_USERNAME"].nil? || ENV["LANGUAGE_TRANSLATOR_V3_PASSWORD"].nil?
+  # Integration tests for the Language Translator V3 Service
+  class LanguageTranslatorV3Test < Minitest::Test
+    include Minitest::Hooks
+    attr_accessor :service
+    def before_all
+      @service = IBMWatson::LanguageTranslatorV3.new(
+        username: ENV["LANGUAGE_TRANSLATOR_V3_USERNAME"],
+        password: ENV["LANGUAGE_TRANSLATOR_V3_PASSWORD"],
+        version: "2018-05-01"
+      )
+      @service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+    end
 
-  def test_get_model
-    service_response = service.get_model(
-      model_id: "en-it"
-    ).result
-    refute(service_response.nil?)
-  end
+    def test_get_model
+      service_response = service.get_model(
+        model_id: "en-it"
+      ).result
+      refute(service_response.nil?)
+    end
 
-  def test_list_models
-    service_response = service.list_models.result
-    refute(service_response.nil?)
-  end
+    def test_list_models
+      service_response = service.list_models.result
+      refute(service_response.nil?)
+    end
 
-  def test_translate_source_target
-    service_response = service.translate(
-      text: "Hola, cómo estás? €",
-      source: "es",
-      target: "en"
-    ).result
-    refute(service_response.nil?)
-  end
+    def test_translate_source_target
+      service_response = service.translate(
+        text: "Hola, cómo estás? €",
+        source: "es",
+        target: "en"
+      ).result
+      refute(service_response.nil?)
+    end
 
-  def test_translate_model_id
-    service_response = service.translate(
-      text: "Messi is the best ever",
-      model_id: "en-es"
-    ).result
-    refute(service_response.nil?)
-  end
+    def test_translate_model_id
+      service_response = service.translate(
+        text: "Messi is the best ever",
+        model_id: "en-es"
+      ).result
+      refute(service_response.nil?)
+    end
 
-  def test_identify
-    service_response = service.identify(
-      text: "祝你有美好的一天"
-    ).result
-    refute(service_response.nil?)
-  end
+    def test_identify
+      service_response = service.identify(
+        text: "祝你有美好的一天"
+      ).result
+      refute(service_response.nil?)
+    end
 
-  def test_list_identifiable_languages
-    service_response = service.list_identifiable_languages.result
-    refute(service_response.nil?)
-  end
+    def test_list_identifiable_languages
+      service_response = service.list_identifiable_languages.result
+      refute(service_response.nil?)
+    end
 
-  def test_create_delete_model
-    skip "Methods not available in lite plans"
-    custom_model = File.open(Dir.getwd + "/resources/language_translator_model.tmx")
-    service_response = service.create_model(
-      base_model_id: "en-fr",
-      name: "test_glossary_ruby_integration",
-      forced_glossary: custom_model
-    ).result
-    refute(service_response.nil?)
-    model_id = service_response["model_id"]
-    service_response = service.delete_model(
-      model_id: model_id
-    ).result
-    assert_equal("OK", service_response["status"])
+    def test_create_delete_model
+      skip "Methods not available in lite plans"
+      custom_model = File.open(Dir.getwd + "/resources/language_translator_model.tmx")
+      service_response = service.create_model(
+        base_model_id: "en-fr",
+        name: "test_glossary_ruby_integration",
+        forced_glossary: custom_model
+      ).result
+      refute(service_response.nil?)
+      model_id = service_response["model_id"]
+      service_response = service.delete_model(
+        model_id: model_id
+      ).result
+      assert_equal("OK", service_response["status"])
+    end
   end
 end

data/test/integration/test_natural_language_classifier_v1.rb

@@ -4,66 +4,68 @@ require("json")
 require_relative("./../test_helper.rb")
 require("minitest/hooks/test")
 
-# Integration tests for the Natural Language Classifier V1 Service
-class NaturalLanguageClassifierV1Test < Minitest::Test
-  include Minitest::Hooks
-  attr_accessor :service
-  def before_all
-    @service = IBMWatson::NaturalLanguageClassifierV1.new(
-      username: ENV["NATURAL_LANGUAGE_CLASSIFIER_USERNAME"],
-      password: ENV["NATURAL_LANGUAGE_CLASSIFIER_PASSWORD"]
-    )
-    @service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-  end
-
-  def test_list_classifier
-    list_classifiers = @service.list_classifiers.result
-    refute(list_classifiers.nil?)
-  end
+unless ENV["NATURAL_LANGUAGE_CLASSIFIER_USERNAME"].nil? || ENV["NATURAL_LANGUAGE_CLASSIFIER_PASSWORD"].nil?
+  # Integration tests for the Natural Language Classifier V1 Service
+  class NaturalLanguageClassifierV1Test < Minitest::Test
+    include Minitest::Hooks
+    attr_accessor :service
+    def before_all
+      @service = IBMWatson::NaturalLanguageClassifierV1.new(
+        username: ENV["NATURAL_LANGUAGE_CLASSIFIER_USERNAME"],
+        password: ENV["NATURAL_LANGUAGE_CLASSIFIER_PASSWORD"]
+      )
+      @service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+    end
 
-  def test_classify_text
-    skip "The classifier takes more than a minute"
-    training_data = File.open(Dir.getwd + "/resources/weather_data_train.csv")
-    metadata = { "name" => "my-classifier", "language" => "en" }
-    status = nil
-    classifier = @service.create_classifier(
-      metadata: metadata,
-      training_data: training_data
-    ).result
-    classifier_id = classifier["classifier_id"]
-    iterations = 0
-    while iterations < 15
-      status = @service.get_classifier(classifier_id: classifier_id)
-      iterations += 1
-      sleep(5) unless status["status"] == "Available"
+    def test_list_classifier
+      list_classifiers = @service.list_classifiers.result
+      refute(list_classifiers.nil?)
     end
-    unless status["status"] == "Available"
+
+    def test_classify_text
+      skip "The classifier takes more than a minute"
+      training_data = File.open(Dir.getwd + "/resources/weather_data_train.csv")
+      metadata = { "name" => "my-classifier", "language" => "en" }
+      status = nil
+      classifier = @service.create_classifier(
+        metadata: metadata,
+        training_data: training_data
+      ).result
+      classifier_id = classifier["classifier_id"]
+      iterations = 0
+      while iterations < 15
+        status = @service.get_classifier(classifier_id: classifier_id)
+        iterations += 1
+        sleep(5) unless status["status"] == "Available"
+      end
+      unless status["status"] == "Available"
+        @service.delete_classifier(
+          classifier_id: classifier_id
+        )
+        assert(false, msg: "Classifier is not available")
+      end
+
+      classes = @service.classify(
+        classifier_id: classifier_id,
+        text: "How hot will it be tomorrow?"
+      ).result
+      refute(classes.nil?)
+
+      collection = [{ "text" => "How hot will it be today?" }, { "text" => "Is it hot outside?" }]
+      classes = @service.classify_collection(
+        classifier_id: classifier_id,
+        collection: collection
+      ).result
+      refute(classes.nil?)
+
       @service.delete_classifier(
         classifier_id: classifier_id
       )
-      assert(false, msg: "Classifier is not available")
     end
-
-    classes = @service.classify(
-      classifier_id: classifier_id,
-      text: "How hot will it be tomorrow?"
-    ).result
-    refute(classes.nil?)
-
-    collection = [{ "text" => "How hot will it be today?" }, { "text" => "Is it hot outside?" }]
-    classes = @service.classify_collection(
-      classifier_id: classifier_id,
-      collection: collection
-    ).result
-    refute(classes.nil?)
-
-    @service.delete_classifier(
-      classifier_id: classifier_id
-    )
   end
 end

data/test/integration/test_natural_language_understanding_v1.rb

@@ -3,96 +3,98 @@
 require("json")
 require_relative("./../test_helper.rb")
 
-# Integration 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: ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"],
-      password: ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    text = "IBM is an American multinational technology company "
-    text += "headquartered in Armonk, New York, United States, "
-    text += "with operations in over 170 countries."
-    service_response = service.analyze(
-      features: {
-        entities: {
-          emotion: true,
-          sentiment: true,
-          limit: 2
-        },
-        keywords: {
-          emotion: true,
-          sentiment: true,
-          limit: 2
+unless ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"].nil? || ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"].nil?
+  # Integration 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: ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"],
+        password: ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
         }
-      },
-      text: text
-    )
-    assert((200..299).cover?(service_response.status))
-  end
+      )
+      text = "IBM is an American multinational technology company "
+      text += "headquartered in Armonk, New York, United States, "
+      text += "with operations in over 170 countries."
+      service_response = service.analyze(
+        features: {
+          entities: {
+            emotion: true,
+            sentiment: true,
+            limit: 2
+          },
+          keywords: {
+            emotion: true,
+            sentiment: true,
+            limit: 2
+          }
+        },
+        text: text
+      )
+      assert((200..299).cover?(service_response.status))
+    end
 
-  def test_html_analyze
-    service = IBMWatson::NaturalLanguageUnderstandingV1.new(
-      version: "2018-03-16",
-      username: ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"],
-      password: ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.analyze(
-      features: {
-        sentiment: {}
-      },
-      html: "<span>hello this is a test </span>"
-    )
-    assert((200..299).cover?(service_response.status))
-  end
+    def test_html_analyze
+      service = IBMWatson::NaturalLanguageUnderstandingV1.new(
+        version: "2018-03-16",
+        username: ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"],
+        password: ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.analyze(
+        features: {
+          sentiment: {}
+        },
+        html: "<span>hello this is a test </span>"
+      )
+      assert((200..299).cover?(service_response.status))
+    end
 
-  def test_url_analyze
-    service = IBMWatson::NaturalLanguageUnderstandingV1.new(
-      version: "2018-03-16",
-      username: ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"],
-      password: ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.analyze(
-      features: {
-        categories: {}
-      },
-      url: "www.ibm.com"
-    )
-    assert((200..299).cover?(service_response.status))
-  end
+    def test_url_analyze
+      service = IBMWatson::NaturalLanguageUnderstandingV1.new(
+        version: "2018-03-16",
+        username: ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"],
+        password: ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.analyze(
+        features: {
+          categories: {}
+        },
+        url: "www.ibm.com"
+      )
+      assert((200..299).cover?(service_response.status))
+    end
 
-  def test_list_models
-    service = IBMWatson::NaturalLanguageUnderstandingV1.new(
-      version: "2018-03-16",
-      username: ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"],
-      password: ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.list_models
-    assert((200..299).cover?(service_response.status))
+    def test_list_models
+      service = IBMWatson::NaturalLanguageUnderstandingV1.new(
+        version: "2018-03-16",
+        username: ENV["NATURAL_LANGUAGE_UNDERSTANDING_USERNAME"],
+        password: ENV["NATURAL_LANGUAGE_UNDERSTANDING_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.list_models
+      assert((200..299).cover?(service_response.status))
+    end
   end
 end

data/test/integration/test_personality_insights_v3.rb

@@ -3,93 +3,95 @@
 require("json")
 require_relative("./../test_helper.rb")
 
-# Integration tests for the Personality Insights V3 Service
-class PersonalityInsightsV3Test < Minitest::Test
-  def test_plain_to_json
-    personality_text = File.read(Dir.getwd + "/resources/personality-v3.txt")
-    service = IBMWatson::PersonalityInsightsV3.new(
-      version: "2017-10-13",
-      username: ENV["PERSONALITY_INSIGHTS_USERNAME"],
-      password: ENV["PERSONALITY_INSIGHTS_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.profile(
-      content: personality_text,
-      content_type: "text/plain;charset=utf-8"
-    )
-    assert((200..299).cover?(service_response.status))
-  end
+unless ENV["PERSONALITY_INSIGHTS_USERNAME"].nil? || ENV["PERSONALITY_INSIGHTS_PASSWORD"].nil?
+  # Integration tests for the Personality Insights V3 Service
+  class PersonalityInsightsV3Test < Minitest::Test
+    def test_plain_to_json
+      personality_text = File.read(Dir.getwd + "/resources/personality-v3.txt")
+      service = IBMWatson::PersonalityInsightsV3.new(
+        version: "2017-10-13",
+        username: ENV["PERSONALITY_INSIGHTS_USERNAME"],
+        password: ENV["PERSONALITY_INSIGHTS_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.profile(
+        content: personality_text,
+        content_type: "text/plain;charset=utf-8"
+      )
+      assert((200..299).cover?(service_response.status))
+    end
 
-  def test_json_to_json
-    personality_text = File.read(Dir.getwd + "/resources/personality-v3.json")
-    service = IBMWatson::PersonalityInsightsV3.new(
-      version: "2017-10-13",
-      username: ENV["PERSONALITY_INSIGHTS_USERNAME"],
-      password: ENV["PERSONALITY_INSIGHTS_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.profile(
-      content: personality_text,
-      content_type: "application/json",
-      raw_scores: true,
-      consumption_preferences: true
-    )
-    assert((200..299).cover?(service_response.status))
-  end
+    def test_json_to_json
+      personality_text = File.read(Dir.getwd + "/resources/personality-v3.json")
+      service = IBMWatson::PersonalityInsightsV3.new(
+        version: "2017-10-13",
+        username: ENV["PERSONALITY_INSIGHTS_USERNAME"],
+        password: ENV["PERSONALITY_INSIGHTS_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.profile(
+        content: personality_text,
+        content_type: "application/json",
+        raw_scores: true,
+        consumption_preferences: true
+      )
+      assert((200..299).cover?(service_response.status))
+    end
 
-  def test_json_to_csv
-    personality_text = File.read(Dir.getwd + "/resources/personality-v3.json")
-    service = IBMWatson::PersonalityInsightsV3.new(
-      version: "2017-10-13",
-      username: ENV["PERSONALITY_INSIGHTS_USERNAME"],
-      password: ENV["PERSONALITY_INSIGHTS_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.profile(
-      content: personality_text,
-      content_type: "application/json",
-      accept: "text/csv",
-      csv_headers: true,
-      raw_scores: true,
-      consumption_preferences: true
-    )
-    assert((200..299).cover?(service_response.status))
-  end
+    def test_json_to_csv
+      personality_text = File.read(Dir.getwd + "/resources/personality-v3.json")
+      service = IBMWatson::PersonalityInsightsV3.new(
+        version: "2017-10-13",
+        username: ENV["PERSONALITY_INSIGHTS_USERNAME"],
+        password: ENV["PERSONALITY_INSIGHTS_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.profile(
+        content: personality_text,
+        content_type: "application/json",
+        accept: "text/csv",
+        csv_headers: true,
+        raw_scores: true,
+        consumption_preferences: true
+      )
+      assert((200..299).cover?(service_response.status))
+    end
 
-  def test_plain_to_json_es
-    personality_text = File.read(Dir.getwd + "/resources/personality-v3-es.txt")
-    service = IBMWatson::PersonalityInsightsV3.new(
-      version: "2017-10-13",
-      username: ENV["PERSONALITY_INSIGHTS_USERNAME"],
-      password: ENV["PERSONALITY_INSIGHTS_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.profile(
-      content: personality_text,
-      content_type: "text/plain;charset=utf-8",
-      content_language: "es",
-      accept_language: "es"
-    )
-    assert((200..299).cover?(service_response.status))
+    def test_plain_to_json_es
+      personality_text = File.read(Dir.getwd + "/resources/personality-v3-es.txt")
+      service = IBMWatson::PersonalityInsightsV3.new(
+        version: "2017-10-13",
+        username: ENV["PERSONALITY_INSIGHTS_USERNAME"],
+        password: ENV["PERSONALITY_INSIGHTS_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.profile(
+        content: personality_text,
+        content_type: "text/plain;charset=utf-8",
+        content_language: "es",
+        accept_language: "es"
+      )
+      assert((200..299).cover?(service_response.status))
+    end
   end
 end