transpec 1.9.3 → 1.10.0

data/spec/transpec/syntax/have_spec.rb

@@ -319,39 +319,8 @@ module Transpec
         end
 
         context 'when it is `expect(collection).to have(2).items` form' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'has 2 items' do
-                  expect(collection).to have(2).items
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'has 2 items' do
-                  expect(collection.size).to eq(2)
-                end
-              end
-            END
-          end
-
           let(:have_object) { expect_object.have_matcher }
 
-          it 'converts into `expect(collection.size).to eq(2)` form' do
-            have_object.convert_to_standard_expectation!
-            rewritten_source.should == expected_source
-          end
-
-          it 'adds record `expect(collection).to have(n).items` -> `expect(collection.size).to eq(n)`' do
-            have_object.convert_to_standard_expectation!
-            record.original_syntax.should  == 'expect(collection).to have(n).items'
-            record.converted_syntax.should == 'expect(collection.size).to eq(n)'
-          end
-
           context 'with runtime information' do
             include_context 'dynamic analysis objects'
 
@@ -393,13 +362,55 @@ module Transpec
                 rewritten_source.should == expected_source
               end
 
-              it 'adds record `expect(collection).to have(n).items` -> `expect(collection.size).to eq(n)`' do
+              it 'adds record `expect(collection).to have(n).items` -> `expect(collection.size).to eq(n)` ' \
+                 'without annotation' do
                 have_object.convert_to_standard_expectation!
                 record.original_syntax.should  == 'expect(collection).to have(n).items'
                 record.converted_syntax.should == 'expect(collection.size).to eq(n)'
+                record.annotation.should be_nil
               end
             end
           end
+
+          context 'without runtime information' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'has 2 items' do
+                    expect(collection).to have(2).items
+                  end
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                describe 'example' do
+                  it 'has 2 items' do
+                    expect(collection.size).to eq(2)
+                  end
+                end
+              END
+            end
+
+            it 'converts into `expect(collection.size).to eq(2)` form' do
+              have_object.convert_to_standard_expectation!
+              rewritten_source.should == expected_source
+            end
+
+            it 'adds record `expect(collection).to have(n).items` -> `expect(collection.size).to eq(n)` ' \
+               'with annotation' do
+              have_object.convert_to_standard_expectation!
+
+              record.original_syntax.should  == 'expect(collection).to have(n).items'
+              record.converted_syntax.should == 'expect(collection.size).to eq(n)'
+
+              record.annotation.message.should ==
+                'The `have(2).items` has been converted but it might possibly be incorrect ' \
+                "due to a lack of runtime information. It's recommended to review the change carefully."
+              record.annotation.source_range.source.should == 'have(2).items'
+            end
+          end
         end
 
         context 'when it is `expect(collection).not_to have(2).items` form' do

data/spec/transpec/syntax/method_stub_spec.rb

@@ -220,6 +220,14 @@ module Transpec
             record.converted_syntax.should == 'allow(obj).to receive(:message)'
           end
 
+          context 'with runtime information' do
+            include_context 'dynamic analysis objects'
+
+            it 'converts into `allow(subject).to receive(:method)` form' do
+              rewritten_source.should == expected_source
+            end
+          end
+
           context 'and #allow and #receive are not available in the context', :no_before_allowize! do
             context 'and the context is determinable statically' do
               let(:source) do

data/spec/transpec/syntax/operator_spec.rb

@@ -65,6 +65,7 @@ module Transpec
           it 'adds record `== expected` -> `eq(expected)`' do
             record.original_syntax.should == '== expected'
             record.converted_syntax.should == 'eq(expected)'
+            record.annotation.should be_nil
           end
 
           # Operator methods allow their argument to be in the next line,
@@ -185,6 +186,7 @@ module Transpec
           it 'adds record `== expected` -> `eq(expected)`' do
             record.original_syntax.should == '== expected'
             record.converted_syntax.should == 'eq(expected)'
+            record.annotation.should be_nil
           end
         end
 
@@ -335,6 +337,7 @@ module Transpec
             it "adds record `#{operator} expected` -> `be #{operator} expected`" do
               record.original_syntax.should == "#{operator} expected"
               record.converted_syntax.should == "be #{operator} expected"
+              record.annotation.should be_nil
             end
           end
 
@@ -384,9 +387,10 @@ module Transpec
             rewritten_source.should == expected_source
           end
 
-          it 'adds record `=~ /pattern/` -> `match(/pattern/)`' do
+          it 'adds record `=~ /pattern/` -> `match(/pattern/)` without annotation' do
             record.original_syntax.should == '=~ /pattern/'
             record.converted_syntax.should == 'match(/pattern/)'
+            record.annotation.should be_nil
           end
         end
 
@@ -467,9 +471,10 @@ module Transpec
             rewritten_source.should == expected_source
           end
 
-          it 'adds record `=~ [1, 2]` -> `match_array([1, 2])`' do
+          it 'adds record `=~ [1, 2]` -> `match_array([1, 2])` without annotation' do
             record.original_syntax.should == '=~ [1, 2]'
             record.converted_syntax.should == 'match_array([1, 2])'
+            record.annotation.should be_nil
           end
         end
 
@@ -554,6 +559,12 @@ module Transpec
             it 'converts into `match_array(variable)` form' do
               rewritten_source.should == expected_source
             end
+
+            it 'adds record `=~ [1, 2]` -> `match_array([1, 2])` without annotation' do
+              record.original_syntax.should == '=~ [1, 2]'
+              record.converted_syntax.should == 'match_array([1, 2])'
+              record.annotation.should be_nil
+            end
           end
 
           context 'and runtime type of the variable is regular expression' do
@@ -584,6 +595,12 @@ module Transpec
             it 'converts into `match(variable)` form' do
               rewritten_source.should == expected_source
             end
+
+            it 'adds record `=~ /pattern/` -> `match(/pattern/)` without annotation' do
+              record.original_syntax.should == '=~ /pattern/'
+              record.converted_syntax.should == 'match(/pattern/)'
+              record.annotation.should be_nil
+            end
           end
 
           context 'and no runtime type information is provided' do
@@ -610,6 +627,54 @@ module Transpec
             it 'converts into `match(variable)` form' do
               rewritten_source.should == expected_source
             end
+
+            it 'adds record `=~ /pattern/` -> `match(/pattern/)` with annotation' do
+              record.original_syntax.should == '=~ /pattern/'
+              record.converted_syntax.should == 'match(/pattern/)'
+
+              record.annotation.message.should ==
+                'The `=~ variable` has been converted but it might possibly be incorrect ' \
+                "due to a lack of runtime information. It's recommended to review the change carefully."
+              record.annotation.source_range.source.should == '=~ variable'
+            end
+          end
+        end
+
+        context 'when it is `be =~ variable` form' do
+          context 'and no runtime type information is provided' do
+            let(:source) do
+              <<-END
+                describe 'example' do
+                  it 'matches the pattern' do
+                    subject.should be =~ variable
+                  end
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                describe 'example' do
+                  it 'matches the pattern' do
+                    subject.should match(variable)
+                  end
+                end
+              END
+            end
+
+            it 'converts into `match(variable)` form' do
+              rewritten_source.should == expected_source
+            end
+
+            it 'adds record `=~ /pattern/` -> `match(/pattern/)` with annotation' do
+              record.original_syntax.should == '=~ /pattern/'
+              record.converted_syntax.should == 'match(/pattern/)'
+
+              record.annotation.message.should ==
+                'The `be =~ variable` has been converted but it might possibly be incorrect ' \
+                "due to a lack of runtime information. It's recommended to review the change carefully."
+              record.annotation.source_range.source.should == 'be =~ variable'
+            end
           end
         end
       end

data/spec/transpec/syntax/pending_spec.rb

@@ -0,0 +1,375 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'transpec/syntax/pending'
+
+module Transpec
+  class Syntax
+    describe Pending do
+      include_context 'parsed objects'
+      include_context 'syntax object', Pending, :pending_object
+
+      let(:record) { pending_object.report.records.last }
+
+      describe '.conversion_target_node?' do
+        subject { Pending.conversion_target_node?(pending_node, runtime_data) }
+
+        let(:pending_node) do
+          ast.each_descendent_node do |node|
+            next unless node.send_type?
+            method_name = node.children[1]
+            return node if method_name == :pending
+          end
+          fail 'No #pending node is found!'
+        end
+
+        context 'when #pending specification node inside of an example is passed' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'will be skipped' do
+                  pending
+                end
+              end
+            END
+          end
+
+          context 'without runtime information' do
+            it { should be_true }
+          end
+
+          context 'with runtime information' do
+            include_context 'dynamic analysis objects'
+            it { should be_true }
+          end
+        end
+
+        context 'when #pending example node is passed' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                pending 'will be skipped' do
+                end
+              end
+            END
+          end
+
+          context 'without runtime information' do
+            it { should be_false }
+          end
+
+          context 'with runtime information' do
+            include_context 'dynamic analysis objects'
+            it { should be_false }
+          end
+        end
+      end
+
+      describe '#convert_deprecated_syntax!' do
+        before do
+          pending_object.convert_deprecated_syntax!
+        end
+
+        context 'when it is `pending` form' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'will be skipped' do
+                  pending
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'will be skipped' do
+                  skip
+                end
+              end
+            END
+          end
+
+          it 'converts into `skip` form' do
+            rewritten_source.should == expected_source
+          end
+
+          it 'adds record `pending` -> `skip`' do
+            record.original_syntax.should  == 'pending'
+            record.converted_syntax.should == 'skip'
+          end
+        end
+
+        context "when it is `pending 'some reason'` form" do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'will be skipped' do
+                  pending 'some reason'
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'will be skipped' do
+                  skip 'some reason'
+                end
+              end
+            END
+          end
+
+          it "converts into `skip 'some reason` form" do
+            rewritten_source.should == expected_source
+          end
+
+          it 'adds record `pending` -> `skip`' do
+            record.original_syntax.should  == 'pending'
+            record.converted_syntax.should == 'skip'
+          end
+        end
+
+        context 'when it is singleline `pending { do_something_fail }` form' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending { do_something_fail }
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending
+                  do_something_fail
+                end
+              end
+            END
+          end
+
+          it 'converts into `pending; do_something_fail` form' do
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context "when it is singleline `pending('some reason') { do_something_fail }` form" do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending('some reason') { do_something_fail }
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending('some reason')
+                  do_something_fail
+                end
+              end
+            END
+          end
+
+          it "converts into `pending('some reason'); do_something_fail` form" do
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context 'when it is multiline `pending { do_something_fail }` form' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending do
+                    do_something_first
+                    do_something_fail
+                  end
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending
+                  do_something_first
+                  do_something_fail
+                end
+              end
+            END
+          end
+
+          it 'converts into `pending; do_something_fail` form' do
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context "when it is multiline `pending('some reason') { do_something_fail }` form" do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending('some reason') do
+                    do_something_first
+                    do_something_fail
+                  end
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending('some reason')
+                  do_something_first
+                  do_something_fail
+                end
+              end
+            END
+          end
+
+          it "converts into `pending('some reason'); do_something_fail` form" do
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context 'when it is multiline `pending { do_something_fail }` form ' \
+                'but the body is not indented' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending do
+                  do_something_first
+                  do_something_fail
+                  end
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending
+                  do_something_first
+                  do_something_fail
+                end
+              end
+            END
+          end
+
+          it 'converts into `pending; do_something_fail` form' do
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context 'when it is multiline `pending { do_something_fail }` form ' \
+                'but the body is outdented' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending do
+                do_something_first
+                do_something_fail
+                  end
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending
+                do_something_first
+                do_something_fail
+                end
+              end
+            END
+          end
+
+          it 'converts into `pending; do_something_fail` form' do
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context 'when it is multiline `pending { do_something_fail }` form ' \
+                'but anomalistically the beginning and the body of block are same line' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending do do_something_fail
+                  end
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending
+                  do_something_fail
+                end
+              end
+            END
+          end
+
+          it 'converts into `pending; do_something_fail` form' do
+            rewritten_source.should == expected_source
+          end
+        end
+
+        context 'when it is multiline `pending { do_something_fail }` form ' \
+                'but anomalistically the body and the end of block are same line' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending do
+                    do_something_fail end
+                end
+              end
+            END
+          end
+
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'is expected to fail' do
+                  pending
+                  do_something_fail
+                end
+              end
+            END
+          end
+
+          it 'converts into `pending; do_something_fail` form' do
+            rewritten_source.should == expected_source
+          end
+        end
+      end
+    end
+  end
+end