Sipper 1.1.3

data/sipper_test/test_cancel_with481.rb

@@ -0,0 +1,83 @@
+
+require 'driven_sip_test_case'
+
+# Client sends a CANCEL after getting 1xx/INVITE but in the meantime server also sends a 2xx 
+# thereby clearing the transaction on the server. The CANCEL does not find a Stx and thus 
+# should be responded to by a 481.  
+
+class TestCancelWith481 < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module TestCancelWith481_SipInline
+      class UasCancel4Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true 
+        transaction_timers :tz=>0  # terminate immediately
+        session_timer #{@grty*6}
+        
+        def on_invite(session)
+          session.respond_with(200)
+          session.invalidate
+          logd("Received INVITE in #{name} sent a 200")
+        end
+       
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacCancel4Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true  
+        session_timer #{@grty*6}
+        
+        def start
+          SipperConfigurator[:ProtocolCompliance] = 'lax'
+          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 failure response in #{name}")
+          session.invalidate
+          session.flow_completed_for("TestCancelWith481")
+        end
+        
+        def on_success_res(session)
+          logd("Received success response in #{name}")
+          if session.iresponse.get_request_method == "INVITE"
+            sleep #{@grty}/1000.0 # make sure IST terminates
+            session.send(session.create_cancel) unless session['cancel_sent']
+            session['cancel_sent'] = true
+          end
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("TestCancelWith481_SipInline::UacCancel4Controller")
+  end
+  
+  
+  def test_cancel3_controllers
+    self.expected_flow = ["> INVITE", "< 100", "< 200", "> CANCEL", "< 481"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "> 200", "< CANCEL", "> 481"] 
+    verify_call_flow(:in)
+  end
+  
+end
+
+

data/sipper_test/test_cancel_with487.rb

@@ -0,0 +1,70 @@
+
+require 'driven_sip_test_case'
+
+class TestCancelWith487 < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasCancel1Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        
+        def on_invite(session)
+          logd("Received INVITE in #{name} not doing anything")
+        end
+        
+        def on_cancel(session)
+          session.invalidate(true)
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacCancel1Controller < SIP::SipTestDriverController
+        transaction_usage :use_transactions=>true        
+        session_timer 100
+        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}")
+          u.create_and_send_cancel_when_ready
+        end
+     
+        def on_failure_res(session)
+          logd("Received failure response in #{name}")
+          session.invalidate
+          session.flow_completed_for("TestCancelWith487") 
+        end
+        
+        def on_success_res(session)
+          logd("Received success response in #{name}") 
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacCancel1Controller")
+  end
+  
+  
+  def test_cancel1_controllers
+    self.expected_flow = ["> INVITE", "< 100", "> CANCEL", "< 200", "< 487", "> ACK"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "< CANCEL", "> 200", "> 487", "< ACK {0,}"] 
+    verify_call_flow(:in)
+  end
+  
+end
+
+

data/sipper_test/test_cancel_with_ist_without_nist.rb

@@ -0,0 +1,99 @@
+
+require 'driven_sip_test_case'
+
+# The Client sends a CANCEL to INVITE, the server is using IST but not using NIST.
+
+class TestCancelWithIstWithoutNist < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    #----- Txn Handler--------
+    require 'transaction/state_machine_wrapper'
+
+    class IstTxnHandler
+    
+      def after_ack(txn)
+        txn.__consume_msg(true)
+        SIP::Transaction::SM_PROCEED  
+      end
+      
+    end
+    #------------------------
+    
+    
+    #------ Controllers -----
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasCancel5Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>false, :use_ist=>true
+        transaction_handlers :Ist=>IstTxnHandler
+             
+        def on_cancel(session)
+          session.respond_with(200)
+        end
+        
+        def on_invite(session)
+        end
+        
+        # Usually the controller will not see ACK for 4xx response
+        # we use the transcation handler to change the consume flag
+        # in this case. 
+        def on_ack(session)
+          session.invalidate(true)
+          session.flow_completed_for("TestCancelWithIstWithoutNist")
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      
+      class UacCancel5Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>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}")
+          u.create_and_send_cancel_when_ready
+        end
+     
+        def on_failure_res(session)
+          logd("Received failure response in #{name}")
+          if session.iresponse.get_request_method == "INVITE"
+            session.invalidate(true)
+          end
+        end
+        
+        def on_success_res(session)
+          logd("Received success response in #{name}")
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacCancel5Controller")
+  end
+  
+  
+  def test_cancel5_controllers
+    self.expected_flow = ["> INVITE", "< 100", "> CANCEL", "< 200", "< 487", "> ACK"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "< CANCEL", "> 200", "> 487", "< ACK"] 
+    verify_call_flow(:in)
+  end
+  
+end
+
+

data/sipper_test/test_cancel_with_nist.rb

@@ -0,0 +1,84 @@
+
+require 'driven_sip_test_case'
+
+# The client sends an INFO and after 183 gets a CANCEL and it gets responded to with a 200. 
+# Later the INFO also gets a 200. So CANCEL has not impact on INFO transaction.  
+
+class TestCancelWithNist < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module TestCancelWithNist_SipInline
+      class UasCancel4Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        
+        def on_info(session)
+          session.respond_with(183)
+          logd("Received INFO in #{name} sent a 183")
+          session['info_request'] = session.irequest
+        end
+        
+        def on_cancel(session)
+          r = session.create_response(200, "OK", session['info_request'])
+          session.send(r)
+          session.invalidate(true)
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacCancel4Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true  
+        
+        session_timer 300 
+        
+        def start
+          r = Request.create_initial("info", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          u.send(r)
+          logd("Sent a new INFO from #{name}")
+          u.create_and_send_cancel_when_ready
+        end
+     
+      
+        
+        def on_success_res(session)
+          logd("Received success response in #{name}")
+          if session.iresponse.get_request_method == "CANCEL"
+            session.do_record("200_CANCEL")
+          else
+            session.do_record("200_INFO")
+            session.invalidate(true)
+            session.flow_completed_for("TestCancelWithNist")
+          end
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("TestCancelWithNist_SipInline::UacCancel4Controller")
+  end
+  
+  
+  def test_cancel4_controllers
+    self.expected_flow = ["> INFO", "< 183", "> CANCEL", "< 200", "! 200_CANCEL", "< 200", "! 200_INFO"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INFO", "> 183", "< CANCEL", "> 200 {2,2}"] 
+    verify_call_flow(:in)
+  end
+ 
+  
+end
+
+

data/sipper_test/test_cancel_without487.rb

@@ -0,0 +1,77 @@
+
+require 'driven_sip_test_case'
+
+# The Client sends a CANCEL to INVITE but never gets the 487/INVITE, but it should still timeout
+# according to timer Y.
+# Note that there is no ACK here because the408 response is locally generated on transaction timeout
+# and ICT transaction is terminated. 
+
+class TestCancelWithout487 < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasCancel2Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>false
+        
+        def on_invite(session)
+          session.respond_with(100)
+          logd("Received INVITE in #{name} not doing anything")
+        end
+        
+        def on_cancel(session)
+          session.respond_with(200)
+          session.invalidate(true)
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacCancel2Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true  
+        transaction_timers :ty=>#{@grty*4}      
+        
+        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}")
+          u.create_and_send_cancel_when_ready
+        end
+     
+        def on_failure_res(session)
+          logd("Received failure response in #{name}")
+          session.invalidate(true)
+          session.flow_completed_for("TestCancelWithout487")  
+        end
+        
+        def on_success_res(session)
+          logd("Received success response in #{name}")
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacCancel2Controller")
+  end
+  
+  
+  def test_cancel1_controllers
+    self.expected_flow = ["> INVITE", "< 100", "> CANCEL", "< 200", "< 408"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "< CANCEL", "> 200"] 
+    verify_call_flow(:in)
+  end
+  
+end

data/sipper_test/test_command_element.rb

@@ -0,0 +1,38 @@
+
+require 'base_test_case'
+require 'util/command_element'
+require 'benchmark'
+
+class TestCommandElement < BaseTestCase
+
+  def setup
+    super
+  end
+  
+  def test_sleep 
+    c = SipperUtil::CommandElement.new("@sleep_ms 33")
+    assert_equal("@", c.direction)
+    assert_equal("sleep 0.033", c.command_str) # this is actual Ruby command
+  end
+  
+  def test_bad1
+    assert_raise(ArgumentError) { SipperUtil::CommandElement.new("<sleep_ms 33") }    
+  end
+  
+  def test_bad2
+    assert_raise(ArgumentError) { SipperUtil::CommandElement.new("@") }    
+  end
+  
+  def test_bad3
+    assert_raise(ArgumentError) { SipperUtil::CommandElement.new("@sleep_ms -33") }    
+  end
+  
+  def test_actual_sleep_execution
+    c = SipperUtil::CommandElement.new("@sleep_ms 500")
+    elapsed_time = Benchmark.realtime do 
+      eval c.command_str  
+    end
+    assert_in_delta(0.5, elapsed_time, 0.1)
+  end
+  
+end