ibm_watson 0.1.0

data/test/integration/test_language_translator_v3.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+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
+
+  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_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_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_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

data/test/integration/test_natural_language_classifier_v1.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+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
+
+  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
+    )
+  end
+end

data/test/integration/test_natural_language_understanding_v1.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+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
+        }
+      },
+      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_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))
+  end
+end

data/test/integration/test_personality_insights_v3.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+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
+
+  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_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

data/test/integration/test_speech_to_text_v1.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative("./../test_helper.rb")
+require_relative("./../../lib/ibm_watson/websocket/recognize_callback.rb")
+require_relative("./../../lib/ibm_watson/websocket/speech_to_text_websocket_listener.rb")
+require("minitest/hooks/test")
+require("concurrent")
+
+# Recognize Callback class
+class MyRecognizeCallback < IBMWatson::RecognizeCallback
+  def initialize(atomic_boolean: nil)
+    super
+    @atomic_boolean = atomic_boolean
+  end
+
+  def on_error(error:)
+    puts "Error received: #{error}"
+  end
+
+  def on_inactivity_timeout(*)
+    @atomic_boolean.make_true
+  end
+end
+
+# Integration tests for the Speech to Text V1 Service
+class SpeechToTextV1Test < Minitest::Test
+  include Minitest::Hooks
+
+  attr_accessor :service
+  def before_all
+    @service = IBMWatson::SpeechToTextV1.new(
+      username: ENV["SPEECH_TO_TEXT_USERNAME"],
+      password: ENV["SPEECH_TO_TEXT_PASSWORD"]
+    )
+    @service.add_default_headers(
+      headers: {
+        "X-Watson-Learning-Opt-Out" => "1",
+        "X-Watson-Test" => "1"
+      }
+    )
+  end
+
+  def test_models
+    output = @service.list_models.result
+    refute_nil(output)
+
+    model = @service.get_model(
+      model_id: "ko-KR_BroadbandModel"
+    ).result
+    model = model
+    refute_nil(model)
+
+    begin
+      @service.get_model(
+        model_id: "bogus"
+      )
+    rescue StandardError => e
+      refute_nil(e.global_transaction_id)
+    end
+  end
+
+  def test_recognize_await
+    audio_file = File.open(Dir.getwd + "/resources/speech.wav")
+    future = @service.await.recognize(
+      audio: audio_file,
+      content_type: "audio/l16; rate=44100"
+    )
+    output = future.value.result
+    refute_nil(output["results"][0]["alternatives"][0]["transcript"])
+  end
+
+  def test_recognize_async
+    audio_file = File.open(Dir.getwd + "/resources/speech.wav")
+    future = @service.async.recognize(
+      audio: audio_file,
+      content_type: "audio/l16; rate=44100"
+    )
+    future.wait!
+    output = future.value.result
+    refute_nil(output["results"][0]["alternatives"][0]["transcript"])
+  end
+
+  def test_recognitions
+    output = @service.check_jobs.result
+    refute_nil(output)
+  end
+
+  def test_custom_corpora
+    model = @service.create_language_model(
+      name: "integration_test_model",
+      base_model_name: "en-US_BroadbandModel"
+    ).result
+    customization_id = model["customization_id"]
+
+    output = @service.list_corpora(
+      customization_id: customization_id
+    ).result
+    refute_nil(output)
+
+    @service.delete_language_model(
+      customization_id: customization_id
+    )
+  end
+
+  def test_acoustic_model
+    list_models = @service.list_acoustic_models.result
+    refute_nil(list_models)
+
+    create_acoustic_model = @service.create_acoustic_model(
+      name: "integration_test_model_ruby",
+      base_model_name: "en-US_BroadbandModel"
+    ).result
+    refute_nil(create_acoustic_model)
+
+    get_acoustic_model = @service.get_acoustic_model(
+      customization_id: create_acoustic_model["customization_id"]
+    ).result
+    refute_nil(get_acoustic_model)
+
+    @service.reset_acoustic_model(
+      customization_id: get_acoustic_model["customization_id"]
+    )
+
+    @service.delete_acoustic_model(
+      customization_id: get_acoustic_model["customization_id"]
+    )
+  end
+
+  def test_recognize_websocket_as_chunks
+    audio_file = File.open(Dir.getwd + "/resources/speech.wav")
+    mycallback = MyRecognizeCallback.new
+    speech = @service.recognize_with_websocket(
+      chunk_data: true,
+      recognize_callback: mycallback,
+      interim_results: true,
+      timestamps: true,
+      max_alternatives: 2,
+      word_alternatives_threshold: 0.5,
+      model: "en-US_BroadbandModel"
+    )
+    Thread.new do
+      until audio_file.eof?
+        chunk = audio_file.read(1024)
+        speech.add_audio_chunk(chunk: chunk)
+      end
+      sleep(1)
+      speech.stop_audio # Tell the websocket object that no more audio will be added
+    end
+    thr = Thread.new { speech.start }
+    thr.join
+  end
+
+  def test_recognize_websocket
+    audio_file = File.open(Dir.getwd + "/resources/speech.wav")
+    mycallback = MyRecognizeCallback.new
+    speech = @service.recognize_with_websocket(
+      audio: audio_file,
+      recognize_callback: mycallback,
+      interim_results: true,
+      timestamps: true,
+      max_alternatives: 2,
+      word_alternatives_threshold: 0.5,
+      model: "en-US_BroadbandModel"
+    )
+    thr = Thread.new { speech.start }
+    thr.join
+  end
+
+  def test_inactivity_timeout_with_websocket
+    audio_file = File.open(Dir.getwd + "/resources/sound-with-pause.wav")
+    atomic_boolean = Concurrent::AtomicBoolean.new
+    mycallback = MyRecognizeCallback.new(atomic_boolean: atomic_boolean)
+    speech = @service.recognize_with_websocket(
+      audio: audio_file,
+      recognize_callback: mycallback,
+      interim_results: true,
+      inactivity_timeout: 3,
+      timestamps: true,
+      max_alternatives: 2,
+      word_alternatives_threshold: 0.5,
+      model: "en-US_BroadbandModel"
+    )
+    thr = Thread.new { speech.start }
+    thr.join
+    assert(atomic_boolean.true?)
+  end
+end