solutious-stella 0.5.5 → 0.6.0

data/lib/stella/environment.rb

@@ -0,0 +1,66 @@
+module Stella
+  class Environment
+    
+    
+  end
+end
+
+module Stella
+  class Environment
+    
+    attr_accessor :name
+    
+      # An array of `Stella::Common::Machine objects to be use during the test.
+      #     @stella_environments.machines << "stellaaahhhh.com:80"
+    attr_accessor :machines
+      # The default proxy, a Stella::Common::Proxy object containing the proxy to be used for the test.
+    attr_accessor :proxy
+    
+    def initialize(name=:development)
+      @name = name
+      @machines = []
+    end
+
+    
+    def add_machines(*args)
+      return if args.empty?
+      args.each do |machine|
+        @machines << Stella::Common::Machine.new(machine)
+      end
+    end
+    
+    # Creates a Stella::TestPlan::Proxy object and stores it to +@proxy+
+    def proxy=(*args)
+      uri, user, pass = args.flatten
+      @proxy = Stella::Common::Proxy.new(uri, user, pass)
+    end
+    
+    
+  end
+end
+
+module Stella
+  module DSL
+    module Environment
+      attr_accessor :stella_current_environment
+
+      def environments
+        @stella_environments 
+      end
+    
+      def environment(name, &define)
+        @stella_environments ||= {}
+        @stella_current_environment = @stella_environments[name] = Stella::Environment.new(name)
+        define.call if define
+      end
+      
+      def machines(*args)
+        return unless @stella_current_environment.is_a? Stella::Environment
+        args.each do |machine|
+          @stella_current_environment.add_machines machine
+        end
+      end
+      
+    end
+  end
+end

data/lib/stella/functest.rb

@@ -0,0 +1,105 @@
+
+
+
+module Stella
+  class FunctionalTest
+    include TestRunner
+    
+    def type; "functional"; end
+    
+    
+    
+    def update_start(machine, name)
+      puts '-'*60
+      puts "%10s: %s" % ["MACHINE", machine]  
+    end
+    
+    def update_authorized(domain, user, pass)
+      note = user
+      note += ":****" if pass
+      puts "%10s: %s" % ["user", note]
+      puts
+    end
+    
+    def update_request(method, uri, query, response_status, response_headers, response_body)
+      puts "#{method} #{uri}"
+      puts "%18s: %s" % ["status", response_status]
+      puts "%18s: %s" % ["query", query] if @verbose > 0 && !query.empty?
+      puts "%18s: %s" % ["response_headers", response_headers]
+      puts "%18s: #{$/}%s" % ["response_body", response_body[0..100]] if @verbose > 0
+      puts
+    end
+    
+    def update_request_exception(method, uri, query, ex)
+      puts "#{method} #{uri}"
+      puts "EXCEPTION: #{ex.message}"
+      puts ex.backtrace
+    end
+    
+    def update_request_unexpected_response(method, uri, query, response_status, response_headers, response_body)
+      puts "#{method} #{uri}"
+      puts "%18s: %s" % ["status", response_status]
+      puts "%18s: %s" % ["note", "unexpected response status"]
+      puts "", response_body[0..500]
+      puts '...' if response_body.length >= 500
+    end
+    
+    def update_retrying(uri, retry_count, total)
+      puts "retrying: #{uri} (#{retry_count} of #{total})"
+    end
+
+
+    # +environment+ is a Stella::Common::Environment object. 
+    # +namespace+ is a reference to the namespace which contains the instance
+    # variables. This will be the section of code that makes use of the DSL.
+    def run(environment, namespace)
+      raise "No testplan defined" unless @testplan
+      raise "No machines defined for #{environment.name}" if environment.machines.empty?
+      
+      
+      begin
+        if environment.proxy
+          http_client = HTTPClient.new(environment.proxy.uri)
+          http_client.set_proxy_auth(environment.proxy.user, environment.proxy.pass) if environment.proxy.user
+        else
+          http_client = HTTPClient.new
+        end
+      rescue => ex
+        puts ex.class
+      end
+      
+      request_stats = {}
+      environment.machines.each do |machine|
+        client = Stella::Client.new
+        client.add_observer(self)
+        client.execute_testplan(request_stats, http_client, machine, namespace, @testplan, @verbose)
+      end
+      
+
+      request_stats.each do |rstat|
+        puts rstat[1][:stats].to_s
+      end
+    end
+    
+
+  end
+end
+
+
+
+
+module Stella
+    module DSL 
+      module FunctionalTest
+        include Stella::DSL::TestRunner
+      
+      def functest(name=:default, &define)
+        @tests ||= {}
+        @current_test = @tests[name] = Stella::FunctionalTest.new(name)
+        define.call if define
+      end
+      
+      
+    end
+  end
+end

data/lib/stella/loadtest.rb

@@ -0,0 +1,186 @@
+# See, re Threadify on JRuby: http://www.ruby-forum.com/topic/158180
+
+#
+#
+module Stella
+  class LoadTest
+    include TestRunner
+
+    attr_accessor :clients
+    attr_accessor :repetitions
+    attr_accessor :duration
+    
+    attr_reader :testplans_started
+    attr_reader :testplans_completed
+    
+    attr_reader :requests_successful
+    attr_reader :requests_failed
+    
+    def init
+      @repetitions = 1
+      @clients = 1
+      @duration = 0
+      reset
+    end
+    
+    def reset
+      @testplans_started = 0
+      @testplans_completed = 0
+      @requests_successful = 0
+      @requests_failed = 0
+    end
+    
+    def type; "load"; end
+    
+    def requests_total
+      @requests_successful + @requests_failed
+    end
+    
+    def update_start(machine, name)
+      @testplans_started += 1
+    end
+    
+    def update_done(*args)
+      @testplans_completed += 1
+    end
+    
+    def update_authorized(domain, user, pass)
+    end
+    
+    def update_request(method, uri, query, response_status, response_headers, response_body)
+      @requests_successful += 1
+    end
+    
+    def update_request_exception(method, uri, query, ex)
+      @requests_failed += 1
+      puts [method, uri, query, ex.message].join("|")
+    end
+    
+    def update_request_unexpected_response(method, uri, query, response_status, response_headers, response_body)
+      @requests_failed += 1
+      #puts [method, uri, query, response_status, response_headers, response_body].join("|")
+    end
+    
+    def update_retrying(uri, retry_count, total)
+      #print retry_count
+    end
+    
+    
+    # +environment+ is a Stella::Common::Environment object. 
+    # +namespace+ is a reference to the namespace which contains the instance
+    # variables. 
+    def run(environment, namespace)
+      raise "No testplan defined" unless @testplan
+      raise "No machines defined for #{environment.name}" if environment.machines.empty?
+
+      [:duration, :clients, :repetitions].each do |p|
+        val = instance_variable_get("@#{p}")
+        puts " %11s: %s" % [p, val] if val
+      end
+      
+      stats = Stats.new("LoadTest")
+      request_stats = {}
+
+      time_started = Time.now
+      seconds_elapsed = 0
+      (1..@clients).to_a.threadify do |i|
+        
+        (0..@repetitions).to_a.each do |rep|
+
+          if environment.proxy
+            http_client = HTTPClient.new(environment.proxy.uri)
+            http_client.set_proxy_auth(environment.proxy.user, environment.proxy.pass) if environment.proxy.user
+          else
+            http_client = HTTPClient.new
+          end
+
+
+          environment.machines.each do |machine|
+            client = Stella::Client.new(i)
+            client.add_observer(self)
+            client.execute_testplan(request_stats, http_client, machine, namespace, @testplan, @verbose)
+          end
+          
+          seconds_elapsed = Time.now - time_started
+
+          #request_stats.each do |rstat|
+          #  puts rstat[1][:stats].to_s
+          #end
+          
+          # If a duration was given, we make sure to run for that
+          # amount of time.
+          if @duration > 0
+            redo if seconds_elapsed <= @duration 
+            break if seconds_elapsed >= @duration
+          end
+        end
+      end
+
+      stats.tick
+      puts "DONE! (#{seconds_elapsed.minutes} minutes)"
+      instance_variables.each do |name|
+        #next unless name =~ /request/
+        puts "%20s: %s" % [name, instance_variable_get(name)]
+      end
+      
+      puts "Final Status"
+      puts stats.to_s
+      puts
+
+      request_stats.each do |rstat|
+        puts rstat[1][:stats].to_s
+      end
+    end
+    
+    
+    def clients=(*args)
+      count = args.flatten.first
+      @clients = count
+    end
+    
+    def repetitions=(*args)
+      @repetitions = args.flatten.first
+    end
+    
+    def duration=(*args)
+      @duration = args.flatten.first
+    end
+  end
+end
+
+
+
+
+
+
+
+module Stella
+  module DSL 
+    module LoadTest
+      include Stella::DSL::TestRunner
+      
+      def loadtest(name=:default, &define)
+        @tests ||= {}
+        @current_test = @tests[name] = Stella::LoadTest.new(name)
+        define.call if define
+      end
+      
+      def rampup(*args)
+      end 
+      
+      def warmup(*args)
+      end
+          
+      [:repetitions, :duration, :clients].each do |method_name|
+        eval <<-RUBY, binding, '(Stella::DSL::LoadTest)', 1
+        def #{method_name}(*val)
+          return unless @current_test.is_a? Stella::LoadTest
+          @current_test.#{method_name}=(val)
+        end
+        private :#{method_name}
+        RUBY
+      end
+      
+    end
+  end
+end

data/lib/{utils → stella}/stats.rb

@@ -1,26 +1,20 @@
-# Copyright (c) 2005 Zed A. Shaw 
-# You can redistribute it and/or modify it under the same terms as Ruby.
-#
-# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
-# for more information.
 
-# A very simple little class for doing some basic fast statistics sampling.
-# You feed it either samples of numeric data you want measured or you call
-# Stats.tick to get it to add a time delta between the last time you called it.
-# When you're done either call sum, sumsq, n, min, max, mean or sd to get 
-# the information.  The other option is to just call dump and see everything.
-#
-# It does all of this very fast and doesn't take up any memory since the samples
-# are not stored but instead all the values are calculated on the fly.
 
-class Stats
+module Stella
+# Based on Mongrel::Stats, Copyright (c) 2005 Zed A. Shaw
+class Stats    
+
   attr_reader :sum, :sumsq, :n, :min, :max
 
-  def initialize(name=:unknown)
+  def initialize(name)
     @name = name
     reset
   end
-
+  
+  def +(obj)
+    puts obj.class
+  end
+  
   # Resets the internal counters so you can start sampling again.
   def reset
     @sum = 0.0
@@ -41,7 +35,7 @@ class Stats
       @min = s if @min > s
       @max = s if @max < s
     end
-    (@n+=1).to_f
+    @n+=1
   end
 
   # Dump this Stats object with an optional additional message.
@@ -50,7 +44,7 @@ class Stats
   end
 
   # Returns a common display (used by dump)
-  def to_s  
+  def to_s
   "[#{@name}]: SUM=%0.4f, SUMSQ=%0.4f, N=%0.4f, MEAN=%0.4f, SD=%0.4f, MIN=%0.4f, MAX=%0.4f" % [@sum, @sumsq, @n, mean, sd, @min, @max]
   end
 
@@ -62,9 +56,10 @@ class Stats
 
   # 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) ).to_f
+      return Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) )
     rescue Errno::EDOM
       return 0.0
     end
@@ -73,7 +68,7 @@ class Stats
 
   # Adds a time delta between now and the last time you called this.  This
   # will give you the average time between two activities.
-  # 
+  #
   # An example is:
   #
   #  t = Stats.new("do_stuff")
@@ -86,3 +81,4 @@ class Stats
     @last_time = now
   end
 end
+end

data/lib/stella/testplan.rb

@@ -0,0 +1,237 @@
+
+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
+  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
+    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
+    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
+
+    # 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)
+      end
+    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
+  end
+end
+
+