shoulda-context 1.2.2 → 2.0.0

data/lib/shoulda/context/dsl.rb

@@ -0,0 +1,279 @@
+require "shoulda/context/assertions"
+
+module Shoulda
+  module Context
+    module DSL
+      def self.included(base)
+        base.class_eval do
+          include Assertions
+          include InstanceMethods
+        end
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # == Should statements
+        #
+        # Should statements are just syntactic sugar over normal Test::Unit test
+        # methods.  A should block contains all the normal code and assertions
+        # you're used to seeing, with the added benefit that they can be wrapped
+        # inside context blocks (see below).
+        #
+        # === Example:
+        #
+        #  class UserTest < Test::Unit::TestCase
+        #
+        #    def setup
+        #      @user = User.new("John", "Doe")
+        #    end
+        #
+        #    should "return its full name"
+        #      assert_equal 'John Doe', @user.full_name
+        #    end
+        #
+        #  end
+        #
+        # ...will produce the following test:
+        # * <tt>"test: User should return its full name. "</tt>
+        #
+        # Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
+        #
+        # Should statements can also take a Proc as a <tt>:before </tt>option.  This proc runs after any
+        # parent context's setups but before the current context's setup.
+        #
+        # === Example:
+        #
+        #  context "Some context" do
+        #    setup { puts("I run after the :before proc") }
+        #
+        #    should "run a :before proc", :before => lambda { puts("I run before the setup") }  do
+        #      assert true
+        #    end
+        #  end
+        #
+        # Should statements can also wrap matchers, making virtually any matcher
+        # usable in a macro style. The matcher's description is used to generate a
+        # test name and failure message, and the test will pass if the matcher
+        # matches the subject.
+        #
+        # === Example:
+        #
+        #   should validate_presence_of(:first_name).with_message(/gotta be there/)
+        #
+
+        def should(name_or_matcher, options = {}, &blk)
+          if Shoulda::Context.current_context
+            Shoulda::Context.current_context.should(name_or_matcher, options, &blk)
+          else
+            context_name = self.name.gsub(/Test$/, "") if name
+            context = Shoulda::Context::Context.new(context_name, self) do
+              should(name_or_matcher, options, &blk)
+            end
+            context.build
+          end
+        end
+
+        # Allows negative tests using matchers. The matcher's description is used
+        # to generate a test name and negative failure message, and the test will
+        # pass unless the matcher matches the subject.
+        #
+        # === Example:
+        #
+        #   should_not set_the_flash
+        def should_not(matcher)
+          if Shoulda::Context.current_context
+            Shoulda::Context.current_context.should_not(matcher)
+          else
+            context_name = self.name.gsub(/Test$/, "") if name
+            context = Shoulda::Context::Context.new(context_name, self) do
+              should_not(matcher)
+            end
+            context.build
+          end
+        end
+
+        # == Before statements
+        #
+        # Before statements are should statements that run before the current
+        # context's setup. These are especially useful when setting expectations.
+        #
+        # === Example:
+        #
+        #  class UserControllerTest < Test::Unit::TestCase
+        #    context "the index action" do
+        #      setup do
+        #        @users = [Factory(:user)]
+        #        User.stubs(:find).returns(@users)
+        #      end
+        #
+        #      context "on GET" do
+        #        setup { get :index }
+        #
+        #        should respond_with(:success)
+        #
+        #        # runs before "get :index"
+        #        before_should "find all users" do
+        #          User.expects(:find).with(:all).returns(@users)
+        #        end
+        #      end
+        #    end
+        #  end
+        def before_should(name, &blk)
+          should(name, :before => blk) { assert true }
+        end
+
+        # Just like should, but never runs, and instead prints an 'X' in the Test::Unit output.
+        def should_eventually(name, options = {}, &blk)
+          context_name = self.name.gsub(/Test$/, "")
+          context = Shoulda::Context::Context.new(context_name, self) do
+            should_eventually(name, &blk)
+          end
+          context.build
+        end
+
+        # == Contexts
+        #
+        # A context block groups should statements under a common set of setup/teardown methods.
+        # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
+        # and readability of your test code.
+        #
+        # A context block can contain setup, should, should_eventually, and teardown blocks.
+        #
+        #  class UserTest < Test::Unit::TestCase
+        #    context "A User instance" do
+        #      setup do
+        #        @user = User.find(:first)
+        #      end
+        #
+        #      should "return its full name"
+        #        assert_equal 'John Doe', @user.full_name
+        #      end
+        #    end
+        #  end
+        #
+        # This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
+        #
+        # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each
+        # should statement.  They then run their teardown blocks from in to out after each should statement.
+        #
+        #  class UserTest < Test::Unit::TestCase
+        #    context "A User instance" do
+        #      setup do
+        #        @user = User.find(:first)
+        #      end
+        #
+        #      should "return its full name"
+        #        assert_equal 'John Doe', @user.full_name
+        #      end
+        #
+        #      context "with a profile" do
+        #        setup do
+        #          @user.profile = Profile.find(:first)
+        #        end
+        #
+        #        should "return true when sent :has_profile?"
+        #          assert @user.has_profile?
+        #        end
+        #      end
+        #    end
+        #  end
+        #
+        # This code will produce the following methods
+        # * <tt>"test: A User instance should return its full name. "</tt>
+        # * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
+        #
+        # <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt>
+        # tests</b>.  This means you do not have to fully commit to the context/should syntax in a test file.
+
+        def context(name, &blk)
+          if Shoulda::Context.current_context
+            Shoulda::Context.current_context.context(name, &blk)
+          else
+            context = Shoulda::Context::Context.new(name, self, &blk)
+            context.build
+          end
+        end
+
+        # Returns the class being tested, as determined by the test class name.
+        #
+        #   class UserTest; described_type; end
+        #   # => User
+        def described_type
+          @described_type ||= self.name.
+            gsub(/Test$/, '').
+            split('::').
+            inject(Object) do |parent, local_name|
+              parent.const_get(local_name, false)
+            end
+        end
+
+        # Sets the return value of the subject instance method:
+        #
+        #   class UserTest < Test::Unit::TestCase
+        #     subject { User.first }
+        #
+        #     # uses the existing user
+        #     should validate_uniqueness_of(:email)
+        #   end
+        def subject(&block)
+          @subject_block = block
+        end
+
+        def subject_block # :nodoc:
+          @subject_block ||= nil
+        end
+      end
+
+      module InstanceMethods
+        # Returns an instance of the class under test.
+        #
+        #   class UserTest
+        #     should "be a user" do
+        #       assert_kind_of User, subject # passes
+        #     end
+        #   end
+        #
+        # The subject can be explicitly set using the subject class method:
+        #
+        #   class UserTest
+        #     subject { User.first }
+        #     should "be an existing user" do
+        #       assert !subject.new_record? # uses the first user
+        #     end
+        #   end
+        #
+        # The subject is used by all macros that require an instance of the class
+        # being tested.
+        def subject
+          @shoulda_subject ||= construct_subject
+        end
+
+        def subject_block # :nodoc:
+          (@shoulda_context && @shoulda_context.subject_block) || self.class.subject_block
+        end
+
+        def get_instance_of(object_or_klass) # :nodoc:
+          if object_or_klass.is_a?(Class)
+            object_or_klass.new
+          else
+            object_or_klass
+          end
+        end
+
+        def instance_variable_name_for(klass) # :nodoc:
+          klass.to_s.split('::').last.underscore
+        end
+
+        private
+
+        def construct_subject
+          if subject_block
+            instance_eval(&subject_block)
+          else
+            get_instance_of(self.class.described_type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/context/rails_test_unit_reporter_patch.rb

@@ -0,0 +1,21 @@
+begin
+  require "rails/test_unit/reporter"
+
+  Rails::TestUnitReporter.class_eval do
+    # Fix #format_rerun_snippet so that it works with recent versions of Minitest.
+    # This was cribbed from:
+    # <https://github.com/rails/rails/commit/ff0d5f14504f1aa29ad908ab15bab66b101427b7#diff-a071a1c8f51ce3b8bcb17ca59c79fc70>
+    def format_rerun_snippet(result)
+      location, line =
+        if result.respond_to?(:source_location)
+          result.source_location
+        else
+          result.method(result.name).source_location
+        end
+
+      "#{executable} #{relative_path_for(location)}:#{line}"
+    end
+  end
+rescue LoadError
+  # Rails::TestUnitReporter was introduced in Rails 5
+end

data/lib/shoulda/context/railtie.rb

@@ -0,0 +1,14 @@
+module Shoulda
+  module Context
+    class Railtie < Rails::Railtie
+      initializer "shoulda_context.autoload_macros" do
+        if Rails.env.test?
+          Shoulda.autoload_macros(
+            Rails.root,
+            File.join("vendor", "{plugins,gems}", "*")
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/context/test_framework_detection.rb

@@ -3,10 +3,9 @@ module Shoulda
     module TestFrameworkDetection
       def self.possible_test_frameworks
         [
-          lambda { ActiveSupport::TestCase },
-          lambda { Minitest::Test },
-          lambda { MiniTest::Unit::TestCase },
-          lambda { Test::Unit::TestCase }
+          -> { ActiveSupport::TestCase },
+          -> { Minitest::Test },
+          -> { Test::Unit::TestCase }
         ]
       end
 
@@ -23,7 +22,7 @@ module Shoulda
       end
 
       def self.test_framework_test_cases
-        @_test_framework_test_case ||= detected_test_framework_test_cases
+        @_test_framework_test_cases ||= detected_test_framework_test_cases
       end
     end
 

data/lib/shoulda/context/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Context
-    VERSION = '1.2.2'.freeze
+    VERSION = "2.0.0".freeze
   end
 end

data/lib/shoulda/context/world.rb

@@ -0,0 +1,22 @@
+module Shoulda
+  module Context
+    class << self
+      def contexts # :nodoc:
+        @contexts ||= []
+      end
+      attr_writer :contexts
+
+      def current_context # :nodoc:
+        self.contexts.last
+      end
+
+      def add_context(context) # :nodoc:
+        self.contexts.push(context)
+      end
+
+      def remove_context # :nodoc:
+        self.contexts.pop
+      end
+    end
+  end
+end

data/shoulda-context.gemspec

@@ -1,30 +1,23 @@
 # -*- encoding: utf-8 -*-
-$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
-require 'shoulda/context/version'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "lib")
+require "shoulda/context/version"
 
 Gem::Specification.new do |s|
-  s.name        = %q{shoulda-context}
+  s.name        = "shoulda-context"
   s.version     = Shoulda::Context::VERSION.dup
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["thoughtbot, inc.", "Tammer Saleh", "Joe Ferris",
                    "Ryan McGeary", "Dan Croak", "Matt Jankowski"]
-  s.email       = %q{support@thoughtbot.com}
-  s.homepage    = %q{http://thoughtbot.com/community/}
-  s.summary     = %q{Context framework extracted from Shoulda}
-  s.description = %q{Context framework extracted from Shoulda}
-  s.license     = %q{MIT}
+  s.email       = "support@thoughtbot.com"
+  s.homepage    = "http://thoughtbot.com/community/"
+  s.summary     = "Context framework extracted from Shoulda"
+  s.description = "Context framework extracted from Shoulda"
+  s.license     = "MIT"
 
   s.files            = `git ls-files`.split("\n")
   s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables      = `git ls-files -- exe/*`.split("\n").map { |f| File.basename(f) }
+  s.bindir           = "exe"
   s.require_paths    = ["lib"]
-
-  s.add_development_dependency("appraisal", "~> 0.5")
-  s.add_development_dependency("rails", ">= 3.0")
-  s.add_development_dependency("mocha", "~> 0.9.10")
-  s.add_development_dependency("rake")
-  s.add_development_dependency("test-unit", "~> 2.1.0")
-  s.add_development_dependency("pry")
-  s.add_development_dependency("byebug")
-  s.add_development_dependency("pry-byebug")
 end

data/test/fake_rails_root/test/shoulda_macros/custom_macro.rb

@@ -2,5 +2,5 @@ module CustomMacro
   def custom_macro
   end
 end
-Test::Unit::TestCase.extend(CustomMacro)
+PARENT_TEST_CASE.extend(CustomMacro)
 

data/test/fake_rails_root/vendor/gems/gem_with_macro-0.0.1/shoulda_macros/gem_macro.rb

@@ -2,5 +2,4 @@ module GemMacro
   def gem_macro
   end
 end
-Test::Unit::TestCase.extend(GemMacro)
-
+PARENT_TEST_CASE.extend(GemMacro)

data/test/fake_rails_root/vendor/plugins/plugin_with_macro/shoulda_macros/plugin_macro.rb

@@ -2,5 +2,4 @@ module PluginMacro
   def plugin_macro
   end
 end
-Test::Unit::TestCase.extend(PluginMacro)
-
+PARENT_TEST_CASE.extend(PluginMacro)

data/test/shoulda/autoload_macro_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class AutoloadMacroTest < Test::Unit::TestCase # :nodoc:
+class AutoloadMacroTest < PARENT_TEST_CASE
   context "The macro auto-loader" do
     should "load macros from the plugins" do
       assert self.class.respond_to?('plugin_macro')

data/test/shoulda/context_test.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
-class ContextTest < Test::Unit::TestCase # :nodoc:
-
+class ContextTest < PARENT_TEST_CASE
   def self.context_macro(&blk)
     context "with a subcontext made by a macro" do
       setup { @context_macro = :foo }
@@ -20,7 +19,7 @@ class ContextTest < Test::Unit::TestCase # :nodoc:
     end
 
     should "have name set right" do
-      assert_match(/^test: context with setup block/, self.to_s)
+      assert_match(/^test: context with setup block/, normalized_name)
     end
 
     context "and a subcontext" do
@@ -29,7 +28,7 @@ class ContextTest < Test::Unit::TestCase # :nodoc:
       end
 
       should "be named correctly" do
-        assert_match(/^test: context with setup block and a subcontext should be named correctly/, self.to_s)
+        assert_match(/^test: context with setup block and a subcontext should be named correctly/, normalized_name)
       end
 
       should "run the setup blocks in order" do
@@ -39,7 +38,7 @@ class ContextTest < Test::Unit::TestCase # :nodoc:
 
     context_macro do
       should "have name set right" do
-        assert_match(/^test: context with setup block with a subcontext made by a macro should have name set right/, self.to_s)
+        assert_match(/^test: context with setup block with a subcontext made by a macro should have name set right/, normalized_name)
       end
 
       should "run the setup block of that context macro" do
@@ -63,7 +62,7 @@ class ContextTest < Test::Unit::TestCase # :nodoc:
     end
 
     should "have name set right" do
-      assert_match(/^test: another context with setup block/, self.to_s)
+      assert_match(/^test: another context with setup block/, normalized_name)
     end
   end
 
@@ -77,7 +76,7 @@ class ContextTest < Test::Unit::TestCase # :nodoc:
     end
 
     should "have name set right" do
-      assert_match(/^test: context with method definition/, self.to_s)
+      assert_match(/^test: context with method definition/, normalized_name)
     end
   end
 
@@ -166,19 +165,22 @@ class ContextTest < Test::Unit::TestCase # :nodoc:
     end
   end
 
+  def normalized_name
+    name.sub("test_:", "test:")
+  end
 end
 
 class ::Some
   class NestedModel; end
 end
 
-class Some::NestedModelTest < Test::Unit::TestCase
+class Some::NestedModelTest < PARENT_TEST_CASE
   should "determine the described type for a nested model" do
     assert_equal Some::NestedModel, self.class.described_type
   end
 end
 
-class Some::SomeTest < Test::Unit::TestCase
+class Some::SomeTest < PARENT_TEST_CASE
   should "not fallback to higher-level constants with same name" do
     assert_raises(NameError) do
       assert_equal nil, self.class.described_type
@@ -186,13 +188,13 @@ class Some::SomeTest < Test::Unit::TestCase
   end
 end
 
-class ShouldMatcherTest < Test::Unit::TestCase
+class ShouldMatcherTest < PARENT_TEST_CASE
   class FakeMatcher
     attr_reader :subject
     attr_accessor :fail
 
     def description
-      "do something"
+      "be a fake matcher"
     end
 
     def matches?(subject)
@@ -200,46 +202,33 @@ class ShouldMatcherTest < Test::Unit::TestCase
       !@fail
     end
 
-    def failure_message_for_should
-      "failure message for should"
+    def failure_message
+      "positive failure message"
     end
 
-    def failure_message_for_should_not
-      "failure message for should not"
+    def failure_message_when_negated
+      "negative failure message"
     end
   end
 
-  def run_test_suite
-    @test_suite.run(@test_result) { |event, name| }
-  end
-
   def setup
     @matcher = FakeMatcher.new
-    @test_result = Test::Unit::TestResult.new
-    class << @test_result
-      def failure_messages
-        @failures.map { |failure| failure.message }
-      end
-    end
-  end
-
-  def create_test_suite(&definition)
-    test_class = Class.new(Test::Unit::TestCase, &definition)
-    test_class.suite
   end
 
-  def assert_failed_with(message, test_result)
-    assert_equal 1, test_result.failure_count
-    assert_equal [message], test_result.failure_messages
+  def assert_failed_with(message, test_suite)
+    assert_equal [message], test_suite.failure_messages
   end
 
-  def assert_passed(test_result)
-    assert_equal 0, test_result.failure_count
+  def assert_passed(test_suite)
+    assert_equal [], test_suite.failure_messages
   end
 
   def assert_test_named(expected_name, test_suite)
-    name = test_suite.tests.map { |test| test.method_name }.first
-    assert name.include?(expected_name), "Expected #{name} to include #{expected_name}"
+    name = test_suite.test_names.first
+    assert(
+      name.include?(expected_name),
+      "Expected #{name} to include #{expected_name}"
+    )
   end
 
   def self.should_use_positive_matcher
@@ -249,19 +238,19 @@ class ShouldMatcherTest < Test::Unit::TestCase
 
     should "pass with a passing matcher" do
       @matcher.fail = false
-      run_test_suite
-      assert_passed @test_result
+      @test_suite.run
+      assert_passed @test_suite
     end
 
     should "fail with a failing matcher" do
       @matcher.fail = true
-      run_test_suite
-      assert_failed_with "failure message for should", @test_result
+      @test_suite.run
+      assert_failed_with "positive failure message", @test_suite
     end
 
     should "provide the subject" do
       @matcher.fail = false
-      run_test_suite
+      @test_suite.run
       assert_equal 'a subject', @matcher.subject
     end
   end
@@ -273,19 +262,19 @@ class ShouldMatcherTest < Test::Unit::TestCase
 
     should "pass with a failing matcher" do
       @matcher.fail = true
-      run_test_suite
-      assert_passed @test_result
+      @test_suite.run
+      assert_passed @test_suite
     end
 
     should "fail with a passing matcher" do
       @matcher.fail = false
-      run_test_suite
-      assert_failed_with "failure message for should not", @test_result
+      @test_suite.run
+      assert_failed_with "negative failure message", @test_suite
     end
 
     should "provide the subject" do
       @matcher.fail = false
-      run_test_suite
+      @test_suite.run
       assert_equal 'a subject', @matcher.subject
     end
   end
@@ -293,7 +282,7 @@ class ShouldMatcherTest < Test::Unit::TestCase
   context "a should block with a matcher" do
     setup do
       matcher = @matcher
-      @test_suite = create_test_suite do
+      @test_suite = TestSuite.create do
         subject { 'a subject' }
         should matcher
       end
@@ -305,7 +294,7 @@ class ShouldMatcherTest < Test::Unit::TestCase
   context "a should block with a matcher within a context" do
     setup do
       matcher = @matcher
-      @test_suite = create_test_suite do
+      @test_suite = TestSuite.create do
         context "in context" do
           subject { 'a subject' }
           should matcher
@@ -319,7 +308,7 @@ class ShouldMatcherTest < Test::Unit::TestCase
   context "a should_not block with a matcher" do
     setup do
       matcher = @matcher
-      @test_suite = create_test_suite do
+      @test_suite = TestSuite.create do
         subject { 'a subject' }
         should_not matcher
       end
@@ -331,7 +320,7 @@ class ShouldMatcherTest < Test::Unit::TestCase
   context "a should_not block with a matcher within a context" do
     setup do
       matcher = @matcher
-      @test_suite = create_test_suite do
+      @test_suite = TestSuite.create do
         context "in context" do
           subject { 'a subject' }
           should_not matcher
@@ -341,11 +330,61 @@ class ShouldMatcherTest < Test::Unit::TestCase
 
     should_use_negative_matcher
   end
+
+  class TestSuite
+    def self.create(&definition)
+      if defined?(Test::Unit)
+        TestUnitSuite.new(&definition)
+      else
+        MinitestSuite.new(&definition)
+      end
+    end
+  end
+
+  class TestUnitSuite
+    def initialize(&definition)
+      @suite = Class.new(Test::Unit::TestCase, &definition).suite
+      @result = Test::Unit::TestResult.new
+    end
+
+    def run
+      @suite.run(@result) do |event, name|
+        # do nothing
+      end
+    end
+
+    def failure_messages
+      @result.failures.map(&:message)
+    end
+
+    def test_names
+      @suite.tests.map(&:method_name)
+    end
+  end
+
+  class MinitestSuite
+    def initialize(&definition)
+      @test_case_class = Class.new(Minitest::Test, &definition)
+      @reporter = Minitest::StatisticsReporter.new(StringIO.new)
+    end
+
+    def run
+      @test_case_class.run(@reporter)
+    end
+
+    def failure_messages
+      @reporter.results.flat_map(&:failures).map(&:message)
+    end
+
+    def test_names
+      @test_case_class.runnable_methods
+    end
+  end
 end
 
 class Subject; end
 
-class SubjectTest < Test::Unit::TestCase
+class SubjectTest < PARENT_TEST_CASE
 
   def setup
     @expected = Subject.new
@@ -358,7 +397,7 @@ class SubjectTest < Test::Unit::TestCase
   end
 end
 
-class SubjectLazinessTest < Test::Unit::TestCase
+class SubjectLazinessTest < PARENT_TEST_CASE
   subject { Subject.new }
 
   should "only build the subject once" do