Sipper 1.1.3

data/sipper_test/test_invite_replace.rb

@@ -0,0 +1,147 @@
+
+#                              Bob                      Bob
+#       Alice                  desk                     lab
+#        |                       |                        |
+#    *1  |-----INVITE----------->|                        |
+#    *2  |<----180---------------|  Bob hears desk phone  |
+#        |                       |  ringing from lab but  |
+#        |                       |  isn't REGISTERed yet  |
+#        |                       |                        |
+#        |                       |<--fetch dialog state --|
+#        |                       |---response ----------->|
+#   *3/4 |<-----INVITE with Replaces/200/ACK--------------|
+#   *5/6 |------CANCEL/200------>|                        |
+#   *7   |<-----487--------------|                        |
+#        |------ACK------------->|                        |
+#        |                       |                        |
+#        |                       |                        |
+
+require 'driven_sip_test_case'
+require 'custom_message'
+
+class TestInviteReplace < DrivenSipTestCase
+
+  def setup
+    SipperConfigurator[:ControllerPath] = nil
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module TestInviteReplace_SipInline
+      class BobLabAndDeskController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+       
+        session_timer 1500
+        
+        def interested?(req)
+          !req[:replaces]
+        end
+        
+        def on_invite(bob_session1)
+          bob_session1.name = "bob_session1"
+          bob_session1.respond_with(180)
+          bob_session2 = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          bob_session2.name = "bob_session2"
+          r = bob_session2.create_initial_request("invite", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+          r.replaces = bob_session1.call_id
+          r.replaces["from-tag"] = bob_session1.local_tag
+          r.replaces["to-tag"] = bob_session1.remote_tag
+          r.replaces["early-only"] = ''      
+          bob_session2.send(r)
+          logd("Sent a new Invite with replaces from " + name)  
+        end
+
+      
+        def on_success_res(bob_session2)
+          logd("Received response in "+name)
+          bob_session2.create_and_send_ack
+          bob_session2.invalidate(true)
+        end
+
+        def on_cancel(bob_session1)
+           logd("Received cancel request in #{name}")
+           bob_session1.invalidate(true)
+        end
+      end
+   
+      
+      
+      
+      class AliceController < SIP::SipTestDriverController
+        transaction_usage :use_transactions=>true        
+        session_timer 500
+        
+        
+        def interested?(req)
+          req[:replaces]
+        end
+        
+        def start
+          alice_session1 = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          alice_session1.name = "alice_session1"
+          alice_session1.request_with('INVITE', 'sip:nasir@sipper.com', :p_session_record=>"msg-info" )
+          logd("Sent a new Invite from " +name)
+        end
+     
+        def on_invite(alice_session2)
+          alice_session2.name = "alice_session2"
+          if alice_session2.irequest[:replaces] != nil
+             r = alice_session2.irequest
+             callid = r.replaces.header_value
+             localtag = r.replaces["to-tag"]
+             remotetag = r.replaces["from-tag"]
+             alice_session1 = SessionManager.find_session(callid, localtag, remotetag)
+             alice_session1.post_custom_message(CustomMessage.new)
+          end  
+          alice_session2.respond_with(200)
+        end
+        
+        def on_custom_msg(alice_session1, msg)
+          logd("Received Custom message in "+ name)
+          alice_session1.create_and_send_cancel_when_ready
+        end
+        
+        def on_failure_res(alice_session1)
+          logd("Received failure response in "+ name)
+          alice_session1.invalidate(true)
+        end
+
+        def on_ack(alice_session2)
+          logd("Received ACK in "+ name)
+          alice_session2.invalidate
+          alice_session2.flow_completed_for("TestInviteReplace")
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("TestInviteReplace_SipInline::AliceController")
+  end
+  
+  
+  def test_invite_replace
+    # alice_session1
+    self.expected_flow = ["> INVITE","< 100", "< 180", "> CANCEL", "< 200", "< 487", "> ACK"]
+    start_controller
+    verify_call_flow(:out, 0)
+
+
+    # bob_session1
+    self.expected_flow = ["< INVITE","> 100", "> 180", "< CANCEL", "> 200", "> 487", "< ACK"]
+    verify_call_flow(:in, 0)
+
+    # bob_session2
+    self.expected_flow = ["> INVITE", "< 100", "< 200", "> ACK"]
+    verify_call_flow(:out, 1)
+
+    # alice_session2
+    self.expected_flow = ["< INVITE", "> 100", "> 200", "< ACK"]
+    verify_call_flow(:in, 1)
+  end
+  
+end
+
+

data/sipper_test/test_invite_retransmission.rb

@@ -0,0 +1,90 @@
+
+require 'driven_sip_test_case'
+
+class TestInviteRetransmission < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    #----- Txn Handler--------
+    require 'transaction/state_machine_wrapper'
+
+    class IstTxnHandler
+    
+      def before_invite(txn)
+        def before_invite(txn)
+          SIP::Transaction::SM_PROCEED  
+        end
+        txn.__consume_msg(true)
+        SIP::Transaction::SM_PROCEED_NO_ACTION
+      end
+      
+    end
+    #------------------------
+    
+    
+    #------ Controllers -----
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasIstRetransController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        transaction_handlers :Ist=>IstTxnHandler
+
+        def on_invite(session)
+          logd("Received INVITE in #{name}")
+          session.do_record("First_Invite")
+          session.schedule_timer_for("sending_200", #{@grty*4})
+        end
+        
+        def on_timer(session, task)
+          logd("Timer invoked in #{name}")
+          session.respond_with(200)
+        end
+        
+        def on_ack(session)
+          session.invalidate(true)
+          session.flow_completed_for("TestInviteRetransmission")
+        end
+        
+        def order
+          0
+        end
+      end
+      
+      class UacIstRetransController < SIP::SipTestDriverController
+        transaction_usage :use_transactions=>true    
+        transaction_timers :t1=>#{@grty*2}  
+        
+        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.create_and_send_ack    
+          session.invalidate(true)  
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacIstRetransController")
+  end
+  
+  
+  def test_invite_retrans
+    self.expected_flow = ["> INVITE {2,}",  "< 200", "> ACK"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "! First_Invite", "< INVITE {0,}", "> 200", "< INVITE {0,}",  "< ACK"]
+    verify_call_flow(:in)
+  end
+  
+end

data/sipper_test/test_invite_server_transaction.rb

@@ -0,0 +1,208 @@
+require 'sip_test_case'
+require 'transaction/invite_server_transaction'
+require 'request'
+require 'response'
+require 'sipper_configurator'
+require 'util/locator'
+require 'transport/rel_unrel'
+require 'transaction_test_helper'
+
+
+class TestInviteServerTransaction < SipTestCase
+
+  def setup
+    super
+    @t = SipMockTester::MockTimeTransport.new
+    @tu = SipMockTester::Tu.new
+  end
+  
+  def test_initial_state
+    ist = SIP::Transaction::InviteServerTransaction.new(@tu, nil, nil, @t, nil)
+    assert_equal("IstMap.Initial", ist.state)
+  end
+
+  # invite in initial state  
+  def test_invite_initial
+    ist = SIP::Transaction::InviteServerTransaction.new(@tu, nil, nil, @t, nil)
+    ist.txn_received SipMockTester::MockRequest.new("INVITE")
+    assert_equal("IstMap.Proceeding", ist.state)
+    assert_equal(1, @t.msg.length)
+    assert(ist.consume?)
+  end
+    
+  # sending provisional in proceeding  
+  def test_proceeding_provisional
+    ist = SIP::Transaction::InviteServerTransaction.new(@tu, nil, nil, @t, nil)
+    ist.txn_received SipMockTester::MockRequest.new("INVITE")  # now in proceeding
+    r = SipMockTester::MockResponse.new(180)
+    ist.txn_send r
+    assert_equal("IstMap.Proceeding", ist.state)
+    assert_equal(2, @t.msg.length)
+  end
+  
+  # invite comes in proceeding after just 100 trying being sent
+  def test_proceeding_invite1
+    t = SipMockTester::MockMsgTransport.new
+    ist = SIP::Transaction::InviteServerTransaction.new(@tu, nil, nil, t, nil)
+    i = SipMockTester::MockRequest.new("INVITE")  
+    ist.txn_received(i)   # now in proceeding
+    assert(ist.consume?)
+    ist.txn_received(i)   # invite retrasmission
+    assert(!ist.consume?)
+    assert_equal(2, t.msg.length)
+    t.msg.each {|m|  assert_match(/100/, m) }
+  end
+  
+  # invite retrans comes in proceeding after 100 and 180 being sent
+  def test_proceeding_invite1
+    ist, t, i = _send_initial_invite_with_msg_transport
+    assert(ist.consume?)
+    r = SipMockTester::MockResponse.new(180)
+    ist.txn_send r
+    ist.txn_received(i)   # invite retrasmission
+    assert(!ist.consume?)
+    assert_equal(3, t.msg.length)
+    assert_match(/100/, t.msg[0])
+    assert_equal(180, t.msg[1])
+    assert_equal(180, t.msg[2])
+  end
+  
+  def test_success_final_proceeding_finished
+    ist, t, i = _send_initial_invite_with_msg_transport
+    ist.tz = 100
+    r = SipMockTester::MockResponse.new(200)
+    ist.txn_send r # should now be in Finished state
+    assert_equal("IstMap.Finished", ist.state)
+    ist.txn_received(i)
+    assert(!ist.consume?)
+    c = SipMockTester::MockRequest.new("CANCEL")
+    ist.cancel_received(c, nil)
+    assert(ist.consume?)
+    sleep 0.2
+    assert_equal("IstMap.Terminated", ist.state)
+  end
+  
+  # note: the timers are set to defaults, even if the timers are fired during the 
+  # course of the test the message will be retransmitted by this isolated Txn to
+  # the isolated transport here. 
+  def test_non_sucess_final_proceeding
+    ist, t, i = _send_initial_invite_with_msg_transport
+    r = SipMockTester::MockResponse.new(400)
+    ist.txn_send r # should now be in Completed state
+    assert_equal("IstMap.Completed", ist.state)
+    ist.txn_received(i)
+    assert(!ist.consume?)
+    assert_equal(3, t.msg.length)
+    assert_match(/100/, t.msg[0])
+    assert_equal(400, t.msg[1])
+    assert_equal(400, t.msg[2])
+  end
+  
+  
+  def test_non_success_final_with_timers_proceeding
+    ist, t, i = _send_initial_invite_with_msg_transport
+    ist.tg = 50
+    ist.th = 1000
+    ist.t4 = 200
+    r = SipMockTester::MockResponse.new(400)
+    ist.txn_send r # should now be in Completed state
+    assert_equal("IstMap.Completed", ist.state)
+    assert_equal(2, t.msg.length)
+    assert_match(/100/, t.msg[0])
+    assert_equal(400, t.msg[1])
+    sleep 0.5    # next retrans at min(150*2, 200) t=350 
+    #assert_equal(5, t.msg.length)
+    assert_equal(400, t.msg[2])
+    assert_equal(400, t.msg[3])
+    assert_equal(400, t.msg[4])
+    sleep 1  # timer H should have fired by now. 
+    assert_equal("IstMap.Terminated", ist.state)
+  end
+  
+  def test_cancel_proceeding
+    ist, t, i = _send_initial_invite_with_msg_transport
+    c = SipMockTester::MockRequest.new("CANCEL")  
+    ist.cancel_received(c, nil)
+    assert(ist.consume?)
+    assert_equal(2, t.msg.length)
+    assert_match(/100/, t.msg[0])
+    assert_match(/487/, t.msg[1])
+    assert_equal("IstMap.Completed", ist.state)
+  end
+  
+  def test_ack
+    ist, t, i = _send_initial_invite_with_msg_transport
+    r = SipMockTester::MockResponse.new(400)
+    ist.txn_send r # should now be in Completed state
+    a = SipMockTester::MockRequest.new("ACK")  
+    ist.txn_received(a)
+    assert(!ist.consume?)
+    assert_equal("IstMap.Confirmed", ist.state)
+  end
+  
+  def test_completed_invite
+    ist, t, i = _send_initial_invite_with_msg_transport
+    r = SipMockTester::MockResponse.new(400)
+    ist.txn_send r # should now be in Completed state
+    ist.txn_received(i)
+    assert_equal(3, t.msg.length)
+    assert_match(/100/, t.msg[0])
+    assert_equal(400, t.msg[1])
+    assert_equal(400, t.msg[2])
+    assert(!ist.consume?)
+    a = SipMockTester::MockRequest.new("ACK")  
+    ist.txn_received(a)
+    assert(!ist.consume?)
+    assert_equal("IstMap.Confirmed", ist.state)
+  end
+  
+
+  def test_confirmed_with_timer_I
+    ist, t, i = _send_initial_invite_with_msg_transport
+    r = SipMockTester::MockResponse.new(400)
+    ist.txn_send r # should now be in Completed state
+    a = SipMockTester::MockRequest.new("ACK")  
+    ist.ti = 100
+    ist.txn_received(a)
+    assert_equal("IstMap.Confirmed", ist.state)
+    ist.txn_received(i)
+    assert(!ist.consume?)
+    sleep 0.5  # though timer I is 100, we sleep for more to eotsoc
+    assert_equal(3, t.msg.length)
+    assert_match(/100/, t.msg[0])
+    assert_equal(400, t.msg[1])
+    assert_equal(400, t.msg[2])
+    assert_equal("IstMap.Terminated", ist.state)
+  end
+  
+  def test_wrong_state
+    t = SipMockTester::MockMsgTransport.new
+    ist = SIP::Transaction::InviteServerTransaction.new(@tu, nil, nil, t, nil)
+    i = SipMockTester::MockRequest.new("INVITE")  
+    ist.txn_received(i)   # now in proceeding
+    r = SipMockTester::MockResponse.new(400)
+    ist.txn_send r # should now be in Completed state
+    assert_nil(@tu.txn)
+    ist.txn_send r  # illegal to send a new response from here
+    assert_equal(ist, @tu.txn)
+    @tu.txn = nil
+    a = SipMockTester::MockRequest.new("ACK")  
+    ist.txn_received(a)
+    assert_equal("IstMap.Confirmed", ist.state)
+    ist.txn_received(a)
+    assert_nil(@tu.txn)
+    ist.txn_send r  # illegal to send a new response from here
+    assert_equal(ist, @tu.txn)
+  end
+  
+  
+  def _send_initial_invite_with_msg_transport
+    t = SipMockTester::MockMsgTransport.new
+    ist = SIP::Transaction::InviteServerTransaction.new(@tu, nil, nil, t, nil)
+    i = SipMockTester::MockRequest.new("INVITE")  
+    ist.txn_received(i)   # now in proceeding
+    [ist, t, i]
+  end
+  
+  private :_send_initial_invite_with_msg_transport
+end

data/sipper_test/test_lower_cseq.rb

@@ -0,0 +1,79 @@
+
+require 'driven_sip_test_case'
+
+
+class TestLowerCseq < DrivenSipTestCase
+
+  def setup
+    @orig_compliance = SipperConfigurator[:ProtocolCompliance]
+    SipperConfigurator[:ProtocolCompliance]='strict'
+    super
+    str = <<-EOF
+   
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasLowerCseqController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        session_timer #{@grty*5}
+        
+        def on_invite(session)
+          session.respond_with(200)
+        end
+        
+        def on_ack(session)
+          session.invalidate
+          session.flow_completed_for("TestLowerCseq")
+        end
+        
+        def order
+          0
+        end
+      end
+      
+      class UacLowerCseqController < SIP::SipTestDriverController
+
+        transaction_usage :use_transactions=>false
+
+        def start
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          u.request_with("invite", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+          logd("Sent a new INVITE from "+name)
+        end
+     
+        def on_success_res(session)
+          session.request_with('ack') 
+          logd("sent ACK now creating an INVITE")
+          r = session.create_subsequent_request("invite")
+          r.cseq = "1 INVITE" 
+          session.send(r)      
+        end
+        
+        def on_failure_res(session)
+          session.request_with("ack")
+          session.invalidate(true)
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacLowerCseqController")
+  end
+  
+  
+  def test_reinvite
+    self.expected_flow = ["> INVITE", "< 100", "< 200", "> ACK", "> INVITE", "< 100","< 500", "> ACK"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "> 200", "< ACK", "< INVITE", "> 100","> 500", "< ACK"]
+    verify_call_flow(:in)
+  end
+  
+  def teardown
+    SipperConfigurator[:ProtocolCompliance] = @orig_compliance
+    super
+  end
+  
+end