xip 0.0.1 → 2.0.0.beta2

data/spec/controller/unrecognized_message_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Xip::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 = [
+        '/xip/lib/xip/controller/controller.rb',
+        '/xip/lib/xip/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(Xip::Logger).to receive(:l).with(
+          topic: 'unrecognized_message',
+          message: "The message \"Hello World!\" was not recognized in the original context."
+        ).ordered
+
+        expect(Xip::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 < Xip::Controller
+        def handle_unrecognized_message
+          do_nothing
+        end
+      end
+
+      expect(Xip::Logger).to receive(:l).with(
+        topic: 'unrecognized_message',
+        message: "The message \"Hello World!\" was not recognized in the original context."
+      ).ordered
+
+      expect(Xip::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 < Xip::Controller
+        def handle_unrecognized_message
+          # Oops
+        end
+      end
+
+      expect(Xip::Logger).to receive(:l).with(
+        topic: 'unrecognized_message',
+        message: "The message \"Hello World!\" was not recognized in the original context."
+      ).ordered
+
+      expect(Xip::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 = Xip::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 = Xip::Errors::ReplyNotFound.new('oops')
+
+        class UnrecognizedMessagesController < Xip::Controller
+          def handle_unrecognized_message
+            raise $err
+          end
+        end
+
+        expect(Xip::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 < Xip::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 < Xip::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 < Xip::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 "Xip::Dispatcher" do
+
+    class Xip::Services::Facebook::MessageHandler
+
+    end
+
+    describe 'coordinate' do
+      let(:dispatcher) {
+        Xip::Dispatcher.new(
+          service: 'facebook',
+          params: {},
+          headers: {}
+        )
+      }
+
+      it 'should call coordinate on the message handler' do
+        message_handler = double
+        expect(Xip::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 < Xip::Controller
+        def route
+          true
+        end
+      end
+
+      let(:dispatcher) {
+        Xip::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(Xip::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(Xip::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')
+
+        Xip.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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Xip::Flow do
+
+  class CustomFlowMap
+    include Xip::Flow
+
+    flow :new_todo do
+      state :new
+      state :get_due_date
+      state :created
+      state :error
+    end
+
+    flow :hello do
+      state :say_hello
+      state :say_oi
+    end
+
+    flow "howdy" do
+      state :say_howdy
+    end
+  end
+
+  let(:flow_map) { CustomFlowMap.new }
+
+  describe "inititating with states" do
+    it "should init a state given a state name" do
+      flow_map.init(flow: 'new_todo', state: 'created')
+      expect(flow_map.current_state).to eq :created
+
+      flow_map.init(flow: 'new_todo', state: 'error')
+      expect(flow_map.current_state).to eq :error
+    end
+
+    it "should raise an error if an invalid state is specified" do
+      expect {
+        flow_map.init(flow: 'new_todo', state: 'invalid')
+      }.to raise_error(Xip::Errors::InvalidStateTransition)
+    end
+  end
+
+  describe "accessing states" do
+    it "should default to the first flow and state" do
+      expect(flow_map.current_flow).to eq(:new_todo)
+      expect(flow_map.current_state).to eq(:new)
+    end
+
+    it "should support comparing states" do
+      first_state = CustomFlowMap.flow_spec[:new_todo].states[:new]
+      last_state = CustomFlowMap.flow_spec[:new_todo].states[:error]
+      expect(first_state < last_state).to be true
+      expect(last_state > first_state).to be true
+    end
+
+    it "should allow every state to be fetched for a flow" do
+      expect(CustomFlowMap.flow_spec[:new_todo].states.length).to eq 4
+      expect(CustomFlowMap.flow_spec[:hello].states.length).to eq 2
+      expect(CustomFlowMap.flow_spec[:new_todo].states.keys).to eq([:new, :get_due_date, :created, :error])
+      expect(CustomFlowMap.flow_spec[:hello].states.keys).to eq([:say_hello, :say_oi])
+    end
+
+    it "should return the states in an array for a given FlowMap instance" do
+      expect(flow_map.states).to eq [:new, :get_due_date, :created, :error]
+      flow_map.init(flow: :hello, state: :say_oi)
+      expect(flow_map.states).to eq [:say_hello, :say_oi]
+    end
+
+    it "should allow flows to be specified with strings" do
+      expect(CustomFlowMap.flow_spec[:howdy].states.length).to eq 1
+      expect(CustomFlowMap.flow_spec[:howdy].states.keys).to eq([:say_howdy])
+    end
+
+    it "should allow FlowMaps to be intialized with strings" do
+      flow_map.init(flow: "hello", state: "say_oi")
+      expect(flow_map.states).to eq [:say_hello, :say_oi]
+    end
+  end
+
+end

data/spec/flow/state_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Xip::Flow::State do
+
+  class SuperFlowMap
+    include Xip::Flow
+
+    flow :new_todo do
+      state :new
+      state :get_due_date
+      state :created, fails_to: :new
+      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
+
+  let(:flow_map) { SuperFlowMap.new }
+
+  describe "flow states" do
+    it "should convert itself to a string" do
+      expect(flow_map.current_state.to_s).to be_a(String)
+    end
+
+    it "should convert itself to a symbol" do
+      expect(flow_map.current_state.to_sym).to be_a(Symbol)
+    end
+  end
+
+  describe "fails_to" do
+    it "should be nil for a state that has not specified a fails_to" do
+      expect(flow_map.current_state.fails_to).to be_nil
+    end
+
+    it "should return the fail_state if a fails_to was specified" do
+      flow_map.init(flow: :new_todo, state: :created)
+      expect(flow_map.current_state.fails_to).to be_a(Xip::Session)
+      expect(flow_map.current_state.fails_to.state_string).to eq 'new'
+    end
+
+    it "should return the fail_state if a fails_to was specified as a session" do
+      flow_map.init(flow: :new_todo, state: :created2)
+      expect(flow_map.current_state.fails_to).to be_a(Xip::Session)
+      expect(flow_map.current_state.fails_to.state_string).to eq 'new'
+      expect(flow_map.current_state.fails_to.flow_string).to eq 'new_todo'
+    end
+  end
+
+  describe "redirects_to" do
+    it "should be nil for a state that has not specified a fails_to" do
+      expect(flow_map.current_state.redirects_to).to be_nil
+    end
+
+    it "should return the redirects_to state if a redirects_to was specified" do
+      flow_map.init(flow: :new_todo, state: :deprecated)
+      expect(flow_map.current_state.redirects_to).to be_a(Xip::Session)
+      expect(flow_map.current_state.redirects_to.state_string).to eq 'new'
+    end
+
+    it "should return the redirects_to state if a redirects_to was specified as a session" do
+      flow_map.init(flow: :new_todo, state: :deprecated2)
+      expect(flow_map.current_state.redirects_to).to be_a(Xip::Session)
+      expect(flow_map.current_state.redirects_to.state_string).to eq 'say_hi'
+      expect(flow_map.current_state.redirects_to.flow_string).to eq 'other_flow'
+    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)
+      new_state = flow_map.current_state + 1.state
+      expect(new_state).to eq(:created)
+    end
+
+    it "should decrement the state" do
+      flow_map.init(flow: :new_todo, state: :error)
+      new_state = flow_map.current_state - 6.states
+      expect(new_state).to eq(:get_due_date)
+    end
+
+    it "should return the first state if the decrement is out of bounds" do
+      flow_map.init(flow: :new_todo, state: :get_due_date)
+      new_state = flow_map.current_state - 5.states
+      expect(new_state).to eq(:new)
+    end
+
+    it "should return the last state if the increment is out of bounds" do
+      flow_map.init(flow: :new_todo, state: :created)
+      new_state = flow_map.current_state + 10.states
+      expect(new_state).to eq(:error)
+    end
+  end
+
+end

data/spec/helpers/redis_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Xip::Redis" do
+
+  class RedisTester
+    include Xip::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
+      Xip.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
+      Xip.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
+      Xip.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
+      Xip.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
+      Xip.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
+      Xip.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