stealth 1.1.2 → 2.0.0.beta1

data/spec/nlp/client_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::Nlp::Client" do
+
+  describe 'blank client' do
+    let(:nlp_client) { Stealth::Nlp::Client.new }
+
+    it 'should return nil for client' do
+      expect(nlp_client.client).to be_nil
+    end
+
+    it 'should return nil for the understand call' do
+      expect(nlp_client.understand(query: 'hello world!')).to be_nil
+    end
+
+    it 'should return nil for the understand_speec call' do
+      expect(nlp_client.understand_speech(audio_file: 'https://path.to/audio.mp3')).to be_nil
+    end
+  end
+
+end

data/spec/nlp/result_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::Nlp::Result" do
+
+  it 'should return the built-in entity types' do
+    expect(Stealth::Nlp::Result::ENTITY_TYPES).to eq %i(number currency email percentage phone age
+                      url ordinal geo dimension temp datetime duration
+                      key_phrase name)
+  end
+
+  describe 'blank result' do
+    let(:stealth_result) { Stealth::Nlp::Result.new(result: 1234) }
+
+    it 'should initialize @result to the value provided during instantiation' do
+      expect(stealth_result.result).to eq 1234
+    end
+
+    it 'should return nil for parsed_result' do
+      expect(stealth_result.parsed_result).to be_nil
+    end
+
+    it 'should return nil for intent_id' do
+      expect(stealth_result.intent_id).to be_nil
+    end
+
+    it 'should return nil for intent' do
+      expect(stealth_result.intent).to be_nil
+    end
+
+    it 'should return nil for intent_score' do
+      expect(stealth_result.intent_score).to be_nil
+    end
+
+    it 'should return {} for raw_entities' do
+      expect(stealth_result.raw_entities).to eq({})
+    end
+
+    it 'should return {} for entities' do
+      expect(stealth_result.entities).to eq({})
+    end
+
+    it 'should return nil for sentiment' do
+      expect(stealth_result.sentiment).to be_nil
+    end
+
+    it 'should return nil for sentiment_score' do
+      expect(stealth_result.sentiment_score).to be_nil
+    end
+
+    it 'should return false for present?' do
+      expect(stealth_result.present?).to be false
+    end
+  end
+
+end

data/spec/replies/messages/say_msgs_without_breaks.yml

@@ -0,0 +1,4 @@
+- reply_type: text
+  text: "Hi, Morty. Welcome to Stealth bot..."
+- reply_type: text
+  text: "We offer users an awesome Ruby framework for building chat bots."

data/spec/replies/messages/say_randomize_speech.yml

@@ -0,0 +1,10 @@
+- reply_type: speech
+  text:
+    - Build amazing chatbots with tools you know and love.
+    - Stealth is an open source Ruby framework for voice and text chatbots.
+    - From our MVC architecture to our convention over configuration philosophy, you'll feel right at home with Stealth.
+    - Every service integration in Stealth is a Ruby gem.
+    - From web servers to continuous integration testing, Stealth is built to take advantage of all the great work done by the web development community.
+    - Stealth is a Rack application.
+    - Stealth already powers bots for large, well-known brands.
+    - Stealth is MIT licensed to ensure you own your bot.

data/spec/replies/messages/say_randomize_text.yml

@@ -0,0 +1,10 @@
+- reply_type: text
+  text:
+    - Build amazing chatbots with tools you know and love.
+    - Stealth is an open source Ruby framework for voice and text chatbots.
+    - From our MVC architecture to our convention over configuration philosophy, you'll feel right at home with Stealth.
+    - Every service integration in Stealth is a Ruby gem.
+    - From web servers to continuous integration testing, Stealth is built to take advantage of all the great work done by the web development community.
+    - Stealth is a Rack application.
+    - Stealth already powers bots for large, well-known brands.
+    - Stealth is MIT licensed to ensure you own your bot.

data/spec/replies/messages/sub1/sub2/say_nested.yml

@@ -0,0 +1,10 @@
+- 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."
+- reply_type: delay
+  duration: 2
+- reply_type: text
+  text: "This reply was nested."

data/spec/reply_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::Reply" do
+
+  let!(:unstructured_text) {
+    { 'reply_type' => 'text', 'text' => 'Hello World!' }
+  }
+  let!(:unstructured_delay) {
+    { 'reply_type' => 'delay', 'duration' => 'dynamic' }
+  }
+  let(:text_reply) { Stealth::Reply.new(unstructured_reply: unstructured_text) }
+  let(:delay_reply) { Stealth::Reply.new(unstructured_reply: unstructured_delay) }
+
+  describe 'hash-like [] getter' do
+    it 'should return the values' do
+      expect(text_reply['text']).to eq 'Hello World!'
+      expect(delay_reply['duration']).to eq 'dynamic'
+    end
+  end
+
+  describe 'hash-like []= setter' do
+    it 'should return the values' do
+      text_reply['woot'] = 'root'
+      delay_reply['duration'] = 4.3
+      expect(text_reply['woot']).to eq 'root'
+      expect(delay_reply['duration']).to eq 4.3
+    end
+  end
+
+  describe 'reply_type' do
+    it 'should act as a getter method for reply_type' do
+      expect(text_reply.reply_type).to eq 'text'
+      expect(delay_reply.reply_type).to eq 'delay'
+    end
+  end
+
+  describe 'delay?' do
+    it 'should return false for a text reply' do
+      expect(text_reply.delay?).to be false
+    end
+
+    it 'should return true for a delay reply' do
+      expect(delay_reply.delay?).to be true
+    end
+  end
+
+  describe 'self.dynamic_delay' do
+    it 'should return a new Stealth::Reply' do
+      expect(Stealth::Reply.dynamic_delay).to be_a(Stealth::Reply)
+    end
+
+    it 'should be a dynamic delay' do
+      expect(Stealth::Reply.dynamic_delay.delay?).to be true
+      expect(Stealth::Reply.dynamic_delay.reply_type).to eq 'delay'
+      expect(Stealth::Reply.dynamic_delay['duration']).to eq 'dynamic'
+    end
+  end
+
+end

data/spec/scheduled_reply_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::ScheduledReplyJob" do
+
+  let(:scheduled_reply_job) { Stealth::ScheduledReplyJob.new }
+
+  it "should instantiate BotController with service_message, set flow and state, and route" do
+    service_msg_double = double('service_message')
+    expect(Stealth::ServiceMessage).to receive(:new).with(service: 'twilio').and_return(service_msg_double)
+    expect(service_msg_double).to receive(:sender_id=).with('+18885551212')
+    expect(service_msg_double).to receive(:target_id=).with('33322')
+
+    bot_controller_double = double('bot_controller')
+    expect(BotController).to receive(:new).with(service_message: service_msg_double).and_return(bot_controller_double)
+    expect(bot_controller_double).to receive(:step_to).with(flow: 'my_flow', state: 'say_hi')
+
+    scheduled_reply_job = Stealth::ScheduledReplyJob.new
+    scheduled_reply_job.perform('twilio', '+18885551212', 'my_flow', 'say_hi', '33322')
+  end
+
+end

data/spec/service_reply_spec.rb

@@ -1,7 +1,6 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 describe "Stealth::ServiceReply" do
 

data/spec/session_spec.rb

@@ -1,7 +1,6 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 class FlowMap
   include Stealth::Flow
@@ -19,20 +18,20 @@ class FlowMap
 end
 
 describe "Stealth::Session" do
-  let(:user_id) { '0xDEADBEEF' }
+  let(:id) { '0xDEADBEEF' }
 
   it "should raise an error if $redis is not set" do
     $redis = nil
 
     expect {
-      Stealth::Session.new(user_id: user_id)
+      Stealth::Session.new(id: id)
     }.to raise_error(Stealth::Errors::RedisNotConfigured)
 
     $redis = MockRedis.new
   end
 
   describe "without a session" do
-    let(:session) { Stealth::Session.new(user_id: user_id) }
+    let(:session) { Stealth::Session.new(id: id) }
 
     it "should have nil flow and state" do
       expect(session.flow).to be_nil
@@ -52,8 +51,8 @@ describe "Stealth::Session" do
 
   describe "with a session" do
     let(:session) do
-      session = Stealth::Session.new(user_id: user_id)
-      session.set(flow: 'marco', state: 'polo')
+      session = Stealth::Session.new(id: id)
+      session.set_session(new_flow: 'marco', new_state: 'polo')
       session
     end
 
@@ -81,33 +80,71 @@ describe "Stealth::Session" do
   end
 
   describe "incrementing and decrementing" do
-    let(:session) { Stealth::Session.new(user_id: user_id) }
+    let(:session) { Stealth::Session.new(id: id) }
 
     it "should increment the state" do
-      session.set(flow: 'new_todo', state: 'get_due_date')
+      session.set_session(new_flow: 'new_todo', new_state: 'get_due_date')
       new_session = session + 1.state
       expect(new_session.state_string).to eq('created')
     end
 
     it "should decrement the state" do
-      session.set(flow: 'new_todo', state: 'error')
+      session.set_session(new_flow: 'new_todo', new_state: 'error')
       new_session = session - 2.states
       expect(new_session.state_string).to eq('get_due_date')
     end
 
     it "should return the first state if the decrement is out of bounds" do
-      session.set(flow: 'new_todo', state: 'get_due_date')
+      session.set_session(new_flow: 'new_todo', new_state: 'get_due_date')
       new_session = session - 5.states
       expect(new_session.state_string).to eq('new')
     end
 
     it "should return the last state if the increment is out of bounds" do
-      session.set(flow: 'new_todo', state: 'created')
+      session.set_session(new_flow: 'new_todo', new_state: 'created')
       new_session = session + 5.states
       expect(new_session.state_string).to eq('error')
     end
   end
 
+  describe "==" do
+    let(:session) {
+      _session = Stealth::Session.new(id: id, type: :primary)
+      _session.set_session(new_flow: 'hello', new_state: 'say_hola')
+      _session
+    }
+
+    it "should return false if the session ids do not" do
+      other_session = Stealth::Session.new(id: 'xyz123', type: :primary)
+      other_session.set_session(new_flow: 'hello', new_state: 'say_hola')
+      expect(session == other_session).to be false
+    end
+
+    it "should return false if the states do not" do
+      other_session = Stealth::Session.new(id: id, type: :primary)
+      other_session.set_session(new_flow: 'hello', new_state: 'say_hola2')
+      expect(session == other_session).to be false
+    end
+
+    it "should return false if flows do not match" do
+      other_session = Stealth::Session.new(id: id, type: :primary)
+      other_session.set_session(new_flow: 'hello2', new_state: 'say_hola')
+      expect(session == other_session).to be false
+    end
+
+    it 'should return false if the session type does not match' do
+      other_session = Stealth::Session.new(id: id, type: :back_to)
+      other_session.set_session(new_flow: 'hello', new_state: 'say_hola')
+      expect(session == other_session).to be false
+    end
+
+    it 'should return true if the session id, flow, state, and session types match' do
+      other_session = Stealth::Session.new(id: id, type: :primary)
+      other_session.set_session(new_flow: 'hello', new_state: 'say_hola')
+      expect(session == other_session).to be true
+    end
+  end
+
   describe "self.is_a_session_string?" do
     it "should return false for state strings" do
       session_string = 'say_hello'
@@ -124,4 +161,206 @@ describe "Stealth::Session" do
       expect(Stealth::Session.is_a_session_string?(session_string)).to be true
     end
   end
+
+  describe "self.canonical_session_slug" do
+    it "should generate a canonical session slug given a flow and state as symbols" do
+      expect(
+        Stealth::Session.canonical_session_slug(flow: :hello, state: :say_hello)
+      ).to eq 'hello->say_hello'
+    end
+
+    it "should generate a canonical session slug given a flow and state as strings" do
+      expect(
+        Stealth::Session.canonical_session_slug(flow: 'hello', state: 'say_hello')
+      ).to eq 'hello->say_hello'
+    end
+  end
+
+  describe "self.flow_and_state_from_session_slug" do
+    it "should return the flow and string as a hash with symbolized keys" do
+      slug = 'hello->say_hello'
+      expect(
+        Stealth::Session.flow_and_state_from_session_slug(slug: slug)
+      ).to eq({ flow: 'hello', state: 'say_hello' })
+    end
+
+    it "should not raise if slug is nil" do
+      slug = nil
+      expect(
+        Stealth::Session.flow_and_state_from_session_slug(slug: slug)
+      ).to eq({ flow: nil, state: nil })
+    end
+  end
+
+  describe "setting sessions" do
+    let(:session) { Stealth::Session.new(id: id) }
+    let(:previous_session) { Stealth::Session.new(id: id, type: :previous) }
+    let(:back_to_session) { Stealth::Session.new(id: id, type: :back_to) }
+
+    before(:each) do
+      $redis.del(id)
+      $redis.del([id, 'previous'].join('-'))
+      $redis.del([id, 'back_to'].join('-'))
+    end
+
+    it "should store the new session" do
+      session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect($redis.get(id)).to eq 'marco->polo'
+    end
+
+    it "should store the current_session to previous_session" do
+      $redis.set(id, 'new_todo->new')
+      $redis.set([id, 'previous'].join('-'), 'new_todo->error')
+      session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect(previous_session.get_session).to eq 'new_todo->new'
+    end
+
+    it "should not update previous_session if it matches current_session" do
+      $redis.set(id, 'marco->polo')
+      $redis.set([id, 'previous'].join('-'), 'new_todo->new')
+      session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect(previous_session.get_session).to eq 'new_todo->new'
+    end
+
+    it "should set an expiration for current_session if session_ttl is specified" do
+      Stealth.config.session_ttl = 500
+      session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect($redis.ttl(id)).to be > 0
+      Stealth.config.session_ttl = 0
+    end
+
+    it "should set an expiration for previous_session if session_ttl is specified" do
+      Stealth.config.session_ttl = 500
+      $redis.set(id, 'new_todo->new')
+      session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect($redis.ttl([id, 'previous'].join('-'))).to be > 0
+      Stealth.config.session_ttl = 0
+    end
+
+    it "should NOT set an expiration if session_ttl is not specified" do
+      Stealth.config.session_ttl = 0
+      session.set_session(new_flow: 'new_todo', new_state: 'get_due_date')
+      expect($redis.ttl(id)).to eq -1 # Does not expire
+    end
+
+    it "should set the session for back_to" do
+      back_to_session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect($redis.get([id, 'back_to'].join('-'))).to eq 'marco->polo'
+    end
+
+    it "should set an expiration for back_to if session_ttl is specified" do
+      Stealth.config.session_ttl = 500
+      back_to_session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect($redis.ttl([id, 'back_to'].join('-'))).to be > 0
+      Stealth.config.session_ttl = 0
+    end
+  end
+
+  describe "getting sessions" do
+    let(:session) { Stealth::Session.new(id: id) }
+    let(:previous_session) { Stealth::Session.new(id: id, type: :previous) }
+    let(:back_to_session) { Stealth::Session.new(id: id, type: :back_to) }
+
+    before(:each) do
+      $redis.del(id)
+      $redis.del([id, 'previous'].join('-'))
+      $redis.del([id, 'back_to'].join('-'))
+    end
+
+    it "should return the stored current_session" do
+      session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect(session.get_session).to eq 'marco->polo'
+    end
+
+    it "should return the stored previous_session if previous is requested" do
+      $redis.set(id, 'new_todo->new')
+      session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect(previous_session.get_session).to eq 'new_todo->new'
+    end
+
+    it "should update the expiration of current_session if session_ttl is set" do
+      Stealth.config.session_ttl = 50
+      session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect($redis.ttl(id)).to be_between(0, 50).inclusive
+
+      Stealth.config.session_ttl = 500
+      session.session = nil # reset memoization
+      session.get_session
+      expect($redis.ttl(id)).to be > 100
+
+      Stealth.config.session_ttl = 0
+    end
+
+    it "should return the stored back_to_session" do
+      back_to_session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect(back_to_session.get_session).to eq 'marco->polo'
+    end
+
+    it "should update the expiration of back_to_session if session_ttl is set" do
+      Stealth.config.session_ttl = 50
+      back_to_session.set_session(new_flow: 'marco', new_state: 'polo')
+      expect($redis.ttl([id, 'back_to'].join('-'))).to be_between(0, 50).inclusive
+
+      Stealth.config.session_ttl = 500
+      back_to_session.session = nil # reset memoization
+      back_to_session.get_session
+      expect($redis.ttl([id, 'back_to'].join('-'))).to be > 100
+
+      Stealth.config.session_ttl = 0
+    end
+  end
+
+  describe "clearing sessions" do
+    let(:session) { Stealth::Session.new(id: id) }
+    let(:previous_session) { Stealth::Session.new(id: id, type: :previous) }
+    let(:back_to_session) { Stealth::Session.new(id: id, type: :back_to) }
+
+    before(:each) do
+      session.send(:persist_key, key: session.session_key, value: '1')
+      previous_session.send(:persist_key, key: previous_session.session_key, value: '1')
+      back_to_session.send(:persist_key, key: back_to_session.session_key, value: '1')
+    end
+
+    it "should remove a default session from Redis" do
+      expect($redis.get(session.session_key)).to eq '1'
+      session.clear_session
+      expect($redis.get(session.session_key)).to be_nil
+    end
+
+    it "should remove a previous session from Redis" do
+      expect($redis.get(previous_session.session_key)).to eq '1'
+      previous_session.clear_session
+      expect($redis.get(previous_session.session_key)).to be_nil
+    end
+
+    it "should remove a back_to session from Redis" do
+      expect($redis.get(back_to_session.session_key)).to eq '1'
+      back_to_session.clear_session
+      expect($redis.get(back_to_session.session_key)).to be_nil
+    end
+  end
+
+  describe "self.slugify" do
+    it "should return a session slug given a flow and state" do
+      expect(Stealth::Session.slugify(flow: 'hello', state: 'world')).to eq 'hello->world'
+    end
+
+    it "should raise an ArgumentError if flow is blank" do
+      expect {
+        Stealth::Session.slugify(flow: '', state: 'world')
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an ArgumentError if state is blank" do
+      expect {
+        Stealth::Session.slugify(flow: 'hello', state: nil)
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an ArgumentError if flow and state are blank" do
+      expect {
+        Stealth::Session.slugify(flow: nil, state: nil)
+      }.to raise_error(ArgumentError)
+    end
+  end
 end