sipatra 0.0.3 → 0.1.0

data/spec/helpers_spec.rb

@@ -0,0 +1,352 @@
+require File.dirname(__FILE__) + '/helper'
+
+class FakeApp 
+  include Sipatra::HelperMethods
+  
+  public :message # or we would NOT have access to the WRONG private method of Object
+end
+
+describe 'When', Sipatra::HelperMethods, 'is included; ', FakeApp do
+  def mock_address
+    @mock_address ||= mock('Address')
+  end
+  
+  def mock_uri
+    @mock_uri ||= mock('URI')
+  end
+  
+  def mock_proxy
+    @mock_proxy ||= mock('Proxy')
+  end
+  
+  def mock_sip_factory
+    @sip_factory ||= mock('SipFactory')
+  end
+  
+  def mock_response
+    @mock_response ||= mock('SipServletResponse')
+  end
+  
+  subject do
+    FakeApp::new
+  end
+  
+  before do
+    subject.stub!(:message).and_return(Object::new)
+  end
+  
+  describe "#convert_status_code" do
+    it "should convert Integer to an Integer" do
+      subject.send(:convert_status_code, 400).should be_kind_of(Integer)
+    end
+    
+    it "should convert a Symbol to it's numeric equivalent" do
+      subject.send(:convert_status_code, :not_found).should == 404
+    end
+  end
+  
+  describe "#remove_header" do
+    it "should remove the header with the given name" do
+      subject.message.should_receive(:removeHeader).twice.with('toto')
+      
+      subject.remove_header(:toto)
+      subject.remove_header('toto')
+    end
+  end
+  
+  describe "#modify_header" do
+    # TODO: what if we have multiple headers ?
+    it 'should replace a header value with substitution' do
+      mock_headers = mock('HeadersWrapper')
+      subject.should_receive(:headers).twice.and_return(mock_headers)
+      mock_headers.should_receive(:"[]").with('X-Header').and_return(['old_value'])
+      mock_headers.should_receive(:"[]=").with('X-Header', ['new_value'])
+      
+      subject.modify_header 'X-Header', /^old_(value)$/, 'new_\1'
+    end
+    
+    it 'should replace multiple headers with substitution' do
+      mock_headers = mock('HeadersWrapper')
+      subject.should_receive(:headers).twice.and_return(mock_headers)
+      mock_headers.should_receive(:"[]").with('X-Header').and_return(['old_value', 'old_foo'])
+      mock_headers.should_receive(:"[]=").with('X-Header', ['new_value', 'new_foo'])
+      
+      subject.modify_header 'X-Header', /^old_(.*)$/, 'new_\1'
+    end
+    
+    it 'should replace a header value with a block result' do
+      mock_headers = mock('HeadersWrapper')
+      subject.should_receive(:headers).twice.and_return(mock_headers)
+      mock_headers.should_receive(:"[]").with('X-Header').and_return(['old_value', 'old_value'])
+      mock_headers.should_receive(:"[]=").with('X-Header', ['new_value', 'new_value'])
+      
+      i = 0
+      subject.modify_header 'X-Header' do |value|
+        value.should == "old_value"
+        i += 1
+        'new_value'
+      end
+      i.should == 2      
+    end
+  end
+  
+  describe "#create_address" do
+    before do
+      subject.stub!(:sip_factory => mock_sip_factory)
+    end
+    
+    it "should create a wildcard address" do
+      mock_sip_factory.should_receive(:createAddress).twice.with('*').and_return(mock_address)
+      
+      subject.create_address('*').should == mock_address
+      subject.create_address(:*).should == mock_address
+    end
+    
+    it "should set expires on the address" do
+      mock_sip_factory.should_receive(:createAddress).with('test').and_return(mock_address)
+      mock_address.should_receive(:setExpires).with(1234)
+      
+      subject.create_address('test', :expires => 1234).should == mock_address
+    end
+    
+    it "should set displayName on the address" do
+      mock_sip_factory.should_receive(:createAddress).with('test').and_return(mock_address)
+      mock_address.should_receive(:setDisplayName).with("display name")
+      
+      subject.create_address('test', :display_name => "display name").should == mock_address
+    end
+  end
+  
+  describe "#create_uri" do
+    before do
+      subject.stub!(:sip_factory => mock_sip_factory)
+      mock_sip_factory.should_receive(:createURI).with('some_uri').and_return(mock_uri)
+    end
+    
+    it "should createURI and set LR to true" do
+      mock_uri.should_receive(:setLrParam).with(true)
+      mock_uri.should_not_receive(:setParameter)
+
+      subject.create_uri('some_uri').should == mock_uri
+    end
+
+    it "should createURI and set LR to false" do
+      mock_uri.should_receive(:setLrParam).with(false)
+      mock_uri.should_not_receive(:setParameter)
+
+      subject.create_uri('some_uri', :lr => false).should == mock_uri
+    end
+
+    it "should createURI, set LR to false and other parameters" do
+      mock_uri.should_receive(:setLrParam).with(false)
+      mock_uri.should_receive(:setParameter).with("a_name", "a value")
+      mock_uri.should_receive(:setParameter).with("another_name", "another value")
+
+      subject.create_uri('some_uri', 
+                         :lr => false, 
+                         :a_name => "a value", 
+                         "another_name" => :"another value").should == mock_uri
+    end
+  end
+
+  describe "#send_response" do    
+    it 'should raise an ArgumentError when call with an incorrect symbol' do
+      lambda { subject.send_response(:toto) }.should raise_exception(ArgumentError)
+    end
+    
+    it 'should create a 404 status code when called with :not_found' do
+      subject.message.should_receive(:createResponse).with(404).and_return(mock_response)  
+      mock_response.should_receive(:send)
+      
+      subject.send_response(:not_found)
+    end
+    
+    it 'should respond to send_response with Integer' do
+      subject.message.should_receive(:createResponse).with(500).and_return(mock_response)  
+      mock_response.should_receive(:send)
+      
+      subject.send_response(500)
+    end
+    
+    it 'should respond to send_response with a block' do
+      subject.message.should_receive(:createResponse).with(500).and_return(mock_response)  
+      mock_response.should_receive(:addHeader).with('Test1', 'Value1')
+      mock_response.should_receive(:send)
+      
+      subject.send_response(500) do 
+        response.addHeader('Test1', 'Value1')
+      end
+    end
+    
+    it 'should respond to send_response with a Hash' do
+      subject.message.should_receive(:createResponse).with(500).and_return(mock_response)  
+      mock_response.should_receive(:addHeader).with('Test1', '1234')
+      mock_response.should_receive(:send)
+      
+      subject.send_response 500, :Test1 => 1234
+    end
+    
+    it 'should respond to send_response with a Hash and block' do
+      subject.message.should_receive(:createResponse).with(500).and_return(mock_response)  
+      mock_response.should_receive(:addHeader).with('Test1', 'Value1')
+      mock_response.should_receive(:addHeader).with('Test2', 'Value2')
+      mock_response.should_receive(:send)
+      
+      subject.send_response 500, :Test1 => 'Value1' do 
+        response.addHeader('Test2', 'Value2')
+      end
+    end
+    
+    it 'should respond to send_response with a message and block' do
+      subject.message.should_receive(:createResponse).with(500, 'Error').and_return(mock_response)
+      mock_response.should_receive(:addHeader).with('Test2', 'Value2')
+      mock_response.should_receive(:send)
+      
+      subject.send_response(500, 'Error') do 
+        response.addHeader('Test2', 'Value2')
+      end      
+    end
+  end
+  
+  it 'should respond to header[]' do
+    subject.message.should_receive(:getHeader).twice.with('toto').and_return('test1')
+    
+    subject.header[:toto].should  == 'test1'
+    subject.header['toto'].should == 'test1'
+  end
+  
+  it 'should respond to header[]=' do
+    subject.message.should_receive(:setHeader).twice.with('toto', 'test2')
+    
+    subject.header[:toto]  = 'test2'
+    subject.header['toto'] = 'test2'
+  end
+  
+  it 'should respond to headers[]' do
+    subject.message.should_receive(:getHeaders).twice.with('toto').and_return(['test1', 'test2'])
+    
+    subject.headers[:toto].should == ['test1', 'test2']
+    subject.headers['toto'].should == ['test1', 'test2']
+  end
+  
+  it 'should respond to headers[]=' do
+    values = ['foo', :bar]
+    
+    subject.message.should_receive(:removeHeader).with('toto')
+    values.each do |value| 
+      subject.message.should_receive(:addHeader).with('toto', value.to_s) 
+    end
+    subject.message.should_receive(:removeHeader).with('toto')
+    values.each do |value| 
+      subject.message.should_receive(:addHeader).with('toto', value.to_s) 
+    end
+
+    subject.headers[:toto] = values
+    subject.headers['toto'] = values
+  end
+  
+  it 'should respond to address_header[]' do
+    subject.message.should_receive(:getAddressHeader).twice.with('toto').and_return(['test1', 'test2'])
+    
+    subject.address_header[:toto].should == ['test1', 'test2']
+    subject.address_header['toto'].should == ['test1', 'test2']
+  end
+  
+  it 'should respond to address_header[]=' do
+    subject.message.should_receive(:setAddressHeader).twice.with('toto', 'test2')
+    
+    subject.address_header[:toto]  = 'test2'
+    subject.address_header['toto'] = 'test2'
+  end
+  
+  it 'should respond to address_headers[]' do
+    subject.message.should_receive(:getAddressHeaders).twice.with('toto').and_return(['test1', 'test2'])
+    
+    subject.address_headers[:toto].should == ['test1', 'test2']
+    subject.address_headers['toto'].should == ['test1', 'test2']
+  end
+  
+  it 'should not respond to address_headers[]=' do
+    values = ['foo', :bar]
+    subject.message.should_receive(:removeHeader).with('toto')
+    values.each do |value| 
+      subject.message.should_receive(:addAddressHeader).with('toto', value, true) 
+    end
+    subject.message.should_receive(:removeHeader).with('toto')
+    values.each do |value| 
+      subject.message.should_receive(:addAddressHeader).with('toto', value, true) 
+    end  
+    
+    subject.address_headers[:toto] = values
+    subject.address_headers['toto'] = values
+  end
+  
+  it 'should respond to header?' do
+    subject.message.should_receive(:getHeader).twice.with('toto').and_return('test1')
+    
+    subject.header?(:toto).should == true
+    subject.header?('toto').should == true
+  end
+  
+  it 'should add a header' do
+    subject.message.should_receive(:addHeader).twice.with('toto', 'test2')
+    
+    subject.add_header(:toto, 'test2')
+    subject.add_header('toto', 'test2')
+  end
+  
+  it 'should add an address header' do
+    subject.message.should_receive(:addAddressHeader).with('titi', 'test1', false)
+    subject.message.should_receive(:addAddressHeader).twice.with('toto', 'test2', true)
+    
+    subject.add_address_header(:titi, 'test1', false)
+    subject.add_address_header(:toto, 'test2')
+    subject.add_address_header('toto', 'test2')
+  end
+  
+  it 'should push a route' do
+    mock_sip_factory.should_receive(:createAddress).with('sip:an_address').and_return(mock_address)
+    subject.should_receive(:sip_factory).and_return(mock_sip_factory)
+    subject.message.should_receive(:pushRoute).with(mock_address)
+    
+    subject.push_route('sip:an_address')
+  end
+  
+  describe "#proxy" do
+    it 'should proxy without URI' do
+      subject.message.should_receive(:requestURI).and_return('the_uri')
+      subject.message.should_receive(:proxy).and_return(mock_proxy)
+      mock_proxy.should_receive(:proxyTo).with('the_uri')
+      
+      subject.proxy
+    end
+    
+    it 'should proxy (RR) without URI' do
+      subject.message.should_receive(:requestURI).and_return('the_uri')
+      subject.message.should_receive(:proxy).and_return(mock_proxy)
+      mock_proxy.should_receive(:setRecordRoute).with(true)
+      mock_proxy.should_receive(:proxyTo).with('the_uri')
+      
+      subject.proxy :record_route => true
+    end
+    
+    it 'should proxy with an URI' do
+      subject.message.should_receive(:proxy).and_return(mock_proxy)
+      subject.should_receive(:sip_factory).and_return(mock_sip_factory)
+      mock_sip_factory.should_receive(:createURI).with('the_uri_string').and_return('the_uri')
+      mock_proxy.should_receive(:proxyTo).with('the_uri')
+      
+      subject.proxy('the_uri_string')
+    end 
+    
+    it 'should proxy (RR) with an URI' do
+      subject.message.should_receive(:proxy).and_return(mock_proxy)
+      subject.should_receive(:sip_factory).and_return(mock_sip_factory)
+      mock_sip_factory.should_receive(:createURI).with('the_uri_string').and_return('the_uri')
+      mock_proxy.should_receive(:setRecordRoute).with(false)
+      mock_proxy.should_receive(:proxyTo).with('the_uri')
+      
+      subject.proxy('the_uri_string', :record_route => false)
+    end 
+  end
+end

data/spec/sipatra_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe Sipatra do
+  subject do
+    Sipatra
+  end
+  
+  it_should_behave_like ExtensionsMethods
+  
+  describe "#register_extensions" do
+    module ExtensionModule
+      def dsl_extension
+        invite 'foo' do
+          # nothing
+        end
+      end
+    end
+
+    it "should add the module as a DSL extensions" do
+      Sipatra.register_extension ExtensionModule
+      
+      Sipatra::Application.public_methods.include?('dsl_extension').should be_true
+      private_methods.include?('dsl_extension').should be_true
+    end
+  end
+end

data/test/integration/sipapp/WEB-INF/sip.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<sip-app  xmlns="http://www.jcp.org/xml/ns/sipservlet"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="http://www.jcp.org/xml/ns/sipservlet http://www.jcp.org/xml/ns/sipservlet/sip-app_1_1.xsd"
+          version="1.1">
+  <listener>
+    <listener-class>org.cipango.sipatra.DefaultContextLoader</listener-class>
+  </listener>
+  <servlet>
+    <servlet-name>sipatra</servlet-name>
+    <servlet-class>org.cipango.sipatra.SipatraServlet</servlet-class>
+    <load-on-startup>1</load-on-startup>
+  </servlet>
+</sip-app>

data/test/integration/sipapp/WEB-INF/sipatra/application.rb

@@ -0,0 +1,26 @@
+invite /.*/ do
+  puts "#{message.method} #{message.requestURI}"
+  $stdout.flush
+  proxy "sip:#{message.requestURI.user}@127.0.0.1:5090"
+end
+
+register do
+  puts "#{message.method} #{message.requestURI}"
+  $stdout.flush
+  proxy "sip:#{message.requestURI.user}@127.0.100.1:5060"
+end
+
+request do
+  puts "#{message.method} #{message.requestURI} [default]"
+  $stdout.flush
+end
+
+#ack do
+#  puts "#{message.method} #{message.requestURI}"
+#  proxy "sip:toto@127.0.2.1:5062"
+#end
+
+response do
+  puts "RESPONSE: #{message.status} #{message.request.requestURI}"
+  $stdout.flush
+end

data/test/integration/sipatra.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0"  encoding="ISO-8859-1"?>
+<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN" "http://jetty.mortbay.org/configure.dtd">
+<Configure class="org.cipango.sipapp.SipAppContext">
+  <Set name="contextPath">/sipatra</Set>
+  <Set name="war">/vagrant/test/integration/sipapp</Set>
+  <Set name="defaultsDescriptor"><SystemProperty default="." name="jetty.home"/>/etc/webdefault.xml</Set>
+  <Set name="defaultsSipDescriptor"><SystemProperty default="." name="jetty.home"/>/etc/sipdefault.xml</Set>
+</Configure>
+

data/test/integration/sipp/uac.xml

@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE scenario SYSTEM "sipp.dtd">
+
+<!-- This program is free software; you can redistribute it and/or      -->
+<!-- modify it under the terms of the GNU General Public License as     -->
+<!-- published by the Free Software Foundation; either version 2 of the -->
+<!-- License, or (at your option) any later version.                    -->
+<!--                                                                    -->
+<!-- This program is distributed in the hope that it will be useful,    -->
+<!-- but WITHOUT ANY WARRANTY; without even the implied warranty of     -->
+<!-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the      -->
+<!-- GNU General Public License for more details.                       -->
+<!--                                                                    -->
+<!-- You should have received a copy of the GNU General Public License  -->
+<!-- along with this program; if not, write to the                      -->
+<!-- Free Software Foundation, Inc.,                                    -->
+<!-- 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA             -->
+<!--                                                                    -->
+<!--                 Sipp default 'uac' scenario.                       -->
+<!--                                                                    -->
+
+<scenario name="Basic Sipstone UAC">
+  <!-- In client mode (sipp placing calls), the Call-ID MUST be         -->
+  <!-- generated by sipp. To do so, use [call_id] keyword.                -->
+  <send retrans="500">
+    <![CDATA[
+
+      INVITE sip:[service]@[remote_ip]:[remote_port] SIP/2.0
+      Via: SIP/2.0/[transport] [local_ip]:[local_port];branch=[branch]
+      From: sipp <sip:sipp@[local_ip]:[local_port]>;tag=[pid]SIPpTag00[call_number]
+      To: sut <sip:[service]@[remote_ip]:[remote_port]>
+      Call-ID: [call_id]
+      CSeq: 1 INVITE
+      Contact: sip:sipp@[local_ip]:[local_port]
+      Max-Forwards: 70
+      Subject: Performance Test
+      Content-Type: application/sdp
+      Content-Length: [len]
+
+      v=0
+      o=user1 53655765 2353687637 IN IP[local_ip_type] [local_ip]
+      s=-
+      c=IN IP[media_ip_type] [media_ip]
+      t=0 0
+      m=audio [media_port] RTP/AVP 0
+      a=rtpmap:0 PCMU/8000
+
+    ]]>
+  </send>
+
+  <recv response="100"
+        optional="true">
+  </recv>
+
+  <recv response="180" optional="true">
+  </recv>
+
+  <recv response="183" optional="true">
+  </recv>
+
+  <!-- By adding rrs="true" (Record Route Sets), the route sets         -->
+  <!-- are saved and used for following messages sent. Useful to test   -->
+  <!-- against stateful SIP proxies/B2BUAs.                             -->
+  <recv response="200" rtd="true" rrs="true">
+    <action>
+        <ereg regexp=".*<([^>]*)>.*" search_in="hdr" header="Contact:" check_it="true" assign_to="1,contact" />
+        <log message="Junk is [$1]"/>
+    </action>
+  </recv>
+
+  <!-- Packet lost can be simulated in any send/recv message by         -->
+  <!-- by adding the 'lost = "10"'. Value can be [1-100] percent.       -->
+  <send>
+    <![CDATA[
+
+      ACK [$contact] SIP/2.0
+      Via: SIP/2.0/[transport] [local_ip]:[local_port];branch=[branch]
+      From: sipp <sip:sipp@[local_ip]:[local_port]>;tag=[pid]SIPpTag00[call_number]
+      To: sut <sip:[service]@[remote_ip]:[remote_port]>[peer_tag_param]
+      Call-ID: [call_id]
+      CSeq: 1 ACK
+      Contact: sip:sipp@[local_ip]:[local_port]
+      Max-Forwards: 70
+      Subject: Performance Test
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <!-- This delay can be customized by the -d command-line option       -->
+  <!-- or by adding a 'milliseconds = "value"' option here.             -->
+  <pause milliseconds="500"/>
+
+  <!-- The 'crlf' option inserts a blank line in the statistics report. -->
+  <send retrans="500">
+    <![CDATA[
+
+      BYE [$contact] SIP/2.0
+      Via: SIP/2.0/[transport] [local_ip]:[local_port];branch=[branch]
+      From: sipp <sip:sipp@[local_ip]:[local_port]>;tag=[pid]SIPpTag00[call_number]
+      To: sut <sip:[service]@[remote_ip]:[remote_port]>[peer_tag_param]
+      Call-ID: [call_id]
+      CSeq: 2 BYE
+      Contact: sip:sipp@[local_ip]:[local_port]
+      Max-Forwards: 70
+      Subject: Performance Test
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <recv response="200" crlf="true">
+  </recv>
+
+  <!-- definition of the response time repartition table (unit is ms)   -->
+  <ResponseTimeRepartition value="10, 20, 30, 40, 50, 100, 150, 200"/>
+
+  <!-- definition of the call length repartition table (unit is ms)     -->
+  <CallLengthRepartition value="10, 50, 100, 500, 1000, 5000, 10000"/>
+
+</scenario>
+