jeremymcanally-context 0.0.3 → 0.0.5

data/config/hoe.rb

@@ -56,7 +56,7 @@ $hoe = Hoe.new(GEM_NAME, VERS) do |p|
   p.summary = DESCRIPTION
   p.url = HOMEPATH
   p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
-  p.test_globs = ["test/**/test_*.rb"]
+  p.test_globs = ["test/test_*.rb"]
   p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
 
   # == Optional

data/config/requirements.rb

@@ -2,7 +2,7 @@ require 'fileutils'
 include FileUtils
 
 require 'rubygems'
-%w[rake hoe newgem rubigen].each do |req_gem|
+%w[rake hoe].each do |req_gem|
   begin
     require req_gem
   rescue LoadError

data/context.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = "context"
-  s.version  = "0.0.3"
+  s.version  = "0.0.5"
   s.date     = "2008-10-03"
   s.summary  = "Contexts and DSL sugar for your tests"
   s.email    = "jeremy@entp.com"

data/lib/context/context.rb

@@ -1,5 +1,10 @@
 class Test::Unit::TestCase
   class << self
+    # Test::Unit uses ObjectSpace to figure out what Test::Unit:TestCase instances are running
+    # Contexts are not named and therefore sometimes get garbage collected.
+    # Think of #context_list as the shelter for nameless contexts
+    attr_accessor :context_list
+
     def context_name #:nodoc:
       @context_name ||= ""
       if superclass.respond_to?(:context_name)
@@ -41,9 +46,12 @@ class Test::Unit::TestCase
     def context(name, &block)
       cls = Class.new(self)
       cls.context_name = name
-      puts "Creating context #{cls.context_name}"
+      # puts "Creating context #{cls.context_name}"
       cls.class_eval(&block)
+      (self.context_list ||= []) << cls
       
+      # TODO: Find a better way to uniquely identify classes
+      const_set("Test#{name.to_class_name}#{cls.object_id}", cls)
       cls
     end
 

data/lib/context/core_ext/string.rb

@@ -1,11 +1,16 @@
 class String
   # Replaces spaces and tabs with _ so we can use the string as a method name
   def to_method_name
-    self.downcase.gsub(/\s+/,'_')
+    self.downcase.gsub(/[\s:']+/,'_')
   end
   
   # Borrowed from +camelize+ in ActiveSupport
   def to_module_name
     self.to_method_name.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
   end
+  
+  # Borrowed from +camelize+ in ActiveSupport
+  def to_class_name
+    self.to_method_name.gsub(/\/(.?)/) { "#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
 end

data/lib/context/lifecycle.rb

@@ -1,14 +1,15 @@
 class Test::Unit::TestCase
-  # TODO: Chained lifecycle methods
   class << self
+    attr_accessor :before_each_callbacks, :before_all_callbacks, :after_each_callbacks, :after_all_callbacks
+
     # Add logic to run before the tests (i.e., a +setup+ method)
     #
     #     before do
     #       @user = User.first
     #     end
     # 
-    def before(&block)
-      define_method(:setup, &block)
+    def before(period = :each, &block)
+      send("before_#{period}_callbacks") << block
     end
     
     # Add logic to run after the tests (i.e., a +teardown+ method)
@@ -17,8 +18,54 @@ class Test::Unit::TestCase
     #       User.delete_all
     #     end
     #
-    def after(&block)
-      define_method(:teardown, &block)
+    def after(period = :each, &block)
+      send("after_#{period}_callbacks") << block
+    end
+
+    def gather_callbacks(callback_type, period)
+      callbacks = superclass.respond_to?(:gather_callbacks) ? superclass.gather_callbacks(callback_type, period) : []
+      callbacks.push(*send("#{callback_type}_#{period}_callbacks"))
+    end
+  end
+
+  self.before_all_callbacks  = []
+  self.before_each_callbacks = []
+  self.after_each_callbacks  = []
+  self.after_all_callbacks   = []
+
+  def self.inherited(child)
+    super
+    child.before_all_callbacks  = []
+    child.before_each_callbacks = []
+    child.after_each_callbacks  = []
+    child.after_all_callbacks   = []
+
+    child.class_eval do
+      def setup
+        run_each_callbacks :before
+      end
+
+      def teardown
+        run_each_callbacks :after
+      end
+    end
+  end
+
+  def run_each_callbacks(callback_type)
+    self.class.gather_callbacks(callback_type, :each).each { |c| instance_eval(&c) }
+  end
+
+  def run_all_callbacks(callback_type)
+    previous_ivars = instance_variables
+    self.class.gather_callbacks(callback_type, :all).each { |c| instance_eval(&c) }
+    (instance_variables - previous_ivars).inject({}) do |hash, ivar|
+      hash.update ivar => instance_variable_get(ivar)
+    end
+  end
+
+  def set_values_from_callbacks(values)
+    values.each do |name, value|
+      instance_variable_set name, value
     end
   end
 end

data/lib/context/shared_behavior.rb

@@ -1,3 +1,23 @@
+class SharedContext < Module
+  def self.create_from_behavior(beh)
+    mod = self.new
+    mod.behavior = beh
+    mod
+  end
+  
+  def behavior=(beh)
+    @behavior = beh
+  end
+  
+  def behavior
+    @behavior
+  end
+  
+  def included(arg)
+    @behavior.call
+  end
+end
+
 class Test::Unit::TestCase
   class << self
     def shared(name, &block)
@@ -10,14 +30,14 @@ class Test::Unit::TestCase
         raise ArgumentError, "Provide a String or Symbol as the name of the shared behavior group"
       end
       
-      Object.const_set(name, Module.new(&block))
+      Object.const_set(name, SharedContext.create_from_behavior(block))
     end
     
     %w(shared_behavior share_as share_behavior_as shared_examples_for).each {|m| alias_method m, :shared}
     
     def use(shared_name)
       case shared_name.class.name
-      when "Module"
+      when "SharedContext", "Module"
         include shared_name
       when "String"
         include Object.const_get(shared_name.to_module_name)

data/lib/context/suite.rb

@@ -1,20 +1,39 @@
-class Test::Unit::TestCase
-  class << self
-    # Tweaks to standard method so we don't get superclass methods and we don't
-    # get weird default tests
-    def suite # :nodoc:
-      method_names = public_instance_methods(false)
+module Test
+  module Unit
+    class TestCase
+      class << self
+        # Tweaks to standard method so we don't get superclass methods and we don't
+        # get weird default tests
+        def suite # :nodoc:
+          method_names = public_instance_methods - superclass.public_instance_methods
+    
+          tests = method_names.delete_if {|method_name| method_name !~ /^test./}
+          suite = Test::Unit::TestSuite.new(name)
+          
+          tests.sort.each do |test|
+            catch(:invalid_test) do
+              suite << new(test)
+            end
+          end
+          
+          suite
+        end
+      end
+    end
 
-      tests = method_names.delete_if {|method_name| method_name !~ /^test./}
-      suite = Test::Unit::TestSuite.new(name)
-      
-      tests.sort.each do |test|
-        catch(:invalid_test) do
-          suite << new(test)
+    class TestSuite
+      # Runs the tests and/or suites contained in this
+      # TestSuite.
+      def run(result, &progress_block)
+        yield(STARTED, name)
+        ivars_from_callback = @tests.first.run_all_callbacks(:before) if @tests.first.is_a?(Test::Unit::TestCase)
+        @tests.each do |test|
+          test.set_values_from_callbacks(ivars_from_callback) if ivars_from_callback
+          test.run(result, &progress_block)
         end
+        ivars_from_callback = @tests.first.run_all_callbacks(:after) if ivars_from_callback
+        yield(FINISHED, name)
       end
-      
-      suite
     end
   end
 end

data/lib/context/test.rb

@@ -9,7 +9,7 @@ class Test::Unit::TestCase
     #
     def test(name, &block)
       test_name = "test_#{((context_name == "" ? context_name : context_name + " ") + name).to_method_name}".to_sym
-      puts "running test #{test_name}"
+      # puts "running test #{test_name}"
       defined = instance_method(test_name) rescue false
       raise "#{test_name} is already defined in #{self}" if defined
       

data/lib/context/version.rb

@@ -2,7 +2,7 @@ module Context
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 3
+    TINY  = 5
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_lifecycle.rb

@@ -1,17 +1,130 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 
 class TestLifecycle < Test::Unit::TestCase
-  context "A before block" do
-    it "should define a setup method" do
-      self.class.before { true }
-      assert self.class.method_defined?(:setup)
+  before do
+    @inherited_before_each_var = 1
+  end
+
+  before do
+    @inherited_before_each_var = 2
+    @inherited_before_each_var_2 = 1
+  end
+
+  after do
+    @inherited_after_each_var = 1
+  end
+
+  before :all do
+    @inherited_before_all_var = 1
+  end
+
+  after :all do
+    @inherited_after_all_var = 1
+  end
+
+  sample_test = context "lifecycle" do
+    attr_reader :inherited_before_each_var, :inherited_before_each_var_2, :inherited_after_each_var, 
+      :after_each_var, :inherited_before_all_var, :inherited_after_all_var, :before_all_var, :after_all_var, 
+      :superclass_before_each_var, :superclass_after_each_var, :superclass_before_all_var, :superclass_after_all_var
+
+    before do
+      @inherited_before_each_var = 3
+    end
+
+    after do
+      @after_each_var = 1
+    end
+
+    before :all do
+      @before_all_var = 1
+    end
+
+    after :all do
+      @after_all_var = 1
     end
+
+    test "foo" do
+    end
+  end
+
+  before do
+    @superclass_before_each_var = 1
   end
-  
-  context "An after block" do
-    it "should define a teardown method" do
-      self.class.after { true }
-      assert self.class.method_defined?(:teardown)
+
+  after do
+    @superclass_after_each_var = 1
+  end
+
+  before :all do
+    @superclass_before_all_var = 1
+  end
+
+  after :all do
+    @superclass_after_all_var = 1
+  end
+
+  context "With before/after :each blocks" do
+    before do
+      @result = Test::Unit::TestResult.new
+      @test = sample_test.new("test_lifecycle_foo")
+      @test.run(@result) { |inherited_after_each_var, v| }
+    end
+
+    it "it runs superclass before callbacks in order" do
+      assert_equal 1, @test.superclass_before_each_var
+    end
+
+    it "it runs inherited before callbacks in order" do
+      assert_equal 3, @test.inherited_before_each_var
+    end
+
+    it "it runs before callbacks in order" do
+      assert_equal 1, @test.inherited_before_each_var_2
+    end
+
+    it "it runs superclass after callbacks" do
+      assert_equal 1, @test.superclass_after_each_var
+    end
+
+    it "it runs inherited after callbacks" do
+      assert_equal 1, @test.inherited_after_each_var
+    end
+
+    it "it runs after callbacks" do
+      assert_equal 1, @test.after_each_var
+    end
+  end
+
+  context "With before/after :all blocks" do
+    before do
+      @result = Test::Unit::TestResult.new
+      @suite  = sample_test.suite
+      @suite.run(@result) { |inherited_after_each_var, v| }
+      @test   = @suite.tests.first
+    end
+
+    it "it runs superclass before callbacks in order" do
+      assert_equal 1, @test.superclass_before_all_var
+    end
+
+    it "it runs inherited before callbacks in order" do
+      assert_equal 1, @test.inherited_before_all_var
+    end
+
+    it "it runs before callbacks in order" do
+      assert_equal 1, @test.before_all_var
+    end
+
+    it "it runs superclass after callbacks" do
+      assert_equal 1, @test.superclass_after_all_var
+    end
+
+    it "it runs inherited after callbacks" do
+      assert_equal 1, @test.inherited_after_all_var
+    end
+
+    it "it runs after callbacks" do
+      assert_equal 1, @test.after_all_var
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jeremymcanally-context
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors: 
 - Jeremy McAnally