shoulda-matchers 3.0.0.rc1 → 3.0.0

data/spec/unit/shoulda/matchers/doublespeak/double_collection_spec.rb

@@ -26,6 +26,36 @@ module Shoulda::Matchers::Doublespeak
           to have_received(:new).
           with(world, :klass, :a_method, :implementation)
       end
+
+      context 'if a double has already been registered for the method' do
+        it 'does not call Double.new again' do
+          world = build_world
+          allow(DoubleImplementationRegistry).
+            to receive(:find).
+            and_return(:implementation)
+          allow(Double).to receive(:new)
+          double_collection = described_class.new(world, :klass)
+
+          double_collection.register_stub(:a_method)
+          double_collection.register_stub(:a_method)
+
+          expect(Double).to have_received(:new).once
+        end
+
+        it 'returns the same Double' do
+          world = build_world
+          allow(DoubleImplementationRegistry).
+            to receive(:find).
+            and_return(:implementation)
+          allow(Double).to receive(:new)
+          double_collection = described_class.new(world, :klass)
+
+          double1 = double_collection.register_stub(:a_method)
+          double2 = double_collection.register_stub(:a_method)
+
+          expect(double1).to equal(double2)
+        end
+      end
     end
 
     describe '#register_proxy' do
@@ -54,6 +84,36 @@ module Shoulda::Matchers::Doublespeak
           to have_received(:new).
           with(world, :klass, :a_method, :implementation)
       end
+
+      context 'if a double has already been registered for the method' do
+        it 'does not call Double.new again' do
+          world = build_world
+          allow(DoubleImplementationRegistry).
+            to receive(:find).
+            and_return(:implementation)
+          allow(Double).to receive(:new)
+          double_collection = described_class.new(world, :klass)
+
+          double_collection.register_proxy(:a_method)
+          double_collection.register_proxy(:a_method)
+
+          expect(Double).to have_received(:new).once
+        end
+
+        it 'returns the same Double' do
+          world = build_world
+          allow(DoubleImplementationRegistry).
+            to receive(:find).
+            and_return(:implementation)
+          allow(Double).to receive(:new)
+          double_collection = described_class.new(world, :klass)
+
+          double1 = double_collection.register_proxy(:a_method)
+          double2 = double_collection.register_proxy(:a_method)
+
+          expect(double1).to equal(double2)
+        end
+      end
     end
 
     describe '#activate' do

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

@@ -2,6 +2,20 @@ require 'doublespeak_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe Double do
+    describe 'initializer' do
+      context 'if doubles are currently activated on the world level' do
+        it 'immediately activates the new Double' do
+          world = build_world(doubles_activated?: true)
+          klass = create_class(a_method_name: nil)
+          implementation = build_implementation
+
+          double = described_class.new(world, klass, :a_method_name, implementation)
+
+          expect(double).to be_activated
+        end
+      end
+    end
+
     describe '#to_return' do
       it 'tells its implementation to call the given block' do
         sent_block = -> { }
@@ -12,7 +26,7 @@ module Shoulda::Matchers::Doublespeak
           actual_block = block
         end
         double = described_class.new(
-          :a_world,
+          build_world,
           :klass,
           :a_method,
           implementation
@@ -24,7 +38,7 @@ module Shoulda::Matchers::Doublespeak
       it 'tells its implementation to return the given value' do
         implementation = build_implementation
         double = described_class.new(
-          :a_world,
+          build_world,
           :klass,
           :a_method,
           implementation
@@ -43,7 +57,7 @@ module Shoulda::Matchers::Doublespeak
           actual_block = block
         end
         double = described_class.new(
-          :a_world,
+          build_world,
           :klass,
           :a_method,
           implementation
@@ -72,7 +86,8 @@ module Shoulda::Matchers::Doublespeak
           object: instance,
           method_name: method_name,
           args: args,
-          block: block
+          block: block,
+          caller: :some_caller
         )
 
         double.activate
@@ -127,7 +142,7 @@ module Shoulda::Matchers::Doublespeak
         klass = create_class(a_method: 42)
         instance = klass.new
         double = described_class.new(
-          :a_world,
+          build_world,
           klass,
           :a_method,
           build_implementation
@@ -141,7 +156,7 @@ module Shoulda::Matchers::Doublespeak
     describe '#record_call' do
       it 'adds the given call to the list of calls' do
         double = described_class.new(
-          :a_world,
+          build_world,
           :a_klass,
           :a_method,
           :an_implementation
@@ -247,7 +262,8 @@ module Shoulda::Matchers::Doublespeak
     def build_world(methods = {})
       defaults = {
         original_method_for: nil,
-        store_original_method_for: nil
+        store_original_method_for: nil,
+        doubles_activated?: nil
       }
       double('world', defaults.merge(methods))
     end

data/spec/unit/shoulda/matchers/routing/route_matcher_spec.rb

@@ -0,0 +1,242 @@
+require 'unit_spec_helper'
+
+describe 'Shoulda::Matchers::Routing::RouteMatcher', type: :routing do
+  before do
+    define_controller('ThingsController')
+  end
+
+  shared_examples_for 'core tests' do
+    context 'when the given method, path, controller, and action match an existing route' do
+      it 'accepts' do
+        define_routes { get '/', to: 'things#index' }
+
+        assert_accepts add_target_to(
+          route(:get, '/'),
+          controller: 'things',
+          action: 'index'
+        )
+      end
+
+      context 'and the expected controller is specified as a symbol' do
+        it 'accepts' do
+          define_routes { get '/', to: 'things#index' }
+
+          assert_accepts add_target_to(
+            route(:get, '/'),
+            controller: :things,
+            action: 'index'
+          )
+        end
+      end
+
+      context 'and the expected action is specified as a symbol' do
+        it 'accepts' do
+          define_routes { get '/', to: 'things#index' }
+
+          assert_accepts add_target_to(
+            route(:get, '/'),
+            controller: 'things',
+            action: :index
+          )
+        end
+      end
+    end
+
+    context 'when the given method, path, controller, and action do not match an existing route' do
+      it 'rejects' do
+        assert_rejects add_target_to(
+          route(:get, '/non_existent_route'),
+          controller: 'no_controller',
+          action: 'no_action'
+        )
+      end
+    end
+
+    context 'when the given path, controller, and action match an existing route but the method does not' do
+      it 'rejects' do
+        define_routes { post '/', to: 'things#index' }
+
+        assert_rejects add_target_to(
+          route(:get, '/'),
+          controller: 'things',
+          action: 'index'
+        )
+      end
+    end
+
+    context 'when the given method, controller, and action match an existing route but the path does not' do
+      it 'rejects' do
+        define_routes { get '/', to: 'things#index' }
+
+        assert_rejects add_target_to(
+          route(:get, '/different_path'),
+          controller: 'things',
+          action: 'index'
+        )
+      end
+    end
+
+    context 'when the given method and path match an existing route but the controller does not' do
+      it 'rejects' do
+        define_routes { get '/', to: 'another_controller#index' }
+
+        assert_rejects add_target_to(
+          route(:get, '/'),
+          controller: 'things',
+          action: 'index'
+        )
+      end
+    end
+
+    context 'when the given method, path, and controller match an existing route but the action does not' do
+      it 'rejects' do
+        define_routes { get '/', to: 'things#index' }
+
+        assert_rejects add_target_to(
+          route(:get, '/'),
+          controller: 'things',
+          action: 'another_action'
+        )
+      end
+    end
+
+    context 'when the actual route has a param' do
+      context 'and the expected params include that param' do
+        it 'accepts' do
+          define_routes { get '/things/:id', to: 'things#show' }
+
+          assert_accepts add_target_to(
+            route(:get, '/things/1'),
+            controller: 'things',
+            action: 'show',
+            id: '1'
+          )
+        end
+
+        context 'but its value was not specified as a string' do
+          it 'accepts, treating it as a string' do
+            define_routes { get '/things/:id', to: 'things#show' }
+
+            assert_accepts add_target_to(
+              route(:get, '/things/1'),
+              controller: 'things',
+              action: 'show',
+              id: 1
+            )
+          end
+        end
+      end
+
+      context 'and the expected params do not match the actual params' do
+        it 'rejects' do
+          define_routes { get '/things/:id', to: 'things#show' }
+
+          params = {
+            controller: 'things',
+            action: 'show',
+            some: 'other',
+            params: 'here'
+          }
+          assert_rejects add_target_to(
+            route(:get, '/things/:id'),
+            params
+          )
+        end
+      end
+    end
+
+    context 'when the actual route has a default param whose value is a symbol' do
+      context 'and the expected params include a value for it' do
+        context 'as a symbol' do
+          it 'accepts' do
+            define_routes do
+              post '/things(.:format)',
+                to: 'things#create',
+                defaults: { format: :json }
+            end
+
+            assert_accepts add_target_to(
+              route(:post, '/things'),
+              controller: 'things',
+              action: 'create',
+              format: :json
+            )
+          end
+        end
+
+        context 'as a string' do
+          it 'accepts' do
+            define_routes do
+              post '/things(.:format)',
+                to: 'things#create',
+                defaults: { format: :json }
+            end
+
+            assert_accepts add_target_to(
+              route(:post, '/things'),
+              controller: 'things',
+              action: 'create',
+              format: 'json'
+            )
+          end
+        end
+      end
+    end
+
+    context 'when the existing route has a glob segment' do
+      context 'and a param is given which represents the segment' do
+        it 'accepts' do
+          define_routes { get '/things/*id', to: 'things#whatever' }
+
+          assert_accepts add_target_to(
+            route(:get, '/things/foo/bar'),
+            controller: 'things',
+            action: 'whatever',
+            id: 'foo/bar'
+          )
+        end
+      end
+
+      context 'and no param is given which represents the segment' do
+        it 'rejects' do
+          define_routes { get '/things/*id', to: 'things#whatever' }
+
+          assert_rejects add_target_to(
+            route(:get, '/things'),
+            controller: 'things',
+            action: 'whatever'
+          )
+        end
+      end
+    end
+  end
+
+  context 'given a controller and action specified as individual options' do
+    include_examples 'core tests'
+
+    def add_target_to(route_matcher, params)
+      route_matcher.to(params)
+    end
+  end
+
+  context 'given a controller and action joined together in a string' do
+    include_examples 'core tests'
+
+    def add_target_to(route_matcher, args)
+      controller = args.fetch(:controller)
+      action = args.fetch(:action)
+      route_matcher.to(
+        "#{controller}##{action}",
+        args.except(:controller, :action)
+      )
+    end
+  end
+
+  def assert_accepts(matcher)
+    should(matcher)
+  end
+
+  def assert_rejects(matcher)
+    should_not(matcher)
+  end
+end

data/spec/unit_spec_helper.rb

@@ -30,6 +30,10 @@ RSpec.configure do |config|
     c.syntax = :expect
   end
 
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
   config.mock_with :rspec
 
   if config.respond_to?(:infer_spec_type_from_file_location!)

data/tasks/documentation.rb

@@ -33,6 +33,41 @@ module Shoulda
             publisher.generate_docs_for(args.version, latest_version: args.latest_version)
           end
 
+          desc 'Watch source files for this project for changes and autogenerate docs accordingly'
+          task :autogenerate do
+            require 'fssm'
+
+            project_directory = File.expand_path(File.dirname(__FILE__) + "/..")
+
+            regenerate_docs = -> (base, relative) {
+              print 'Regenerating docs... '
+              system('bundle exec yard doc &>/dev/null')
+              puts 'done!'
+            }
+
+            puts 'Waiting for documentation files to change...'
+
+            FSSM.monitor do
+              path project_directory do
+                glob 'README.md'
+                create(&regenerate_docs)
+                update(&regenerate_docs)
+              end
+
+              path File.join(project_directory, 'doc_config/yard') do
+                glob '**/*.rb'
+                create(&regenerate_docs)
+                update(&regenerate_docs)
+              end
+
+              path File.join(project_directory, 'lib') do
+                glob '**/*.rb'
+                create(&regenerate_docs)
+                update(&regenerate_docs)
+              end
+            end
+          end
+
           desc 'Generate docs for a particular version and push them to GitHub'
           task :publish, [:version, :latest_version] => :setup do |t, args|
             unless args.version