running_man 0.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Rick Olson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,89 @@
+# RunningMan
+
+Provides a simple way of setting up setup/teardown blocks that execute just
+once for the entire test case.
+
+    class MyTest < Test::Unit::TestCase
+      class << self
+        attr_accessor :block
+      end
+      
+      self.block = RunningMan::Block.new do
+        # something expensive
+      end
+      
+      def setup
+        self.class.block.run(self)
+      end
+    end
+
+This looks much better in something like ActiveSupport::TestCase, where a
+`#setup` method takes a block.
+
+    class MyTest < ActiveSupport::TestCase
+      block = RunningMan::Block.new do
+        # something expensive
+      end
+      
+      setup { block.run(self) }
+    end
+
+You can also extend your test case class with helper methods to make this 
+look nicer.
+
+    RunningMan.setup_on ActiveSupport::TestCase
+    class MyTest < ActiveSupport::TestCase
+      setup_once do
+        # something expensive
+      end
+    end
+
+## ActiveRecord!
+
+The use case for RunningMan is for database testing in my Rails apps.
+RunningMan gives me a setup where on each test case, we:
+
+1. Clear the database
+2. Load the fixtures
+3. Run the tests
+
+It's not entirely unlike Rails' default fixture behavior, but there are a few 
+important subtleties:
+
+1. Fixtures are not loaded into the DB for each test - instead they
+   are loaded once for each test class and shared amongst the
+   tests.
+2. Each test class has its own set of fixtures. Adding or removing
+   fixtures to a test class will not break other tests in strange
+   and mysterious ways.
+
+This has been tested on Ruby 1.8.7/ActiveRecord 2.2 and 
+Ruby 1.9/ActiveRecord 3.0 beta 3.
+
+    RunningMan.setup_on ActiveSupport::TestCase, :ActiveRecordBlock
+    class MyTest < ActiveSupport::TestCase
+      fixtures do
+        @post = Post.make # <3 Machinist
+      end
+
+      test "check something on post" do
+        assert_equal 'foo', @post.title
+      end
+
+      test "delete post" do
+        @post.destroy
+      end
+    end
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don’t break it in a future version 
+  unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have 
+  your own version, that is fine but bump version in a commit by itself I can 
+  ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+Copyright © 2010 rick. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,146 @@
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+desc "Generate RCov test coverage and open in your browser"
+task :coverage do
+  require 'rcov'
+  sh "rm -fr coverage"
+  sh "rcov test/test_*.rb"
+  sh "open coverage/index.html"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{name} #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push v#{version}"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/lib/running_man/active_record_block.rb

@@ -0,0 +1,50 @@
+module RunningMan
+  # Allow simple setup:
+  #
+  #   RunningMan.setup_on Test::Unit::TestCase, :ActiveRecordBlock
+  #
+  # See README for instructions on use.
+  class ActiveRecordBlock < Block
+    module TestClassMethods
+      def fixtures(&block)
+        test_block = RunningMan::ActiveRecordBlock.new(block)
+        setup do
+          test_block.run(self)
+
+          # Open a new transaction before running any test.
+          ActiveRecord::Base.connection.increment_open_transactions
+          ActiveRecord::Base.connection.begin_db_transaction
+        end
+
+        teardown do
+          # Rollback our transaction, returning our fixtures to a pristine
+          # state.
+          ActiveRecord::Base.connection.rollback_db_transaction
+          ActiveRecord::Base.connection.decrement_open_transactions
+          ActiveRecord::Base.clear_active_connections!
+        end
+      end
+    end
+
+    # Clear the database before running the block.
+    def run_once(binding)
+      clear_database
+      super
+    end
+
+    # reload any AR instances
+    def set_ivar(binding, ivar, value)
+      if value.class.respond_to?(:find)
+        value = value.class.find(value.id)
+      end
+      super(binding, ivar, value)
+    end
+
+    def clear_database
+      conn = ActiveRecord::Base.connection
+      conn.tables.each do |table|
+        conn.delete "DELETE FROM #{table}"
+      end
+    end
+  end
+end

data/lib/running_man/block.rb

@@ -0,0 +1,80 @@
+module RunningMan
+  class Block
+    module TestClassMethods
+      # Runs the given block 
+      def setup_once(&block)
+        test_block = RunningMan::Block.new(block)
+        setup { test_block.run(self) }
+      end
+    end
+
+    # block_arg - Optional Proc of code that runs only once for the test case.
+    # &block    - The default Proc of code that runs only once.  Falls back to 
+    #             block_arg if provided.
+    #
+    # Returns RunningMan::Block instance.
+    def initialize(block_arg = nil, &block)
+      @block = block || block_arg
+      @run   = false
+      @ivars = {}
+      if !@block
+        raise ArgumentError, "needs a block."
+      end
+    end
+
+    # Public: This is what is run in the test/unit callback.  #run_once is 
+    # called only the first time, and #run_always is always called.
+    #
+    # binding - Object that is running the test (usually a Test::Unit::TestCase).
+    #
+    # Returns nothing.
+    def run(binding)
+      if !run_once?
+        @run = true
+        run_once(binding)
+      end
+      run_always(binding)
+    end
+
+    # This runs the block and stores any new instance variables that were set.
+    #
+    # binding - The same Object that is given to #run.
+    #
+    # Returns nothing.
+    def run_once(binding)
+      @ivars.clear
+      before = instance_variables
+      instance_eval(&@block)
+      (instance_variables - before).each do |ivar|
+        @ivars[ivar] = instance_variable_get(ivar)
+      end
+    end
+
+    # This sets the instance variables set from #run_once on the test case.
+    # 
+    # binding - The same Object that is given to #run.
+    #
+    # Returns nothing.
+    def run_always(binding)
+      @ivars.each do |ivar, value|
+        set_ivar(binding, ivar, value)
+      end
+    end
+
+    # Sets the given instance variable to the test case.
+    #
+    # binding - The same Object that is given to #run.
+    # ivar    - String name of the instance variable to set.
+    # value   - The Object value of the instance variable.
+    def set_ivar(binding, ivar, value)
+      binding.instance_variable_set(ivar, value)
+    end
+
+    # Determines whether #run_once has already been called.
+    #
+    # Returns a Boolean.
+    def run_once?
+      !!@run
+    end
+  end
+end

data/lib/running_man.rb

@@ -0,0 +1,45 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+
+module RunningMan
+  VERSION = '0.1'
+
+  # Public: Sets up any helper class methods in TestClassMethods on the 
+  # specified test case class.
+  #
+  # Examples
+  #
+  #   # extends test/unit with RunningMan::Block::TestClassMethods
+  #   RunningMan::Block.setup_on Test::Unit::TestCase
+  #
+  #   # extends ActiveSupport::TestCase
+  #   RunningMan::Block.setup_on ActiveSupport::TestCase
+  #
+  #   # extends test/unit with RunningMan::Block::TestClassMethods and 
+  #   # RunningMan::FooBlock::TestClassMethods
+  #   RunningMan::Block.setup_on Test::Unit::TestCase, :FooBlock
+  #
+  #   # extends test/unit with RunningMan::Block::TestClassMethods and 
+  #   # MyBlock::TestClassMethods
+  #   RunningMan::Block.setup_on Test::Unit::TestCase, MyBlock
+  #
+  # source   - The class to extend.  Usually Test::Unit::TestCase.
+  # *klasses - Optional Array of RunningMan::Block subclasses or Symbols.
+  # 
+  # Returns nothing.
+  def self.setup_on(source, *klasses)
+    klasses.unshift(Block)
+    klasses.uniq!
+    klasses.each do |klass|
+      if klass.is_a?(Symbol)
+        klass = RunningMan.const_get(klass)
+      end
+      if klass.const_defined?(:TestClassMethods)
+        source.extend klass.const_get(:TestClassMethods)
+      end
+    end
+  end
+
+  autoload :ActiveRecordBlock, 'running_man/active_record_block'
+end
+
+require 'running_man/block'

data/running_man.gemspec

@@ -0,0 +1,58 @@
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'running_man'
+  s.version           = '0.1'
+  s.date              = '2010-05-01'
+  s.rubyforge_project = 'running_man'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "Simple class for test/unit setup blocks that run just once."
+  s.description = "Simple class for test/unit setup blocks that run just once."
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["rick"]
+  s.email    = 'technoweenie@gmail.com'
+  s.homepage = 'http://techno-weenie.net'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    LICENSE
+    README.md
+    Rakefile
+    lib/running_man.rb
+    lib/running_man/active_record_block.rb
+    lib/running_man/block.rb
+    running_man.gemspec
+    test/running_man/active_record_block_test.rb
+    test/running_man/block_helper_test.rb
+    test/running_man/block_test.rb
+    test/test_helper.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ /^test\/.*_test\.rb/ }
+end

data/test/running_man/active_record_block_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+begin
+  RunningMan::ActiveRecordBlock
+
+  require 'active_record'
+  require 'active_record/version'
+  ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+  ActiveRecord::Base.connection.create_table :test_models do |t|
+    t.string :name
+  end
+
+class ActiveRecordBlockTest < Test::Unit::TestCase
+  class TestModel < ActiveRecord::Base
+  end
+
+  class << self
+    attr_accessor :block_calls
+  end
+  self.block_calls = 0
+
+  fixtures do
+    ActiveRecordBlockTest.block_calls += 1
+    @test = ActiveRecordBlockTest::TestModel.create! :name => 'foo'
+  end
+
+  def test_sets_ivar_from_block
+    check_values
+    assert_equal 'foo', @test.name
+  end
+
+  def test_rollbacks
+    check_values
+    @test.update_attribute :name, 'bar'
+    TestModel.create!
+  end
+
+  def test_rollbacks_2
+    check_values
+    @test.update_attribute :name, 'bar'
+    TestModel.create!
+  end
+
+  def test_rollbacks_3
+    check_values
+    @test.update_attribute :name, 'bar'
+    TestModel.create!
+  end
+
+  # since the primitive #setup and #teardown blocks only allow one set per
+  # class, do the checks here
+  def check_values
+    assert_equal 'foo', @test.name
+    assert_equal 1,     TestModel.count
+    assert_equal 1,     self.class.block_calls
+  end
+end
+
+puts "Running ActiveRecord v#{ActiveRecord::VERSION::STRING} tests..."
+
+rescue LoadError
+  puts $!
+  puts "skipping ActiveRecord tests...  gem install activerecord sqlite3-ruby"
+end

data/test/running_man/block_helper_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class BlockHelperTest < Test::Unit::TestCase
+  class << self
+    attr_accessor :block_calls
+  end
+  self.block_calls = 0
+
+  setup_once do
+    @a = 1
+    BlockHelperTest.block_calls += 1
+  end
+
+  def teardown
+    assert_equal 1, self.class.block_calls
+  end
+
+  def test_sets_ivar_from_block
+    assert_equal 1, @a
+  end
+
+  # checks that block_calls is not incremented again
+  def test_again
+  end
+end

data/test/running_man/block_test.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class BlockTest < Test::Unit::TestCase
+  class << self
+    attr_accessor :block,  :block_calls
+  end
+
+  self.block_calls = 0
+  self.block = RunningMan::Block.new do
+    @a = 1
+    BlockTest.block_calls += 1
+  end
+
+  def setup
+    @b = 2
+    self.class.block.run(self)
+  end
+
+  def teardown
+    assert_equal 1, self.class.block_calls
+  end
+
+  def test_sets_ivar_from_block
+    assert_equal 1, @a
+  end
+
+  def test_sets_ivar_from_setup
+    assert_equal 2, @b
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+require 'rubygems'
+require 'running_man'
+
+RunningMan.setup_on Test::Unit::TestCase, :ActiveRecordBlock
+
+class Test::Unit::TestCase
+  def self.setup(&block)
+    define_method(:setup, &block)
+  end
+
+  def self.teardown(&block)
+    define_method(:teardown, &block)
+  end
+end
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: running_man
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- rick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-01 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Simple class for test/unit setup blocks that run just once.
+email: technoweenie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- lib/running_man.rb
+- lib/running_man/active_record_block.rb
+- lib/running_man/block.rb
+- running_man.gemspec
+- test/running_man/active_record_block_test.rb
+- test/running_man/block_helper_test.rb
+- test/running_man/block_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://techno-weenie.net
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: running_man
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Simple class for test/unit setup blocks that run just once.
+test_files: 
+- test/running_man/active_record_block_test.rb
+- test/running_man/block_helper_test.rb
+- test/running_man/block_test.rb