transpec 1.6.1 → 1.7.0

data/spec/transpec/syntax/operator_matcher_spec.rb

@@ -181,13 +181,13 @@ module Transpec
             let(:parenthesize_arg) { false }
 
             let(:expected_source) do
-            <<-END
+              <<-END
               describe 'example' do
                 it 'is 1' do
                   subject.should eq 1
                 end
               end
-            END
+              END
             end
 
             it 'converts into `eq 1` form' do
@@ -691,13 +691,13 @@ module Transpec
             let(:always) { true }
 
             let(:expected_source) do
-            <<-END
+              <<-END
               describe 'example' do
                 it 'is 1' do
                   subject.should eq(1)
                 end
               end
-            END
+              END
             end
 
             it 'inserts parentheses' do
@@ -709,13 +709,13 @@ module Transpec
             let(:always) { false }
 
             let(:expected_source) do
-            <<-END
+              <<-END
               describe 'example' do
                 it 'is 1' do
                   subject.should eq 1
                 end
               end
-            END
+              END
             end
 
             it 'does not nothing' do

data/spec/transpec/syntax/receive_spec.rb

@@ -0,0 +1,270 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'transpec/syntax/receive'
+require 'transpec/syntax/expect'
+require 'transpec/syntax/allow'
+
+module Transpec
+  class Syntax
+    describe Receive do
+      include_context 'parsed objects'
+      include_context 'syntax object', Expect, :expect_object
+      include_context 'syntax object', Allow, :allow_object
+
+      describe '#add_receiver_arg_to_any_instance_implementation_block!' do
+        let(:record) { receive_object.report.records.last }
+
+        before do
+          receive_object.add_receiver_arg_to_any_instance_implementation_block!
+        end
+
+        context 'with #expect' do
+          let(:receive_object) { expect_object.receive_matcher }
+
+          context 'when it is `expect_any_instance_of(Klass).to receive(:method) do |arg| .. end` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'receives #foo' do
+                    expect_any_instance_of(Klass).to receive(:foo) do |arg|
+                    end
+                  end
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                describe 'example' do
+                  it 'receives #foo' do
+                    expect_any_instance_of(Klass).to receive(:foo) do |instance, arg|
+                    end
+                  end
+                end
+              END
+            end
+
+            it 'converts into `expect_any_instance_of(Klass).to receive(:method) do |instance, arg| .. end` form' do
+              rewritten_source.should == expected_source
+            end
+
+            it 'adds record `expect_any_instance_of(Klass).to receive(:message) { |arg| }` ' +
+               '-> `Klass.any_instance.should_receive(:message) { |instance, arg| }`' do
+              record.original_syntax.should  == 'expect_any_instance_of(Klass).to receive(:message) { |arg| }'
+              record.converted_syntax.should == 'expect_any_instance_of(Klass).to receive(:message) { |instance, arg| }'
+            end
+          end
+
+          context 'when it is `expect_any_instance_of(Klass).to receive(:method) { |arg| .. }` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'receives #foo' do
+                    expect_any_instance_of(Klass).to receive(:foo) { |arg|
+                    }
+                  end
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                describe 'example' do
+                  it 'receives #foo' do
+                    expect_any_instance_of(Klass).to receive(:foo) { |instance, arg|
+                    }
+                  end
+                end
+              END
+            end
+
+            it 'converts into `expect_any_instance_of(Klass).to receive(:method) { |instance, arg| .. }` form' do
+              rewritten_source.should == expected_source
+            end
+
+            it 'adds record `expect_any_instance_of(Klass).to receive(:message) { |arg| }` ' +
+               '-> `Klass.any_instance.should_receive(:message) { |instance, arg| }`' do
+              record.original_syntax.should  == 'expect_any_instance_of(Klass).to receive(:message) { |arg| }'
+              record.converted_syntax.should == 'expect_any_instance_of(Klass).to receive(:message) { |instance, arg| }'
+            end
+          end
+
+          context 'when it is `expect_any_instance_of(Klass).to receive(:method) do .. end` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'receives #foo' do
+                    expect_any_instance_of(Klass).to receive(:foo) do
+                    end
+                  end
+                end
+              END
+            end
+
+            it 'does nothing' do
+              rewritten_source.should == source
+            end
+          end
+
+          context 'when it is `expect_any_instance_of(Klass).to receive(:method) do |instance| .. end` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'receives #foo' do
+                    expect_any_instance_of(Klass).to receive(:foo) do |instance|
+                    end
+                  end
+                end
+              END
+            end
+
+            it 'does nothing' do
+              rewritten_source.should == source
+            end
+          end
+
+          context 'when it is `expect(subject).to receive(:method) do |arg| .. end` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'receives #foo' do
+                    expect(subject).to receive(:foo) do |arg|
+                    end
+                  end
+                end
+              END
+            end
+
+            it 'does nothing' do
+              rewritten_source.should == source
+            end
+          end
+        end
+
+        context 'with #allow' do
+          let(:receive_object) { allow_object.receive_matcher }
+
+          context 'when it is `allow_any_instance_of(Klass).to receive(:method) do |arg| .. end` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'responds to #foo' do
+                    allow_any_instance_of(Klass).to receive(:foo) do |arg|
+                    end
+                  end
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                describe 'example' do
+                  it 'responds to #foo' do
+                    allow_any_instance_of(Klass).to receive(:foo) do |instance, arg|
+                    end
+                  end
+                end
+              END
+            end
+
+            it 'converts into `allow_any_instance_of(Klass).to receive(:method) do |instance, arg| .. end` form' do
+              rewritten_source.should == expected_source
+            end
+
+            it 'adds record `allow_any_instance_of(Klass).to receive(:message) { |arg| }` ' +
+               '-> `Klass.any_instance.should_receive(:message) { |instance, arg| }`' do
+              record.original_syntax.should  == 'allow_any_instance_of(Klass).to receive(:message) { |arg| }'
+              record.converted_syntax.should == 'allow_any_instance_of(Klass).to receive(:message) { |instance, arg| }'
+            end
+          end
+
+          context 'when it is `allow_any_instance_of(Klass).to receive(:method) { |arg| .. }` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'responds to #foo' do
+                    allow_any_instance_of(Klass).to receive(:foo) { |arg|
+                    }
+                  end
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                describe 'example' do
+                  it 'responds to #foo' do
+                    allow_any_instance_of(Klass).to receive(:foo) { |instance, arg|
+                    }
+                  end
+                end
+              END
+            end
+
+            it 'converts into `allow_any_instance_of(Klass).to receive(:method) { |instance, arg| .. }` form' do
+              rewritten_source.should == expected_source
+            end
+
+            it 'adds record `allow_any_instance_of(Klass).to receive(:message) { |arg| }` ' +
+               '-> `Klass.any_instance.should_receive(:message) { |instance, arg| }`' do
+              record.original_syntax.should  == 'allow_any_instance_of(Klass).to receive(:message) { |arg| }'
+              record.converted_syntax.should == 'allow_any_instance_of(Klass).to receive(:message) { |instance, arg| }'
+            end
+          end
+
+          context 'when it is `allow_any_instance_of(Klass).to receive(:method) do .. end` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'responds to #foo' do
+                    allow_any_instance_of(Klass).to receive(:foo) do
+                    end
+                  end
+                end
+              END
+            end
+
+            it 'does nothing' do
+              rewritten_source.should == source
+            end
+          end
+
+          context 'when it is `allow_any_instance_of(Klass).to receive(:method) do |instance| .. end` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'responds to #foo' do
+                    allow_any_instance_of(Klass).to receive(:foo) do |instance|
+                    end
+                  end
+                end
+              END
+            end
+
+            it 'does nothing' do
+              rewritten_source.should == source
+            end
+          end
+
+          context 'when it is `allow(subject).to receive(:method) do |arg| .. end` form' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'responds to #foo' do
+                    allow(subject).to receive(:foo) do |arg|
+                    end
+                  end
+                end
+              END
+            end
+
+            it 'does nothing' do
+              rewritten_source.should == source
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/transpec/syntax/rspec_configure_spec.rb

@@ -9,18 +9,15 @@ module Transpec
       include_context 'parsed objects'
       include_context 'syntax object', RSpecConfigure, :rspec_configure
 
-      [
-        [:expectation_syntaxes, :expect_with, 'RSpec::Matchers::Configuration'],
-        [:mock_syntaxes,        :mock_with,   'RSpec::Mocks::Configuration']
-      ].each do |subject_method, config_block_method, framework_config_class|
-        describe "##{subject_method}" do
-          subject { rspec_configure.send(subject_method) }
+      shared_examples '#syntaxes' do |framework_block_method|
+        describe '#syntaxes' do
+          subject { super().syntaxes }
 
           context 'when :should is enabled' do
             let(:source) do
               <<-END
                 RSpec.configure do |config|
-                  config.#{config_block_method} :rspec do |c|
+                  config.#{framework_block_method} :rspec do |c|
                     c.syntax = :should
                   end
                 end
@@ -36,7 +33,7 @@ module Transpec
             let(:source) do
               <<-END
                 RSpec.configure do |config|
-                  config.#{config_block_method} :rspec do |c|
+                  config.#{framework_block_method} :rspec do |c|
                     c.syntax = [:should, :expect]
                   end
                 end
@@ -52,7 +49,7 @@ module Transpec
             let(:source) do
               <<-END
                 RSpec.configure do |config|
-                  config.#{config_block_method} :rspec do |c|
+                  config.#{framework_block_method} :rspec do |c|
                     c.syntax = some_syntax
                   end
                 end
@@ -60,11 +57,11 @@ module Transpec
             end
 
             it 'raises error' do
-              -> { subject }.should raise_error(RSpecConfigure::UnknownSyntaxError)
+              -> { subject }.should raise_error(RSpecConfigure::Framework::UnknownSyntaxError)
             end
           end
 
-          context "when RSpec::Core::Configuration##{config_block_method} block does not exist" do
+          context "when ##{framework_block_method} block does not exist" do
             let(:source) do
               <<-END
                 RSpec.configure do |config|
@@ -77,11 +74,11 @@ module Transpec
             end
           end
 
-          context "when #{framework_config_class}#syntax= does not exist" do
+          context "when ##{framework_block_method} { #syntax= } does not exist" do
             let(:source) do
               <<-END
                 RSpec.configure do |config|
-                  config.#{config_block_method} :rspec do |c|
+                  config.#{framework_block_method} :rspec do |c|
                   end
                 end
               END
@@ -94,19 +91,16 @@ module Transpec
         end
       end
 
-      [
-        [:modify_expectation_syntaxes!, :expect_with, 'RSpec::Matchers::Configuration'],
-        [:modify_mock_syntaxes!,        :mock_with,   'RSpec::Mocks::Configuration']
-      ].each do |subject_method, config_block_method, framework_config_class|
-        describe "##{subject_method}" do
+      shared_examples '#syntaxes=' do |framework_block_method|
+        describe '#syntaxes=' do
           before do
-            rspec_configure.send(subject_method, syntaxes)
+            subject.syntaxes = syntaxes
           end
 
           let(:source) do
             <<-END
               RSpec.configure do |config|
-                config.#{config_block_method} :rspec do |c|
+                config.#{framework_block_method} :rspec do |c|
                   c.syntax = :should
                 end
               end
@@ -117,13 +111,13 @@ module Transpec
             let(:syntaxes) { :expect }
 
             let(:expected_source) do
-            <<-END
+              <<-END
               RSpec.configure do |config|
-                config.#{config_block_method} :rspec do |c|
+                config.#{framework_block_method} :rspec do |c|
                   c.syntax = :expect
                 end
               end
-            END
+              END
             end
 
             it 'rewrites syntax specification to `c.syntax = :expect`' do
@@ -135,13 +129,13 @@ module Transpec
             let(:syntaxes) { [:should, :expect] }
 
             let(:expected_source) do
-            <<-END
+              <<-END
               RSpec.configure do |config|
-                config.#{config_block_method} :rspec do |c|
+                config.#{framework_block_method} :rspec do |c|
                   c.syntax = [:should, :expect]
                 end
               end
-            END
+              END
             end
 
             it 'rewrites syntax specification to `c.syntax = [:should, :expect]`' do
@@ -149,12 +143,229 @@ module Transpec
             end
           end
 
-          context 'when RSpec::Core::Configuration#expect_with block does not exist' do
-            pending
+          context "when ##{framework_block_method} { #syntax= } does not exist" do
+            let(:source) do
+              <<-END
+                RSpec.configure do |config|
+                  config.#{framework_block_method} :rspec do |c|
+                  end
+                end
+              END
+            end
+
+            let(:syntaxes) { :expect }
+
+            let(:expected_source) do
+              <<-END
+                RSpec.configure do |config|
+                  config.#{framework_block_method} :rspec do |c|
+                    c.syntax = :expect
+                  end
+                end
+              END
+            end
+
+            it 'adds #syntax= statement' do
+              rewritten_source.should == expected_source
+            end
           end
 
-          context "when #{framework_config_class}#syntax= does not exist" do
-            pending
+          context "when ##{framework_block_method} block does not exist" do
+            let(:source) do
+              <<-END
+                RSpec.configure do |config|
+                end
+              END
+            end
+
+            let(:syntaxes) { :expect }
+
+            let(:expected_source) do
+              <<-END
+                RSpec.configure do |config|
+                  config.#{framework_block_method} :rspec do |c|
+                    c.syntax = :expect
+                  end
+                end
+              END
+            end
+
+            it "adds ##{framework_block_method} block " +
+               'and #syntax= statement' do
+              rewritten_source.should == expected_source
+            end
+
+            context 'when there are already some configurations' do
+              let(:source) do
+                <<-END
+                  RSpec.configure do |config|
+                    config.foo = 1
+                  end
+                END
+              end
+
+              let(:syntaxes) { :expect }
+
+              let(:expected_source) do
+                <<-END
+                  RSpec.configure do |config|
+                    config.foo = 1
+
+                    config.#{framework_block_method} :rspec do |c|
+                      c.syntax = :expect
+                    end
+                  end
+                END
+              end
+
+              it 'adds the block after a blank line' do
+                rewritten_source.should == expected_source
+              end
+            end
+          end
+        end
+      end
+
+      describe '#expectations' do
+        subject { rspec_configure.expectations }
+
+        include_examples '#syntaxes', :expect_with
+        include_examples '#syntaxes=', :expect_with
+      end
+
+      describe '#mocks' do
+        subject(:mocks) { rspec_configure.mocks }
+
+        include_examples '#syntaxes', :mock_with
+        include_examples '#syntaxes=', :mock_with
+
+        describe '#yield_receiver_to_any_instance_implementation_blocks=' do
+          before do
+            mocks.yield_receiver_to_any_instance_implementation_blocks = value
+          end
+
+          context 'when #mock_with { #yield_receiver_to_any_instance_implementation_blocks= } exists' do
+            let(:source) do
+              <<-END
+                RSpec.configure do |config|
+                  config.mock_with :rspec do |c|
+                    c.yield_receiver_to_any_instance_implementation_blocks = foo
+                  end
+                end
+              END
+            end
+
+            context 'when true is passed' do
+              let(:value) { true }
+
+              let(:expected_source) do
+                <<-END
+                RSpec.configure do |config|
+                  config.mock_with :rspec do |c|
+                    c.yield_receiver_to_any_instance_implementation_blocks = true
+                  end
+                end
+                END
+              end
+
+              it 'rewrites the setter argument to `true`' do
+                rewritten_source.should == expected_source
+              end
+            end
+
+            context 'when false is passed' do
+              let(:value) { false }
+
+              let(:expected_source) do
+                <<-END
+                RSpec.configure do |config|
+                  config.mock_with :rspec do |c|
+                    c.yield_receiver_to_any_instance_implementation_blocks = false
+                  end
+                end
+                END
+              end
+
+              it 'rewrites the setter argument to `false`' do
+                rewritten_source.should == expected_source
+              end
+            end
+          end
+
+          context 'when #mock_with { #yield_receiver_to_any_instance_implementation_blocks= } does not exist' do
+            let(:source) do
+              <<-END
+                RSpec.configure do |config|
+                  config.mock_with :rspec do |c|
+                  end
+                end
+              END
+            end
+
+            let(:value) { true }
+
+            let(:expected_source) do
+              <<-END
+                RSpec.configure do |config|
+                  config.mock_with :rspec do |c|
+                    c.yield_receiver_to_any_instance_implementation_blocks = true
+                  end
+                end
+              END
+            end
+
+            it 'adds #yield_receiver_to_any_instance_implementation_blocks= statement' do
+              rewritten_source.should == expected_source
+            end
+          end
+
+          context 'when #mock_with block does not exist' do
+            let(:source) do
+              <<-END
+                RSpec.configure do |config|
+                end
+              END
+            end
+
+            let(:value) { true }
+
+            let(:expected_source) do
+              <<-END
+                RSpec.configure do |config|
+                  config.mock_with :rspec do |c|
+                    c.yield_receiver_to_any_instance_implementation_blocks = true
+                  end
+                end
+              END
+            end
+
+            it 'adds #mock_with block ' +
+               'and #yield_receiver_to_any_instance_implementation_blocks= statement' do
+              rewritten_source.should == expected_source
+            end
+
+            context "when RSpec.configure's argument variable name is `rspec`" do
+              let(:source) do
+                <<-END
+                  RSpec.configure do |rspec|
+                  end
+                END
+              end
+
+              let(:expected_source) do
+                <<-END
+                  RSpec.configure do |rspec|
+                    rspec.mock_with :rspec do |mocks|
+                      mocks.yield_receiver_to_any_instance_implementation_blocks = true
+                    end
+                  end
+                END
+              end
+
+              it 'defines #mock_with block argument name as `mocks`' do
+                rewritten_source.should == expected_source
+              end
+            end
           end
         end
       end