stealth 1.1.2 → 2.0.0.beta1

data/spec/controller/unrecognized_message_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::Controller::UnrecognizedMessage" do
+
+  let(:fb_message) { SampleMessage.new(service: 'facebook') }
+  let(:controller) { VadersController.new(service_message: fb_message.message_with_text) }
+
+  describe 'run_unrecognized_message' do
+    let(:e) {
+      e = OpenStruct.new
+      e.class = RuntimeError
+      e.message = 'oops'
+      e.backtrace = [
+        '/stealth/lib/stealth/controller/controller.rb',
+        '/stealth/lib/stealth/controller/catch_all.rb',
+      ]
+      e
+    }
+
+    describe 'when UnrecognizedMessagesController is not defined' do
+      before(:each) do
+        Object.send(:remove_const, :UnrecognizedMessagesController)
+      end
+
+      it "should log and run catch_all" do
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: 'unrecognized_message',
+          message: "The message \"Hello World!\" was not recognized in the original context."
+        ).ordered
+
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: 'unrecognized_message',
+          message: 'Running catch_all; UnrecognizedMessagesController not defined.'
+        ).ordered
+
+        expect(controller).to receive(:run_catch_all).with(err: e)
+        controller.run_unrecognized_message(err: e)
+      end
+    end
+
+    it "should call handle_unrecognized_message on the UnrecognizedMessagesController" do
+      class UnrecognizedMessagesController < Stealth::Controller
+        def handle_unrecognized_message
+          do_nothing
+        end
+      end
+
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: 'unrecognized_message',
+        message: "The message \"Hello World!\" was not recognized in the original context."
+      ).ordered
+
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: 'unrecognized_message',
+        message: 'A match was detected. Skipping catch-all.'
+      ).ordered
+
+      controller.run_unrecognized_message(err: e)
+    end
+
+    it "should log if the UnrecognizedMessagesController#handle_unrecognized_message does not progress the session" do
+      class UnrecognizedMessagesController < Stealth::Controller
+        def handle_unrecognized_message
+          # Oops
+        end
+      end
+
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: 'unrecognized_message',
+        message: "The message \"Hello World!\" was not recognized in the original context."
+      ).ordered
+
+      expect(Stealth::Logger).to receive(:l).with(
+        topic: 'unrecognized_message',
+        message: 'Did not send replies, update session, or step'
+      ).ordered
+
+      expect(controller).to_not receive(:run_catch_all)
+
+      controller.run_unrecognized_message(err: e)
+    end
+
+    describe 'handoff to catch_all' do
+      before(:each) do
+        @session = Stealth::Session.new(id: controller.current_session_id)
+        @session.set_session(new_flow: 'vader', new_state: 'action_with_unrecognized_msg')
+
+        @error_slug = [
+          'error',
+          controller.current_session_id,
+          'vader',
+          'action_with_unrecognized_msg'
+        ].join('-')
+
+        $redis.del(@error_slug)
+      end
+
+      it "should catch StandardError within UnrecognizedMessagesController and run catch_all" do
+        $err = Stealth::Errors::ReplyNotFound.new('oops')
+
+        class UnrecognizedMessagesController < Stealth::Controller
+          def handle_unrecognized_message
+            raise $err
+          end
+        end
+
+        expect(Stealth::Logger).to receive(:l).with(
+          topic: 'unrecognized_message',
+          message: "The message \"Hello World!\" was not recognized in the original context."
+        ).ordered
+
+        expect(controller).to receive(:run_catch_all).with(err: $err)
+
+        controller.run_unrecognized_message(err: e)
+      end
+
+      it "should track the catch_all level against the original session during exceptions" do
+        class UnrecognizedMessagesController < Stealth::Controller
+          def handle_unrecognized_message
+            raise 'oops'
+          end
+        end
+
+        expect($redis.get(@error_slug)).to be_nil
+        controller.run_unrecognized_message(err: e)
+        expect($redis.get(@error_slug)).to eq '1'
+      end
+
+      it "should track the catch_all level against the original session for UnrecognizedMessage errors" do
+        class UnrecognizedMessagesController < Stealth::Controller
+          def handle_unrecognized_message
+            handle_message(
+              'x' => proc { do_nothing },
+              'y' => proc { do_nothing }
+            )
+          end
+        end
+
+        expect($redis.get(@error_slug)).to be_nil
+        controller.action(action: :action_with_unrecognized_msg)
+        expect($redis.get(@error_slug)).to eq '1'
+      end
+
+      it "should NOT run catch_all if UnrecognizedMessagesController handles the message" do
+        $x = 0
+        class UnrecognizedMessagesController < Stealth::Controller
+          def handle_unrecognized_message
+            handle_message(
+              'Hello World!' => proc {
+                $x = 1
+                do_nothing
+              },
+              'y' => proc { do_nothing }
+            )
+          end
+        end
+
+        expect($redis.get(@error_slug)).to be_nil
+        controller.action(action: :action_with_unrecognized_msg)
+        expect($redis.get(@error_slug)).to be_nil
+        expect($x).to eq 1
+      end
+    end
+  end
+
+end

data/spec/dispatcher_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::Dispatcher" do
+
+    class Stealth::Services::Facebook::MessageHandler
+
+    end
+
+    describe 'coordinate' do
+      let(:dispatcher) {
+        Stealth::Dispatcher.new(
+          service: 'facebook',
+          params: {},
+          headers: {}
+        )
+      }
+
+      it 'should call coordinate on the message handler' do
+        message_handler = double
+        expect(Stealth::Services::Facebook::MessageHandler).to receive(:new).and_return(message_handler)
+        expect(message_handler).to receive(:coordinate)
+
+        dispatcher.coordinate
+      end
+    end
+
+    describe 'process' do
+      class StubbedBotController < Stealth::Controller
+        def route
+          true
+        end
+      end
+
+      let(:dispatcher) {
+        Stealth::Dispatcher.new(
+          service: 'facebook',
+          params: {},
+          headers: {}
+        )
+      }
+      let(:fb_message) { SampleMessage.new(service: 'facebook') }
+      let(:stubbed_controller) {
+        StubbedBotController.new(service_message: fb_message.message_with_text)
+      }
+
+      it 'should call process on the message handler' do
+        message_handler = double
+
+        # Stub out the message handler to return a service_message
+        expect(Stealth::Services::Facebook::MessageHandler).to receive(:new).and_return(message_handler)
+        expect(message_handler).to receive(:process).and_return(fb_message.message_with_text)
+
+        # Stub out BotController and set session
+        expect(BotController).to receive(:new).and_return(stubbed_controller)
+        stubbed_controller.current_session.set_session(new_flow: 'mr_tron', new_state: 'other_action')
+
+        dispatcher.process
+      end
+
+      it 'should log the incoming message if transcript_logging is enabled' do
+        message_handler = double
+
+        # Stub out the message handler to return a service_message
+        expect(Stealth::Services::Facebook::MessageHandler).to receive(:new).and_return(message_handler)
+        expect(message_handler).to receive(:process).and_return(fb_message.message_with_text)
+
+        # Stub out BotController and set session
+        expect(BotController).to receive(:new).and_return(stubbed_controller)
+        stubbed_controller.current_session.set_session(new_flow: 'mr_tron', new_state: 'other_action')
+
+        Stealth.config.transcript_logging = true
+        expect(dispatcher).to receive(:log_incoming_message).with(fb_message.message_with_text)
+        dispatcher.process
+      end
+    end
+
+end

data/spec/flow/flow_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::Flow do
 

data/spec/flow/state_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::Flow::State do
 
@@ -15,6 +14,7 @@ describe Stealth::Flow::State do
       state :created2, fails_to: 'new_todo->new'
       state :deprecated, redirects_to: 'new'
       state :deprecated2, redirects_to: 'other_flow->say_hi'
+      state :new_opts, opt1: 'hello', opt2: 1
       state :error
     end
   end
@@ -69,6 +69,17 @@ describe Stealth::Flow::State do
     end
   end
 
+  describe "opts" do
+    it "should return {} for a state that has not specified any opts" do
+      expect(flow_map.current_state.opts).to eq({})
+    end
+
+    it "should return the opts if they were specified" do
+      flow_map.init(flow: :new_todo, state: :new_opts)
+      expect(flow_map.current_state.opts).to eq({ opt1: 'hello', opt2: 1 })
+    end
+  end
+
   describe "state incrementing and decrementing" do
     it "should increment the state" do
       flow_map.init(flow: :new_todo, state: :get_due_date)
@@ -78,7 +89,7 @@ describe Stealth::Flow::State do
 
     it "should decrement the state" do
       flow_map.init(flow: :new_todo, state: :error)
-      new_state = flow_map.current_state - 5.states
+      new_state = flow_map.current_state - 6.states
       expect(new_state).to eq(:get_due_date)
     end
 

data/spec/helpers/redis_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::Redis" do
+
+  class RedisTester
+    include Stealth::Redis
+  end
+
+  let(:redis_tester) { RedisTester.new }
+  let(:key) { 'xyz' }
+
+  describe "get_key" do
+    it "should return the key from Redis if an expiration is not set" do
+      $redis.set(key, 'abc')
+      expect(redis_tester.send(:get_key, key)).to eq 'abc'
+    end
+
+    it "should call getex if an expiration is set" do
+      expect(redis_tester).to receive(:getex).with(key, 30)
+      redis_tester.send(:get_key, key, expiration: 30)
+    end
+  end
+
+  describe "delete_key" do
+    it 'should delete the key from Redis' do
+      $redis.set(key, 'abc')
+      expect(redis_tester.send(:get_key, key)).to eq 'abc'
+      redis_tester.send(:delete_key, key)
+      expect(redis_tester.send(:get_key, key)).to be_nil
+    end
+  end
+
+  describe "getex" do
+    it "should return the key from Redis" do
+      Stealth.config.session_ttl = 50
+      $redis.set(key, 'abc')
+      expect(redis_tester.send(:getex, key)).to eq 'abc'
+    end
+
+    it "should set the expiration of a key in Redis" do
+      Stealth.config.session_ttl = 50
+      $redis.set(key, 'abc')
+      redis_tester.send(:getex, key)
+      expect($redis.ttl(key)).to be_between(0, 50).inclusive
+    end
+
+    it "should update the expiration of a key in Redis" do
+      Stealth.config.session_ttl = 500
+      $redis.setex(key, 50, 'abc')
+      redis_tester.send(:getex, key)
+      expect($redis.ttl(key)).to be_between(400, 500).inclusive
+    end
+  end
+
+  describe "persist_key" do
+    it "should set the key in Redis" do
+      Stealth.config.session_ttl = 50
+      redis_tester.send(:persist_key, key: key, value: 'zzz')
+      expect($redis.get(key)).to eq 'zzz'
+    end
+
+    it "should set the expiration to session_ttl if none specified" do
+      Stealth.config.session_ttl = 50
+      redis_tester.send(:persist_key, key: key, value: 'zzz')
+      expect($redis.ttl(key)).to be_between(0, 50).inclusive
+    end
+
+    it "should set the expiration to the specified value when provided" do
+      Stealth.config.session_ttl = 50
+      redis_tester.send(:persist_key, key: key, value: 'zzz', expiration: 500)
+      expect($redis.ttl(key)).to be_between(400, 500).inclusive
+    end
+  end
+
+end

data/spec/lock_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Stealth::Lock" do
+  let(:session_id) { SecureRandom.hex(14) }
+  let(:session_slug) { 'hello->say_hello' }
+
+  before(:each) do
+    Stealth.config.lock_autorelease = 30
+  end
+
+  describe "create" do
+    it "should raise an ArgumentError if the session_slug was not provided" do
+      lock = Stealth::Lock.new(session_id: session_id)
+      expect {
+        lock.create
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should save the lock using a canonical key and value" do
+      lock = Stealth::Lock.new(session_id: session_id, session_slug: session_slug)
+      canonical_key = "#{session_id}-lock"
+      expected_value = "#{lock.tid}##{session_slug}"
+      lock.create
+      expect($redis.get(canonical_key)).to eq expected_value
+    end
+
+    it "should include the reply file position in the lock" do
+      lock = Stealth::Lock.new(
+        session_id: session_id,
+        session_slug: session_slug,
+        position: 3
+      )
+      canonical_key = "#{session_id}-lock"
+      expected_value = "#{lock.tid}##{session_slug}:3"
+      lock.create
+      expect($redis.get(canonical_key)).to eq expected_value
+    end
+
+    it "should set the lock expiration to lock_autorelease" do
+      lock = Stealth::Lock.new(session_id: session_id, session_slug: session_slug)
+      canonical_key = "#{session_id}-lock"
+      expected_value = "#{lock.tid}##{session_slug}"
+      lock.create
+      expect($redis.ttl(canonical_key)).to be_between(1, 30).inclusive
+    end
+  end
+
+  describe "release" do
+    it "should delete the key in Redis" do
+      lock = Stealth::Lock.new(session_id: session_id, session_slug: session_slug)
+      canonical_key = "#{session_id}-lock"
+      lock.create
+      expect($redis.get(canonical_key)).to_not be_nil
+      lock.release
+      expect($redis.get(canonical_key)).to be_nil
+    end
+  end
+
+  describe "slug" do
+    it "should return the lock slug from Redis" do
+      lock = Stealth::Lock.new(session_id: session_id, session_slug: session_slug)
+      lock.create
+      canonical_key = "#{session_id}-lock"
+      expect(lock.slug).to eq "#{lock.tid}##{session_slug}"
+    end
+  end
+
+  describe "flow_and_state" do
+    it "should return a hash containing the flow and state" do
+      lock = Stealth::Lock.new(session_id: session_id, session_slug: session_slug)
+      expect(lock.flow_and_state[:flow]).to eq 'hello'
+      expect(lock.flow_and_state[:state]).to eq 'say_hello'
+    end
+  end
+
+  describe "self.find_lock" do
+    it "should load the lock from Redis" do
+      lock_key = "#{session_id}-lock"
+      example_tid = 'ovefhgJvx'
+      example_session = 'goodbye->say_goodbye'
+      example_position = 2
+      example_lock = "#{example_tid}##{example_session}:#{example_position}"
+      $redis.set(lock_key, example_lock)
+
+      lock = Stealth::Lock.find_lock(session_id: session_id)
+      expect(lock.tid).to eq example_tid
+      expect(lock.session_slug).to eq example_session
+      expect(lock.position).to eq example_position
+    end
+
+    it "should return nil if the lock is not found" do
+      lock_key = "#{session_id}-lock"
+      lock = Stealth::Lock.find_lock(session_id: session_id)
+      expect($redis.get(lock_key)).to be_nil
+      expect(lock).to be_nil
+    end
+  end
+end