transpec 0.0.1

data/spec/transpec/syntax/method_stub_spec.rb

@@ -0,0 +1,386 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  class Syntax
+    describe MethodStub do
+      include_context 'parsed objects'
+
+      subject(:method_stub_object) do
+        AST::Scanner.scan(ast) do |node, ancestor_nodes, in_example_group_context|
+          next unless MethodStub.target_node?(node)
+          return MethodStub.new(
+            node,
+            ancestor_nodes,
+            in_example_group_context?,
+            source_rewriter
+          )
+        end
+        fail 'No method stub node is found!'
+      end
+
+      let(:in_example_group_context?) { true }
+
+      describe '#method_name' do
+        let(:source) do
+          <<-END
+            it 'responds to #foo' do
+              subject.stub(:foo)
+            end
+          END
+        end
+
+        it 'returns the method name' do
+          method_stub_object.method_name.should == :stub
+        end
+      end
+
+      describe '#allowize!' do
+        [:stub, :stub!].each do |method|
+          context "when it is `subject.#{method}(:method)` form" do
+            let(:source) do
+              <<-END
+                it 'responds to #foo' do
+                  subject.#{method}(:foo)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'responds to #foo' do
+                  allow(subject).to receive(:foo)
+                end
+              END
+            end
+
+            it 'converts into `allow(subject).to receive(:method)` form' do
+              method_stub_object.allowize!
+              rewritten_source.should == expected_source
+            end
+          end
+
+          context "when it is `subject.#{method}(:method).and_return(value)` form" do
+            let(:source) do
+              <<-END
+                it 'responds to #foo' do
+                  subject.#{method}(:foo).and_return(value)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'responds to #foo' do
+                  allow(subject).to receive(:foo).and_return(value)
+                end
+              END
+            end
+
+            it 'converts into `allow(subject).to receive(:method).and_return(value)` form' do
+              method_stub_object.allowize!
+              rewritten_source.should == expected_source
+            end
+          end
+
+          context "when it is `subject.#{method}(:method).and_raise(RuntimeError)` form" do
+            let(:source) do
+              <<-END
+                it 'responds to #foo' do
+                  subject.#{method}(:foo).and_raise(RuntimeError)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'responds to #foo' do
+                  allow(subject).to receive(:foo).and_raise(RuntimeError)
+                end
+              END
+            end
+
+            it 'converts into `allow(subject).to receive(:method).and_raise(RuntimeError)` form' do
+              method_stub_object.allowize!
+              rewritten_source.should == expected_source
+            end
+          end
+
+          context "when it's statement continues over multi lines" do
+            let(:source) do
+              <<-END
+                it 'responds to #foo' do
+                  subject.#{method}(
+                      :baz
+                    ).
+                    and_return(
+                      3
+                    )
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'responds to #foo' do
+                  allow(subject).to receive(
+                      :baz
+                    ).
+                    and_return(
+                      3
+                    )
+                end
+              END
+            end
+
+            it 'keeps the style as far as possible' do
+              method_stub_object.allowize!
+              rewritten_source.should == expected_source
+            end
+          end
+
+          context "when it is `subject.#{method}(:method => value)` form" do
+            let(:source) do
+              <<-END
+                it 'responds to #foo and returns 1' do
+                  subject.#{method}(:foo => 1)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'responds to #foo and returns 1' do
+                  allow(subject).to receive(:foo).and_return(1)
+                end
+              END
+            end
+
+            it 'converts into `allow(subject).to receive(:method).and_return(value)` form' do
+              method_stub_object.allowize!
+              rewritten_source.should == expected_source
+            end
+          end
+
+          context "when it is `subject.#{method}(method: value)` form" do
+            let(:source) do
+              <<-END
+                it 'responds to #foo and returns 1' do
+                  subject.#{method}(foo: 1)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'responds to #foo and returns 1' do
+                  allow(subject).to receive(:foo).and_return(1)
+                end
+              END
+            end
+
+            it 'converts into `allow(subject).to receive(:method).and_return(value)` form' do
+              method_stub_object.allowize!
+              rewritten_source.should == expected_source
+            end
+          end
+
+          context "when it is `subject.#{method}(:a_method => a_value, b_method => b_value)` form" do
+            let(:source) do
+              <<-END
+                it 'responds to #foo and returns 1' do
+                  subject.#{method}(:foo => 1, :bar => 2)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'responds to #foo and returns 1' do
+                  allow(subject).to receive(:foo).and_return(1)
+                  allow(subject).to receive(:bar).and_return(2)
+                end
+              END
+            end
+
+            it 'converts into `allow(subject).to receive(:a_method).and_return(a_value)` ' +
+               'and `allow(subject).to receive(:b_method).and_return(b_value)` form' do
+              method_stub_object.allowize!
+              rewritten_source.should == expected_source
+            end
+
+            context "when it's statement continues over multi lines" do
+              let(:source) do
+                <<-END
+                  it 'responds to #foo' do
+                    subject
+                      .#{method}(
+                        :foo => 1,
+                        :bar => 2
+                      )
+                  end
+                END
+              end
+
+              let(:expected_source) do
+                <<-END
+                  it 'responds to #foo' do
+                    allow(subject)
+                      .to receive(:foo).and_return(1)
+                    allow(subject)
+                      .to receive(:bar).and_return(2)
+                  end
+                END
+              end
+
+              it 'keeps the style except around the hash' do
+                method_stub_object.allowize!
+                rewritten_source.should == expected_source
+              end
+            end
+          end
+        end
+
+        [:unstub, :unstub!].each do |method|
+          context "when it is `subject.#{method}(:method)` form" do
+            let(:source) do
+              <<-END
+                it 'does not respond to #foo' do
+                  subject.#{method}(:foo)
+                end
+              END
+            end
+
+            it 'does nothing' do
+              method_stub_object.allowize!
+              rewritten_source.should == source
+            end
+          end
+        end
+
+        [:stub, :stub!].each do |method|
+          context "when it is `SomeClass.any_instance.#{method}(:method)` form" do
+            let(:source) do
+              <<-END
+                it 'responds to #foo' do
+                  SomeClass.any_instance.#{method}(:foo)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'responds to #foo' do
+                  allow_any_instance_of(SomeClass).to receive(:foo)
+                end
+              END
+            end
+
+            it 'converts into `allow_any_instance_of(SomeClass).to receive(:method)` form' do
+              method_stub_object.allowize!
+              rewritten_source.should == expected_source
+            end
+          end
+        end
+
+        [:unstub, :unstub!].each do |method|
+          context "when it is `SomeClass.any_instance.#{method}(:method)` form" do
+            let(:source) do
+              <<-END
+                it 'does not respond to #foo' do
+                  SomeClass.any_instance.#{method}(:foo)
+                end
+              END
+            end
+
+            it 'does nothing' do
+              method_stub_object.allowize!
+              rewritten_source.should == source
+            end
+          end
+        end
+
+        context 'when already replaced deprecated method' do
+          let(:source) do
+            <<-END
+              it 'responds to #foo' do
+                subject.stub!(:foo)
+              end
+            END
+          end
+
+          it 'raises error' do
+            method_stub_object.replace_deprecated_method!
+            -> { method_stub_object.allowize! }.should raise_error
+          end
+        end
+      end
+
+      describe '#replace_deprecated_method!' do
+        [
+          [:stub!,   :stub,   'responds to'],
+          [:unstub!, :unstub, 'does not respond to']
+        ].each do |method, replacement_method, description|
+          context "when it is ##{method}" do
+            let(:source) do
+              <<-END
+                it '#{description} #foo' do
+                  subject.#{method}(:foo)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it '#{description} #foo' do
+                  subject.#{replacement_method}(:foo)
+                end
+              END
+            end
+
+            it "replaces with ##{replacement_method}" do
+              method_stub_object.replace_deprecated_method!
+              rewritten_source.should == expected_source
+            end
+          end
+        end
+
+        [
+          [:stub,   'responds to'],
+          [:unstub, 'does not respond to']
+        ].each do |method, description|
+          context "when it is ##{method}" do
+            let(:source) do
+              <<-END
+                it '#{description} #foo' do
+                  subject.#{method}(:foo)
+                end
+              END
+            end
+
+            it 'does nothing' do
+              method_stub_object.replace_deprecated_method!
+              rewritten_source.should == source
+            end
+          end
+        end
+
+        context 'when already allowized' do
+          let(:source) do
+            <<-END
+              it 'responds to #foo' do
+                subject.stub!(:foo)
+              end
+            END
+          end
+
+          it 'raises error' do
+            method_stub_object.allowize!
+            -> { method_stub_object.replace_deprecated_method! }.should raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/transpec/syntax/should_receive_spec.rb

@@ -0,0 +1,286 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  class Syntax
+    describe ShouldReceive do
+      include_context 'parsed objects'
+
+      subject(:should_receive_object) do
+        AST::Scanner.scan(ast) do |node, ancestor_nodes, in_example_group_context|
+          next unless ShouldReceive.target_node?(node)
+          return ShouldReceive.new(
+            node,
+            ancestor_nodes,
+            in_example_group_context?,
+            source_rewriter
+          )
+        end
+        fail 'No should_receive node is found!'
+      end
+
+      let(:in_example_group_context?) { true }
+
+      describe '#expectize!' do
+        context 'when it is `subject.should_receive(:method)` form' do
+          let(:source) do
+            <<-END
+              it 'receives #foo' do
+                subject.should_receive(:foo)
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              it 'receives #foo' do
+                expect(subject).to receive(:foo)
+              end
+            END
+          end
+
+          it 'converts into `expect(subject).to receive(:method)` form' do
+            should_receive_object.expectize!
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context 'when it is `subject.should_not_receive(:method)` form' do
+          let(:source) do
+            <<-END
+              it 'does not receive #foo' do
+                subject.should_not_receive(:foo)
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              it 'does not receive #foo' do
+                expect(subject).not_to receive(:foo)
+              end
+            END
+          end
+
+          it 'converts into `expect(subject).not_to receive(:method)` form' do
+            should_receive_object.expectize!
+            rewritten_source.should == expected_source
+          end
+
+          context 'and "to_not" is passed as negative form' do
+            let(:expected_source) do
+            <<-END
+              it 'does not receive #foo' do
+                expect(subject).to_not receive(:foo)
+              end
+            END
+            end
+
+            it 'converts into `expect(subject).to_not receive(:method)` form' do
+              should_receive_object.expectize!('to_not')
+              rewritten_source.should == expected_source
+            end
+          end
+        end
+
+        # Currently MessageExpectation#with supports the following syntax:
+        #
+        #   subject.should_receive(:foo).with do |arg|
+        #     arg == 1
+        #   end
+        #
+        # This syntax allows to expect arbitrary arguments without expect or should.
+        # This is available only when #with got no normal arguments but a block,
+        # and the block will not be used as a substitute implementation.
+        #
+        # https://github.com/rspec/rspec-mocks/blob/e6d1980/lib/rspec/mocks/message_expectation.rb#L307
+        # https://github.com/rspec/rspec-mocks/blob/e6d1980/lib/rspec/mocks/argument_list_matcher.rb#L43
+        #
+        # Then, if you convert the example into expect syntax straightforward:
+        #
+        #   expect(subject).to receive(:foo).with do |arg|
+        #     arg == 1
+        #   end
+        #
+        # The do..end block is taken by the #to method, because {..} blocks have higher precedence
+        # over do..end blocks. This behavior breaks the spec.
+        #
+        # To keep the same meaning of syntax, the block needs to be {..} form literal:
+        #
+        #   expect(subject).to receive(:foo).with { |arg|
+        #     arg == 1
+        #   }
+        #
+        context 'when it is `subject.should_receive(:method).with do..end` form' do
+          let(:source) do
+            <<-END
+              it 'receives #foo with 1' do
+                subject.should_receive(:foo).with do |arg|
+                  arg == 1
+                end
+                subject.foo(1)
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              it 'receives #foo with 1' do
+                expect(subject).to receive(:foo).with { |arg|
+                  arg == 1
+                }
+                subject.foo(1)
+              end
+            END
+          end
+
+          it 'converts into `expect(subject).to receive(:method) { .. }` form' do
+            should_receive_object.expectize!
+            rewritten_source.should == expected_source
+          end
+        end
+
+        # If #with take normal arguments, the block won't be used as an argument matcher.
+        context 'when it is `subject.should_receive(:method).with(:arg) do..end` form' do
+          let(:source) do
+            <<-END
+              it 'receives #foo with 1' do
+                subject.should_receive(:foo).with(:bar) do |arg|
+                  do_some_substitute_implementation
+                end
+                subject.foo(1)
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              it 'receives #foo with 1' do
+                expect(subject).to receive(:foo).with(:bar) do |arg|
+                  do_some_substitute_implementation
+                end
+                subject.foo(1)
+              end
+            END
+          end
+
+          it 'converts into `expect(subject).to receive(:method) { .. }` form' do
+            should_receive_object.expectize!
+            rewritten_source.should == expected_source
+          end
+        end
+
+        # In this case, the do..end block is taken by the #should_receive method.
+        # This means the receiver of #once method is return value of #should_receive,
+        # that is actually an instance of RSpec::Mocks::MessageExpectation.
+        #
+        #   subject.should_receive(:foo) do |arg|
+        #     arg == 1
+        #   end.once
+        #
+        # However with `expect(subject).to receive`, the do..end block is taken by the #to method.
+        # This means the receiver of #once method is return value of #to, that is actually
+        # return value of RSpec::Mocks::Matchers::Receive#setup_method_substitute
+        # and it's not the instance of RSpec::Mocks::MessageExpectation.
+        #
+        # https://github.com/rspec/rspec-mocks/blob/9cdef17/lib/rspec/mocks/targets.rb#L19
+        # https://github.com/rspec/rspec-mocks/blob/9cdef17/lib/rspec/mocks/matchers/receive.rb#L74
+        #
+        # Then, the following syntax will be error:
+        #
+        #   expect(subject).to receive(:foo) do |arg|
+        #     arg == 1
+        #   end.once
+        #
+        # So the block needs to be {..} form literal also in this case.
+        #
+        #   expect(subject).to receive(:foo) { |arg|
+        #     arg == 1
+        #   }.once
+        #
+        context 'when it is `subject.should_receive(:method) do..end.once` form' do
+          let(:source) do
+            <<-END
+              it 'receives #foo with 1' do
+                subject.should_receive(:foo) do |arg|
+                  arg == 1
+                end.once
+                subject.foo(1)
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              it 'receives #foo with 1' do
+                expect(subject).to receive(:foo) { |arg|
+                  arg == 1
+                }.once
+                subject.foo(1)
+              end
+            END
+          end
+
+          it 'converts into `expect(subject).to receive(:method) { .. }.once` form' do
+            should_receive_object.expectize!
+            rewritten_source.should == expected_source
+          end
+        end
+
+        # This case, do..end block works without problem.
+        context 'when it is `subject.should_receive(:method) do..end` form' do
+          let(:source) do
+            <<-END
+              it 'receives #foo with 1' do
+                subject.should_receive(:foo) do |arg|
+                  expect(arg).to eq(1)
+                end
+                subject.foo(1)
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              it 'receives #foo with 1' do
+                expect(subject).to receive(:foo) do |arg|
+                  expect(arg).to eq(1)
+                end
+                subject.foo(1)
+              end
+            END
+          end
+
+          it 'converts into `expect(subject).to receive(:method) do..end` form' do
+            should_receive_object.expectize!
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context 'when it is `SomeClass.any_instance.should_receive(:method)` form' do
+          let(:source) do
+            <<-END
+              it 'receives #foo' do
+                SomeClass.any_instance.should_receive(:foo)
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              it 'receives #foo' do
+                expect_any_instance_of(SomeClass).to receive(:foo)
+              end
+            END
+          end
+
+          it 'converts into `expect_any_instance_of(SomeClass).to receive(:method)` form' do
+            should_receive_object.expectize!
+            rewritten_source.should == expected_source
+          end
+        end
+      end
+    end
+  end
+end