sevenscale-adhearsion 0.7.1000

data/spec/voip/asterisk/config_file_generators/test_voicemail.rb

@@ -0,0 +1,306 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. test_helper])
+require 'adhearsion/voip/asterisk/config_generators/voicemail.conf'
+
+context 'Basic requirements of the Voicemail config generator' do
+  attr_reader :config
+  before :each do
+    @config = Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail.new
+  end
+  
+  test 'should have a [general] context' do
+    config.to_sanitary_hash.has_key?('[general]').should.equal true
+  end
+  
+  test 'should set the format to "wav" by default in the general section' do
+    config.to_sanitary_hash['[general]'].should.include 'format=wav'
+  end
+  
+  test 'an exception should be raised if the context name is "general"' do
+    the_following_code {
+      config.context(:general) {|_|}
+    }.should.raise ArgumentError
+  end
+  
+end
+
+context 'Defining recording-related settings of the Voicemail config file' do
+  
+  attr_reader :recordings
+  before :each do
+    @recordings = Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail::RecordingDefinition.new
+  end
+  
+  test 'the recordings setting setter' do
+    Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail.new.recordings.should.be.kind_of? recordings.class
+  end
+  
+  test 'recordings format should only allow a few options' do
+    the_following_code {
+      recordings.format :wav 
+      recordings.format :wav49
+      recordings.format :gsm
+    }.should.not.raise
+    
+    the_following_code {
+      recordings.format :lolcats
+    }.should.raise ArgumentError
+  end
+  
+end
+
+context 'Defining email-related Voicemail settings' do
+  
+  attr_reader :email
+  before :each do
+    @email = Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail::EmailDefinition.new
+  end
+  
+  test 'the [] operator is overloaded to return conveniences for the body() and subject() methods' do
+    variables = %{#{email[:name]} #{email[:mailbox]} #{email[:date]} #{email[:duration]} } + 
+                %{#{email[:message_number]} #{email[:caller_id]} #{email[:caller_id_number]} } +
+                %{#{email[:caller_id_name]}}
+    formatted = %{${VM_NAME} ${VM_MAILBOX} ${VM_DATE} ${VM_DUR} ${VM_MSGNUM} ${VM_CALLERID} ${VM_CIDNUM} ${VM_CIDNAME}}      
+    email.body variables
+    email.subject variables
+    email.properties[:emailbody].should == formatted
+    email.properties[:emailsubject].should == formatted
+  end
+  
+  test 'when defining a body, newlines should be escaped and carriage returns removed' do
+    unescaped, escaped = "one\ntwo\n\r\r\nthree\n\n\n", 'one\ntwo\n\nthree\n\n\n'
+    email.body unescaped
+    email.properties[:emailbody].should == escaped
+  end
+  
+  test 'the body must not be allowed to exceed 512 characters' do
+    the_following_code {
+      email.body "X" * 512
+    }.should.not.raise ArgumentError
+    
+    the_following_code {
+      email.body "X" * 513
+    }.should.raise ArgumentError
+    
+    the_following_code {
+      email.body "X" * 1000
+    }.should.raise ArgumentError
+  end
+  
+  test 'should store away the email command properly' do
+    mail_command = "/usr/sbin/sendmail -f alice@wonderland.com -t"
+    email.command mail_command
+    email.properties[:mailcmd].should == mail_command
+  end
+  
+end
+
+context 'A mailbox definition' do
+  attr_reader :mailbox
+  before :each do
+    @mailbox = Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail::ContextDefinition::MailboxDefinition.new("123")
+  end
+  
+  test 'setting the name should be reflected in the to_hash form of the definition' do
+    mailbox.name "Foobar"
+    mailbox.to_hash[:name].should == "Foobar"
+  end
+  
+  test 'setting the pin_number should be reflected in the to_hash form of the definition' do
+    mailbox.pin_number 555
+    mailbox.to_hash[:pin_number].should.equal 555
+  end
+  
+  test 'the mailbox number should be available in the mailbox_number getter' do
+    Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail::ContextDefinition::MailboxDefinition.new '123'
+    mailbox.mailbox_number.should.equal '123'
+  end
+  
+  test 'an ArgumentError should be raised if the mailbox_number is not numeric' do
+    the_following_code {
+      Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail::ContextDefinition::MailboxDefinition.new("this is not numeric")
+    }.should.raise ArgumentError
+  end
+  
+  test 'an ArgumentError should be raised if the pin_number is not numeric' do
+    the_following_code {
+      mailbox.pin_number "this is not numeric"
+    }.should.raise ArgumentError
+  end
+  
+  test "the string representation should be valid" do
+    expected = "123 => 1337,Jay Phillips,ahn@adhearsion.com"
+    mailbox.pin_number 1337
+    mailbox.name "Jay Phillips"
+    mailbox.email "ahn@adhearsion.com"
+    mailbox.to_s.should == expected
+  end
+  
+  test 'should not add a trailing comma when the email is left out' do
+    mailbox.pin_number 1337
+    mailbox.name "Jay Phillips"
+    mailbox.to_s.ends_with?(',').should.equal false
+  end
+  
+  test 'should not add a trailing comma when the email and name is left out' do
+    mailbox.pin_number 1337
+    mailbox.to_s.ends_with?(',').should.equal false
+  end
+  
+end
+
+context "A Voicemail context definition" do
+  
+  test "should ultimately add a [] context definition to the string output" do
+    voicemail = Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail.new
+    voicemail.context "monkeys" do |config|
+      config.should.be.kind_of voicemail.class::ContextDefinition
+      config.mailbox 1234 do |mailbox|
+        mailbox.pin_number 3333
+        mailbox.email "alice@wonderland.com"
+        mailbox.name "Alice Little"
+      end
+    end
+    voicemail.to_sanitary_hash.has_key?('[monkeys]').should.equal true
+  end
+  
+  test 'should raise a LocalJumpError if no block is given' do
+    the_following_code {
+      Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail.new.context('lols')
+    }.should.raise LocalJumpError
+  end
+  
+  test 'its string representation should begin with a context declaration' do
+    vm = Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail.new
+    vm.context("jay") {|_|}.to_s.starts_with?("[jay]").should.equal true
+  end
+  
+end
+
+context 'Defining Voicemail contexts with mailbox definitions' do
+  
+end
+
+context 'An expansive example of the Voicemail config generator' do
+  
+  before :each do
+    @employees = [
+      {:name => "Tango",  :pin_number => 7777, :mailbox_number => 10},
+      {:name => "Echo",   :pin_number => 7777, :mailbox_number => 20},
+      {:name => "Sierra", :pin_number => 7777, :mailbox_number => 30},
+      {:name => "Tango2", :pin_number => 7777, :mailbox_number => 40}
+    ].map { |hash| OpenStruct.new(hash) }
+    
+    @groups = [
+      {:name => "Brand New Cadillac", :pin_number => 1111, :mailbox_number => 1},
+      {:name => "Jimmy Jazz",         :pin_number => 2222, :mailbox_number => 2},
+      {:name => "Death or Glory",     :pin_number => 3333, :mailbox_number => 3},
+      {:name => "Rudie Can't Fail",   :pin_number => 4444, :mailbox_number => 4},
+      {:name => "Spanish Bombs",      :pin_number => 5555, :mailbox_number => 5}
+    ].map { |hash| OpenStruct.new(hash) }
+  end
+  
+  test 'a huge, brittle integration test' do
+    vm = Adhearsion::VoIP::Asterisk::ConfigFileGenerators::Voicemail.new do |voicemail|
+      voicemail.context :default do |context|
+        context.mailbox 123 do |mailbox|
+          mailbox.name "Administrator"
+          mailbox.email "jabberwocky@wonderland.com"
+          mailbox.pin_number 9876
+        end
+      end
+
+      voicemail.context :employees do |context|
+        @employees.each do |employee|
+          context.mailbox employee.mailbox_number do |mailbox|
+            mailbox.pin_number 1337
+            mailbox.name employee.name
+          end
+        end
+      end
+
+      voicemail.context :groups do |context|
+        @groups.each do |group|
+          context.mailbox group.mailbox_number do |mailbox|
+            mailbox.pin_number 1337
+            mailbox.name group.name
+            mailbox.email "foo@qaz.org"
+          end
+        end
+      end
+
+      voicemail.execute_on_pin_change "/path/to/my/changer_script.rb"
+      ############################################################################
+      ############################################################################
+
+      signature = "Your Friendly Phone System"
+
+      # execute_after_email "netcat 192.168.1.2 12345"
+      # greeting_maximum 1.minute
+      # time_jumped_with_skip_key 3.seconds # milliseconds!
+      # logging_in do |config|
+      #   config.maximum_attempts 3
+      # end
+
+      voicemail.recordings do |config|
+        config.format :wav # ONCE YOU PICK A FORMAT, NEVER CHANGE IT UNLESS YOU KNOW THE CONSEQUENCES!
+        config.allowed_length 3.seconds..5.minutes
+        config.maximum_silence 10.seconds
+        # config.silence_threshold 128 # wtf?
+      end
+
+      voicemail.emails do |config|
+        config.from :name => signature, :email => "noreply@adhearsion.com"
+        config.attach_recordings true
+        config.command '/usr/sbin/sendmail -f alice@wonderland.com -t'
+        config.subject "New voicemail for #{config[:name]}"
+        config.body <<-BODY.unindent
+          Dear #{config[:name]}:
+          
+          The caller #{config[:caller_id]} left you a #{config[:duration]} long voicemail
+          (number #{config[:message_number]}) on #{config[:date]} in mailbox #{config[:mailbox]}.
+          
+          #{ "The recording is attached to this email.\n" if config.attach_recordings? }
+          - #{signature}
+        BODY
+      end
+    end
+    internalized = vm.to_sanitary_hash
+    internalized.size.should.equal 5 # general, zonemessages, default, employees, groups
+    
+    target_config = <<-CONFIG
+[general]
+attach=yes
+emailbody=Dear ${VM_NAME}:\\nThe caller ${VM_CALLERID} left you a ${VM_DUR} long voicemail\\n(number ${VM_MSGNUM}) on ${VM_DATE} in mailbox ${VM_MAILBOX}.\\nThe recording is attached to this email.\\n- Your Friendly Phone System\\n
+emailsubject=New voicemail for ${VM_NAME}
+externpass=/path/to/my/changer_script.rb
+format=wav
+fromstring=Your Friendly Phone System
+mailcmd=/usr/sbin/sendmail -f alice@wonderland.com -t
+serveremail=noreply@adhearsion.com
+
+[zonemessages]
+eastern=America/New_York|'vm-received' Q 'digits/at' IMp
+central=America/Chicago|'vm-received' Q 'digits/at' IMp
+central24=America/Chicago|'vm-received' q 'digits/at' H N 'hours'
+military=Zulu|'vm-received' q 'digits/at' H N 'hours' 'phonetic/z_p'
+european=Europe/Copenhagen|'vm-received' a d b 'digits/at' HM
+[default]
+123 => 9876,Administrator,jabberwocky@wonderland.com
+
+[employees]
+10 => 1337,Tango
+20 => 1337,Echo
+30 => 1337,Sierra
+40 => 1337,Tango2
+
+[groups]
+1 => 1337,Brand New Cadillac,foo@qaz.org
+2 => 1337,Jimmy Jazz,foo@qaz.org
+3 => 1337,Death or Glory,foo@qaz.org
+4 => 1337,Rudie Can't Fail,foo@qaz.org
+5 => 1337,Spanish Bombs,foo@qaz.org
+    CONFIG
+    vm.to_s.grep(/^$|^[^;]/).join.strip.should == target_config.strip
+    
+  end
+end

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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,176 @@
+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