Sipper 1.1.3

data/sipper_test/test_b2bua4.rb

@@ -0,0 +1,130 @@
+
+require 'driven_sip_test_case'
+require 'sdp/sdp_generator'
+
+class TestB2bua4 < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    require 'b2bua_controller'
+    
+    module SipInline
+      class UasB2bua4Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        
+        def on_invite(session)
+          session.name = "uas"
+          r = session.create_response(200)
+          r.sdp = SDP::SdpGenerator.make_no_media_sdp
+          session.send(r)
+          logd("Received INVITE sent a 200 from "+name)
+        end
+        
+        def on_ack(session)
+        end
+        
+        def on_bye(session)
+          session.respond_with(200)
+          session.invalidate(true)
+        end
+        
+        
+        def order
+          1
+        end
+        
+        def interested?(req)
+          req.p_controller == "uas"
+        end
+        
+      end
+      
+      
+      class TestB2bua4Controller < SIP::B2buaController
+      
+        transaction_usage :use_transactions=>true
+        
+        def on_invite(session)
+          session.name = "b2buas"
+          peer = get_or_create_peer_session(session, SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          peer.name = "b2buac"
+          r = create_b2bua_request(session)
+          r.p_controller = "uas"
+          r.p_session_record = nil
+          peer.send r
+        end
+
+
+        def on_success_res(session)
+          relay_response(session)
+          if session.iresponse.get_request_method == "BYE"
+            invalidate_sessions(session, true)
+          end
+        end
+
+        def on_ack(session)
+          relay_request(session)
+        end
+        
+        def on_bye(session)
+          relay_request(session)
+        end
+        
+        def interested?(req)
+          req.p_controller == "b2bua"
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      
+      class UacB2bua4Controller < 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.name = "uac"
+          r.p_controller = "b2bua"
+          u.send(r)
+          logd("Sent a new INVITE from "+name)
+        end
+     
+        
+        def on_success_res_for_invite(session)
+          session.request_with('ACK')
+          session.request_with('BYE')
+        end
+        
+        def on_success_res_for_bye(session)
+          session.invalidate(true)
+          session.flow_completed_for("TestB2bua4")
+        end
+       
+         
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacB2bua4Controller")
+  end
+  
+  
+  def test_b2bua4
+    self.expected_flow = ["> INVITE", "< 100", "< 200", "> ACK", "> BYE", "< 200"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "> 200", "< ACK", "< BYE", "> 200"]
+    verify_call_flow(:in)
+  end
+  
+  
+end

data/sipper_test/test_base_controller.rb

@@ -0,0 +1,110 @@
+require 'sip_test_case'
+require 'base_controller'
+require 'test_controllers/test_controller'
+require 'flexmock'
+
+class TestBaseController < SipTestCase
+  include FlexMock::TestCase
+  def setup
+    @bc = SIP::BaseController.new
+    @tc = TestController.new
+    super
+  end
+  
+  
+  def test_sol
+    assert( !SIP::BaseController.start_on_load? )
+    assert( TestController.start_on_load? )
+  end
+  
+  def test_name
+    assert_equal("SIP::BaseController", @bc.name)
+    assert_equal("TestController", @tc.name)
+  end
+
+  def test_log
+    assert_nothing_raised {
+      @bc.logd("Print logs")
+      @bc.logi("Print logs")
+      @bc.logw("Print logs")
+      @bc.loge("Print logs")
+      @bc.logf("Print logs")
+    }
+    assert_nothing_raised {
+      @tc.logd("Print logs")
+      @tc.logi("Print logs")
+      @tc.logw("Print logs")
+      @tc.loge("Print logs")
+      @tc.logf("Print logs")
+    }
+  end
+  
+  def test_start
+    assert !@bc.start
+    ret = @tc.start
+    assert(ret.nil? || ret)
+  end
+  
+  def test_response
+    r = FlexMock.new
+    r.should_receive(:code).and_return(100)
+    s = FlexMock.new
+    s.should_receive(:iresponse).and_return(r)
+    r.should_receive(:get_request_method).and_return("invite")
+    @bc.extend(SipperUtil::WrapExtender)
+    assert_equal("SIP::BaseController", SipperUtil::WrapExtender.last_class( @bc.on_response(s) ))
+    @tc.extend(SipperUtil::WrapExtender)
+    assert_equal("SIP::BaseController", SipperUtil::WrapExtender.last_class( @tc.on_response(s) )) 
+    # reset mocks to return 200
+    r = FlexMock.new
+    r.should_receive(:code).and_return(200)
+    s = FlexMock.new
+    s.should_receive(:iresponse).and_return(r)
+    assert_equal("TestController", SipperUtil::WrapExtender.last_class( @tc.on_response(s) )) 
+  end
+      
+  def test_request
+    r = FlexMock.new
+    r.should_receive(:method).and_return("INFO")
+    s = FlexMock.new
+    s.should_receive(:irequest).and_return(r)
+    s.should_receive(:call_id).and_return("my_call_id")
+    assert(!@tc.on_request(s))
+    r = FlexMock.new
+    r.should_receive(:method).and_return("INVITE")
+    s = FlexMock.new
+    s.should_receive(:irequest).and_return(r)
+    s.should_receive(:call_id).and_return("my_call_id")
+    ret = @tc.on_request(s)
+    assert(ret.nil? || ret)
+  end
+      
+  def test_interested
+    r = FlexMock.new
+    r.should_receive(:method).and_return("INFO")
+    assert(! @bc.interested?(r) )
+    assert(! @tc.interested?(r) )
+    r = FlexMock.new
+    r.should_receive(:method).and_return("INVITE")
+    assert(! @bc.interested?(r) )
+    assert( @tc.interested?(r) )
+  end
+  
+  def test_transaction_settings
+    s = @tc.get_test_session
+    assert(!s.use_ict)
+    assert(s.use_nict)
+    assert(!s.use_ist)
+    assert(s.use_nist)
+    s.set_transaction_timers(:Ict, :tb=>32000, :t2=>300)
+  end
+  
+  def teardown
+    super
+    load 'base_controller.rb'
+    load File.join('test_controllers', 'test_controller.rb')
+  end
+  
+end
+
+

data/sipper_test/test_base_transport.rb

@@ -0,0 +1,37 @@
+require 'base_test_case'
+require 'transport/base_transport'
+
+class TestBaseTransport < BaseTestCase
+ 
+  def setup
+    super
+    require 'transport_filters'
+  end
+  
+  def test_filters
+    in_filters = Transport::BaseTransport.in_filters
+    assert_equal(2, in_filters.length)
+    out_filters = Transport::BaseTransport.out_filters
+    assert_equal(2, out_filters.length)
+    Transport::BaseTransport.in_order = ["InTransportHandler1", "InTransportHandler2"]
+    in_filters = Transport::BaseTransport.in_filters
+    msg = "_a__b_"
+    msg = in_filters[0].do_filter(msg)
+    assert_equal("1_b_", msg)
+    msg = in_filters[1].do_filter(msg)
+    assert_equal("12", msg)
+    
+    Transport::BaseTransport.out_order = ["OutTransportHandler1", "OutTransportHandler2"]
+    out_filters = Transport::BaseTransport.out_filters
+    msg = "_a__b_"
+    msg = out_filters[0].do_filter(msg)
+    assert_equal("1_b_", msg)
+    msg = out_filters[1].do_filter(msg)
+    assert_equal("12", msg)
+  end
+  
+  def cleanup
+    Transport::BaseTransport.clear_all_filters
+  end
+  
+end

data/sipper_test/test_cancel.rb

@@ -0,0 +1,21 @@
+
+require 'driven_sip_test_case'
+
+class TestCancel < DrivenSipTestCase
+   
+  def setup
+    SipperConfigurator[:ControllerPath] = File.join(SipperConfigurator[:SipperBasePath], "sipper_test", "test_controllers", "cancel")
+    super
+  end
+  
+  def test_cancel
+    #set_controller("CancelCase::UacCancelController") 
+    self.expected_flow = ["> INVITE {1,}", "! Exception_while_sending_CANCEL", "> INVITE {0,}", "< 100", "> CANCEL", "< 200"]
+    start_named_controller("CancelCase::UacCancelController")
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE {1,}", "> 100", "< CANCEL", "> 200"]
+    verify_call_flow(:in)
+  end
+  
+end
+

data/sipper_test/test_cancel_after2xx.rb

@@ -0,0 +1,81 @@
+
+require 'driven_sip_test_case'
+
+# The Client sends a CANCEL to INVITE after a 2xx response. lax setting required for this.
+#  The UAS does not use transactions so no 481 response will be sent. 
+
+class TestCancelAfter2xx < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasCancel3Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>false
+        
+        def on_invite(session)
+          session.respond_with(200)
+          logd("Received INVITE in #{name} sent a 200")
+        end
+        
+        def on_cancel(session)
+          session.respond_with(200)
+          session.invalidate(true)
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacCancel3Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true  
+        transaction_timers :ty=>150      
+        session_timer 300 
+        
+        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}")
+          u.create_and_send_cancel_when_ready
+        end
+     
+        def on_failure_res(session)
+          logd("Received failure response in #{name}")
+          session.do_record("FAILURE 408 is not expected here")
+        end
+        
+        def on_success_res(session)
+          logd("Received success response in #{name}")
+          if session.iresponse.get_request_method == "CANCEL"
+            session.invalidate(true)
+            session.flow_completed_for("TestCancelAfter2xx")
+          end
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacCancel3Controller")
+  end
+  
+  
+  def test_cancel3_controllers
+    self.expected_flow = ["> INVITE", "< 200", "> CANCEL", "< 200"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 200", "< CANCEL", "> 200"] 
+    verify_call_flow(:in)
+  end
+  
+end
+

data/sipper_test/test_cancel_retransmission.rb

@@ -0,0 +1,105 @@
+
+require 'driven_sip_test_case'
+
+# The Client sends a CANCEL to INVITE, the server is using both IST and NIST and though sends
+# a 487/INVITE, does not sent a 200/CANCEL forcing retransmissions for CANCEL alone.
+
+class TestCancelRetransmission < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    #----- Txn Handler--------
+    require 'transaction/state_machine_wrapper'
+
+    
+    class NistTxnHandler
+         
+      def before_cancel_with_st(txn)
+        txn.__consume_msg(true)
+        SIP::Transaction::SM_PROCEED_NO_ACTION
+      end
+      
+    end
+    #------------------------
+    
+    
+    #------ Controllers -----
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasCancel6Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        transaction_handlers :Nist=>NistTxnHandler
+             
+        def on_cancel(session)
+          tid = nil
+          if tid = session['cancel_txn_id']
+            if tid == session.irequest.transaction.object_id
+              logd("Received CANCEL in #{name} sending 200 with txn")
+              session.respond_with(200) 
+            else
+              session.do_record("Error")
+              logd("Received CANCEL in #{name} txn is not correct")
+            end
+            session.invalidate(true)
+          else
+            session['cancel_txn_id'] = session.irequest.transaction.object_id
+            logd("Received CANCEL in #{name} saving txn_id")
+          end
+        end
+        
+        
+        def on_invite(session)
+        end
+        
+        
+        
+        def order
+          0
+        end
+        
+      end
+      
+      
+      class UacCancel6Controller < 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_success_res(session)
+          logd("Received success response in #{name}")
+          session.invalidate
+          session.flow_completed_for("TestCancelRetransmission")
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacCancel6Controller")
+  end
+  
+  
+  def test_cancel6_controllers
+    self.expected_flow = ["> INVITE", "< 100", "> CANCEL", "< 487", "> ACK", "> CANCEL", "< 200"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "< CANCEL", "> 487", "< CANCEL {0,}", "> 200 {0,}","< ACK", "< CANCEL {0,}", "> 200"] 
+    verify_call_flow(:in)
+  end
+  
+end
+
+