mutant 0.5.10 → 0.5.11

data/spec/integration/mutant/corpus_spec.rb

@@ -0,0 +1,121 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe 'Mutant on ruby corpus' do
+
+  before do
+    pending 'Unparser is too slow on big files'
+  end
+
+  ROOT = Pathname.new(__FILE__).parent.parent.parent.parent
+
+  TMP = ROOT.join('tmp')
+
+  class Project
+    include Anima.new(:name, :repo_uri, :exclude)
+
+    # Perform verification via unparser cli
+    #
+    # @return [self]
+    #   if successful
+    #
+    # @raise [Exception]
+    #   otherwise
+    #
+    def verify
+      checkout
+      Pathname.glob(repo_path.join('**/*.rb')).sort.each do |path|
+        puts "Generating mutations for: #{path.to_s}"
+        node = Parser::CurrentRuby.parse(path.read)
+        count = 0
+        Mutant::Mutator::Node.each(node) do |mutant|
+          count += 1
+          if (count % 100).zero?
+            puts count
+          end
+        end
+        puts "Mutations: #{count}"
+      end
+      self
+    end
+
+    # Checkout repository
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def checkout
+      TMP.mkdir unless TMP.directory?
+      if repo_path.exist?
+        Dir.chdir(repo_path) do
+          system(%w(git pull origin master))
+          system(%w(git clean -f -d -x))
+        end
+      else
+        system(%W(git clone #{repo_uri} #{repo_path}))
+      end
+      self
+    end
+
+  private
+
+    # Return repository path
+    #
+    # @return [Pathname]
+    #
+    # @api private
+    #
+    def repo_path
+      TMP.join(name)
+    end
+
+    # Helper method to execute system commands
+    #
+    # @param [Array<String>] arguments
+    #
+    # @api private
+    #
+    def system(arguments)
+      unless Kernel.system(*arguments)
+        if block_given?
+          yield
+        else
+          raise 'System command failed!'
+        end
+      end
+    end
+
+    LOADER = Morpher.build do
+      s(:block,
+        s(:guard, s(:primitive, Array)),
+        s(:map,
+          s(:block,
+            s(:guard, s(:primitive, Hash)),
+            s(:hash_transform,
+              s(:key_symbolize, :repo_uri, s(:guard, s(:primitive, String))),
+              s(:key_symbolize, :name,     s(:guard, s(:primitive, String))),
+              s(:key_symbolize, :exclude,  s(:map, s(:guard, s(:primitive, String))))
+            ),
+            s(:load_attribute_hash,
+              # NOTE: The domain param has no DSL currently!
+              Morpher::Evaluator::Transformer::Domain::Param.new(
+                Project,
+                [:repo_uri, :name, :exclude]
+              )
+            )
+          )
+        )
+      )
+    end
+
+    ALL = LOADER.call(YAML.load_file(ROOT.join('spec', 'integrations.yml')))
+  end
+
+  Project::ALL.each do |project|
+    specify "unparsing #{project.name}" do
+      project.verify
+    end
+  end
+end

data/spec/integration/mutant/rspec_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Mutant, 'rspec integration' do
+describe 'rspec integration' do
 
   let(:base_cmd) { 'bundle exec mutant -I lib --require test_app --use rspec' }
 

data/spec/integration/mutant/test_mutator_handles_types_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Mutant do
+describe do
 
   specify 'mutant should not crash for any node parser can generate' do
     Mutant::NODE_TYPES.each do |type|

data/spec/integration/mutant/zombie_spec.rb

@@ -2,9 +2,9 @@
 
 require 'spec_helper'
 
-describe Mutant, 'as a zombie' do
-  pending 'it allows to create zombie from mutant' do
-    Mutant::Zombifier.run('mutant')
+describe 'as a zombie' do
+  specify 'it allows to create zombie from mutant' do
+    expect { Mutant.zombify }.to change { !!defined?(Zombie) }.from(false).to(true)
     expect(Zombie.constants).to include(:Mutant)
   end
 end

data/spec/integrations.yml

@@ -0,0 +1,23 @@
+---
+- name: rubyspec
+  repo_uri: 'https://github.com/rubyspec/rubyspec.git'
+  exclude:
+    # Binary encoded source subjected to limitations see Readme
+    - core/array/pack/{b,h,u}_spec.rb
+    - language/versions/*1.8*
+    - core/array/pack/shared/float.rb
+    - core/array/pack/shared/integer.rb
+    - core/array/pack/{c,m,w}_spec.rb
+    - core/regexp/shared/new.rb
+    - core/regexp/shared/quote.rb
+    - core/encoding/compatible_spec.rb
+    - core/io/readpartial_spec.rb
+    - core/env/element_reference_spec.rb
+    - core/dir/pwd_spec.rb
+    - core/string/casecmp_spec.rb
+    - core/string/unpack/{b,c,h,m,u,w}_spec.rb
+    - core/string/unpack/b_spec.rb
+    - core/string/unpack/shared/float.rb
+    - core/string/unpack/shared/integer.rb
+    - core/symbol/casecmp_spec.rb
+    - optional/capi/integer_spec.rb

data/spec/shared/mutator_behavior.rb

@@ -1,52 +1,12 @@
-# encoding: utf-8
-
-class Subject
-
-  include Equalizer.new(:source)
-
-  Undefined = Object.new.freeze
-
-  attr_reader :source
-
-  def self.coerce(input)
-    case input
-    when Parser::AST::Node
-      new(input)
-    when String
-      new(Parser::CurrentRuby.parse(input))
-    else
-      raise
-    end
-  end
-
-  def to_s
-    "#{@node.inspect}\n#{@source}"
-  end
-
-  def initialize(node)
-    source = Unparser.unparse(node)
-    @node, @source = node, source
-  end
-
-  def assert_transitive!
-    generated = Unparser.generate(@node)
-    parsed    = Parser::CurrentRuby.parse(generated)
-    again     = Unparser.generate(parsed)
-    unless generated == again
-      # mostly an unparser bug!
-      fail sprintf("Untransitive:\n%s\n---\n%s", generated, again)
-    end
-    self
-  end
-end
+# encoding: UTF-8
 
 shared_examples_for 'a mutator' do
-  subject { object.each(node) { |item| yields << item } }
+  subject { object.each(node, &yields.method(:<<)) }
 
   let(:yields) { []              }
   let(:object) { described_class }
 
-  unless instance_methods.map(&:to_s).include?('node')
+  unless instance_methods.include?(:node)
     let(:node) { parse(source) }
   end
 
@@ -57,42 +17,32 @@ shared_examples_for 'a mutator' do
 
     it { should be_instance_of(to_enum.class) }
 
-    let(:expected_mutations) do
-      mutations.map(&Subject.method(:coerce))
+    def coerce(input)
+      case input
+      when String
+        Parser::CurrentRuby.parse(input)
+      when Parser::AST::Node
+        input
+      else
+        raise
+      end
     end
 
-    let(:generated_mutations) do
+    def normalize(node)
+      Unparser::Preprocessor.run(node)
     end
 
-    it 'generates the expected mutations' do
-
-      generated  = subject.map { |node| Subject.new(node) }
-
-      missing    = expected_mutations - generated
-      unexpected = generated - expected_mutations
-
-      message = []
-
-      if missing.any?
-        message << sprintf('Missing mutations (%i):', missing.length)
-        message.concat(missing)
-      end
-
-      if unexpected.any?
-        message << sprintf('Unexpected mutations (%i):', unexpected.length)
-        message.concat(unexpected)
-      end
+    let(:expected_mutations) do
+      mutations.map(&method(:coerce)).map(&method(:normalize))
+    end
 
-      if message.any?
+    it 'generates the expected mutations' do
+      generated_mutations = subject.map(&method(:normalize))
 
-        message = sprintf(
-          "Original:\n%s\n%s\n-----\n%s",
-          generate(node),
-          node.inspect,
-          message.join("\n-----\n")
-        )
+      verifier = MutationVerifier.new(node, expected_mutations, generated_mutations)
 
-        fail message
+      unless verifier.success?
+        fail verifier.error_report
       end
     end
   end

data/spec/spec_helper.rb

@@ -21,8 +21,10 @@ if ENV['COVERAGE'] == 'true'
   end
 end
 
-require 'equalizer'
+require 'concord'
+require 'adamantium'
 require 'devtools/spec_helper'
+require 'unparser/cli'
 require 'mutant'
 
 $LOAD_PATH << File.join(TestApp.root, 'lib')
@@ -39,7 +41,7 @@ module ParserHelper
   end
 
   def parse(string)
-    Parser::CurrentRuby.parse(string)
+    Unparser::Preprocessor.run(Parser::CurrentRuby.parse(string))
   end
 end
 

data/spec/support/mutation_verifier.rb

@@ -0,0 +1,95 @@
+# encoding: UTF-8
+
+class MutationVerifier
+  include Adamantium::Flat, Concord.new(:original_node, :expected, :generated)
+
+  # Test if mutation was verified successfully
+  #
+  # @return [Boolean]
+  #
+  # @api private
+  #
+  def success?
+    unparser.success? && missing.empty? && unexpected.empty?
+  end
+
+  # Return error report
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def error_report
+    unless unparser.success?
+      return unparser.report
+    end
+    mutation_report
+  end
+
+private
+
+  # Return unexpected mutationso
+  #
+  # @return [Array<Parser::AST::Node>]
+  #
+  # @api private
+  #
+  def unexpected
+    generated - expected
+  end
+  memoize :unexpected
+
+  # Return mutation report
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def mutation_report
+    message = ['Original:', original_node.inspect]
+    if missing.any?
+      message << 'Missing mutations:'
+      message << missing.map(&method(:format_mutation)).join("\n-----\n")
+    end
+    if unexpected.any?
+      message << 'Unexpected mutations:'
+      message << unexpected.map(&method(:format_mutation)).join("\n-----\n")
+    end
+    message.join("\n======\n")
+  end
+
+  # Format mutation
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def format_mutation(node)
+    [
+      node.inspect,
+      Unparser.unparse(node)
+    ].join("\n")
+  end
+
+  # Return missing mutationso
+  #
+  # @return [Array<Parser::AST::Node>]
+  #
+  # @api private
+  #
+  def missing
+    expected - generated
+  end
+  memoize :missing
+
+  # Return unparser verifier
+  #
+  # @return [Unparser::CLI::Source]
+  #
+  # @api private
+  #
+  def unparser
+    Unparser::CLI::Source::Node.new(Unparser::Preprocessor.run(original_node))
+  end
+  memoize :unparser
+end # MutationVerifier

data/spec/unit/mutant/mutator/node/conditional_loop_spec.rb

@@ -4,6 +4,20 @@ require 'spec_helper'
 
 describe Mutant::Mutator::Node::ConditionalLoop do
 
+  context 'with empty body' do
+    let(:source) { 'while true; end' }
+
+    let(:mutations) do
+      mutations = []
+      mutations << 'while true; raise; end'
+      mutations << 'while false; end'
+      mutations << 'while nil; end'
+      mutations << 'nil'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
   context 'with while statement' do
     let(:source) { 'while true; foo; bar; end' }
 
@@ -16,6 +30,7 @@ describe Mutant::Mutator::Node::ConditionalLoop do
       mutations << 'while nil;   foo; bar; end'
       mutations << 'while true;  foo; nil; end'
       mutations << 'while true;  nil; bar; end'
+      mutations << 'while true;  raise; end'
       mutations << 'nil'
     end
 
@@ -34,6 +49,7 @@ describe Mutant::Mutator::Node::ConditionalLoop do
       mutations << 'until nil;   foo; bar; end'
       mutations << 'until true;  foo; nil; end'
       mutations << 'until true;  nil; bar; end'
+      mutations << 'until true;  raise; end'
       mutations << 'nil'
     end
 

data/spec/unit/mutant/mutator/node/match_current_line_spec.rb

@@ -3,16 +3,16 @@
 require 'spec_helper'
 
 describe Mutant::Mutator::Node::Generic, 'match_current_line' do
-  let(:source) { 'true if //' }
+  let(:source) { 'true if /foo/' }
 
   let(:mutations) do
     mutations = []
-    mutations << 'false if //'
-    mutations << 'nil if //'
+    mutations << 'false if /foo/'
+    mutations << 'true if //'
+    mutations << 'nil if /foo/'
     mutations << 'true if true'
     mutations << 'true if false'
     mutations << 'true if nil'
-    mutations << s(:if, s(:send, s(:match_current_line, s(:regexp, s(:regopt))), :!), s(:true), nil)
     mutations << 'true if /a\A/'
     mutations << 'nil'
   end

data/spec/unit/mutant/mutator/node/named_value/access_spec.rb

@@ -60,10 +60,13 @@ describe Mutant::Mutator::Node::NamedValue::Access, 'mutations' do
       mutants = []
       mutants << 'a = nil; nil'
       mutants << 'a = nil'
-      mutants << 'a'
       mutants << 'a = ::Object.new; a'
-      mutants << 'srandom = nil; a'
-      mutants << 'nil; a'
+      # TODO: fix invalid AST
+      #   These ASTs are not valid and should NOT be emitted
+      #   Mutations of lvarasgn need to be special cased to avoid this.
+      mutants << s(:begin, s(:lvasgn, :srandom, s(:nil)), s(:lvar, :a))
+      mutants << s(:begin, s(:nil), s(:lvar, :a))
+      mutants << s(:lvar, :a)
     end
 
     it_should_behave_like 'a mutator'

data/spec/unit/mutant/mutator/node/nthref_spec.rb

@@ -4,8 +4,8 @@ require 'spec_helper'
 
 describe Mutant::Mutator, 'nthref' do
   context '$1' do
-    let(:source)    { '$1' }
-    let(:mutations) { ['$2', '$0']   }
+    let(:source)    { '$1'   }
+    let(:mutations) { ['$2'] }
 
     it_should_behave_like 'a mutator'
   end

data/spec/unit/mutant/mutator/node/op_assgn_spec.rb

@@ -13,10 +13,12 @@ describe Mutant::Mutator::Node::Generic, 'op_asgn' do
     mutations << '@a.b += 2'
     mutations << '@a.b += 0'
     mutations << '@a.b += nil'
-    mutations << '@a += 1'
     mutations << '@a.b += 5'
     mutations << 'nil.b += 1'
     mutations << 'nil'
+    # TODO: fix invalid AST
+    #   This should not get emitted as invalid AST with valid unparsed source
+    mutations << s(:op_asgn, s(:ivar, :@a), :+, s(:int, 1))
   end
 
   before do

data/spec/unit/mutant/mutator/node/send_spec.rb

@@ -63,7 +63,6 @@ describe Mutant::Mutator, 'send' do
 
     let(:mutations) do
       mutations = []
-      mutations << 'foo ||= expression'
       mutations << 'self.foo ||= nil'
       mutations << 'nil.foo ||= expression'
       mutations << 'nil'

data/spec/unit/mutant/require_highjack_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Mutant::RequireHighjack do
+  let(:object) { described_class.new(target, highjacked_calls.method(:push)) }
+
+  let(:highjacked_calls) { [] }
+  let(:require_calls)    { [] }
+
+  let(:target) do
+    require_calls = self.require_calls
+    Module.new do
+      define_method(:require) do |logical_name|
+        require_calls << logical_name
+      end
+      module_function :require
+    end
+  end
+
+  describe '#run' do
+    let(:block)        { -> {}                  }
+    let(:logical_name) { double('Logical Name') }
+
+    subject do
+      object.run(&block)
+    end
+
+    context 'require calls before run' do
+      it 'does not highjack anything' do
+        target.require(logical_name)
+        expect(require_calls).to eql([logical_name])
+        expect(highjacked_calls).to eql([])
+      end
+    end
+
+    context 'require calls during run' do
+      let(:block) { -> { target.require(logical_name) } }
+
+      it 'does highjack the calls' do
+        expect { subject }.to change { highjacked_calls }.from([]).to([logical_name])
+        expect(require_calls).to eql([])
+      end
+    end
+
+    context 'require calls after run' do
+
+      it 'does not the calls anything' do
+        subject
+        target.require(logical_name)
+        expect(require_calls).to eql([logical_name])
+        expect(highjacked_calls).to eql([])
+      end
+    end
+  end
+end

data/spec/unit/mutant/subject/method/instance_spec.rb

@@ -20,6 +20,12 @@ describe Mutant::Subject::Method::Instance do
 
     let(:scope) do
       Class.new do
+        attr_reader :bar
+
+        def initialize
+          @bar = :boo
+        end
+
         def foo
         end
       end
@@ -27,11 +33,36 @@ describe Mutant::Subject::Method::Instance do
 
     subject { object.prepare }
 
-    it 'undefines method on scope' do
-      expect { subject }.to change { scope.instance_methods.include?(:foo) }.from(true).to(false)
+    context 'on non initialize methods' do
+
+      it 'undefines method on scope' do
+        expect { subject }.to change { scope.instance_methods.include?(:foo) }.from(true).to(false)
+      end
+
+      it_should_behave_like 'a command method'
+
     end
 
-    it_should_behave_like 'a command method'
+    context 'on initialize method' do
+
+      let(:node) do
+        s(:def, :initialize, s(:args))
+      end
+
+      it 'does not write warnings' do
+        warnings = Mutant::WarningFilter.use do
+          subject
+        end
+        expect(warnings).to eql([])
+      end
+
+      it 'undefines method on scope' do
+        subject
+        expect { scope.new }.to raise_error(NoMethodError)
+      end
+
+      it_should_behave_like 'a command method'
+    end
   end
 
   describe '#source' do