stella 0.7.3.002 → 0.7.4.001

data/lib/stella/stats.rb

@@ -1,79 +0,0 @@
-
-module Stella
-# Based on Mongrel::Stats, Copyright (c) 2005 Zed A. Shaw
-class Stats < Array
-
-  attr_reader :sum, :sumsq, :n, :min, :max
-
-  def initialize
-    reset
-  end
-  
-  def +(obj)
-    puts obj.class
-  end
-  
-  # Resets the internal counters so you can start sampling again.
-  def reset
-    self.clear
-    @n, @sum, @sumsq = 0.0, 0.0, 0.0
-    @last_time = 0.0
-    @min, @max = 0.0, 0.0
-  end
-
-  # Adds a sampling to the calculations.
-  def sample(s)
-    self << s
-    update s
-  end
-  
-  def update(s)
-    @sum += s
-    @sumsq += s * s
-    if @n == 0
-      @min = @max = s
-    else
-      @min = s if @min > s
-      @max = s if @max < s
-    end
-    @n+=1
-  end
-  
-  # Dump this Stats object with an optional additional message.
-  def dump(msg = "", out=STDERR)
-    out.puts "#{msg}: #{self.inspect}"
-  end
-
-  # Returns a common display (used by dump)
-  def inspect
-    v = [mean, @n, @sum, @sumsq, sd, @min, @max]
-    t = %q"N=%0.4f SUM=%0.4f SUMSQ=%0.4f SD=%0.4f MIN=%0.4f MAX=%0.4f"
-    ("%0.4f: " << t) % v
-  end
-
-  def to_s; mean.to_s; end
-  def to_f; mean.to_f; end
-  def to_i; mean.to_i; end
-  
-  # Calculates and returns the mean for the data passed so far.
-  def mean; return 0.0 unless @n > 0; @sum / @n; end
-
-  # Calculates the standard deviation of the data so far.
-  def sd
-    return 0.0 if @n <= 1
-    # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).n)) / ((s).n-1) ))
-    begin
-      return Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) )
-    rescue Errno::EDOM
-      return 0.0
-    end
-  end
-  
-  def recalculate
-    samples = self.clone
-    reset
-    samples.each { |s| sample(s) }
-  end
-  
-end
-end

data/lib/stella/testplan/stats.rb

@@ -1,26 +0,0 @@
-
-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

@@ -1,119 +0,0 @@
-autoload :CSV, 'csv'
-
-module Stella
-class Testplan
-  
-  #
-  # Any valid Ruby syntax will do the trick:
-  #
-  #     usecase(10, "Self-serve") {
-  #       post("/listing/add", "Add a listing") {
-  #         wait 1..4 
-  #         param :name => random(8)
-  #         param :city => "Vancouver"
-  #         response(302) {
-  #           repeat 3
-  #         }
-  #       }
-  #     }
-  #
-  class Usecase
-    include Gibbler::Complex
-    include Stella::Data::Helpers
-    extend Attic
-    
-    class Auth < Struct.new(:kind, :user, :pass)
-      include Gibbler::Complex
-    end
-    
-    attic :base_path # we don't want gibbler to see this
-    attic :plan_path
-    
-    attr_accessor :desc
-    attr_writer :ratio
-    attr_reader :http_auth
-    
-    attr_accessor :requests
-    attr_accessor :resources
-    
-    class UnknownResource < Stella::Error
-      def message; "UnknownResource: #{@obj}"; end
-    end
-    
-    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
-    
-    def ratio_pretty
-      r = (@ratio || 0).to_f
-      r > 1.0 ? r.to_i : (r * 100).to_i
-    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 read(path)
-      path = File.join(base_path, path) if base_path
-      Stella.ld "READING FILE: #{path}"
-      File.read(path)
-    end
-      
-    def list(path)
-      read(path).split $/
-    end
-    
-    def csv(path)
-      path = File.join(base_path, path) if base_path
-      Stella.ld "READING CSV: #{path}"
-      CSV.read(path)
-    end
-    
-    def freeze
-      @requests.each { |r| r.freeze }
-      super
-      self
-    end
-    
-    def auth(user, pass=nil, kind=:basic)
-      @http_auth ||= Auth.new
-      @http_auth.user, @http_auth.pass, @http_auth.kind = user, pass, kind
-    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

data/lib/stella/version.rb

@@ -1,15 +0,0 @@
-
-
-module Stella
-  module VERSION
-    unless defined?(MAJOR)
-      MAJOR = 0.freeze
-      MINOR = 7.freeze
-      TINY  = 3.freeze
-      PATCH = '002'.freeze 
-    end
-    def self.to_s; [MAJOR, MINOR, TINY].join('.'); end
-    def self.to_f; self.to_s.to_f; end
-    def self.patch; PATCH; end
-  end
-end