shoulda-matchers 2.6.1 → 2.6.2

data/spec/report_warnings.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../warnings_spy', __FILE__)
+
+# Adapted from <http://myronmars.to/n/dev-blog/2011/08/making-your-gem-warning-free>
+
+warnings_spy = WarningsSpy.new('shoulda-matchers')
+warnings_spy.capture_warnings
+warnings_spy.report_warnings_at_exit

data/spec/shoulda/matchers/action_controller/route_matcher_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::ActionController::RouteMatcher, type: :controller do
+describe 'Shoulda::Matchers::ActionController::RouteMatcher', type: :controller do
   context 'given a controller with a defined glob url' do
     it 'accepts glob route' do
       controller = define_controller('Examples').new

data/spec/shoulda/matchers/action_controller/strong_parameters_matcher_spec.rb

@@ -25,6 +25,15 @@ describe Shoulda::Matchers::ActionController do
 
       expect(@controller).to permit(:name, :age).for(:create)
     end
+
+    it 'can be used more than once in the same test' do
+      controller_for_resource_with_strong_parameters(action: :create) do
+        params.require(:user).permit(:name)
+      end
+
+      expect(@controller).to permit(:name).for(:create)
+      expect(@controller).not_to permit(:admin).for(:create)
+    end
   end
 end
 

data/spec/shoulda/matchers/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -383,42 +383,6 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     end
   end
 
-  context "a model with non-nullable attribute" do
-    context "of type" do
-      [:string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean].each do |type|
-        context type do
-          it "does not raise an error" do
-            model = define_model_with_non_nullable(type)
-            expect { expect(model).to matcher }.not_to raise_error
-          end
-        end
-      end
-    end
-
-    context "that is a primary key" do
-      it "does not cause duplicate entry errors by re-using default values for primary keys" do
-        create_table :examples, id: false do |t|
-          t.string :attr
-          t.integer :non_nullable, primary: true
-        end
-        model_class = define_model(:example, attr: :string) do
-          validates_uniqueness_of :attr
-        end
-        model_1 = model_class.new
-        model_2 = model_class.new
-        expect(model_1).to matcher
-        expect { expect(model_2).to matcher }.not_to raise_error 
-      end
-    end
-
-    def define_model_with_non_nullable(type)
-      define_model(:example, attr: :string, non_nullable: { type: type, options: { null: false } }) do
-        attr_accessible :attr, :non_nullable
-        validates_uniqueness_of :attr
-      end.new
-    end
-  end
-
   def case_sensitive_validation_with_existing_value(attr_type)
     model = define_model(:example, attr: attr_type) do
       attr_accessible :attr

data/spec/shoulda/matchers/active_model/validation_message_finder_spec.rb

@@ -67,7 +67,7 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
 
       description = finder.messages_description
 
-      expected_messages = ['attr is invalid ("xyz")']
+      expected_messages = ['is invalid (attribute: "attr", value: "xyz")']
       expect(description).to eq "errors: #{expected_messages}"
     end
 
@@ -87,7 +87,7 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
       end.new
       finder = Shoulda::Matchers::ActiveModel::ValidationMessageFinder.new(instance, :attribute)
 
-      expected_messages = ['association.association_attribute is invalid']
+      expected_messages = ['is invalid (attribute: "association.association_attribute")']
       expect(finder.messages_description).to eq "errors: #{expected_messages}"
     end
 

data/spec/shoulda/matchers/doublespeak/double_spec.rb

@@ -103,7 +103,7 @@ module Shoulda::Matchers::Doublespeak
 
     describe '#call_original_method' do
       it 'binds the stored method object to the class and calls it with the given args and block' do
-        klass = create_class(a_method: nil)
+        klass = create_class
         instance = klass.new
         actual_args = actual_block = method_called = nil
         expected_args = [:one, :two, :three]

data/spec/shoulda/matchers/doublespeak/world_spec.rb

@@ -2,18 +2,19 @@ require 'spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe World do
-    describe '#register_double_collection' do
-      it 'calls DoubleCollection.new with the given class' do
-        DoubleCollection.expects(:new).with(:klass)
+    describe '#double_collection_for' do
+      it 'calls DoubleCollection.new once with the given class' do
+        DoubleCollection.expects(:new).with(:klass).returns(:klass).once
         world = described_class.new
-        world.register_double_collection(:klass)
+        world.double_collection_for(:klass)
+        world.double_collection_for(:klass)
       end
 
-      it 'returns the newly created DoubleCollection' do
+      it 'returns the created DoubleCollection' do
         double_collection = Object.new
         DoubleCollection.stubs(:new).with(:klass).returns(double_collection)
         world = described_class.new
-        expect(world.register_double_collection(:klass)).to be double_collection
+        expect(world.double_collection_for(:klass)).to be double_collection
       end
     end
 
@@ -40,9 +41,9 @@ module Shoulda::Matchers::Doublespeak
         DoubleCollection.stubs(:new).
           with(:klass3).
           returns(double_collections[2])
-        world.register_double_collection(:klass1)
-        world.register_double_collection(:klass2)
-        world.register_double_collection(:klass3)
+        world.double_collection_for(:klass1)
+        world.double_collection_for(:klass2)
+        world.double_collection_for(:klass3)
 
         world.with_doubles_activated { block_called = true }
 
@@ -57,32 +58,13 @@ module Shoulda::Matchers::Doublespeak
         world = described_class.new
 
         DoubleCollection.stubs(:new).returns(double_collection)
-        world.register_double_collection(:klass)
+        world.double_collection_for(:klass)
 
         begin
           world.with_doubles_activated { raise 'error' }
         rescue RuntimeError
         end
       end
-
-      it 'does not allow multiple DoubleCollections to be registered that represent the same class' do
-        double_collections = [stub, stub]
-        sequence = sequence('with_doubles_activated')
-        double_collections[0].expects(:activate).never
-        double_collections[0].expects(:deactivate).never
-        double_collections[1].expects(:activate).in_sequence(sequence)
-        double_collections[1].expects(:deactivate).in_sequence(sequence)
-
-        world = described_class.new
-
-        DoubleCollection.stubs(:new).
-          returns(double_collections[0]).then.
-          returns(double_collections[1])
-        world.register_double_collection(:klass1)
-        world.register_double_collection(:klass1)
-
-        world.with_doubles_activated { }
-      end
     end
   end
 end

data/spec/shoulda/matchers/doublespeak_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 module Shoulda::Matchers
   describe Doublespeak do
-    describe '.register_double_collection' do
+    describe '.double_collection_for' do
       it 'delegates to its world' do
-        Doublespeak.world.expects(:register_double_collection).with(:klass)
-        described_class.register_double_collection(:klass)
+        Doublespeak.world.expects(:double_collection_for).with(:klass)
+        described_class.double_collection_for(:klass)
       end
     end
 

data/spec/spec_helper.rb

@@ -1,9 +1,24 @@
 require File.expand_path('../support/test_application', __FILE__)
 
+def monkey_patch_minitest_to_do_nothing
+  # Rails 3.1's test_help file requires Turn, which loads Minitest in autorun
+  # mode. This means that Minitest tests will run after these RSpec tests are
+  # finished running. This will break on CI since we pass --color to the `rspec`
+  # command.
+
+  if defined?(MiniTest)
+    MiniTest::Unit.class_eval do
+      def run(*); end
+    end
+  end
+end
+
 $test_app = TestApplication.new
 $test_app.create
 $test_app.load
 
+monkey_patch_minitest_to_do_nothing
+
 ENV['BUNDLE_GEMFILE'] ||= app.gemfile_path
 ENV['RAILS_ENV'] = 'test'
 
@@ -24,3 +39,5 @@ RSpec.configure do |config|
   config.include Shoulda::Matchers::ActionController,
                  example_group: { file_path: /action_controller/ }
 end
+
+$VERBOSE = true

data/spec/support/class_builder.rb

@@ -10,6 +10,10 @@ module ClassBuilder
   def define_class(class_name, base = Object, &block)
     class_name = class_name.to_s.camelize
 
+    if Object.const_defined?(class_name)
+      Object.__send__(:remove_const, class_name)
+    end
+
     # FIXME: ActionMailer 3.2 calls `name.underscore` immediately upon
     # subclassing. Class.new.name == nil. So, Class.new(ActionMailer::Base)
     # errors out since it's trying to do `nil.underscore`. This is very ugly but

data/spec/support/test_application.rb

@@ -92,7 +92,7 @@ EOT
   end
 
   def install_gems
-    retrying('bundle install') do |command|
+    retrying('bundle install --local') do |command|
       Bundler.with_clean_env { `#{command}` }
     end
   end

data/spec/warnings_spy.rb

@@ -0,0 +1,64 @@
+require 'forwardable'
+
+require File.expand_path('../warnings_spy/filesystem', __FILE__)
+require File.expand_path('../warnings_spy/reader', __FILE__)
+require File.expand_path('../warnings_spy/partitioner', __FILE__)
+require File.expand_path('../warnings_spy/reporter', __FILE__)
+
+class WarningsSpy
+  extend Forwardable
+
+  def initialize(project_name)
+    filesystem = Filesystem.new
+    @warnings_file = filesystem.warnings_file
+    @reader = Reader.new(filesystem)
+    @partitioner = Partitioner.new(reader, filesystem)
+    @reporter = Reporter.new(partitioner, filesystem, project_name)
+  end
+
+  def capture_warnings
+    $stderr.reopen(warnings_file.path)
+  end
+
+  def report_warnings_at_exit
+    at_exit do
+      printing_exceptions do
+        report_and_exit
+      end
+    end
+  end
+
+  protected
+
+  attr_reader :warnings_file, :reader, :partitioner, :reporter
+
+  private
+
+  def_delegators :partitioner, :relevant_warning_groups,
+    :irrelevant_warning_groups
+
+  def report_and_exit
+    reader.read
+    partitioner.partition
+    reporter.report
+    #fail_build_if_there_are_any_warnings
+  end
+
+  def fail_build_if_there_are_any_warnings
+    if relevant_warning_groups.any?
+      exit(1)
+    end
+  end
+
+  def printing_exceptions
+    begin
+      yield
+    rescue => error
+      puts "\n--- ERROR IN AT_EXIT --------------------------------"
+      puts "#{error.class}: #{error.message}"
+      puts error.backtrace.join("\n")
+      puts "-----------------------------------------------------"
+      raise error
+    end
+  end
+end

data/spec/warnings_spy/filesystem.rb

@@ -0,0 +1,45 @@
+require 'fileutils'
+
+class WarningsSpy
+  class Filesystem
+    PROJECT_DIR = File.expand_path('../../..', __FILE__)
+    TEMP_DIR = File.join(PROJECT_DIR, 'tmp')
+
+    def initialize
+      @files_by_name = Hash.new do |hash, name|
+        FileUtils.mkdir_p(TEMP_DIR)
+        hash[name] = file_for(name)
+      end
+    end
+
+    def warnings_file
+      files_by_name['all_warnings']
+    end
+
+    def irrelevant_warnings_file
+      files_by_name['irrelevant_warnings']
+    end
+
+    def relevant_warnings_file
+      files_by_name['relevant_warnings']
+    end
+
+    def project_dir
+      PROJECT_DIR
+    end
+
+    protected
+
+    attr_reader :files_by_name
+
+    private
+
+    def path_for(name)
+      File.join(TEMP_DIR, "#{name}.txt")
+    end
+
+    def file_for(name)
+      File.open(path_for(name), 'w+')
+    end
+  end
+end

data/spec/warnings_spy/partitioner.rb

@@ -0,0 +1,29 @@
+require 'forwardable'
+
+class WarningsSpy
+  class Partitioner
+    extend Forwardable
+
+    attr_reader :relevant_warning_groups, :irrelevant_warning_groups
+
+    def initialize(reader, filesystem)
+      @reader = reader
+      @search_text = filesystem.project_dir
+    end
+
+    def partition
+      @relevant_warning_groups, @irrelevant_warning_groups =
+        warning_groups.partition do |group|
+          group.any? { |line| line.include?(search_text) }
+        end
+    end
+
+    protected
+
+    attr_reader :reader, :search_text
+
+    private
+
+    def_delegators :reader, :warning_groups
+  end
+end

data/spec/warnings_spy/reader.rb

@@ -0,0 +1,64 @@
+class WarningsSpy
+  class Reader
+    attr_reader :warning_groups
+
+    def initialize(filesystem)
+      @warnings_file = filesystem.warnings_file
+
+      @recording = false
+      @current_group = []
+      @warning_groups = []
+    end
+
+    def read
+      warnings_file.rewind
+
+      warnings_file.each_line do |line|
+        process_line(line)
+      end
+
+      add_group(current_group)
+    end
+
+    protected
+
+    attr_reader :warnings_file, :current_group
+
+    private
+
+    def process_line(line)
+      if backtrace_line?(line) && recording?
+        current_group << line
+      else
+        unless current_group.empty?
+          add_group(current_group)
+          current_group.clear
+        end
+
+        current_group << line
+
+        @recording = true
+      end
+    end
+
+    def add_group(group)
+      unless group_already_added?(group)
+        warning_groups << group
+      end
+    end
+
+    def group_already_added?(group_to_be_added)
+      warning_groups.any? do |group|
+        group == group_to_be_added
+      end
+    end
+
+    def backtrace_line?(line)
+      line =~ /^\s+/
+    end
+
+    def recording?
+      @recording
+    end
+  end
+end