minitest-rails-shoulda 0.2.0 → 0.3.0

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
 .bundle
 Gemfile.lock
+log/*
 pkg/*

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3@minitest-rails-shoulda

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source :rubygems
 
 # Specify your gem's dependencies in minitest-rails-shoulda.gemspec
 gemspec

data/README.rdoc

@@ -10,6 +10,10 @@ In Rails 3 and Bundler, add the following to your Gemfile:
     gem "minitest-rails-shoulda"
   end
 
+Add the following to your test helper:
+
+  require "minitest/rails/shoulda"
+
 == Usage
 
 === ActiveRecord Matchers
@@ -64,3 +68,7 @@ Matchers to test common patterns:
     end
   end
 
+=== Contributors
+
+* Phil Cohen <github@phlippers.net>
+* Mike Moore <mike@blowmage.com>

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "lib" << "test"
+  t.pattern = "test/**/test_*.rb"
+  t.verbose = true
+end

data/lib/minitest-rails-shoulda.rb

@@ -1,12 +1,9 @@
-require "minitest-rails-shoulda/version"
-require "minitest/rails"
-require "minitest/matchers"
-require "minitest-rails-shoulda/integrations"
+require "minitest-rails"
+require "minitest/rails/shoulda"
 
-module MiniTest
+module Minitest
   module Rails
     module Shoulda
-      # Your code goes here...
     end
   end
 end

data/lib/minitest/rails/shoulda.rb

@@ -0,0 +1,4 @@
+require "minitest/rails/shoulda/version"
+require "minitest/rails/shoulda/assertions"
+require "minitest/rails/shoulda/dsl"
+require "minitest/rails/shoulda/matchers"

data/lib/minitest/rails/shoulda/assertions.rb

@@ -0,0 +1,110 @@
+require "minitest/unit"
+
+# Add Shoulda's assertions to MiniTest
+
+module MiniTest
+  module Assertions
+
+    # Asserts that two arrays contain the same elements, the same number of times.  Essentially ==, but unordered.
+    #
+    #   assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
+    def assert_same_elements(a1, a2, msg = nil)
+      [:select, :inject, :size].each do |m|
+        [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
+      end
+
+      assert a1h = a1.inject({}) { |h,e| h[e] ||= a1.select { |i| i == e }.size; h }
+      assert a2h = a2.inject({}) { |h,e| h[e] ||= a2.select { |i| i == e }.size; h }
+
+      assert_equal(a1h, a2h, msg)
+    end
+
+    # Fails if two arrays contain the same elements.  Essentially ==, but unordered.
+    #
+    #   refute_same_elements([:a, :b, :c], [:c, :a, :d]) => passes
+    def refute_same_elements(a1, a2, msg = nil)
+      [:select, :inject, :size].each do |m|
+        [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
+      end
+
+      assert a1h = a1.inject({}) { |h,e| h[e] ||= a1.select { |i| i == e }.size; h }
+      assert a2h = a2.inject({}) { |h,e| h[e] ||= a2.select { |i| i == e }.size; h }
+
+      refute_equal(a1h, a2h, msg)
+    end
+
+    # Asserts that the given collection contains item x.
+    # If x is a regular expression, ensure that
+    # at least one element from the collection matches x.
+    # +extra_msg+ is appended to the error message if the assertion fails.
+    #
+    #   assert_contains(['a', '1'], /\d/) => passes
+    #   assert_contains(['a', '1'], 'a') => passes
+    #   assert_contains(['a', '1'], /not there/) => fails
+    def assert_contains(collection, x, extra_msg = "")
+      collection = Array(collection)
+      msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
+      case x
+      when Regexp
+        assert(collection.detect { |e| e =~ x }, msg)
+      else
+        assert(collection.include?(x), msg)
+      end
+    end
+
+    # Asserts that the given collection does not contain item x.
+    # If x is a regular expression, ensure that
+    # none of the elements from the collection match x.
+    def assert_does_not_contain(collection, x, extra_msg = "")
+      collection = Array(collection)
+      msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
+      case x
+      when Regexp
+        assert(!collection.detect { |e| e =~ x }, msg)
+      else
+        assert(!collection.include?(x), msg)
+      end
+    end
+
+    # Asserts that the given matcher returns true when +target+ is passed to #matches?
+    def assert_accepts(matcher, target, options = {})
+      if matcher.respond_to?(:in_context)
+        matcher.in_context(self)
+      end
+
+      if matcher.matches?(target)
+        pass
+        if options[:message]
+          assert_match options[:message], matcher.negative_failure_message
+        end
+      else
+        flunk matcher.failure_message
+      end
+    end
+
+    # Asserts that the given matcher returns true when +target+ is passed to #does_not_match?
+    # or false when +target+ is passed to #matches? if #does_not_match? is not implemented
+    def assert_rejects(matcher, target, options = {})
+      if matcher.respond_to?(:in_context)
+        matcher.in_context(self)
+      end
+
+      not_match = matcher.respond_to?(:does_not_match?) ? matcher.does_not_match?(target) : !matcher.matches?(target)
+
+      if not_match
+        pass
+        if options[:message]
+          assert_match options[:message], matcher.failure_message
+        end
+      else
+        flunk matcher.negative_failure_message
+      end
+    end
+
+    alias :refute_contains :assert_does_not_contain
+    alias :refute_does_not_contain :assert_contains
+
+    alias :refute_accepts :assert_rejects
+    alias :refute_rejects :assert_accepts
+  end
+end

data/lib/minitest/rails/shoulda/dsl.rb

@@ -0,0 +1,28 @@
+require "minitest/spec"
+
+# Duck punch MiniTest::Spec to behave more like Shoulda
+
+class MiniTest::Spec < MiniTest::Unit::TestCase
+  class << self
+
+    # Add Shoulda DSL
+    alias :setup    :before
+    alias :teardown :after
+    alias :context  :describe
+    alias :should   :it
+
+    ##
+    # Define a named expectation to be skipped for now.
+    # The implementation may or may not be present.
+    # The test is listed but does not cause a failure.
+    #
+    # Add here so we have something to alias later...
+    def skip desc = "skipped", &block
+      it desc do
+        skip desc
+      end
+    end unless respond_to?(:skip)
+
+    alias :should_eventually :skip
+  end
+end

data/lib/minitest/rails/shoulda/matchers.rb

@@ -0,0 +1,69 @@
+require "minitest/matchers"
+
+if defined?(ActiveRecord)
+  require "minitest/rails/active_support"
+  require "shoulda/matchers/active_record"
+
+  Shoulda::Matchers::ActiveRecord.module_eval do
+    def self.included(base)
+      instance_methods.each do |name|
+        base.register_matcher name, name
+      end
+    end
+  end
+
+  class MiniTest::Rails::ActiveSupport::TestCase
+    include Shoulda::Matchers::ActiveRecord
+  end
+end
+
+if defined?(ActiveModel)
+  require "minitest/rails/active_support"
+  require "shoulda/matchers/active_model"
+
+  Shoulda::Matchers::ActiveModel.module_eval do
+    def self.included(base)
+      instance_methods.each do |name|
+        base.register_matcher name, name
+      end
+    end
+  end
+
+  class MiniTest::Rails::ActiveSupport::TestCase
+    include Shoulda::Matchers::ActiveModel
+  end
+end
+
+if defined?(ActionController)
+  require "minitest/rails/action_controller"
+  require "shoulda/matchers/action_controller"
+
+  Shoulda::Matchers::ActionController.module_eval do
+    def self.included(base)
+      instance_methods.each do |name|
+        base.register_matcher name, name
+      end
+    end
+  end
+
+  class MiniTest::Rails::ActionController::TestCase
+    include Shoulda::Matchers::ActionController
+  end
+end
+
+if defined?(ActionMailer)
+  require "minitest/rails/action_mailer"
+  require "shoulda/matchers/action_mailer"
+
+  Shoulda::Matchers::ActionMailer.module_eval do
+    def self.included(base)
+      instance_methods.each do |name|
+        base.register_matcher name, name
+      end
+    end
+  end
+
+  class MiniTest::Rails::ActionMailer::TestCase
+    include Shoulda::Matchers::ActionMailer
+  end
+end

data/lib/{minitest-rails-shoulda → minitest/rails/shoulda}/version.rb

@@ -1,7 +1,7 @@
 module MiniTest
   module Rails
     module Shoulda
-      VERSION = "0.2.0"
+      VERSION = "0.3.0"
     end
   end
 end

data/minitest-rails-shoulda.gemspec

@@ -1,6 +1,5 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "minitest-rails-shoulda/version"
+require File.expand_path("../lib/minitest/rails/shoulda/version", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "minitest-rails-shoulda"
@@ -20,5 +19,5 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency "minitest-rails",    "~> 0.2.0"
   s.add_runtime_dependency "minitest-matchers", "~> 1.2.0"
-  s.add_runtime_dependency "shoulda-matchers",  "~> 1.3.0"
+  s.add_runtime_dependency "shoulda-matchers",  "~> 1.4.1"
 end

data/test/rails_helper.rb

@@ -0,0 +1,31 @@
+require "minitest/autorun"
+require "action_controller/railtie"
+
+class TestApp < Rails::Application
+  config.secret_token = "821c600ece97fc4ba952d67655b4b475"
+  initialize!
+  routes.draw do
+    root to: 'hello#world'
+  end
+end
+class HelloController < ActionController::Base
+  def world
+    render inline: "<!DOCTYPE html><title>TestApp</title>
+                    <h1>Hello <span>World</span></h1>
+                    <nav><ul><li><a href='/'>home</a></li></ul></nav>
+                    <p><label>Email Address<input type='text'></label></p>
+                    <button>random button</button>
+                    <label>going<input type='checkbox' checked='checked'></label>
+                    <label>avoid<input type='checkbox'></label>"
+  end
+end
+
+Rails.application = TestApp
+
+require "minitest/rails"
+require "minitest/rails/shoulda"
+
+begin
+  require 'turn/autorun'
+  Turn.config.format = :progress
+rescue LoadError; end

data/test/test_assertions.rb

@@ -0,0 +1,47 @@
+require "minitest/autorun"
+require "minitest/rails/shoulda/dsl"
+require "minitest/rails/shoulda/assertions"
+
+describe "Shoulda Style Assertions" do
+
+  context "an array of values" do
+
+    setup do
+      @a = ['abc', 'def', 3]
+    end
+
+    [/b/, 'abc', 3].each do |x|
+      should "contain #{x.inspect}" do
+        assert_raises(MiniTest::Assertion) do
+          assert_does_not_contain @a, x
+        end
+        assert_contains @a, x
+        refute_does_not_contain @a, x
+      end
+    end
+
+    should "not contain 'wtf'" do
+      assert_raises(MiniTest::Assertion) {assert_contains @a, 'wtf'}
+      assert_does_not_contain @a, 'wtf'
+      refute_contains @a, 'wtf'
+    end
+
+    should "be the same as another array, ordered differently" do
+      assert_same_elements(@a, [3, "def", "abc"])
+
+      assert_raises(MiniTest::Assertion) do
+        assert_same_elements(@a, [3, 3, "def", "abc"])
+      end
+      refute_same_elements(@a, [3, 3, "def", "abc"])
+
+      assert_same_elements([@a, "abc"].flatten, ["abc", 3, "def", "abc"])
+
+      assert_raises(MiniTest::Assertion) do
+        assert_same_elements([@a, "abc"].flatten, [3, 3, "def", "abc"])
+      end
+      refute_same_elements([@a, "abc"].flatten, [3, 3, "def", "abc"])
+    end
+
+  end
+
+end

data/test/test_matchers.rb

@@ -0,0 +1,187 @@
+require "rails_helper"
+
+describe HelloController do
+
+  context "index" do
+    setup do
+      get :world
+    end
+
+    describe "assertions" do
+      it "should give us HTML" do
+        assert_respond_with_content_type(@controller, :html)
+      end
+
+      it "should not give us XML" do
+        refute_respond_with_content_type(@controller, :xml)
+      end
+    end
+
+    describe "with matchers" do
+      should "give us HTML" do
+        @controller.must respond_with_content_type(:html)
+      end
+
+      should_eventually "give us JSON"
+
+      # should_eventually "give us JSON" do
+      #   @controller.must respond_with_content_type(:json)
+      # end
+
+      should "not give us XML" do
+        @controller.wont respond_with_content_type(:xml)
+      end
+    end
+
+    describe "with subject" do
+      subject { @controller }
+
+      it { must respond_with_content_type(:html) }
+      it { wont respond_with_content_type(:xml) }
+
+      must { respond_with_content_type(:html) }
+      wont { respond_with_content_type(:xml) }
+    end
+  end
+
+  # describe "have_content" do
+  #   it "has page with content" do
+  #     visit root_path
+  #     assert_have_content page, "Hello World"
+  #     refute_have_content page, "Goobye All!"
+  #     page.must_have_content    "Hello World"
+  #     page.wont_have_content    "Goobye All!"
+  #   end
+
+  #   describe "with subject" do
+  #     before  { visit(root_path) }
+  #     subject { page }
+
+  #     it { must have_content("Hello World") }
+  #     it { wont have_content("Goobye All!") }
+  #     must { have_content("Hello World") }
+  #     wont { have_content("Goobye All!") }
+  #   end
+  # end
+
+  # describe "have_selector" do
+  #   it "has page with heading" do
+  #     visit root_path
+  #     assert_have_selector page, "h1"
+  #     refute_have_selector page, "h3"
+  #     page.must_have_selector    "h1"
+  #     page.wont_have_selector    "h3"
+  #   end
+
+  #   describe "with subject" do
+  #     before  { visit(root_path) }
+  #     subject { page }
+
+  #     it { must have_selector("h1") }
+  #     it { wont have_selector("h3") }
+  #     must { have_selector("h1") }
+  #     wont { have_selector("h3") }
+  #   end
+  # end
+
+  # describe "have_link" do
+  #   it "has a link to home" do
+  #     visit root_path
+  #     assert_have_link page, "home"
+  #     refute_have_link page, "away"
+  #     page.must_have_link    "home"
+  #     page.wont_have_link    "away"
+  #   end
+
+  #   describe "with subject" do
+  #     before  { visit(root_path) }
+  #     subject { page }
+
+  #     it { must have_link("home") }
+  #     it { wont have_link("away") }
+  #     must { have_link("home") }
+  #     wont { have_link("away") }
+  #   end
+  # end
+
+  # describe "have_field" do
+  #   it "has a button to submit" do
+  #     visit root_path
+  #     assert_have_field page, "Email Address"
+  #     refute_have_field page, "Bank Account"
+  #     page.must_have_field    "Email Address"
+  #     page.wont_have_field    "Bank Account"
+  #   end
+
+  #   describe "with subject" do
+  #     before  { visit(root_path) }
+  #     subject { page }
+
+  #     it { must have_field("Email Address") }
+  #     it { wont have_field("Bank Account") }
+  #     must { have_field("Email Address") }
+  #     wont { have_field("Bank Account") }
+  #   end
+  # end
+
+  # describe "have_button" do
+  #   it "has a button to login" do
+  #     visit root_path
+  #     assert_have_button page, "random button"
+  #     refute_have_button page, "missing button"
+  #     page.must_have_button    "random button"
+  #     page.wont_have_button    "missing button"
+  #   end
+
+  #   describe "with subject" do
+  #     before  { visit(root_path) }
+  #     subject { page }
+
+  #     it { must have_button("random button") }
+  #     it { wont have_button("missing button") }
+  #     must { have_button("random button") }
+  #     wont { have_button("missing button") }
+  #   end
+  # end
+
+  # describe "have_checked_field" do
+  #   it "has a button to submit" do
+  #     visit root_path
+  #     assert_have_checked_field page, "going"
+  #     refute_have_checked_field page, "avoid"
+  #     page.must_have_checked_field    "going"
+  #     page.wont_have_checked_field    "avoid"
+  #   end
+
+  #   describe "with subject" do
+  #     before  { visit(root_path) }
+  #     subject { page }
+
+  #     it { must have_checked_field("going") }
+  #     it { wont have_checked_field("avoid") }
+  #     must { have_checked_field("going") }
+  #     wont { have_checked_field("avoid") }
+  #   end
+  # end
+
+  # describe "have_unchecked_field" do
+  #   it "has a button to submit" do
+  #     visit root_path
+  #     assert_have_unchecked_field page, "avoid"
+  #     refute_have_unchecked_field page, "going"
+  #     page.must_have_unchecked_field    "avoid"
+  #     page.wont_have_unchecked_field    "going"
+  #   end
+
+  #   describe "with subject" do
+  #     before  { visit(root_path) }
+  #     subject { page }
+
+  #     it { must have_unchecked_field("avoid") }
+  #     it { wont have_unchecked_field("going") }
+  #     must { have_unchecked_field("avoid") }
+  #     wont { have_unchecked_field("going") }
+  #   end
+  # end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-rails-shoulda
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-27 00:00:00.000000000 Z
+date: 2012-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest-rails
@@ -51,7 +51,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -59,7 +59,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.4.1
 description: Making shoulda-matchers available for minitest-rails
 email:
 - robert@robertbousquet.com
@@ -69,15 +69,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .ruby-version
 - CHANGELOG.txt
 - Gemfile
 - License.txt
 - README.rdoc
 - Rakefile
 - lib/minitest-rails-shoulda.rb
-- lib/minitest-rails-shoulda/integrations.rb
-- lib/minitest-rails-shoulda/version.rb
+- lib/minitest/rails/shoulda.rb
+- lib/minitest/rails/shoulda/assertions.rb
+- lib/minitest/rails/shoulda/dsl.rb
+- lib/minitest/rails/shoulda/matchers.rb
+- lib/minitest/rails/shoulda/version.rb
 - minitest-rails-shoulda.gemspec
+- test/rails_helper.rb
+- test/test_assertions.rb
+- test/test_matchers.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -90,16 +97,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2081821548100069152
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2081821548100069152
 requirements: []
 rubyforge_project: minitest-rails-shoulda
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Making shoulda-matchers available for minitest-rails
-test_files: []
+test_files:
+- test/rails_helper.rb
+- test/test_assertions.rb
+- test/test_matchers.rb

data/lib/minitest-rails-shoulda/integrations.rb

@@ -1,36 +0,0 @@
-if defined? ActionController
-  require "shoulda/matchers/action_controller"
-
-  class MiniTest::Rails::ActionController::TestCase
-    include Shoulda::Matchers::ActionController
-    extend Shoulda::Matchers::ActionController
-  end
-end
-
-if defined? ActionMailer
-  require "shoulda/matchers/action_mailer"
-
-  class MiniTest::Rails::ActionMailer::TestCase
-    include Shoulda::Matchers::ActionMailer
-    extend Shoulda::Matchers::ActionMailer
-  end
-end
-
-if defined? ActiveRecord
-  require "shoulda/matchers/active_record"
-  require "shoulda/matchers/active_model"
-
-  class MiniTest::Rails::ActiveSupport::TestCase
-    include Shoulda::Matchers::ActiveRecord
-    extend Shoulda::Matchers::ActiveRecord
-    include Shoulda::Matchers::ActiveModel
-    extend Shoulda::Matchers::ActiveModel
-  end
-elsif defined? ActiveModel
-  require "shoulda/matchers/active_model"
-
-  class MiniTest::Rails::ActiveSupport::TestCase
-    include Shoulda::Matchers::ActiveModel
-    extend Shoulda::Matchers::ActiveModel
-  end
-end