stella 0.7.6.007 → 0.8.0.000

data/lib/stella/data/http.rb

@@ -142,6 +142,28 @@ module Stella::Data::HTTP
       header[:Cookie] 
     end
     
+    def freeze
+      @params = convert_values_to_templates @params
+      @headers = convert_values_to_templates @headers
+      super
+      self
+    end
+    
+    private 
+     def convert_values_to_templates(hash)
+       updated = {}
+       hash.each_pair { |k,v| 
+         next if Stella::Template === v
+         if Proc === v
+           msg = "As of Stella 0.8, Procs are no longer supported as values#{$/}"
+           msg << "for parameters and headers (\"#{k}\" in \"#{description}\").#{$/}"
+           msg << "Use string templates instead. See the examples/ directory."
+           raise Stella::Error, msg
+         end
+         updated[k] = Stella::Template.new( v || '')
+       }
+       updated
+     end
   end
   
 end

data/lib/stella/data.rb

@@ -4,353 +4,54 @@ module Stella::Data
     
   module Helpers
     
-    def resource(name)
-      Proc.new do
-        resource name 
-      end
-    end
+    def resource(args)   to_templ(:resource, *args)   end
     
     # Can include glob
     #
     # e.g.
     #    random_file('avatar*')
-    def random_file(*args)
-      input = args.size > 1 ? args : args.first
-      Proc.new do
-        value = case input.class.to_s
-        when "String"
-          Stella.ld "FILE: #{input}"
-          path = File.exists?(input) ? input : File.join(@base_path, input)
-          files = Dir.glob(path)
-          path = files[ rand(files.size) ]
-          Stella.ld "Creating file object: #{path}"
-          File.new(path)
-        when "Proc"
-          input.call
-        else
-          input
-        end
-        raise Stella::Testplan::Usecase::UnknownResource, input if value.nil?
-        Stella.ld "FILE: #{value}"
-        value
-      end
-    end
+    def random_file(*args)  to_templ(:random_file, *args)    end
     
-    def read_file(*args)
-      input = args.size > 1 ? args : args.first
-      Proc.new do
-        case input.class.to_s
-        when "String"
-          file(input).read  # This is the file method defined in Container.
-        when "Proc"
-          input.call
-        else
-          input
-        end
-      end
-    end
+    def read_file(*args) to_templ(:read_file, *args)    end
     
-    def path(*args)
-      input = File.join *args
-      Proc.new do
-        File.exists?(input) ? input : File.join(@base_path, input)
-      end
-    end
+    def path(*args)   to_templ(:path, *args)     end
     
-    def file(*args)
-      input = args.size > 1 ? args : args.first
-      Proc.new do
-        value = case input.class.to_s
-        when "String"
-          Stella.ld "FILE: #{input}"
-          path = File.exists?(input) ? input : File.join(@base_path, input)
-          Stella.ld "Creating file object: #{path}"
-          File.new(path)
-        when "Proc"
-          input.call
-        else
-          input
-        end
-        raise Stella::Testplan::Usecase::UnknownResource, input if value.nil?
-        Stella.ld "FILE: #{value}"
-        value
-      end
-    end
+    def file(*args)   to_templ(:file, *args)    end
     
     def random(*args)
-      if Symbol === args.first
-        input, index = *args
-      elsif Array === args.first || args.size == 1
-        input = args.first
-      else
-        input = args
-      end
-        
-      Proc.new do
-        if @random_value[input.object_id]
-          value = @random_value[input.object_id]
-        else
-          value = case input.class.to_s
-          when "Symbol"
-            resource(input)
-          when "Array"
-            input
-          when "Range"
-            input.to_a
-          when "Proc"
-            input.call
-          when "Fixnum"
-            Stella::Utils.strand( input )
-          when "NilClass"
-            Stella::Utils.strand( rand(100) )
-          end
-          raise Stella::Testplan::Usecase::UnknownResource, input if value.nil?
-          Stella.ld "RANDVALUES: #{input} #{value.class} #{value.inspect}"
-          value = value[ rand(value.size) ] if value.is_a?(Array)
-          Stella.ld "SELECTED: #{value.class} #{value} "
-          @random_value[input.object_id] = value
-        end
-        
-        # The resource may be an Array of Arrays (e.g. a CSV file)
-        if value.is_a?(Array) && !index.nil?
-          value = value[ index ] 
-          Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
-        end
-        
-        value
-      end
+      to_templ(:random, *args)
     end
     
     
     # NOTE: This is global across all users
     def sequential(*args)
-      if Symbol === args.first
-        input, index = *args
-      elsif Array === args.first || args.size == 1
-        input = args.first
-      else
-        input = args
-      end
-      Proc.new do
-        if @sequential_value[input.object_id]
-          value = @sequential_value[input.object_id]
-        else
-          value = case input.class.to_s
-          when "Symbol"
-            ret = resource(input)
-            ret
-          when "Array"
-            input
-          when "Range"
-            input.to_a
-          when "Proc"
-            input.call
-          end
-          digest = value.object_id
-          if value.is_a?(Array)
-            idx = Stella::Client::Container.sequential_offset(digest, value.size-1)
-            value = value[ idx ] 
-            Stella.ld "SELECTED(SEQ): #{value} #{idx} #{input} #{digest}"
-          end
-          
-          # I think this needs to be updated for global_sequential:
-          @sequential_value[input.object_id] = value
-        end
-        # The resource may be an Array of Arrays (e.g. a CSV file)
-        if value.is_a?(Array) && !index.nil?
-          value = value[ index ] 
-          Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
-        end
-        value
-      end
+      to_templ(:sequential, *args)
     end
     
     # NOTE: This is global across all users
     def rsequential(*args)
-      if Symbol === args.first
-        input, index = *args
-      elsif Array === args.first || args.size == 1
-        input = args.first
-      else
-        input = args
-      end
-      Proc.new do
-        if @rsequential_value[input.object_id]
-          value = @rsequential_value[input.object_id]
+      to_templ(:rsequential, *args)
+    end
+    
+    private 
+
+    def args_to_str(*args)
+      args.collect! do |el|
+        if el.kind_of?(Enumerable) || el.kind_of?(Numeric)
+          el.inspect
+        elsif el.is_a?(Symbol)
+          ":#{el.to_s}"
         else
-          value = case input.class.to_s
-          when "Symbol"
-            ret = resource(input)
-            ret
-          when "Array"
-            input
-          when "Range"
-            input.to_a
-          when "Proc"
-            input.call
-          end
-          digest = value.object_id
-          if value.is_a?(Array)
-            idx = Stella::Client::Container.rsequential_offset(digest, value.size-1)
-            value = value[ idx ] 
-            Stella.ld "SELECTED(RSEQ): #{value} #{idx} #{input} #{digest}"
-          end
-          
-          # I think this needs to be updated for global_sequential:
-          @rsequential_value[input.object_id] = value
-        end
-        # The resource may be an Array of Arrays (e.g. a CSV file)
-        if value.is_a?(Array) && !index.nil?
-          value = value[ index ] 
-          Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
-        end
-        value
+          "'#{el.to_s}'"
+        end 
       end
+      args.join(', ')
     end
     
-    ###
-    ### Disabled b/c it doesn't work anymore since a  
-    ### new Container is created for every repetition. 
-    ###
-    ##def sequential(*args)
-    ##  if Symbol === args.first
-    ##    input, index = *args
-    ##  elsif Array === args.first || args.size == 1
-    ##    input = args.first
-    ##  else
-    ##    input = args
-    ##  end
-    ##  Proc.new do
-    ##    if @sequential_value[input]
-    ##      value = @sequential_value[input]
-    ##    else
-    ##      value = case input.class.to_s
-    ##      when "Symbol"
-    ##        ret = resource(input)
-    ##        ret
-    ##      when "Array"
-    ##        input
-    ##      when "Range"
-    ##        input.to_a
-    ##      when "Proc"
-    ##        input.call
-    ##      end
-    ##      digest = value.object_id
-    ##      @sequential_offset ||= {}
-    ##      @sequential_offset[digest] ||= 0
-    ##      Stella.ld "SEQVALUES: #{@sequential_offset.object_id} #{value.inspect} #{@sequential_offset[digest]}"
-    ##      if value.is_a?(Array)
-    ##        size = value.size
-    ##        @sequential_offset[digest] = 0 if @sequential_offset[digest] >= size
-    ##        value = value[ @sequential_offset[digest] ] 
-    ##        Stella.stdout.info "WHAY: #{value} (#{@sequential_offset[digest]})"
-    ##        @sequential_offset[digest] += 1
-    ##      end
-    ##      Stella.ld "SELECTED: #{value}"
-    ##      @sequential_value[input] = value
-    ##    end
-    ##    # The resource may be an Array of Arrays (e.g. a CSV file)
-    ##    if value.is_a?(Array) && !index.nil?
-    ##      value = value[ index ] 
-    ##      Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
-    ##    end
-    ##    value
-    ##  end
-    ##end
-    ##
-    ##def rsequential(*args)
-    ##  if Symbol === args.first
-    ##    input, index = *args
-    ##  elsif Array === args.first || args.size == 1
-    ##    input = args.first
-    ##  else
-    ##    input = args
-    ##  end
-    ##  Proc.new do
-    ##    if @rsequential_value[input.digest]
-    ##      value = @rsequential_value[input.digest]
-    ##    else
-    ##      value = case input.class.to_s
-    ##      when "Symbol"
-    ##        ret = resource(input)
-    ##        ret
-    ##      when "Array"
-    ##        input
-    ##      when "Range"
-    ##        input.to_a
-    ##      when "Proc"
-    ##        input.call
-    ##      end
-    ##      digest = value.object_id
-    ##      @rsequential_offset ||= {}
-    ##      Stella.ld "RSEQVALUES: #{input} #{value.inspect}"
-    ##      if value.is_a?(Array)
-    ##        size = value.size
-    ##        @rsequential_offset[digest] ||= size-1 
-    ##        @rsequential_offset[digest] = size-1 if @rsequential_offset[digest] < 0
-    ##        value = value[ @rsequential_offset[digest] ] 
-    ##        @rsequential_offset[digest] -= 1
-    ##      end
-    ##      Stella.ld "SELECTED: #{value}"
-    ##      @rsequential_value[input.digest] = value
-    ##    end
-    ##    
-    ##    # The resource may be an Array of Arrays (e.g. a CSV file)
-    ##    if value.is_a?(Array) && !index.nil?
-    ##      value = value[ index ] 
-    ##      Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
-    ##    end
-    ##    
-    ##    value
-    ##  end
-    ##end
-    
-    
+    def to_templ(meth, *args)
+      Stella::Template.to_templ("#{meth}(#{args_to_str(*args)})")
+    end
     
-    # NOTE: This is global across all users
-    ## TODO: Broken??
-    ##def rsequential(*args)
-    ##  if Symbol === args.first
-    ##    input, index = *args
-    ##  elsif Array === args.first || args.size == 1
-    ##    input = args.first
-    ##  else
-    ##    input = args
-    ##  end
-    ##  Proc.new do
-    ##    if @rsequential_value[input.object_id]
-    ##      value = @rsequential_value[input.object_id]
-    ##    else
-    ##      value = case input.class.to_s
-    ##      when "Symbol"
-    ##        ret = resource(input)
-    ##        ret
-    ##      when "Array"
-    ##        input
-    ##      when "Range"
-    ##        input.to_a
-    ##      when "Proc"
-    ##        input.call
-    ##      end
-    ##      digest = value.object_id
-    ##      if value.is_a?(Array)
-    ##        index = Stella::Client::Container.rsequential_offset(digest, value.size-1)
-    ##        value = value[ index ] 
-    ##      end
-    ##      Stella.ld "SELECTED(RSEQ): #{value} #{index} #{input} #{digest}"
-    ##      # I think this needs to be updated for global_rsequential:
-    ##      @rsequential_value[input.object_id] = value
-    ##    end
-    ##    
-    ##    # The resource may be an Array of Arrays (e.g. a CSV file)
-    ##    if value.is_a?(Array) && !index.nil?
-    ##      value = value[ index ] 
-    ##      Stella.ld "SELECTED INDEX: #{index} #{value.inspect} #{input} #{digest}"
-    ##    end
-    ##    
-    ##    value
-    ##  end
-    ##end
   end
       
 end

data/lib/stella/engine/functional.rb

@@ -12,15 +12,22 @@ module Stella::Engine
       
       client = Stella::Client.new opts[:hosts].first, 1, opts
       client.add_observer(self)
-
+            
       client.enable_nowait_mode if opts[:nowait]
       
+      if Stella::Engine.service
+        Stella::Engine.service.testplan_sync plan
+        Stella::Engine.service.testrun_create opts
+        Stella::Engine.service.client_create client.digest, :index => client.index
+      end
+      
       Stella.stdout.info2 $/, "Starting test...", $/
-      sleep 0.3
       
       # Identify this thread to Benelux
       Benelux.current_track :functional 
       
+      start_time = Time.now.utc
+      
       dig = Stella.stdout.lev > 1 ? plan.digest_cache : plan.digest_cache.shorter
       Stella.stdout.info " %-65s  ".att(:reverse) % ["#{plan.desc}  (#{dig})"]
       plan.usecases.each_with_index do |uc,i|
@@ -30,8 +37,24 @@ module Stella::Engine
         Stella.rescue { client.execute uc }
       end
       
-      tl = Benelux.thread_timeline
-      tl.stats.group(:failed).merge.n == 0
+      test_time = Time.now.utc - start_time
+      
+      # Need to use thread timeline b/c the clients are running in the
+      # main thread which Benelux.update_global_timeline does not touch.
+      tt = Benelux.thread_timeline
+      
+      failed = tt.stats.group(:failed).merge
+      total = tt.stats.group(:do_request).merge
+      
+      if Stella::Engine.service
+        data = tt.messages.filter(:kind => :log).to_json
+        Stella::Engine.service.client_log client.digest, data
+        Stella::Engine.service.testrun_summary :successful => (total.n-failed.n),
+                                               :failed => failed.n,
+                                               :duration => test_time
+      end
+      
+      failed == 0
     end
     
     
@@ -42,7 +65,18 @@ module Stella::Engine
       Stella.stdout.info2 "  %-46s %16s ".bright % [desc, notice]
     end
     
+    
     def update_receive_response(client_id, usecase, uri, req, params, headers, counter, container)
+      log = Stella::Engine::Log.new Time.now.to_f, container.unique_id, client_id,
+                                    'testplanid',
+                                    usecase.digest, req.digest,
+                                    req.http_method, container.status, uri,
+                                    params, headers, 
+                                    container.response.header.dump, 
+                                    container.response.body.dump
+
+      Benelux.thread_timeline.add_message log, :status => container.status, :kind => :log
+      
       msg = '  %-6s %-53s ' % [req.http_method, uri]
       msg << container.status.to_s if Stella.stdout.lev == 1
       Stella.stdout.info msg
@@ -52,33 +86,33 @@ module Stella::Engine
         Stella.stdout.info2 "     %s: %s" % pair
       end
       
-      Stella.stdout.info2 $/, '   ' << container.response.request.header.send(:request_line)
+      Stella.stdout.info3 $/, '   ' << container.response.request.header.send(:request_line)
       
       container.response.request.header.all.each do |pair|
-        Stella.stdout.info2 "   %s: %s" % pair
+        Stella.stdout.info3 "   %s: %s" % pair
       end
       
       if req.http_method == 'POST'
         cont = container.response.request.body.content
         if String === cont
-          Stella.stdout.info3('   ' << cont.split($/).join("#{$/}    "))
+          Stella.stdout.info4('   ' << cont.split($/).join("#{$/}    "))
         elsif HTTP::Message::Body::Parts === cont
           cont.parts.each do |part|
             if File === part
-              Stella.stdout.info3 "<#{part.path}>"
+              Stella.stdout.info4 "<#{part.path}>"
             else
-              Stella.stdout.info3 part
+              Stella.stdout.info4 part
             end
           end
         end
       end
       
       resh = container.response.header
-      Stella.stdout.info2 $/, '   HTTP/%s %3d %s' % [resh.http_version, resh.status_code, resh.reason_phrase]
+      Stella.stdout.info3 $/, '   HTTP/%s %3d %s' % [resh.http_version, resh.status_code, resh.reason_phrase]
       container.headers.all.each do |pair|
-        Stella.stdout.info2 "   %s: %s" % pair
+        Stella.stdout.info3 "   %s: %s" % pair
       end
-      Stella.stdout.info3 container.body.empty? ? '   [empty]' : container.body
+      Stella.stdout.info4 container.body.empty? ? '   [empty]' : container.body
       Stella.stdout.info2 $/
     end
     
@@ -92,7 +126,7 @@ module Stella::Engine
     
     def update_request_unhandled_exception(client_id, usecase, uri, req, params, ex)
       #desc = "#{usecase.desc} > #{req.desc}"
-      Stella.le '  ERROR   %24s: %s' % [ex.message, uri]
+      Stella.le '  ERROR   %24s   %s' % [ex.message, uri]
       Stella.le '  %s' % params.inspect
       unless req.headers.nil? || req.headers.empty? 
         Stella.le '  %s' % req.headers.inspect

data/lib/stella/engine/loadbase.rb

@@ -81,7 +81,7 @@ module Stella::Engine
         execute_test_plan packages, opts[:repetitions], opts[:duration], opts[:arrival]
         Stella.stdout.info $/, "Done" 
       rescue Interrupt
-        Stella.stdout.nstatus "Stopping test"
+        Stella.stdout.info $/, "Stopping test"
         Stella.abort!
         @threads.each { |t| t.join } unless @threads.nil? || @threads.empty? # wait
       rescue => ex

data/lib/stella/engine.rb

@@ -1,7 +1,25 @@
 
-
 module Stella::Engine
-  
+  @service = nil
+  class << self
+    attr_accessor :service
+  end
+  class Log < Storable
+    include Selectable::Object
+    field :stamp
+    field :uniqueid
+    field :clientid
+    field :planid
+    field :caseid
+    field :reqid
+    field :httpmethod
+    field :httpstatus
+    field :uri     
+    field :params
+    field :headers
+    field :response_headers
+    field :response_body
+  end
   module Base
     extend self