stealth 1.0.0.pre1 → 1.0.0.pre2

data/spec/controller/controller_spec.rb

@@ -5,7 +5,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper')
 
 describe "Stealth::Controller" do
 
-  class MrRobotsController < BotController
+  class MrRobotsController < Stealth::Controller
     def my_action
       [:success, :my_action]
     end
@@ -19,7 +19,7 @@ describe "Stealth::Controller" do
     end
   end
 
-  class MrTronsController < BotController
+  class MrTronsController < Stealth::Controller
     def other_action
 
     end
@@ -33,20 +33,16 @@ describe "Stealth::Controller" do
     end
   end
 
-  class MrRobotFlow
+  class FlowMap
     include Stealth::Flow
 
-    flow do
+    flow :mr_robot do
       state :my_action
       state :my_action2
       state :my_action3
     end
-  end
-
-  class MrTronFlow
-    include Stealth::Flow
 
-    flow do
+    flow :mr_tron do
       state :other_action
       state :other_action2
       state :other_action3
@@ -54,56 +50,299 @@ describe "Stealth::Controller" do
   end
 
   let(:facebook_message) { SampleMessage.new(service: 'facebook') }
+  let(:controller) { MrTronsController.new(service_message: facebook_message.message_with_text) }
 
   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
-
+      expect_any_instance_of(MrRobotsController).to receive(:my_action)
+      controller.step_to flow: "mr_robot"
     end
 
     it "should call a controller's corresponding action when only a state is provided" do
+      expect_any_instance_of(MrTronsController).to receive(:other_action3)
+
+      controller.current_session.set(flow: 'mr_tron', state: 'other_action')
 
+      controller.step_to state: "other_action3"
     end
 
     it "should call a controller's corresponding action when a state and flow is provided" do
-
+      expect_any_instance_of(MrRobotsController).to receive(:my_action3)
+      controller.step_to flow: "mr_robot", state: "my_action3"
     end
 
     it "should call a controller's corresponding action when a session is provided" do
+      expect_any_instance_of(MrRobotsController).to receive(:my_action3)
 
+      allow(controller.current_session).to receive(:flow_string).and_return("mr_robot")
+      allow(controller.current_session).to receive(:state_string).and_return("my_action3")
+
+      controller.step_to session: controller.current_session
+    end
+
+    it "should accept flow and string specified as symbols" do
+      expect_any_instance_of(MrRobotsController).to receive(:my_action3)
+      controller.step_to flow: :mr_robot, state: :my_action3
     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
+
+    it "should update session to flow's first state's controller action when only a flow is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      controller.update_session_to flow: "mr_robot"
+      expect(controller.current_session.flow_string).to eq('mr_robot')
+      expect(controller.current_session.state_string).to eq('my_action')
+    end
+
+    it "should update session to controller's corresponding action when only a state is provided" do
+      expect_any_instance_of(MrTronsController).to_not receive(:other_action3)
+
+      controller.current_session.set(flow: 'mr_tron', state: 'other_action')
+
+      controller.update_session_to state: "other_action3"
+      expect(controller.current_session.flow_string).to eq('mr_tron')
+      expect(controller.current_session.state_string).to eq('other_action3')
+    end
+
+    it "should update session to controller's corresponding action when a state and flow is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action3)
+
+      controller.update_session_to flow: "mr_robot", state: "my_action3"
+      expect(controller.current_session.flow_string).to eq('mr_robot')
+      expect(controller.current_session.state_string).to eq('my_action3')
+    end
+
+    it "should update session to controller's corresponding action when a session is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action3)
+
+      session = Stealth::Session.new(user_id: controller.current_user_id)
+      session.set(flow: 'mr_robot', state: 'my_action3')
+
+      controller.update_session_to session: session
+      expect(controller.current_session.flow_string).to eq('mr_robot')
+      expect(controller.current_session.state_string).to eq('my_action3')
+    end
+
+    it "should accept flow and string specified as symbols" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action3)
+
+      controller.update_session_to flow: :mr_robot, state: :my_action3
+      expect(controller.current_session.flow_string).to eq('mr_robot')
+      expect(controller.current_session.state_string).to eq('my_action3')
+    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
+    it "should raise an ArgumentError if delay is not specifed as an ActiveSupport::Duration" do
+      expect {
+        controller.step_to_in DateTime.now, flow: 'mr_robot'
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should schedule a transition to flow's first state's controller action when only a flow is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_in).with(
+        100.seconds,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_robot',
+        'my_action'
+      )
+
+      expect {
+        controller.step_to_in 100.seconds, flow: "mr_robot"
+      }.to_not change(controller.current_session, :get)
+    end
+
+    it "should schedule a transition to controller's corresponding action when only a state is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      controller.current_session.set(flow: 'mr_tron', state: 'other_action')
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_in).with(
+        100.seconds,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_tron',
+        'other_action3'
+      )
+
+      expect {
+        controller.step_to_in 100.seconds, state: "other_action3"
+      }.to_not change(controller.current_session, :get)
+    end
+
+    it "should update session to controller's corresponding action when a state and flow is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_in).with(
+        100.seconds,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_robot',
+        'my_action3'
+      )
+
+      expect {
+        controller.step_to_in 100.seconds, flow: 'mr_robot', state: "my_action3"
+      }.to_not change(controller.current_session, :get)
+    end
 
+    it "should update session to controller's corresponding action when a session is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      session = Stealth::Session.new(user_id: controller.current_user_id)
+      session.set(flow: 'mr_robot', state: 'my_action3')
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_in).with(
+        100.seconds,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_robot',
+        'my_action3'
+      )
+
+      expect {
+        controller.step_to_in 100.seconds, session: session
+      }.to_not change(controller.current_session, :get)
+    end
+
+    it "should accept flow and string specified as symbols" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_in).with(
+        100.seconds,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_robot',
+        'my_action3'
+      )
+
+      expect {
+        controller.step_to_in 100.seconds, flow: :mr_robot, state: :my_action3
+      }.to_not change(controller.current_session, :get)
+    end
   end
 
-  describe "update_session_to_next" do
+  describe "step_to_at" do
+    let(:future_timestamp) { DateTime.now + 10.hours }
 
+    it "should raise an ArgumentError if a session, flow, or state is not specified" do
+      expect {
+        controller.step_to_at
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an ArgumentError if delay is not specifed as a DateTime" do
+      expect {
+        controller.step_to_at 100.seconds, flow: 'mr_robot'
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should schedule a transition to flow's first state's controller action when only a flow is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_at).with(
+        future_timestamp,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_robot',
+        'my_action'
+      )
+
+      expect {
+        controller.step_to_at future_timestamp, flow: "mr_robot"
+      }.to_not change(controller.current_session, :get)
+    end
+
+    it "should schedule a transition to controller's corresponding action when only a state is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      controller.current_session.set(flow: 'mr_tron', state: 'other_action')
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_at).with(
+        future_timestamp,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_tron',
+        'other_action3'
+      )
+
+      expect {
+        controller.step_to_at future_timestamp, state: "other_action3"
+      }.to_not change(controller.current_session, :get)
+    end
+
+    it "should update session to controller's corresponding action when a state and flow is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_at).with(
+        future_timestamp,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_robot',
+        'my_action3'
+      )
+
+      expect {
+        controller.step_to_at future_timestamp, flow: 'mr_robot', state: "my_action3"
+      }.to_not change(controller.current_session, :get)
+    end
+
+    it "should update session to controller's corresponding action when a session is provided" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      session = Stealth::Session.new(user_id: controller.current_user_id)
+      session.set(flow: 'mr_robot', state: 'my_action3')
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_at).with(
+        future_timestamp,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_robot',
+        'my_action3'
+      )
+
+      expect {
+        controller.step_to_at future_timestamp, session: session
+      }.to_not change(controller.current_session, :get)
+    end
+
+    it "should accept flow and string specified as symbols" do
+      expect_any_instance_of(MrRobotsController).to_not receive(:my_action)
+
+      expect(Stealth::ScheduledReplyJob).to receive(:perform_at).with(
+        future_timestamp,
+        controller.current_service,
+        controller.current_user_id,
+        'mr_robot',
+        'my_action3'
+      )
+
+      expect {
+        controller.step_to_at future_timestamp, flow: :mr_robot, state: :my_action3
+      }.to_not change(controller.current_session, :get)
+    end
   end
 
 end

data/spec/controller/helpers_spec.rb

@@ -16,6 +16,10 @@ describe "Stealth::Controller helpers" do
       def say_hello_world
         hello_world
       end
+
+      def say_kaboom
+        hello_world2
+      end
     end
 
     class PdfController < Stealth::Controller
@@ -33,6 +37,12 @@ describe "Stealth::Controller helpers" do
     helper :all
   end
 
+  class InheritedHelpersController < AllHelpersController
+    def say_hello_world
+      hello_world
+    end
+  end
+
   class SizzleController < Stealth::Controller
     helper :standalone
 
@@ -78,12 +88,28 @@ describe "Stealth::Controller helpers" do
       expect(AllHelpersController._helpers.instance_methods).to match_array(all_helper_methods)
     end
 
+    it "should load all helpers if parent class inherits all helpers" do
+      expect(InheritedHelpersController._helpers.instance_methods).to match_array(all_helper_methods)
+    end
+
+    it "should allow a controller that has inherited all helpers to access a helper method" do
+      expect {
+        InheritedHelpersController.new(service_message: facebook_message.message_with_text).say_hello_world
+      }.to_not raise_error
+    end
+
     it "should allow a controller that has loaded all helpers to access a helper method" do
       expect {
         Fun::GamesController.new(service_message: facebook_message.message_with_text).say_hello_world
       }.to_not raise_error
     end
 
+    it "should raise an error if a helper method does not exist" do
+      expect {
+        Fun::GamesController.new(service_message: facebook_message.message_with_text).say_kaboom
+      }.to raise_error(NameError)
+    end
+
     it "should allow a controller action to access a helper method" do
       expect {
         Fun::PdfController.new(service_message: facebook_message.message_with_text).say_pdf_name

data/spec/flow/flow_spec.rb

@@ -5,57 +5,78 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Stealth::Flow do
 
-  class NewTodoFlow
+  class CustomFlowMap
     include Stealth::Flow
 
-    flow do
+    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) { NewTodoFlow.new }
+  let(:flow_map) { CustomFlowMap.new }
 
   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
+      flow_map.init(flow: 'new_todo', state: 'created')
+      expect(flow_map.current_state).to eq :created
 
-      flow.init_state('error')
-      expect(flow.current_state).to eq :error
+      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.init_state(:invalid)
+        flow_map.init(flow: 'new_todo', state: 'invalid')
       }.to raise_error(Stealth::Errors::InvalidStateTransition)
     end
   end
 
   describe "accessing states" do
-    it "should start out in the initial state" do
-      expect(flow.current_state).to eq :new
+    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 = NewTodoFlow.flow_spec.states[:new]
-      last_state = NewTodoFlow.flow_spec.states[:error]
+      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 the class" do
-      expect(NewTodoFlow.flow_spec.states.length).to eq 4
-      expect(NewTodoFlow.flow_spec.states.keys).to eq([:new, :get_due_date, :created, :error])
+    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 return the states in an array for a given flow instance" do
-      expect(flow.states).to eq [:new, :get_due_date, :created, :error]
+    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
 

data/spec/flow/state_spec.rb

@@ -5,66 +5,63 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Stealth::Flow::State do
 
-  class NewTodoFlow
+  class SuperFlowMap
     include Stealth::Flow
 
-    flow do
+    flow :new_todo do
       state :new
-
       state :get_due_date
-
       state :created, fails_to: :new
-
       state :error
     end
   end
 
-  let(:flow) { NewTodoFlow.new }
+  let(:flow_map) { SuperFlowMap.new }
 
   describe "flow states" do
     it "should convert itself to a string" do
-      expect(flow.current_state.to_s).to be_a(String)
+      expect(flow_map.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)
+      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.current_state.fails_to).to be_nil
+      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.init_state(:created)
-      expect(flow.current_state.fails_to).to be_a(Stealth::Flow::State)
-      expect(flow.current_state.fails_to).to eq :new
+      flow_map.init(flow: :new_todo, state: :created)
+      expect(flow_map.current_state.fails_to).to be_a(Stealth::Flow::State)
+      expect(flow_map.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
+      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.init_state(:error)
-      new_state = flow.current_state - 2.states
+      flow_map.init(flow: :new_todo, state: :error)
+      new_state = flow_map.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
+      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.init_state(:created)
-      new_state = flow.current_state + 5.states
+      flow_map.init(flow: :new_todo, state: :created)
+      new_state = flow_map.current_state + 5.states
       expect(new_state).to eq(:error)
     end
   end

data/spec/session_spec.rb

@@ -3,18 +3,19 @@
 
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-class NewTodoFlow
+class FlowMap
   include Stealth::Flow
 
-  flow do
+  flow :new_todo do
     state :new
-
     state :get_due_date
-
     state :created, fails_to: :new
-
     state :error
   end
+
+  flow :marco do
+    state :polo
+  end
 end
 
 describe "Stealth::Session" do
@@ -50,22 +51,14 @@ describe "Stealth::Session" do
   end
 
   describe "with a session" do
-    class MarcoFlow
-      include Stealth::Flow
-
-      flow do
-        state :polo
-      end
-    end
-
     let(:session) do
       session = Stealth::Session.new(user_id: user_id)
-      session.set(flow: 'Marco', state: 'polo')
+      session.set(flow: 'marco', state: 'polo')
       session
     end
 
-    it "should return the flow" do
-      expect(session.flow).to be_a(MarcoFlow)
+    it "should return the FlowMap" do
+      expect(session.flow).to be_a(FlowMap)
     end
 
     it "should return the state" do
@@ -74,7 +67,7 @@ describe "Stealth::Session" do
     end
 
     it "should return the flow_string" do
-      expect(session.flow_string).to eq "Marco"
+      expect(session.flow_string).to eq "marco"
     end
 
     it "should return the state_string" do
@@ -91,25 +84,25 @@ describe "Stealth::Session" do
     let(:session) { Stealth::Session.new(user_id: user_id) }
 
     it "should increment the state" do
-      session.set(flow: 'NewTodo', state: 'get_due_date')
+      session.set(flow: 'new_todo', 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: 'NewTodo', state: 'error')
+      session.set(flow: 'new_todo', 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: 'NewTodo', state: 'get_due_date')
+      session.set(flow: 'new_todo', 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: 'NewTodo', state: 'created')
+      session.set(flow: 'new_todo', state: 'created')
       new_session = session + 5.states
       expect(new_session.state_string).to eq('error')
     end