Sipper 1.1.3

data/sipper_test/test_multiple_contacts.rb

@@ -0,0 +1,89 @@
+
+require 'driven_sip_test_case'
+
+
+class TestMultipleContacts < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasMcController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        
+        def on_invite(session)
+          session.do_record(session.irequest.contacts[0])
+          session.do_record(session.irequest.contacts[1])
+          r = session.create_response(200)
+          r.contact = "sip:xyz@sipper.com"
+          r.contact.expires='500'
+          r.add_contact("mailto:xyz@sipper.com")
+          r.contacts[1].expires='400'
+          session.send r
+          logd("Received INVITE sent a 200 from "+name)
+        end
+        
+        def on_ack(session)
+          session.request_with("bye")
+        end
+        
+        def on_success_res(session)
+          session.invalidate(true)
+          session.flow_completed_for("TestMultipleContacts")
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacMcController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true  
+        
+        def start
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          r = u.create_initial_request("invite", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+          r.contact = "sip:abc@sipper.com"
+          r.contact.expires="500"
+          r.add_contact("<mailto:abc@sipper.com>;expires=400")
+
+          r.sdp = SDP::SdpGenerator.make_no_media_sdp
+          u.send(r)
+          logd("Sent a new INVITE from "+name)
+        end
+     
+        
+        def on_success_res(session)
+          session.do_record(session.iresponse.contacts[0])
+          session.do_record(session.iresponse.contacts[1])
+          session.request_with('ACK')
+        end
+        
+        def on_bye(session)
+          session.respond_with(200)
+          session.invalidate(true)
+        end
+         
+      end
+    end
+    EOF
+    define_controller_from(str)
+  end
+  
+  
+  def test_smoke_controllers
+    start_named_controller("SipInline::UacMcController")
+    self.expected_flow = ["> INVITE", "< 100", "< 200", "! <sip:xyz@sipper.com>;expires=500","! <mailto:xyz@sipper.com>;expires=400",  "> ACK", "< BYE", "> 200"]
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "! <sip:abc@sipper.com>;expires=500","! <mailto:abc@sipper.com>;expires=400", "> 200", "< ACK", "> BYE", "< 200"]
+    verify_call_flow(:in)
+  end
+
+  
+end

data/sipper_test/test_non2xx_retransmission_with_ist.rb

@@ -0,0 +1,87 @@
+
+require 'driven_sip_test_case'
+
+# On INVITE send a 4xx response and the UAC Ctx shall send an automatic ACK
+# this ACK is dropped because of a specialized transport filter and so UAS
+# shall retransmist the 4xx response on Timer G. This time the ACK generated 
+# by the UAC Ctx (ACK retransmission) is duly received at the UAS and the test 
+# ends. 
+class TestNon2xxRetransmissionWithIst < DrivenSipTestCase
+
+  def setup
+    super
+    Transport::BaseTransport.clear_all_filters
+    str = <<-EOF
+    
+    #-------- Transport Filters------------
+    
+    require 'transport/base_transport'
+    module TransportHandlerForTestNon2xxModule
+      class MyInTransportHandler < Transport::TransportIngressFilter
+        def do_filter(msg)
+          if msg =~ /ACK/
+            # redefine the method
+            def do_filter(msg)
+              msg
+            end
+            return nil
+          else
+            msg
+          end
+        end  
+      end
+    end
+    
+    
+    #--------- Controllers ---------------
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasNon2xxController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        transaction_timers :t1=>#{@grty*2} 
+        session_timer #{@grty*10} 
+        
+        def on_invite(session)
+          logd("Received INVITE in #{name}")
+          session.respond_with(404)
+          session.invalidate
+          session.flow_completed_for("TestNon2xxRetransmissionWithIst")
+        end
+        
+        
+        def order
+          0
+        end
+      end
+      
+      class UacNon2xxController < SIP::SipTestDriverController
+        transaction_usage :use_transactions=>true        
+        session_timer #{@grty*8} 
+        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.invalidate
+        end
+          
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacNon2xxController")
+  end
+  
+  
+  def test_2xx_retransmissions
+    self.expected_flow = ["> INVITE","< 100", "< 404", "> ACK", "< 404", "> ACK"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "> 404 {2,2}", "< ACK"]
+    verify_call_flow(:in)
+  end
+  
+end

data/sipper_test/test_non_invite_client_transaction.rb

@@ -0,0 +1,210 @@
+
+require 'sip_test_case'
+require 'transaction/non_invite_client_transaction'
+require 'request'
+require 'response'
+require 'sipper_configurator'
+require 'util/locator'
+require 'transport/rel_unrel'
+require 'transaction_test_helper'
+
+# SipTestCase because it starts sipper.
+class TestNonInviteClientTransaction < SipTestCase
+  
+  def setup
+    super
+    @t = SipMockTester::MockTimeTransport.new
+    @tu = SipMockTester::Tu.new
+  end
+  
+  
+  def test_initial_state
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, nil, @t, nil)
+    assert_equal("NictMap.Initial", nict.state)
+  end
+  
+  
+  # default timer E is 500 ms
+  def test_default_timerE
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, nil, @t, nil)
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    sleep 5  
+    _assert_deltas(@t, 500, 4)  
+  end
+  
+  def test_override_T1
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, nil, @t, nil)
+    nict.t1 = @grty*2
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    sleep((@grty*200)/1000.0)  # 2 sec for 50 msec grty
+    _assert_deltas(@t, @grty*2, 4)
+  end
+  
+
+  def test_timerE_F
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, nil, @t, nil)
+    nict.t1 = @grty*2  
+    nict.t2 = @grty*4  
+    nict.tf = @grty*25 
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    assert_equal("NictMap.Trying", nict.state)
+    sleep((@grty*35)/1000.0)  # 1.5 secs
+    assert(@t.msg.length >= 6) # at least 6 
+    assert_equal("NictMap.Terminated", nict.state) # as timer F would have fired by now
+  end
+  
+  
+  def test_provisional
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, nil, @t, nil)
+    nict.t1 = @grty*2 
+    nict.t2 = @grty*10  
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    nict.txn_received SipMockTester::MockResponse.new(100)
+    assert_equal(1, @t.msg.length) 
+    assert_equal("NictMap.Proceeding", nict.state)
+    assert(nict.consume?)
+    sleep((@grty*18)/1000.0)
+    assert_equal(3, @t.msg.length) 
+    # now once in proceeding state a provisional should keep you here
+    nict.txn_received SipMockTester::MockResponse.new(100)
+    assert_equal("NictMap.Proceeding", nict.state)
+    assert(nict.consume?)
+  end
+  
+  def test_timerF_with_reliable
+    @t.extend(SIP::Transport::ReliableTransport)
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, nil, @t, nil)
+    nict.t1 = @grty #50
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    sleep((@grty*70)/1000.0)
+    assert_equal(1, @t.msg.length)
+  end
+  
+  
+  def test_final_in_trying
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, nil, @t, nil)
+    nict.t1 = @grty*2 #100
+    nict.tk = @grty*20 #1000
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    nict.txn_received SipMockTester::MockResponse.new(200)
+    assert(nict.consume?)
+    sleep((@grty*4)/1000.0)  # see after twice timer E
+    assert_equal(1, @t.msg.length)  # no retrans
+    assert_equal("NictMap.Completed", nict.state)
+    nict.txn_received SipMockTester::MockResponse.new(200) # a 2xx retrans
+    assert(!nict.consume?)
+    assert_equal("NictMap.Completed", nict.state)
+    sleep((@grty*20)/1000.0) # sleep one full sec
+    assert_equal("NictMap.Terminated", nict.state)
+  end
+
+  def test_final_in_proceeding
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, nil, @t, nil)
+    nict.t1 = @grty*2 #100
+    nict.tk = @grty*20 #1000
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    nict.txn_received SipMockTester::MockResponse.new(100)
+    assert(nict.consume?)
+    assert_equal("NictMap.Proceeding", nict.state)
+    sleep((@grty*4)/1000.0)  # see after twice timer E
+    assert(@t.msg.length>1)  # some retrans
+    nict.txn_received SipMockTester::MockResponse.new(200)
+    msg_so_far = @t.msg.length
+    assert(nict.consume?)
+    sleep((@grty*4)/1000.0)  # see further after twice timer E
+    assert_equal(msg_so_far, @t.msg.length)  # no further retrans
+    assert_equal("NictMap.Completed", nict.state)
+    nict.txn_received SipMockTester::MockResponse.new(200) # a 2xx retrans
+    assert(!nict.consume?)
+    sleep((@grty*4)/1000.0)  # see further after twice timer E
+    assert_equal(msg_so_far, @t.msg.length)  # no further retrans
+    assert_equal("NictMap.Completed", nict.state)
+    sleep((@grty*15)/1000.0) # sleep further till termination
+    assert_equal("NictMap.Terminated", nict.state)
+  end
+
+
+  def test_trans_exception1
+    tu = SipMockTester::Tu.new
+    t = SipMockTester::ExceptionalTransportOnNthAttempt.new(1)
+    nict = SIP::Transaction::NonInviteClientTransaction.new(tu, nil, nil, t, nil)
+    assert_equal("NictMap.Initial", nict.state)
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    assert_equal("NictMap.Terminated", nict.state)
+    assert_equal(nict, tu.txn)
+  end
+  
+  def test_trans_exception2
+    tu = SipMockTester::Tu.new
+    t = SipMockTester::ExceptionalTransportOnNthAttempt.new(2)
+    nict = SIP::Transaction::NonInviteClientTransaction.new(tu, nil, nil, t, nil)
+    nict.te = @grty*2
+    assert_equal("NictMap.Initial", nict.state)
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    assert_equal("NictMap.Trying", nict.state)
+    assert_nil(tu.txn)
+    sleep((@grty*4)/1000.0)  # sleep twice timer E 
+    assert_equal("NictMap.Terminated", nict.state)
+    assert_equal(nict, tu.txn)
+  end
+  
+
+  # default, proceed with no change
+  def test_txn_handler1
+    tcbh = SipMockTester::Tcbh1.new
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, tcbh, @t, nil)
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    assert_equal("NictMap.Trying", nict.state)
+    assert_equal("NictMap.Initial", tcbh.states[0])  # before
+    assert_equal("NictMap.Trying", tcbh.states[1])   # after
+    assert_equal(1, @t.msg.length)   
+  end
+  
+  
+  # state change but no action masker
+  def test_txn_handler2
+    tcbh = SipMockTester::Tcbh2.new
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, tcbh, @t, nil)
+    nict.txn_send SipMockTester::MockRequest.new("MESSAGE")
+    assert_equal("NictMap.Trying", nict.state)
+    assert_equal(0, @t.msg.length)   
+  end
+  
+  # do not proceed
+  def test_txn_handler3
+    tcbh = SipMockTester::Tcbh3.new
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, tcbh, @t, nil)
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    assert_equal("NictMap.Initial", nict.state)
+    assert_equal(0, @t.msg.length)   
+    assert(tcbh.txn.is_a?(SIP::Transaction::NonInviteClientTransaction))
+  end
+  
+  # illegal state test
+  def test_txn_handler4
+    tcbh = SipMockTester::Tcbh4.new
+    nict = SIP::Transaction::NonInviteClientTransaction.new(@tu, nil, tcbh, @t, nil)
+    nict.txn_send SipMockTester::MockRequest.new("INFO")
+    assert_equal("NictMap.Trying", nict.state)
+    assert_equal(1, @t.msg.length)
+    assert_nil(tcbh.txn)
+    nict.txn_send SipMockTester::MockRequest.new("MESSAGE") # you cannot send a request in Calling.    
+    assert(tcbh.txn.is_a?(SIP::Transaction::NonInviteClientTransaction))
+    assert_equal("NictMap.Trying", nict.state)    
+  end
+  
+  def _assert_deltas(t, delta, times)
+    1.upto(times-1) do |x|
+      # as it is +/- for both timers, and allowing for an error factor of 1 so 3.0
+      assert_in_delta(t.msg[x-1]+delta, t.msg[x], SIP::Locator[:Sth].granularity * 3.0)  # as it is +/- for both timers
+      delta *= 2
+    end
+  rescue Test::Unit::AssertionFailedError
+    t.msg.each {|m| print "#{m},"}
+    puts
+    raise
+  end
+  
+  private :_assert_deltas
+end
+

data/sipper_test/test_non_invite_retransmission.rb

@@ -0,0 +1,91 @@
+
+require 'driven_sip_test_case'
+
+class TestNonInviteRetransmission < DrivenSipTestCase
+
+  def setup_once
+    super
+    tid = nil
+    str = <<-EOF
+    
+    #----- Txn Handler--------
+    require 'transaction/state_machine_wrapper'
+
+    
+    class NistTxnHandler
+         
+      def before_request(txn)
+        txn.__consume_msg(true)
+        SIP::Transaction::SM_PROCEED_NO_ACTION
+      end
+      
+    end
+    #------------------------
+    
+    
+    #------ Controllers -----
+    require 'sip_test_driver_controller'
+    module SipInline
+    
+      class UasNist1Controller < SIP::SipTestDriverController
+      
+        transaction_usage    :use_transactions=>true
+        transaction_handlers :Nist=>NistTxnHandler
+        
+        def on_info(session)
+          if tid = session['nist_txn_id']
+            if tid == session.irequest.transaction.object_id
+              logd("Received INFO in #{name} sending 200 with txn " + tid.to_s)
+              session.respond_with(200) 
+            else
+              session.do_record("Error")
+              logd("Received INFO in #{name} txn is not correct " + tid.to_s)
+            end
+            session.invalidate(true)
+          else
+            session['nist_txn_id'] = session.irequest.transaction.object_id
+            logd("Received INFO in #{name} saving txn_id " + session['nist_txn_id'].to_s )
+          end
+        end
+        
+        
+        def order
+          0
+        end
+         
+      end
+      
+      class UacNict1Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        
+        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}")
+        end
+    
+        
+        def on_success_res(session)
+          logd("Received response in #{name}")
+          session.invalidate(true)
+          session.flow_completed_for("TestNonInviteRetransmission")
+        end  
+      end 
+      
+    end
+    EOF
+    define_controller_from(str)
+  end
+  
+  
+  def test_nict_retrans
+    self.expected_flow = ["> INFO {2,}", "< 200"]
+    start_named_controller("SipInline::UacNict1Controller")
+    verify_call_flow(:out)
+    self.expected_flow = ["< INFO {2,}", "> 200"]  # one retrans
+    verify_call_flow(:in)
+  end
+  
+end