transpec 3.0.0 → 3.0.1

data/spec/transpec/directory_cloner_spec.rb

@@ -1,74 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/directory_cloner'
-
-module Transpec
-  describe DirectoryCloner do
-    include FileHelper
-    include_context 'isolated environment'
-
-    describe '#copy_recursively' do
-      it 'copies files recursively' do
-        [
-          'src/file1',
-          'src/file2',
-          'src/dir1/file',
-          'src/dir2/file'
-        ].each do |path|
-          create_file(path, '')
-        end
-
-        DirectoryCloner.copy_recursively('src', 'dst')
-
-        [
-          'dst/file1',
-          'dst/file2',
-          'dst/dir1/file',
-          'dst/dir2/file'
-        ].each do |path|
-          File.exist?(path).should be_true
-        end
-      end
-
-      it 'copies only directories, files and symlinks' do
-        create_file('src/file', '')
-        File.symlink('file', 'src/symlink')
-        Dir.mkdir('src/dir')
-        system('mkfifo', 'src/fifo')
-
-        DirectoryCloner.copy_recursively('src', 'dst')
-
-        File.file?('dst/file').should be_true
-        File.symlink?('dst/symlink').should be_true
-        File.directory?('dst/dir').should be_true
-        File.exist?('dst/fifo').should be_false
-      end
-
-      def permission(path)
-        format('%o', File.lstat(path).mode)[-4..-1]
-      end
-
-      it 'preserves permission' do
-        create_file('src/file', '')
-        File.chmod(0755, 'src/file')
-
-        File.symlink('file', 'src/symlink')
-
-        Dir.mkdir('src/dir')
-        File.chmod(0600, 'src/dir')
-
-        DirectoryCloner.copy_recursively('src', 'dst')
-
-        permission('dst/file').should == '0755'
-        permission('dst/dir').should == '0600'
-      end
-
-      it 'returns the copied directory path' do
-        Dir.mkdir('src')
-        path = DirectoryCloner.copy_recursively('src', 'dst')
-        path.should == File.expand_path('dst')
-      end
-    end
-  end
-end

data/spec/transpec/dynamic_analyzer/rewriter_spec.rb

@@ -1,143 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/dynamic_analyzer/rewriter'
-
-module Transpec
-  class DynamicAnalyzer
-    describe Rewriter do
-      include ::AST::Sexp
-
-      subject(:rewriter) { Rewriter.new }
-
-      describe '#rewrite_source' do
-        subject { rewriter.rewrite_source(source) }
-
-        let(:source) do
-          <<-END
-            subject.should be(foo)
-          END
-        end
-
-        # rubocop:disable LineLength
-        let(:expected_source) do
-          <<-'END'
-            Transpec.analyze((Transpec.analyze((subject), self, "(string)_12_19", { :should_source_location => [:object, "method(:should).source_location"], :should_example_method_defined_by_user? => [:object, "owner = method(:should).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] }).should be(foo)), self, "(string)_12_34", { :expect_available? => [:context, "self.class.ancestors.any? { |a| a.name.start_with?('RSpec::') } && respond_to?(:expect)"] })
-          END
-        end
-        # rubocop:enable LineLength
-
-        it 'wraps target object with analysis helper method' do
-          should == expected_source
-        end
-
-        context 'when the target includes here document' do
-          let(:source) do
-            <<-END
-              subject.should =~ <<-HEREDOC.gsub('foo', 'bar')
-              foo
-              HEREDOC
-            END
-          end
-
-          # rubocop:disable LineLength
-          let(:expected_source) do
-            <<-'END'
-              Transpec.analyze((Transpec.analyze((subject), self, "(string)_14_21", { :should_source_location => [:object, "method(:should).source_location"], :should_example_method_defined_by_user? => [:object, "owner = method(:should).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] }).should), self, "(string)_14_28", { :expect_available? => [:context, "self.class.ancestors.any? { |a| a.name.start_with?('RSpec::') } && respond_to?(:expect)"], :"=~_source_location" => [:object, "method(:=~).source_location"], :"=~_example_method_defined_by_user?" => [:object, "owner = method(:=~).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] }) =~ Transpec.analyze((<<-HEREDOC.gsub('foo', 'bar')), self, "(string)_32_61", { :enumerable_arg? => [:object, "is_a?(Enumerable)"] })
-              foo
-              HEREDOC
-            END
-          end
-          # rubocop:enable LineLength
-
-          it 'wraps the here document properly' do
-            should == expected_source
-          end
-        end
-
-        context 'when the target takes block' do
-          let(:source) do
-            <<-END
-              expect { do_something }.to throw_symbol
-            END
-          end
-
-          # rubocop:disable LineLength
-          let(:expected_source) do
-            <<-'END'
-              Transpec.analyze((expect { do_something }), self, "(string)_14_20", { :expect_source_location => [:context, "method(:expect).source_location"], :expect_example_method_defined_by_user? => [:context, "owner = method(:expect).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] }).to throw_symbol
-            END
-          end
-          # rubocop:enable LineLength
-
-          it 'wraps the block properly' do
-            should == expected_source
-          end
-        end
-
-        context 'when the target is method invocation without parentheses' do
-          let(:source) do
-            <<-END
-              double 'something'
-            END
-          end
-
-          # rubocop:disable LineLength
-          let(:expected_source) do
-            <<-'END'
-              Transpec.analyze((double 'something'), self, "(string)_14_32", { :double_source_location => [:context, "method(:double).source_location"], :double_example_method_defined_by_user? => [:context, "owner = method(:double).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] })
-            END
-          end
-          # rubocop:enable LineLength
-
-          it 'wraps the target properly' do
-            should == expected_source
-          end
-        end
-      end
-
-      describe '#register_request' do
-        include_context 'parsed objects'
-
-        let(:source) do
-          <<-END
-            1
-            2
-          END
-        end
-
-        let(:a_node) { ast.children[0] }
-        let(:another_node) { ast.children[1] }
-
-        it 'stores requests for each node' do
-          rewriter.register_request(a_node, :odd, 'odd?', :object)
-          rewriter.register_request(another_node, :even, 'even?', :object)
-          rewriter.requests[a_node].should == { odd: [:object, 'odd?'] }
-          rewriter.requests[another_node].should == { even: [:object, 'even?'] }
-        end
-
-        it 'merges multiple requests for same node' do
-          rewriter.register_request(a_node, :odd, 'odd?', :object)
-          rewriter.register_request(a_node, :even, 'even?', :object)
-          rewriter.requests[a_node].should == { odd: [:object, 'odd?'], even: [:object, 'even?'] }
-        end
-
-        context 'when there are same structure nodes but they are not identical objects' do
-          let(:source) do
-            <<-END
-              1
-              1
-            END
-          end
-
-          it 'properly diffrenciate them' do
-            rewriter.register_request(a_node, :odd, 'odd?', :object)
-            rewriter.register_request(another_node, :even, 'even?', :object)
-            rewriter.requests[a_node].should == { odd: [:object, 'odd?'] }
-            rewriter.requests[another_node].should == { even: [:object, 'even?'] }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/transpec/dynamic_analyzer_spec.rb

@@ -1,329 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/dynamic_analyzer'
-
-module Transpec
-  describe DynamicAnalyzer do
-    include FileHelper
-    include ::AST::Sexp
-    include_context 'isolated environment'
-
-    def find_node_in_file(file_path, &block)
-      processed_source = ProcessedSource.from_file(file_path)
-      processed_source.ast.each_node.find(&block)
-    end
-
-    subject(:dynamic_analyzer) { DynamicAnalyzer.new(rspec_command: rspec_command, silent: true) }
-    let(:rspec_command) { nil }
-
-    describe '.new' do
-      context 'when block is passed' do
-        it 'yields the instance' do
-          yielded = false
-
-          DynamicAnalyzer.new(silent: true) do |analyzer|
-            yielded = true
-            analyzer.should be_a(DynamicAnalyzer)
-          end
-
-          yielded.should be_true
-        end
-
-        it 'changes working directory to copied project directory' do
-          initial_directory = Dir.pwd
-          DynamicAnalyzer.new(silent: true) do
-            Dir.pwd.should_not == initial_directory
-          end
-        end
-      end
-    end
-
-    describe '#rspec_command' do
-      subject { dynamic_analyzer.rspec_command }
-
-      context 'when command is specified' do
-        let(:rspec_command) { 'rspec some_argument' }
-
-        it 'returns the specified command' do
-          should == rspec_command
-        end
-      end
-
-      context 'when command is not specified' do
-        context 'and there is a Gemfile.lock' do
-          before do
-            create_file('Gemfile.lock', '')
-          end
-
-          it 'returns "bundle exec rspec"' do
-            should == 'bundle exec rspec'
-          end
-        end
-
-        context 'and there is no Gemfile.lock' do
-          it 'returns "rspec"' do
-            should == 'rspec'
-          end
-        end
-      end
-    end
-
-    describe '#analyze' do
-      before do
-        create_file(spec_file_path, source)
-      end
-
-      let(:spec_file_path) { 'spec/example_spec.rb' }
-
-      let(:source) do
-        <<-END
-          describe [1, 2] do
-            it 'has 2 items' do
-              expect(subject).to have(2).items
-            end
-          end
-        END
-      end
-
-      context 'when already in copied project directory' do
-        it 'does not copy the project again' do
-          DynamicAnalyzer.new(silent: true) do |analyzer|
-            DirectoryCloner.should_not_receive(:copy_recursively)
-            analyzer.analyze
-          end
-        end
-      end
-
-      context 'when no path is passed' do
-        it 'rewrites all files in the "spec" directory' do
-          DynamicAnalyzer::Rewriter.any_instance.should_receive(:rewrite_file!) do |spec|
-            spec.path.should == spec_file_path
-          end
-
-          dynamic_analyzer.analyze
-        end
-      end
-
-      context 'when some paths are passed' do
-        before do
-          create_file('spec/another_spec.rb', '')
-        end
-
-        it 'rewrites only files in the passed paths' do
-          DynamicAnalyzer::Rewriter.any_instance.should_receive(:rewrite_file!) do |spec|
-            spec.path.should == spec_file_path
-          end
-
-          dynamic_analyzer.analyze([spec_file_path])
-        end
-      end
-
-      context 'when there is invalid syntax source file' do
-        before do
-          create_file('spec/fixtures/invalid.rb', 'This is invalid syntax <')
-        end
-
-        it 'does not raise error' do
-          -> { dynamic_analyzer.analyze }.should_not raise_error
-        end
-      end
-
-      context 'when rspec did not pass' do
-        let(:source) do
-          <<-END
-            describe [1, 2] do
-              it 'has 2 items' do
-                expect(subject).to have(1).items
-              end
-            end
-          END
-        end
-
-        it 'does not raise error' do
-          -> { dynamic_analyzer.analyze }.should_not raise_error
-        end
-      end
-
-      context 'when analysis result data file is not found' do
-        let(:source) { 'exit!' }
-
-        it 'raises AnalysisError' do
-          -> { dynamic_analyzer.analyze }
-            .should raise_error(DynamicAnalyzer::AnalysisError, /Failed running dynamic analysis/)
-        end
-      end
-
-      context 'when working directory has been changed at exit of rspec' do
-        let(:source) { "Dir.chdir('spec')" }
-
-        it 'does not raise error' do
-          -> { dynamic_analyzer.analyze }.should_not raise_error
-        end
-      end
-
-      context 'when rspec is run via rake task' do
-        before do
-          create_file('Rakefile', <<-END)
-            require 'rspec/core/rake_task'
-            RSpec::Core::RakeTask.new(:spec)
-          END
-        end
-
-        let(:rspec_command) { 'rake spec' }
-
-        it 'does not raise error' do
-          -> { dynamic_analyzer.analyze }.should_not raise_error
-        end
-      end
-
-      context 'when there is a .rspec file containing `--require spec_helper`' do
-        before do
-          create_file('.rspec', '--require spec_helper')
-        end
-
-        context 'and the spec/spec_helper.rb contains some code that is dynamic analysis target' do
-          before do
-            create_file('spec/spec_helper.rb', <<-END)
-              RSpec.configure { }
-
-              def some_helper_method_used_in_each_spec
-              end
-            END
-          end
-
-          let(:source) do
-            <<-END
-              some_helper_method_used_in_each_spec
-
-              describe 'something' do
-              end
-            END
-          end
-
-          it 'does not raise error' do
-            -> { dynamic_analyzer.analyze }.should_not raise_error
-          end
-
-          it 'preserves the existing `--require`' do
-            describe_node = find_node_in_file(spec_file_path) do |node|
-              node.send_type? && node.children[1] == :describe
-            end
-
-            runtime_data = dynamic_analyzer.analyze
-            runtime_data.run?(describe_node).should be_true
-          end
-        end
-      end
-
-      context 'when there is a proxy/delegator Class that undefines Object methods' do
-        let(:source) do
-          # https://github.com/thoughtbot/factory_girl/blob/v4.4.0/lib/factory_girl/definition_proxy.rb#L3-L7
-          <<-END
-            class SomeProxy
-              UNPROXIED_METHODS = %w(__send__ object_id initialize instance_eval).map(&:to_sym)
-
-              (instance_methods + private_instance_methods).each do |method|
-                undef_method(method) unless UNPROXIED_METHODS.include?(method)
-              end
-            end
-
-            describe 'example' do
-              it 'is 1' do
-                proxy = SomeProxy.new
-                proxy.instance_eval do
-                  1.should == 1
-                end
-              end
-            end
-          END
-        end
-
-        it 'properly analyzes even in such context' do
-          should_node = find_node_in_file(spec_file_path) do |node|
-            node.send_type? && node.children[1] == :should
-          end
-
-          runtime_data = dynamic_analyzer.analyze
-          runtime_data.run?(should_node).should be_true
-        end
-      end
-
-      context 'when a deprecated syntax is used with `RSpec.configure { |c| c.raise_errors_for_deprecations! }`' do
-        include CacheHelper
-
-        around do |example|
-          with_cached_dir('rspec-2.99-project') do |cached|
-            unless cached
-              create_file('Gemfile', <<-END)
-                source 'https://rubygems.org'
-                gem 'rspec', '~> 2.99'
-              END
-
-              Bundler.with_clean_env do
-                `bundle install --path vendor/bundle`
-              end
-
-              create_file('spec/spec_helper.rb', <<-END)
-                RSpec.configure do |config|
-                  config.raise_errors_for_deprecations!
-                end
-              END
-            end
-
-            example.run
-          end
-        end
-
-        let(:source) do
-          <<-END
-            require 'spec_helper'
-
-            describe 'example' do
-              it 'is deprecated syntax' do
-                mock('something')
-              end
-            end
-          END
-        end
-
-        it 'raises AnalysisError with a warning message about `raise_errors_for_deprecations!`' do
-          -> { dynamic_analyzer.analyze }
-            .should raise_error(DynamicAnalyzer::AnalysisError, /raise_errors_for_deprecations!/)
-        end
-      end
-
-      runtime_data_cache = {}
-
-      subject(:runtime_data) do
-        if runtime_data_cache[source]
-          runtime_data_cache[source]
-        else
-          runtime_data_cache[source] = dynamic_analyzer.analyze
-        end
-      end
-
-      it 'returns an instance of DynamicAnalyzer::RuntimeData' do
-        runtime_data.should be_an(DynamicAnalyzer::RuntimeData)
-      end
-
-      describe 'an element of the runtime data' do
-        let(:target_node) do
-          find_node_in_file(spec_file_path) do |node|
-            node == s(:send, nil, :subject)
-          end
-        end
-
-        subject(:element) { runtime_data[target_node] }
-
-        it 'is an OpenStruct' do
-          should be_a(OpenStruct)
-        end
-
-        it 'has result of requested analysis' do
-          element[:available_query_methods].should =~ %w(size count length)
-        end
-      end
-    end
-  end
-end