transpec 3.0.0 → 3.0.1

data/spec/transpec/syntax/allow_spec.rb

@@ -1,122 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/syntax/allow'
-
-module Transpec
-  class Syntax
-    describe Allow do
-      include_context 'parsed objects'
-      include_context 'syntax object', Allow, :allow_object
-
-      describe '#subject_node' do
-        let(:source) do
-          <<-END
-            describe 'example' do
-              it 'is empty' do
-                allow(subject).to be_empty
-              end
-            end
-          END
-        end
-
-        it 'returns subject node' do
-          method_name = allow_object.subject_node.children[1]
-          method_name.should == :subject
-        end
-      end
-
-      describe '#matcher_node' do
-        context 'when the matcher is taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is empty' do
-                  allow(subject).to receive(:foo) { }
-                end
-              end
-            END
-          end
-
-          it 'returns send node of the matcher' do
-            method_name = allow_object.matcher_node.children[1]
-            method_name.should == :receive
-          end
-        end
-
-        context 'when the matcher is not taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is empty' do
-                  allow(subject).to be_empty
-                end
-              end
-            END
-          end
-
-          it 'returns send node of the matcher' do
-            method_name = allow_object.matcher_node.children[1]
-            method_name.should == :be_empty
-          end
-        end
-      end
-
-      describe '#receive_matcher' do
-        subject { allow_object.receive_matcher }
-
-        let(:source) do
-          <<-END
-            describe 'example' do
-              it 'receives :foo' do
-                allow(subject).to receive(:foo)
-              end
-            end
-          END
-        end
-
-        it 'returns an instance of Receive' do
-          should be_an(Receive)
-        end
-      end
-
-      describe '#block_node' do
-        subject { allow_object.block_node }
-
-        context 'when the #to is taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'receives :foo' do
-                  allow(subject).to receive(:foo) do |arg|
-                  end
-                end
-              end
-            END
-          end
-
-          it 'returns the block node' do
-            should be_block_type
-          end
-        end
-
-        context 'when the #to is not taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'receives :foo' do
-                  allow(subject).to receive(:foo) { |arg|
-                  }
-                end
-              end
-            END
-          end
-
-          it 'returns nil' do
-            should be_nil
-          end
-        end
-      end
-    end
-  end
-end

data/spec/transpec/syntax/be_boolean_spec.rb

@@ -1,176 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/syntax/be_boolean'
-
-module Transpec
-  class Syntax
-    describe BeBoolean do
-      include_context 'parsed objects'
-      include_context 'syntax object', BeBoolean, :be_boolean_object
-
-      let(:record) { be_boolean_object.report.records.last }
-
-      describe '#convert_to_conditional_matcher!' do
-        before do
-          be_boolean_object.convert_to_conditional_matcher!(arg)
-        end
-
-        let(:arg) { 'be_falsey' }
-
-        context 'with expression `be_true`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is truthy' do
-                  1.should be_true
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is truthy' do
-                  1.should be_truthy
-                end
-              end
-            END
-          end
-
-          it 'converts to `be_truthy`' do
-            rewritten_source.should == expected_source
-          end
-
-          it 'adds record `be_true` -> `be_truthy`' do
-            record.old_syntax.should == 'be_true'
-            record.new_syntax.should == 'be_truthy'
-          end
-        end
-
-        context 'with expression `be_false`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is falsey' do
-                  nil.should be_false
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is falsey' do
-                  nil.should be_falsey
-                end
-              end
-            END
-          end
-
-          it 'converts to `be_falsey`' do
-            rewritten_source.should == expected_source
-          end
-
-          it 'adds record `be_false` -> `be_falsey`' do
-            record.old_syntax.should == 'be_false'
-            record.new_syntax.should == 'be_falsey'
-          end
-
-          context 'and "be_falsy" is passed' do
-            let(:arg) { 'be_falsy' }
-
-            let(:expected_source) do
-              <<-END
-              describe 'example' do
-                it 'is falsey' do
-                  nil.should be_falsy
-                end
-              end
-              END
-            end
-
-            it 'converts to `be_falsy`' do
-              rewritten_source.should == expected_source
-            end
-
-            it 'adds record `be_false` -> `be_falsy`' do
-              record.old_syntax.should == 'be_false'
-              record.new_syntax.should == 'be_falsy'
-            end
-          end
-        end
-      end
-
-      describe '#convert_to_exact_matcher!' do
-        before do
-          be_boolean_object.convert_to_exact_matcher!
-        end
-
-        context 'with expression `be_true`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is true' do
-                  true.should be_true
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is true' do
-                  true.should be true
-                end
-              end
-            END
-          end
-
-          it 'converts to `be true`' do
-            rewritten_source.should == expected_source
-          end
-
-          it 'adds record `be_true` -> `be true`' do
-            record.old_syntax.should == 'be_true'
-            record.new_syntax.should == 'be true'
-          end
-        end
-
-        context 'with expression `be_false`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is false' do
-                  false.should be_false
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is false' do
-                  false.should be false
-                end
-              end
-            END
-          end
-
-          it 'converts to `be false`' do
-            rewritten_source.should == expected_source
-          end
-
-          it 'adds record `be_false` -> `be false`' do
-            record.old_syntax.should == 'be_false'
-            record.new_syntax.should == 'be false'
-          end
-        end
-      end
-    end
-  end
-end

data/spec/transpec/syntax/be_close_spec.rb

@@ -1,51 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/syntax/be_close'
-
-module Transpec
-  class Syntax
-    describe BeClose do
-      include_context 'parsed objects'
-      include_context 'syntax object', BeClose, :be_close_object
-
-      describe '#convert_to_be_within!' do
-        before do
-          be_close_object.convert_to_be_within!
-        end
-
-        context 'with expression `be_close(expected, delta)`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is close to 0.333' do
-                  (1.0 / 3.0).should be_close(0.333, 0.001)
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is close to 0.333' do
-                  (1.0 / 3.0).should be_within(0.001).of(0.333)
-                end
-              end
-            END
-          end
-
-          it 'converts to `be_within(delta).of(expected)` form' do
-            rewritten_source.should == expected_source
-          end
-
-          it 'adds record `be_close(expected, delta)` -> `be_within(delta).of(expected)`' do
-            record = be_close_object.report.records.first
-            record.old_syntax.should == 'be_close(expected, delta)'
-            record.new_syntax.should == 'be_within(delta).of(expected)'
-          end
-        end
-      end
-    end
-  end
-end

data/spec/transpec/syntax/current_example_spec.rb

@@ -1,319 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/syntax/current_example'
-
-module Transpec
-  class Syntax
-    describe CurrentExample do
-      include_context 'parsed objects'
-      include_context 'syntax object', CurrentExample, :current_example_object
-
-      let(:record) { current_example_object.report.records.last }
-
-      describe '#conversion_target?' do
-        let(:target_node) do
-          ast.each_node(:send).find do |send_node|
-            method_name = send_node.children[1]
-            method_name == :example
-          end
-        end
-
-        let(:current_example_object) do
-          CurrentExample.new(target_node, runtime_data)
-        end
-
-        subject { current_example_object.conversion_target? }
-
-        context 'with #example node that returns current example object' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                after do
-                  do_something if example.metadata[:foo]
-                end
-              end
-            END
-          end
-
-          it { should be_true }
-        end
-
-        context 'when #example node that defines a spec example is passed' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                example 'it does something' do
-                  do_something
-                end
-              end
-            END
-          end
-
-          it { should be_false }
-        end
-
-        context 'when #example node defined with #let by user is passed' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                let(:example) { 'This is not current example object' }
-
-                it 'does something' do
-                  example
-                end
-              end
-            END
-          end
-
-          it 'unfortunately returns true ' \
-             "since it's impossible to differentiate them without runtime information" do
-            should be_true
-          end
-
-          context 'with runtime information' do
-            include_context 'dynamic analysis objects'
-
-            it 'returns false properly' do
-              should be_false
-            end
-          end
-        end
-      end
-
-      describe '#convert!' do
-        before do
-          current_example_object.convert! unless example.metadata[:no_auto_convert]
-        end
-
-        (RSpecDSL::EXAMPLE_METHODS + RSpecDSL::HOOK_METHODS).each do |method|
-          context "with expression `#{method} do example end`" do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  #{method} do
-                    do_something if example.metadata[:foo]
-                  end
-                end
-              END
-            end
-
-            let(:expected_source) do
-              <<-END
-                describe 'example' do
-                  #{method} do |example|
-                    do_something if example.metadata[:foo]
-                  end
-                end
-              END
-            end
-
-            it "converts to `#{method} do |example| example end` form" do
-              rewritten_source.should == expected_source
-            end
-
-            it "adds record `#{method} { example }` -> `#{method} { |example| example }`" do
-              record.old_syntax.should == "#{method} { example }"
-              record.new_syntax.should == "#{method} { |example| example }"
-            end
-          end
-        end
-
-        RSpecDSL::HELPER_METHODS.each do |method|
-          context "with expression `#{method}(:name) do example end`" do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  #{method}(:name) do
-                    do_something if example.metadata[:foo]
-                  end
-                end
-              END
-            end
-
-            let(:expected_source) do
-              <<-END
-                describe 'example' do
-                  #{method}(:name) do |example|
-                    do_something if example.metadata[:foo]
-                  end
-                end
-              END
-            end
-
-            it "converts to `#{method}(:name) do |example| example end` form" do
-              rewritten_source.should == expected_source
-            end
-
-            it "adds record `#{method}(:name) { example }` -> `#{method}(:name) { |example| example }`" do
-              record.old_syntax.should == "#{method}(:name) { example }"
-              record.new_syntax.should == "#{method}(:name) { |example| example }"
-            end
-          end
-        end
-
-        context 'with expression `after { example }`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                after {
-                  do_something if example.metadata[:foo]
-                }
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                after { |example|
-                  do_something if example.metadata[:foo]
-                }
-              end
-            END
-          end
-
-          it 'converts to `after { |example| example }` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-
-        context 'with expression `after do running_example end`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                after do
-                  do_something if running_example.metadata[:foo]
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                after do |example|
-                  do_something if example.metadata[:foo]
-                end
-              end
-            END
-          end
-
-          it 'converts to `after do |example| example end` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-
-        context 'when the wrapper block contains multiple invocation of `example`', :no_auto_convert do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                after do
-                  do_something if example.metadata[:foo]
-                  puts example.description
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                after do |example|
-                  do_something if example.metadata[:foo]
-                  puts example.description
-                end
-              end
-            END
-          end
-
-          let(:current_example_objects) do
-            ast.each_node.each_with_object([]) do |node, objects|
-              current_example_object = CurrentExample.new(node, runtime_data, project, source_rewriter)
-              objects << current_example_object if current_example_object.conversion_target?
-            end
-          end
-
-          it 'adds only a block argument' do
-            current_example_objects.size.should eq(2)
-            current_example_objects.each(&:convert!)
-            rewritten_source.should == expected_source
-          end
-        end
-
-        context 'with expression `around do |ex| example end`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                around do |ex|
-                  do_something if example.metadata[:foo]
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                around do |ex|
-                  do_something if ex.metadata[:foo]
-                end
-              end
-            END
-          end
-
-          it 'converts to `around do |ex| ex end` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-
-        context 'with expression `def helper_method example; end`' do
-          let(:source) do
-            <<-END
-              module Helper
-                def display_description
-                  puts example.description
-                end
-              end
-
-              describe 'example' do
-                include Helper
-
-                after do
-                  display_description
-                end
-              end
-            END
-          end
-
-          let(:expected_source) do
-            <<-END
-              module Helper
-                def display_description
-                  puts RSpec.current_example.description
-                end
-              end
-
-              describe 'example' do
-                include Helper
-
-                after do
-                  display_description
-                end
-              end
-            END
-          end
-
-          it 'converts to `def helper_method RSpec.current_example; end` form' do
-            rewritten_source.should == expected_source
-          end
-
-          it 'adds record `def helper_method example; end` -> `def helper_method RSpec.current_example; end`' do
-            record.old_syntax.should == 'def helper_method example; end'
-            record.new_syntax.should == 'def helper_method RSpec.current_example; end'
-          end
-        end
-      end
-    end
-  end
-end