call_center 0.1.1 → 0.1.2

data/README.md

@@ -3,6 +3,8 @@ Call Center
 
 Support for defining call center workflows.
 
+[![Build Status](https://secure.travis-ci.org/zendesk/call_center.png)](http://travis-ci.org/zendesk/call_center)
+
 Overview
 --------
 Call Center streamlines the process of defining multi-party call workflows in your application. Particularly, with [Twilio](http://www.twilio.com/docs) in mind.

data/Rakefile

@@ -40,7 +40,13 @@ Rcov::RcovTask.new do |test|
   test.rcov_opts << '--exclude "gems/*,lib/call_center/core_ext/object_instance_exec.rb"'
 end
 
-task :default => :test
+namespace :test do
+  Rake::TestTask.new(:dsl) do |t|
+    t.pattern = "minitest/**/*_test.rb"
+  end
+end
+
+task :default => ['test', 'test:dsl']
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/call_center.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{call_center}
-  s.version = "0.1.1"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Henry Hsu"]

data/lib/call_center.rb

@@ -54,6 +54,10 @@ module CallCenter
     def current_state_machine
       self.state_machines[self.call_flow_state_machine_name]
     end
+
+    def inherited(subclass)
+      subclass.call_flow_state_machine_name ||= self.call_flow_state_machine_name
+    end
   end
 
   module InstanceMethods

data/test/call_center_test.rb

@@ -4,6 +4,7 @@ require 'call_center/test/dsl'
 
 require 'test/examples/legacy_call'
 require 'test/examples/call'
+require 'test/examples/outbound_call'
 require 'test/examples/non_standard_call'
 require 'test/examples/multiple_flow_call'
 require 'test/examples/dynamic_transition_call'
@@ -175,227 +176,230 @@ class CallCenterTest < Test::Unit::TestCase
     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
+  ['Call', 'SubclassCall'].each do |class_name|
+    context class_name do
+      setup do
+        klass = class_name.constantize
+        @call = klass.new
+      end
 
-    should "return customer url for event" do
-      assert_equal("/voice/calls/flow?event=voicemail_complete&actor=customer", @call.customer(:voicemail_complete))
-    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 "return agent url for event" do
-      assert_equal("/voice/calls/flow?event=voicemail_complete&actor=agent", @call.agent(:voicemail_complete))
-    end
+      should "return customer url for event" do
+        assert_equal("/voice/calls/flow?event=voicemail_complete&actor=customer", @call.customer(:voicemail_complete))
+      end
 
-    should "render xml for voicemail state" do
-      @call.stubs(:agents_available?).returns(false)
-      @call.incoming_call!
-      @call.expects(:notify).with(:rendering_voicemail)
+      should "return agent url for event" do
+        assert_equal("/voice/calls/flow?event=voicemail_complete&actor=agent", @call.agent(:voicemail_complete))
+      end
 
-      body @call.render
-      assert_select "Response>Say"
-      assert_select "Response>Record[action=/voice/calls/flow?event=voicemail_complete&actor=customer]"
-    end
+      should "render xml for voicemail state" do
+        @call.stubs(:agents_available?).returns(false)
+        @call.incoming_call!
+        @call.expects(:notify).with(:rendering_voicemail)
 
-    should "render noop when no render block" do
-      @call.stubs(:agents_available?).returns(true)
-      @call.incoming_call!
+        body @call.render
+        assert_select "Response>Say"
+        assert_select "Response>Record[action=/voice/calls/flow?event=voicemail_complete&actor=customer]"
+      end
 
-      body @call.render
-      assert_select "Response"
-    end
+      should "render noop when no render block" do
+        @call.stubs(:agents_available?).returns(true)
+        @call.incoming_call!
 
-    should "execute callbacks" do
-      @call.state = 'cancelled'
+        body @call.render
+        assert_select "Response"
+      end
 
-      @call.expects(:notify).with(:before_always).times(3)
-      @call.expects(:notify).with(:before_always_uniq).times(1)
+      should "execute callbacks" do
+        @call.state = 'cancelled'
 
-      @call.expects(:notify).with(:after_always).times(4)
-      @call.expects(:notify).with(:after_success).times(3)
-      @call.expects(:notify).with(:after_failure).times(1)
+        @call.expects(:notify).with(:before_always).times(3)
+        @call.expects(:notify).with(:before_always_uniq).times(1)
 
-      @call.expects(:notify).with(:after_always_uniq).times(1)
-      @call.expects(:notify).with { |notification, transition| notification == :after_success_uniq && transition.kind_of?(StateMachine::Transition) }.times(1)
-      @call.expects(:notify).with(:after_failure_uniq).times(0)
+        @call.expects(:notify).with(:after_always).times(4)
+        @call.expects(:notify).with(:after_success).times(3)
+        @call.expects(:notify).with(:after_failure).times(1)
 
-      @call.customer_end!
-      @call.customer_end!
-      @call.customer_end!
-      assert(!@call.customer_hangs_up)
-    end
+        @call.expects(:notify).with(:after_always_uniq).times(1)
+        @call.expects(:notify).with { |notification, transition| notification == :after_success_uniq && transition.kind_of?(StateMachine::Transition) }.times(1)
+        @call.expects(:notify).with(:after_failure_uniq).times(0)
 
-    should "execute callbacks in sequence" do
-      seq = sequence('callback_sequence')
-      @call.state = 'cancelled'
+        @call.customer_end!
+        @call.customer_end!
+        @call.customer_end!
+        assert(!@call.customer_hangs_up)
+      end
 
-      @call.expects(:notify).with(:before_always).in_sequence(seq)
-      @call.expects(:notify).with(:before_always_uniq).in_sequence(seq)
+      should "execute callbacks in sequence" do
+        seq = sequence('callback_sequence')
+        @call.state = 'cancelled'
 
-      @call.expects(:notify).with(:after_always).in_sequence(seq)
-      @call.expects(:notify).with(:after_success).in_sequence(seq)
+        @call.expects(:notify).with(:before_always).in_sequence(seq)
+        @call.expects(:notify).with(:before_always_uniq).in_sequence(seq)
 
-      @call.expects(:notify).with(:after_always_uniq).in_sequence(seq)
-      @call.expects(:notify).with(:after_success_uniq, anything).in_sequence(seq)
+        @call.expects(:notify).with(:after_always).in_sequence(seq)
+        @call.expects(:notify).with(:after_success).in_sequence(seq)
 
-      @call.customer_end!
-    end
+        @call.expects(:notify).with(:after_always_uniq).in_sequence(seq)
+        @call.expects(:notify).with(:after_success_uniq, anything).in_sequence(seq)
 
-    should "defer callbacks" do
-      (class << @call; self; end).class_eval do
-        include CallCenter::DeferredCallbacks
+        @call.customer_end!
       end
-      @call.state = 'cancelled'
 
-      @call.expects(:notify).with(:before_always).never
-      @call.expects(:notify).with(:before_always_uniq).never
-
-      @call.expects(:notify).with(:after_always).never
-      @call.expects(:notify).with(:after_success).never
-      @call.expects(:notify).with(:after_failure).never
+      should "defer callbacks" do
+        (class << @call; self; end).class_eval do
+          include CallCenter::DeferredCallbacks
+        end
+        @call.state = 'cancelled'
 
-      @call.expects(:notify).with(:after_always_uniq).never
-      @call.expects(:notify).with(:after_success_uniq, anything).never
+        @call.expects(:notify).with(:before_always).never
+        @call.expects(:notify).with(:before_always_uniq).never
 
-      @call.customer_end!
-      assert(!@call.customer_hangs_up)
+        @call.expects(:notify).with(:after_always).never
+        @call.expects(:notify).with(:after_success).never
+        @call.expects(:notify).with(:after_failure).never
 
-      # Ready for deferred callbacks
+        @call.expects(:notify).with(:after_always_uniq).never
+        @call.expects(:notify).with(:after_success_uniq, anything).never
 
-      seq = sequence('callback_sequence')
+        @call.customer_end!
+        assert(!@call.customer_hangs_up)
 
-      @call.expects(:notify).with(:before_always)
-      @call.expects(:notify).with(:before_always_uniq)
+        # Ready for deferred callbacks
 
-      @call.call_flow_run_deferred(:before_transition)
+        seq = sequence('callback_sequence')
 
-      @call.expects(:notify).with(:after_always).times(2)
-      @call.expects(:notify).with(:after_success)
+        @call.expects(:notify).with(:before_always)
+        @call.expects(:notify).with(:before_always_uniq)
 
-      @call.expects(:notify).with(:after_always_uniq)
-      @call.expects(:notify).with(:after_success_uniq, anything)
+        @call.call_flow_run_deferred(:before_transition)
 
-      @call.call_flow_run_deferred(:after_transition)
+        @call.expects(:notify).with(:after_always).times(2)
+        @call.expects(:notify).with(:after_success)
 
-      @call.expects(:notify).with(:after_always).times(2)
-      @call.expects(:notify).with(:after_failure)
-      @call.expects(:notify).with(:after_always_uniq)
+        @call.expects(:notify).with(:after_always_uniq)
+        @call.expects(:notify).with(:after_success_uniq, anything)
 
-      @call.call_flow_run_deferred(:after_failure)
+        @call.call_flow_run_deferred(:after_transition)
 
-      # Empty
-      @call.call_flow_run_deferred(:before_transition)
-      @call.call_flow_run_deferred(:after_transition)
-      @call.call_flow_run_deferred(:after_failure)
-    end
+        @call.expects(:notify).with(:after_always).times(2)
+        @call.expects(:notify).with(:after_failure)
+        @call.expects(:notify).with(:after_always_uniq)
 
-    should "asynchronously perform event" do
-      @call.stubs(:agents_available?).returns(true)
-      @call.incoming_call!
-      @call.expects(:redirect_to).with(:start_conference)
+        @call.call_flow_run_deferred(:after_failure)
 
-      @call.redirect_and_start_conference!
-    end
+        # Empty
+        @call.call_flow_run_deferred(:before_transition)
+        @call.call_flow_run_deferred(:after_transition)
+        @call.call_flow_run_deferred(:after_failure)
+      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')
+      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!(:status => 'completed')
-    end
+        @call.redirect_and_start_conference!
+      end
 
-    should "raise error on missing method" do
-      assert_raises {
-        @call.i_am_missing!
-      }
-    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')
 
-    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
+        @call.redirect_and_start_conference!(:status => 'completed')
+      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(:customer).returns('the_flow')
-      } do
-        should_also { assert_received(@call, :notify) { |e| e.with(:rendering_voicemail) } }
-        and_also { assert_received(@call, :customer) { |e| e.with(:voicemail_complete) } }
-        and_render { "Response>Say" }
-        and_render { "Response>Record[action=the_flow]" }
+      should "raise error on missing method" do
+        assert_raises {
+          @call.i_am_missing!
+        }
       end
 
-      should_flow :on => :incoming_call, :initial => :routing, :when => Proc.new {
-        @call.stubs(:agents_available?).returns(true)
-      } do
-        should_render { "Response" }
+      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
 
-      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? }
+      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(:customer).returns('the_flow')
+        } do
+          should_also { assert_received(@call, :notify) { |e| e.with(:rendering_voicemail) } }
+          and_also { assert_received(@call, :customer) { |e| e.with(:voicemail_complete) } }
+          and_render { "Response>Say" }
+          and_render { "Response>Record[action=the_flow]" }
+        end
 
-        should_flow :on => :customer_hangs_up, :cancelled => :cancelled do
-          should_also { assert_received(@call, :notify) { |e| e.with(:cancelled).once } } # For above
+        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 "deferred and using test DSL:" do
-      setup do
-        (class << @call; self; end).class_eval do
-          include CallCenter::DeferredCallbacks
+      context "deferred and using test DSL:" do
+        setup do
+          (class << @call; self; end).class_eval do
+            include CallCenter::DeferredCallbacks
+          end
         end
-      end
 
-      should_flow :on => :incoming_call, :initial => :voicemail, :when => Proc.new {
-        @call.stubs(:agents_available?).returns(false)
-        @call.stubs(:notify)
-        @call.stubs(:customer).returns('the_flow')
-      } do
-        should_also { assert_received(@call, :notify) { |e| e.with(:rendering_voicemail) } }
-        and_also { assert_received(@call, :customer) { |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 => :incoming_call, :initial => :voicemail, :when => Proc.new {
+          @call.stubs(:agents_available?).returns(false)
+          @call.stubs(:notify)
+          @call.stubs(:customer).returns('the_flow')
+        } do
+          should_also { assert_received(@call, :notify) { |e| e.with(:rendering_voicemail) } }
+          and_also { assert_received(@call, :customer) { |e| e.with(:voicemail_complete) } }
+          and_render { "Response>Say" }
+          and_render { "Response>Record[action=the_flow]" }
+        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 => :incoming_call, :initial => :routing, :when => Proc.new {
+          @call.stubs(:agents_available?).returns(true)
+        } do
+          should_render { "Response" }
+        end
 
-        should_flow :on => :customer_hangs_up, :cancelled => :cancelled do
-          should_also { assert_received(@call, :notify) { |e| e.with(:cancelled).once } } # For above
+        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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: call_center
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Henry Hsu