larynx 0.1.0

data/spec/larynx/call_handler_spec.rb

@@ -0,0 +1,290 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Larynx::CallHandler do
+  attr_reader :call
+
+  before do
+    @call = TestCallHandler.new(1)
+  end
+
+  context "execute" do
+    before do
+      call.queue = []
+    end
+
+    it "should queue commands" do
+      call.execute Larynx::Command.new('dummy1')
+      call.execute Larynx::Command.new('dummy2')
+      call.queue[0].command.should == 'dummy1'
+      call.queue[1].command.should == 'dummy2'
+    end
+
+    it "should push command on front of queue when immediate is true" do
+      call.execute Larynx::Command.new('dummy1')
+      call.execute Larynx::Command.new('dummy2'), true
+      call.queue[0].command.should == 'dummy2'
+      call.queue[1].command.should == 'dummy1'
+    end
+  end
+
+  it "should return first command in queue for current_command" do
+    call.queue = []
+    call.execute Larynx::Command.new('dummy')
+    call.current_command.command.should == 'dummy'
+  end
+
+  it "should send current command message on send_next_command" do
+    call.queue = []
+    call.execute Larynx::Command.new('dummy')
+    call.send_next_command
+    call.sent_data.should == 'dummy'
+  end
+
+  context "reply received" do
+    before do
+      call.queue = []
+    end
+
+    it "should finalise current command if it is an API command" do
+      call.should_receive :finalize_command
+      call.connect
+      call.send_response :reply_ok
+    end
+
+    it "should not finalise current command if it is an App command" do
+      call.should_not_receive :finalize_command
+      call.speak 'hello'
+      call.send_response :reply_ok
+    end
+  end
+
+  context "executing event received" do
+    before do
+      call.queue = []
+    end
+
+    it "should run app command before callback" do
+      call.speak('hello world').before { @callback = true }
+      call.send_response :execute
+      @callback.should be_true
+    end
+
+    it "should change state to executing" do
+      call.speak 'hello'
+      call.send_response :execute
+      call.state.should == :executing
+    end
+
+    it "should not finalize command" do
+      call.should_not_receive :finalize_command
+      call.speak 'hello'
+      call.send_response :execute
+    end
+  end
+
+  context "execution complete event received" do
+    before do
+      call.queue = []
+    end
+
+    it "should finalize command" do
+      call.should_receive :finalize_command
+      call.speak 'hello'
+      call.send_response :execute_complete
+    end
+
+    it "should change state to ready" do
+      call.speak 'hello'
+      call.send_response :execute_complete
+      call.state.should == :ready
+    end
+  end
+
+  context "finalizing command" do
+    before do
+      call.queue = []
+      call.speak('hello world').after { @callback = true }
+      @command = call.current_command
+      call.finalize_command
+    end
+
+    it "should run after callback" do
+      @callback.should be_true
+    end
+
+    it "should remove command from queue" do
+      call.queue.should be_empty
+    end
+
+    it "should set command as last command" do
+      call.last_command.should == @command
+    end
+  end
+
+	it "should queue connect command on init" do
+		call.current_command.name.should == 'connect'
+	end
+
+  context "on connection" do
+    it "should create session object" do
+      connect_call
+      call.session.should_not be_nil
+    end
+
+    it "should fire global connect callback" do
+      Larynx.connect {|call| @callback = true }
+      connect_call
+      @callback.should be_true
+    end
+
+    it "should start the call session" do
+      call.should_receive :start_session
+      connect_call
+    end
+
+    def connect_call
+      call.send_response :channel_data
+    end
+
+    after do
+      Larynx.connect {|call|}
+    end
+  end
+
+  context "on session start" do
+    before do
+      call.queue = []
+      call.session = mock('session', :unique_id => '123')
+    end
+
+    it "should subscribe to myevents" do
+      call.should_receive(:myevents)
+      call.start_session
+    end
+
+    it "should set event lingering on after filter events" do
+      call.should_receive(:linger)
+      call.start_session
+      call.send_response :reply_ok
+    end
+
+    it "should answer call after filter events" do
+      call.should_receive(:answer)
+      call.start_session
+      call.send_response :reply_ok
+    end
+  end
+
+  context "on answer" do
+    before do
+      call.queue = []
+      call.session = mock('session', :unique_id => '123')
+    end
+
+    it "should change state to ready" do
+      answer_call
+      call.state.should == :ready
+    end
+
+    it "should fire global answer callback" do
+      Larynx.answer {|call| @callback = true }
+      answer_call
+      @callback.should be_true
+    end
+
+    def answer_call
+      call.start_session
+      call.send_response :reply_ok
+      call.send_response :reply_ok
+      call.send_response :reply_ok
+      call.send_response :execute_complete
+    end
+  end
+
+  context "DTMF event" do
+    it "should add DTMF digit to input" do
+      run_command
+      call.send_response :dtmf
+      call.input.should == ['1']
+    end
+
+    it "should send break if interruptable command" do
+      run_command true
+      call.send_response :dtmf
+      call.sent_data.should match(/break/)
+    end
+
+    it "should not send break if non-interruptable command" do
+      run_command false
+      call.send_response :dtmf
+      call.sent_data.should_not match(/break/)
+    end
+
+    it "should send next command if state is ready" do
+      call.state = :ready
+      call.should_receive(:send_next_command)
+      call.send_response :dtmf
+    end
+
+    it "should notify observers and pass digit" do
+      app = mock('App')
+      call.add_observer app
+      app.should_receive(:dtmf_received).with('1')
+      call.send_response :dtmf
+    end
+
+    def run_command(interruptable=true)
+      call.queue = []
+      call.speak 'hello', :bargein => interruptable
+      call.send_next_command
+      call.send_response :execute
+    end
+  end
+
+  context "timer" do
+    it "should add EM timer with name and timeout" do
+      Larynx::RestartableTimer.stub!(:new)
+      call.timer(:test, 0.1)
+      call.timers[:test].should_not be_nil
+    end
+
+    it "should run callback on timeout" do
+      em do
+        call.timer(:test, 0.2) { @callback = true; done }
+      end
+      @callback.should be_true
+    end
+  end
+
+  context "stop_timer" do
+    it "should run callback on timeout" do
+      em do
+        call.timer(:test, 1) { @callback = true }
+        EM::Timer.new(0.1) { call.stop_timer :test; done }
+      end
+      @callback.should be_true
+    end
+  end
+
+  context "cancel_timer" do
+    it "should not run callback" do
+      em do
+        call.timer(:test, 0.2) { @callback = true }
+        EM::Timer.new(0.1) { call.cancel_timer :test; done }
+      end
+      @callback.should_not be_true
+    end
+  end
+
+  context "restart_timer" do
+    it "should start timer again" do
+      start = Time.now
+      em do
+        EM::Timer.new(0.5) { call.restart_timer :test }
+        call.timer(:test, 1) { done }
+      end
+      (Time.now-start).should be_close(1.5, 0.2)
+    end
+  end
+
+end

data/spec/larynx/command_spec.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Larynx::Command do
+
+  it "should allow before callback" do
+    cmd = Larynx::Command.new('dummy').before { @callback = true }
+    @callback.should_not be_true
+    cmd.fire_callback :before
+    @callback.should be_true
+  end
+
+  it "should allow after callback" do
+    cmd = Larynx::Command.new('dummy').after  { @callback = true }
+    @callback.should_not be_true
+    cmd.fire_callback :after
+    @callback.should be_true
+  end
+
+  it "should add block given to new as after block" do
+    cmd = Larynx::Command.new('dummy') { @callback = true }
+    @callback.should_not be_true
+    cmd.fire_callback :after
+    @callback.should be_true
+  end
+
+  context 'call command' do
+    before do
+      @cmd = Larynx::CallCommand.new('dummy', 'arg')
+    end
+
+    it "should return name as command and params" do
+      @cmd.name.should == 'dummy arg'
+    end
+
+    it "should return to_s as full command message" do
+      @cmd.to_s.should == "dummy arg\n\n"
+    end
+  end
+
+  context 'api command' do
+    before do
+      @cmd = Larynx::ApiCommand.new('dummy', 'arg')
+    end
+
+    it "should return name as command and params" do
+      @cmd.name.should == 'dummy arg'
+    end
+
+    it "should return to_s as full command message" do
+      @cmd.to_s.should == "api dummy arg\n\n"
+    end
+  end
+
+  context 'app command' do
+    before do
+      @cmd = Larynx::AppCommand.new('dummy', 'arg', :bargein => true)
+    end
+
+    it "should return name as command and params" do
+      @cmd.name.should == "dummy 'arg'"
+    end
+
+    it "should return to_s as full command message" do
+      @cmd.to_s.should == "sendmsg\ncall-command: execute\nexecute-app-name: dummy\nexecute-app-arg: arg\n\n"
+    end
+
+    it "should return to_s as with arg if no param" do
+      cmd = Larynx::AppCommand.new('dummy')
+      cmd.to_s.should == "sendmsg\ncall-command: execute\nexecute-app-name: dummy\n\n"
+    end
+
+    it "should return true for interruptable if bargein option is true" do
+      @cmd.interruptable?.should be_true
+    end
+  end
+end

data/spec/larynx/eventmachince_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Larynx::RestartableTimer do
+
+  it "should allow timer to be restarted" do
+    start = Time.now
+    em do
+      timer = Larynx::RestartableTimer.new(1) { done }
+      EM::Timer.new(0.5) { timer.restart }
+    end
+    (Time.now-start).should be_close(1.5, 0.2)
+  end
+
+end

data/spec/larynx/fields_spec.rb

@@ -0,0 +1,194 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Larynx::Fields do
+  attr_reader :call, :app
+
+  before do
+    @call = TestCallHandler.new(1)
+    @app = Larynx::Application.new(@call)
+  end
+
+  context 'module' do
+    include Larynx::Fields
+
+    it 'should add field class method' do
+      self.class.should respond_to(:field)
+    end
+
+    it 'should add instance accessor for field name' do
+      self.class.field(:guess) { prompt :speak => 'hello' }
+      self.methods.include?(:guess)
+    end
+  end
+
+  context 'next_field' do
+    include Larynx::Fields
+    field(:field1) { prompt :speak => 'hello' }
+    field(:field2) { prompt :speak => 'hello' }
+    field(:field3) { prompt :speak => 'hello' }
+
+    it 'should iterate over defined fields' do
+      next_field.name.should == :field1
+      next_field.name.should == :field2
+      next_field.name.should == :field3
+    end
+
+    it 'should jump to field name if supplied' do
+      next_field(:field2).name.should == :field2
+    end
+  end
+
+  context 'field object' do
+    it 'should raise exception if field has no prompt' do
+      lambda { field(:guess) {} }.should raise_exception(Larynx::NoPromptDefined)
+    end
+
+    it 'should run setup callback once' do
+      call_me = should_be_called
+      fld = field(:guess) do
+        prompt :speak => 'first'
+        setup &call_me
+      end
+      fld.run app
+    end
+
+    it 'should return same prompt all attempts if single prompt' do
+      fld = field(:guess) do
+        prompt :speak => 'first'
+      end
+      fld.run(app)
+      fld.current_prompt.message.should == 'first'
+      fld.increment_attempts
+      fld.current_prompt.message.should == 'first'
+    end
+
+    it 'should return reprompt for subsequent prompts' do
+      fld = field(:guess) do
+        prompt :speak => 'first'
+        reprompt :speak => 'second'
+      end
+      fld.run(app)
+      fld.current_prompt.message.should == 'first'
+      fld.increment_attempts
+      fld.current_prompt.message.should == 'second'
+    end
+
+    it 'should return prompt for given number of repeats before subsequent prompts' do
+      fld = field(:guess) do
+        prompt :speak => 'first', :repeats => 2
+        reprompt :speak => 'second'
+      end
+      fld.run(app)
+      fld.current_prompt.message.should == 'first'
+      fld.increment_attempts
+      fld.current_prompt.message.should == 'first'
+      fld.increment_attempts
+      fld.current_prompt.message.should == 'second'
+    end
+
+    context 'valid?' do
+      it 'should be false if input size less than minimum' do
+        fld = field(:guess) do
+          prompt :speak => 'first'
+        end
+        fld.run app
+        fld.current_prompt.finalise
+        fld.valid?.should be_false
+      end
+
+      it 'should run validate callback if input minimum length' do
+        call_me = should_be_called
+        fld = field(:guess, :min_length => 1) do
+          prompt :speak => 'first'
+          validate &call_me
+        end
+        fld.run app
+        call.input << '1'
+        fld.current_prompt.finalise
+      end
+    end
+
+    context 'input evaluation' do
+      it 'should run invalid callback if length not valid' do
+        call_me = should_be_called
+        fld = field(:guess) do
+          prompt :speak => 'first'
+          invalid &call_me
+        end
+        fld.run app
+        fld.current_prompt.finalise
+      end
+
+      it 'should run invalid callback if validate callback returns false' do
+        call_me = should_be_called
+        fld = field(:guess, :min_length => 1) do
+          prompt :speak => 'first'
+          validate { false }
+          invalid &call_me
+        end
+        fld.run app
+        call.input << '1'
+        fld.current_prompt.finalise
+      end
+
+      it 'should run success callback if length valid and no validate callback' do
+        call_me = should_be_called
+        fld = field(:guess, :min_length => 1) do
+          prompt :speak => 'first'
+          success &call_me
+        end
+        fld.run app
+        call.input << '1'
+        fld.current_prompt.finalise
+      end
+
+      it 'should run success callback if validate callback returns true' do
+        call_me = should_be_called
+        fld = field(:guess, :min_length => 1) do
+          prompt :speak => 'first'
+          validate { true }
+          success &call_me
+        end
+        fld.run app
+        call.input << '1'
+        fld.current_prompt.finalise
+      end
+
+      it 'should run failure callback if not valid and last attempt' do
+        call_me = should_be_called
+        fld = field(:guess, :min_length => 1, :attempts => 1) do
+          prompt :speak => 'first'
+          failure &call_me
+        end
+        fld.run app
+        fld.current_prompt.finalise
+      end
+
+      it 'should increment attempts if not valid' do
+        fld = field(:guess) do
+          prompt :speak => 'first'
+          reprompt :speak => 'second'
+        end
+        fld.run app
+        fld.current_prompt.finalise
+        fld.current_prompt.message.should == 'second'
+      end
+
+      it 'should execute next prompt if not valid' do
+        fld = field(:guess) do
+          prompt :speak => 'first'
+          reprompt :speak => 'second'
+        end
+        fld.run app
+        fld.should_receive(:execute_prompt)
+        fld.current_prompt.finalise
+      end
+    end
+
+  end
+
+  def field(name, options={}, &block)
+    @app.class.class_eval { attr_accessor name }
+    Larynx::Fields::Field.new(name, options, &block)
+  end
+end