freec 0.2.6 → 0.2.8

metadata

@@ -1,84 +1,131 @@
 --- !ruby/object:Gem::Specification
 name: freec
 version: !ruby/object:Gem::Version
-  version: 0.2.6
-  prerelease: 
+  version: 0.2.8
 platform: ruby
 authors:
 - Jan Kubr
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2012-02-23 00:00:00.000000000 Z
+date: 2017-04-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: gserver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: daemons
-  requirement: &70325537302580 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.2.4
   type: :runtime
   prerelease: false
-  version_requirements: *70325537302580
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70325537302100 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>'
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: '3.0'
   type: :development
   prerelease: false
-  version_requirements: *70325537302100
-description: 
-email: mail@jankubr.com
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: The layer between your Ruby voice app and FreeSWITCH.
+email:
+- mail@jankubr.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.rdoc
+extra_rdoc_files: []
 files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
 - README.rdoc
 - Rakefile
+- bin/console
+- bin/setup
+- freec.gemspec
 - lib/call_variables.rb
 - lib/freec.rb
+- lib/freec/version.rb
 - lib/freec_base.rb
 - lib/freec_logger.rb
 - lib/freeswitch_applications.rb
 - lib/listener.rb
 - lib/tools.rb
-- spec/data/event.rb
-- spec/data/event_with_body.rb
-- spec/event_parser_spec.rb
-- spec/freec_base_spec.rb
-- spec/freeswitch_applications_spec.rb
-- spec/spec_helper.rb
 homepage: http://github.com/jankubr/freec
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
-rdoc_options:
-- --line-numbers
-- --inline-source
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: freec
-rubygems_version: 1.8.10
+rubyforge_project: 
+rubygems_version: 2.5.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: The layer between your Ruby voice app and FreeSWITCH.
 test_files: []

data/spec/data/event.rb

@@ -1,56 +0,0 @@
-unless defined?(EVENT)
-EVENT=<<STRING
-Content-Length: 1693
-Content-Type: text/event-plain
-
-Event-Name: CHANNEL_EXECUTE
-Core-UUID: 4a78c88d-38cc-4e35-92af-c155def76f9a
-FreeSWITCH-Hostname: air.local
-FreeSWITCH-IPv4: 10.0.1.2
-FreeSWITCH-IPv6: %3A%3A1
-Event-Date-Local: 2009-05-14%2019%3A29%3A09
-Event-Date-GMT: Thu,%2014%20May%202009%2017%3A29%3A09%20GMT
-Event-Date-Timestamp: 1242322149917313
-Event-Calling-File: switch_core_session.c
-Event-Calling-Function: switch_core_session_exec
-Event-Calling-Line-Number: 1460
-Channel-State: CS_EXECUTE
-Channel-State-Number: 4
-Channel-Name: sofia/internal/jan.kubr.gmail.com%4010.0.1.2
-Channel-Destination-Number: 886
-Unique-ID: f3c2d5ee-d064-4f55-9280-5be2a65867e8
-Call-Direction: inbound
-Presence-Call-Direction: inbound
-Answer-State: answered
-Channel-Read-Codec-Name: GSM
-Channel-Read-Codec-Rate: 8000
-Channel-Write-Codec-Name: GSM
-Channel-Write-Codec-Rate: 8000
-Caller-Username: jan.kubr.gmail.com
-Caller-Dialplan: XML
-Caller-Caller-ID-Name: Jan%20Local
-Caller-Caller-ID-Number: jan.kubr.gmail.com
-Caller-Network-Addr: 10.0.1.2
-Caller-Destination-Number: 0
-Caller-Unique-ID: f3c2d5ee-d064-4f55-9280-5be2a65867e8
-Caller-Source: mod_sofia
-Caller-Context: default
-Caller-Channel-Name: sofia/internal/jan.kubr.gmail.com%4010.0.1.2
-Caller-Profile-Index: 1
-Caller-Profile-Created-Time: 1242322142643329
-Caller-Channel-Created-Time: 1242322142643329
-Caller-Channel-Answered-Time: 1242322143798188
-Caller-Channel-Progress-Time: 0
-Caller-Channel-Progress-Media-Time: 1242322142657064
-Caller-Channel-Hangup-Time: 0
-Caller-Channel-Transfer-Time: 0
-Caller-Screen-Bit: true
-Caller-Privacy-Hide-Name: false
-Caller-Privacy-Hide-Number: false
-variable_sip_to_user: 886
-variable_sip_from_user: 1001
-Application: set
-Application-Data: continue_on_fail%3Dtrue
-
-STRING
-end

data/spec/data/event_with_body.rb

@@ -1,25 +0,0 @@
-unless defined?(EVENT_WITH_BODY)
-EVENT_WITH_BODY=<<STRING
-Content-Length: 460
-Content-Type: text/event-plain
-
-Event-Name: DETECTED_SPEECH
-Core-UUID: b61467b4-6d7c-4a6f-ba87-32ade7b79951
-FreeSWITCH-Hostname: air.local
-FreeSWITCH-IPv4: 10.0.1.2
-FreeSWITCH-IPv6: %3A%3A1
-Event-Date-Local: 2009-05-04%2020%3A40%3A48
-Event-Date-GMT: Mon,%2004%20May%202009%2018%3A40%3A48%20GMT
-Event-Date-Timestamp: 1241462448174337
-Event-Calling-File: switch_ivr_async.c
-Event-Calling-Function: speech_thread
-Event-Calling-Line-Number: 1878
-Speech-Type: detected-speech
-Content-Length: 132
-
-<interpretation grammar="battle" score="100">
-  <result name="match">FREESTYLE</result>
-  <input>FREESTYLE</input>
-</interpretation>
-STRING
-end

data/spec/event_parser_spec.rb

@@ -1,84 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-describe Freec do
-  before do
-    io = stub(:io)
-    log = FreecLogger.new(STDOUT)
-    log.level = Logger::FATAL
-    @freec = Freec.new(io, log, {})
-  end
-  
-  describe "parses body-less event" do
-    before do
-      @freec.instance_variable_set(:@response, EVENT)
-      @freec.send :parse_response
-    end
-    
-    it "should read unique id from response" do
-      @freec.instance_variable_get(:@unique_id).should == 'f3c2d5ee-d064-4f55-9280-5be2a65867e8'
-    end
-    
-    it "should include channel unique id to the array of ids event variables are read from" do
-      @freec.instance_variable_get(:@want_events_from).should == ['f3c2d5ee-d064-4f55-9280-5be2a65867e8']
-    end
-    
-    it "should parse variables from response" do
-      @freec.call_vars[:call_direction].should == 'inbound'
-      @freec.call_vars[:caller_context].should == 'default'
-      @freec.call_vars[:application].should == 'set'
-    end    
-  
-    it "should make the value of the sip_from_user variable available as a method" do
-      @freec.sip_from_user.should == '1001'
-    end
-
-    it "should make the value of the sip_to_user variable available as a method" do
-      @freec.sip_to_user.should == '886'
-    end
-
-    it "should make the value of the channel_destination_number variable available as a method" do
-      @freec.channel_destination_number.should == '886'
-    end
-  end
-  
-  describe "ignores variables from another channel event" do
-
-    it "should not parse variables from event of another channel" do
-      @freec.instance_variable_set(:@response, EVENT)
-      @freec.send(:parse_response).should be_true
-      another_channel_event = EVENT.sub('Unique-ID: f3c2d5ee-d064-4f55-9280-5be2a65867e8', 'Unique-ID: ffff1111-e72d-48bf-9ecf-d71bd4b60617').
-                                    sub('Application: set', 'Application: bridge')
-      @freec.instance_variable_set(:@response, another_channel_event)
-      @freec.send(:parse_response).should be_false
-      @freec.call_vars[:application].should == 'set'
-    end
-    
-    it "parses variables from disconnect notices" do
-      @freec.instance_variable_set(:@response, EVENT)
-      @freec.send(:parse_response).should be_true
-      @freec.call_vars[:content_type].should == 'text/event-plain'
-      disconnect_notice_event = EVENT.sub('Unique-ID: f3c2d5ee-d064-4f55-9280-5be2a65867e8', 'Unique-ID: ').
-                                    sub('Content-Type: text/event-plain', 'Content-Type: text/disconnect-notice')
-      @freec.instance_variable_set(:@response, disconnect_notice_event)
-      @freec.send(:parse_response).should be_true 
-      @freec.call_vars[:content_type].should == 'text/disconnect-notice'
-    end    
-    
-  end
-
-  describe "parses an event with a body" do
-    before do
-      @freec.instance_variable_set(:@response, EVENT_WITH_BODY)
-      @freec.send :parse_response
-    end
-      
-    it "should parse the variables from the event header" do
-      @freec.call_vars[:event_name].should == 'DETECTED_SPEECH'
-    end
-    
-    it "makes the body of the response available as a public method" do
-      @freec.event_body.should =~ /<\/interpretation>$/
-    end
-
-  end
-end

data/spec/freec_base_spec.rb

@@ -1,213 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-module FreecSpecHelper
-  def event_parts(event=EVENT)
-    @parts = event.split("\n\n").map {|p| "#{p}\n\n"}  
-  end
-  
-  def initial_response
-    @initial_response ||= EVENT.split("\n\n")[1] + "\n\n"
-  end
-  
-end
-
-describe Freec do
-  include FreecSpecHelper
-
-  before do
-    @io = stub(:io)
-    @log = FreecLogger.new(STDOUT)
-    @log.level = Logger::FATAL
-    @config = {:config1 => 'value'}
-    @freec = Freec.new(@io, @log, @config)
-  end
-  
-  describe "initialization" do
-
-    it "makes log and config available" do
-      @freec.log.should == @log
-      @freec.config.should == @config
-    end
-
-  end
-
-  describe "call initialization" do
-  
-    it "sends 'connect' command to Freeswitch" do
-      @freec.should_receive(:send_data).with("connect")
-      @freec.should_receive(:send_data)
-      @freec.should_receive(:send_data)
-      @freec.should_receive(:send_data)
-      @io.should_receive(:gets).exactly(4).and_return(initial_response)
-      @freec.send :call_initialization
-    end
-    
-    it "subscribes to events" do
-      @freec.should_receive(:send_data)
-      @freec.should_receive(:send_data).with('events plain all')
-      @freec.should_receive(:send_data).with('filter Unique-ID f3c2d5ee-d064-4f55-9280-5be2a65867e8')
-      @freec.should_receive(:send_data).with('divert_events on')
-      @io.should_receive(:gets).exactly(4).and_return(initial_response)
-      @freec.send :call_initialization
-    end
-    
-  end
-  
-  describe "response reader" do
-  
-    it "reads the full body-less event" do
-      @io.should_receive(:gets).and_return(event_parts(EVENT)[0], event_parts(EVENT)[1])
-      @freec.send(:read_response)
-    end
-
-    it "raises exception if IO is disconnected while reading response info" do
-      @io.should_receive(:gets).and_return(nil)
-      lambda { @freec.send(:read_response) }.should raise_error(RuntimeError, 'IO disconnected - FreeSWITCH crashed?')
-    end
-
-    it "raises exception if IO is disconnected while reading event header" do
-      @io.should_receive(:gets).and_return(event_parts(EVENT)[0], nil)
-      lambda { @freec.send(:read_response) }.should raise_error(RuntimeError, 'IO disconnected - FreeSWITCH crashed?')
-    end
-    
-    it "reads the full event with body" do
-      @io.should_receive(:gets).and_return(event_parts(EVENT_WITH_BODY)[0], 
-                                          event_parts(EVENT_WITH_BODY)[1])
-      @io.should_receive(:read).and_return(event_parts(EVENT_WITH_BODY)[2].strip.chomp)
-      @freec.send(:read_response)
-    end
-    
-    it "raises exception if IO is disconnected while reading body" do
-      @io.should_receive(:gets).and_return(event_parts(EVENT_WITH_BODY)[0], 
-                                          event_parts(EVENT_WITH_BODY)[1])
-      @io.should_receive(:read).and_return(nil)
-      lambda { @freec.send(:read_response) }.should raise_error(RuntimeError, 'IO disconnected - FreeSWITCH crashed?')
-    end
-  
-  end
-  
-  
-  describe "event recognition" do
-
-    it "ignores events for another channel" do
-      @freec.should_receive(:read_response).twice
-      @freec.should_receive(:parse_response).and_return(false, true)
-      @freec.send(:read_and_parse_response)
-    end
-  
-    it "should subscribe to events of other leg channel after bridge" do
-      bridge_event = EVENT.sub('CHANNEL_EXECUTE', 'CHANNEL_BRIDGE').sub('Caller-Profile-Index: 1', 'Other-Leg-Unique-ID: 6c75cb42-e72d-48bf-9ecf-d71bd4b60617')
-      @freec.instance_variable_set(:@response, bridge_event)
-      @freec.send(:parse_response)
-      @freec.should_receive(:send_and_read).with("filter Unique-ID 6c75cb42-e72d-48bf-9ecf-d71bd4b60617")
-      @freec.send(:subscribe_to_new_channel_events)
-      @freec.instance_variable_get(:@want_events_from).should == ["f3c2d5ee-d064-4f55-9280-5be2a65867e8", "6c75cb42-e72d-48bf-9ecf-d71bd4b60617"]
-    end
-    
-    it "should recognize last event was DTMF to call the on_dtmf callback" do
-      dtmf_event = EVENT.sub('CHANNEL_EXECUTE', 'DTMF')
-      @freec.instance_variable_set(:@response, dtmf_event)
-      @freec.send(:parse_response)
-      @freec.send(:last_event_dtmf?).should be_true
-    end
-      
-    it "should recognize an event as a non-DTMF one" do
-      @freec.instance_variable_set(:@response, EVENT)
-      @freec.send(:parse_response)
-      @freec.send(:last_event_dtmf?).should be_false
-    end
-      
-    it "should recognize that app execution has been completed for the last run app" do
-      @freec.instance_variable_set(:@last_app_executed, 'set')
-      set_executed_event = EVENT.sub('CHANNEL_EXECUTE', 'CHANNEL_EXECUTE_COMPLETE')
-      @freec.instance_variable_set(:@response, set_executed_event)
-      @freec.send(:parse_response)      
-    
-      @freec.send(:execute_completed?).should be_true
-      @freec.instance_variable_get(:@last_app_executed).should be_nil
-    end
-      
-    it "should recognize that app execution has been completed but not for the last run one" do
-      @freec.instance_variable_set(:@last_app_executed, 'different')
-      set_executed_event = EVENT.sub('CHANNEL_EXECUTE', 'CHANNEL_EXECUTE_COMPLETE')
-      @freec.instance_variable_set(:@response, set_executed_event)
-      @freec.send(:parse_response)      
-    
-      @freec.send(:execute_completed?).should be_false
-      @freec.instance_variable_get(:@last_app_executed).should == 'different'
-    end
-      
-    it "should hangup the call, send exit command to Freeswitch and disconnect from it when step callback returns nil" do
-      @freec.should_receive(:send_data).with("connect")
-      @freec.should_receive(:send_data).with("events plain all")      
-      @freec.should_receive(:send_data).with('filter Unique-ID f3c2d5ee-d064-4f55-9280-5be2a65867e8')
-      @freec.should_receive(:send_data).with('divert_events on')
-      
-      @io.should_receive(:gets).and_return(initial_response, initial_response, initial_response, initial_response, "bye\n\n")
-      @io.should_receive(:closed?).twice.and_return(false)
-      @freec.should_receive(:step).and_return(nil)
-      @freec.should_receive(:execute_app).with('hangup')
-      @freec.should_receive(:on_hangup)
-      @freec.should_receive(:send_data).with("exit")      
-      @freec.handle_call
-    end
-    
-    it "should exit when Freeswitch disconnects (e.g. caller hangs up) and neither call the step callback nor send any other data to Freeswitch" do
-      disconnect_event = EVENT.sub('text/event-plain', 'text/disconnect-notice')
-      @freec.should_receive(:send_data).with("connect")
-      @freec.should_receive(:send_data).with("events plain all")      
-      @freec.should_receive(:send_data).with('filter Unique-ID f3c2d5ee-d064-4f55-9280-5be2a65867e8')
-      @freec.should_receive(:send_data).with('divert_events on')
-      @io.should_receive(:gets).and_return(initial_response, initial_response, event_parts(disconnect_event)[0], event_parts(disconnect_event)[1])
-      @io.should_receive(:closed?).twice.and_return(true)
-      @freec.should_receive(:step).never
-      @freec.should_receive(:on_hangup)
-      @freec.should_receive(:execute_app).never      
-      @freec.should_receive(:send_data).never
-      @freec.handle_call
-    end
-      
-  end
-  
-  describe "callback exception handling" do  
-    it "should catch and log any exception occurred in a callback" do
-      @freec.should_receive(:callback_name).and_raise(RuntimeError)
-      @freec.log.should_receive(:error).with('RuntimeError')
-      @freec.log.should_receive(:error).at_least(1).times #backtrace
-      lambda { @freec.send(:callback, :callback_name) }.should_not raise_error(Exception)
-    end  
-  end
-  
-  describe "custom waiting conditions" do
-    
-    # it "should return true from waiting_for_this_response? when the conditions for the response are met" do
-    #   @freec.wait_for(:content_type, 'command/reply')
-    #   @freec.instance_variable_set(:@response, EVENT)
-    #   @freec.send(:parse_response)
-    #   @freec.send(:waiting_for_this_response?).should be_true
-    # end
-    #   
-    # it "should return false from waiting_for_this_response? when the conditions for the response are not met" do
-    #   @freec.wait_for(:content_type, 'text/event-plain')
-    #   @freec.instance_variable_set(:@response, EVENT)
-    #   @freec.send(:parse_response)
-    #   @freec.send(:waiting_for_this_response?).should be_false
-    # end
-    #   
-    # it "should reset the waiting conditions after they have been met" do      
-    #   @freec.wait_for(:content_type, 'command/reply')
-    #   @freec.should_receive(:send_data).with("connect")
-    #   @freec.should_receive(:send_data).with("myevents")      
-    #   @io.should_receive(:gets).and_return(EVENT, EVENT, "bye\n\n")
-    #   @freec.instance_variable_set(:@last_app_executed, 'set')
-    #   @freec.should_receive(:step).and_return(nil)
-    #   @freec.should_receive(:execute_app).with('hangup')
-    #   @freec.should_receive(:on_hangup)
-    #   @freec.should_receive(:send_data).with("exit")      
-    #   @freec.handle_call
-    #   @freec.send(:waiting_for_this_response?).should be_nil
-    # end
-    #   
-  end
-
-end

data/spec/freeswitch_applications_spec.rb

@@ -1,128 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-module FreeswitchApplicationsSpecHelper
-  def freeswitch_command(app, pars = nil)    
-    cmd = "sendmsg "
-    cmd += "\ncall-command: execute"
-    cmd += "\nexecute-app-name: #{app}"
-    cmd += "\nexecute-app-arg: #{pars}" unless pars.blank?
-    cmd += "\nevent-lock:true"
-    cmd
-  end
-end
-
-describe Freec do
-
-  before do
-    io = stub(:io)
-    log = FreecLogger.new(STDOUT)
-    log.level = Logger::FATAL
-    @freec = Freec.new(io, log, {})
-  end
-
-  describe "executes Freeswitch applications" do
-    include FreeswitchApplicationsSpecHelper
-
-    it "should set the last_app_executed variable to last run app" do
-      @freec.should_receive(:send_data).with(freeswitch_command('answer'))
-      @freec.answer
-      @freec.instance_variable_get(:@last_app_executed).should == 'answer'
-    end
-
-    it "should execute the answer app when called the answer method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('answer'))
-      @freec.answer
-    end
-  
-    it "should execute the playback app when called the playback method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('playback', 'sounds/file.wav'))
-      @freec.playback('sounds/file.wav')
-    end
-
-    it "should execute the phrase app with spell option when called the spell method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('phrase', 'spell,abcd'))
-      @freec.spell('abcd')
-    end
-
-    it "should execute the speak app when called the speak method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('speak', 'hello'))
-      @freec.speak('hello')
-    end
-
-    it "should execute the bridge app when called the bridge method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('bridge', 'user/brian@10.0.1.2'))
-      @freec.bridge('user/brian@10.0.1.2')
-    end
-
-    it "should execute the transfer app when called the transfer method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('transfer', '1000'))
-      @freec.transfer('1000')
-    end
-
-    it "should pass all numbers passed to the bridge method as params of the bridge separated by comma (thus numbers are called simultaneously)" do
-      @freec.should_receive(:send_data).with(freeswitch_command('bridge', 'user/brian@10.0.1.2,user/karl@10.0.1.2'))
-      @freec.bridge(['user/brian@10.0.1.2', 'user/karl@10.0.1.2'])
-    end
-
-    it "should execute the record app when called the record method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('record', 'recordings/file.mp3 600'))
-      @freec.record('recordings/file.mp3')
-    end
-
-    it "should set the time_limit_secs option send to the record method as the max length of the recording" do
-      @freec.should_receive(:send_data).with(freeswitch_command('record', 'recordings/file.mp3 120'))
-      @freec.record('recordings/file.mp3', :time_limit_secs => 120)
-    end
-
-    it "should execute the read app when called the input method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('read', '1 1 sounds/file.mp3 input 10000 #'))
-      @freec.read('sounds/file.mp3')
-    end
-
-    it "should allow to pass the minimum and maximum digits to be read" do
-      @freec.should_receive(:send_data).with(freeswitch_command('read', '2 5 sounds/file.mp3 input 10000 #'))
-      @freec.read('sounds/file.mp3', :min => 2, :max => 5)
-    end
-
-    it "should allow to pass the timeout in seconds before the read apps before it times out" do
-      @freec.should_receive(:send_data).with(freeswitch_command('read', '1 1 sounds/file.mp3 input 5000 #'))
-      @freec.read('sounds/file.mp3', :timeout => 5)
-    end
-
-    it "should allow to pass the terminator for the read app" do
-      @freec.should_receive(:send_data).with(freeswitch_command('read', '1 1 sounds/file.mp3 input 10000 *'))
-      @freec.read('sounds/file.mp3', :terminators => '*')
-    end
-
-    it "should allow to pass the terminators as an array for the read app" do
-      @freec.should_receive(:send_data).with(freeswitch_command('read', '1 1 sounds/file.mp3 input 10000 #,*'))
-      @freec.read('sounds/file.mp3', :terminators => ['#', '*'])
-    end
-
-    it "should allow to specify the variable name the input is read by the read app" do
-      @freec.should_receive(:send_data).with(freeswitch_command('read', '1 1 sounds/file.mp3 name 10000 #'))
-      @freec.read('sounds/file.mp3', :variable => 'name')
-    end
-
-    it "should execute the record_session app when called the start_recording method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('record_session', 'file.wav'))
-      @freec.start_recording('file.wav')
-    end
-
-    it "should execute the stop_record_session app when called the start_recording method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('stop_record_session', 'file.wav'))
-      @freec.stop_recording('file.wav')
-    end
-  
-    it "should call the set app to set a variable" do
-      @freec.should_receive(:send_data).with(freeswitch_command('set', 'name=value'))
-      @freec.set_variable('name', 'value')
-    end
-  
-    it "should call the hangup app when caled the hangup method" do
-      @freec.should_receive(:send_data).with(freeswitch_command('hangup'))
-      @freec.hangup
-    end
-    
-  end
-end

data/spec/spec_helper.rb

@@ -1,12 +0,0 @@
-require 'rubygems'
-require 'rspec'
-
-$:.unshift(File.join(File.dirname(__FILE__), "..", 'lib')).unshift(File.dirname(__FILE__)).
-  unshift(File.join(File.dirname(__FILE__), 'data'))
-ROOT = File.join(File.dirname(__FILE__), '..') unless defined?(ROOT)
-@@config = ''
-ENVIRONMENT = 'test' unless defined?(ENVIRONMENT)
-TEST = true unless defined?(TEST)
-require 'freec'
-require 'event'
-require 'event_with_body'