shoulda-context 1.2.2 → 2.0.0

data/test/shoulda/convert_to_should_syntax_test.rb

@@ -1,9 +1,8 @@
-require 'test/unit'
-
-class ConvertToShouldSyntaxTest < Test::Unit::TestCase # :nodoc:
+require 'test_helper'
 
+class ConvertToShouldSyntaxTest < PARENT_TEST_CASE
   BEFORE_FIXTURE = <<-EOS
-    class DummyTest < Test::Unit::TestCase
+    class DummyTest < #{PARENT_TEST_CASE}
 
       should "Not change this_word_with_underscores" do
       end
@@ -23,7 +22,7 @@ class ConvertToShouldSyntaxTest < Test::Unit::TestCase # :nodoc:
   EOS
 
   AFTER_FIXTURE = <<-EOS
-    class DummyTest < Test::Unit::TestCase
+    class DummyTest < #{PARENT_TEST_CASE}
 
       should "Not change this_word_with_underscores" do
       end
@@ -48,7 +47,7 @@ class ConvertToShouldSyntaxTest < Test::Unit::TestCase # :nodoc:
 
   def test_convert_to_should_syntax
     File.open(FIXTURE_PATH, "w") {|f| f.write(BEFORE_FIXTURE)}
-    cmd = "#{RUBY} #{File.join(File.dirname(__FILE__), '../../bin/convert_to_should_syntax')} #{FIXTURE_PATH}"
+    cmd = "#{RUBY} #{File.join(File.dirname(__FILE__), '../../exe/convert_to_should_syntax')} #{FIXTURE_PATH}"
     output = `#{cmd}`
     File.unlink($1) if output.match(/has been stored in '([^']+)/)
     assert_match(/has been converted/, output)
@@ -59,5 +58,4 @@ class ConvertToShouldSyntaxTest < Test::Unit::TestCase # :nodoc:
   def teardown
     File.unlink(FIXTURE_PATH)
   end
-
 end

data/test/shoulda/helpers_test.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
-class HelpersTest < Test::Unit::TestCase # :nodoc:
-
+class HelpersTest < PARENT_TEST_CASE
   context "an array of values" do
     setup do
       @a = ['abc', 'def', 3]
@@ -9,7 +8,7 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
 
     [/b/, 'abc', 3].each do |x|
       should "contain #{x.inspect}" do
-        assert_raises(Test::Unit::AssertionFailedError) do
+        assert_raises(ASSERTION_CLASS) do
           assert_does_not_contain @a, x
         end
         assert_contains @a, x
@@ -17,17 +16,17 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
     end
 
     should "not contain 'wtf'" do
-      assert_raises(Test::Unit::AssertionFailedError) {assert_contains @a, 'wtf'}
+      assert_raises(ASSERTION_CLASS) {assert_contains @a, 'wtf'}
       assert_does_not_contain @a, 'wtf'
     end
 
     should "be the same as another array, ordered differently" do
       assert_same_elements(@a, [3, "def", "abc"])
-      assert_raises(Test::Unit::AssertionFailedError) do
+      assert_raises(ASSERTION_CLASS) do
         assert_same_elements(@a, [3, 3, "def", "abc"])
       end
       assert_same_elements([@a, "abc"].flatten, ["abc", 3, "def", "abc"])
-      assert_raises(Test::Unit::AssertionFailedError) do
+      assert_raises(ASSERTION_CLASS) do
         assert_same_elements([@a, "abc"].flatten, [3, 3, "def", "abc"])
       end
     end
@@ -41,9 +40,12 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
 
   context "a matching matcher" do
     setup do
-      @matcher = stub('matcher', :matches?                       => true,
-                                 :failure_message_for_should     => 'bad failure message',
-                                 :failure_message_for_should_not => 'big time failure')
+      @matcher = stub(
+        "matcher",
+        matches?: true,
+        failure_message: "bad failure message",
+        failure_message_when_negated: "big time failure"
+      )
     end
 
     should "pass when given to assert_accepts with no message expectation" do
@@ -55,7 +57,7 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
     end
 
     should "fail when given to assert_accepts with non-matching message" do
-      assert_raise Test::Unit::AssertionFailedError do
+      assert_raises ASSERTION_CLASS do
         assert_accepts @matcher, 'target', :message => /small time/
       end
     end
@@ -68,7 +70,7 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
             @matcher.stubs(:matches?).returns(false)
             @matcher.stubs(:does_not_match?).returns(true)
             assert_rejects @matcher, 'target'
-          rescue Test::Unit::AssertionFailedError => @error
+          rescue ASSERTION_CLASS => @error
           end
         end
 
@@ -82,12 +84,12 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
           @error = nil
           begin
             assert_rejects @matcher, 'target'
-          rescue Test::Unit::AssertionFailedError => @error
+          rescue ASSERTION_CLASS => @error
           end
         end
 
         should "fail" do
-          assert_not_nil @error
+          refute_nil @error
         end
 
         should "use the error message from the matcher" do
@@ -99,49 +101,12 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
 
   context "a non-matching matcher" do
     setup do
-      @matcher = stub('matcher', :matches?                       => false,
-                                 :failure_message_for_should     => 'big time failure',
-                                 :failure_message_for_should_not => 'bad failure message')
-    end
-
-    should "pass when given to assert_rejects with no message expectation" do
-      assert_rejects @matcher, 'target'
-    end
-
-    should "pass when given to assert_rejects with a matching message" do
-      assert_rejects @matcher, 'target', :message => /big time/
-    end
-
-    should "fail when given to assert_rejects with a non-matching message" do
-      assert_raise Test::Unit::AssertionFailedError do
-        assert_rejects @matcher, 'target', :message => /small time/
-      end
-    end
-
-    context "when given to assert_accepts" do
-      setup do
-        begin
-          assert_accepts @matcher, 'target'
-        rescue Test::Unit::AssertionFailedError => @error
-        end
-      end
-
-      should "fail" do
-        assert_not_nil @error
-      end
-
-      should "use the error message from the matcher" do
-        assert_equal 'big time failure', @error.message
-      end
-    end
-  end
-
-
-  context "a matcher using antiquated syntax" do
-    setup do
-      @matcher = stub('matcher', :matches?                 => false,
-                                 :failure_message          => 'big time failure',
-                                 :negative_failure_message => 'bad failure message')
+      @matcher = stub(
+        "matcher",
+        matches?: false,
+        failure_message: "big time failure",
+        failure_message_when_negated: "bad failure message"
+      )
     end
 
     should "pass when given to assert_rejects with no message expectation" do
@@ -153,7 +118,7 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
     end
 
     should "fail when given to assert_rejects with a non-matching message" do
-      assert_raise Test::Unit::AssertionFailedError do
+      assert_raises ASSERTION_CLASS do
         assert_rejects @matcher, 'target', :message => /small time/
       end
     end
@@ -162,12 +127,12 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
       setup do
         begin
           assert_accepts @matcher, 'target'
-        rescue Test::Unit::AssertionFailedError => @error
+        rescue ASSERTION_CLASS => @error
         end
       end
 
       should "fail" do
-        assert_not_nil @error
+        refute_nil @error
       end
 
       should "use the error message from the matcher" do

data/test/shoulda/railtie_test.rb

@@ -0,0 +1,43 @@
+require "test_helper"
+
+class RailtieTest < PARENT_TEST_CASE
+  context "A Rails application with shoulda-context added to it" do
+    setup do
+      app.create
+    end
+
+    should "load files in vendor/gems and vendor/plugins when booted" do
+      app.create_gem_with_macro(
+        module_name: "MacrosFromVendor",
+        location: "vendor/gems/vendored_gem_with_macro",
+        macro_name: "macro_from_vendored_gem"
+      )
+      app.create_gem_with_macro(
+        module_name: "MacrosFromPlugin",
+        location: "vendor/plugins/plugin_gem_with_macro",
+        macro_name: "macro_from_plugin_gem"
+      )
+      app.create_gem_with_macro(
+        module_name: "MacrosFromTest",
+        location: "test",
+        macro_name: "macro_from_test"
+      )
+      app.write_file("test/macros_test.rb", <<~RUBY)
+        ENV["RAILS_ENV"] = "test"
+        require_relative "../config/environment"
+
+        class MacrosTest < #{PARENT_TEST_CASE}
+          macro_from_vendored_gem
+          macro_from_plugin_gem
+          macro_from_test
+        end
+      RUBY
+
+      app.run_n_unit_test_suite
+    end
+  end
+
+  def app
+    @_app ||= RailsApplicationWithShouldaContext.new
+  end
+end

data/test/shoulda/rerun_snippet_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class RerunSnippetTest < PARENT_TEST_CASE
+  context "A Rails application with shoulda-context added to it" do
+    should "display the correct rerun snippet when a test fails" do
+      if app.rails_version >= 5 && TEST_FRAMEWORK == "minitest"
+        app.create
+
+        app.write_file("test/models/failing_test.rb", <<~RUBY)
+          ENV["RAILS_ENV"] = "test"
+          require_relative "../../config/environment"
+
+          class FailingTest < #{PARENT_TEST_CASE}
+            should "fail" do
+              assert false
+            end
+          end
+        RUBY
+
+        command_runner = app.run_n_unit_test_suite
+
+        expected_file_path_with_line_number =
+          if rails_version >= 6
+            "rails test test/models/failing_test.rb:5"
+          else
+            "bin/rails test test/models/failing_test.rb:5"
+          end
+
+        assert_includes(
+          command_runner.output,
+          expected_file_path_with_line_number
+        )
+      end
+    end
+  end
+
+  def app
+    @_app ||= RailsApplicationWithShouldaContext.new
+  end
+
+  def rails_version
+    # TODO: Update snowglobe so that we don't have to do this
+    app.send(:bundle).version_of("rails")
+  end
+end

data/test/shoulda/should_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ShouldTest < Test::Unit::TestCase # :nodoc:
+class ShouldTest < PARENT_TEST_CASE
   should "be able to define a should statement outside of a context" do
     assert true
   end
@@ -19,7 +19,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
     should "be able to setup a should eventually in a class method"
   end
 
-  def self.should_see_a_context_block_like_a_Test_Unit_class
+  def self.should_see_a_context_block_like_a_test_case_class
     should "see a context block as a Test::Unit class" do
       assert_equal "ShouldTest", self.class.name
     end
@@ -40,14 +40,22 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   def self.should_be_able_to_make_context_macros(prefix = nil)
     context "a macro" do
       should "have the tests named correctly" do
-        assert_match(/^test: #{prefix}a macro should have the tests named correctly/, self.to_s)
+        assert_match(
+          Regexp.new(
+            "^" +
+            build_expected_test_name(
+              "#{prefix}a macro should have the tests named correctly"
+            )
+          ),
+          test_name
+        )
       end
     end
   end
 
   context "Context" do
     should_see_class_methods
-    should_see_a_context_block_like_a_Test_Unit_class
+    should_see_a_context_block_like_a_test_case_class
     should_be_able_to_make_context_macros("Context ")
     should_be_able_to_setup_a_should_eventually_in_a_class_method
 
@@ -81,7 +89,13 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
     should_see_blah
 
     should "have name set right" do
-      assert_match(/^test: Context with setup block/, self.to_s)
+      assert_match(
+        Regexp.new(
+          "^" +
+          build_expected_test_name("Context with setup block")
+        ),
+        test_name
+      )
     end
 
     context "and a subcontext" do
@@ -90,7 +104,15 @@ class ShouldTest < 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(
+          Regexp.new(
+            "^" +
+            build_expected_test_name(
+              "Context with setup block and a subcontext should be named correctly"
+            )
+          ),
+          test_name
+        )
       end
 
       should "run the setup methods in order" do
@@ -110,7 +132,13 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
     end
 
     should "have name set right" do
-      assert_match(/^test: Another context with setup block/, self.to_s)
+      assert_match(
+        Regexp.new(
+          "^" +
+          build_expected_test_name("Another context with setup block")
+        ),
+        test_name
+      )
     end
     should_see_blah
   end
@@ -123,14 +151,14 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
 
   def test_should_create_a_new_context
     assert_nothing_raised do
-      Shoulda::Context::Context.new("context name", self) do; end
+      Shoulda::Context::Context.new("context name", self.class) do; end
     end
   end
 
   def test_should_create_a_new_context_even_if_block_is_omitted
     old_verbose, $VERBOSE = $VERBOSE, nil
     assert_nothing_raised do
-      Shoulda::Context::Context.new("context without a block", self)
+      Shoulda::Context::Context.new("context without a block", self.class)
     end
   ensure
     $VERBOSE = old_verbose
@@ -138,14 +166,14 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
 
   def test_should_create_a_nested_context
     assert_nothing_raised do
-      parent = Shoulda::Context::Context.new("Parent", self) do; end
+      parent = Shoulda::Context::Context.new("Parent", self.class) do; end
       child  = Shoulda::Context::Context.new("Child", parent) do; end
       raise unless child.instance_of? Shoulda::Context::Context
     end
   end
 
   def test_should_name_a_contexts_correctly
-    parent     = Shoulda::Context::Context.new("Parent", self) do; end
+    parent     = Shoulda::Context::Context.new("Parent", self.class) do; end
     child      = Shoulda::Context::Context.new("Child", parent) do; end
     grandchild = Shoulda::Context::Context.new("GrandChild", child) do; end
 
@@ -155,12 +183,11 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   end
 
   def test_should_raise_on_duplicate_naming
-  tu_class = Test::Unit::TestCase
-   context = Shoulda::Context::Context.new("DupContext", tu_class) do
+    context = Shoulda::Context::Context.new("DupContext", self.class) do
       should "dup" do; end
       should "dup" do; end
     end
-    assert_raise DuplicateTestError do
+    assert_raises Shoulda::Context::DuplicateTestError do
       context.build
     end
   end
@@ -168,7 +195,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   # Should statements
 
   def test_should_have_should_hashes_when_given_should_statements
-    context = Shoulda::Context::Context.new("name", self) do
+    context = Shoulda::Context::Context.new("name", self.class) do
       should "be good" do; end
       should "another" do; end
     end
@@ -180,7 +207,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   # setup and teardown
 
   def test_should_capture_setup_and_teardown_blocks
-    context = Shoulda::Context::Context.new("name", self) do
+    context = Shoulda::Context::Context.new("name", self.class) do
       setup    do; "setup";    end
       teardown do; "teardown"; end
     end
@@ -192,7 +219,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   # building
 
   def test_should_create_shoulda_test_for_each_should_on_build
-    context = Shoulda::Context::Context.new("name", self) do
+    context = Shoulda::Context::Context.new("name", self.class) do
       should "one" do; end
       should "two" do; end
     end
@@ -202,44 +229,54 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   end
 
   def test_should_create_test_methods_on_build
-    tu_class = Test::Unit::TestCase
+    tu_class = self.class
     context = Shoulda::Context::Context.new("A Context", tu_class) do
       should "define the test" do; end
     end
 
-    tu_class.expects(:define_method).with(:"test: A Context should define the test. ")
+    tu_class.
+      expects(:define_method).
+      with(
+        build_expected_test_name("A Context should define the test. ").to_sym
+      )
     context.build
   end
 
   def test_should_create_test_methods_on_build_when_subcontext
-    tu_class = Test::Unit::TestCase
+    tu_class = self.class
     context = Shoulda::Context::Context.new("A Context", tu_class) do
       context "with a child" do
         should "define the test" do; end
       end
     end
 
-    tu_class.expects(:define_method).with(:"test: A Context with a child should define the test. ")
+    tu_class.
+      expects(:define_method).
+      with(
+        build_expected_test_name(
+          "A Context with a child should define the test. "
+        ).to_sym
+      )
     context.build
   end
 
   # Test::Unit integration
 
-  def test_should_create_a_new_context_and_build_it_on_Test_Unit_context
+  def test_should_create_a_new_context_and_build_it_on_test_case_context
     c = mock("context")
     c.expects(:build)
     Shoulda::Context::Context.expects(:new).with("foo", kind_of(Class)).returns(c)
     self.class.context "foo" do; end
   end
 
-  def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should
+  def test_should_create_a_one_off_context_and_build_it_on_test_case_should
     s = mock("test")
     Shoulda::Context::Context.any_instance.expects(:should).with("rock", {}).returns(s)
     Shoulda::Context::Context.any_instance.expects(:build)
     self.class.should "rock" do; end
   end
 
-  def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should_eventually
+  def test_should_create_a_one_off_context_and_build_it_on_test_case_should_eventually
     s = mock("test")
     Shoulda::Context::Context.any_instance.expects(:should_eventually).with("rock").returns(s)
     Shoulda::Context::Context.any_instance.expects(:build)
@@ -288,4 +325,106 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
     end
   end
 
+  def test_name
+    name
+  end
+
+  def build_expected_test_name(value)
+    if TEST_FRAMEWORK == "minitest"
+      if value.is_a?(Regexp)
+        Regexp.new("^test_: #{value.source}")
+      else
+        "test_: #{value}"
+      end
+    elsif value.is_a?(Regexp)
+      Regexp.new("^test: #{value.source}")
+    else
+      "test: #{value}"
+    end
+  end
+
+  # Minitest removed assert_nothing_raised a while back;
+  # see here: <http://www.zenspider.com/ruby/2012/01/assert_nothing_tested.html>
+  def assert_nothing_raised
+    yield
+  end
+end
+
+class RedTestarossaDriver; end
+
+class RedTestarossaDriverTest < PARENT_TEST_CASE
+  class DummyMatcher
+    def description
+      "fail to construct the proper test name with a 'should_not'"
+    end
+
+    def matches?(*)
+      false
+    end
+
+    def failure_message_when_negated
+      "dummy failure message"
+    end
+  end
+
+  should "call Shoulda::Context::Context.new using the correct context name" do
+    assert_equal "RedTestarossaDriver", @shoulda_context.name
+  end
+
+  should "see the name of the test case class as RedTestarossaDriverTest" do
+    assert_equal "RedTestarossaDriverTest", self.class.name
+  end
+
+  should "include the correct context name in the full name of the test" do
+    assert_match(
+      build_expected_test_name(/RedTestarossaDriver/),
+      test_name
+    )
+  end
+
+  def test_should_property_construct_test_name_for_should_eventually
+    context = Shoulda::Context::Context.new("whatever", self.class) do
+      "this is just a placeholder"
+    end
+
+    Shoulda::Context::Context.
+      expects(:new).
+      with("RedTestarossaDriver", RedTestarossaDriverTest).
+      returns(context)
+
+    self.class.should_eventually("do something") {}
+  end
+
+  def test_should_property_construct_test_name_for_should_not
+    context = Shoulda::Context::Context.new("whatever", self.class) do
+      "this is just a placeholder"
+    end
+
+    Shoulda::Context::Context.
+      expects(:new).
+      with("RedTestarossaDriver", RedTestarossaDriverTest).
+      returns(context)
+
+    self.class.should_not(DummyMatcher.new)
+  end
+
+  private
+
+  def test_name
+    name
+  end
+
+  def build_expected_test_name(value)
+    if TEST_FRAMEWORK == "minitest"
+      if value.is_a?(Regexp)
+        Regexp.new("^test_: #{value.source}")
+      else
+        "test_: #{value}"
+      end
+    elsif value.is_a?(Regexp)
+      Regexp.new("^test: #{value.source}")
+    else
+      "test: #{value}"
+    end
+  end
 end