jstorimer-deep-test 0.1.0

data/sample_rails_project/vendor/rails/railties/lib/tasks/pre_namespace_aliases.rake

@@ -0,0 +1,53 @@
+def deprecated_task(name, new_name)
+  task name=>new_name do 
+    $stderr.puts "The rake task #{name} has been deprecated, please use the replacement version #{new_name}"
+  end
+end
+
+
+# clear
+deprecated_task :clear_logs, "log:clear"
+
+# test
+deprecated_task :recent,          "test:recent"
+deprecated_task :test_units,      "test:units"
+deprecated_task :test_functional, "test:functionals"
+deprecated_task :test_plugins,    "test:plugins"
+
+
+# doc
+deprecated_task :appdoc,            "doc:app"
+deprecated_task :apidoc,            "doc:rails"
+deprecated_task :plugindoc,         "doc:plugins"
+deprecated_task :clobber_plugindoc, "doc:clobber_plugins"
+
+FileList['vendor/plugins/**'].collect { |plugin| File.basename(plugin) }.each do |plugin|
+  deprecated_task :"#{plugin}_plugindoc", "doc:plugins:#{plugin}"
+end
+
+
+# rails
+deprecated_task :freeze_gems,        "rails:freeze:gems"
+deprecated_task :freeze_edge,        "rails:freeze:edge"
+deprecated_task :unfreeze_rails,     "rails:unfreeze"
+deprecated_task :add_new_scripts,    "rails:update:scripts"
+deprecated_task :update_javascripts, "rails:update:javascripts"
+
+
+# db
+deprecated_task :migrate,       "db:migrate"
+deprecated_task :load_fixtures, "db:fixtures:load"
+
+deprecated_task :db_schema_dump,   "db:schema:dump"
+deprecated_task :db_schema_import, "db:schema:load"
+
+deprecated_task :db_structure_dump, "db:structure:dump"
+
+deprecated_task :purge_test_database,     "db:test:purge"
+deprecated_task :clone_schema_to_test,    "db:test:clone"
+deprecated_task :clone_structure_to_test, "db:test:clone_structure"
+deprecated_task :prepare_test_database,   "db:test:prepare"
+
+deprecated_task :create_sessions_table, "db:sessions:create"
+deprecated_task :drop_sessions_table,   "db:sessions:drop"
+deprecated_task :purge_sessions_table,  "db:sessions:recreate"

data/sample_rails_project/vendor/rails/railties/lib/tasks/rails.rb

@@ -0,0 +1,8 @@
+$VERBOSE = nil
+
+# Load Rails rakefile extensions
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }
+
+# Load any custom rakefile extensions
+Dir["#{RAILS_ROOT}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+Dir["#{RAILS_ROOT}/vendor/plugins/**/tasks/**/*.rake"].sort.each { |ext| load ext }

data/sample_rails_project/vendor/rails/railties/lib/tasks/statistics.rake

@@ -0,0 +1,18 @@
+STATS_DIRECTORIES = [
+  %w(Controllers        app/controllers),
+  %w(Helpers            app/helpers), 
+  %w(Models             app/models),
+  %w(Libraries          lib/),
+  %w(APIs               app/apis),
+  %w(Components         components),
+  %w(Integration\ tests test/integration),
+  %w(Functional\ tests  test/functional),
+  %w(Unit\ tests        test/unit)
+
+].collect { |name, dir| [ name, "#{RAILS_ROOT}/#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'code_statistics'
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end

data/sample_rails_project/vendor/rails/railties/lib/tasks/testing.rake

@@ -0,0 +1,120 @@
+TEST_CHANGES_SINCE = Time.now - 600
+
+# Look up tests for recently modified sources.
+def recent_tests(source_pattern, test_path, touched_since = 10.minutes.ago)
+  FileList[source_pattern].map do |path|
+    if File.mtime(path) > touched_since
+      tests = []
+      source_dir = File.dirname(path).split("/")
+      source_file = File.basename(path, '.rb')
+      
+      # Support subdirs in app/models and app/controllers
+      modified_test_path = source_dir.length > 2 ? "#{test_path}/" << source_dir[1..source_dir.length].join('/') : test_path
+
+      # For modified files in app/ run the tests for it. ex. /test/functional/account_controller.rb
+      test = "#{modified_test_path}/#{source_file}_test.rb"
+      tests.push test if File.exists?(test)
+
+      # For modified files in app, run tests in subdirs too. ex. /test/functional/account/*_test.rb
+      test = "#{modified_test_path}/#{File.basename(path, '.rb').sub("_controller","")}"
+      FileList["#{test}/*_test.rb"].each { |f| tests.push f } if File.exists?(test)
+		
+      return tests
+
+    end
+  end.flatten.compact
+end
+
+
+# Recreated here from ActiveSupport because :uncommitted needs it before Rails is available
+module Kernel
+  def silence_stderr
+    old_stderr = STDERR.dup
+    STDERR.reopen(RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'NUL:' : '/dev/null')
+    STDERR.sync = true
+    yield
+  ensure
+    STDERR.reopen(old_stderr)
+  end
+end
+
+desc 'Test all units and functionals'
+task :test do
+  exceptions = ["test:units", "test:functionals", "test:integration"].collect do |task|
+    begin
+      Rake::Task[task].invoke
+      nil
+    rescue => e
+      e
+    end
+  end.compact
+  
+  exceptions.each {|e| puts e;puts e.backtrace }
+  raise "Test failures" unless exceptions.empty?
+end
+
+namespace :test do
+  Rake::TestTask.new(:recent => "db:test:prepare") do |t|
+    since = TEST_CHANGES_SINCE
+    touched = FileList['test/**/*_test.rb'].select { |path| File.mtime(path) > since } +
+      recent_tests('app/models/**/*.rb', 'test/unit', since) +
+      recent_tests('app/controllers/**/*.rb', 'test/functional', since)
+
+    t.libs << 'test'
+    t.verbose = true
+    t.test_files = touched.uniq
+  end
+  Rake::Task['test:recent'].comment = "Test recent changes"
+  
+  Rake::TestTask.new(:uncommitted => "db:test:prepare") do |t|
+    def t.file_list
+      changed_since_checkin = silence_stderr { `svn status` }.map { |path| path.chomp[7 .. -1] }
+
+      models      = changed_since_checkin.select { |path| path =~ /app[\\\/]models[\\\/].*\.rb/ }
+      controllers = changed_since_checkin.select { |path| path =~ /app[\\\/]controllers[\\\/].*\.rb/ }  
+
+      unit_tests       = models.map { |model| "test/unit/#{File.basename(model, '.rb')}_test.rb" }
+      functional_tests = controllers.map { |controller| "test/functional/#{File.basename(controller, '.rb')}_test.rb" }
+
+      unit_tests.uniq + functional_tests.uniq
+    end
+    
+    t.libs << 'test'
+    t.verbose = true
+  end
+  Rake::Task['test:uncommitted'].comment = "Test changes since last checkin (only Subversion)"
+
+  Rake::TestTask.new(:units => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:units'].comment = "Run the unit tests in test/unit"
+
+  Rake::TestTask.new(:functionals => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/functional/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:functionals'].comment = "Run the functional tests in test/functional"
+
+  Rake::TestTask.new(:integration => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/integration/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:integration'].comment = "Run the integration tests in test/integration"
+
+  Rake::TestTask.new(:plugins => :environment) do |t|
+    t.libs << "test"
+
+    if ENV['PLUGIN']
+      t.pattern = "vendor/plugins/#{ENV['PLUGIN']}/test/**/*_test.rb"
+    else
+      t.pattern = 'vendor/plugins/**/test/**/*_test.rb'
+    end
+
+    t.verbose = true
+  end
+  Rake::Task['test:plugins'].comment = "Run the plugin tests in vendor/plugins/**/test (or specify with PLUGIN=name)"
+end

data/sample_rails_project/vendor/rails/railties/lib/tasks/tmp.rake

@@ -0,0 +1,37 @@
+namespace :tmp do
+  desc "Clear session, cache, and socket files from tmp/"
+  task :clear => [ "tmp:sessions:clear",  "tmp:cache:clear", "tmp:sockets:clear"]
+
+  desc "Creates tmp directories for sessions, cache, and sockets"
+  task :create do
+    FileUtils.mkdir_p(%w( tmp/sessions tmp/cache tmp/sockets tmp/pids ))
+  end
+
+  namespace :sessions do
+    desc "Clears all files in tmp/sessions"
+    task :clear do
+      FileUtils.rm(Dir['tmp/sessions/[^.]*'])
+    end
+  end
+
+  namespace :cache do
+    desc "Clears all files and directories in tmp/cache"
+    task :clear do
+      FileUtils.rm_rf(Dir['tmp/cache/[^.]*'])
+    end
+  end
+
+  namespace :sockets do
+    desc "Clears all files in tmp/sockets"
+    task :clear do
+      FileUtils.rm(Dir['tmp/sockets/[^.]*'])
+    end
+  end
+
+  namespace :pids do
+    desc "Clears all files in tmp/pids"
+    task :clear do
+      FileUtils.rm(Dir['tmp/pids/[^.]*'])
+    end
+  end
+end

data/sample_rails_project/vendor/rails/railties/lib/test_help.rb

@@ -0,0 +1,19 @@
+require_dependency 'application'
+
+# Make double-sure the RAILS_ENV is set to test,
+# so fixtures are loaded to the right database
+silence_warnings { RAILS_ENV = "test" }
+
+require 'test/unit'
+require 'active_record/fixtures'
+require 'action_controller/test_process'
+require 'action_controller/integration'
+require 'action_web_service/test_invoke'
+require 'breakpoint'
+
+Test::Unit::TestCase.fixture_path = RAILS_ROOT + "/test/fixtures/"
+ActionController::IntegrationTest.fixture_path = Test::Unit::TestCase.fixture_path
+
+def create_fixtures(*table_names)
+  Fixtures.create_fixtures(RAILS_ROOT + "/test/fixtures", table_names)
+end

data/sample_rails_project/vendor/rails/railties/lib/webrick_server.rb

@@ -0,0 +1,166 @@
+# Donated by Florian Gross
+
+require 'webrick'
+require 'cgi'
+require 'stringio'
+require 'dispatcher'
+
+include WEBrick
+
+class CGI #:nodoc:
+  def stdinput
+    @stdin || $stdin
+  end
+  
+  def env_table
+    @env_table || ENV
+  end
+  
+  def initialize(type = "query", table = nil, stdin = nil)
+    @env_table, @stdin = table, stdin
+
+    if defined?(MOD_RUBY) && !ENV.key?("GATEWAY_INTERFACE")
+      Apache.request.setup_cgi_env
+    end
+
+    extend QueryExtension
+    @multipart = false
+    if defined?(CGI_PARAMS)
+      warn "do not use CGI_PARAMS and CGI_COOKIES"
+      @params = CGI_PARAMS.dup
+      @cookies = CGI_COOKIES.dup
+    else
+      initialize_query()  # set @params, @cookies
+    end
+    @output_cookies = nil
+    @output_hidden = nil
+  end
+end
+
+# A custom dispatch servlet for use with WEBrick. It dispatches requests
+# (using the Rails Dispatcher) to the appropriate controller/action. By default,
+# it restricts WEBrick to a managing a single Rails request at a time, but you
+# can change this behavior by setting ActionController::Base.allow_concurrency
+# to true.
+class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
+  REQUEST_MUTEX = Mutex.new
+
+  # Start the WEBrick server with the given options, mounting the
+  # DispatchServlet at <tt>/</tt>.
+  def self.dispatch(options = {})
+    Socket.do_not_reverse_lookup = true # patch for OS X
+
+    params = { :Port        => options[:port].to_i,
+               :ServerType  => options[:server_type],
+               :BindAddress => options[:ip] }
+    params[:MimeTypes] = options[:mime_types] if options[:mime_types]
+
+    server = WEBrick::HTTPServer.new(params)
+    server.mount('/', DispatchServlet, options)
+
+    trap("INT") { server.shutdown }
+    
+    server.start
+  end
+
+  def initialize(server, options) #:nodoc:
+    @server_options = options
+    @file_handler = WEBrick::HTTPServlet::FileHandler.new(server, options[:server_root])
+    # Change to the RAILS_ROOT, since Webrick::Daemon.start does a Dir::cwd("/") 
+    # OPTIONS['working_directory'] is an absolute path of the RAILS_ROOT, set in railties/lib/commands/servers/webrick.rb 
+    Dir.chdir(OPTIONS['working_directory']) if defined?(OPTIONS) && File.directory?(OPTIONS['working_directory']) 
+    super
+  end
+
+  def service(req, res) #:nodoc:
+    unless handle_file(req, res)
+      begin
+        REQUEST_MUTEX.lock unless ActionController::Base.allow_concurrency
+        unless handle_dispatch(req, res)
+          raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found."
+        end
+      ensure
+        unless ActionController::Base.allow_concurrency
+          REQUEST_MUTEX.unlock if REQUEST_MUTEX.locked?
+        end
+      end
+    end
+  end
+
+  def handle_file(req, res) #:nodoc:
+    begin
+      req = req.dup
+      path = req.path.dup
+
+      # Add .html if the last path piece has no . in it
+      path << '.html' if path != '/' && (%r{(^|/)[^./]+$} =~ path) 
+      path.gsub!('+', ' ') # Unescape + since FileHandler doesn't do so.
+
+      req.instance_variable_set(:@path_info, path) # Set the modified path...
+
+      @file_handler.send(:service, req, res)      
+      return true
+    rescue HTTPStatus::PartialContent, HTTPStatus::NotModified => err
+      res.set_error(err)
+      return true
+    rescue => err
+      return false
+    end
+  end
+
+  def handle_dispatch(req, res, origin = nil) #:nodoc:
+    data = StringIO.new
+    Dispatcher.dispatch(
+      CGI.new("query", create_env_table(req, origin), StringIO.new(req.body || "")), 
+      ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, 
+      data
+    )
+
+    header, body = extract_header_and_body(data)
+
+    set_charset(header)
+    assign_status(res, header)
+    res.cookies.concat(header.delete('set-cookie') || [])
+    header.each { |key, val| res[key] = val.join(", ") }
+    
+    res.body = body
+    return true
+  rescue => err
+    p err, err.backtrace
+    return false
+  end
+  
+  private
+    def create_env_table(req, origin)
+      env = req.meta_vars.clone
+      env.delete "SCRIPT_NAME"
+      env["QUERY_STRING"] = req.request_uri.query
+      env["REQUEST_URI"]  = origin if origin
+      return env
+    end
+    
+    def extract_header_and_body(data)
+      data.rewind
+      data = data.read
+
+      raw_header, body = *data.split(/^[\xd\xa]{2}/on, 2)
+      header = WEBrick::HTTPUtils::parse_header(raw_header)
+      
+      return header, body
+    end
+    
+    def set_charset(header)
+      ct = header["content-type"]
+      if ct.any? { |x| x =~ /^text\// } && ! ct.any? { |x| x =~ /charset=/ }
+        ch = @server_options[:charset] || "UTF-8"
+        ct.find { |x| x =~ /^text\// } << ("; charset=" + ch)
+      end
+    end
+
+    def assign_status(res, header)
+      if /^(\d+)/ =~ header['status'][0]
+        res.status = $1.to_i
+        header.delete('status')
+      end
+    end
+end

data/spec/deep_test/options_spec.rb

@@ -0,0 +1,204 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module DeepTest
+  describe Options do
+    it "should support number_of_agents" do
+      Options.new(:number_of_agents => 3).number_of_agents.should == 3
+    end
+
+    it "should default to number_of_agents based on cpu info at time of call" do
+      options = Options.new({})
+      CpuInfo.should_receive(:new).and_return stub("cpu_info", :count => 4)
+      options.number_of_agents.should == 4
+    end
+
+    it "should have reasonable defaults" do
+      options = Options.new({})
+      options.pattern.should == nil
+      options.metrics_file.should == nil
+    end
+
+    it "should support pattern" do
+      Options.new(:pattern => '*').pattern.should == '*'
+    end
+
+    it "should support distributed_hosts" do
+      Options.new(:distributed_hosts => %w[host1 host2]).
+        distributed_hosts.should == %w[host1 host2]
+    end
+
+    it "should support sync_options" do
+      Options.new(:sync_options => {:options => 1}).sync_options.should == {:options => 1}
+    end
+
+    it "should support listener" do
+      Options.new(:listener => "AListener").
+        listener.should == "AListener"
+    end
+
+    it "should use DeepTest::NullListener as the default listener" do
+      Options.new({}).listener.should == "DeepTest::NullListener"
+    end
+    
+    it "should allow listener to be set with class" do
+      class FakeListener; end
+      Options.new(:listener => FakeListener).
+        listener.should == "DeepTest::FakeListener"
+    end
+
+    it "should allow multiple listeners to be specified" do
+      class FakeListener1; end
+      class FakeListener2; end
+      options = Options.new(
+        :listener => "DeepTest::FakeListener1,DeepTest::FakeListener2"
+      )
+      listener = options.new_listener_list
+      listener.should be_instance_of(DeepTest::ListenerList)
+      listener.listeners.should have(2).listeners
+      listener.listeners.first.should be_instance_of(FakeListener1)
+      listener.listeners.last.should be_instance_of(FakeListener2)
+    end
+
+    it "should create a list of agent listeners upon request" do
+      Options.new({}).new_listener_list.should be_instance_of(DeepTest::ListenerList)
+    end
+
+    it "should support ui" do
+      Options.new(:ui => "AUI").ui.should == "AUI"
+    end
+
+    it "should use DeepTest:UIas the default listener" do
+      Options.new({}).ui.should == "DeepTest::UI::Console"
+    end
+    
+    it "should allow ui to be set with class" do
+      class FakeUI; end
+      Options.new(:ui => FakeUI).ui.should == "DeepTest::FakeUI"
+    end
+
+    it "should instantiate ui, passing itself as parameter" do
+      options = Options.new({})
+      DeepTest::UI::Console.should_receive(:new).with(options)
+      options.ui_instance
+    end
+
+    it "should instantiate ui only one" do
+      options = Options.new({})
+      options.ui_instance.should equal(options.ui_instance)
+    end
+
+    it "should support strings as well as symbols" do
+      Options.new("server_port" => 2).server_port.should == 2
+    end
+
+    it "should raise error when invalid option is specifed" do
+      lambda {
+        Options.new(:foo => 1)
+      }.should raise_error(Options::InvalidOptionError)
+    end
+
+    it "should convert to command line option string" do
+      options = Options.new(:number_of_agents => 1)
+      options.to_command_line.should == Base64.encode64(Marshal.dump(options)).gsub("\n","")
+    end
+
+    it "should parse from command line option string" do
+      options = Options.new(:number_of_agents => 2, :pattern => '*')
+      parsed_options = Options.from_command_line(options.to_command_line)
+      parsed_options.number_of_agents.should == 2
+      parsed_options.pattern.should == '*'
+    end
+
+    it "should use default option value when no command line option is present" do
+      ["", nil].each do |blank_value|
+        options = Options.from_command_line(blank_value)
+        options.ui == "DeepTest::UI::Console"
+      end
+    end
+
+    it "should create local deployment by default" do
+      options = Options.new({})
+      options.new_deployment.should be_instance_of(LocalDeployment) 
+    end
+
+    it "should create remote deployment when distributed hosts are specified" do
+      options = Options.new(:distributed_hosts => %w[hosts], :sync_options => {:source => "root"})
+      Distributed::RemoteDeployment.should_receive(:new).with(options, 
+                                                              be_instance_of(Distributed::LandingFleet), 
+                                                              be_instance_of(LocalDeployment))
+      options.new_deployment
+    end
+
+    it "should create a landing fleet with a ship for each host" do
+      Socket.should_receive(:gethostname).and_return("myhost")
+      options = Options.new(:ui => "DeepTest::UI::Null",
+                            :sync_options => {:source => "/my/local/dir"},
+                            :distributed_hosts => %w[host1 host2])
+
+      Distributed::RSync.should_receive(:push).with("host1", options.sync_options, "/tmp/myhost_my_local_dir")
+      Distributed::RSync.should_receive(:push).with("host2", options.sync_options, "/tmp/myhost_my_local_dir")
+
+      options.new_landing_fleet.push_code(options)
+    end
+
+
+    it "should return localhost as origin_hostname current hostname is same as when created" do
+      options = Options.new({})
+      options.origin_hostname.should == 'localhost'
+    end
+
+    it "should hostname at instantiation when current hostname is different" do
+      local_hostname = Socket.gethostname
+      options = Options.new({})
+      Socket.should_receive(:gethostname).and_return("host_of_query")
+      options.origin_hostname.should == local_hostname
+    end
+
+    it "should connect_to_central_command on localhost when there is no SSH info" do
+      Telegraph::Wire.should_receive(:connect).with("localhost", 9999).and_yield(:wire)
+      yielded_wire = nil
+      Options.new(:server_port => 9999).connect_to_central_command { |yielded_wire| }
+      yielded_wire.should == :wire
+    end
+
+    it "should connect_to_central_command on remote address where there is SSH info" do
+      Telegraph::Wire.should_receive(:connect).with("remote_address", 9999).and_yield(:wire)
+      yielded_wire = nil
+
+      options = Options.new(:server_port => 9999)
+      options.ssh_client_connection_info = mock("connection_info", :address => "remote_address")
+      options.connect_to_central_command { |yielded_wire| }
+
+      yielded_wire.should == :wire
+    end
+
+    it "should be able to calculate mirror_path based on sync_options" do
+      Socket.should_receive(:gethostname).and_return("hostname")
+      options = Options.new(:sync_options => {:source => "/my/source/path", :remote_base_dir => "/mirror/base/path"})
+      options.mirror_path.should == "/mirror/base/path/hostname_my_source_path"
+    end
+
+    it "should raise a useful error if no source is specified" do
+      options = DeepTest::Options.new(:sync_options => {:remote_base_dir => "/mirror/base/path/"})
+      lambda {
+        options.mirror_path
+      }.should raise_error("No source directory specified in sync_options")
+    end
+
+    it "should default to /tmp if no remote_base_dir is specified in sync_options" do
+      Socket.should_receive(:gethostname).and_return("hostname")
+      options = DeepTest::Options.new(:sync_options => {:source => "/my/source/path"})
+      options.mirror_path.should == "/tmp/hostname_my_source_path"
+    end
+
+    it "should be gathering metrics if metrics file is set" do
+      options = DeepTest::Options.new(:metrics_file => "filename")
+      options.should be_gathering_metrics
+    end
+
+    it "should not be gathering metrics if metrics file is not set" do
+      options = DeepTest::Options.new({})
+      options.should_not be_gathering_metrics
+    end
+  end
+end

data/spec/deep_test/spec/extensions/example_group_methods_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+
+module Spec
+  module Example
+    # NoMethodError: undefined method `subclass' if constant is used below
+    # instead of string
+    describe "ExampleGroupMethods" do
+      before(:each) do
+        $show_deep_test_all_block_warning = true
+      end
+
+      it_should_behave_like "sandboxed rspec_options"
+      
+      [:append_before, :before, :after, :prepend_before, :append_after, :prepend_after].each do |rspec_method|
+        it "should print warning on first call to #{rspec_method}(:all)" do
+          out = capture_stderr do
+            describe("test") do
+              send(rspec_method, :all) {}
+              send(rspec_method, :all) {}
+            end
+          end
+
+          out.should == ExampleGroupMethods::DeepTestAllBlockWarning + "\n"
+        end
+
+        it "#{rspec_method}(:all) should not print warning if global setting is turned off" do
+          $show_deep_test_all_block_warning = false
+          
+          out = capture_stderr do
+            describe("test") do
+              send(rspec_method, :all) {}
+            end
+          end
+
+          out.should == ""
+        end
+        
+        it "should not raise error on #{rspec_method}(:each)" do
+          lambda {
+            describe("test") do
+              send(rspec_method, :each) {}
+            end
+          }.should_not raise_error
+        end
+      end
+    end
+  end
+end