solutious-stella 0.6.0 → 0.7.0.001

data/lib/stella/mixins.rb

@@ -0,0 +1,2 @@
+
+Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'mixins', '*.rb')

data/lib/stella/stats.rb

@@ -1,5 +1,4 @@
 
-
 module Stella
 # Based on Mongrel::Stats, Copyright (c) 2005 Zed A. Shaw
 class Stats    
@@ -17,12 +16,9 @@ class Stats
   
   # Resets the internal counters so you can start sampling again.
   def reset
-    @sum = 0.0
-    @sumsq = 0.0
+    @n, @sum, @sumsq = 0.0, 0.0, 0.0
     @last_time = Time.new
-    @n = 0.0
-    @min = 0.0
-    @max = 0.0
+    @min, @max = 0.0, 0.0
   end
 
   # Adds a sampling to the calculations.
@@ -81,4 +77,4 @@ class Stats
     @last_time = now
   end
 end
-end
+end

data/lib/stella/testplan.rb

@@ -1,237 +1,112 @@
+require 'stella/testplan/usecase'
+require 'stella/testplan/stats'
 
 module Stella
-  class TestPlan
-    class ResponseHandler
-      attr_accessor :action
-      attr_accessor :times
-      attr_accessor :wait
-      def initialize(action, times=1, wait=1)
-        @action = action
-        @times = times
-        @wait = wait
-      end
-    end
+class Testplan
+  include Gibbler::Complex
+  
+  class WackyRatio < Stella::Error
   end
-end
-
-module Stella
-
-  class TestPlan
-      # The name of the testplan. 
-    attr_accessor :name
-      # A brief description of this testplan
-    attr_accessor :description
-      # Used as the default protocol for the testplan. One of: http, https 
-    attr_accessor :protocol
-      # A Stella::TestPlan::Auth object
-    attr_accessor :auth
-      # An array of Stella::TestPlan::Request objects representing all "primary" requests
-      # for the given test plan (an html page for example). Each primary Request object can have an array of "auxilliary"
-      # requests which represent dependencies for that resource (javascript, images, callbacks, etc...).
-    attr_accessor :requests
-      
-    def initialize(name=:anonymous)
-      @name = name
-      @requests = []
-      @servers = []
-      @protocol = "http"
-    end
-    
 
-    def description
-      @description
-    end
-    def description=(val)
-      val = val.first if val.is_a? Array
-      @description = val
+  
+  attr_accessor :usecases
+  attr_accessor :base_path
+  attr_accessor :desc
+  attr_reader :stats
+  
+  def initialize
+    @desc, @usecases = "Stella's plan", []
+    @testplan_current_ratio = 0
+    @stats = Stella::Testplan::Stats.new
+  end
+  
+  def self.load_file(path)
+    conf = File.read path
+    plan = Stella::Testplan.new
+    plan.base_path = File.dirname path
+    # eval so the DSL code can be executed in this namespace.
+    plan.instance_eval conf
+    plan
+  end
+  
+  def check!
+    # Adjust ratios if necessary
+    needy = @usecases.select { |u| u.ratio == -1 }
+    needy.each do |u|
+      u.ratio = (remaining_ratio / needy.size).to_f
     end
-    
-    alias :desc  :description
-    alias :desc= :description=
-    
-    # Append a Stella::TestPlan::Request object to +requests+.
-    def add_request(req)
-      raise "That is not an instance of Stella::Data::HTTPRequest" unless req.is_a? Stella::Data::HTTPRequest
-      @requests << req
+    # Give usecases a name if necessary
+    @usecases.each_with_index { |uc,i| uc.desc ||= "Usecase ##{i+1}" }
+    if @testplan_current_ratio > 1.0 
+      msg = "Usecase ratio cannot be higher than 1.0"
+      msg << " (#{@testplan_current_ratio})"
+      raise WackyRatio, msg
     end
+  end
     
-      
-    # Creates a Stella::TestPlan::Auth object and stores it to +@auth+
-    def auth=(*args)
-      type, user, pass = args.flatten
-      @auth = Stella::Common::Auth.new(type, user, pass)
-    end
+  def usecase(*args, &blk)
+    return @usecases if args.empty?
+    ratio, name = nil,nil
+    ratio, name = args[0], args[1] if args[0].is_a?(Numeric)
+    ratio, name = args[1], args[0] if args[0].is_a?(String)
+    uc = Stella::Testplan::Usecase.new
+    uc.base_path = @base_path
+    uc.instance_eval &blk
+    uc.ratio, uc.desc = (ratio || -1).to_f, name
+    @testplan_current_ratio += uc.ratio if uc.ratio > 0
+    add_usecase uc
+  end
+  def xusecase(*args, &blk); Stella.ld "Skipping usecase"; end
+  
+  def add_usecase(uc)
+    Stella.ld "Usecase: #{uc.desc}"
+    @usecases << uc
+    uc
+  end
+  
+  def desc(*args)
+    @desc = args.first unless args.empty?
+    @desc
+  end
 
-    # A string to be parsed by URI#parsed or a URI object. The host and port are added to +@servers+ 
-    # in the form "host:port". The protocol is stored in +@protocol+. NOTE: The 
-    # protocol is used as a default for the test and if it's already set, this 
-    # method will not try to overwrite it. 
-    def base_uri=(*args)
-      uri_str = args.flatten.first
-      begin
-        uri = URI.parse uri_str
-        host_str = uri.host
-        host_str << ":#{uri.port}" if uri.port
-        @servers << host_str
-        @protocol = uri.scheme unless @protocol
-      rescue => ex
-        Stella.fatal(ex)
+  def pretty
+    str = []
+    str << " %-50s ".att(:reverse) % [@desc]
+    @usecases.each_with_index do |uc,i| 
+      description = uc.desc || "Usecase ##{i+1}"
+      str << "  %s (%s)".bright % [description, uc.ratio]
+      requests = uc.requests.each do |r| 
+        str << "    %-35s %s" % ["#{r.desc}:", r]
+        if Stella.loglev > 2
+          [:wait].each { |i| str << "      %s: %s" % [i, r.send(i)] }
+        end
       end
     end
-    
-    
+    str.join($/)
+  end
+  
+  private
+  def remaining_ratio
+    1.0 - @testplan_current_ratio
   end
-
   
 end
+end
 
-
-
-
-
-
-
-
-
-module Stella
-  module DSL
-    module TestPlan 
-      attr_accessor :current_plan
-      attr_accessor :current_request
-
-      def testplan(name, &define)
-        @plans ||= {}
-        @current_plan = @plans[name] = Stella::TestPlan.new(name)
-        define.call if define
-      end
-
-      def plans
-        @plans 
-      end
-      
-      def repeat(*args)
-        raise "Repeat format does not look like a hash" unless args.first.is_a?(Hash)
-        response_handler = Stella::TestPlan::ResponseHandler.new(:repeat)
-        [:times, :wait].each do |att|
-          response_handler.send("#{att}=", args.first[att])
-        end
-        
-        response_handler
-      end
-      
-      def body(*args)
-        
-        raise "current_plan is not a valid testplan: #{@current_plan}" unless @current_plan.is_a? Stella::TestPlan
-        
-        # NOTE: @current_request must be set in the calling namespace
-        # before this method is called. See: make_request
-        raise "current_request is not a valid request" unless @current_request.is_a? Stella::Data::HTTPRequest
-        
-        param, content_type, content = args if args.size == 3
-        param, content = args if args.size == 2
-        content = args.first if args.size == 1
-        
-        @current_request.add_body(content, param, content_type)
-      end
-      
-      def name(*args)
-        raise "current_plan is not a valid testplan: #{@current_plan}" unless @current_plan.is_a? Stella::TestPlan
-        
-        # NOTE: @current_request must be set in the calling namespace
-        # before this method is called. See: make_request
-        raise "current_request is not a valid request" unless @current_request.is_a? Stella::Data::HTTPRequest
-        @current_request.name = args.first
-      end
-      
-      
-      def response(*args, &b)
-        raise "current_plan is not a valid testplan" unless @current_plan.is_a? Stella::TestPlan
-        
-        # NOTE: @current_request must be set in the calling namespace
-        # before this method is called. See: make_request
-        raise "current_request is not a valid request" unless @current_request.is_a? Stella::Data::HTTPRequest
-        
-        @current_request.add_response_handler(*args, &b)
-      end
-      private :response
-      
-      # Stella::Data::HTTPRequest#add_ methods
-      [:header, :param].each do |method_name|
-        eval <<-RUBY, binding, '(Stella::DSL::TestPlan)', 1
-        def #{method_name}(*args, &b)
-          raise "current_plan is not a valid testplan" unless @current_plan.is_a? Stella::TestPlan
-          
-          # NOTE: @current_request must be set in the calling namespace
-          # before this method is called. See: make_request
-          raise "current_request is not a valid request" unless @current_request.is_a? Stella::Data::HTTPRequest
-          
-          @current_request.add_#{method_name}(*args, &b)
-        end
-        private :#{method_name}
-        RUBY
-      end
-      
-      # TestPlan#= methods
-      [:proxy, :auth, :base_uri, :desc, :description].each do |method_name|
-        eval <<-RUBY, binding, '(Stella::DSL::TestPlan)', 1
-        def #{method_name}(*args)
-          return unless @current_plan.is_a? Stella::TestPlan
-          @current_plan.#{method_name}=(args)
-        end
-        private :#{method_name}
-        RUBY
-      end
-      
-      # = methods 
-      [:protocol].each do |method_name|
-        eval <<-RUBY, binding, '(Stella::DSL::TestPlan)', 1
-        def #{method_name}(val)
-          return unless @current_plan.is_a? Stella::TestPlan
-          @current_plan.#{method_name}=(val.to_s)
-        end
-        private :#{method_name}
-        RUBY
-      end
-      
-      def post(uri, &define)
-        make_request(:POST, uri, &define)
-      end
-        def xpost(*args); end;
-        def xget(*args); end;
-      
-      def get(uri, &define)
-        make_request(:GET, uri, &define)
-      end
-      
-    private
-      
-      def make_request(method, uri, &define)
-        return unless @current_plan.is_a? Stella::TestPlan
-        req = Stella::Data::HTTPRequest.new(uri, method.to_s.upcase)
-        @current_plan.add_request req
-        index = @current_plan.requests.size
-        method_name = :"#{index} #{req.http_method} #{req.uri}"
-        
-        req_method = Proc.new {
-          # These instance variables are very important. The bring in the context
-          # when the request method is called in the testrunner class. We know what 
-          # the current plan is while we're executing the DSL blocks to define the 
-          # request. The response block however, is called only after a require request
-          # is made. We set these instance variables so that the response block will
-          # know what request it's associated too.  
-          instance_variable_set('@current_plan', @current_plan)
-          instance_variable_set('@current_request', req)
-          define.call if define
-          req
-        }
-        metaclass.instance_eval do
-          define_method(method_name, &req_method) 
-        end
-
-      end
-      
+__END__
+# instance_exec for Ruby 1.8 written by Mauricio Fernandez
+# http://eigenclass.org/hiki/instance_exec
+if RUBY_VERSION =~ /1.8/
+  module InstanceExecHelper; end
+  include InstanceExecHelper
+  def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
+    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+    InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
     end
+    ret
   end
 end
-
-

data/lib/stella/testplan/stats.rb

@@ -0,0 +1,26 @@
+
+module Stella
+class Testplan
+
+  class Stats
+    include Gibbler::Complex
+    attr_reader :requests
+
+    def initialize
+      @requests = OpenStruct.new
+      reset
+    end
+    
+    def total_requests
+      @requests.successful + @requests.failed
+    end
+    
+    def reset 
+      @requests.successful = 0
+      @requests.failed = 0
+    end
+    
+  end
+    
+end
+end

data/lib/stella/testplan/usecase.rb

@@ -0,0 +1,67 @@
+
+
+module Stella
+class Testplan
+  
+  class Usecase
+    include Gibbler::Complex
+    attr_accessor :desc
+    attr_accessor :requests
+    attr_writer :ratio
+    attr_accessor :resources
+    attr_accessor :base_path
+    
+    def initialize(&blk)
+      @requests, @resources = [], {}
+      instance_eval &blk unless blk.nil?
+    end
+    
+    def desc(*args)
+      @desc = args.first unless args.empty?
+      @desc
+    end
+    
+    def resource(name, value=nil)
+      @resources[name] = value unless value.nil?
+      @resources[name]
+    end
+    
+    def ratio
+      r = (@ratio || 0).to_f
+      r = r/100 if r > 1 
+      r
+    end
+    
+    # Reads the contents of the file <tt>path</tt> (the current working
+    # directory is assumed to be the same directory containing the test plan).
+    def file(path)
+      path = File.join(@base_path, path) if @base_path
+      File.read(path)
+    end
+    
+    def list(path)
+      file(path).split $/
+    end
+    
+    def add_request(meth, *args, &blk)
+      req = Stella::Data::HTTP::Request.new meth.to_s.upcase, args[0], &blk
+      req.desc = args[1] if args.size > 1 # Description is optional
+      Stella.ld req
+      @requests << req
+      req
+    end
+    def get(*args, &blk);    add_request :get,    *args, &blk; end
+    def put(*args, &blk);    add_request :put,    *args, &blk; end
+    def post(*args, &blk);   add_request :post,   *args, &blk; end
+    def head(*args, &blk);   add_request :head,   *args, &blk; end
+    def delete(*args, &blk); add_request :delete, *args, &blk; end
+    
+    def xget(*args, &blk);    Stella.ld "Skipping get" end
+    def xput(*args, &blk);    Stella.ld "Skipping put" end
+    def xpost(*args, &blk);   Stella.ld "Skipping post" end
+    def xhead(*args, &blk);   Stella.ld "Skipping head" end
+    def xdelete(*args, &blk); Stella.ld "Skipping delete" end
+    
+  end
+end
+end