stella 0.7.6.005 → 0.7.6.007

data/CHANGES.txt

@@ -1,15 +1,37 @@
 STELLA, CHANGES
 
-#### 0.7.7 (2009-11-??) ###############################
+#### 0.8.0 (2009-12-??) ###############################
+
+* FIXED: HTTP auth failures
+* FIXED: Request timeouts should count towards failures
+* FIXED: Stella::Client ID was changing between requests in certain conditions
+* ADDED: follow responses can contain definition blocks
+* ADDED: Support for specifying default path prefix on CLI
+* ADDED: Support for specifying timeouts
+
+* TODO: Replace runtime procs with string templates
+* TODO: review cooking handling. Not always sent automatically. 
+* TODO: global responses
+* TODO: review :variables in URI elements
+
+
+#### 0.7.7 (2009-12-05) ###############################
 
 * FIXED: JSON parse error when nil body 
 * FIXED: URI query parameter encoding
 * CHANGE: Removed Stella::Testplan::Stats
+* CHANGE: Better output for errors during functional tests
+* CHANGE: Global variables now implemented in Stella::Testplan.global
+  and can be used like usecase and request resources.
+* CHANGE: Variable replacement now checks the client container 
+  resources before the usecase resources. 
 * ADDED: Stella::Testplan#to_json
 * ADDED: Stella::Data::Helpers#read_file
 * ADDED: Stella::Data::Helpers#resequential
 * ADDED: Stella::Data::Helpers#path
 * ADDED: no-param, no-header options
+* ADDED: Follow redirects within one request definition
+* ADDED: Support for specifying HTTP AUTH domain in usecase config 
 
 
 #### 0.7.6 (2009-11-24) ###############################

data/bin/stella

@@ -54,11 +54,7 @@ class Stella::CLI::Definition
     String.disable_color
     Stella.log.output = v
   end
-  global :var, String, 'Set an arbitrary variable (--var "name=v")' do |var|
-    n, v = *var.split('=')
-    raise "Bad variable format: #{var}" if n.nil? || !n.match(/[a-z]+/i)
-    eval "$#{n} = '#{v}'"
-  end
+  global :var, Array, 'Set an arbitrary variable (--var "name=v")'
   global :f, :format, String, "Output format (partial support)"
   global :n, :nocolor, "Disable output colors" do
     String.disable_color
@@ -69,11 +65,15 @@ class Stella::CLI::Definition
   global :v, :verbose, "Increase verbosity of output (e.g. -v or -vv or -vvv)" do
     Stella.stdout.lev += 1
   end
-  global :'disable-stats', "Disable stat collection"
-  global :'disable-logging', "Disable all logging" do
+  global :'no-stats', "Disable stat collection" do
+    true
+  end
+  global :'no-logging', "Disable all logging" do
     Stella::Logger.disable!
   end
-  global :'disable-templates', "Disable template parsing"
+  global :'no-templates', "Disable template parsing" do
+    true
+  end
   global :V, :version, "Display version number" do
     puts "Stella version: #{Stella::VERSION} (#{Stella::VERSION::PATCH})"
     exit 0

data/examples/dynamic/plan.rb

@@ -0,0 +1,61 @@
+# Stella Test Plan - Dynamic Data (2009-11-28)
+#
+#
+# 1. START THE EXAMPLE APPLICATION
+# 
+# This test plan is written to work with the
+# example application that ships with Stella. 
+# See:
+#
+# $ stella example
+#
+#
+# 2. RUN THE TEST PLAN
+#
+# $ stella verify -p examples/dynamic/plan.rb http://127.0.0.1:3114/
+# 
+# $ stella generate -c 2 -r 2 -p examples/dynamic/plan.rb http://127.0.0.1:3114/
+#
+usecase "Dynamic Data" do
+  
+  # Specify HTTP Authentication (Basic or Digest). 
+  # Specify a username, password, and optional value
+  # to use for the authentication domain. If no domain
+  # is specifed, the root URI will be used. 
+  #auth :user, :password, 'http://domain/'
+  
+  # Retrieve a list of listings and store
+  # them in a resource called listing_ids.
+  get '/listings.yaml', "Get Listings" do
+    response 200 do
+      listings = doc.collect! { |l|; l[:id]; }
+      set :listing_ids, listings[0..2]
+    end
+  end
+  
+  # Access each listing page in the order
+  get "/listing/:lid.yaml", "Sequential" do
+    param :lid => sequential(:listing_ids)
+    response 200 do
+      repeat 5
+    end
+  end
+  
+  # Access each listing page in reverse order
+  get "/listing/:lid.yaml", "Reverse Sequential" do
+    param :lid => rsequential(:listing_ids)
+    
+    response 200 do
+      repeat 5
+    end
+  end
+ 
+  # Access listing pages in random order
+  get "/listing/:lid.yaml", "Random" do
+    param :lid => random(:listing_ids)
+    response 200 do
+      repeat 5
+    end
+  end
+   
+end

data/examples/timeout/plan.rb

@@ -0,0 +1,18 @@
+# Stella Test Plan - Timeouts (2009-12-08)
+#
+# TO BE DOCUMENTED. 
+# 
+# If you're reading this, remind me!
+#
+
+
+usecase "Timeout" do
+  timeout 20
+  
+  get "/" do
+    timeout 0.01
+  end
+  
+  get "/"
+  
+end

data/examples/variables/plan.rb

@@ -0,0 +1,40 @@
+# Stella Test Plan - Using Variables (2009-12-04)
+#
+#
+# 1. START THE EXAMPLE APPLICATION
+# 
+# This test plan is written to work with the
+# example application that ships with Stella. 
+# See:
+#
+# $ stella example
+#
+# 2. RUN THE TESTPLAN
+#
+# $ stella --var globalvar=smoked verify -p examples/variables/plan.rb
+#
+#
+usecase "Form Example" do
+  set :uri => 'http://localhost:3114'
+  set :apple => resource(:globalvar)
+  
+  # Variables can be used in the request URIs. Stella looks
+  # for a replacement value in the usecase resources, then
+  # in the params, and then in global variables. 
+  get ":uri" do
+  end
+  
+  # URI variables can also be specified with a dollar sign. 
+  get "$uri/search" do
+    param :what => resource(:globalvar)
+    response do
+      puts "  Global variable: " << resource(:globalvar)
+      puts "  Usecase variable: " << resource(:uri)
+      puts "  Usecase copy of global: " << resource(:apple)
+    end
+  end
+  
+  get 
+  
+end
+

data/lib/stella.rb

@@ -23,7 +23,7 @@ module Stella
       MAJOR = 0.freeze
       MINOR = 7.freeze
       TINY  = 6.freeze
-      PATCH = '005'.freeze 
+      PATCH = '007'.freeze 
     end
     def self.to_s; [MAJOR, MINOR, TINY].join('.'); end
     def self.to_f; self.to_s.to_f; end
@@ -123,7 +123,6 @@ class Storable
     #
     # This allows an object to have a preset ID. 
     #
-    # NOTE: Does not assign a value to +@id+. 
     def gibbler_id_processor
       Proc.new do |val|
         @id || self.gibbler

data/lib/stella/cli.rb

@@ -19,9 +19,10 @@ class Stella::CLI < Drydock::Command
     opts = {}
     opts[:hosts] = @hosts
     opts[:nowait] = true if @option.nowait
-    [:'disable-templates', :'disable-stats', :'no-header', :'no-param'].each do |opt|
+    [:'no-templates', :'no-stats', :'no-header', :'no-param'].each do |opt|
       opts[opt] = @global.send(opt) unless @global.send(opt).nil?
     end
+    
     ret = Stella::Engine::Functional.run @testplan, opts
     @exit_code = (ret ? 0 : 1)
   end
@@ -37,7 +38,7 @@ class Stella::CLI < Drydock::Command
       opts[opt] = @option.send(opt) unless @option.send(opt).nil?
     end
 
-    [:'disable-templates', :'disable-stats', :'no-header', :'no-param'].each do |opt|
+    [:'no-templates', :'no-stats', :'no-header', :'no-param'].each do |opt|
       opts[opt] = @global.send(opt) unless @global.send(opt).nil?
     end
     
@@ -99,6 +100,11 @@ class Stella::CLI < Drydock::Command
       uri = 'http://' << uri unless uri.match /^https?:\/\//i
       URI.parse uri; 
     }
+    (@global.var || []).each do |var|
+      n, v = *var.split('=')
+      raise "Bad variable format: #{var}" if n.nil? || !n.match(/[a-z]+/i)
+      Stella::Testplan.global(n.to_sym, v)
+    end
     if @option.testplan
       @testplan = Stella::Testplan.load_file @option.testplan
     else

data/lib/stella/client.rb

@@ -6,6 +6,7 @@ Stella::Utils.require_vendor "httpclient", '2.1.5.2'
 
 module Stella
   class Client
+    MAX_REDIRECTS = 5.freeze unless defined?(MAX_REDIRECTS)
     
     require 'stella/client/container'
     
@@ -18,7 +19,7 @@ module Stella
     
     def initialize(base_uri=nil, client_id=1, opts={})
       opts = {
-        :'disable-templates' => true
+        :'no-templates' => false
       }.merge! opts
       @opts = opts
       @base_uri, @client_id = base_uri, client_id
@@ -26,9 +27,10 @@ module Stella
       @proxy = OpenStruct.new
     end
     def execute(usecase, &stat_collector)
-      # We need to make sure the gibbler cache has a value
-      self.gibbler if self.digest_cache.nil?
-      
+#      Gibbler.enable_debug
+      # We need to make sure the digest cache has a value
+      self.digest if self.digest_cache.nil?
+      Gibbler.disable_debug
       http_client = create_http_client
       stats = {}
       container = Container.new(self.digest_cache, usecase)
@@ -50,28 +52,35 @@ module Stella
           headers = prepare_headers(container, req.headers)
         
           container.params, container.headers = params, headers
-        
+          
           uri = build_request_uri req.uri, params, container
           
-          if http_auth = usecase.http_auth || req.http_auth
+          if http_auth = req.http_auth || usecase.http_auth
             # TODO: The first arg is domain and can include a URI path. 
             #       Are there cases where this is important?
-            domain = '%s://%s:%d%s' % [uri.scheme, uri.host, uri.port, req.uri] 
+            domain = http_auth.domain
+            domain ||= '%s://%s:%d%s' % [uri.scheme, uri.host, uri.port, req.uri] 
+            domain = container.instance_eval &domain if Proc === domain
             Stella.ld "DOMAIN " << domain
             user, pass = http_auth.user, http_auth.pass
             user = container.instance_eval &user if Proc === user
             pass = container.instance_eval &pass if Proc === pass
-            update(:authenticate, usecase, req, http_auth.kind, domain, user, pass)
+            update(:authenticate, usecase, req, domain, user, pass)
             http_client.set_auth(domain, user, pass)
           end
-        
+          
+          if tout = req.timeout || usecase.timeout
+            http_client.receive_timeout = tout
+          end
+          Stella.ld "TIMEOUT " << http_client.receive_timeout.to_s
+          
           raise NoHostDefined, req.uri if uri.host.nil? || uri.host.empty?
-          stella_id = [Time.now.to_f, self.digest_cache, req.digest_cache, params, headers, counter].gibbler
+          stella_id = [Time.now.to_f, self.digest_cache, req.digest_cache, params, headers, counter].digest
         
           Benelux.add_thread_tags :request => req.digest_cache
           Benelux.add_thread_tags :retry => counter
           Benelux.add_thread_tags :stella_id => stella_id
-        
+          
           container.unique_id = stella_id[0..10]
           
           params['__stella'] = container.unique_id unless @opts[:'no-param']
@@ -111,9 +120,11 @@ module Stella
             Benelux.remove_thread_tags :asset
           end
           asset_duration = Time.now - asset_start
-        rescue HTTPClient::ConnectTimeoutError => ex
+        rescue HTTPClient::ConnectTimeoutError, HTTPClient::SendTimeoutError,
+               HTTPClient::ReceiveTimeoutError => ex
           update(:request_timeout, usecase, uri, req, params, headers, counter, container)
           Benelux.remove_thread_tags :status, :retry, :request, :stella_id
+          next
         rescue => ex
           update(:request_unhandled_exception, usecase, uri, req, params, ex)
           Benelux.remove_thread_tags :status, :retry, :request, :stella_id
@@ -128,6 +139,17 @@ module Stella
           update(:request_repeat, counter, ret.times+1, uri, container)
           Benelux.remove_thread_tags :status
           redo if counter <= ret.times
+        when "Stella::Client::Follow"
+          ret.uri ||= container.header['Location'].first
+          if counter > MAX_REDIRECTS
+            update(:max_redirects, counter-1, ret, uri, container)
+            break
+          else
+            req = ret.generate_request(req)
+            update(:follow_redirect, ret, uri, container)
+            Benelux.remove_thread_tags :status, :request
+            redo
+          end
         when "Stella::Client::Quit"
           update(:usecase_quit, ret.message, uri, container)
           Benelux.remove_thread_tags :status
@@ -200,7 +222,7 @@ module Stella
       #Stella.ld "PREPARE HEADERS: #{headers}"
       hashobj.each_pair do |n,v|
         v = container.instance_eval &v if v.is_a?(Proc)
-        if @opts[:'disable-templates']
+        unless @opts[:'no-templates']
           v = container.parse_template v if String === v
         end
         v = extra.call(v) unless extra.nil?
@@ -220,6 +242,7 @@ module Stella
     # if necessary and replaces all variables with literal values.
     # If no replacement value can be found, the variable will remain. 
     def build_request_uri(uri, params, container)
+      raise "Request given with no URI" if uri.nil?
       newuri = uri.clone  # don't modify uri template
       # We call uri.clone b/c we modify uri. 
       uri.scan(/([:\$])([a-z_]+)/i) do |inst|
@@ -239,8 +262,18 @@ module Stella
       uri.scheme = base_uri.scheme if uri.scheme.nil?
       uri.host = base_uri.host if uri.host.nil?
       uri.port = base_uri.port if uri.port.nil?
-      uri.path ||= ''
-      uri.path.gsub! /\/$/, ''  # Don't double up on the first slash
+      
+      # Support for specifying default path prefix:
+      # $ stella verify -p plan.rb http://localhost/basicauth
+      if base_uri.path
+        if uri.path.nil? || uri.path.empty?
+          uri.path = base_uri.path
+        else
+          a = base_uri.path.gsub(/\/$/, '')
+          b = uri.path.gsub(/^\//, '')
+          uri.path = [a,b].join('/')
+        end
+      end
       
       uri
     end
@@ -258,8 +291,11 @@ module Stella
         value = base_uri.host 
       elsif params.has_key?(name.to_sym)
         value = params.delete name.to_sym
+      elsif container.resource?( name)
+        value = container.resource name
+      elsif Stella::Testplan.global?(name)
+        Stella::Testplan.global(name)
       end
-      value = container.resource name.to_sym if value.nil?
       value
     end 
     
@@ -314,15 +350,46 @@ end
 class Stella::Client
   
   class ResponseModifier
-    attr_accessor :message
-    def initialize(msg=nil)
-      @message = msg
+    attr_accessor :obj
+    def initialize(obj=nil)
+      @obj = obj
     end 
+    alias_method :message, :obj
+    alias_method :message=, :obj=
   end
   class Repeat < ResponseModifier; 
-    attr_accessor :times
-    def initialize(times)
-      @times = times
+    alias_method :times, :obj
+    alias_method :times=, :obj=
+  end
+  #
+  # Automatically follow a Location header or you 
+  # can optionally specify the URI to load. 
+  # 
+  #     get '/' do
+  #       response 302 do
+  #         follow do 
+  #           header :'X-SOME-HEADER' => 'somevalue'
+  #         end
+  #       end
+  #     end
+  #
+  # The block is optional and accepts the same syntax as regular requests.
+  #
+  class Follow < ResponseModifier; 
+    alias_method :uri, :obj
+    alias_method :uri=, :obj=
+    attr_reader :definition
+    def initialize(obj=nil,&definition)
+      @obj, @definition = obj, definition
+    end
+    def generate_request(req)
+      n = Stella::Data::HTTP::Request.new :GET, self.uri, req.http_version, &definition
+      n.description = "#{req.description || 'Request'} (autofollow)"
+      n.http_auth = req.http_auth
+      n.response_handler = req.response_handler
+      n.autofollow!
+      n.freeze
+      n
     end
   end
   class Quit < ResponseModifier; end

data/lib/stella/client/container.rb

@@ -147,27 +147,37 @@ class Stella::Client
     end
     alias_method :form, :forms
     
-    # Return a resource from the usecase or from this 
-    # container (in that order).
+    # Return a resource from this container or from  
+    # the usecase (in that order). Otherwise, nil. 
     def resource(n)
-      return @usecase.resource(n) if @usecase.resources.has_key? n
-      return @resources[n] if @resources.has_key? n
-      nil
+      n &&= n.to_sym
+      v = @resources.has_key?(n) ? @resources[n] : @usecase.resource(n)
+      v = Stella::Testplan.global(n) if Stella::Testplan.global?(n)
+      v
+    end
+    
+    def resource?(n)
+      !resource(n).nil?
     end
     
     def body; @response.body.content; end
     def headers; @response.header; end
       alias_method :header, :headers
     def status; @response.status; end
-    def set(*args)
-      h = Hash === args[0] ? args[0] : {args[0]=> args[1]}
-      @resources.merge! h
+    def set(name, *args)
+      if Hash === name
+        Stella.ld "ARGS IGNORED: #{args.inspect} (#{caller[0]})" if !args.empty?
+        @resources.merge! name
+      elsif !name.nil? && !args.empty?
+        @resources.merge!({name => args[0]})
+      end
     end
     def wait(t); sleep t; end
     def quit(msg=nil); Quit.new(msg); end
     def fail(msg=nil); Fail.new(msg); end
     def error(msg=nil); Error.new(msg); end
     def repeat(t=1); Repeat.new(t); end
+    def follow(uri=nil,&blk); Follow.new(uri,&blk); end
     
     
     

data/lib/stella/common.rb

@@ -227,7 +227,7 @@ class Stella::Config < Storable
     DEFAULT_CONFIG = <<CONF
 apikey: ''
 secret: ''
-source: api.solutious.com
+source: ''
 CONF
     DEFAULT_CONFIG_HASH = YAML.load(DEFAULT_CONFIG).gibbler
   end

data/lib/stella/data/http.rb

@@ -21,6 +21,9 @@ module Stella::Data::HTTP
     field :http_version
     field :content_type
     field :http_auth
+    field :timeout
+    
+    field :autofollow  # boolean. Was this an auto generated follow request. 
     
       # A hash containing blocks to be executed depending on the HTTP response status.
       # The hash keys are numeric HTTP Status Codes. 
@@ -40,14 +43,24 @@ module Stella::Data::HTTP
       @http_method, @http_version = method, version
       @headers, @params, @response_handler = {}, {}, {}
       @resources = {}
+      @autofollow = false
       @wait = 0
       self.description = "Request"
       instance_eval &definition unless definition.nil?
     end
     
-    def auth(user=nil, pass=nil, kind=:basic)
+    def autofollow!
+      @autofollow = true
+    end
+    
+    def auth(user=nil, pass=nil, domain=nil)
       @http_auth ||= Stella::Testplan::Usecase::Auth.new
-      @http_auth.user, @http_auth.pass, @http_auth.kind = user, pass, kind
+      @http_auth.user, @http_auth.pass, @http_auth.domain = user, pass, domain
+    end
+    
+    def timeout(*args)
+      @timeout = args.first unless args.empty?
+      @timeout
     end
     
     def desc(*args)

data/lib/stella/engine/functional.rb

@@ -86,16 +86,28 @@ module Stella::Engine
     end
     
     def update_error_execute_response_handler(client_id, ex, req, container)
-      Stella.le ex.message
+      Stella.le "#{ex.message} (#{ex.backtrace.first})"
       Stella.ld ex.backtrace
     end
     
     def update_request_unhandled_exception(client_id, usecase, uri, req, params, ex)
-      desc = "#{usecase.desc} > #{req.desc}"
-      Stella.le '  Client-%s %-45s %s' % [client_id.short, desc, ex.message]
+      #desc = "#{usecase.desc} > #{req.desc}"
+      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
+      end
       Stella.ld ex.backtrace
     end
     
+    def update_follow_redirect client_id, ret, req, container
+      Stella.stdout.info2 "  FOLLOW   %-53s" % [ret.uri]
+    end
+    
+    def update_max_redirects client_id, counter, ret, req, container
+      Stella.stdout.info "  MAX REDIRECTS   %-53s" % [counter]
+    end
+    
     def update_usecase_quit client_id, msg, req, container
       Stella.stdout.info "  QUIT   %s" % [msg]
     end
@@ -110,12 +122,17 @@ module Stella::Engine
     end
     
     def update_request_repeat client_id, counter, total, req, container
-      Stella.stdout.info3 "  Client-%s     REPEAT   %d of %d" % [client_id.shorter, counter, total]
+      Stella.stdout.info3 "  REPEAT   %d of %d" % [counter, total]
+    end
+    
+    def update_authenticate client_id, usecase, req, domain, user, pass
+      Stella.stdout.info "  AUTH   #{domain} (#{user}/#{pass})"
     end
     
-    def update_authenticate client_id, usecase, req, kind, domain, user, pass
-      Stella.stdout.info "  AUTH   (#{kind}) #{domain} (#{user}/#{pass})"
+    def update_request_timeout(client_id, usecase, uri, req, params, headers, counter, container)
+      Stella.stdout.info "  TIMEOUT   %-53s" % [uri]
     end
+    
   end
 end
 

data/lib/stella/engine/load_queue.rb

@@ -31,7 +31,9 @@ module Stella::Engine
           reps.times { |rep| 
             break if Stella.abort?
             Thread.current[:real_reps] += 1
-            args = [c.digest.short, uc.desc, uc.digest.short, Thread.current[:real_reps]]
+            # NOTE: It's important to not call digest or gibbler methods
+            # on client object b/c it is not frozen. Always use digest_cache.
+            args = [c.digest_cache.short, uc.desc, uc.digest.short, Thread.current[:real_reps]]
             Stella.stdout.info4 $/, "======== THREAD %s: %s:%s (rep: %d)" % args
             
             Benelux.add_thread_tags :rep =>  rep

data/lib/stella/engine/loadbase.rb

@@ -151,7 +151,7 @@ module Stella::Engine
         @failog.info Benelux.timeline.messages.filter(:kind => :timeout)
         @authlog.info Benelux.timeline.messages.filter(:kind => :authentication)
         @reqlog.clear and @failog.clear and @authlog.clear
-        Benelux.timeline.clear if opts[:"disable-stats"]
+        Benelux.timeline.clear if opts[:"no-stats"]
       end
 
     end
@@ -398,14 +398,23 @@ module Stella::Engine
       Stella.stdout.info3 "  Client-%s     REPEAT   %d of %d" % [client_id.shorter, counter, total]
     end
     
-    def update_authenticate client_id, usecase, req, kind, domain, user, pass
+    def update_follow_redirect client_id, ret, req, container
+      Stella.stdout.info3 "  Client-%s     FOLLOW   %-53s" % [client_id.shorter, ret.uri]
+    end
+    
+    def update_max_redirects client_id, counter, ret, req, container
+      Stella.stdout.info3 "  Client-%s     MAX REDIRECTS   %s " % [client_id.shorter, counter]
+    end
+    
+    def update_authenticate client_id, usecase, req, domain, user, pass
       args = [Time.now.to_f, Stella.sysinfo.hostname, client_id.short]
       args.push usecase.digest.shorter, req.digest.shorter
-      args.push 'AUTH', kind, domain, user, pass
+      args.push 'AUTH', domain, user, pass
       Benelux.thread_timeline.add_message args.join('; '), :kind => :authentication
     end
     
     def update_request_timeout(client_id, usecase, uri, req, params, headers, counter, container)
+      Stella.stdout.info3 "  Client-%s     TIMEOUT   %-53s" % [client_id.shorter, uri]
       args = [Time.now.to_f, Stella.sysinfo.hostname, client_id.short]
       Benelux.thread_timeline.add_count :failed, 1
       args.push [uri, 'TOUT', container.unique_id[0,10]]

data/lib/stella/testplan.rb

@@ -7,9 +7,10 @@ class Testplan < Storable
   extend Attic
   
   @file_cache = {}
-  
+  @globals = {}
   class << self
     attr_reader :file_cache
+    attr_reader :globals
     def readlines path
       if @file_cache.has_key?(path)
         Stella.ld "FILE CACHE HIT: #{path}"
@@ -18,6 +19,13 @@ class Testplan < Storable
       Stella.ld "FILE CACHE LOAD: #{path}"
       @file_cache[path] = File.readlines(path)
     end
+    def global(n,v=nil)
+      @globals[n.to_sym] = v unless v.nil?
+      @globals[n.to_sym]
+    end
+    def global?(n)
+      @globals.has_key?(n.to_sym)
+    end
   end
   
   attic :base_path
@@ -28,11 +36,13 @@ class Testplan < Storable
   
   field :usecases 
   field :description 
+  #field :resources
   
   def initialize(uris=[], opts={})
     self.description = "Test plan"
     @usecases = []
     @testplan_current_ratio = 0
+    #@resources = {}
     
     unless uris.empty?
       uris = [uris] unless Array === uris
@@ -171,7 +181,7 @@ class Testplan
     include Stella::Data::Helpers
     extend Attic
     
-    class Auth < Struct.new(:kind, :user, :pass)
+    class Auth < Struct.new(:domain, :user, :pass)
       include Gibbler::Complex
     end
     
@@ -185,6 +195,7 @@ class Testplan
     
     field :ratio
     field :http_auth
+    field :timeout
     field :requests
     field :resources
     
@@ -202,10 +213,24 @@ class Testplan
       self.description
     end
     
-    def resource(name, value=nil)
-      @resources[name] = value unless value.nil?
-      @resources[name]
+    def timeout(*args)
+      @timeout = args.first unless args.empty?
+      @timeout
+    end
+    
+    def resource(name, *args)
+      if Hash === name
+        Stella.ld "ARGS IGNORED: #{args.inspect} (#{caller[0]})" if !args.empty?
+        @resources.merge! name
+      elsif !name.nil? && !args.empty?
+        @resources.merge!({name => args[0]})
+      elsif @resources.has_key?(name)
+        @resources[name]
+      elsif Stella::Testplan.global?(name)
+        Stella::Testplan.global(name)
+      end
     end
+    alias_method :set, :resource
     
     def ratio
       r = (@ratio || 0).to_f
@@ -255,12 +280,13 @@ class Testplan
       self
     end
     
-    def auth(user, pass=nil, kind=:basic)
+    def auth(user, pass=nil, domain=nil)
       @http_auth ||= Auth.new
-      @http_auth.user, @http_auth.pass, @http_auth.kind = user, pass, kind
+      @http_auth.user, @http_auth.pass, @http_auth.domain = user, pass, domain
     end
     
     def add_request(meth, *args, &blk)
+      raise "'#{meth}' block given in #{self.plan_path} with no URI" if args[0].nil?
       req = Stella::Data::HTTP::Request.new meth.to_s.upcase, args[0], &blk
       req.description = args[1] if args.size > 1 # Description is optional
       Stella.ld req

data/stella.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "stella"
   s.rubyforge_project = 'stella'
-  s.version = "0.7.6.005"
+  s.version = "0.7.6.007"
   s.summary = "Blame Stella for breaking your web applications."
   s.description = s.summary
   s.author = "Delano Mandelbaum"
@@ -34,10 +34,13 @@
   examples/cookies/plan.rb
   examples/csvdata/plan.rb
   examples/csvdata/search_terms.csv
+  examples/dynamic/plan.rb
   examples/essentials/logo.png
   examples/essentials/plan.rb
   examples/essentials/search_terms.txt
   examples/exceptions/plan.rb
+  examples/timeout/plan.rb
+  examples/variables/plan.rb
   lib/proc_source.rb
   lib/stella.rb
   lib/stella/cli.rb

data/vendor/httpclient-2.1.5.2/httpclient/auth.rb

@@ -233,6 +233,7 @@ class HTTPClient
         uri = Util.uri_dirname(uri)
         @auth[uri] = ["#{user}:#{passwd}"].pack('m').tr("\n", '')
       end
+      
     end
 
     # Response handler: returns credential.

data/vendor/httpclient-2.1.5.2/httpclient/session.rb

@@ -119,7 +119,7 @@ class HTTPClient
       @chunk_size = 4096
 
       @connect_timeout = 60
-      @connect_retry = 1
+      @connect_retry = 2
       @send_timeout = 120
       @receive_timeout = 60       # For each read_block_size bytes
       @read_block_size = 1024 * 16 # follows net/http change in 1.8.7
@@ -495,11 +495,11 @@ class HTTPClient
       @debug_dev = nil
 
       @connect_timeout = nil
-      @connect_retry = 1
+      @connect_retry = 2
       @send_timeout = nil
       @receive_timeout = nil
       @read_block_size = nil
-      @protocol_retry_count = 5
+      @protocol_retry_count = 2
 
       @ssl_config = nil
       @ssl_peer_cert = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: stella
 version: !ruby/object:Gem::Version 
-  version: 0.7.6.005
+  version: 0.7.6.007
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-01 00:00:00 -05:00
+date: 2009-12-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -92,10 +92,13 @@ files:
 - examples/cookies/plan.rb
 - examples/csvdata/plan.rb
 - examples/csvdata/search_terms.csv
+- examples/dynamic/plan.rb
 - examples/essentials/logo.png
 - examples/essentials/plan.rb
 - examples/essentials/search_terms.txt
 - examples/exceptions/plan.rb
+- examples/timeout/plan.rb
+- examples/variables/plan.rb
 - lib/proc_source.rb
 - lib/stella.rb
 - lib/stella/cli.rb