stealth 1.1.5 → 2.0.0.beta3

data/lib/stealth/scheduled_reply.rb

@@ -6,12 +6,12 @@ module Stealth
   class ScheduledReplyJob < Stealth::Jobs
     sidekiq_options queue: :stealth_replies, retry: false
 
-    def perform(service, user_id, flow, state)
+    def perform(service, user_id, flow, state, target_id=nil)
       service_message = ServiceMessage.new(service: service)
       service_message.sender_id = user_id
+      service_message.target_id = target_id
       controller = BotController.new(service_message: service_message)
-      controller.update_session_to(flow: flow, state: state)
-      controller.route
+      controller.step_to(flow: flow, state: state)
     end
   end
 

data/lib/stealth/server.rb

@@ -30,7 +30,7 @@ module Stealth
     end
 
     get_or_post '/incoming/:service' do
-      Stealth::Logger.l(topic: "incoming", message: "Received webhook from #{params[:service]}")
+      Stealth::Logger.l(topic: params[:service], message: 'Received webhook.')
 
       # JSON params need to be parsed and added to the params
       if request.env['CONTENT_TYPE']&.match(/application\/json/i)
@@ -44,14 +44,19 @@ module Stealth
         headers: get_helpers_from_request(request)
       )
 
+      headers 'Access-Control-Allow-Origin' => '*',
+              'Access-Control-Allow-Methods' => ['OPTIONS', 'GET', 'POST']
+      # content_type 'audio/mp3'
+      content_type 'application/octet-stream'
+
       dispatcher.coordinate
     end
 
     private
 
       def get_helpers_from_request(request)
-        request.env.reject do |header, value|
-          header.match(/rack\.|puma\.|sinatra\./)
+        request.env.select do |header, value|
+          %w[HTTP_HOST].include?(header)
         end
       end
 

data/lib/stealth/service_message.rb

@@ -4,8 +4,9 @@
 module Stealth
   class ServiceMessage
 
-    attr_accessor :sender_id, :timestamp, :service, :message, :location,
-                  :attachments, :payload, :referral
+    attr_accessor :sender_id, :target_id, :timestamp, :service, :message,
+                  :location, :attachments, :payload, :referral, :nlp_result,
+                  :catch_all_reason
 
     def initialize(service:)
       @service = service

data/lib/stealth/service_reply.rb

@@ -18,7 +18,11 @@ module Stealth
         @yaml_reply
       end
 
-      @replies = load_replies(YAML.load(processed_reply))
+      if yaml_reply.is_a?(Array)
+        @replies = load_replies(@yaml_reply)
+      else
+        @replies = load_replies(YAML.load(processed_reply))
+      end
     end
 
     private

data/lib/stealth/services/base_reply_handler.rb

@@ -8,8 +8,8 @@ module Stealth
       attr_reader :recipient_id, :reply
 
       def initialize(recipient_id:, reply:)
-        @client = client
-        @options = options
+        @recipient_id = recipient_id
+        @reply = reply
       end
 
       def text
@@ -60,6 +60,14 @@ module Stealth
         reply_format_not_supported(format: 'delay')
       end
 
+      def speech
+        reply_format_not_supported(format: 'speech')
+      end
+
+      def ssml
+        reply_format_not_supported(format: 'ssml')
+      end
+
     end
   end
 end

data/lib/stealth/session.rb

@@ -4,21 +4,30 @@
 module Stealth
   class Session
 
+    include Stealth::Redis
+
     SLUG_SEPARATOR = '->'
 
-    attr_reader :flow, :state, :user_id, :previous
+    attr_reader :flow, :state, :id, :type
     attr_accessor :session
 
-    def initialize(user_id: nil, previous: false)
-      @user_id = user_id
-      @previous = previous
+    # Session types:
+    #   - :primary
+    #   - :previous
+    #   - :back_to
+    def initialize(id: nil, type: :primary)
+      @id = id
+      @type = type
 
-      if user_id.present?
+      if id.present?
         unless defined?($redis) && $redis.present?
-          raise(Stealth::Errors::RedisNotConfigured, "Please make sure REDIS_URL is configured before using sessions")
+          raise(
+            Stealth::Errors::RedisNotConfigured,
+            "Please make sure REDIS_URL is configured before using sessions"
+          )
         end
 
-        get
+        get_session
       end
 
       self
@@ -31,6 +40,14 @@ module Stealth
       }
     end
 
+    def self.slugify(flow:, state:)
+      unless flow.present? && state.present?
+        raise(ArgumentError, 'A flow and state must be specified.')
+      end
+
+      [flow, state].join(SLUG_SEPARATOR)
+    end
+
     def flow
       return nil if flow_string.blank?
 
@@ -49,31 +66,32 @@ module Stealth
       session&.split(SLUG_SEPARATOR)&.last
     end
 
-    def get
-      prev_key = previous_session_key(user_id: user_id)
-
-      @session ||= begin
-        if sessions_expire?
-          previous? ? getex(prev_key) : getex(user_id)
-        else
-          previous? ? $redis.get(prev_key) : $redis.get(user_id)
-        end
-      end
+    def get_session
+      @session ||= get_key(session_key)
     end
 
-    def set(flow:, state:)
-      store_current_to_previous(flow: flow, state: state)
-
-      @flow = nil
-      @session = self.class.canonical_session_slug(flow: flow, state: state)
+    def set_session(new_flow:, new_state:)
+      @flow = nil # override @flow's memoization
+      existing_session = session # tmp backup for previous_session storage
+      @session = self.class.canonical_session_slug(
+        flow: new_flow,
+        state: new_state
+      )
+
+      Stealth::Logger.l(
+        topic: [type, 'session'].join('_'),
+        message: "User #{id}: setting session to #{new_flow}->#{new_state}"
+      )
+
+      if primary_session?
+        store_current_to_previous(existing_session: existing_session)
+      end
 
-      Stealth::Logger.l(topic: "session", message: "User #{user_id}: setting session to #{flow}->#{state}")
+      persist_key(key: session_key, value: session)
+    end
 
-      if sessions_expire?
-        $redis.setex(user_id, Stealth.config.session_ttl, session)
-      else
-        $redis.set(user_id, session)
-      end
+    def clear_session
+      $redis.del(session_key)
     end
 
     def present?
@@ -84,17 +102,16 @@ module Stealth
       !present?
     end
 
-    def previous?
-      @previous
-    end
-
     def +(steps)
       return nil if flow.blank?
       return self if steps.zero?
 
       new_state = self.state + steps
-      new_session = Stealth::Session.new(user_id: self.user_id)
-      new_session.session = self.class.canonical_session_slug(flow: self.flow_string, state: new_state)
+      new_session = Stealth::Session.new(id: self.id)
+      new_session.session = self.class.canonical_session_slug(
+        flow: self.flow_string,
+        state: new_state
+      )
 
       new_session
     end
@@ -109,6 +126,13 @@ module Stealth
       end
     end
 
+    def ==(other_session)
+      self.flow_string == other_session.flow_string &&
+        self.state_string == other_session.state_string &&
+        self.type == other_session.type &&
+        self.id == other_session.id
+    end
+
     def self.is_a_session_string?(string)
       session_regex = /(.+)(#{SLUG_SEPARATOR})(.+)/
       !!string.match(session_regex)
@@ -118,32 +142,61 @@ module Stealth
       [flow, state].join(SLUG_SEPARATOR)
     end
 
-    private
-
-      def previous_session_key(user_id:)
-        [user_id, 'previous'].join('-')
+    def session_key
+      case type
+      when :primary
+        id
+      when :previous
+        previous_session_key
+      when :back_to
+        back_to_key
       end
+    end
 
-      def store_current_to_previous(flow:, state:)
-        new_session = self.class.canonical_session_slug(flow: flow, state: state)
+    def primary_session?
+      type == :primary
+    end
 
-        # Prevent previous_session from becoming current_session
-        if new_session == session
-          Stealth::Logger.l(topic: "previous_session", message: "User #{user_id}: skipping setting to #{session} because it is the same as current_session")
-        else
-          Stealth::Logger.l(topic: "previous_session", message: "User #{user_id}: setting to #{session}")
-          $redis.set(previous_session_key(user_id: user_id), session)
-        end
+    def previous_session?
+      type == :previous
+    end
+
+    def back_to_session?
+      type == :back_to
+    end
+
+    def to_s
+      [flow_string, state_string].join(SLUG_SEPARATOR)
+    end
+
+    private
+
+      def previous_session_key
+        [id, 'previous'].join('-')
       end
 
-      def sessions_expire?
-        Stealth.config.session_ttl > 0
+      def back_to_key
+        [id, 'back_to'].join('-')
       end
 
-      def getex(key)
-        $redis.multi do
-          $redis.expire(key, Stealth.config.session_ttl)
-          $redis.get(key)
+      def store_current_to_previous(existing_session:)
+        # Prevent previous_session from becoming current_session
+        if session == existing_session
+          Stealth::Logger.l(
+            topic: "previous_session",
+            message: "User #{id}: skipping setting to #{session}"\
+                     ' because it is the same as current_session'
+          )
+        else
+          Stealth::Logger.l(
+            topic: "previous_session",
+            message: "User #{id}: setting to #{existing_session}"
+          )
+
+          persist_key(
+            key: previous_session_key,
+            value: existing_session
+          )
         end
       end
 

data/spec/configuration_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::Configuration" do
 
@@ -29,6 +28,14 @@ describe "Stealth::Configuration" do
     it "should handle multiple keys at the root level" do
       expect(config.twilio_sms.account_sid).to eq parsed_config['twilio_sms']['account_sid']
     end
+
+    it "should return nil if the key is not present at the node" do
+      expect(config.twilio_sms.api_key).to be nil
+    end
+
+    it "should raise a NoMethodError when accessing multi-levels of missing nodes" do
+      expect { config.slack.api_key }.to raise_error(NoMethodError)
+    end
   end
 
   describe "config files with ERB" do
@@ -50,4 +57,37 @@ describe "Stealth::Configuration" do
     end
   end
 
+  describe "configuring with default values" do
+    let(:config) {
+      Stealth::Configuration.new(
+        { 'a' => nil, 'x' => 0, 'y' => false, 'z' => '' }
+      )
+    }
+
+    it 'should replace a nil value' do
+      config.set_default('a', 99)
+      expect(config.a).to eq 99
+    end
+
+    it 'should NOT replace a zero value' do
+      config.set_default('x', 99)
+      expect(config.x).to eq 0
+    end
+
+    it 'should NOT replace a false value' do
+      config.set_default('y', 99)
+      expect(config.y).to be false
+    end
+
+    it 'should NOT replace a blank string value' do
+      config.set_default('z', 99)
+      expect(config.z).to eq ''
+    end
+
+    it 'should replace a not-set key' do
+      config.set_default('zz', 99)
+      expect(config.zz).to eq 99
+    end
+  end
+
 end

data/spec/controller/callbacks_spec.rb

@@ -1,57 +1,48 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper'))
+require 'spec_helper'
+
+$history = []
 
 class BotController < Stealth::Controller
   before_action :fetch_user_name
 
-  attr_accessor :record
-
   def some_action
-    @record = []
     step_to flow: 'flow_tester', state: 'my_action'
   end
 
   def other_action
-    @record = []
     step_to flow: 'other_flow_tester', state: 'other_action'
   end
 
   def halted_action
-    @record = []
     step_to flow: 'flow_tester', state: 'my_action2'
   end
 
   def filtered_action
-    @record = []
     step_to flow: 'flow_tester', state: 'my_action3'
   end
 
   def some_other_action2
-    @record = []
     step_to flow: 'other_flow_tester', state: 'other_action2'
   end
 
   def some_other_action3
-    @record = []
     step_to flow: 'other_flow_tester', state: 'other_action3'
   end
 
   def some_other_action4
-    @record = []
     step_to flow: 'other_flow_tester', state: 'other_action4'
   end
 
   def some_other_action5
-    @record = []
     step_to flow: 'other_flow_tester', state: 'other_action5'
   end
 
   private
 
     def fetch_user_name
-      @record << "fetched user name"
+      $history << "fetched user name"
     end
 end
 
@@ -77,7 +68,7 @@ class FlowTestersController < BotController
   protected
 
     def test_action
-      @record << "tested action"
+      $history << "tested action"
     end
 
     def test_before_halting
@@ -85,11 +76,11 @@ class FlowTestersController < BotController
     end
 
     def test_filtering
-      @record << "filtered"
+      $history << "filtered"
     end
 
     def test_after_halting
-      @record << "after action ran"
+      $history << "after action ran"
     end
 end
 
@@ -125,11 +116,11 @@ class OtherFlowTestersController < BotController
   private
 
     def after_action1
-      @record << "after action 1"
+      $history << "after action 1"
     end
 
     def after_action2
-      @record << "after action 2"
+      $history << "after action 2"
     end
 
     def run_halt
@@ -137,9 +128,9 @@ class OtherFlowTestersController < BotController
     end
 
     def run_around_filter
-      @record << "around before"
+      $history << "around before"
       yield
-      @record << "around after"
+      $history << "around after"
     end
 end
 
@@ -165,29 +156,33 @@ describe "Stealth::Controller callbacks" do
 
   let(:facebook_message) { SampleMessage.new(service: 'facebook') }
 
+  before(:each) do
+    $history = []
+  end
+
   describe "before_action" do
     it "should fire the callback on the parent class" do
       controller = BotController.new(service_message: facebook_message.message_with_text)
       controller.other_action
-      expect(controller.record).to eq ["fetched user name"]
+      expect($history).to eq ["fetched user name"]
     end
 
     it "should fire the callback on a child class" do
       controller = FlowTestersController.new(service_message: facebook_message.message_with_text)
       controller.some_action
-      expect(controller.record).to eq ["fetched user name", "tested action"]
+      expect($history).to eq ["fetched user name", "tested action"]
     end
 
     it "should halt the callback chain when :abort is thrown" do
       controller = FlowTestersController.new(service_message: facebook_message.message_with_text)
       controller.halted_action
-      expect(controller.record).to eq ["fetched user name"]
+      expect($history).to eq ["fetched user name"]
     end
 
     it "should respect 'unless' filter" do
       controller = FlowTestersController.new(service_message: facebook_message.message_with_text)
       controller.filtered_action
-      expect(controller.record).to eq ["fetched user name", "tested action", "filtered"]
+      expect($history).to eq ["fetched user name", "tested action", "filtered"]
     end
   end
 
@@ -195,13 +190,13 @@ describe "Stealth::Controller callbacks" do
     it "should fire the after callbacks in reverse order" do
       controller = OtherFlowTestersController.new(service_message: facebook_message.message_with_text)
       controller.some_other_action2
-      expect(controller.record).to eq ["fetched user name", "after action 2", "after action 1"]
+      expect($history).to eq ["fetched user name", "after action 2", "after action 1"]
     end
 
     it "should not fire after callbacks if a before callback throws an :abort" do
       controller = OtherFlowTestersController.new(service_message: facebook_message.message_with_text)
       controller.some_other_action3
-      expect(controller.record).to eq ["fetched user name"]
+      expect($history).to eq ["fetched user name"]
     end
   end
 
@@ -209,13 +204,13 @@ describe "Stealth::Controller callbacks" do
     it "should fire the around callback before and after" do
       controller = OtherFlowTestersController.new(service_message: facebook_message.message_with_text)
       controller.some_other_action4
-      expect(controller.record).to eq ["fetched user name", "around before", "around after"]
+      expect($history).to eq ["fetched user name", "around before", "around after"]
     end
 
     it "should not fire the around callback if a before callback throws abort" do
       controller = OtherFlowTestersController.new(service_message: facebook_message.message_with_text)
       controller.some_other_action5
-      expect(controller.record).to eq ["fetched user name"]
+      expect($history).to eq ["fetched user name"]
     end
   end