coulda 0.3.1 → 0.4.0

data/HISTORY

@@ -27,3 +27,9 @@ Cleanup
 - Minor refactorings
 - Added more examples
 - Adds "And" support to Given, When, and Then
+
+0.4.0
+-----
+- Complete internal redesign/rewrite
+- Feature method now accepts a :testcase_class => Class argument specifying the subclass of Test::Unit::TestCase,
+  allowing for simple integration with other Test::Unit frameworks

data/README.rdoc

@@ -1,9 +1,9 @@
-coulda
+Coulda
 ------
-coulda gives you Cucumber-like BDD power but with an internal DSL.  This means no "call-by-regexp" and
-no Gherkin/plain-text/external DSL.  coulda is just code -- but with a Cucumber-like take on BDD.
+Coulda gives you Cucumber-like BDD power but with an internal DSL.  This means no "call-by-regexp" and
+no Gherkin/plain-text/external DSL.  Coulda is just code -- but with a Cucumber-like take on BDD.
 
-coulda, obviously was inspired by Cucumber, Shoulda, but also Thor.  coulda believes that the best way to reuse
+Coulda, obviously was inspired by Cucumber, Shoulda, but also Thor.  Coulda believes that the best way to reuse
 code is the good ol' fashioned method.  Instead of sharing files of regexps mapped to procs, you just write
 methods.  That simple.
 
@@ -11,6 +11,10 @@ You can define the implementation of your Given/When/Then right there with the b
 if you want to reuse some Givens/Whens/Thens, just write a method!  And if you find your Feature is getting
 too bloated or that you would like to reuse Givens/Whens/Thens between features, put them in a helper.
 
+Coulda also easily supports your Test::Unit framework of choice (including Rails Tests).
+
+See http://coulda.tiggerpalace.com for more information.
+
 Easy as pie.
 
   require 'rubygems'
@@ -46,3 +50,9 @@ Easy as pie.
       Then "blech" do; end
     end
   end
+
+Thanks to
+---------
+* David Chelimsky and Jim Weirich for turning me into the test-obsessed developer that I am.
+* Timothy King for putting up with my scotch-powered rambling while working on v0.4.0
+* We Are Titans (http://www.wearetitans.net/) for sponsoring v0.4.0

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/gempackagetask'
 
 require 'lib/coulda/tasks'
 
-gem 'thoughtbot-shoulda'
+gem 'shoulda'
 require 'shoulda'
 
 # Test::Unit::UI::VERBOSE

data/coulda.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{coulda}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan David Light"]
-  s.date = %q{2009-09-23}
+  s.date = %q{2009-11-23}
   s.description = %q{Behaviour Driven Development derived from Cucumber but as an internal DSL with methods for reuse}
   s.email = %q{evan@tiggerpalace.com}
   s.extra_rdoc_files = [

data/lib/coulda.rb

@@ -2,7 +2,6 @@ module Coulda
   SyntaxError = Class.new(StandardError)
 end
 
-
 require 'test/unit'
 
 gem 'jeremymcanally-pending', '>= 0.1'
@@ -12,56 +11,13 @@ require 'coulda/feature'
 require 'coulda/scenario'
 
 module Kernel
-  def Feature(name, &block)
-    f = Feature.for_name(name)
-    f.class_eval(&block) if block_given?
-    f.assert_description
+  def Feature(name, opts = {}, &block)
+    f = Feature.new(name, opts)
+    f.instance_eval &block if block_given?
+    f.assert_presence_of_intent
     f
   end
 end
 
-# Slightly tweeked version of #constantize from ActiveSupport 2.3.3
-class String
-  # Ruby 1.9 introduces an inherit argument for Module#const_get and
-  # #const_defined? and changes their default behavior.
-  if Module.method(:const_get).arity == 1
-    # Tries to find a constant with the name specified in the argument string:
-    #
-    #   "Module".constantize     # => Module
-    #   "Test::Unit".constantize # => Test::Unit
-    #
-    # The name is assumed to be the one of a top-level constant, no matter whether
-    # it starts with "::" or not. No lexical context is taken into account:
-    #
-    #   C = 'outside'
-    #   module M
-    #     C = 'inside'
-    #     C               # => 'inside'
-    #     "C".constantize # => 'outside', same as ::C
-    #   end
-    #
-    # NameError is raised when the name is not in CamelCase or the constant is
-    # unknown.
-    def constantize
-      names = self.split('::')
-      names.shift if names.empty? || names.first.empty?
-
-      constant = Object
-      names.each do |name|
-        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-      end
-      constant
-    end
-  else
-    def constantize #:nodoc:
-      names = self.split('::')
-      names.shift if names.empty? || names.first.empty?
-
-      constant = Object
-      names.each do |name|
-        constant = constant.const_get(name, false) || constant.const_missing(name)
-      end
-      constant
-    end
-  end
-end
+require 'vendor/constantize'
+require 'vendor/underscore'

data/lib/coulda/feature.rb

@@ -1,119 +1,57 @@
 module Coulda
-  Statement = Struct.new(:type, :name, :block)
+  # The Feature class is composed of an intent and a series of zero or more Scenarios that describe the behavior
+  # that satisfies the intent.  Capturing intent is a key feature of Coulda.  Intent defines the business value 
+  # the Feature is attempting to fulfill.  It serves as a reminder for developers (and customers) as to why this
+  # Feature was implemented and why this spec was written.
+  class Feature
+    include Test::Unit::Assertions
+
+    attr_reader :scenarios, :name
+    attr_accessor :current_scenario
+
+    def initialize(name, opts = {})
+      @name = name
+      @scenarios = []
+      Scenario.testcase_class = opts[:testcase_class] if opts[:testcase_class]
+    end
 
-  module FeatureBehavior
-    %w[Given When Then And].each do |statement|
+    %w[in_order_to as_a i_want_to].each do |intent|
       eval <<-HERE
-        def #{statement}(name, &block)
-          @pending = true unless block_given?
-          @statements << stmt = Statement.new(:#{statement}, name, block)
+        # An intent specifier
+        def #{intent}(val = nil)
+          val ? @#{intent} = val : @#{intent}
         end
       HERE
     end
-  end
-
-  class Feature < Test::Unit::TestCase
-    class << self
-      attr_accessor :description
-      attr_reader :in_order_to, :as_a, :i_want_to
-
-      def include(*args)
-        super *args
-        extend *args
-      end
-
-      [:in_order_to, :as_a, :i_want_to].each do |field|
-        eval <<-HERE
-          def #{field}(arg = nil)
-            if arg
-              @#{field} = arg
-            else
-              @#{field}
-            end
-          end
-        HERE
-      end
-
-      def for_name(name)
-        klass = Class.new(Feature)
-        klass.extend(FeatureBehavior)
-        klass.description = name
-        class_name = feature_name_from(name)
-        Object.const_set(class_name, klass)
-        klass
-      end
-
-      def feature_name_from(name)
-        "Feature" + name.split(/\s|_/).map { |w| w.capitalize }.join
-      end
-
-      def assert_description
-        if @in_order_to || @as_a || @i_want_to
-          raise SyntaxError.new("Must call in_order_to if as_a and/or i_wanted_to called") unless @in_order_to
-          raise SyntaxError.new("Must call as_a if in_order_to and/or i_want_to called") unless @as_a
-          raise SyntaxError.new("Must call i_want_to if in_order_to and/or as_a called") unless @i_want_to
-        end
-      end
-
-      def Scenario(name, &test_implementation)
-        raise SyntaxError.new("A scenario requires a name") unless name
-        create_test_method_for(name, &test_implementation)
-        create_scenario_for(name, &test_implementation)
-      end
-
-      def scenarios
-        @scenarios ||= []
-      end
-
-      def pending?
-        @scenarios.all? { |s| !s.pending? }
-      end
 
-      private
-
-      def create_test_method_for(name, &test_implementation)
-        method_name = "test_#{name.sub(/\s+/, "_").downcase}"
-        @scenarios ||= []
-        if block_given?
-          define_method(method_name, &test_implementation)
-        else
-          define_method(method_name) { pending }
-        end
-      end
-
-      def create_scenario_for(name, &test_implementation)
-        @scenarios ||= []
-        scenario = nil
-        if block_given?
-          scenario = Scenario.new(name, &test_implementation)
-          scenario.statements = extract_statements_from &test_implementation
-        else
-          scenario = Scenario.new(name)
+    %w[Given When Then And].each do |stmt|
+      eval <<-HERE
+        # Specifies a prereqisite, event, or expectation.  May be used in any order within the spec
+        def #{stmt}(text, &block)
+          @current_scenario.statements << { :type => :#{stmt}, :text => text }
+          @current_scenario.steps << block if block
         end
-        @scenarios << scenario
-        scenario
-      end
+      HERE
+    end
 
-      def extract_statements_from(&test_implementation)
-        @statements ||= []
-        self.instance_eval(&test_implementation)
-        statements = @statements
-        @statements = []
-        statements
-      end
+    # Creates a Scenario instance and adds it to the Feature
+    def Scenario(scenario_name, &block)
+      @scenarios << scenario = Scenario.new(scenario_name, self, &block)
+      scenario
     end
 
-    # Scenario-less features should be pending
-    def default_test
-      pending
+    # Accessor to the Scenario-created TestCases
+    def tests
+      @scenarios.collect { |s| s.test_class }
     end
 
-    %w[Given When Then And].each do |statement|
-      eval <<-HERE
-        def #{statement}(name, &block)
-          yield if block_given?
-        end
-      HERE
+
+    # Raises an error if only some of the intent is captured (i.e., in_order_to and as_a without i_want_to)
+    def assert_presence_of_intent
+      presence = %w[in_order_to as_a i_want_to].map { |intent| instance_variable_get("@#{intent}") }
+      if presence.any? { |p| p } && !presence.all? { |p| p }
+        raise SyntaxError.new("Must have all or none of in_order, as_a, and i_want_to called in a Feature")
+      end
     end
   end
 end

data/lib/coulda/scenario.rb

@@ -1,17 +1,74 @@
 module Coulda
+  # A factory for Test::Unit::TestCases (or their subclass).
   class Scenario
-    attr_reader :name
-    attr_accessor :statements
+    attr_reader :name, :test_class
+    attr_accessor :steps, :statements
 
-    def initialize(name, &block)
-      @name = name.to_s
-      @block = block
+    # Class-level method to set the subclass of Test::Unit::TestCase to use as the parent for 
+    # tests manufactured by Scenarios.
+    def self.testcase_class=(klass)
+      unless klass.ancestors.include?(Test::Unit::TestCase)
+        raise Exception.new("class must inherit from Test::Unit:TestCase") 
+      end
+      @testcase_class = klass
+    end
+
+    def self.testcase_class
+      @testcase_class
+    end
+
+    def initialize(name, my_feature, &block)
+      raise Exception.new("Scenario must have a name") unless name 
+      @name = name
       @statements = []
-      @pending = !block_given?
+      @steps = []
+      @pending = false
+      @test_class = ::Class.new(Scenario.testcase_class || Test::Unit::TestCase)
+      assign_test_class_to_const(my_feature)
+      test_impl = nil
+      if block
+        create_and_provision_test_method_for my_feature, &block
+      else
+        @pending = true
+        define_test_method_using { pending }
+      end
     end
 
+    # Predicate indicating if the Scenario was provided with an example
     def pending?
       @pending
     end
+    
+    private
+
+    def create_and_provision_test_method_for(feature, &block)
+      execute block, :within => feature
+      inject_test_steps_into @test_class
+      define_test_method_using { self.class.test_steps.each { |s| feature.instance_eval &s } }
+    end
+
+    def assign_test_class_to_const(my_feature)
+      base_name = "#{my_feature.name}_#{@name}_#{rand(1_000_000_000)}"
+      base_name = "letter_" + base_name if base_name =~ /^[^a-zA-Z]/
+      titleized_underscored_name = base_name.super_custom_underscore.gsub(/\b('?[a-z])/) { $1.upcase }
+      ::Module.const_set(titleized_underscored_name, @test_class)
+    end
+
+    def define_test_method_using(&block)
+      @test_class.send(:define_method, "test_#{@name.downcase.super_custom_underscore}", &block)
+    end
+
+    def execute(block, params = {})
+      feature = params[:within]
+      feature.current_scenario = self
+      feature.instance_eval &block
+    end
+
+    def inject_test_steps_into(test_class)
+      class << test_class
+        attr_accessor :test_steps
+      end
+      test_class.test_steps = @steps
+    end
   end
 end

data/test/feature_test.rb

@@ -1,41 +1,23 @@
 require File.join(File.dirname(__FILE__), "test_helper")
 
 class FeatureTest < Test::Unit::TestCase
-  context "A Feature instance" do
-    @@counter = 1
+  context "A Feature" do
     setup do
-      feature_class = Feature.for_name "foobarblech#{@@counter}"
-      @@counter += 1
-      @feature = feature_class.new("default_test")
-    end
-
-    %w[Given When Then And].each do |condition|
-      should "have a method called '#{condition}'" do
-        assert(@feature.respond_to?(condition))
+      @feature = Feature "foobarblech#{@@counter}" do
+        Scenario "" do
+          Given "" do; end
+          Then "" do; end
+        end
       end
     end
-  end
 
-  context "A Feature class" do
-    should "have Test::Unit::TestCase as an ancestor" do
-      assert(Feature.ancestors.include?(Test::Unit::TestCase))
+    should "contain tests" do
+      assert(@feature.tests.first)
     end
 
-    context "created by name" do
-      @@counter = 1
-      setup do 
-        @feature = Feature.for_name "foo#{@@counter}"
-        @@counter += 1
-      end
-
-      should "be a subclass of Feature" do
-        assert(@feature.ancestors.include?(Feature))
-      end
-      
-      %w[Given When Then And].each do |condition|
-        should "have a method called '#{condition}'" do
-          assert(@feature.respond_to?(condition), "does not have a method called #{condition}")
-        end
+    %w[Given When Then And].each do |condition|
+      should "have a method called '#{condition}'" do
+        assert(@feature.respond_to?(condition))
       end
     end
 
@@ -93,9 +75,8 @@ class FeatureTest < Test::Unit::TestCase
         end
       end
 
-      should "not have any errors when run" do
-        result = run_feature @feature_without_scenarios
-        Object::RUBY_VERSION =~ /^1.9/ ? assert(result) : assert(result.passed?)
+      should "not have any test" do
+        assert(@feature_without_scenarios.tests.empty?)
       end
     end
 
@@ -113,11 +94,11 @@ class FeatureTest < Test::Unit::TestCase
       ### Integration tests
 
       context "with a block containing a scenario" do
-        should "create a Feature instance method named 'test_<underscored_scenario_name>'" do
-          @feature_without_errors.Scenario "pending scenario"
+        should "create a Feature instance method named 'test_<underscored_feature_name>_<underscored_scenario_name>'" do
+          @feature_without_errors.Scenario("pending scenario") {}
           test_name = "test_pending_scenario"
-          test_name = :test_pending_scenario if RUBY_VERSION =~ /^1.9/
-          assert(@feature_without_errors.instance_methods.include?(test_name), "Feature is missing test method from scenario")
+          test_name = test_name.to_sym if RUBY_VERSION =~ /^1.9/
+          assert(@feature_without_errors.tests.first.instance_methods.include?(test_name), "Test is missing test method from scenario")
         end
 
         should "create a Scenario" do

data/test/integration/using_coulda_test.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 
-Feature "Using Coulda" do
+Feature "Using Coulda", :testcase_class => Test::Unit::TestCase do
   in_order_to "perform lightweight integration/acceptance testing with Coulda"
   as_a "developer"
   i_want_to "have typical Coulda usage work"

data/test/regression/issue_1_test.rb

@@ -13,7 +13,7 @@ class Issue1Test < Test::Unit::TestCase
       pendings_are_errors
 
       @feature_without_errors = Feature "Issue 1 feature" do
-        include GivenSomething
+        extend GivenSomething
 
         in_order_to "foo"
         as_a "bar"
@@ -28,7 +28,7 @@ class Issue1Test < Test::Unit::TestCase
     end
 
     should "pass" do
-      assert(run_feature(@feature_without_errors))
+      assert(run_feature(@feature_without_errors.tests.first))
     end
   end
 end

data/test/scenario_test.rb

@@ -3,13 +3,13 @@ require File.join(File.dirname(__FILE__), "test_helper")
 class ScenarioTest < Test::Unit::TestCase
   context "A Scenario" do
     setup do
-      @scenario = Scenario.new("foobar")
+      @scenario = Scenario.new("foobar", Feature("something_or_other")) {}
     end
 
     context "when instantiated" do 
       context "with only a String" do
         setup do 
-          @scenario = Scenario.new("foobar")
+          @scenario = Scenario.new("foobar", Feature("another")) 
         end
 
         should "be pending" do
@@ -18,5 +18,15 @@ class ScenarioTest < Test::Unit::TestCase
       end
     end
   end
+
+  should "allow Test::Unit::TestCase class to subclass to be set" do
+    Scenario.testcase_class = Test::Unit::TestCase
+  end
+
+  should "raise an Exception if provided a class that does not inherit from Test::Unit::TestCase" do
+    assert_raises Exception do
+      Scenario.testcase_class = Object
+    end
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: coulda
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - Evan David Light
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-23 00:00:00 -04:00
+date: 2009-11-23 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency