transpec 0.0.1

data/spec/transpec/git_spec.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  describe Git do
+    include_context 'isolated environment'
+
+    describe '.command_available?' do
+      subject { Git.command_available? }
+
+      context 'when git command is found in PATH' do
+        it { should be_true }
+      end
+
+      context 'when git command is not found in PATH' do
+        before { stub_const('Transpec::Git::GIT', 'non-existent-command') }
+        it { should be_false }
+      end
+    end
+
+    shared_context 'inside of git repository' do
+      around do |example|
+        Dir.mkdir('repo')
+        Dir.chdir('repo') do
+          `git init`
+          example.run
+        end
+      end
+    end
+
+    describe '.inside_of_repository?' do
+      subject { Git.inside_of_repository? }
+
+      context 'when the current directory is inside of git repository' do
+        include_context 'inside of git repository'
+        it { should be_true }
+      end
+
+      context 'when the current directory is not inside of git repository' do
+        it { should be_false }
+      end
+    end
+
+    describe '.clean?' do
+      include_context 'inside of git repository'
+
+      subject { Git.clean? }
+
+      before do
+        File.write('foo', 'This is a sample file')
+        `git add .`
+        `git commit -m 'Initial commit'`
+      end
+
+      context 'when there are no changes' do
+        it { should be_true }
+      end
+
+      context 'when there is an untracked file' do
+        before { File.write('bar', 'This is an untracked file') }
+        it { should be_false }
+      end
+
+      context 'when there is a deleted file' do
+        before { File.delete('foo') }
+        it { should be_false }
+      end
+
+      context 'when there is a not staged change' do
+        before { File.write('foo', 'This is modified content') }
+        it { should be_false }
+      end
+
+      context 'when there is a staged change' do
+        before do
+          File.write('foo', 'This is modified content')
+          `git add .`
+        end
+
+        it { should be_false }
+      end
+    end
+  end
+end

data/spec/transpec/rewriter_spec.rb

@@ -0,0 +1,203 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  describe Rewriter do
+    subject(:rewriter) { Rewriter.new(configuration) }
+    let(:configuration) { Configuration.new }
+
+    describe '#rewrite_file!' do
+      include_context 'isolated environment'
+
+      let(:file_path) { 'sample_spec.rb' }
+
+      before do
+        File.write(file_path, 'This is a spec')
+        rewriter.stub(:rewrite).and_return('This is the rewritten spec')
+      end
+
+      it 'overwrites the passed file path' do
+        rewriter.rewrite_file!(file_path)
+        File.read(file_path).should == 'This is the rewritten spec'
+      end
+    end
+
+    describe '#rewrite' do
+      subject { rewriter.rewrite(source) }
+
+      let(:source) do
+        <<-END
+          describe 'example group' do
+            it 'is an example' do
+              something = mock('something')
+              something.stub!(:message)
+              something.should_receive(:message)
+              something.should_not == 'foo'
+            end
+          end
+        END
+      end
+
+      context 'when the configuration #convert_to_expect_to_matcher? is true' do
+        before { configuration.convert_to_expect_to_matcher = true }
+
+        context 'and configuration #negative_form_of_to is "not_to"' do
+          before { configuration.negative_form_of_to = 'not_to' }
+
+          it 'invokes Should#expectize! with "not_to"' do
+            Syntax::Should.any_instance.should_receive(:expectize!).with('not_to', anything)
+            rewriter.rewrite(source)
+          end
+        end
+
+        context 'and configuration #negative_form_of_to is "to_not"' do
+          before { configuration.negative_form_of_to = 'to_not' }
+
+          it 'invokes Should#expectize! with "to_not"' do
+            Syntax::Should.any_instance.should_receive(:expectize!).with('to_not', anything)
+            rewriter.rewrite(source)
+          end
+        end
+
+        context 'and configuration #parenthesize_matcher_arg is true' do
+          before { configuration.parenthesize_matcher_arg = true }
+
+          it 'invokes Should#expectize! with true as second argument' do
+            Syntax::Should.any_instance.should_receive(:expectize!).with(anything, true)
+            rewriter.rewrite(source)
+          end
+        end
+
+        context 'and configuration #parenthesize_matcher_arg is false' do
+          before { configuration.parenthesize_matcher_arg = false }
+
+          it 'invokes Should#expectize! with false as second argument' do
+            Syntax::Should.any_instance.should_receive(:expectize!).with(anything, false)
+            rewriter.rewrite(source)
+          end
+        end
+      end
+
+      context 'when the configuration #convert_to_expect_to_matcher? is false' do
+        before { configuration.convert_to_expect_to_matcher = false }
+
+        it 'does not invoke Should#expectize!' do
+          Syntax::Should.any_instance.should_not_receive(:expectize!)
+          rewriter.rewrite(source)
+        end
+      end
+
+      context 'when the configuration #convert_to_expect_to_receive? is true' do
+        before { configuration.convert_to_expect_to_receive = true }
+
+        context 'and configuration #negative_form_of_to is "not_to"' do
+          before { configuration.negative_form_of_to = 'not_to' }
+
+          it 'invokes ShouldReceive#expectize! with "not_to"' do
+            Syntax::ShouldReceive.any_instance.should_receive(:expectize!).with('not_to')
+            rewriter.rewrite(source)
+          end
+        end
+
+        context 'and configuration #negative_form_of_to is "to_not"' do
+          before { configuration.negative_form_of_to = 'to_not' }
+
+          it 'invokes ShouldReceive#expectize! with "to_not"' do
+            Syntax::ShouldReceive.any_instance.should_receive(:expectize!).with('to_not')
+            rewriter.rewrite(source)
+          end
+        end
+      end
+
+      context 'when the configuration #convert_to_expect_to_receive? is false' do
+        before { configuration.convert_to_expect_to_receive = false }
+
+        it 'does not invoke ShouldReceive#expectize!' do
+          Syntax::ShouldReceive.any_instance.should_not_receive(:expectize!)
+          rewriter.rewrite(source)
+        end
+      end
+
+      context 'when the configuration #convert_to_allow_to_receive? is true' do
+        before { configuration.convert_to_allow_to_receive = true }
+
+        it 'invokes MethodStub#allowize!' do
+          Syntax::MethodStub.any_instance.should_receive(:allowize!)
+          rewriter.rewrite(source)
+        end
+      end
+
+      context 'when the configuration #convert_to_allow_to_receive? is false' do
+        before { configuration.convert_to_allow_to_receive = false }
+
+        it 'does not invoke MethodStub#allowize!' do
+          Syntax::MethodStub.any_instance.should_not_receive(:allowize!)
+          rewriter.rewrite(source)
+        end
+      end
+
+      context 'when the source have overlapped rewrite targets' do
+        let(:source) do
+          <<-END
+            describe 'example group' do
+              it 'is an example' do
+                object.stub(:message => mock('something'))
+              end
+            end
+          END
+        end
+
+        let(:expected_source) do
+          <<-END
+            describe 'example group' do
+              it 'is an example' do
+                allow(object).to receive(:message).and_return(double('something'))
+              end
+            end
+          END
+        end
+
+        it 'rewrites all targets properly' do
+          should == expected_source
+        end
+      end
+
+      context 'when the source have a monkey-patched expectation outside of example group context' do
+        before do
+          configuration.convert_to_expect_to_matcher = true
+          rewriter.stub(:warn)
+        end
+
+        let(:source) do
+          <<-END
+            describe 'example group' do
+              class SomeClass
+                def some_method
+                  1.should == 1
+                end
+              end
+
+              it 'is an example' do
+                SomeClass.new.some_method
+              end
+            end
+          END
+        end
+
+        it 'does not rewrite the expectation to non-monkey-patch syntax' do
+          should == source
+        end
+
+        it 'warns to user' do
+          rewriter.should_receive(:warn) do |message|
+            message.should =~ /cannot/i
+            message.should =~ /context/i
+          end
+
+          rewriter.rewrite(source)
+        end
+      end
+    end
+  end
+end

data/spec/transpec/syntax/double_spec.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  class Syntax
+    describe Double do
+      include_context 'parsed objects'
+
+      subject(:double_object) do
+        AST::Scanner.scan(ast) do |node, ancestor_nodes|
+          next unless Double.target_node?(node)
+          return Double.new(
+            node,
+            ancestor_nodes,
+            in_example_group_context?,
+            source_rewriter
+          )
+        end
+        fail 'No double node is found!'
+      end
+
+      let(:in_example_group_context?) { true }
+
+      describe '#method_name' do
+        let(:source) do
+          <<-END
+            it 'includes something' do
+              something = double('something')
+              [1, something].should include(something)
+            end
+          END
+        end
+
+        it 'returns the method name' do
+          double_object.method_name.should == :double
+        end
+      end
+
+      describe '#replace_deprecated_method!' do
+        before do
+          double_object.replace_deprecated_method!
+        end
+
+        [:mock, :stub].each do |method|
+          context "when it is ##{method}" do
+            let(:source) do
+              <<-END
+                it 'includes something' do
+                  something = #{method}('something')
+                  [1, something].should include(something)
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                it 'includes something' do
+                  something = double('something')
+                  [1, something].should include(something)
+                end
+              END
+            end
+
+            it 'replaces with #double' do
+              rewritten_source.should == expected_source
+            end
+          end
+        end
+
+        context 'when it is #double' do
+          let(:source) do
+            <<-END
+              it 'includes something' do
+                something = double('something')
+                [1, something].should include(something)
+              end
+            END
+          end
+
+          it 'does nothing' do
+            rewritten_source.should == source
+          end
+        end
+      end
+    end
+  end
+end