stealth 1.1.6 → 2.0.0.beta1

data/spec/controller/nlp_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Stealth::Controller::Nlp do
+
+  let(:fb_message) { SampleMessage.new(service: 'facebook') }
+  let(:controller) { VadersController.new(service_message: fb_message.message_with_text) }
+
+  describe 'nlp_client_klass' do
+    it 'should return the correct class for LUIS' do
+      config_dbl = double('Stealth Config', nlp_integration: :luis).as_null_object
+      allow(Stealth).to receive(:config).and_return(config_dbl)
+      expect(controller.send(:nlp_client_klass)).to eq Stealth::Nlp::Luis::Client
+    end
+
+    it 'should return the correct class for Dialogflow' do
+      config_dbl = double('Stealth Config', nlp_integration: :dialogflow).as_null_object
+      allow(Stealth).to receive(:config).and_return(config_dbl)
+      expect(controller.send(:nlp_client_klass)).to eq Stealth::Nlp::Dialogflow::Client
+    end
+
+    it 'should raise an error if it cannot locate a class' do
+      config_dbl = double('Stealth Config', nlp_integration: :unknown).as_null_object
+      allow(Stealth).to receive(:config).and_return(config_dbl)
+      expect {
+        controller.send(:nlp_client_klass)
+      }.to raise_error(NameError)
+    end
+  end
+
+  describe 'perform_nlp!' do
+
+    describe 'NLP has not yet been configured' do
+      it 'should raise Stealth::Errors::ConfigurationError' do
+        config_dbl = double('Stealth Config', nlp_integration: nil).as_null_object
+        allow(Stealth).to receive(:config).and_return(config_dbl)
+
+        expect {
+          controller.perform_nlp!
+        }.to raise_error(Stealth::Errors::ConfigurationError)
+      end
+    end
+
+    describe 'NLP has been configured' do
+      before(:each) do
+        config_dbl = double('Stealth Config', nlp_integration: :luis).as_null_object
+        @luis_client_dbl = double('LUIS Client')
+        allow(Stealth).to receive(:config).and_return(config_dbl)
+        allow(Stealth::Nlp::Luis::Client).to receive(:new).and_return(@luis_client_dbl)
+      end
+
+      let(:nlp_result) { Stealth::Nlp::Result.new(result: {}) }
+
+      it 'should call understand on the NLP client' do
+        expect(@luis_client_dbl).to receive(:understand).with(query: 'Hello World!').and_return(nlp_result)
+        controller.perform_nlp!
+      end
+
+      it 'should return an Nlp::Result object' do
+        expect(@luis_client_dbl).to receive(:understand).with(query: 'Hello World!').and_return(nlp_result)
+        expect(controller.perform_nlp!).to eq nlp_result
+      end
+
+      it 'should memoize the understand call' do
+        expect(@luis_client_dbl).to receive(:understand).once.with(query: 'Hello World!').and_return(nlp_result)
+        controller.perform_nlp!
+        controller.perform_nlp!
+        controller.perform_nlp!
+      end
+
+      it 'should store the nlp_result for the current controller' do
+        expect(@luis_client_dbl).to receive(:understand).once.with(query: 'Hello World!').and_return(nlp_result)
+        controller.perform_nlp!
+        expect(controller.nlp_result).to eq nlp_result
+      end
+
+      it 'should store the nlp_result for the current service_message' do
+        expect(@luis_client_dbl).to receive(:understand).once.with(query: 'Hello World!').and_return(nlp_result)
+        controller.perform_nlp!
+        expect(controller.current_message.nlp_result).to eq nlp_result
+      end
+
+      it 'should perform the NLP query if it has been cleared out' do
+        expect(@luis_client_dbl).to receive(:understand).exactly(2).times.with(query: 'Hello World!').and_return(nlp_result)
+        controller.perform_nlp!
+        controller.nlp_result = nil
+        controller.perform_nlp!
+      end
+    end
+  end
+
+end

data/spec/controller/replies_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'
 
 describe "Stealth::Controller replies" do
 
@@ -39,9 +38,43 @@ describe "Stealth::Controller replies" do
       send_replies
     end
 
+    def say_msgs_without_breaks
+      send_replies
+    end
+
     def say_uh_oh
       send_replies
     end
+
+    def say_randomize_text
+      send_replies
+    end
+
+    def say_randomize_speech
+      send_replies
+    end
+
+    def say_custom_reply
+      send_replies custom_reply: 'messages/say_offer'
+    end
+
+    def say_howdy_with_dynamic
+      send_replies
+    end
+
+    def say_nested_custom_reply
+      send_replies custom_reply: 'messages/sub1/sub2/say_nested'
+    end
+
+    def say_inline_reply
+      reply = [
+        { 'reply_type' => 'text', 'text' => 'Hi, Morty. Welcome to Stealth bot...' },
+        { 'reply_type' => 'delay', 'duration' => 2 },
+        { 'reply_type' => 'text', 'text' => 'We offer users an awesome Ruby framework for building chat bots.' }
+      ]
+
+      send_replies inline: reply
+    end
   end
 
   describe "missing reply" do
@@ -100,6 +133,11 @@ describe "Stealth::Controller replies" do
       allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
       allow(controller.current_session).to receive(:flow_string).and_return("message")
       allow(controller.current_session).to receive(:state_string).and_return("say_oi")
+      Stealth.config.auto_insert_delays = false
+    end
+
+    after(:each) do
+      Stealth.config.auto_insert_delays = true
     end
 
     it "should translate each reply_type in the reply" do
@@ -139,6 +177,11 @@ describe "Stealth::Controller replies" do
       allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
       allow(controller.current_session).to receive(:flow_string).and_return("message")
       allow(controller.current_session).to receive(:state_string).and_return("say_offer")
+      Stealth.config.auto_insert_delays = false
+    end
+
+    after(:each) do
+      Stealth.config.auto_insert_delays = true
     end
 
     it "should translate each reply_type in the reply" do
@@ -169,6 +212,243 @@ describe "Stealth::Controller replies" do
     end
   end
 
+  describe "custom_reply" do
+    let(:stubbed_handler) { double("handler") }
+    let(:stubbed_client) { double("client") }
+
+    before(:each) do
+      allow(Stealth::Services::Facebook::ReplyHandler).to receive(:new).and_return(stubbed_handler)
+      allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
+      allow(controller.current_session).to receive(:flow_string).and_return("message")
+      allow(controller.current_session).to receive(:state_string).and_return("say_custom_reply")
+      Stealth.config.auto_insert_delays = false
+    end
+
+    after(:each) do
+      Stealth.config.auto_insert_delays = true
+    end
+
+    it "should translate each reply_type in the reply" do
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true).with(2.0)
+
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to receive(:delay).exactly(1).times
+      controller.say_custom_reply
+    end
+
+    it "should transmit each reply_type in the reply" do
+      allow(stubbed_handler).to receive(:text).exactly(2).times
+      allow(stubbed_handler).to receive(:delay).exactly(1).times
+      allow(controller).to receive(:sleep).and_return(true).with(2.0)
+
+      expect(stubbed_client).to receive(:transmit).exactly(3).times
+      controller.say_custom_reply
+    end
+
+    it "should sleep on delays" do
+      allow(stubbed_handler).to receive(:text).exactly(2).times
+      allow(stubbed_handler).to receive(:delay).exactly(1).times
+      allow(stubbed_client).to receive(:transmit).exactly(3).times
+
+      expect(controller).to receive(:sleep).exactly(1).times.with(2.0)
+      controller.say_custom_reply
+    end
+
+    it "should correctly load from sub-dirs" do
+      expect(stubbed_handler).to receive(:text).exactly(3).times
+      expect(stubbed_handler).to receive(:delay).exactly(2).times
+      expect(stubbed_client).to receive(:transmit).exactly(5).times
+
+      expect(controller).to receive(:sleep).exactly(2).times.with(2.0)
+      controller.say_nested_custom_reply
+    end
+  end
+
+  describe "inline replies" do
+    let(:stubbed_handler) { double("handler") }
+    let(:stubbed_client) { double("client") }
+
+    before(:each) do
+      allow(Stealth::Services::Facebook::ReplyHandler).to receive(:new).and_return(stubbed_handler)
+      allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
+      allow(controller.current_session).to receive(:flow_string).and_return("message")
+      allow(controller.current_session).to receive(:state_string).and_return("say_inline_reply")
+      Stealth.config.auto_insert_delays = false
+    end
+
+    after(:each) do
+      Stealth.config.auto_insert_delays = true
+    end
+
+    it "should translate each reply_type in the reply" do
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true).with(2.0)
+
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to receive(:delay).exactly(1).times
+      controller.say_inline_reply
+    end
+
+    it "should transmit each reply_type in the reply" do
+      allow(stubbed_handler).to receive(:text).exactly(2).times
+      allow(stubbed_handler).to receive(:delay).exactly(1).times
+      allow(controller).to receive(:sleep).and_return(true).with(2.0)
+
+      expect(stubbed_client).to receive(:transmit).exactly(3).times
+      controller.say_inline_reply
+    end
+
+    it "should sleep on delays" do
+      allow(stubbed_handler).to receive(:text).exactly(2).times
+      allow(stubbed_handler).to receive(:delay).exactly(1).times
+      allow(stubbed_client).to receive(:transmit).exactly(3).times
+
+      expect(controller).to receive(:sleep).exactly(1).times.with(2.0)
+      controller.say_inline_reply
+    end
+  end
+
+  describe "auto delays" do
+    let(:stubbed_handler) { double("handler") }
+    let(:stubbed_client) { double("client") }
+
+    before(:each) do
+      allow(Stealth::Services::Facebook::ReplyHandler).to receive(:new).and_return(stubbed_handler)
+      allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
+      allow(controller.current_session).to receive(:flow_string).and_return("message")
+      allow(controller.current_session).to receive(:state_string).and_return("say_msgs_without_breaks")
+    end
+
+    it "should add two additional delays to a reply without delays" do
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true)
+
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to receive(:delay).exactly(2).times
+      controller.say_msgs_without_breaks
+    end
+
+    it "should only add a single delay to a reply that already contains a delay" do
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true)
+
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to receive(:delay).exactly(2).times
+      controller.say_offer
+    end
+
+    it "should not add delays if auto_insert_delays = false" do
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true)
+
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to_not receive(:delay)
+
+      Stealth.config.auto_insert_delays = false
+      controller.say_msgs_without_breaks
+      Stealth.config.auto_insert_delays = true
+    end
+  end
+
+  describe "session locking" do
+    let(:stubbed_handler) { double("handler") }
+    let(:stubbed_client) { double("client") }
+
+    before(:each) do
+      allow(Stealth::Services::Facebook::ReplyHandler).to receive(:new).and_return(stubbed_handler)
+      allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
+      allow(controller.current_session).to receive(:flow_string).and_return("message")
+      allow(controller.current_session).to receive(:state_string).and_return("say_offer")
+      Stealth.config.auto_insert_delays = false
+    end
+
+    after(:each) do
+      Stealth.config.auto_insert_delays = true
+    end
+
+    it "should update the lock for each reply_type in the reply" do
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true).with(2.0)
+
+      expect(controller).to receive(:lock_session!).exactly(3).times
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to receive(:delay).exactly(1).times
+      controller.say_offer
+    end
+
+    it "should update the lock position for each reply_type in the reply" do
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true).with(2.0)
+
+      expect(controller).to receive(
+        :lock_session!
+      ).with(
+        session_slug: controller.current_session.get_session,
+        position: 0
+      ).exactly(1).times
+
+      expect(controller).to receive(
+        :lock_session!
+      ).with(
+        session_slug: controller.current_session.get_session,
+        position: 1
+      ).exactly(1).times
+
+      expect(controller).to receive(
+        :lock_session!
+      ).with(
+        session_slug: controller.current_session.get_session,
+        position: 2
+      ).exactly(1).times
+
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to receive(:delay).exactly(1).times
+      controller.say_offer
+    end
+
+    it "should update the lock position with an offset for each reply_type in the reply" do
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true)
+
+      controller.pos = 17 # set the offset
+
+      expect(controller).to receive(
+        :lock_session!
+      ).with(
+        session_slug: controller.current_session.get_session,
+        position: 17
+      ).exactly(1).times
+
+      expect(controller).to receive(
+        :lock_session!
+      ).with(
+        session_slug: controller.current_session.get_session,
+        position: 18
+      ).exactly(1).times
+
+      expect(controller).to receive(
+        :lock_session!
+      ).with(
+        session_slug: controller.current_session.get_session,
+        position: 19
+      ).exactly(1).times
+
+      expect(controller).to receive(
+        :lock_session!
+      ).with(
+        session_slug: controller.current_session.get_session,
+        position: 20
+      ).exactly(1).times
+
+      expect(stubbed_handler).to receive(:cards).exactly(1).time
+      expect(stubbed_handler).to receive(:list).exactly(1).time
+      expect(stubbed_handler).to receive(:delay).exactly(2).times
+      allow(controller.current_session).to receive(:state_string).and_return("say_howdy_with_dynamic")
+      controller.say_howdy_with_dynamic
+    end
+  end
+
   describe "dynamic delays" do
     let(:stubbed_handler) { double("handler") }
     let(:stubbed_client) { double("client") }
@@ -182,33 +462,33 @@ describe "Stealth::Controller replies" do
 
     it "should use the default multiplier if none is set" do
       allow(stubbed_handler).to receive(:text).exactly(2).times
-      allow(stubbed_handler).to receive(:delay).exactly(1).times
-      allow(stubbed_client).to receive(:transmit).exactly(3).times
+      allow(stubbed_handler).to receive(:delay).exactly(2).times
+      allow(stubbed_client).to receive(:transmit).exactly(4).times
 
       delay = Stealth.config.dynamic_delay_muliplier * Stealth::Controller::DynamicDelay::SHORT_DELAY
-      expect(controller).to receive(:sleep).exactly(1).times.with(delay)
+      expect(controller).to receive(:sleep).exactly(2).times.with(delay)
       controller.say_offer_with_dynamic
     end
 
     it "should slow down SHORT_DELAY if dynamic_delay_muliplier > 1" do
       allow(stubbed_handler).to receive(:text).exactly(2).times
-      allow(stubbed_handler).to receive(:delay).exactly(1).times
-      allow(stubbed_client).to receive(:transmit).exactly(3).times
+      allow(stubbed_handler).to receive(:delay).exactly(2).times
+      allow(stubbed_client).to receive(:transmit).exactly(4).times
 
       Stealth.config.dynamic_delay_muliplier = 5
       delay = Stealth.config.dynamic_delay_muliplier * Stealth::Controller::DynamicDelay::SHORT_DELAY
-      expect(controller).to receive(:sleep).exactly(1).times.with(delay)
+      expect(controller).to receive(:sleep).exactly(2).times.with(delay)
       controller.say_offer_with_dynamic
     end
 
     it "should speed up SHORT_DELAY if dynamic_delay_muliplier < 1" do
       allow(stubbed_handler).to receive(:text).exactly(2).times
-      allow(stubbed_handler).to receive(:delay).exactly(1).times
-      allow(stubbed_client).to receive(:transmit).exactly(3).times
+      allow(stubbed_handler).to receive(:delay).exactly(2).times
+      allow(stubbed_client).to receive(:transmit).exactly(4).times
 
       Stealth.config.dynamic_delay_muliplier = 0.1
       delay = Stealth.config.dynamic_delay_muliplier * Stealth::Controller::DynamicDelay::SHORT_DELAY
-      expect(controller).to receive(:sleep).exactly(1).times.with(delay)
+      expect(controller).to receive(:sleep).exactly(2).times.with(delay)
       controller.say_offer_with_dynamic
     end
   end
@@ -256,4 +536,159 @@ describe "Stealth::Controller replies" do
     end
   end
 
+  describe "randomized replies" do
+    let(:stubbed_handler) { double("handler") }
+    let(:stubbed_client) { double("client") }
+
+    before(:each) do
+      allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
+    end
+
+    describe "text replies" do
+      before(:each) do
+        allow(controller.current_session).to receive(:flow_string).and_return("message")
+        allow(controller.current_session).to receive(:state_string).and_return("say_randomize_text")
+        Stealth.config.auto_insert_delays = false
+      end
+
+      after(:each) do
+        Stealth.config.auto_insert_delays = true
+      end
+
+      it "should receive a single text string" do
+        allow(Stealth::Services::Facebook::ReplyHandler).to receive(:new) do |*args|
+          expect(args.first[:reply]['text']).to be_a(String)
+          stubbed_handler
+        end
+        allow(stubbed_handler).to receive(:text).exactly(1).time
+        expect(stubbed_client).to receive(:transmit).exactly(1).time
+        controller.say_randomize_text
+      end
+    end
+  end
+
+  describe "sub-state replies" do
+    let(:stubbed_handler) { double("handler") }
+    let(:stubbed_client) { double("client") }
+
+    before(:each) do
+      allow(Stealth::Services::Facebook::ReplyHandler).to receive(:new).and_return(stubbed_handler)
+      allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
+      allow(controller.current_session).to receive(:flow_string).and_return("message")
+      allow(controller.current_session).to receive(:state_string).and_return("say_offer")
+      allow(stubbed_client).to receive(:transmit).and_return(true)
+      allow(controller).to receive(:sleep).and_return(true)
+    end
+
+    it "should transmit only the last reply in the file when @pos = -1" do
+      expect(stubbed_handler).to receive(:text).exactly(1).time
+      expect(stubbed_handler).to receive(:delay).exactly(1).time # auto-delay
+      controller.pos = -1
+      controller.say_offer
+    end
+
+    it "should transmit the last two replies in the file when @pos = -2" do
+      expect(stubbed_handler).to receive(:text).exactly(1).time
+      expect(stubbed_handler).to receive(:delay).exactly(1).time
+      controller.pos = -2
+      controller.say_offer
+    end
+
+    it "should transmit all the replies in the file when @pos = 0" do
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to receive(:delay).exactly(2).times
+      controller.pos = 0
+      controller.say_offer
+    end
+
+    it "should transmit all the replies in the file when @pos = nil" do
+      expect(stubbed_handler).to receive(:text).exactly(2).times
+      expect(stubbed_handler).to receive(:delay).exactly(2).times
+      expect(controller.pos).to be_nil
+      controller.say_offer
+    end
+  end
+
+  describe "client errors" do
+    let(:stubbed_handler) { double("handler") }
+    let(:stubbed_client) { double("client") }
+
+    before(:each) do
+      allow(Stealth::Services::Facebook::ReplyHandler).to receive(:new).and_return(stubbed_handler)
+      allow(Stealth::Services::Facebook::Client).to receive(:new).and_return(stubbed_client)
+      allow(controller.current_session).to receive(:flow_string).and_return("message")
+      allow(controller.current_session).to receive(:state_string).and_return("say_offer")
+      allow(stubbed_handler).to receive(:delay).exactly(1).time
+      allow(stubbed_handler).to receive(:text).exactly(1).time
+    end
+
+    describe "Stealth::Errors::UserOptOut" do
+      before(:each) do
+        expect(stubbed_client).to receive(:transmit).and_raise(
+          Stealth::Errors::UserOptOut.new('boom')
+        ).once # Retuns early; doesn't send the remaining replies in the file
+      end
+
+      it "should log the unhandled exception if the controller does not have a handle_opt_out method" do
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: :err,
+          message: "User #{facebook_message.sender_id} unhandled exception due to opt-out."
+        )
+        expect(controller).to receive(:do_nothing)
+        controller.say_offer
+      end
+
+      it "should call handle_opt_out method" do
+        expect(controller).to receive(:handle_opt_out)
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: 'facebook',
+          message: "User #{facebook_message.sender_id} opted out. [boom]"
+        )
+        expect(controller).to receive(:do_nothing)
+        controller.say_offer
+      end
+    end
+
+    describe "Stealth::Errors::InvalidSessionID" do
+      before(:each) do
+        expect(stubbed_client).to receive(:transmit).and_raise(
+          Stealth::Errors::InvalidSessionID.new('boom')
+        ).once # Retuns early; doesn't send the remaining replies in the file
+      end
+
+      it "should log the unhandled exception if the controller does not have a handle_invalid_session_id method" do
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: :err,
+          message: "User #{facebook_message.sender_id} unhandled exception due to invalid session_id."
+        )
+        expect(controller).to receive(:do_nothing)
+        controller.say_offer
+      end
+
+      it "should call handle_invalid_session_id method" do
+        expect(controller).to receive(:handle_invalid_session_id)
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: 'facebook',
+          message: "User #{facebook_message.sender_id} has an invalid session_id. [boom]"
+        )
+        expect(controller).to receive(:do_nothing)
+        controller.say_offer
+      end
+    end
+
+    describe 'an unknown client error' do
+      before(:each) do
+        allow(stubbed_client).to receive(:transmit).and_raise(
+          StandardError
+        )
+      end
+
+      it 'should raise the error' do
+        expect {
+          controller.say_offer
+        }.to raise_error(StandardError)
+      end
+    end
+  end
+
 end