stealth 1.1.6 → 2.0.0.beta1

data/spec/controller/dynamic_delay_spec.rb

@@ -1,72 +1,70 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper'))
+require 'spec_helper'
 
 describe "Stealth::Controller::DynamicDelay" do
 
   let(:facebook_message) { SampleMessage.new(service: 'facebook') }
   let(:controller) { VadersController.new(service_message: facebook_message.message_with_text) }
-  let(:service_replies) { YAML.load(File.read(File.expand_path("../replies/messages/say_howdy_with_dynamic.yml", __dir__))) }
+  let!(:service_replies) { YAML.load(File.read(File.expand_path("../replies/messages/say_howdy_with_dynamic.yml", __dir__))) }
 
   it "should return a SHORT_DELAY for a dynamic delay at position 0" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 0)
+    delay = controller.dynamic_delay(previous_reply: nil)
     expect(delay).to eq(Stealth::Controller::DynamicDelay::SHORT_DELAY)
   end
 
-  it "should return a SHORT_DELAY for a dynamic delay at position -1" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: -1)
-    expect(delay).to eq(Stealth::Controller::DynamicDelay::SHORT_DELAY)
+  it "should return a STANDARD_DELAY for a dynamic delay at position -2" do
+    delay = controller.dynamic_delay(previous_reply: service_replies[-2])
+    expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY)
   end
 
   it "should return a SHORT_DELAY for text 35 chars long" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 2)
+    delay = controller.dynamic_delay(previous_reply: service_replies[1])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::SHORT_DELAY)
   end
 
   it "should return a STANDARD_DELAY for text 120 chars long" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 4)
+    delay = controller.dynamic_delay(previous_reply: service_replies[3])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY)
   end
 
   it "should return a (STANDARD_DELAY * 1.5) for text 230 chars long" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 6)
+    delay = controller.dynamic_delay(previous_reply: service_replies[5])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY * 1.5)
   end
 
   it "should return a LONG_DELAY for text 350 chars long" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 8)
+    delay = controller.dynamic_delay(previous_reply: service_replies[7])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::LONG_DELAY)
   end
 
   it "should return a STANDARD_DELAY for an image" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 10)
+    delay = controller.dynamic_delay(previous_reply: service_replies[9])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY)
   end
 
   it "should return a STANDARD_DELAY for a video" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 12)
+    delay = controller.dynamic_delay(previous_reply: service_replies[11])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY)
   end
 
   it "should return a STANDARD_DELAY for an audio" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 14)
+    delay = controller.dynamic_delay(previous_reply: service_replies[13])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY)
   end
 
   it "should return a STANDARD_DELAY for a file" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 16)
+    delay = controller.dynamic_delay(previous_reply: service_replies[15])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY)
   end
 
   it "should return a STANDARD_DELAY for cards" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 18)
+    delay = controller.dynamic_delay(previous_reply: service_replies[17])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY)
   end
 
   it "should return a STANDARD_DELAY for a list" do
-    delay = controller.dynamic_delay(service_replies: service_replies, position: 20)
+    delay = controller.dynamic_delay(previous_reply: service_replies[19])
     expect(delay).to eq(Stealth::Controller::DynamicDelay::STANDARD_DELAY)
   end
 end
-

data/spec/controller/helpers_spec.rb

@@ -1,7 +1,6 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper'))
+require 'spec_helper'
 
 $:.unshift File.expand_path("../support/helpers", __dir__)
 

data/spec/controller/interrupt_detect_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::Controller::InterruptDetect" do
+
+  let(:fb_message) { SampleMessage.new(service: 'facebook') }
+  let(:controller) { VadersController.new(service_message: fb_message.message_with_text) }
+  let(:lock_key) { "#{fb_message.sender_id}-lock" }
+  let(:example_tid) { 'ovefhgJvx' }
+  let(:example_session) { 'goodbye->say_goodbye' }
+  let(:example_position) { 2 }
+  let(:example_lock) { "#{example_tid}##{example_session}:#{example_position}" }
+
+  describe 'current_lock' do
+    it "should return the current lock for the session if it is locked" do
+      $redis.set(lock_key, example_lock)
+      current_lock = controller.current_lock
+      expect(current_lock).to be_a(Stealth::Lock)
+      expect(current_lock.session_id).to eq fb_message.sender_id
+    end
+
+    it "should return nil if the current session is not locked" do
+      random_lock_key = "xyz123-lock"
+
+      # clear the memoization
+      controller.instance_eval do
+        @current_lock = nil
+        @current_session_id = random_lock_key
+      end
+
+      expect($redis.get(random_lock_key)).to be_nil
+      expect(controller.current_lock).to be_nil
+    end
+  end
+
+  describe 'run_interrupt_action' do
+    let(:interrupts_controller) { InterruptController.new(service_message: fb_message) }
+
+    it "should return false if an InterruptsController is not defined" do
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: 'interrupt',
+        message: "Interrupt detected for session #{fb_message.sender_id}"
+      ).ordered
+
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: 'interrupt',
+        message: 'Ignoring interrupt; InterruptsController not defined.'
+      ).ordered
+
+      expect(controller.run_interrupt_action).to be false
+    end
+
+    it "should call say_interrupted on the InterruptsController" do
+      class InterruptsController < Stealth::Controller
+        def say_interrupted
+        end
+      end
+
+      expect_any_instance_of(InterruptsController).to receive(:say_interrupted)
+      controller.run_interrupt_action
+    end
+
+    it "should log if the InterruptsController#say_interrupted does not progress the session" do
+      class InterruptsController < Stealth::Controller
+        def say_interrupted
+        end
+      end
+
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: 'interrupt',
+        message: "Interrupt detected for session #{fb_message.sender_id}"
+      ).ordered
+
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: 'interrupt',
+        message: 'Did not send replies, update session, or step'
+      ).ordered
+
+      controller.run_interrupt_action
+    end
+
+    it "should catch StandardError from within InterruptController and log it" do
+      class InterruptsController < Stealth::Controller
+        def say_interrupted
+          raise Stealth::Errors::ReplyNotFound
+        end
+      end
+
+      # Once for the interrupt detection, once for the error
+      expect(Stealth::Logger).to receive(:l).exactly(2).times
+
+      controller.run_interrupt_action
+    end
+  end
+
+  describe 'interrupt_detected?' do
+    it "should return false if there is not a lock on the session" do
+      random_lock_key = "xyz123-lock"
+
+      # clear the memoization
+      controller.instance_eval do
+        @current_lock = nil
+        @current_session_id = random_lock_key
+      end
+
+      expect(controller.send(:interrupt_detected?)).to be false
+    end
+
+    it "should return false if the current thread owns the lock" do
+      $redis.set(lock_key, example_lock)
+      lock = controller.current_lock
+      expect(lock).to receive(:tid).and_return(Stealth.tid)
+
+      expect(controller.send(:interrupt_detected?)).to be false
+    end
+
+    it 'should return true if the session is locked by another thread' do
+      $redis.set(lock_key, example_lock)
+      # our mock tid will not match the real tid for this test
+      expect(controller.send(:interrupt_detected?)).to be true
+    end
+  end
+
+  describe 'current_thread_has_control?' do
+    it "should return true if the current tid matches the lock tid" do
+      $redis.set(lock_key, example_lock)
+      lock = controller.current_lock
+      expect(lock).to receive(:tid).and_return(Stealth.tid)
+      expect(controller.send(:current_thread_has_control?)).to be true
+    end
+
+    it "should return false if the current tid does not match the lock tid" do
+      $redis.set(lock_key, example_lock)
+      lock = controller.current_lock
+      expect(controller.send(:current_thread_has_control?)).to be false
+    end
+  end
+
+  describe 'lock_session!' do
+    it "should create a lock for the session" do
+      $redis.del(lock_key)
+      controller.send(:lock_session!, session_slug: example_session, position: example_position)
+      expect($redis.get(lock_key)).to match(/goodbye\-\>say_goodbye\:2/)
+    end
+  end
+
+  describe 'release_lock!' do
+    it "should not raise an error if current_lock is nil" do
+      expect(controller).to receive(:current_lock).and_return(nil)
+      controller.send(:release_lock!)
+    end
+
+    it "should not release the lock if we are in the InterruptsController" do
+      class InterruptsController
+      end
+
+      lock = controller.current_lock
+      expect(controller).to receive(:class).and_return InterruptsController
+      expect(lock).to_not receive(:release)
+      controller.send(:release_lock!)
+    end
+
+    it "should release the lock if there is one and we are not in the InterruptsController" do
+      $redis.set(lock_key, example_lock)
+      controller.send(:release_lock!)
+      expect($redis.get(lock_key)).to be_nil
+    end
+  end
+
+end

data/spec/controller/messages_spec.rb

@@ -0,0 +1,744 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Stealth::Controller::Messages do
+
+  class MrTronsController < Stealth::Controller
+
+  end
+
+  let(:facebook_message) { SampleMessage.new(service: 'facebook') }
+  let(:test_controller) {
+    MrTronsController.new(service_message: facebook_message.message_with_text)
+  }
+
+  describe "normalized_msg" do
+    let(:padded_msg) { '  Hello World! 👋  ' }
+    let(:weird_case_msg) { 'Oh BaBy Oh BaBy' }
+
+    it 'should normalize blank-padded messages' do
+      test_controller.current_message.message = padded_msg
+      expect(test_controller.normalized_msg).to eq('HELLO WORLD! 👋')
+    end
+
+    it 'should normalize differently cased messages' do
+      test_controller.current_message.message = weird_case_msg
+      expect(test_controller.normalized_msg).to eq('OH BABY OH BABY')
+    end
+  end
+
+  describe "homophone_translated_msg" do
+    it 'should convert homophones to their respective alpha ordinal' do
+      Stealth::Controller::Messages::HOMOPHONES.each do |homophone, ordinal|
+        test_controller.current_message.message = homophone
+        test_controller.normalized_msg = test_controller.homophone_translated_msg = nil
+        expect(test_controller.homophone_translated_msg).to eq(ordinal)
+      end
+    end
+  end
+
+  describe "get_match" do
+    it "should match messages with different casing" do
+      test_controller.current_message.message = "NICE"
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('nice')
+    end
+
+    it "should match messages with blank padding" do
+      test_controller.current_message.message = " NiCe   "
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('nice')
+    end
+
+    it "should match messages utilizing a lower case SMS quick reply" do
+      test_controller.current_message.message = "a "
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('nice')
+    end
+
+    it "should match messages utilizing an upper case SMS quick reply" do
+      test_controller.current_message.message = " B "
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('woot')
+    end
+
+    it "should match messages utilizing a single-quoted SMS quick reply" do
+      test_controller.current_message.message = "'B'"
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('woot')
+    end
+
+    it "should match messages utilizing a double-quoted SMS quick reply" do
+      test_controller.current_message.message = '"A"'
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('nice')
+    end
+
+    it "should match messages utilizing a double-smartquoted SMS quick reply" do
+      test_controller.current_message.message = '“A”'
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('nice')
+    end
+
+    it "should match messages utilizing a single-smartquoted SMS quick reply" do
+      test_controller.current_message.message = '‘A’'
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('nice')
+    end
+
+    it "should match messages with a period in the SMS quick reply" do
+      test_controller.current_message.message = 'A.'
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('nice')
+    end
+
+    it "should match messages with a question mark in the SMS quick reply" do
+      test_controller.current_message.message = 'B?'
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('woot')
+    end
+
+    it "should match messages in parens in the SMS quick reply" do
+      test_controller.current_message.message = '(B)'
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('woot')
+    end
+
+    it "should match messages with backticks in the SMS quick reply" do
+      test_controller.current_message.message = '`B`'
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('woot')
+    end
+
+    it "should match messages utilizing a homophone" do
+      test_controller.current_message.message = " bee "
+      expect(
+        test_controller.get_match(['nice', 'woot'])
+      ).to eq('woot')
+    end
+
+    it "should raise ReservedHomophoneUsed if a homophone is used" do
+      test_controller.current_message.message = " B "
+      expect {
+        test_controller.get_match(['nice', 'woot', 'sea', 'bee'])
+      }.to raise_error(Stealth::Errors::ReservedHomophoneUsed, 'Cannot use `SEA, BEE`. Reserved for homophones.')
+    end
+
+    it "should raise Stealth::Errors::UnrecognizedMessage if a response was not matched" do
+      test_controller.current_message.message = "uh oh"
+      expect {
+        test_controller.get_match(['nice', 'woot'])
+      }.to raise_error(Stealth::Errors::UnrecognizedMessage)
+    end
+
+    it "should raise Stealth::Errors::UnrecognizedMessage if an SMS quick reply was not matched" do
+      test_controller.current_message.message = "C"
+      expect {
+        test_controller.get_match(['nice', 'woot'])
+      }.to raise_error(Stealth::Errors::UnrecognizedMessage)
+    end
+
+    it "should not run NLP entity detection if an ordinal is entered by the user" do
+      test_controller.current_message.message = "C"
+
+      expect(test_controller).to_not receive(:perform_nlp!)
+      expect(
+        test_controller.get_match([:yes, :no, 'unsubscribe'])
+      ).to eq('unsubscribe')
+    end
+
+    describe "entity detection" do
+      let(:no_intent) { :no }
+      let(:yes_intent) { :yes }
+      let(:single_number_nlp_result) { TestNlpResult::Luis.new(intent: yes_intent, entity: :single_number_entity) }
+      let(:double_number_nlp_result) { TestNlpResult::Luis.new(intent: no_intent, entity: :double_number_entity) }
+      let(:triple_number_nlp_result) { TestNlpResult::Luis.new(intent: yes_intent, entity: :triple_number_entity) }
+
+      describe 'single nlp_result entity' do
+        it 'should return the :number entity' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(single_number_nlp_result)
+          test_controller.nlp_result = single_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect(
+            test_controller.get_match(['nice', :number])
+          ).to eq(test_controller.nlp_result.entities[:number].first)
+        end
+
+        it 'should return the first :number entity if fuzzy_match=true' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(double_number_nlp_result)
+          test_controller.nlp_result = double_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect(
+            test_controller.get_match(['nice', :number])
+          ).to eq(test_controller.nlp_result.entities[:number].first)
+        end
+
+        it 'should raise Stealth::Errors::UnrecognizedMessage if more than one :number entity is returned and fuzzy_match=false' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(double_number_nlp_result)
+          test_controller.nlp_result = double_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect {
+            test_controller.get_match(['nice', :number], fuzzy_match: false)
+          }.to raise_error(Stealth::Errors::UnrecognizedMessage, "Encountered 2 entity matches of type :number and expected 1. To allow, set fuzzy_match to true.")
+        end
+
+        it 'should log the NLP result if log_all_nlp_results=true' do
+          Stealth.config.log_all_nlp_results = true
+          Stealth.config.nlp_integration = :luis
+
+          luis_client = double('luis_client')
+          allow(luis_client).to receive(:understand).and_return(single_number_nlp_result)
+          allow(Stealth::Nlp::Luis::Client).to receive(:new).and_return(luis_client)
+
+          expect(Stealth::Logger).to receive(:l).with(
+            topic: :nlp,
+            message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> Performing NLP."
+          )
+          expect(Stealth::Logger).to receive(:l).with(
+            topic: :nlp,
+            message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> NLP Result: #{single_number_nlp_result.parsed_result.inspect}"
+          )
+          test_controller.current_message.message = "hi"
+          test_controller.get_match(['nice', :number])
+
+          Stealth.config.log_all_nlp_results = false
+          Stealth.config.nlp_integration = nil
+        end
+      end
+
+      describe 'multiple nlp_result entity matches' do
+        it 'should return the [:number, :number] entity' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(double_number_nlp_result)
+          test_controller.nlp_result = double_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect(
+            test_controller.get_match(['nice', [:number, :number]])
+          ).to eq(double_number_nlp_result.entities[:number])
+        end
+
+        it 'should return the [:number, :number, :number] entity' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(triple_number_nlp_result)
+          test_controller.nlp_result = triple_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect(
+            test_controller.get_match(['nice', [:number, :number, :number]])
+          ).to eq(triple_number_nlp_result.entities[:number])
+        end
+
+        it 'should return the [:number, :number] entity from a triple :number entity result' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(triple_number_nlp_result)
+          test_controller.nlp_result = triple_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect(
+            test_controller.get_match(['nice', [:number, :number]])
+          ).to eq(triple_number_nlp_result.entities[:number].slice(0, 2))
+        end
+
+        it 'should return the :number entity from a triple :number entity result' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(triple_number_nlp_result)
+          test_controller.nlp_result = triple_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect(
+            test_controller.get_match(['nice', :number])
+          ).to eq(triple_number_nlp_result.entities[:number].first)
+        end
+
+        it 'should return the [:number, :key_phrase] entities' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(triple_number_nlp_result)
+          test_controller.nlp_result = triple_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect(
+            test_controller.get_match(['nice', [:number, :key_phrase]])
+          ).to eq([89, 'scores'])
+        end
+
+        it 'should raise Stealth::Errors::UnrecognizedMessage if more than one :number entity is returned and fuzzy_match=false' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(triple_number_nlp_result)
+          test_controller.nlp_result = triple_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect {
+            test_controller.get_match(['nice', :number], fuzzy_match: false)
+          }.to raise_error(Stealth::Errors::UnrecognizedMessage, "Encountered 3 entity matches of type :number and expected 1. To allow, set fuzzy_match to true.")
+        end
+
+        it 'should raise Stealth::Errors::UnrecognizedMessage if more than two :number entities are returned and fuzzy_match=false' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(triple_number_nlp_result)
+          test_controller.nlp_result = triple_number_nlp_result
+
+          test_controller.current_message.message = "hi"
+          expect {
+            test_controller.get_match(['nice', [:number, :number]], fuzzy_match: false)
+          }.to raise_error(Stealth::Errors::UnrecognizedMessage, "Encountered 1 additional entity matches of type :number for match [:number, :number]. To allow, set fuzzy_match to true.")
+        end
+
+        it 'should log the NLP result if log_all_nlp_results=true' do
+          Stealth.config.log_all_nlp_results = true
+          Stealth.config.nlp_integration = :luis
+
+          luis_client = double('luis_client')
+          allow(luis_client).to receive(:understand).and_return(triple_number_nlp_result)
+          allow(Stealth::Nlp::Luis::Client).to receive(:new).and_return(luis_client)
+
+          expect(Stealth::Logger).to receive(:l).with(
+            topic: :nlp,
+            message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> Performing NLP."
+          )
+          expect(Stealth::Logger).to receive(:l).with(
+            topic: :nlp,
+            message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> NLP Result: #{triple_number_nlp_result.parsed_result.inspect}"
+          )
+          test_controller.current_message.message = "hi"
+          test_controller.get_match(['nice', [:number, :number]])
+
+          Stealth.config.log_all_nlp_results = false
+          Stealth.config.nlp_integration = nil
+        end
+      end
+
+      describe 'custom entities' do
+        let(:custom_entity_nlp_result) { TestNlpResult::Luis.new(intent: yes_intent, entity: :custom_entity) }
+
+        it 'should return the text matched by the custom entity' do
+          allow(test_controller).to receive(:perform_nlp!).and_return(custom_entity_nlp_result)
+          test_controller.nlp_result = custom_entity_nlp_result
+
+          test_controller.current_message.message = "call me right away"
+          expect(
+            test_controller.get_match(['nice', :asap])
+          ).to eq 'right away'
+        end
+      end
+    end
+
+    describe "mismatch" do
+      describe 'raise_on_mismatch: true' do
+        it "should raise a Stealth::Errors::UnrecognizedMessage" do
+          test_controller.current_message.message = 'C'
+          expect {
+            test_controller.get_match(['nice', 'woot'])
+          }.to raise_error(Stealth::Errors::UnrecognizedMessage)
+        end
+
+        it "should NOT log if an nlp_result is not present" do
+          test_controller.current_message.message = 'spicy'
+          expect(Stealth::Logger).to_not receive(:l)
+          expect {
+            test_controller.get_match(['nice', 'woot'])
+          }.to raise_error(Stealth::Errors::UnrecognizedMessage)
+        end
+
+        it "should log if an nlp_result is present" do
+          test_controller.current_message.message = 'spicy'
+          nlp_result = double('nlp_result')
+          allow(nlp_result).to receive(:parsed_result).and_return({})
+
+          expect(Stealth::Logger).to receive(:l).with(
+            topic: :nlp,
+            message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> NLP Result: {}"
+          )
+
+          test_controller.nlp_result = nlp_result
+
+          expect {
+            test_controller.get_match(['nice', 'woot'])
+          }.to raise_error(Stealth::Errors::UnrecognizedMessage)
+        end
+      end
+
+      describe 'raise_on_mismatch: false' do
+        it "should not raise a Stealth::Errors::UnrecognizedMessage" do
+          test_controller.current_message.message = 'C'
+          expect {
+            test_controller.get_match(['nice', 'woot'], raise_on_mismatch: false)
+          }.to_not raise_error(Stealth::Errors::UnrecognizedMessage)
+        end
+
+        it "should return the original message" do
+          test_controller.current_message.message = 'spicy'
+          expect(
+            test_controller.get_match(['nice', 'woot'], raise_on_mismatch: false)
+          ).to eq 'spicy'
+        end
+
+        it "should NOT log if an nlp_result is not present" do
+          test_controller.current_message.message = 'spicy'
+          expect(Stealth::Logger).to_not receive(:l)
+          test_controller.get_match(['nice', 'woot'], raise_on_mismatch: false)
+        end
+
+        it "should log if an nlp_result is present" do
+          test_controller.current_message.message = 'spicy'
+          nlp_result = double('nlp_result')
+          allow(nlp_result).to receive(:parsed_result).and_return({})
+
+          expect(Stealth::Logger).to receive(:l).with(
+            topic: :nlp,
+            message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> NLP Result: {}"
+          )
+
+          test_controller.nlp_result = nlp_result
+
+          test_controller.get_match(['nice', 'woot'], raise_on_mismatch: false)
+        end
+      end
+    end
+  end
+
+  describe "handle_message" do
+    it "should run the proc of the matched reply" do
+      expect(STDOUT).to receive(:puts).with('Cool, Refinance 👍')
+
+      test_controller.current_message.message = "B"
+      test_controller.handle_message(
+        'Buy' => proc { puts 'Buy' },
+        'Refinance' => proc { puts 'Cool, Refinance 👍' }
+      )
+    end
+
+    it "should run proc in the binding of the calling instance" do
+      test_controller.current_message.message = "B"
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 2
+    end
+
+    it "should match against single-quoted ordinals" do
+      test_controller.current_message.message = "'B'"
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 2
+    end
+
+    it "should match against double-quoted ordinals" do
+      test_controller.current_message.message = '"A"'
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 1
+    end
+
+    it "should match against double-smartquoted ordinals" do
+      test_controller.current_message.message = '“A”'
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 1
+    end
+
+    it "should match against single-smartquoted ordinals" do
+      test_controller.current_message.message = '‘A’'
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 1
+    end
+
+    it "should match against ordinals with periods" do
+      test_controller.current_message.message = 'A.'
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 1
+    end
+
+    it "should match against ordinals with question marks" do
+      test_controller.current_message.message = 'A?'
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 1
+    end
+
+    it "should match against ordinals with parens" do
+      test_controller.current_message.message = '(A)'
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 1
+    end
+
+    it "should match against ordinals with backticks" do
+      test_controller.current_message.message = '`A`'
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 }
+      )
+
+      expect(x).to eq 1
+    end
+
+    it "should match homophones" do
+      test_controller.current_message.message = 'sea'
+      x = 0
+      test_controller.handle_message(
+        'Buy' => proc { x += 1 },
+        'Refinance' => proc { x += 2 },
+        'Other' => proc { x += 3 }
+      )
+
+      expect(x).to eq 3
+    end
+
+    it "should raise ReservedHomophoneUsed error if an arm contains a reserved homophone" do
+      test_controller.current_message.message = "B"
+      x = 0
+
+      expect {
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          :woot => proc { x += 2 },
+          'Sea' => proc { x += 3 }
+        )
+      }.to raise_error(Stealth::Errors::ReservedHomophoneUsed, 'Cannot use `SEA`. Reserved for homophones.')
+    end
+
+    it "should not run NLP if an ordinal is entered by the user" do
+      test_controller.current_message.message = "C"
+      x = 0
+      test_controller.handle_message(
+        :yes => proc { x += 1 },
+        :no => proc { x += 2 },
+        'Unsubscribe' => proc { x += 3 }
+      )
+
+      expect(test_controller).to_not receive(:perform_nlp!)
+      expect(x).to eq 3
+    end
+
+    describe "intent detection" do
+      let(:no_intent) { :no }
+      let(:yes_intent) { :yes }
+      let(:yes_intent_nlp_result) { TestNlpResult::Luis.new(intent: yes_intent, entity: :single_number_entity) }
+      let(:no_intent_nlp_result) { TestNlpResult::Luis.new(intent: no_intent, entity: :double_number_entity) }
+
+      it 'should support :yes intent' do
+        test_controller.current_message.message = "YAS"
+        allow(test_controller).to receive(:perform_nlp!).and_return(yes_intent_nlp_result)
+        test_controller.nlp_result = yes_intent_nlp_result
+
+        x = 0
+        test_controller.send(
+          :handle_message, {
+            'Buy' => proc { x += 1 },
+            :yes => proc { x += 9 },
+            :no => proc { x += 8 }
+          }
+        )
+
+        expect(x).to eq 9
+      end
+
+      it 'should support :no intent' do
+        test_controller.current_message.message = "NAH"
+        allow(test_controller).to receive(:perform_nlp!).and_return(no_intent_nlp_result)
+        test_controller.nlp_result = no_intent_nlp_result
+
+        x = 0
+        test_controller.send(
+          :handle_message, {
+            'Buy' => proc { x += 1 },
+            :yes => proc { x += 9 },
+            :no => proc { x += 8 }
+          }
+        )
+
+        expect(x).to eq 8
+      end
+
+      it 'should log the NLP result if log_all_nlp_results=true' do
+        Stealth.config.log_all_nlp_results = true
+        Stealth.config.nlp_integration = :luis
+
+        luis_client = double('luis_client')
+        allow(luis_client).to receive(:understand).and_return(yes_intent_nlp_result)
+        allow(Stealth::Nlp::Luis::Client).to receive(:new).and_return(luis_client)
+
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: :nlp,
+          message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> Performing NLP."
+        )
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: :nlp,
+          message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> NLP Result: #{yes_intent_nlp_result.parsed_result.inspect}"
+        )
+        test_controller.current_message.message = "YAS"
+        x = 0
+        test_controller.send(
+          :handle_message, {
+            'Buy' => proc { x += 1 },
+            :yes => proc { x += 9 },
+            :no => proc { x += 8 }
+          }
+        )
+
+        Stealth.config.log_all_nlp_results = false
+        Stealth.config.nlp_integration = nil
+      end
+    end
+
+    describe 'Regexp matcher' do
+      it "should match when the Regexp matches" do
+        test_controller.current_message.message = "About Encom"
+        x = 0
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          'Refinance' => proc { x += 2 },
+          /about/i => proc { x += 10 }
+        )
+        expect(x).to eq 10
+      end
+
+      it "should match positional Regexes" do
+        test_controller.current_message.message = "Jump about"
+        x = 0
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          /\Aabout/i => proc { x += 2 },
+          /about/i => proc { x += 10 }
+        )
+        expect(x).to eq 10
+      end
+
+      it "should match as an alpha ordinal" do
+        test_controller.current_message.message = "C"
+        x = 0
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          'Refinance' => proc { x += 2 },
+          /about/i => proc { x += 10 }
+        )
+        expect(x).to eq 10
+      end
+    end
+
+    describe 'nil matcher' do
+      it "should match the respective ordinal" do
+        test_controller.current_message.message = "C"
+        x = 0
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          'Refinance' => proc { x += 2 },
+          nil => proc { x += 10 }
+        )
+        expect(x).to eq 10
+      end
+
+      it "should match an unknown ordinal" do
+        test_controller.current_message.message = "D"
+        x = 0
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          'Refinance' => proc { x += 2 },
+          nil => proc { x += 10 }
+        )
+        expect(x).to eq 10
+      end
+
+      it "should match free-form text" do
+        test_controller.current_message.message = "Hello world!"
+        x = 0
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          'Refinance' => proc { x += 2 },
+          nil => proc { x += 10 }
+        )
+        expect(x).to eq 10
+      end
+    end
+
+    it "should raise Stealth::Errors::UnrecognizedMessage if the reply does not match" do
+      test_controller.current_message.message = "C"
+      x = 0
+      expect {
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          'Refinance' => proc { x += 2 }
+        )
+      }.to raise_error(Stealth::Errors::UnrecognizedMessage)
+    end
+
+    it "should NOT log if an nlp_result is not present" do
+      test_controller.current_message.message = 'spicy'
+      expect(Stealth::Logger).to_not receive(:l)
+
+      x = 0
+      expect {
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          'Refinance' => proc { x += 2 }
+        )
+      }.to raise_error(Stealth::Errors::UnrecognizedMessage)
+    end
+
+    it "should log if an nlp_result is present" do
+      test_controller.current_message.message = 'spicy'
+      nlp_result = double('nlp_result')
+      allow(nlp_result).to receive(:parsed_result).and_return({})
+
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: :nlp,
+        message: "User 8b3e0a3c-62f1-401e-8b0f-615c9d256b1f -> NLP Result: {}"
+      )
+
+      test_controller.nlp_result = nlp_result
+
+      x = 0
+      expect {
+        test_controller.handle_message(
+          'Buy' => proc { x += 1 },
+          'Refinance' => proc { x += 2 }
+        )
+      }.to raise_error(Stealth::Errors::UnrecognizedMessage)
+    end
+  end
+
+end