Sipper 1.1.3

data/sipper_test/test_compact_converter.rb

@@ -0,0 +1,33 @@
+require 'base_test_case'
+require 'util/compact_converter'
+
+class TestCompactConverter < BaseTestCase
+
+  def test_compact_present
+    assert(SipperUtil::CompactConverter.has_compact_form?("Via"))
+    assert(SipperUtil::CompactConverter.has_compact_form?("via"))
+    assert(SipperUtil::CompactConverter.has_compact_form?(:via))
+    assert(SipperUtil::CompactConverter.has_compact_form?("call-id"))
+    assert(SipperUtil::CompactConverter.has_compact_form?("Call-ID"))
+    assert(SipperUtil::CompactConverter.has_compact_form?("Call-Id"))
+    assert(!SipperUtil::CompactConverter.has_compact_form?("P-Non-Header"))
+  end
+
+  def test_expanded_present
+    assert(SipperUtil::CompactConverter.has_expanded_form?("i"))
+    assert(!SipperUtil::CompactConverter.has_expanded_form?("2"))
+  end
+
+  def test_expanded
+    assert_equal("Call-ID", SipperUtil::CompactConverter.get_expanded("i"))
+    assert_equal("From", SipperUtil::CompactConverter.get_expanded("f"))
+    assert_nil(SipperUtil::CompactConverter.get_expanded("2"))
+  end
+  
+  def test_compact
+    assert_equal("i", SipperUtil::CompactConverter.get_compact("Call-ID"))
+    assert_equal("j", SipperUtil::CompactConverter.get_compact("Reject-Contact"))
+    assert_nil(SipperUtil::CompactConverter.get_compact("P-Non-Header"))
+  end
+      
+end

data/sipper_test/test_controller_class_loader.rb

@@ -0,0 +1,37 @@
+
+require 'base_test_case'
+
+
+class TestControllerClassLoader < BaseTestCase
+  include SIP
+  def setup
+    @path = File.join(SipperConfigurator[:SipperBasePath], "sipper_test", "test_controllers", "class_loading")
+  end
+  
+  def test_empty_clear
+    assert_nothing_raised {ControllerClassLoader.clear_all}
+  end
+  
+  def test_empty_controllers
+    assert_equal([], ControllerClassLoader.controllers)
+    test_empty_clear
+    assert_equal([], ControllerClassLoader.controllers)
+  end
+  
+  def test_load
+    file = File.join(@path,"ordered", "first_ordered_controller.rb")
+    ControllerClassLoader.load file
+    assert_equal("FirstOrderedController", ControllerClassLoader.controllers[0].to_s)  
+    file = File.join(@path,"ordered", "second_ordered_controller.rb")
+    ControllerClassLoader.load file
+    assert_equal(2, ControllerClassLoader.controllers.size)
+    assert_not_nil(ControllerClassLoader.controllers.find {|x| x.to_s == "SecondOrderedModule::SecondOrderedController"} )
+    ControllerClassLoader.load file  #load again
+    assert_equal(2, ControllerClassLoader.controllers.size)
+  end
+ 
+   def teardown
+     ControllerClassLoader.clear_all
+   end
+   
+end

data/sipper_test/test_controller_selector.rb

@@ -0,0 +1,53 @@
+require 'base_test_case'
+
+
+class TestControllerSelector < BaseTestCase
+ 
+
+  def setup
+    @path = File.join(SipperConfigurator[:SipperBasePath], "sipper_test", "test_controllers", "class_loading")
+  end
+
+  def test_ordered_load_with_dir
+    p = File.join(@path, "ordered")
+    c = SIP::ControllerSelector.new( Dir.new(p) )
+    assert_equal("SecondOrderedModule::SecondOrderedController", c.get_controllers[0].name)
+    assert_equal("FirstOrderedController", c.get_controllers[1].name)
+    assert_equal("SecondOrderedModule::RecondOrderedController", c.get_controllers[2].name)
+  end
+  
+  def test_ordered_load_with_path
+    p = File.join(@path, "ordered")
+    c = SIP::ControllerSelector.new( p )
+    assert_equal("SecondOrderedModule::SecondOrderedController", c.get_controllers[0].name)
+    assert_equal("FirstOrderedController", c.get_controllers[1].name)
+    assert_equal("SecondOrderedModule::RecondOrderedController", c.get_controllers[2].name)
+    assert_equal("FirstOrderedController", c.get_controller("FirstOrderedController").name)
+  end
+  
+  
+  def test_unordered_load
+    p = File.join(@path, "unordered")
+    c = SIP::ControllerSelector.new( Dir.new(p) )
+    assert_not_nil(c.get_controllers.find {|x| x.name == "SecondUnorderedModule::SecondUnorderedController"})
+    assert_not_nil(c.get_controllers.find {|x| x.name == "FirstUnorderedController"})
+  end
+  
+  def test_clear
+    p = File.join(@path, "ordered")
+    c = SIP::ControllerSelector.new( p )
+    assert_equal(3, c.get_controllers.size)
+    c.clear_all
+    assert_equal(0, c.get_controllers.size)
+  end
+  
+  
+  def teardown
+    if @cs
+      @cs.clear_all 
+    else   
+      SIP::ControllerClassLoader.clear_all
+    end
+  end
+    
+end

data/sipper_test/test_controller_using_compact_headers.rb

@@ -0,0 +1,74 @@
+
+require 'driven_sip_test_case'
+
+class TestControllerUsingCompactHeaders < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasChController < SIP::SipTestDriverController
+        transaction_usage :use_transactions=>false
+        def on_info(session)
+          logd("Received INFO in "+name)
+          r = session.create_response(200, "OK")
+          session.set_compact_headers([:from, :to, :call_id])
+          session.send(r)
+          session.invalidate
+        end
+        
+        def order
+          0
+        end
+      end
+      
+      class UacChController < SIP::SipTestDriverController
+        transaction_usage :use_transactions=>false        
+        use_compact_headers [:to, :from, :call_id, :via]
+        def start
+          r = Request.create_initial("info", "sip:nasir@sipper.com", :p_session_record=>"msg-debug")
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          u.send(r)
+          logd("Sent a new INFO from "+name)
+        end
+     
+        def on_success_res(session)
+          logd("Received response in "+name)
+          session.invalidate
+          session.flow_completed_for("TestControllerUsingCompactHeaders")  
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacChController")
+  end
+  
+  
+  def test_header_order
+    self.expected_flow = ["> INFO","< 200"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INFO", "> 200"]
+    verify_call_flow(:in)
+    
+    msg = get_out_recording.get_recording[0] # first SIP message from UAC
+    ["t", "i", "v", "f"].each do |h| 
+      assert(msg.index(h+": "))
+    end
+    
+    msg = get_in_recording.get_recording[1] # second msg, i.e response from UAS
+    ["t", "i", "f"].each do |h| 
+      assert(msg.index(h+": "))
+    end 
+  end
+  
+end
+
+
+
+

data/sipper_test/test_controller_using_header_order.rb

@@ -0,0 +1,85 @@
+
+require 'driven_sip_test_case'
+
+class TestControllerUsingHeaderOrder < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasHoController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>false
+        def on_info(session)
+          logd("Received INFO in #{name}")
+          session.local_tag = 6  #todo differentiate automatically on the same container somehow
+          r = session.create_response(200, "OK")
+          session.set_header_order([:from, :to, :via, :cseq, :call_id])
+          session.send(r)
+          session.invalidate
+        end
+        
+        def order
+          0
+        end
+      end
+      
+      class UacHoController < SIP::SipTestDriverController
+        transaction_usage :use_transactions=>false        
+        header_order [:to, :from, :call_id, :via, :cseq]
+        def start
+          r = Request.create_initial("info", "sip:nasir@sipper.com", :p_session_record=>"msg-debug")
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          u.send(r)
+          logd("Sent a new INFO from #{name}")
+        end
+     
+        def on_success_res(session)
+          logd("Received response in #{name}")
+          session.invalidate
+          session.flow_completed_for("TestControllerUsingHeaderOrder")  
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacHoController")
+  end
+  
+  
+  def test_header_order
+    self.expected_flow = ["> INFO","< 200"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INFO", "> 200"]
+    verify_call_flow(:in)
+    msg = get_out_recording.get_recording[0] # first SIP message from UAC
+    idx = 0
+    [:to, :from, :call_id, :via, :cseq].each do |h| 
+      new_idx = msg.index(SipperUtil.headerize(h.to_s)+": ")
+      if new_idx
+        assert(new_idx > idx) 
+        idx = new_idx
+      end
+    end
+    
+    msg = get_in_recording.get_recording[1] # second msg, i.e response from UAS
+    idx = 0
+    [:from, :to, :via, :cseq, :call_id].each do |h| 
+      new_idx = msg.index(SipperUtil.headerize(h.to_s)+": ")
+      if new_idx
+        assert(new_idx > idx) 
+        idx = new_idx
+      end
+    end
+    
+  end
+  
+end
+
+
+

data/sipper_test/test_controller_using_ict.rb

@@ -0,0 +1,64 @@
+require 'driven_sip_test_case'
+
+class TestControllerUsingIct < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    require 'sip_test_driver_controller'
+    module SipInline
+      class UasIctController < SIP::SipTestDriverController
+        transaction_usage :use_transactions=>false
+        def on_invite(session)
+          logd("Received INVITE in #{name}")
+          session.local_tag = 5  #todo differentiate automatically on the same container somehow
+          if session['ignored']
+            r = session.create_response(200, "OK") 
+            session.send(r)
+            session.invalidate(true) 
+          else
+            session['ignored'] = true
+          end
+        end
+        
+        def order
+          0
+        end
+      end
+      
+      class UacIctController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>false, :use_ict=>true
+        transaction_timers :t1=>#{@grty*2}  # just want at least one retransmit
+        
+        def start
+          r = Request.create_initial("invite", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          u.send(r)
+          logd("Sent a new INVITE from #{name}")
+        end
+     
+        def on_success_res(session)
+          logd("Received response in #{name}")
+          session.invalidate(true)
+          session.flow_completed_for("TestControllerUsingIct")
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacIctController")
+  end
+  
+  
+  def test_ict_controllers
+    self.expected_flow = ["> INVITE {1,}", "< 200 {1,}"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE {2,2}", "> 200"]  # at least one retrans
+    verify_call_flow(:in)
+  end
+  
+end
+

data/sipper_test/test_controller_using_ict_with_non_success.rb

@@ -0,0 +1,72 @@
+require 'driven_sip_test_case'
+
+class TestControllerUsingIctWithNonSuccess < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+    
+      class UasIctControllerFailure < SIP::SipTestDriverController
+      
+        def on_invite(session)
+          logd("Received INVITE in #{name}")
+          session.local_tag = 5  #todo differentiate automatically on the same container somehow
+          r = session.create_response(404, "Not Found")
+          session.send(r)
+        end
+        
+        def on_ack(session)
+          logd("Received ACK in #{name}")
+          session.invalidate
+          session.flow_completed_for("TestControllerUsingIctWithNonSuccess")
+        end
+        
+        def order
+          0
+        end
+      end
+      
+      class UacIctControllerFailure < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>false, :use_ict=>true
+        
+        def start
+          r = Request.create_initial("invite", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          u.send(r)
+          logd("Sent a new INVITE from #{name}")
+        end
+     
+        def on_failure_res(session)
+          logd("Received response in #{name}")
+          begin
+            session.create_and_send_ack
+          rescue RuntimeError
+            session.do_record("Exception in sending ACK to non 2xx from controller")
+          end
+          session.invalidate
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacIctControllerFailure")
+  end
+  
+  
+  def test_ict_controllers
+    orig = SipperConfigurator[:ProtocolCompliance]
+    SipperConfigurator[:ProtocolCompliance] = 'strict'
+    self.expected_flow = ["> INVITE", "< 404", "> ACK", "! Exception_in_sending_ACK_to_non_2xx_from_controller"]  # as ACK is sent by Txn
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 404", "< ACK"] 
+    verify_call_flow(:in)
+    SipperConfigurator[:ProtocolCompliance] = orig
+  end
+  
+end

data/sipper_test/test_controller_using_ict_with_tcbh.rb

@@ -0,0 +1,24 @@
+require 'driven_sip_test_case'
+
+class TestControllerUsingIctWithTcbh < DrivenSipTestCase
+
+  def setup
+    SipperConfigurator[:ControllerPath] = File.join(SipperConfigurator[:SipperBasePath], "sipper_test", "test_controllers", "ict_tcbh")
+    super
+  end
+  
+  
+  def test_ict_controllers
+    self.expected_flow = ["> INVITE", "< 200", "> INFO"]
+    start_named_controller("SipIct::UacIctTcbhController")
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 200", "< INFO"]
+    verify_call_flow(:in)
+    
+    record_in = get_in_recording(0)
+    assert_header_value_in_recording_equals(record_in.get_recording[0], :test_header, "Sipper")
+  end
+  
+end
+
+