Sipper 1.1.3

data/sipper_test/test_target_refresh_with_update_proxy2.rb

@@ -0,0 +1,139 @@
+
+
+require 'driven_sip_test_case'
+
+# UAC runs on 5066
+# UAS runs on 5067
+# Proxy runs on 5068
+
+class TestTargetRefreshWithUpdateProxy2 < 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] = [5066, 5067]
+
+    super
+    unless RUBY_PLATFORM =~ /mswin/
+      system("srun -p #{SipperConfigurator[:LocalTestPort][1]+1} -o #{SipperConfigurator[:LocalTestPort][1]} -rf 3 -c #{File.join(SipperConfigurator[:SipperBasePath],"sipper_test", "nonrr_proxy.rb")} &")    
+    end
+    
+    str2 = <<-EOF2
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasRt7Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+
+        def specified_transport
+          [SipperConfigurator[:LocalSipperIP], 
+           SipperConfigurator[:LocalTestPort][1]]
+        end
+        
+        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_update(session)
+          session.respond_with(200)
+          session.request_with("bye")
+        end
+
+
+        def on_success_res_for_bye(session)
+          session.invalidate(true)
+          session.flow_completed_for("TestTargetRefreshWithUpdateProxy2")
+        end
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacRt7Controller < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true  
+
+        #pre_existing_route_set ["sip:#{SipperConfigurator[:LocalSipperIP]}:#{SipperConfigurator[:LocalTestPort][1]+1};lr"]
+
+        def specified_transport
+          [SipperConfigurator[:LocalSipperIP], 
+           SipperConfigurator[:LocalTestPort][0]]
+        end
+        
+        def start
+          u = create_udp_session()
+          r = u.create_initial_request("invite", 
+              "sip:nasir@#{SipperConfigurator[:LocalSipperIP]}:#{SipperConfigurator[:LocalTestPort][1]}")
+          r.route = "sip:#{SipperConfigurator[:LocalSipperIP]}:#{SipperConfigurator[:LocalTestPort][1]+1};lr"    
+          u.send(r)
+          logd("Sent a new INVITE from "+name)
+        end
+     
+        
+        def on_success_res_for_invite(session)
+          session.request_with('ACK')
+          r = session.create_subsequent_request('update')
+          orig_contact_uri = r.contact.uri
+          orig_contact_uri.user = "nkhan"
+          r.contact.uri = orig_contact_uri
+          session.send(r)  
+        end
+
+         def on_bye(session)
+          if session.irequest[:via].length == 1
+            session.do_record("single_via")
+          end
+          session.respond_with(200)
+          session.invalidate(true)
+        end
+        
+      end
+    end
+    EOF2
+    define_controller_from(str2)
+    set_controller("SipInline::UacRt7Controller")
+  end
+  
+  
+  def test_rt1_controllers
+    if RUBY_PLATFORM =~ /mswin/ && !ENV['SIPPER_TEST_PROXY_EXTERNAL'] 
+      return  
+    end
+    self.expected_flow = ["> INVITE {1,}", "< 100", "< 200", "> ACK", "> UPDATE", "< 200", "< BYE", "! single_via", "> 200"]
+    start_controller
+    sleep 3
+    verify_call_flow(:out)
+    self.expected_flow = ["< INVITE", "> 100", "! double_via", "> 200", "< ACK", "< UPDATE", "> 200",  "> BYE",  "< 200"]
+    verify_call_flow(:in)
+  end
+  
+  def teardown
+    SipperConfigurator[:SessionRecord] = @sr
+    SipperConfigurator[:LocalTestPort] = @tp
+    super
+  end
+
+end

data/sipper_test/test_timer_manager.rb

@@ -0,0 +1,71 @@
+require 'base_test_case'
+require 'util/timer/timer_task'
+require 'util/timer/timer_manager'
+require 'ruby_ext/time'
+require 'monitor'
+require 'flexmock'
+
+class TestTimerManager < BaseTestCase
+  include FlexMock::TestCase
+
+  def setup
+    @q = []
+    @tm = SIP::TimerManager.new(@q)
+  end
+  
+  def test_running
+    assert_raise(RuntimeError) { @tm.schedule("something") }
+  end
+  
+  def test_one_task
+    @tm.start
+    task = FlexMock.new
+    task.should_receive(:abs_msec).and_return(Time.ctm+100)
+    task.should_receive(:canceled?).and_return(false)
+    @tm.schedule(task)
+    assert(@q.empty?)
+    sleep(0.2)
+    assert_equal(task, @q.shift)
+  end
+  
+  def test_many_tasks
+    @tm.start
+    total = 50
+    total.downto(1) do
+      time = rand*1000 + 500  #offset to ensure that all are scheduled before anyone fires
+      task = SIP::TimerTask.new(nil, nil, nil, nil, time)
+      @tm.schedule(task) 
+    end
+    sleep 3
+    assert_equal(total, @q.size)
+    @q.each_with_index do |val, idx|
+      assert(@q[idx] < @q[idx+1], "idx=#{idx} #{@q[idx].abs_msec} and #{@q[idx+1].abs_msec}") if idx+1 < total
+    end
+  end
+
+  def test_zero_time_task
+    @tm.start
+    task = FlexMock.new
+    task.should_receive(:abs_msec).and_return(Time.ctm)  
+    task.should_receive(:canceled?).and_return(false)
+    @tm.schedule(task)
+    sleep(0.2)
+    assert_equal(task, @q.shift)
+  end
+  
+  def test_canceled_task
+    @tm.start
+    task = FlexMock.new
+    task.should_receive(:abs_msec).and_return(Time.ctm+100)
+    task.should_receive(:canceled?).and_return(true)
+    @tm.schedule(task)
+    assert(@q.empty?)
+    sleep(0.2)
+    assert(@q.empty?)
+  end
+  
+  def teardown
+    @tm.stop
+  end
+  
+end

data/sipper_test/test_timer_task.rb

@@ -0,0 +1,60 @@
+require 'base_test_case'
+require 'util/timer/timer_task'
+require 'ruby_ext/time'
+require 'flexmock'
+
+class MyTarget
+  attr_accessor :count
+  def initialize
+    @count = 0
+  end
+  def on_timer_expiration(timer)
+    @count += 1
+  end
+end
+
+class TestTimerTask < BaseTestCase
+  include FlexMock::TestCase
+  
+  def test_init
+    t = SIP::TimerTask.new(nil)
+    assert_equal(:session, t.type)
+    assert_not_nil(t.abs_msec)
+  
+    t = SIP::TimerTask.new(nil, lambda {return 99})
+    assert_equal(99, t.task.call)  
+    
+    t = SIP::TimerTask.new(nil) { next 99 }
+    assert_equal(99, t.task.call)
+    
+    # past time
+    assert_raise(ArgumentError) { SIP::TimerTask.new(nil, nil, nil, nil, -100) }
+    assert_nothing_raised { SIP::TimerTask.new(nil, nil, nil, nil, 0) }
+  end
+    
+  def test_comparison
+    t1 = SIP::TimerTask.new(nil, nil, nil, nil, 100)
+    t2 = SIP::TimerTask.new(nil, nil, nil, nil, 200)
+    assert(t1 < t2)
+  end
+  
+  def test_invocation
+    tg = FlexMock.new
+    tg.should_receive(:on_timer_expiration).with(SIP::TimerTask).and_return("fine")
+    t = SIP::TimerTask.new(tg)
+    assert_equal("fine", t.invoke)
+  end
+  
+  def test_cancellation
+    tg = MyTarget.new
+    t = SIP::TimerTask.new(tg)
+    t.invoke
+    assert_equal(1, tg.count)
+    t = SIP::TimerTask.new(tg)
+    t.cancel
+    assert(t.canceled?)
+    t.invoke
+    assert_equal(1, tg.count)
+  end
+  
+end

data/sipper_test/test_transport_handler.rb

@@ -0,0 +1,19 @@
+$:.unshift File.join(ENV['SIPPER_HOME'],'sipper_test')
+require 'driven_sip_test_case'
+
+class TestThTest < DrivenSipTestCase 
+
+  def setup
+    SipperConfigurator[:ControllerPath] = File.join(SipperConfigurator[:SipperBasePath], "sipper_test", "test_controllers", "ctrl_trhandler")
+    SipperConfigurator[:SessionRecord]='msg-info'
+    super
+  end
+
+  def test_case_1
+    self.expected_flow = ["> INFO","< 200"]
+    start_named_controller("UacTrHandlerController")
+    verify_call_flow(:out)
+    self.expected_flow = ["< MESSAGE","> 200"]
+    verify_call_flow(:in)
+  end
+end

data/sipper_test/test_transport_multi_handler.rb

@@ -0,0 +1,18 @@
+
+$:.unshift File.join(ENV['SIPPER_HOME'],'sipper_test')
+require 'driven_sip_test_case'
+
+class TestTransportMultiHandler < DrivenSipTestCase 
+
+  def setup
+    SipperConfigurator[:ControllerPath] = File.join(SipperConfigurator[:SipperBasePath], "sipper_test", "test_controllers", "multi_trhandlers")
+    SipperConfigurator[:SessionRecord]='msg-info'
+    super
+  end
+
+  def test_case_1
+    start_named_controller("UacMultiTrHandlerController")
+    self.expected_flow = ["< INFO", "! Transform_OK", "> 200"]
+    verify_call_flow(:in)
+  end
+end

data/sipper_test/test_udp_transport.rb

@@ -0,0 +1,119 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","sipper")
+
+require 'transport/udp_transport'
+require 'test/unit'
+require 'tracing'
+class TestUdpTransport < Test::Unit::TestCase
+  
+  #include Tracing
+  def setup
+    @ip = SipperConfigurator[:LocalSipperIP]
+    @port = 5062
+    @t1 = Transport::UdpTransport.instance(@ip, @port)
+  end
+  
+  def test_instance
+    assert_raise(NoMethodError){Transport::UdpTransport.new}
+    t2 = Transport::UdpTransport.instance(@ip, @port)
+    _check_equal(t2)
+    @t1 = Transport::UdpTransport.instance(@ip, @port)
+    _check_equal(t2)
+    t3 = Transport::UdpTransport.instance(@ip, @port+1)
+    assert_not_equal(@t1, t3)
+    assert(!t2.equal?(t3))
+  end
+  
+  
+  
+  def test_running
+    assert(!@t1.running)
+    @t1.start_transport
+    assert(@t1.running)
+    assert_raise(RuntimeError) {@t1.start_transport}
+  end
+  
+  def test_stopping
+    test_running
+    @t1.stop_transport
+    assert(!@t1.running)
+    assert_raise(RuntimeError) {@t1.stop_transport}
+  end
+  
+  def test_transport_thread
+    th = @t1.start_transport
+    assert(th.alive?)
+    @t1.stop_transport
+    assert(th.stop?)
+  end
+  
+
+  def test_recv
+    th = @t1.start_transport
+    sleep(rand(1)) until @t1.running
+    s1 = UDPSocket.new
+    s1.connect(@ip, @port)
+    s1.send "hello_recv" , 0
+    data = @t1.get_next_message
+    assert_equal("hello_recv", data[0])
+    assert(th.alive?)
+    s1.send "poison dart" , 0
+    data = @t1.get_next_message
+    assert_equal("poison dart", data[0])
+    th.join
+    assert(th.stop?)
+  end
+
+  
+  def _send s_msg, r_msg
+    th2 = Thread.new do 
+      s = UDPSocket.new
+      s.bind(@ip, @port+1)
+      IO.select([s])
+      x = s.recvfrom_nonblock(100)[0]
+      assert_equal(x, r_msg)
+      s.close
+    end
+    @t1.send(s_msg, 0, @ip, @port+1)
+    th2.join
+  end
+  
+  def test_send
+    test_running
+    _send "hello_nasir", "hello_nasir"
+    # todo: add these tests at session sending
+    #_send "nina@_PH_LIP_", "nina@#{@ip}"
+    #_send "nina@_PH_LIP_:_PH_LP_", "nina@#{@ip}:#{@port}"
+    #_send "neena@_PH_RIP_:_PH_RP_", "neena@#{@ip}:#{@port+1}"
+  end
+  
+  def test_one_start
+    started = []
+    threads = [] 
+    50.times do
+      threads << Thread.new do
+        sleep(rand(3))
+        begin
+          @t1.start_transport
+          started << 1
+          rescue RuntimeError
+            started << 0 
+        end #exception
+      end  #threads
+    end #50
+    threads.each {|t| t.join}
+    assert_equal(1, started.inject {|s,v| s = s+v} )
+  end
+  
+  def teardown
+   @t1.stop_transport if @t1.running
+  end
+  
+  
+  def _check_equal(t2)
+    assert_equal(@t1, t2)
+    assert(@t1.equal?(t2))
+  end
+  
+  private :_check_equal, :_send
+  
+end

data/sipper_test/test_unparsed.rb

@@ -0,0 +1,70 @@
+
+require 'driven_sip_test_case'
+
+
+class TestUnparsed < DrivenSipTestCase
+
+  def setup
+    super
+    str = <<-EOF
+    
+    require 'sip_test_driver_controller'
+    
+    module SipInline
+      class UasUpController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true
+        
+        def on_info(session)
+          session.do_record(session.irequest.mytest.to_s)
+          session.respond_with(200)
+          logd("Received INFO sent a 200 from "+name)
+          session.invalidate(true)
+        end
+        
+      
+      
+        
+        def order
+          0
+        end
+        
+      end
+      
+      class UacUpController < SIP::SipTestDriverController
+      
+        transaction_usage :use_transactions=>true  
+        
+        def start
+          u = create_udp_session(SipperConfigurator[:LocalSipperIP], SipperConfigurator[:LocalTestPort])
+          r = u.create_initial_request("info", "sip:nasir@sipper.com", :p_session_record=>"msg-info")
+          r.assign_unparsed(:mytest, "  blah  ")
+          m = u.send(r)
+          logd("Sent a new INVITE from "+name)
+        end
+     
+        
+        def on_success_res(session)
+          session.invalidate(true)   
+          session.flow_completed_for("TestUnparsed")
+        end
+        
+         
+      end
+    end
+    EOF
+    define_controller_from(str)
+    set_controller("SipInline::UacUpController")
+  end
+  
+  
+  def test_up_controllers
+    self.expected_flow = ["> INFO",  "< 200"]
+    start_controller
+    verify_call_flow(:out)
+    self.expected_flow = ["< INFO",  "!   blah  ",  "> 200"]
+    verify_call_flow(:in)
+  end
+
+  
+end