solutious-stella 0.6.0 → 0.7.0.001

data/lib/stella/environment.rb

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

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

@@ -1,186 +0,0 @@
-# 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/stella/testrunner.rb

@@ -1,64 +0,0 @@
-# ---
-# See: http://codeforpeople.com/lib/ruby/flow/flow-2.0.0/sample/a.rb
-# +++
-
-#
-#
-#
-module Stella
-  module TestRunner
-    attr_accessor :name
-      # Name or instance of the testplan to execute
-    attr_accessor :testplan
-      # Determines the amount of output. Default: 0
-    attr_accessor :verbose
-    
-    def initialize(name=:default)
-      @name = name
-      @verbose = 0
-      init if respond_to? :init
-    end
-    
-    def update(*args)
-      what, *args = args
-      self.send("update_#{what}", *args) if respond_to? "update_#{what}"
-    end
-    
-  end
-  module DSL
-    module TestRunner
-      attr_accessor :current_test
-      
-      def plan(testplan)
-        raise "Unknown testplan, '#{testplan}'" unless @plans.has_key?(testplan)
-        return unless @current_test
-        @current_test.testplan = @plans[testplan]
-      end
-      
-      def run(env_name=nil, test_name=nil)
-        to_run = test_name.nil? ? @tests : [@tests[test_name]]
-        env = env_name.nil? ? @stella_environments.first : @stella_environments[env_name]
-        to_run.each do |t|
-          puts '='*60
-          puts "RUNNING TEST: #{test_name}"
-          puts " %11s: %s" % ['type', t.type]
-          puts " %11s: %s" % ['testplan', t.testplan.name]
-          puts " %11s: %s" % ['desc', t.testplan.description]
-          puts " %11s: %s" % ['env', env_name]
-           
-          
-          t.run(env, self)
-        end
-      end
-      
-      def verbose(*args)
-        @current_test.verbose += args.first || 1
-      end
-      
-    private
-      
-    end
-  end
-end
-  
-  

data/lib/storable.rb

@@ -1,280 +0,0 @@
-#--
-# TODO: Handle nested hashes and arrays. 
-# TODO: to_xml, see: http://codeforpeople.com/lib/ruby/xx/xx-2.0.0/README
-# TODO: Rename to Stuffany
-#++
-
-require 'yaml'
-require 'fileutils'
-
-
-# Storable makes data available in multiple formats and can
-# re-create objects from files. Fields are defined using the 
-# Storable.field method which tells Storable the order and 
-# name.
-class Storable
-  VERSION = 2
-  NICE_TIME_FORMAT  = "%Y-%m-%d@%H:%M:%S".freeze unless defined? NICE_TIME_FORMAT
-  SUPPORTED_FORMATS = %w{tsv csv yaml json}.freeze unless defined? SUPPORTED_FORMATS
-  
-  # This value will be used as a default unless provided on-the-fly.
-  # See SUPPORTED_FORMATS for available values.
-  attr_reader :format
-  
-  # See SUPPORTED_FORMATS for available values
-  def format=(v)
-    raise "Unsupported format: #{v}" unless SUPPORTED_FORMATS.member?(v)
-    @format = v
-  end
-  
-  # TODO: from_args([HASH or ordered params])
-  
-  def init
-    # NOTE: I think this can be removed
-    self.class.send(:class_variable_set, :@@field_names, []) unless class_variable_defined?(:@@field_names)
-    self.class.send(:class_variable_set, :@@field_types, []) unless class_variable_defined?(:@@field_types)
-  end
-  
-  # Accepts field definitions in the one of the follow formats:
-  #
-  #     field :product
-  #     field :product => Integer
-  #
-  # The order they're defined determines the order the will be output. The fields
-  # data is available by the standard accessors, class.product and class.product= etc...
-  # The value of the field will be cast to the type (if provided) when read from a file. 
-  # The value is not touched when the type is not provided. 
-  def self.field(args={})
-    # TODO: Examine casting from: http://codeforpeople.com/lib/ruby/fattr/fattr-1.0.3/
-    args = {args => nil} unless args.is_a? Hash
-
-    args.each_pair do |m,t|
-      
-      [[:@@field_names, m], [:@@field_types, t]].each do |tuple|
-        class_variable_set(tuple[0], []) unless class_variable_defined?(tuple[0])
-        class_variable_set(tuple[0], class_variable_get(tuple[0]) << tuple[1])
-      end
-      
-      next if method_defined?(m)
-      
-      define_method(m) do instance_variable_get("@#{m}") end
-      define_method("#{m}=") do |val| 
-        instance_variable_set("@#{m}",val)
-      end
-    end
-  end
-  
-  # Returns an array of field names defined by self.field
-  def self.field_names
-    class_variable_get(:@@field_names)
-  end
-  # Ditto.
-  def field_names
-    self.class.send(:class_variable_get, :@@field_names)
-  end
-  # Returns an array of field types defined by self.field. Fields that did 
-  # not receive a type are set to nil. 
-  def self.field_types
-    class_variable_get(:@@field_types)
-  end
-  # Ditto.
-  def field_types
-    self.class.send(:class_variable_get, :@@field_types)
-  end
-
-  # Dump the object data to the given format. 
-  def dump(format=nil, with_titles=true)
-    format ||= @format
-    raise "Format not defined (#{format})" unless SUPPORTED_FORMATS.member?(format)
-    send("to_#{format}", with_titles) 
-  end
-  
-  # Create a new instance of the object using data from file. 
-  def self.from_file(file_path, format='yaml')
-    raise "Cannot read file (#{file_path})" unless File.exists?(file_path)
-    raise "#{self} doesn't support from_#{format}" unless self.respond_to?("from_#{format}")
-    format = format || File.extname(file_path).tr('.', '')
-    me = send("from_#{format}", read_file_to_array(file_path))
-    me.format = format
-    me
-  end
-  # Write the object data to the given file. 
-  def to_file(file_path=nil, with_titles=true)
-    raise "Cannot store to nil path" if file_path.nil?
-    format = File.extname(file_path).tr('.', '')
-    format ||= @format
-    Storable.write_file(file_path, dump(format, with_titles))
-  end
-
-  # Create a new instance of the object from a hash.
-  def self.from_hash(from={})
-    me = self.new
-  
-    return me if !from || from.empty?
-    
-    fnames = field_names
-    fnames.each_with_index do |key,index|
-      
-      stored_value = from[key] || from[key.to_s] # support for symbol keys and string keys
-      
-      # TODO: Correct this horrible implementation (sorry, me. It's just one of those days.)
-      
-      if field_types[index] == Array
-        ((value ||= []) << stored_value).flatten 
-      elsif field_types[index] == Hash
-        value = stored_value
-      else
-        # SimpleDB stores attribute shit as lists of values
-        value = stored_value.first if stored_value.is_a?(Array) && stored_value.size == 1
-
-        if field_types[index] == Time
-          value = Time.parse(value)
-        elsif field_types[index] == DateTime
-          value = DateTime.parse(value)
-        elsif field_types[index] == TrueClass
-          value = (value.to_s == "true")
-        elsif field_types[index] == Float
-          value = value.to_f
-        elsif field_types[index] == Integer
-          value = value.to_i
-        else
-          value = value.first if value.is_a?(Array) && value.size == 1 # I
-        end
-      end
-      
-      me.send("#{key}=", value) if self.method_defined?("#{key}=")  
-    end
-    
-    me
-  end
-  # Return the object data as a hash
-  # +with_titles+ is ignored. 
-  def to_hash(with_titles=true)
-    tmp = {}
-    field_names.each do |fname|
-      tmp[fname] = self.send(fname)
-    end
-    tmp
-  end
-  
-  # Create a new instance of the object from YAML. 
-  # +from+ a YAML string split into an array by line. 
-  def self.from_yaml(from=[])
-    # from is an array of strings
-    from_str = from.join('')
-    hash = YAML::load(from_str)
-    hash = from_hash(hash) if hash.is_a? Hash 
-    hash
-  end
-  def to_yaml(with_titles=true)
-    to_hash.to_yaml
-  end
-  
-  # Create a new instance of the object from a JSON string. 
-  # +from+ a JSON string split into an array by line.
-  def self.from_json(from=[])
-    require 'json'
-    # from is an array of strings
-    from_str = from.join('')
-    tmp = JSON::load(from_str)
-    hash_sym = tmp.keys.inject({}) do |hash, key|
-       hash[key.to_sym] = tmp[key]
-       hash
-    end
-    hash_sym = from_hash(hash_sym) if hash_sym.is_a? Hash  
-    hash_sym
-  end
-  def to_json(with_titles=true)
-    require 'json'
-    to_hash.to_json
-  end
-  
-  # Return the object data as a delimited string. 
-  # +with_titles+ specifiy whether to include field names (default: false)
-  # +delim+ is the field delimiter.
-  def to_delimited(with_titles=false, delim=',')
-    values = []
-    field_names.each do |fname|
-      values << self.send(fname.to_s)   # TODO: escape values
-    end
-    output = values.join(delim)
-    output = field_names.join(delim) << $/ << output if with_titles
-    output
-  end
-  # Return the object data as a tab delimited string. 
-  # +with_titles+ specifiy whether to include field names (default: false)
-  def to_tsv(with_titles=false)
-    to_delimited(with_titles, "\t")
-  end
-  # Return the object data as a comma delimited string. 
-  # +with_titles+ specifiy whether to include field names (default: false)
-  def to_csv(with_titles=false)
-    to_delimited(with_titles, ',')
-  end
-  # Create a new instance from tab-delimited data.  
-  # +from+ a JSON string split into an array by line.
-  def self.from_tsv(from=[])
-    self.from_delimited(from, "\t")
-  end
-  # Create a new instance of the object from comma-delimited data.
-  # +from+ a JSON string split into an array by line.
-  def self.from_csv(from=[])
-    self.from_delimited(from, ',')
-  end
-  
-  # Create a new instance of the object from a delimited string.
-  # +from+ a JSON string split into an array by line.
-  # +delim+ is the field delimiter.
-  def self.from_delimited(from=[],delim=',')
-    return if from.empty?
-    # We grab an instance of the class so we can 
-    hash = {}
-    
-    fnames = values = []
-    if (from.size > 1 && !from[1].empty?)
-      fnames = from[0].chomp.split(delim)
-      values = from[1].chomp.split(delim)
-    else
-      fnames = self.field_names
-      values = from[0].chomp.split(delim)
-    end
-    
-    fnames.each_with_index do |key,index|
-      next unless values[index]
-      hash[key.to_sym] = values[index]
-    end
-    hash = from_hash(hash) if hash.is_a? Hash 
-    hash
-  end
-
-  def self.read_file_to_array(path)
-    contents = []
-    return contents unless File.exists?(path)
-    
-    open(path, 'r') do |l|
-      contents = l.readlines
-    end
-
-    contents
-  end
-  
-  def self.write_file(path, content, flush=true)
-    write_or_append_file('w', path, content, flush)
-  end
-  
-  def self.append_file(path, content, flush=true)
-    write_or_append_file('a', path, content, flush)
-  end
-  
-  def self.write_or_append_file(write_or_append, path, content = '', flush = true)
-    #STDERR.puts "Writing to #{ path }..." 
-    create_dir(File.dirname(path))
-    
-    open(path, write_or_append) do |f| 
-      f.puts content
-      f.flush if flush;
-    end
-    File.chmod(0600, path)
-  end
-end
-