call_center 0.0.2

data/lib/call_center/core_ext/object_instance_exec.rb

@@ -0,0 +1,21 @@
+# From Active Support
+class Object
+  unless defined? instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
+    end
+  end
+end

data/lib/call_center/state_machine_ext.rb

@@ -0,0 +1,26 @@
+# Extension for StateMachine::Machine to store and provide render blocks
+class StateMachine::Machine
+  attr_accessor :render_blocks
+  attr_accessor :flow_to_blocks
+
+  def on_render(state_name, &blk)
+    @render_blocks ||= {}
+    @render_blocks[state_name] = blk
+  end
+
+  def on_flow_to(state_name, &blk)
+    @flow_to_blocks ||= {}
+    @flow_to_blocks[state_name] = blk
+  end
+end
+
+# Extension for StateMachine::AlternateMachine to provide render blocks inside a state definition
+class StateMachine::AlternateMachine
+  def on_render(state_name = nil, &blk)
+    if @from_state
+      @queued_sends << [[:on_render, @from_state], blk]
+    else
+      @queued_sends << [[:on_render, state_name], blk]
+    end
+  end
+end

data/lib/call_center/test/dsl.rb

@@ -0,0 +1,69 @@
+module CallCenter
+  module Test
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          def response_from_page_or_rjs_with_body
+            HTML::Document.new(CGI.unescapeHTML(@body)).root
+          end
+          alias_method_chain :response_from_page_or_rjs, :body
+        end
+      end
+
+      def body(text, debug = false)
+        puts text if debug
+        @body = text
+      end
+
+      module ClassMethods
+        def should_flow(options, &block)
+          event = options.delete(:on)
+          setup_block = options.delete(:when)
+          setup_block_line = setup_block.to_s.match(/.*@(.*):([0-9]+)>/)[2] if setup_block
+          state_field = options.delete(:state) || :state
+          from, to = options.to_a.first
+          description = ":#{from} => :#{to} via #{event}!#{setup_block_line.present? ? " when:#{setup_block_line}" : nil}"
+          context "" do
+            should "transition #{description}" do
+              self.instance_eval(&setup_block) if setup_block
+              @call.send(:"#{state_field}=", from.to_s)
+              @call.send(:"#{event}")
+              assert_equal to, @call.send(:"#{state_field}_name"), "status should be :#{to}, not :#{@call.send(state_field)}"
+            end
+
+            if block.present?
+              context "#{description} and :#{to}" do
+                setup do
+                  self.instance_eval(&setup_block) if setup_block
+                  @call.send(:"#{state_field}=", from.to_s)
+                  @call.send(:"#{event}")
+                  body(@call.render) if @call.respond_to?(:render)
+                end
+
+                self.instance_eval(&block)
+              end
+            end
+          end
+        end
+
+        def should_also(&block)
+          line = block.to_s.match(/.*@(.*):([0-9]+)>/)[2]
+          should "also satisfy block on line #{line}" do
+            self.instance_eval(&block)
+          end
+        end
+        alias_method :and_also, :should_also
+
+        def should_render(&block)
+          line = block.to_s.match(/.*@(.*):([0-9]+)>/)[2]
+          should "render selector on line #{line}" do
+            args = [self.instance_eval(&block)].flatten
+            assert_select *args
+          end
+        end
+        alias_method :and_render, :should_render
+      end
+    end
+  end
+end

data/test/call_center_test.rb

@@ -0,0 +1,261 @@
+require 'helper'
+
+require 'call_center/test/dsl'
+
+require 'test/examples/legacy_call'
+require 'test/examples/call'
+require 'test/examples/non_standard_call'
+require 'test/examples/multiple_flow_call'
+
+class CallCenterTest < Test::Unit::TestCase
+  include CallCenter::Test::DSL
+
+  [:call, :legacy_call].each do |call_type|
+    context "#{call_type.to_s.gsub('_', ' ')} workflow" do
+      setup do
+        klass = call_type.to_s.gsub('_', ' ').titleize.gsub(' ', '').constantize
+        @call = klass.new
+        @call.stubs(:notify)
+        @call.stubs(:flow_url).returns('the_flow')
+      end
+
+      context "agents available" do
+        setup do
+          @call.stubs(:agents_available?).returns(true)
+        end
+
+        should "transition to routing" do
+          @call.incoming_call!
+          assert_equal 'routing', @call.state
+        end
+      end
+
+      context "no agents available "do
+        setup do
+          @call.stubs(:agents_available?).returns(false)
+        end
+
+        should "transition to voicemail" do
+          @call.incoming_call!
+          assert_equal 'voicemail', @call.state
+        end
+      end
+
+      context "in voicemail" do
+        setup do
+          @call.stubs(:agents_available?).returns(false)
+          @call.incoming_call!
+        end
+
+        context "and customer hangs up" do
+          should "transition to voicemail_completed" do
+            @call.customer_hangs_up!
+            assert @call.voicemail_completed?
+          end
+        end
+      end
+
+      context "something crazy happens" do
+        # It's going to try to call the after transition method, but since it doesn't exist...
+        should "be ok" do
+          @call.something_crazy_happens!
+        end
+      end
+
+      context "cancelled" do
+        should "stay in cancelled" do
+          @call.stubs(:cancelled)
+          @call.state = 'cancelled'
+
+          @call.customer_hangs_up!
+
+          assert @call.cancelled?
+          assert_received(@call, :cancelled) { |e| e.never }
+        end
+      end
+
+      context "using test DSL:" do
+        should_flow :on => :incoming_call, :initial => :routing, :when => Proc.new {
+          @call.stubs(:agents_available?).returns(true)
+        }
+
+        should_flow :on => :incoming_call, :initial => :voicemail, :when => Proc.new {
+          @call.stubs(:agents_available?).returns(false)
+        } do
+          should_flow :on => :customer_hangs_up, :voicemail => :voicemail_completed
+        end
+
+        should_flow :on => :something_crazy_happens, :initial => :uh_oh
+
+        should_flow :on => :customer_hangs_up, :cancelled => :cancelled do
+          should_also { assert_received(@call, :cancelled) { |e| e.never } }
+        end
+      end
+    end
+  end
+
+  context "call" do
+    setup do
+      @call = Call.new
+    end
+
+    should  "render xml for initial state" do
+      @call.expects(:notify).with(:rendering_initial)
+      body @call.render
+      assert_select "Response>Say", "Hello World"
+    end
+
+    should  "render xml for voicemail state" do
+      @call.stubs(:agents_available?).returns(false)
+      @call.incoming_call!
+      @call.expects(:notify).with(:rendering_voicemail)
+      @call.expects(:flow_url).with(:voicemail_complete).returns('the_flow')
+
+      body @call.render
+      assert_select "Response>Say"
+      assert_select "Response>Record[action=the_flow]"
+    end
+
+    should "render noop when no render block" do
+      @call.stubs(:agents_available?).returns(true)
+      @call.incoming_call!
+
+      body @call.render
+      assert_select "Response"
+    end
+
+    should "respond when flow to state (once)" do
+      @call.state = 'routing'
+      @call.expects(:notify).with(:cancelled).once
+      @call.customer_hangs_up!
+      assert @call.cancelled?
+      @call.customer_hangs_up!
+      assert @call.cancelled?
+      @call.customer_hangs_up!
+      assert @call.cancelled?
+    end
+
+    should "asynchronously perform event" do
+      @call.stubs(:agents_available?).returns(true)
+      @call.incoming_call!
+      @call.expects(:redirect_to).with(:start_conference)
+
+      @call.redirect_and_start_conference!
+    end
+
+    should "asynchronously perform event with options" do
+      @call.stubs(:agents_available?).returns(true)
+      @call.incoming_call!
+      @call.expects(:redirect_to).with(:start_conference, :status => 'completed')
+
+      @call.redirect_and_start_conference!(:status => 'completed')
+    end
+
+    should "raise error on missing method" do
+      assert_raises {
+        @call.i_am_missing!
+      }
+    end
+
+    should "draw state machine digraph" do
+      Call.state_machines[:state].expects(:draw).with(:name => 'call_workflow', :font => 'Helvetica Neue')
+      @call.draw_call_flow(:name => 'call_workflow', :font => 'Helvetica Neue')
+    end
+
+    context "using test DSL:" do
+      should_flow :on => :incoming_call, :initial => :voicemail, :when => Proc.new {
+        @call.stubs(:agents_available?).returns(false)
+        @call.stubs(:notify)
+        @call.stubs(:flow_url).returns('the_flow')
+      } do
+        should_also { assert_received(@call, :notify) { |e| e.with(:rendering_voicemail) } }
+        and_also { assert_received(@call, :flow_url) { |e| e.with(:voicemail_complete) } }
+        and_render { "Response>Say" }
+        and_render { "Response>Record[action=the_flow]" }
+      end
+
+      should_flow :on => :incoming_call, :initial => :routing, :when => Proc.new {
+        @call.stubs(:agents_available?).returns(true)
+      } do
+        should_render { "Response" }
+      end
+
+      should_flow :on => :customer_hangs_up, :routing => :cancelled, :when => Proc.new {
+        @call.stubs(:notify)
+      } do
+        should_also { assert_received(@call, :notify) { |e| e.with(:cancelled).once } }
+        and_also { assert @call.cancelled? }
+
+        should_flow :on => :customer_hangs_up, :cancelled => :cancelled do
+          should_also { assert_received(@call, :notify) { |e| e.with(:cancelled).once } } # For above
+          and_also { assert @call.cancelled? }
+
+          should_flow :on => :customer_hangs_up, :cancelled => :cancelled do
+            should_also { assert_received(@call, :notify) { |e| e.with(:cancelled).once } } # For above
+            and_also { assert @call.cancelled? }
+          end
+        end
+      end
+    end
+  end
+
+  context "non-standard call" do
+    setup do
+      @call = NonStandardCall.new
+    end
+
+    should "render xml for initial state" do
+      assert_equal 'ready', @call.status
+      body @call.render
+      assert_select "Response>Say", "Hello World"
+    end
+  end
+
+  context "cache call" do
+    should "re-apply state machine and render xml for initial state" do
+      Object.send(:remove_const, :NonStandardCall)
+      Object.const_set(:NonStandardCall, Class.new)
+      NonStandardCall.class_eval do
+        include CallCenter
+        call_flow :status, :initial => :ready do
+          raise Exception, "Should not be called"
+        end
+      end
+
+      @call = NonStandardCall.new
+
+      assert_equal 'ready', @call.status
+      body @call.render
+      assert_select "Response>Say", "Hello World"
+      assert @call.go!
+    end
+  end
+
+  context "cache multiple call flows" do
+    should "re-apply state machine and render xml for initial state" do
+      Object.send(:remove_const, :MultipleFlowCall)
+      Object.const_set(:MultipleFlowCall, Class.new)
+      MultipleFlowCall.class_eval do
+        include CallCenter
+        call_flow :status, :initial => :ready do
+          raise Exception, "Should not be called"
+        end
+        call_flow :outgoing_status, :initial => :outgoing_ready do
+          raise Exception, "Should not be called"
+        end
+      end
+
+      @call = MultipleFlowCall.new
+
+      assert_equal 'ready', @call.status
+      body @call.render
+      assert_select "Response>Say", "Hello World"
+      assert @call.go!
+
+      assert_equal 'outgoing_ready', @call.outgoing_status
+      body @call.render(:outgoing_status)
+      assert_select "Response>Say", "Hello Outgoing World"
+      assert @call.outgoing_go!
+    end
+  end
+end

data/test/core_ext_test.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class MyObject
+
+end
+
+class CoreExtTest < Test::Unit::TestCase
+  should "use existing" do
+    obj = MyObject.new
+    $capture = nil
+    block = lambda { |a|
+      $capture = [self, a]
+    }
+    obj.instance_exec(true, &block)
+
+    assert_equal [obj, true], $capture
+  end
+end

data/test/examples/call.rb

@@ -0,0 +1,46 @@
+class Call
+  include CallCenter
+  include CommonCallMethods
+
+  call_flow :state, :initial => :initial do
+    state :initial do
+      event :incoming_call, :to => :voicemail, :unless => :agents_available?
+      event :incoming_call, :to => :routing, :if => :agents_available?
+      event :something_crazy_happens, :to => :uh_oh
+    end
+
+    state :voicemail do
+      event :customer_hangs_up, :to => :voicemail_completed
+    end
+
+    state :routing do
+      event :customer_hangs_up, :to => :cancelled
+      event :start_conference, :to => :in_conference
+    end
+
+    state :cancelled do
+      event :customer_hangs_up, :to => same
+    end
+
+    # =================
+    # = Render Blocks =
+    # =================
+
+    state :initial do
+      on_render do |call, x| # To allow defining render blocks within a state
+        call.notify(:rendering_initial)
+        x.Say "Hello World"
+      end
+    end
+
+    on_render(:voicemail) do |call, x| # To allow defining render blocks outside a state
+      notify(:rendering_voicemail)
+      x.Say "Hello World"
+      x.Record :action => flow_url(:voicemail_complete)
+    end
+
+    on_flow_to(:cancelled) do |call, transition|
+      notify(:cancelled)
+    end
+  end
+end