stealth 0.9.8 → 0.10.0

data/lib/stealth/flow/state.rb

@@ -7,33 +7,51 @@ module Stealth
 
       include Comparable
 
-      attr_accessor :name, :events, :meta, :on_entry, :on_exit
-      attr_reader :spec
+      attr_accessor :name
+      attr_reader :spec, :fails_to
 
-      def initialize(name, spec, meta = {})
-        @name, @spec, @events, @meta = name, spec, EventCollection.new, meta
+      def initialize(name, spec, fails_to = nil)
+        if fails_to.present? && !fails_to.is_a?(Stealth::Flow::State)
+          raise(ArgumentError, 'fails_to state should be a Stealth::Flow::State')
+        end
+
+        @name, @spec, @fails_to = name, spec, fails_to
       end
 
-      def draw(graph)
-        defaults = {
-          :label => to_s,
-          :width => '1',
-          :height => '1',
-          :shape => 'ellipse'
-        }
+      def <=>(other_state)
+        state_position(self) <=> state_position(other_state)
+      end
 
-        node = graph.add_nodes(to_s, defaults.merge(meta))
+      def +(steps)
+        if steps < 0
+          new_position = state_position(self) + steps
 
-        # Add open arrow for initial state
-        # graph.add_edge(graph.add_node('starting_state', :shape => 'point'), node) if initial?
+          # we don't want to allow the array index to wrap here so we return
+          # the first state instead
+          if new_position < 0
+            new_state = spec.states.keys.first
+          else
+            new_state = spec.states.keys.at(new_position)
+          end
+        else
+          new_state = spec.states.keys[state_position(self) + steps]
 
-        node
+          # we may have been told to access an out-of-bounds state
+          # return the last state
+          if new_state.blank?
+            new_state = spec.states.keys.last
+          end
+        end
+
+        new_state
       end
 
-      def <=>(other_state)
-        states = spec.states.keys
-        raise ArgumentError, "state `#{other_state}' does not exist" unless states.include?(other_state.to_sym)
-        states.index(self.to_sym) <=> states.index(other_state.to_sym)
+      def -(steps)
+        if steps < 0
+          return self + steps.abs
+        else
+          return self + (-steps)
+        end
       end
 
       def to_s
@@ -43,6 +61,18 @@ module Stealth
       def to_sym
         name.to_sym
       end
+
+      private
+
+        def state_position(state)
+          states = spec.states.keys
+
+          unless states.include?(state.to_sym)
+            raise(ArgumentError, "state `#{state}' does not exist")
+          end
+
+          states.index(state.to_sym)
+        end
     end
   end
 end

data/lib/stealth/session.rb

@@ -6,12 +6,14 @@ module Stealth
 
     SLUG_SEPARATOR = '->'
 
-    attr_reader :session, :flow, :state, :user_id
+    attr_reader :flow, :state, :user_id, :previous
+    attr_accessor :session
 
-    def initialize(user_id:)
+    def initialize(user_id:, previous: false)
       @user_id = user_id
+      @previous = previous
 
-      unless defined?($redis)
+      unless defined?($redis) && $redis.present?
         raise(Stealth::Errors::RedisNotConfigured, "Please make sure REDIS_URL is configured before using sessions")
       end
 
@@ -27,7 +29,9 @@ module Stealth
     end
 
     def flow
-      @flow = begin
+      return nil if flow_string.blank?
+
+      @flow ||= begin
         flow_klass = [flow_string, 'flow'].join('_').classify.constantize
         flow = flow_klass.new.init_state(state_string)
         flow
@@ -35,7 +39,7 @@ module Stealth
     end
 
     def state
-      flow.current_state
+      flow&.current_state
     end
 
     def flow_string
@@ -47,12 +51,18 @@ module Stealth
     end
 
     def get
-      @session ||= $redis.get(user_id)
+      if previous?
+        @session ||= $redis.get(previous_session_key(user_id: user_id))
+      else
+        @session ||= $redis.get(user_id)
+      end
     end
 
     def set(flow:, state:)
+      store_current_to_previous
+
+      @flow = nil
       @session = canonical_session_slug(flow: flow, state: state)
-      flow
       $redis.set(user_id, session)
     end
 
@@ -64,11 +74,44 @@ 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 = canonical_session_slug(flow: self.flow_string, state: new_state)
+
+      new_session
+    end
+
+    def -(steps)
+      return nil if flow.blank?
+
+      if steps < 0
+        return self + steps.abs
+      else
+        return self + (-steps)
+      end
+    end
+
     private
 
       def canonical_session_slug(flow:, state:)
         [flow, state].join(SLUG_SEPARATOR)
       end
 
+      def previous_session_key(user_id:)
+        [user_id, 'previous'].join('-')
+      end
+
+      def store_current_to_previous
+        $redis.set(previous_session_key(user_id: user_id), session)
+      end
+
   end
 end

data/spec/configuration_spec.rb

@@ -5,7 +5,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe "Stealth::Configuration" do
 
   describe "accessing via method calling" do
-    let(:services_yml) { File.read(File.join(File.dirname(__FILE__), 'sample_services_yml', 'services.yml')) }
+    let(:services_yml) { File.read(File.join(File.dirname(__FILE__), 'support', 'services.yml')) }
     let(:parsed_config) { YAML.load(ERB.new(services_yml).result)[Stealth.env] }
     let(:config) { Stealth.load_services_config!(services_yml) }
 
@@ -31,7 +31,7 @@ describe "Stealth::Configuration" do
   end
 
   describe "config files with ERB" do
-    let(:services_yml) { File.read(File.join(File.dirname(__FILE__), 'sample_services_yml', 'services_with_erb.yml')) }
+    let(:services_yml) { File.read(File.join(File.dirname(__FILE__), 'support', 'services_with_erb.yml')) }
     let(:config) { Stealth.load_services_config!(services_yml) }
 
     it "should replace available embedded env vars" do

data/spec/controller/callbacks_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper'))
+
+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"
+    end
+end
+
+class FlowTestersController < BotController
+  before_action :test_before_halting, only: :my_action2
+  before_action :test_action
+  before_action :test_filtering, except: [:my_action, :my_action2]
+
+  attr_reader :action_ran
+
+  def my_action
+
+  end
+
+  def my_action2
+
+  end
+
+  def my_action3
+
+  end
+
+  protected
+
+    def test_action
+      @record << "tested action"
+    end
+
+    def test_before_halting
+      throw(:abort)
+    end
+
+    def test_filtering
+      @record << "filtered"
+    end
+
+    def test_after_halting
+      @record << "after action ran"
+    end
+end
+
+class OtherFlowTestersController < BotController
+  after_action :after_action1, only: :other_action2
+  after_action :after_action2, only: :other_action2
+
+  before_action :run_halt, only: [:other_action3, :other_action5]
+  after_action :after_action3, only: :other_action3
+
+  around_action :run_around_filter, only: [:other_action4, :other_action5]
+
+  def other_action
+
+  end
+
+  def other_action2
+
+  end
+
+  def other_action3
+
+  end
+
+  def other_action4
+
+  end
+
+  def other_action5
+
+  end
+
+  private
+
+    def after_action1
+      @record << "after action 1"
+    end
+
+    def after_action2
+      @record << "after action 2"
+    end
+
+    def run_halt
+      throw(:abort)
+    end
+
+    def run_around_filter
+      @record << "around before"
+      yield
+      @record << "around after"
+    end
+end
+
+class FlowTesterFlow
+  include Stealth::Flow
+
+  flow do
+    state :my_action
+    state :my_action2
+    state :my_action3
+  end
+end
+
+class OtherFlowTesterFlow
+  include Stealth::Flow
+
+  flow do
+    state :other_action
+    state :other_action2
+    state :other_action3
+    state :other_action4
+    state :other_action5
+  end
+end
+
+describe "Stealth::Controller callbacks" do
+
+  let(:facebook_message) { SampleMessage.new(service: 'facebook') }
+
+  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"]
+    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"]
+    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"]
+    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"]
+    end
+  end
+
+  describe "after_action" 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"]
+    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"]
+    end
+  end
+
+  describe "around_action" 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"]
+    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"]
+    end
+  end
+
+end

data/spec/controller/state_transitions_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper'))
+
+describe "Stealth::Controller state transitions" do
+
+  class MrRobotsController < BotController
+    def my_action
+      [:success, :my_action]
+    end
+
+    def my_action2
+      [:success, :my_action2]
+    end
+
+    def my_action3
+      [:success, :my_action3]
+    end
+  end
+
+  class MrTronsController < BotController
+    def other_action
+
+    end
+
+    def other_action2
+
+    end
+
+    def other_action3
+
+    end
+  end
+
+  class MrRobotFlow
+    include Stealth::Flow
+
+    flow do
+      state :my_action
+      state :my_action2
+      state :my_action3
+    end
+  end
+
+  class MrTronFlow
+    include Stealth::Flow
+
+    flow do
+      state :other_action
+      state :other_action2
+      state :other_action3
+    end
+  end
+
+  let(:facebook_message) { SampleMessage.new(service: 'facebook') }
+
+  describe "step_to" do
+    it "should raise an ArgumentError if a session, flow, or state is not specified" do
+      controller = MrTronsController.new(service_message: facebook_message.message_with_text)
+      expect {
+        controller.step_to
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should call the flow's first state's controller action when only a flow is provided" do
+
+    end
+
+    it "should call a controller's corresponding action when only a state is provided" do
+
+    end
+
+    it "should call a controller's corresponding action when a state and flow is provided" do
+
+    end
+
+    it "should call a controller's corresponding action when a session is provided" do
+
+    end
+  end
+
+  describe "update_session_to" do
+    it "should raise an ArgumentError if a session, flow, or state is not specified" do
+      controller = MrTronsController.new(service_message: facebook_message.message_with_text)
+      expect {
+        controller.update_session_to
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "step_to_in" do
+    it "should raise an ArgumentError if a session, flow, or state is not specified" do
+      controller = MrTronsController.new(service_message: facebook_message.message_with_text)
+      expect {
+        controller.step_to_in
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "step_to_next" do
+
+  end
+
+  describe "update_session_to_next" do
+
+  end
+
+end

data/spec/flow/flow_spec.rb

@@ -8,67 +8,37 @@ describe Stealth::Flow do
     include Stealth::Flow
 
     flow do
-      state :new do
-        event :submit_todo, :transitions_to => :get_due_date
-        event :error_in_input, :transitions_to => :error
-      end
+      state :new
 
-      state :get_due_date do
-        event :submit_due_date, :transitions_to => :created
-      end
+      state :get_due_date
 
       state :created
 
-      state :error do
-        event :submit_todo, :transitions_to => :get_due_date
-        event :error_in_input, :transitions_to => :error
-      end
+      state :error
     end
   end
 
   let(:flow) { NewTodoFlow.new }
 
-  describe "state transitions" do
-    it "should start out in the 'new' state" do
-      expect(flow.current_state).to eq :new
-    end
-
-    it "should transition into the 'get_due_date' state after submit" do
-      flow.submit_todo!
-      expect(flow.current_state).to eq :get_due_date
-    end
-
-    it "should transition into the 'error' state after error_in_input" do
-      flow.error_in_input!
-      expect(flow.current_state).to eq :error
-    end
-
-    it "should transition through multiple states" do
-      flow.submit_todo!
-      flow.submit_due_date!
+  describe "inititating with states" do
+    it "should init a state given a state name" do
+      flow.init_state(:created)
       expect(flow.current_state).to eq :created
-    end
 
-    it "should remain in the error state" do
-      flow.error_in_input!
-      expect(flow.current_state).to eq :error
-      flow.error_in_input!
+      flow.init_state('error')
       expect(flow.current_state).to eq :error
     end
 
-    it "should be false when checking the possibility of a non-valid transition" do
-      expect(flow.can_submit_due_date?).to be false
-    end
-
-    it "should be false when checking the possibility of a valid transition" do
-      flow.submit_todo!
-      expect(flow.can_submit_due_date?).to be true
+    it "should raise an error if an invalid state is specified" do
+      expect {
+        flow.init_state(:invalid)
+      }.to raise_error(Stealth::Errors::InvalidStateTransition)
     end
   end
 
   describe "accessing states" do
-    it "should start out in the 'new' state" do
-      expect(flow.new?).to be true
+    it "should start out in the initial state" do
+      expect(flow.current_state).to eq :new
     end
 
     it "should support comparing states" do

data/spec/flow/state_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Stealth::Flow::State do
+
+  class NewTodoFlow
+    include Stealth::Flow
+
+    flow do
+      state :new
+
+      state :get_due_date
+
+      state :created, fails_to: :new
+
+      state :error
+    end
+  end
+
+  let(:flow) { NewTodoFlow.new }
+
+  describe "flow states" do
+    it "should convert itself to a string" do
+      expect(flow.current_state.to_s).to be_a(String)
+    end
+
+    it "should convert itself to a symbol" do
+      expect(flow.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.current_state.fails_to).to be_nil
+    end
+
+    it "should return the fail_state if a fails_to was specified" do
+      flow.init_state(:created)
+      expect(flow.current_state.fails_to).to be_a(Stealth::Flow::State)
+      expect(flow.current_state.fails_to).to eq :new
+    end
+  end
+
+  describe "state incrementing and decrementing" do
+    it "should increment the state" do
+      flow.init_state(:get_due_date)
+      new_state = flow.current_state + 1.state
+      expect(new_state).to eq(:created)
+    end
+
+    it "should decrement the state" do
+      flow.init_state(:error)
+      new_state = flow.current_state - 2.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.init_state(:get_due_date)
+      new_state = flow.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.init_state(:created)
+      new_state = flow.current_state + 5.states
+      expect(new_state).to eq(:error)
+    end
+  end
+
+end