Sipper 1.1.3

data/sipper/generators/README

@@ -0,0 +1,12 @@
+Usage for gen_controller is - 
+gen_controller.rb <name_of_controller_class> "String of call flow" 
+e.g gen_controller.rb MyController "> INVITE, < 200, > ACK"
+The generated controller can be run using the run/run_sipper1 script passing it this 
+generated controller as in run_sipper1.rb -c <proper_path_to my_controller.rb>
+
+Usage for gen_test is - 
+gen_test.rb <name_of_test_class> "String of call flow" 
+e.g gen_test.rb MyTest "> INVITE, < 200, > ACK"
+The generated test class can be run standalone as ruby -I <path to sipper_test> my_test.rb
+If it is a UAS then it will wait for 180 seconds for getting a request before failing the test. 
+This is part of generated code, which can be modified.  

data/sipper/generators/gen_controller.rb

@@ -0,0 +1,228 @@
+#todo have a rake task
+#todo look for ruby code formatter
+
+$:.unshift File.join(File.dirname(__FILE__),"..")
+
+require 'fileutils'
+require 'util/sipper_util'
+require 'util/expectation_parser'
+require 'util/command_element'
+
+module SIP
+  module Generators
+    class GenController
+    
+      def initialize(cname, flow_str, ctype="SIP::BaseController")
+        if cname =~ /^[A-Z]/
+          _cname = cname
+        else
+          _cname = SipperUtil.classify(cname)  
+        end
+         
+        if _cname =~ /Controller$/
+          @gen_class_name = _cname
+        else
+          @gen_class_name = _cname + "Controller"
+        end
+        @gen_file_name = SipperUtil.filify(@gen_class_name)
+        @flow_str = flow_str
+        @ctype = ctype
+        
+        @d_in  = SipperUtil::ExpectationElement::Directions[0]  # < inward
+        @d_out = SipperUtil::ExpectationElement::Directions[1]  # > outward
+        @d_n   = SipperUtil::ExpectationElement::Directions[2]  # ! neutral
+        @d_c   = SipperUtil::ExpectationElement::Directions[3]  # @ command
+        
+        #mod_flow_str = flow_str.gsub(/\{(.*?)\}/, '') # remove {...} for controller
+        mod_flow_str = SipperUtil.make_expectation_parsable(flow_str)
+        @flow = mod_flow_str.split("%").map {|str| str.strip}.map do |e| 
+          if e.index(@d_c) == 0
+            SipperUtil::CommandElement.new(e)
+          else
+            SipperUtil::ExpectationElement.new(e)
+          end
+        end
+        
+        
+        @current_method = ["start"]      # you always start at start()
+        @method_code = {"start" => ""}
+        @method_code_lines = {"start" => 0}
+        @processing_under_state_check = false
+      end
+      
+      def generate_controller(write_to_file=false, dir = nil)    
+        @str = "# FLOW : #{@flow_str}\n#\n"
+        @str << "require \'base_controller\'\n\n"
+        @str << sprintf("class %s < %s \n\n", @gen_class_name, @ctype)
+        @str << "  # change the directive below to true to enable transaction usage.\n"
+        @str << "  # If you do that then make sure that your controller is also \n"
+        @str << "  # transaction aware. i.e does not try send ACK to non-2xx responses,\n"
+        @str << "  # does not send 100 Trying response etc.\n\n"
+        @str << "  transaction_usage :use_transactions=>false\n\n"
+        if @ctype == "SIP::BaseController"
+          @str << "  # change the directive below to true to start after loading.\n"
+          @str << "  start_on_load false\n\n"
+        end
+        
+        @str << "  def initialize\n"
+        @str << "    logd('Controller created')\n  end\n\n"
+        @method_code["start"] << "  def start\n"
+        @method_code["start"] << "    session = create_udp_session(SipperConfigurator[:DefaultRIP], SipperConfigurator[:DefaultRP])\n"
+        @flow.each do |e|
+          if e.direction == @d_in  # have a new method defined for each incoming and repeat outgoing
+            @current_method = []
+            e.messages.each do |m| 
+              k = m.sub(/^\d../, m[0,1]+"xx")
+              _get_message(k); 
+              @current_method << k  
+            end
+          elsif e.direction == @d_out 
+            @current_method.each do |c_method|
+              # if there is a "|" condition for sending then generate a warning.
+              puts "Warning: Sending optional messages is not permitted, taking #{e.messages[0]} only." if e.messages.length>1
+              _send_message(e.messages[0], c_method)
+            end
+          elsif e.direction == @d_n # neutral
+            @current_method.each do |c_method|
+              puts "Warning: Logging optional messages is not permitted, taking #{e.messages[0]} only." if e.messages.length>1
+              _log_message(e.messages[0], c_method)
+            end
+          elsif e.direction == @d_c # command
+            @current_method.each do |c_method|
+              _command(e.command_str, c_method)
+            end
+            if e.command == "set_timer"
+              unless @method_code["timer"]
+                @method_code["timer"] = "  def on_timer(session, task)\n"
+              else
+                @method_code["timer"] << "    end\n" # closing end for if tid 
+              end
+              @method_code["timer"] << "    if task.tid == \"#{e.command_id}\"\n"
+              @current_method = ["timer"]
+            end
+          end  
+        end
+        
+        @current_method.each do |m|
+          @method_code[m] << "    session.invalidate(true)\n"
+          if @ctype == "SIP::SipTestDriverController"
+            test_name = @gen_class_name.sub(/Controller/,"") # by convention the "Controller" is appended to named test 
+            @method_code[m] << "    session.flow_completed_for('#{test_name}')\n" 
+          end
+        end
+        _close_all_methods
+        
+        @str << "end\n"  # close class
+        if write_to_file
+          if dir
+            f = File.join(dir, @gen_file_name)
+          else
+            f = @gen_file_name
+          end
+          cfile = File.new(f, "w")
+          cfile << @str
+          cfile.close
+        end
+        @str
+      end  
+      
+      def _get_message(msg)
+        unless @method_code[msg]
+          @method_code_lines[msg] = 0
+          @processing_under_state_check = false
+          case msg 
+          when /^[A-Z]/
+            @method_code[msg] = "  def on_#{msg.downcase}(session)\n" 
+          when /^100/
+            @method_code[msg] = "  def on_trying_res(session)\n" 
+          when /^1/
+            @method_code[msg] = "  def on_provisional_res(session)\n" 
+          when /^2/
+            @method_code[msg] = "  def on_success_res(session)\n" 
+          when /^3/
+            @method_code[msg] = "  def on_redirect_res(session)\n" 
+          else
+            @method_code[msg] = "  def on_failure_res(session)\n" 
+          end
+        else 
+          # method already exists, now just add the if/else check for
+          # state. 
+          _add_state_check_for(msg) 
+          @processing_under_state_check = true
+        end
+      end
+      
+      
+      def _send_message(msg, method)
+        sp = self._spacing    
+        if msg =~ /^[A-Z]/    
+          @method_code[method] << "#{sp}session.request_with('#{msg}'"
+          if method == "start"
+            @method_code[method] << ", 'sip:nasir@sipper.com')" 
+          else 
+            @method_code[method] << ")"
+          end
+          @method_code[method] << "\n"
+        else
+          @method_code[method] << "#{sp}session.respond_with(#{msg})\n"
+        end
+      end
+      
+      def _log_message(msg, method)
+        sp = self._spacing
+        @method_code[method] << "#{sp}session.do_record('#{msg}')\n" 
+      end
+      
+      def _command(cmd, method)
+        sp = self._spacing
+        @method_code[method] << "#{sp}#{cmd}\n"     
+      end
+      
+      def _spacing
+        sp = "  "
+        if @processing_under_state_check
+            sp = " "*6
+        else
+            sp = " "*4
+        end 
+        return sp
+      end
+      
+      def _add_state_check_for(msg) 
+        count = 0
+        cond_str = "session['#{msg.downcase}']"
+        code_arr = @method_code[msg].split("\n")
+        if @method_code[msg].index(cond_str)
+          count = @method_code[msg].scan(cond_str+ " = ").length  # count session['info'] = n
+          code_arr.insert(-1, "    #{cond_str} = #{count + 1}\n")
+          code_arr.insert(-1, "    elsif #{cond_str} == #{count+1}\n")
+        else
+          code_arr.insert(1, "    if !#{cond_str}")
+          code_arr[2] = "  " + code_arr[2] if code_arr[2] # re-format current message line
+          code_arr.insert(-1, "      #{cond_str} = 1")
+          code_arr.insert(-1, "    elsif #{cond_str} == 1\n")
+        end  
+        @method_code[msg] = code_arr.join("\n")
+      end
+      
+      
+        
+      def _close_method(msg)
+        @method_code[msg] << "\n    end\n" if @method_code[msg].index("if session['")
+        @method_code[msg] << "    end\n" if msg == "timer"
+        @method_code[msg] << "  end\n\n" 
+        @str << @method_code[msg]
+      end
+      
+      def _close_all_methods
+        @method_code.each_key {|k| _close_method(k)}
+      end
+      
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  g = SIP::Generators::GenController.new(ARGV[0], ARGV[1])
+  g.generate_controller(true)
+end

data/sipper/generators/gen_project.rb

@@ -0,0 +1,45 @@
+
+$:.unshift File.join(File.dirname(__FILE__),"..")
+
+require 'fileutils'
+require 'util/sipper_util'
+require 'sipper_configurator'
+
+
+module SIP
+  module Generators
+    class GenProject
+      def initialize(projname, override=false)
+        if override
+          FileUtils.mkdir_p projname
+        else
+          FileUtils.mkdir projname
+        end
+        dir = File.join(File.dirname(__FILE__), 'project_template_dir')
+        Dir.glob(dir+"/**/*").each do |f|
+          n = f.split("project_template_dir/")[1]
+          entity = File.join(projname, n)
+          if File.directory?(f)
+            puts "Creating ...... directory #{entity}"
+            FileUtils.mkdir_p(entity)
+          else
+            puts "Creating ...... file #{entity}"
+            FileUtils.cp(f, entity)  
+          end
+        end
+        FileUtils.mv(File.join(projname,"dot_sipper.proj"), File.join(projname, ".sipper.proj"))
+        # now create the config for the project
+        # log4r file
+        FileUtils.cp File.join(File.dirname(__FILE__), "..", "config", "log4r.xml"), File.join(projname, "config")
+        
+        # Now set the project specific configuration
+        proj_dir = File.join(Dir.pwd, projname)
+        SipperConfigurator[:LogPath] = File.join(proj_dir, "logs")
+        SipperConfigurator[:ConfigPath] = cfd = File.join(proj_dir, "config")
+        SipperConfigurator[:ControllerPath] = File.join(proj_dir, "controllers")
+        SipperConfigurator.write_yaml_file(File.join(SipperConfigurator[:ConfigPath], "sipper.cfg"))
+      end
+    end
+  end
+end
+    

data/sipper/generators/gen_test.rb

@@ -0,0 +1,72 @@
+require 'generators/gen_controller'
+require 'facets/core/string/first_char'
+require 'util/sipper_util'
+
+module SIP
+  module Generators
+    class GenTest
+      def initialize(tname, flow_str)
+        @gen_class_name = SipperUtil.classify(tname)
+        @gen_file_name = SipperUtil.filify(@gen_class_name)
+        @flow_str = flow_str
+        mod_flow_str = SipperUtil.make_expectation_parsable(flow_str)
+        @flow = mod_flow_str.split("%").map {|str| str.strip}
+        @direction = "neutral"
+        case @flow[0].first_char(1)
+        when SipperUtil::ExpectationElement::Directions[0]
+          @direction = "in"
+        when SipperUtil::ExpectationElement::Directions[1]
+          @direction = "out"
+        else
+          @direction = "neutral"
+        end
+        @flow_msg_only = @flow.reject {|x| x.first_char(1) == "@"}
+      end  
+      
+      def generate_test(write_to_file=false, dir = nil)
+        @str = "$:.unshift File.join(ENV['SIPPER_HOME'],'sipper_test')\n"
+        @str << "require \'driven_sip_test_case\'\n\n"
+        @str << sprintf("class %s < DrivenSipTestCase \n\n", @gen_class_name)
+        @str << "  def self.description\n"
+        @str << "    \"Callflow is #{@flow_str}\" \n"
+        @str << "  end\n\n"
+        @str << "  def setup\n"
+        @str << "    super\n"
+        @str << "    SipperConfigurator[:SessionRecord]='msg-info'\n"
+        @str << "    SipperConfigurator[:WaitSecondsForTestCompletion] = 180\n"
+        controller_code = Generators::GenController.new(@gen_class_name+"Controller", @flow_str, "SIP::SipTestDriverController").generate_controller(false)
+        @str << "    str = <<-EOF\n"
+        @str << controller_code
+        @str << "    EOF\n"
+        @str << "    define_controller_from(str)\n" 
+        @str << "    set_controller('#{@gen_class_name}"+"Controller"+"')\n"
+        @str << "  end\n\n"
+        @str << "  def test_case_1\n"
+        @str << "    self.expected_flow = " 
+        @str << SipperUtil.print_arr(@flow_msg_only) + "\n"
+        @str << "    start_controller\n"
+        @str << "    verify_call_flow(:" + @direction +")\n"
+        @str << "  end\n"      
+        @str << "end\n"  # close class
+       
+        if write_to_file
+          if dir
+            f = File.join(dir, @gen_file_name)
+          else
+            f = @gen_file_name
+          end
+          cfile = File.new(f, "w")
+          cfile << @str
+          cfile.close
+        end
+        @str
+      end
+      
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  g = SIP::Generators::GenTest.new(ARGV[0], ARGV[1])
+  g.generate_test
+end

data/sipper/generators/project_template_dir/Rakefile

@@ -0,0 +1,56 @@
+
+require 'rake/clean'
+require 'rake/testtask'
+require 'yaml'
+
+CLEAN.include("logs/*.log")
+CLEAN.include("logs/*._in")
+CLEAN.include("logs/*._out")
+CLEAN.include("logs/precall*")
+CLEAN.include("logs/.Test*")
+
+task :default => [:my_test]
+
+desc "Run all unit tests"
+Rake::TestTask.new(:test) do |t|
+  t.libs << "tests"
+  t.test_files= 
+   Dir.glob("tests/*.rb")
+  t.verbose = true
+end
+
+# order_tests.yaml file should be present
+# in the tests directory for this ordering
+# of tests to work. If not found then we
+# default to built in test run task
+desc "Run all unit tests in order"
+task :my_test do
+  require 'test/unit/ui/console/testrunner'
+  require 'test/unit'
+  Test::Unit.run = true
+  path = File.join("tests", "order_tests.yaml") 
+  if File.exists?(path)
+    a = File.open(path) {|yf| YAML::load(yf)}
+  else
+    begin
+      Rake::Task["test"].execute
+      exit
+    rescue ArgumentError
+      Rake::Task["test"].execute nil
+      exit
+    end
+  end 
+  c = Dir.glob("tests/*.rb")
+  b = c.map {|f| f[6..-1]} # remove "tests/"
+  path = File.join("tests", "order_tests.yaml") 
+  if File.exists?(path)
+    a = File.open(path) {|yf| YAML::load(yf)}
+  else
+    a = []
+  end 
+  test_files = a + (b - a)
+  test_files.each do |tf|   
+    load "tests/"+tf
+    Test::Unit::UI::Console::TestRunner.run(::Kernel.const_get(tf[0..-4].split("_").map! {|x| x.capitalize}.join))
+  end
+end

data/sipper/generators/project_template_dir/config/sipper.cfg

@@ -0,0 +1,31 @@
+--- 
+:LocalSipperIP: 127.0.0.1
+:LocalSipperPort: 5060
+:DefaultRIP: 127.0.0.1
+:DefaultRP: 5060
+:LocalTestPort: 5066
+:SessionLimit: 60000
+:PrintHeapOnExit: false
+:ProtocolCompliance: strict
+:T2xxUsage: false
+:TransactionTimers: {}
+
+:TimerGranularity: 70
+:SessionTxnUsage: 
+  :use_transactions: false
+:WaitSecondsForTestCompletion: 10
+:TargetRefreshMethods: 
+- INVITE
+- SUBSCRIBE
+- UPDATE
+- NOTIFY
+- REFER
+:TestManagerName: 
+:DialogCreatingMethods: 
+- INVITE
+- SUBSCRIBE
+- NOTIFY
+- REFER
+:SessionTimer: 60000
+:TestManagerPort: 
+:EnableRecordingLock: false