sevenscale-adhearsion 0.7.1003 → 0.8.0

data/spec/voip/asterisk/menu_command/test_calculated_match.rb

@@ -1,111 +0,0 @@
-require File.join(File.dirname(__FILE__), *%w[.. .. .. test_helper])
-require 'adhearsion/voip/menu_state_machine/calculated_match'
-
-context 'CalculatedMatch' do
-  test "should make accessible the context name" do
-    Adhearsion::VoIP::CalculatedMatch.new(:match_payload => :foobar).match_payload.should.equal :foobar
-  end
-  test "should make accessible the original pattern" do
-    Adhearsion::VoIP::CalculatedMatch.new(:pattern => :something).pattern.should.equal :something
-  end
-  test "should make accessible the matched query" do
-    Adhearsion::VoIP::CalculatedMatch.new(:query => 123).query.should.equal 123
-  end
-  test '#type_of_match should return :exact, :potential, or nil' do
-    Adhearsion::VoIP::CalculatedMatch.new(:potential_matches => [1]).type_of_match.should.equal :potential
-    Adhearsion::VoIP::CalculatedMatch.new(:exact_matches => [3,3]).type_of_match.should.equal :exact
-    Adhearsion::VoIP::CalculatedMatch.new(:exact_matches => [8,3], :potential_matches => [0,9]).type_of_match.should.equal :exact
-    Adhearsion::VoIP::CalculatedMatch.new.type_of_match.should.equal nil
-  end
-  test '#exact_match? should return true if the match was exact' do
-    Adhearsion::VoIP::CalculatedMatch.new(:exact_matches => [0,3,5]).should.be.exact_match
-  end
-  
-  test '#potential_match? should return true if the match was exact' do
-    Adhearsion::VoIP::CalculatedMatch.new(:potential_matches => [88,99,77]).should.be.potential_match
-  end
-  
-  test '#exact_matches should return an array of exact matches' do
-    Adhearsion::VoIP::CalculatedMatch.new(:exact_matches => [0,3,5]).exact_matches.should == [0,3,5]
-  end
-  
-  test '#potential_matches should return an array of potential matches' do
-    Adhearsion::VoIP::CalculatedMatch.new(:potential_matches => [88,99,77]).potential_matches.should == [88,99,77]
-  end
-  
-  test '::failed_match! should return a match that *really* failed' do
-    failure = Adhearsion::VoIP::CalculatedMatch.failed_match! 10..20, 30, :match_payload_does_not_matter
-    failure.should.not.be.exact_match
-    failure.should.not.be.potential_match
-    failure.type_of_match.should.be nil
-    
-    failure.match_payload.should.equal :match_payload_does_not_matter
-    failure.pattern.should == (10..20)
-    failure.query.should == 30
-  end
-  
-end
-
-context 'CalculatedMatchCollection' do
-  
-  include CalculatedMatchCollectionTestHelper
-  
-  attr_reader :collection
-  before:each do
-    @collection = Adhearsion::VoIP::CalculatedMatchCollection.new
-  end
-  
-  test 'the <<() method should collect the potential matches into the actual_potential_matches Array' do
-    mock_matches_array_1 = [:foo, :bar, :qaz], 
-    mock_matches_array_2 = [10,20,30]
-    mock_matches_1 = mock_with_potential_matches mock_matches_array_1
-    mock_matches_2 = mock_with_potential_matches mock_matches_array_2
-    
-    collection << mock_matches_1
-    collection.actual_potential_matches.should == mock_matches_array_1
-    
-    collection << mock_matches_2
-    collection.actual_potential_matches.should == mock_matches_array_1 + mock_matches_array_2
-  end
-  
-  test 'the <<() method should collect the exact matches into the actual_exact_matches Array' do
-    mock_matches_array_1 = [:blam, :blargh], 
-    mock_matches_array_2 = [5,4,3,2,1]
-    mock_matches_1 = mock_with_exact_matches mock_matches_array_1
-    mock_matches_2 = mock_with_exact_matches mock_matches_array_2
-    
-    collection << mock_matches_1
-    collection.actual_exact_matches.should == mock_matches_array_1
-    
-    collection << mock_matches_2
-    collection.actual_exact_matches.should == mock_matches_array_1 + mock_matches_array_2
-  end
-  
-  test "if any exact matches exist, the exact_match?() method should return true" do
-    collection << mock_with_exact_matches([1,2,3])
-    collection.should.be.exact_match
-  end
-  
-  test "if any potential matches exist, the potential_match?() method should return true" do
-    collection << mock_with_potential_matches([1,2,3])
-    collection.should.be.potential_match
-  end
-end
-
-BEGIN {
-module CalculatedMatchCollectionTestHelper
-  def mock_with_potential_matches(potential_matches)
-    Adhearsion::VoIP::CalculatedMatch.new :potential_matches => potential_matches
-  end
-  
-  def mock_with_exact_matches(exact_matches)
-    Adhearsion::VoIP::CalculatedMatch.new :exact_matches => exact_matches
-  end
-  
-  def mock_with_potential_and_exact_matches(potential_matches, exact_matches)
-    Adhearsion::VoIP::CalculatedMatch.new :potential_matches => potential_matches, 
-                        :exact_matches => exact_matches
-  end
-  
-end
-}

data/spec/voip/asterisk/menu_command/test_matchers.rb

@@ -1,98 +0,0 @@
-require File.join(File.dirname(__FILE__), *%w[.. .. .. test_helper])
-require 'adhearsion/voip/menu_state_machine/menu_builder'
-require 'adhearsion/voip/menu_state_machine/matchers'
-
-context "MatchCalculator" do
-  test "the build_with_pattern() method should return an appropriate subclass instance based on the pattern's class" do
-    Adhearsion::VoIP::MatchCalculator.build_with_pattern(1..2, :main).should.be.instance_of Adhearsion::VoIP::RangeMatchCalculator
-  end
-  
-end
-
-context "The RangeMatchCalculator" do
-  
-  test "matching with a Range should handle the case of two potential matches in the range" do
-    digits_that_begin_with_eleven = [110..119, 1100..1111].map { |x| Array(x) }.flatten
-    
-    calculator = Adhearsion::VoIP::RangeMatchCalculator.new 11..1111, :match_payload_doesnt_matter
-    match = calculator.match 11
-    match.exact_matches.should == [11]
-    match.potential_matches.should == digits_that_begin_with_eleven
-  end
-  
-  test 'return values of #match should be an instance of CalculatedMatch' do
-    calculator = Adhearsion::VoIP::RangeMatchCalculator.new 1..9, :match_payload_doesnt_matter
-    calculator.match(0).should.be.instance_of Adhearsion::VoIP::CalculatedMatch
-    calculator.match(1000).should.be.instance_of Adhearsion::VoIP::CalculatedMatch
-  end
-  
-end
-
-context "FixnumMatchCalculator" do
-  attr_reader :match_payload
-  before:each do
-    @match_payload = :main
-  end
-
-  test "a potential match scenario" do
-    calculator = Adhearsion::VoIP::FixnumMatchCalculator.new(444, match_payload)
-    match = calculator.match 4
-    match.should.be.potential_match
-    match.should.not.be.exact_match
-    match.potential_matches.should == [444]
-  end
-  
-  test 'a multi-digit exact match scenario' do
-    calculator = Adhearsion::VoIP::FixnumMatchCalculator.new(5555, match_payload)
-    calculator.match(5555).should.be.exact_match
-  end
-  
-  test 'a single-digit exact match scenario' do
-    calculator = Adhearsion::VoIP::FixnumMatchCalculator.new(1, match_payload)
-    calculator.match(1).should.be.exact_match
-  end
-  
-  test 'the context name given to the calculator should be passed on to the CalculatedMatch' do
-    match_payload = :icanhascheezburger
-    calculator = Adhearsion::VoIP::FixnumMatchCalculator.new(1337, match_payload)
-    calculator.match(1337).match_payload.should.equal match_payload
-  end
-  
-end
-
-context "StringMatchCalculator" do
-  
-  attr_reader :match_payload
-  before:each do
-    @match_payload = :doesnt_matter
-  end
-  
-  test "numerical digits mixed with special digits" do
-    
-    %w[5*11#3 5*** ###].each do |str|
-      calculator = Adhearsion::VoIP::StringMatchCalculator.new(str, match_payload)
-      
-      match_case = calculator.match str[0,2]
-
-      match_case.should.not.be.exact_match
-      match_case.should.be.potential_match
-      match_case.potential_matches.should == [str]
-      
-      match_case = calculator.match str
-      match_case.should.be.exact_match
-      match_case.should.not.be.potential_match
-      match_case.exact_matches.should == [str]
-    end
-  end
-  
-  test "matching the special DTMF characters such as * and #" do
-    %w[* #].each do |special_digit|
-      calculator = Adhearsion::VoIP::StringMatchCalculator.new(special_digit, match_payload)
-      match_case = calculator.match special_digit
-      match_case.should.not.be.potential_match
-      match_case.should.be.exact_match
-      match_case.exact_matches.first.should == special_digit
-    end
-  end
-  
-end

data/spec/voip/asterisk/mock_ami_server.rb

@@ -1,176 +0,0 @@
-class AmiServer
-  class AMIResponseHelper
-    class << self
-      def bad_login_response
-        { "Response" => "Error", "Message" => "Authentication failed" }
-      end
-
-      def good_login_response
-        { "Response" => "Success", "Message" => "Authentication accepted" }
-      end
-      
-      def follows_response
-        { "Response" => "Follows", "Privilege" => "Command" }
-      end
-
-      def bad_dbget_response
-        { "Response" => "Error", "Message" => "Database entry not found" }
-      end
-
-      def good_dbget_response
-        { "Response" => "Success", "Message" => "Result will follow" }
-      end
-
-      def dbput_response
-        { "Response" => "Success", "Message" => "Updated database successfully" }
-      end
-      
-      def dbget_event_response
-        { "Event" => "DBGetResponse" }
-      end
-      
-      def queue_status_response
-        { "Response" => "Success", "Message" => "Queue status will follow" }
-      end
-
-      def queue_status_event_complete_response
-        { "Event" => "QueueStatusComplete" }
-      end
-
-      def queue_status_event_params_response
-        { "Event" => "QueueParams", "Queue" => "default", "Max" => 0, "Min" => 0, "Holdtime" => 0,
-          "Completed" => 0, "Abandoned" => 0, "ServiceLevel" => 0, "ServiceLevelPerf" => 0 }
-      end
-
-      def events_on_response
-        { "Response" => "Events On" }
-      end
-
-      def events_off_response
-        { "Response" => "Events Off" }
-      end
-      
-      def ping_response
-        { "Response" => "Pong" }
-      end
-      
-      def unrecognized_action
-        { "Response" => "Error", "Message" => "Invalid/unknown command" }
-      end
-    end
-  end
-
-  def initialize(*args)
-    @closed = false
-    @buffer = ""
-    @db = {}
-    extend MonitorMixin
-    fill(prompt, 1)
-  end
-
-  def closed?
-    @closed
-  end
-  
-  def close
-    @closed = true
-  end
-
-  def read_nonblock(count)
-    str = @buffer.slice!(0..count-1)
-    raise Errno::EAGAIN if str == ""
-    str
-  end
-  
-  def gets
-    @buffer.slice!(0..-1)
-  end
-
-  def write(str)
-    raise ArgumentError, "malformed request" if not str.ends_with?("\r\n\r\n")
-    args = str.split("\r\n").inject({}) { |accum, str| accum.merge!(YAML.load(str)) }
-    actionid = args['actionid']
-    case args['action']
-      when "login"
-        if args['username'] == username and args['secret'] == password
-          fill(response(actionid, AMIResponseHelper.good_login_response))
-        else
-          fill(response(actionid, AMIResponseHelper.bad_login_response))
-        end
-      when "queues"
-        fill("No Members\nNo Callers\r\n")
-      when "command"
-        case args['command']
-        when "show channels"
-          fill(response(actionid, AMIResponseHelper.follows_response), 1)
-          fill("Channel (Context Extension Pri ) State Appl. Data\n0 active channel(s)\n--END COMMAND--")
-        when "meetme list"
-          fill(response(actionid, AMIResponseHelper.follows_response), 1)
-          str = []
-          str << "Usage: meetme (un)lock|(un)mute|kick|list [concise] "
-          str << " Executes a command for the conference or on a conferee"
-          str << "--END COMMAND--"
-          fill(str.join("\n"))
-        else
-          fill(response(actionid, AMIResponseHelper.follows_response), 1)
-          fill("No such command '#{args['command']}' (type 'help' for help)\n--END COMMAND--")
-        end
-      when "dbget"
-        if not @db.has_key?(args['family']) or not @db[args['family']].has_key?(args['key'])
-          fill(response(actionid, AMIResponseHelper.bad_dbget_response))
-        else
-          val = @db[args['family']][args['key']]
-          fill(response(actionid, AMIResponseHelper.good_dbget_response))
-          fill(response(actionid, {
-            :Family => args['family'],
-            :Key    => args['key'],
-            :Val    => val }.merge!(AMIResponseHelper.dbget_event_response)))
-        end
-      when "dbput"
-        @db[args['family']] ||= {}
-        @db[args['family']][args['key']] = args['val']
-        fill(response(actionid, AMIResponseHelper.dbput_response))
-      when "queuestatus"
-        fill(response(actionid, AMIResponseHelper.queue_status_response))
-        fill(response(actionid, AMIResponseHelper.queue_status_event_params_response))
-        fill(response(actionid, AMIResponseHelper.queue_status_event_complete_response))
-      when "events"
-        if args['eventmask'] !~ /^on$/i
-          if args['eventmask'] =~ /^off$/i
-            fill(response(actionid, AMIResponseHelper.events_off_response))
-          else
-            fill(response(actionid, AMIResponseHelper.events_on_response))
-          end
-        end
-      when "ping"
-        fill(response(actionid, AMIResponseHelper.ping_response))
-      else
-        # raise ArgumentError, "Unknown action #{args['action']}"
-        fill(response(actionid, AMIResponseHelper.unrecognized_action))
-      end
-  end
-
-  private
-  
-  def response(action_id, args = {})
-    resp = []
-    resp << "Response: #{args.delete('Response')}" if args['Response']
-    resp << "Privilege: #{args.delete('Privilege')}" if args['Privilege']
-    resp << "Event: #{args.delete('Event')}" if args['Event']
-    resp << "ActionID: #{action_id}"
-    resp << "Message: #{args.delete('Message')}" if args['Message']
-    args.inject(resp) do |accum, pair|
-      accum << "#{pair[0]}: #{pair[1]}"
-    end
-    resp.join("\r\n")
-  end
-  
-  def fill(line, blanks=2)
-    @buffer += line
-    @buffer += "\r\n" * blanks
-  end
-  
-  def prompt;   "Asterisk Call Manager/1.0" end
-  def username; "admin"                     end
-  def password; "password"                  end
-end