ibm_watson 0.1.0 → 0.1.1

data/test/integration/test_speech_to_text_v1.rb

@@ -22,166 +22,167 @@ class MyRecognizeCallback < IBMWatson::RecognizeCallback
   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
+unless ENV["SPEECH_TO_TEXT_USERNAME"].nil? || ENV["SPEECH_TO_TEXT_PASSWORD"].nil?
+  # 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)
+    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
 
-    model = @service.get_model(
-      model_id: "ko-KR_BroadbandModel"
-    ).result
-    model = model
-    refute_nil(model)
+    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
 
-    begin
-      @service.get_model(
-        model_id: "bogus"
+    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"
       )
-    rescue StandardError => e
-      refute_nil(e.global_transaction_id)
+      future.wait!
+      output = future.value.result
+      refute_nil(output["results"][0]["alternatives"][0]["transcript"])
     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_recognitions
+      output = @service.check_jobs.result
+      refute_nil(output)
+    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_custom_corpora
+      model = @service.create_language_model(
+        name: "integration_test_model",
+        base_model_name: "en-US_BroadbandModel"
+      ).result
+      customization_id = model["customization_id"]
 
-  def test_recognitions
-    output = @service.check_jobs.result
-    refute_nil(output)
-  end
+      output = @service.list_corpora(
+        customization_id: customization_id
+      ).result
+      refute_nil(output)
 
-  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
+      @service.delete_language_model(
+        customization_id: customization_id
+      )
+    end
 
-  def test_acoustic_model
-    list_models = @service.list_acoustic_models.result
-    refute_nil(list_models)
+    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)
+      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)
+      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.reset_acoustic_model(
+        customization_id: get_acoustic_model["customization_id"]
+      )
 
-    @service.delete_acoustic_model(
-      customization_id: get_acoustic_model["customization_id"]
-    )
-  end
+      @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)
+    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
-      sleep(1)
-      speech.stop_audio # Tell the websocket object that no more audio will be added
+      thr = Thread.new { speech.start }
+      thr.join
     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_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?)
+    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
 end

data/test/integration/test_text_to_speech_v1.rb

@@ -3,79 +3,81 @@
 require_relative("./../test_helper.rb")
 require("minitest/hooks/test")
 
-# Integration tests for the Text to Speech V1 Service
-class TextToSpeechV1Test < Minitest::Test
-  include Minitest::Hooks
-  attr_accessor :service
-  def before_all
-    @service = IBMWatson::TextToSpeechV1.new(
-      username: ENV["TEXT_TO_SPEECH_USERNAME"],
-      password: ENV["TEXT_TO_SPEECH_PASSWORD"]
-    )
-    @service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-  end
+unless ENV["TEXT_TO_SPEECH_USERNAME"].nil? || ENV["TEXT_TO_SPEECH_PASSWORD"].nil?
+  # Integration tests for the Text to Speech V1 Service
+  class TextToSpeechV1Test < Minitest::Test
+    include Minitest::Hooks
+    attr_accessor :service
+    def before_all
+      @service = IBMWatson::TextToSpeechV1.new(
+        username: ENV["TEXT_TO_SPEECH_USERNAME"],
+        password: ENV["TEXT_TO_SPEECH_PASSWORD"]
+      )
+      @service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+    end
 
-  def test_voices
-    output = @service.list_voices.result
-    refute(output["voices"].nil?)
-    voice = @service.get_voice(voice: output["voices"][0]["name"])
-    refute(voice.nil?)
-  end
+    def test_voices
+      output = @service.list_voices.result
+      refute(output["voices"].nil?)
+      voice = @service.get_voice(voice: output["voices"][0]["name"])
+      refute(voice.nil?)
+    end
 
-  def test_speak
-    output = @service.synthesize(
-      text: "my voice is my passport",
-      accept: "audio/wav",
-      voice: "en-US_AllisonVoice"
-    ).result
-    refute(output.nil?)
-  end
+    def test_speak
+      output = @service.synthesize(
+        text: "my voice is my passport",
+        accept: "audio/wav",
+        voice: "en-US_AllisonVoice"
+      ).result
+      refute(output.nil?)
+    end
 
-  def test_pronunciation
-    output = @service.get_pronunciation(
-      text: "hello"
-    ).result
-    refute(output["pronunciation"].nil?)
-  end
+    def test_pronunciation
+      output = @service.get_pronunciation(
+        text: "hello"
+      ).result
+      refute(output["pronunciation"].nil?)
+    end
 
-  def test_customizations
-    service_response = @service.list_voice_models
-    refute(service_response.nil?)
-  end
+    def test_customizations
+      service_response = @service.list_voice_models
+      refute(service_response.nil?)
+    end
 
-  def test_custom_words
-    customization_id = @service.create_voice_model(
-      name: "test_integration_customization",
-      description: "customization for tests"
-    ).result["customization_id"]
-    words = @service.list_words(customization_id: customization_id).result["words"]
-    assert(words.length.zero?)
-    @service.add_word(
-      customization_id: customization_id,
-      word: "ACLs",
-      translation: "ackles"
-    )
-    words = [{ "word" => "MACLs", "translation" => "mackles" }]
-    @service.add_words(
-      customization_id: customization_id,
-      words: words
-    )
-    @service.delete_word(
-      customization_id: customization_id,
-      word: "ACLs"
-    )
-    word = @service.get_word(
-      customization_id: customization_id,
-      word: "MACLs"
-    ).result
-    assert(word["translation"] == "mackles")
-    @service.delete_voice_model(
-      customization_id: customization_id
-    )
+    def test_custom_words
+      customization_id = @service.create_voice_model(
+        name: "test_integration_customization",
+        description: "customization for tests"
+      ).result["customization_id"]
+      words = @service.list_words(customization_id: customization_id).result["words"]
+      assert(words.length.zero?)
+      @service.add_word(
+        customization_id: customization_id,
+        word: "ACLs",
+        translation: "ackles"
+      )
+      words = [{ "word" => "MACLs", "translation" => "mackles" }]
+      @service.add_words(
+        customization_id: customization_id,
+        words: words
+      )
+      @service.delete_word(
+        customization_id: customization_id,
+        word: "ACLs"
+      )
+      word = @service.get_word(
+        customization_id: customization_id,
+        word: "MACLs"
+      ).result
+      assert(word["translation"] == "mackles")
+      @service.delete_voice_model(
+        customization_id: customization_id
+      )
+    end
   end
 end

data/test/integration/test_tone_analyzer_v3.rb

@@ -3,70 +3,72 @@
 require("json")
 require_relative("./../test_helper.rb")
 
-# Integration tests for the Tone Analyzer V3 Service
-class ToneAnalyzerV3Test < Minitest::Test
-  def test_tone
-    tone_text = File.read(Dir.getwd + "/resources/personality.txt")
-    service = IBMWatson::ToneAnalyzerV3.new(
-      version: "2017-09-21",
-      username: ENV["TONE_ANALYZER_USERNAME"],
-      password: ENV["TONE_ANALYZER_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.tone(
-      tone_input: tone_text,
-      content_type: "text/plain"
-    )
-    assert((200..299).cover?(service_response.status))
-  end
+unless ENV["TONE_ANALYZER_USERNAME"].nil? || ENV["TONE_ANALYZER_PASSWORD"].nil?
+  # Integration tests for the Tone Analyzer V3 Service
+  class ToneAnalyzerV3Test < Minitest::Test
+    def test_tone
+      tone_text = File.read(Dir.getwd + "/resources/personality.txt")
+      service = IBMWatson::ToneAnalyzerV3.new(
+        version: "2017-09-21",
+        username: ENV["TONE_ANALYZER_USERNAME"],
+        password: ENV["TONE_ANALYZER_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.tone(
+        tone_input: tone_text,
+        content_type: "text/plain"
+      )
+      assert((200..299).cover?(service_response.status))
+    end
 
-  def test_tone_with_args
-    tone_text = File.read(Dir.getwd + "/resources/personality.txt")
-    service = IBMWatson::ToneAnalyzerV3.new(
-      version: "2017-09-21",
-      username: ENV["TONE_ANALYZER_USERNAME"],
-      password: ENV["TONE_ANALYZER_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    service_response = service.tone(
-      tone_input: tone_text,
-      content_type: "text/plain",
-      sentences: false
-    )
-    assert((200..299).cover?(service_response.status))
-  end
+    def test_tone_with_args
+      tone_text = File.read(Dir.getwd + "/resources/personality.txt")
+      service = IBMWatson::ToneAnalyzerV3.new(
+        version: "2017-09-21",
+        username: ENV["TONE_ANALYZER_USERNAME"],
+        password: ENV["TONE_ANALYZER_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      service_response = service.tone(
+        tone_input: tone_text,
+        content_type: "text/plain",
+        sentences: false
+      )
+      assert((200..299).cover?(service_response.status))
+    end
 
-  def test_tone_chat
-    service = IBMWatson::ToneAnalyzerV3.new(
-      version: "2017-09-21",
-      username: ENV["TONE_ANALYZER_USERNAME"],
-      password: ENV["TONE_ANALYZER_PASSWORD"]
-    )
-    service.add_default_headers(
-      headers: {
-        "X-Watson-Learning-Opt-Out" => "1",
-        "X-Watson-Test" => "1"
-      }
-    )
-    utterances = [
-      {
-        "text" => "I am very happy",
-        "user" => "glenn"
-      }
-    ]
-    service_response = service.tone_chat(
-      utterances: utterances
-    )
-    assert((200..299).cover?(service_response.status))
+    def test_tone_chat
+      service = IBMWatson::ToneAnalyzerV3.new(
+        version: "2017-09-21",
+        username: ENV["TONE_ANALYZER_USERNAME"],
+        password: ENV["TONE_ANALYZER_PASSWORD"]
+      )
+      service.add_default_headers(
+        headers: {
+          "X-Watson-Learning-Opt-Out" => "1",
+          "X-Watson-Test" => "1"
+        }
+      )
+      utterances = [
+        {
+          "text" => "I am very happy",
+          "user" => "glenn"
+        }
+      ]
+      service_response = service.tone_chat(
+        utterances: utterances
+      )
+      assert((200..299).cover?(service_response.status))
+    end
   end
 end