adhearsion 1.0.1 → 1.0.2

data/spec/voip/asterisk/ami/lexer/ami_fixtures.yml

@@ -0,0 +1,30 @@
+:login:
+  :standard:
+    :client:
+      Action: Login
+      Username: :string
+      Secret: :string
+      Events: {one_of: ["on", "off"]}
+    :success:
+      Response: Success
+      Message: Authentication accepted
+    :fail:
+      Response: Error
+      Message: Authentication failed
+
+:errors:
+  :missing_action:
+    Response: Error
+    Message: Missing action in request
+
+:pong:
+  :with_action_id:
+    ActionID: 1287381.1238
+    Response: Pong
+  :without_action_id:
+    Response: Pong
+  :with_extra_keys:
+    ActionID: 1287381.1238
+    Response: Pong
+    Blah: This is something arbitrary
+    Blahhh: something else arbitrary

data/spec/voip/asterisk/ami/lexer/lexer_story

@@ -0,0 +1,291 @@
+Story: Lexing AMI
+
+	As an Adhearsion user
+	I want to lex the AMI protocol
+	So that I can control Asterisk asynchronously
+
+	UNCERTAINTIES:
+	- Are there any pairs with non-unique keys? Could Hash be blowing stuff away?
+
+	WHEN DOING INTEGRATION TESTS:
+	- Try sending it an originate with a bad priority, a timeout of -1... and other improper stuff.
+
+	Scenario: Lexing only the initial AMI version header
+
+		Given a new lexer
+		And a version header for AMI 1.0
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And the version should be set to 1.0
+
+	Scenario: Lexing the initial AMI header and a login attempt
+
+		Given a new lexer
+		And a version header for AMI 1.0
+		And a normal login success with events
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 1 message should have been received
+
+	Scenario: Lexing the initial AMI header and then a Response:Follows section
+
+		Given a new lexer
+		And a version header for AMI 1.0
+		And a multi-line Response:Follows body of ragel_description
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And the 'follows' body of 1 message received should equal ragel_description
+
+	Scenario: Lexing a Response:Follows section with no body
+
+		Given a new lexer
+		And a version header for AMI 1.0
+		And a multi-line Response:Follows body of empty_String
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And the 'follows' body of 1 message received should equal empty_string
+
+	Scenario: Lexing a multi-line Response:Follows simulating the "core show channels" command
+
+		Given a new lexer
+		And a version header for AMI 1.0
+		Given a multi-line Response:Follows body of show_channels_from_wayne
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And the 'follows' body of 1 message received should equal show_channels_from_wayne
+
+	Scenario: Lexing a multi-line Response:Follows simulating the "core show uptime" command
+
+		Given a new lexer
+		And a version header for AMI 1.0
+		Given a multi-line Response:Follows response simulating uptime
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And the first message received should have the key "System uptime" with value "46 minutes, 30 seconds"
+
+
+	Scenario: Lexing a Response:Follows section which has a colon not on the first line
+
+		Given a new lexer
+		And a multi-line Response:Follows body of with_colon_after_first_line
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 1 message should have been received
+		And the 'follows' body of 1 message received should equal with_colon_after_first_line
+
+	Scenario: Lexing an immediate response with a colon in it.
+
+		Given a new lexer
+		And an immediate response with text "markq        has 0 calls (max unlimited) in 'ringall' strategy (0s holdtime), W:0, C:0, A:0, SL:0.0% within 0s\r\n   No Members\r\n   No Callers\r\n\r\n\r\n\r\n"
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 1 message should have been received
+		And 1 message should be an immediate response with text "markq        has 0 calls (max unlimited) in 'ringall' strategy (0s holdtime), W:0, C:0, A:0, SL:0.0% within 0s\r\n   No Members\r\n   No Callers"
+
+	Scenario: Lexing the initial AMI header and then an "Authentication Required" error.
+
+		Given a new lexer
+		And a version header for AMI 1.0
+		And an Authentication Required error
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+
+	Scenario: Lexing the initial AMI header and then a Response:Follows section
+
+		Given a new lexer
+		And a version header for AMI 1.0
+		And a multi-line Response:Follows body of ragel_description
+		And a multi-line Response:Follows body of ragel_description
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And the 'follows' body of 2 messages received should equal ragel_description
+
+	Scenario: Lexing a stanza without receiving an AMI header
+
+		Given a new lexer
+		And a normal login success with events
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 1 message should have been received
+
+	Scenario: Receiving an immediate response as soon as the socket is opened
+
+		Given a new lexer
+		And an immediate response with text "Immediate responses are so ridiculous"
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed with no syntax errors
+		And 1 message should have been received
+		And 1 message should be an immediate response with text "Immediate responses are so ridiculous"
+
+	Scenario: Receiving an immediate message surrounded by real messages
+
+		Given a new lexer
+		And a normal login success with events
+		And an immediate response with text "No queues have been created."
+		And a normal login success with events
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 3 messages should have been received
+		And 1 message should be an immediate response with text "No queues have been created."
+
+	Scenario: Receiving a Pong after a simulated login
+
+		Given a new lexer
+		And a version header for AMI 1.0
+		And a normal login success with events
+		And a Pong response with an ActionID of randomness
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 2 messages should have been received
+
+	Scenario: Ten Pong responses in a row
+
+		Given a new lexer
+		And 5 Pong responses without an ActionID
+		And 5 Pong responses with an ActionID of randomness
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 10 messages should have been received
+
+	Scenario: A Pong with an ActionID
+
+		Given a new lexer
+		And a Pong response with an ActionID of 1224469850.61673
+
+		When the buffer is lexed
+
+		Then the first message received should have a key "ActionID" with value "1224469850.61673"
+
+	Scenario: A response containing a floating point value
+
+		Given a new lexer
+		And a custom stanza named "call"
+		And the custom stanza named "call" has key "ActionID" with value "1224469850.61673"
+		And the custom stanza named "call" has key "Uniqueid" with value "1173223225.10309"
+
+		When the custom stanza named "call" is added to the buffer
+		And the buffer is lexed
+
+		Then the 1st message received should have a key "Uniqueid" with value "1173223225.10309"
+
+	Scenario: Receiving a message with custom key/value pairs
+
+		Given a new lexer
+		And a custom stanza named "person"
+		And the custom stanza named "person" has key "ActionID" with value "1224469850.61673"
+		And the custom stanza named "person" has key "Name" with value "Jay Phillips"
+		And the custom stanza named "person" has key "Age" with value "21"
+		And the custom stanza named "person" has key "Location" with value "San Francisco, CA"
+		And the custom stanza named "person" has key "x-header" with value "<FooBAR>"
+		And the custom stanza named "person" has key "Channel" with value "IAX2/127.0.0.1/4569-9904"
+		And the custom stanza named "person" has key "I have spaces" with value "i have trailing padding   "
+
+		When the custom stanza named "person" is added to the buffer
+		And the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And the first message received should have a key "Name" with value "Jay Phillips"
+		And the first message received should have a key "ActionID" with value "1224469850.61673"
+		And the first message received should have a key "Name" with value "Jay Phillips"
+		And the first message received should have a key "Age" with value "21"
+		And the first message received should have a key "Location" with value "San Francisco, CA"
+		And the first message received should have a key "x-header" with value "<FooBAR>"
+		And the first message received should have a key "Channel" with value "IAX2/127.0.0.1/4569-9904"
+		And the first message received should have a key "I have spaces" with value "i have trailing padding   "
+
+	Scenario: Executing a stanza that was partially received
+
+		Given a new lexer
+		And a normal login success with events split into two pieces
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 1 message should have been received
+
+	Scenario: Receiving an AMI error followed by a normal event
+
+		Given a new lexer
+		And an AMI error whose message is "Missing action in request"
+		And a normal login success with events
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 1 AMI error should have been received
+		And the 1st AMI error should have the message "Missing action in request"
+		And 1 message should have been received
+
+	Scenario: Lexing an immediate response
+
+		Given a new lexer
+		And a normal login success with events
+		And an immediate response with text "Yes, plain English is sent sometimes over AMI."
+		And a normal login success with events
+
+		When the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 3 messages should have been received
+		And 1 message should be an immediate response with text "Yes, plain English is sent sometimes over AMI."
+
+  Scenario: Lexing an AMI event
+
+		Given a new lexer
+		And a custom event with name "NewChannelEvent" identified by "this_event"
+		And a custom header for event identified by "this_event" whose key is "Foo" and value is "Bar"
+		And a custom header for event identified by "this_event" whose key is "Channel" and value is "IAX2/127.0.0.1:4569-9904"
+		And a custom header for event identified by "this_event" whose key is "AppData" and value is "agi://localhost"
+
+		When the custom event identified by "this_event" is added to the buffer
+		And the buffer is lexed
+
+		Then the protocol should have lexed without syntax errors
+		And 1 event should have been received
+		And the 1st event should have the name "NewChannelEvent"
+		And the 1st event should have key "Foo" with value "Bar"
+		And the 1st event should have key "Channel" with value "IAX2/127.0.0.1:4569-9904"
+		And the 1st event should have key "AppData" with value "agi://localhost"
+
+	Scenario: Lexing an immediate packet with a colon in it (syntax error)
+
+		Given a new lexer
+		And syntactically invalid immediate_packet_with_colon
+		And a stanza break
+
+		When the buffer is lexed
+
+		Then 0 messages should have been received
+		And the protocol should have lexed with 1 syntax error
+		And the syntax error fixture named immediate_packet_with_colon should have been encountered
+

data/spec/voip/asterisk/ami/lexer/lexer_story.rb

@@ -0,0 +1,241 @@
+require File.dirname(__FILE__) + "/story_helper"
+
+class IntrospectiveManagerStreamLexer < Adhearsion::VoIP::Asterisk::Manager::AbstractAsteriskManagerInterfaceStreamLexer
+
+  attr_reader :received_messages, :syntax_errors, :ami_errors
+  def initialize(*args)
+    super
+    @received_messages = []
+    @syntax_errors     = []
+    @ami_errors        = []
+  end
+
+  def message_received(message=@current_message)
+    @received_messages << message
+  end
+
+  def error_received(error_message)
+    @ami_errors << error_message
+  end
+
+  def syntax_error_encountered(ignored_chunk)
+    @syntax_errors << ignored_chunk
+  end
+
+end
+
+steps_for :ami_lexer do
+
+  ########################################
+  #### GIVEN
+  ########################################
+
+  Given "a new lexer" do
+    @lexer = IntrospectiveManagerStreamLexer.new
+    @custom_stanzas = {}
+    @custom_events  = {}
+
+    @GivenPong = lambda do |with_or_without, action_id, number|
+      number = number == "a" ? 1 : number.to_i
+      data = case with_or_without
+        when "with"    then "Response: Pong\r\nActionID: #{action_id}\r\n\r\n"
+        when "without" then "Response: Pong\r\n\r\n"
+        else raise "Do not recognize preposition #{with_or_without.inspect}. Should be either 'with' or 'without'"
+      end
+      number.times do
+        @lexer << data
+      end
+    end
+  end
+
+  Given "a version header for AMI $version" do |version|
+    @lexer << "Asterisk Call Manager/1.0\r\n"
+  end
+
+  Given "a normal login success with events" do
+    @lexer << fixture('login/standard/success')
+  end
+
+  Given "a normal login success with events split into two pieces" do
+    stanza = fixture('login/standard/success')
+    @lexer << stanza[0...3]
+    @lexer << stanza[3..-1]
+  end
+
+  Given "a stanza break" do
+    @lexer << "\r\n\r\n"
+  end
+
+  Given "a multi-line Response:Follows body of $method_name" do |method_name|
+    multi_line_response_body = send(:follows_body_text, method_name)
+
+    multi_line_response = format_newlines(<<-RESPONSE + "\r\n") % multi_line_response_body
+Response: Follows\r
+Privilege: Command\r
+ActionID: 123123\r
+%s\r
+--END COMMAND--\r\n\r
+    RESPONSE
+
+    @lexer << multi_line_response
+  end
+
+  Given "a multi-line Response:Follows response simulating uptime" do |method_name|
+    uptime_response = "Response: Follows\r
+Privilege: Command\r
+System uptime: 46 minutes, 30 seconds\r
+--END COMMAND--\r\n\r\n"
+    @lexer << uptime_response
+  end
+
+  Given "syntactically invalid $name" do |name|
+    @lexer << send(:syntax_error_data, name)
+  end
+
+  Given "$number Pong responses? with an ActionID of $action_id" do |number, action_id|
+    @GivenPong.call "with", action_id, number
+  end
+
+  Given "$number Pong responses? without an ActionID" do |number|
+    @GivenPong.call "without", Time.now.to_f, number
+  end
+
+  Given 'a custom stanza named "$name"' do |name|
+    @custom_stanzas[name] = "Response: Success\r\n"
+  end
+
+  Given 'the custom stanza named "$name" has key "$key" with value "$value"' do |name,key,value|
+    @custom_stanzas[name] << "#{key}: #{value}\r\n"
+  end
+
+  Given 'an AMI error whose message is "$message"' do |message|
+    @lexer << "Response: Error\r\nMessage: #{message}\r\n\r\n"
+  end
+
+  Given 'an immediate response with text "$text"' do |text|
+    @lexer << "#{text}\r\n\r\n"
+  end
+
+  Given 'a custom event with name "$event_name" identified by "$identifier"' do |event_name, identifer|
+    @custom_events[identifer] = {:Event => event_name }
+  end
+
+  Given 'a custom header for event identified by "$identifier" whose key is "$key" and value is "$value"' do |identifier, key, value|
+    @custom_events[identifier][key] = value
+  end
+
+  Given "an Authentication Required error" do
+    @lexer << "Response: Error\r\nActionID: BPJeKqW2-SnVg-PyFs-vkXT-7AWVVPD0N3G7\r\nMessage: Authentication Required\r\n\r\n"
+  end
+
+  Given "a follows packet with a colon in it" do
+    @lexer << follows_body_text("with_colon")
+  end
+
+  ########################################
+  #### WHEN
+  ########################################
+
+  When 'the custom stanza named "$name" is added to the buffer' do |name|
+    @lexer << (@custom_stanzas[name] + "\r\n")
+  end
+
+  When 'the custom event identified by "$identifier" is added to the buffer' do |identifier|
+    custom_event = @custom_events[identifier].clone
+    event_name = custom_event.delete :Event
+    stringified_event = "Event: #{event_name}\r\n"
+    custom_event.each_pair do |key,value|
+      stringified_event << "#{key}: #{value}\r\n"
+    end
+    stringified_event << "\r\n"
+    @lexer << stringified_event
+  end
+
+  When "the buffer is lexed" do
+    @lexer.resume!
+  end
+
+  ########################################
+  #### THEN
+  ########################################
+
+  Then "the protocol should have lexed without syntax errors" do
+    current_pointer     = @lexer.send(:instance_variable_get, :@current_pointer)
+    data_ending_pointer = @lexer.send(:instance_variable_get, :@data_ending_pointer)
+    current_pointer.should equal(data_ending_pointer)
+    @lexer.syntax_errors.size.should equal(0)
+  end
+
+  Then "the protocol should have lexed with $number syntax errors?" do |number|
+    @lexer.syntax_errors.size.should equal(number.to_i)
+  end
+
+  Then "the syntax error fixture named $name should have been encountered" do |name|
+    irregularity = send(:syntax_error_data, name)
+    @lexer.syntax_errors.find { |error| error == irregularity }.should_not be_nil
+  end
+
+  Then "$number_received messages? should have been received" do |number_received|
+    @lexer.received_messages.size.should equal(number_received.to_i)
+  end
+
+  Then "the 'follows' body of $number messages? received should equal $method_name" do |number, method_name|
+    multi_line_response = follows_body_text method_name
+    @lexer.received_messages.should_not be_empty
+    @lexer.received_messages.select do |message|
+      message.text_body == multi_line_response
+    end.size.should eql(number.to_i)
+  end
+
+  Then "the version should be set to $version" do |version|
+    @lexer.ami_version.should eql(version.to_f)
+  end
+
+  Then 'the $ordered message received should have a key "$key" with value "$value"' do |ordered,key,value|
+    ordered = ordered[/^(\d+)\w+$/, 1].to_i - 1
+    @lexer.received_messages[ordered][key].should eql(value)
+  end
+
+  Then "$number AMI error should have been received" do |number|
+    @lexer.ami_errors.size.should equal(number.to_i)
+  end
+
+  Then 'the $order AMI error should have the message "$message"' do |order, message|
+    order = order[/^(\d+)\w+$/, 1].to_i - 1
+    @lexer.ami_errors[order].should be_kind_of(Adhearsion::VoIP::Asterisk::Manager::ManagerInterfaceError)
+    @lexer.ami_errors[order].message.should eql(message)
+  end
+
+  Then '$number message should be an immediate response with text "$text"' do |number, text|
+    matching_immediate_responses = @lexer.received_messages.select do |response|
+      response.kind_of?(Adhearsion::VoIP::Asterisk::Manager::ManagerInterfaceResponse) && response.text_body == text
+    end
+    matching_immediate_responses.size.should equal(number.to_i)
+    matching_immediate_responses.first["ActionID"].should eql(nil)
+  end
+
+  Then 'the $order event should have the name "$name"' do |order, name|
+    order = order[/^(\d+)\w+$/, 1].to_i - 1
+    @lexer.received_messages.select do |response|
+      response.kind_of?(Adhearsion::VoIP::Asterisk::Manager::ManagerInterfaceEvent)
+    end[order].name.should eql(name)
+  end
+
+  Then '$number event should have been received' do |number|
+    @lexer.received_messages.select do |response|
+      response.kind_of?(Adhearsion::VoIP::Asterisk::Manager::ManagerInterfaceEvent)
+    end.size.should equal(number.to_i)
+  end
+
+  Then 'the $order event should have key "$key" with value "$value"' do |order, key, value|
+    order = order[/^(\d+)\w+$/, 1].to_i - 1
+    @lexer.received_messages.select do |response|
+      response.kind_of?(Adhearsion::VoIP::Asterisk::Manager::ManagerInterfaceEvent)
+    end[order][key].should eql(value)
+  end
+
+end
+
+with_steps_for(:ami_lexer) do
+  run File.dirname(__FILE__) + "/lexer_story"
+end