Sipper 1.1.3

data/sipper_test/test_validations.rb

@@ -0,0 +1,69 @@
+
+require 'driven_sip_test_case'
+
+class TestValidations < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    require 'sip_test_driver_controller'
+    module SipInline
+      class UasValidationsController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        
+        def on_invite(session)
+          logd("Received INVITE in "+name)
+          r = session.create_response(200, "OK") 
+          r.test_header = "hello"
+          r.test_header.mytag = "123"
+          session.send(r)
+        end
+        
+        def on_ack(session)
+          session.invalidate(true)
+          session.flow_completed_for("TestValidations")
+        end
+        
+        def order
+          0
+        end
+      end
+      
+      class UacValidationsController < 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)
+        end
+     
+        def on_success_res(session)
+          logd("Received response in #{name}")
+          session.validate_presence_of_headers :test_header
+          session.validate_presence_of_header_params :test_header, :mytag
+          session.validate_header_values :test_header=>'hello;mytag=123'
+          session.request_with('ack')
+          session.invalidate(true)
+        end
+        
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacValidationsController")
+  end
+  
+  
+  def test_header_params
+    self.expected_flow = ["> INVITE", "< 100", "< 200", "! true {3,3}", "> ACK"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "> 200", "< ACK"]
+    verify_call_flow(:in)
+  end
+  
+end

data/sipper_test/test_with_rr_proxy.rb

@@ -0,0 +1,111 @@
+
+require 'driven_sip_test_case'
+
+
+class TestWithRRProxy < DrivenSipTestCase
+  
+  # To run this test in windows, in a separate shell execute the proxy 
+  # "srun -p 5068 -0 5067 -c nonrr_proxy.rb"
+  # and set an env var 
+  # "set SIPPER_TEST_PROXY_EXTERNAL=true"
+  # You would do similar thing for rr_proxy with a higher port in a second shell
+  # "srun -p 5069 -0 5067 -c rr_proxy.rb"
+  # Let these two proxies run.
+  # Then run the test cases, after you are done make sure to unset the env var by
+  # "set SIPPER_TEST_PROXY_EXTERNAL="
+  # For one run you need only to execute the two proxies only once for all tests. 
+  def setup
+    @sr = SipperConfigurator[:SessionRecord] 
+    SipperConfigurator[:SessionRecord] = "msg-info"
+    @tp = SipperConfigurator[:LocalTestPort]
+    SipperConfigurator[:LocalTestPort] = 5067
+    SipperConfigurator[:SessionRecord] = "msg-info"
+    super
+    unless RUBY_PLATFORM =~ /mswin/
+      system("srun -p #{SipperConfigurator[:LocalTestPort]+2} -o #{SipperConfigurator[:LocalTestPort]} -rf 3 -c #{File.join(SipperConfigurator[:SipperBasePath],"sipper_test", "rr_proxy.rb")} &")    
+    end
+    
+    str2 = <<-EOF2
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasRt2Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        
+        def on_invite(session)
+          if session.irequest[:via].length == 2
+            session.do_record("double_via")
+          end
+          session.respond_with(200)
+          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("TestWithRRProxy")
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacRt2Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true  
+        
+        def start
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort]+2)
+          r = u.create_initial_request("invite", "sip:nasir@sipper.com")
+          u.send(r)
+          logd("Sent a new INVITE from "+name)
+        end
+     
+        
+        def on_success_res(session)
+          session.request_with('ACK')
+        end
+        
+        def on_bye(session)
+          if session.irequest[:via].length == 2
+            session.do_record("double_via")
+          end
+          session.respond_with(200)
+          session.invalidate(true)
+        end
+         
+      end
+    end
+    EOF2
+    define_controller_from(str2)
+    set_controller("SipInline::UacRt2Controller")
+  end
+  
+  
+  def test_rt1_controllers
+    if RUBY_PLATFORM =~ /mswin/ && !ENV['SIPPER_TEST_PROXY_EXTERNAL'] 
+      return  
+    end
+    self.expected_flow = ["> INVITE {1,}", "< 100", "< 200", "> ACK", "< BYE", "! double_via", "> 200"]
+    start_controller
+    sleep 3
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "! double_via", "> 200", "< ACK", "> BYE", "< 200"]
+    verify_call_flow(:in)
+  end
+  
+  def teardown
+    SipperConfigurator[:SessionRecord] = @sr
+    SipperConfigurator[:LocalTestPort] = @tp
+    super
+  end
+
+end
+

data/sipper_test/testmediacontroller.rb

@@ -0,0 +1,71 @@
+require 'driven_sip_test_case'
+
+class Testmediacontroller < DrivenSipTestCase 
+
+  def setup
+    @sm = SipperConfigurator[:SipperMedia] 
+    SipperConfigurator[:SipperMedia] = true
+    super
+    SipperConfigurator[:SessionRecord]='msg-info'
+    SipperConfigurator[:WaitSecondsForTestCompletion] = 40
+    str = <<-EOF
+# FLOW : > INVITE, < 200, > ACK
+#
+require 'base_controller'
+
+class TestmediacontrollerController < SIP::SipTestDriverController 
+
+  # change the directive below to true to enable transaction usage.
+  # If you do that then make sure that your controller is also 
+  # transaction aware. i.e does not try send ACK to non-2xx responses,
+  # does not send 100 Trying response etc.
+
+  transaction_usage :use_transactions=>false
+
+  def initialize
+    logd('Controller created')
+  end
+
+
+  def on_register(session)
+    session.respond_with(200)
+        
+    registration_store.put(:bob, session.irequest.contact.uri.to_s)
+          
+    session.invalidate(true)
+    
+    s = create_session
+    s.set_media_attributes(:codec=>['G711U'], :type=>'SENDRECV',
+      :play=>{:file=>'hello_sipper.au', :repeat=>false},
+      :record_file=>'in_sipper.au',
+      :remote_m_line=>['any'])
+  
+   r = s.create_initial_request('INVITE', registration_store.get(:bob))
+     r.to = "<sip:nkhan@sipper.com>"
+     s.send r
+  end
+
+  def on_subscribe(session)
+    session.respond_with(200)
+  end
+
+
+  def on_success_res(session)
+    session.request_with('ACK')
+    sleep 15
+    session.invalidate
+    session.flow_completed_for('Testmediacontroller')
+  end
+
+end
+    EOF
+    define_controller_from(str)
+    set_controller('TestmediacontrollerController')
+  end
+
+  def test_case_1
+    self.expected_flow = ['> INVITE','< 200','> ACK']
+    start_controller
+    verify_call_flow(:out)
+  end
+end

data/sipper_test/tracing.rb

@@ -0,0 +1,23 @@
+module Tracing
+def Tracing.included(into)
+into.instance_methods(false).each { |m|
+Tracing.hook_method(into, m) }
+def into.method_added(meth)
+unless @adding
+@adding = true
+Tracing.hook_method(self, meth)
+@adding = false
+end
+end
+end
+def Tracing.hook_method(klass, meth)
+klass.class_eval do
+alias_method "old_#{meth}", "#{meth}"
+define_method(meth) do |*args|
+puts "#{meth} start"
+self.send("old_#{meth}",*args)
+puts "#{meth} end"
+end
+end
+end
+end

data/sipper_test/transaction_test_helper.rb

@@ -0,0 +1,176 @@
+module SipMockTester
+  
+  class MockTimeTransport
+    include SIP::Transport::UnreliableTransport
+    attr_accessor :msg
+    def initialize
+      @msg = []
+    end
+    def send(m, *remaining)
+      @msg << Time.ctm
+    end
+  end
+  
+  class MockMsgTransport
+    include SIP::Transport::UnreliableTransport
+    attr_accessor :msg
+    def initialize
+      @msg = []
+    end
+    def send(m, *remaining)
+      @msg << m.to_s
+    end
+  end
+ 
+  class ExceptionalTransportOnNthAttempt
+    include SIP::Transport::UnreliableTransport
+    def initialize(n)
+      @count = 1
+      @fail_on = n
+    end
+    def send *a
+      raise if @count == @fail_on
+      @count += 1
+    end
+  end
+  
+  class Tu
+    attr_accessor :txn
+    
+    def transaction_transport_err(txn)
+      @txn = txn
+    end
+    
+    def get_request_destination
+      [nil, nil, nil]
+    end
+    
+    def get_response_destination(res)
+      [nil, nil, nil]
+    end
+    
+    def transaction_cleanup(txn)
+      @txn = txn
+    end
+    
+    def transaction_timeout(txn)
+      @txn = txn
+    end
+    
+    def transaction_wrong_state(txn)
+      @txn = txn
+    end
+    
+    def transaction_record(direction, msg)
+    end
+    
+    def create_non_2xx_ack(invite, response)
+      h = {
+            :to => response.to.to_s,
+            :cseq => sprintf("%s %s", SipperUtil.cseq_number(invite.cseq),"ACK")
+          }
+      ack = Request.create_subsequent("ACK", invite.uri, h)
+      ack.copy_from(invite, :call_id, :from, :via, :route, :contact, :max_forwards)
+      ack
+    end
+    
+    def create_response(code, phrase, request=nil)
+      res = Response.create code, phrase  # not using request
+    end
+    
+    def rollback_to_before_request_received_state(request)
+      # no op
+    end
+    
+    def rejection_response_with(code, request)
+      r = create_response(code, "SELECT", request)
+      rollback_to_before_request_received_state(request)
+      return r
+    end
+    
+  end
+  
+  # Plain
+  class Tcbh1
+    attr_accessor :states
+    # for ICT
+    def before_invite(txn)
+     (@states ||= []) << txn.state
+    end 
+    def after_invite(txn)
+     (@states ||= []) << txn.state
+    end
+    # for NICT
+    def before_request(txn)
+     (@states ||= []) << txn.state
+    end 
+    def after_request(txn)
+     (@states ||= []) << txn.state
+    end
+  end
+  
+  # Masker
+  class Tcbh2
+    def before_invite(txn)
+      SIP::Transaction::SM_PROCEED_NO_ACTION
+    end
+    # NICT
+    def before_request(txn)
+      SIP::Transaction::SM_PROCEED_NO_ACTION
+    end
+  end
+  
+  class Tcbh3
+    attr_accessor :txn
+    def before_invite(txn)
+      @txn = txn
+      SIP::Transaction::SM_DO_NOT_PROCEED
+    end
+    # NICT
+    def before_request(txn)
+      @txn = txn
+      SIP::Transaction::SM_DO_NOT_PROCEED
+    end
+  end
+  
+  class Tcbh4
+    attr_accessor :txn
+    def wrong_state(txn)
+      @txn = txn
+    end
+  end
+  
+  class MockRequest
+    def initialize(m)
+      @method = m
+    end
+    def is_request?
+      true
+    end 
+    def method
+      @method
+    end
+  end
+  
+  class MockResponse
+    attr_accessor :code
+    def initialize(code)
+      self.code = code
+    end
+    def is_response?
+      true
+    end
+    def to_s
+      @code
+    end
+    def set_request(inRequest)
+       @request = inRequest
+    end
+    def get_reqeust()
+       raise "No associated request." unless @request
+       return @request
+    end
+  end
+  
+end
+