mutant 0.1.1 → 0.2.0

data/spec/integration/mutant/rspec_killer_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Mutant,'rspec integration' do
+
+  around do |example|
+    Dir.chdir(TestApp.root) do
+      example.run
+    end
+  end
+
+  let(:strategy) { Mutant::Strategy::Rspec::DM2 }
+
+  specify 'allows to kill mutations' do
+    Kernel.system("bundle exec mutant -I lib -r test_app --rspec-dm2 ::TestApp::Literal#string").should be(true)
+  end
+
+  specify 'fails to kill mutations when they are not covered' do
+    Kernel.system("bundle exec mutant -I lib -r test_app --rspec-dm2 ::TestApp::Literal#uncovered_string").should be(false)
+  end
+
+  specify 'fails when some mutations when are not covered' do
+    Kernel.system("bundle exec mutant -I lib -r test_app --rspec-dm2 ::TestApp::Literal").should be(false)
+  end
+end

data/spec/integration/mutant/runner_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Mutant, 'runner' do
+  before do
+    pending
+  end
+
+  around do |example|
+    Dir.chdir(TestApp.root) do
+      example.run
+    end
+  end
+
+  it 'allows to run mutant over a project' do
+    output = StringIO.new
+    runner = Mutant::Runner.run(
+      :killer => Mutant::Killer::Rspec,
+      :matcher => Mutant::Matcher::ObjectSpace.new(/\ATestApp::/),
+      :reporter => Mutant::Reporter::CLI.new(output)
+    )
+    runner.fail?.should be(true)
+    runner.errors.size.should be(22)
+    output.rewind
+    output.lines.grep(/Mutant alive:/).size.should be(22)
+  end
+end

data/spec/integration/mutant/zombie_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Mutant, 'as a zombie' do
+  specify 'allows to create zombie from mutant' do
+    Zombie.setup
+    Zombie::Runner
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/command_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'a command method' do
+  it 'returns self' do
+    should equal(object)
+  end
+end

data/spec/shared/each_method_behaviour.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+shared_examples_for 'an #each method' do
+  it_should_behave_like 'a command method'
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected values' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+end

data/spec/shared/hash_method_behavior.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+shared_examples_for 'a hash method' do
+  it_should_behave_like 'an idempotent method'
+
+  specification = proc do
+    should be_instance_of(Fixnum)
+  end
+
+  it 'is a fixnum' do
+    instance_eval(&specification)
+  end
+
+  it 'memoizes the hash code' do
+    subject.should eql(object.memoized(:hash))
+  end
+end

data/spec/shared/idempotent_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/shared/invertible_method_behaviour.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+shared_examples_for 'an invertible method' do
+  it_should_behave_like 'an idempotent method'
+
+  it 'is invertible' do
+    subject.inverse.should equal(object)
+  end
+end

data/spec/shared/method_filter_parse_behavior.rb

@@ -0,0 +1,16 @@
+shared_examples_for 'a method filter parse result' do
+  before do
+    expected_class.stub(:new => response)
+  end
+
+  let(:response) { mock('Response') }
+
+  it { should be(response) }
+
+  it 'should initialize method filter with correct arguments' do
+    expected_class.should_receive(:new).with(TestApp::Literal, :string).and_return(response)
+    subject
+  end
+end
+
+

data/spec/shared/method_match_behavior.rb

@@ -0,0 +1,39 @@
+shared_examples_for 'a method match' do
+  subject { Mutant::Matcher::Method.parse(pattern).to_a }
+
+  let(:values) { defaults.merge(expectation) }
+
+  let(:method_name)       { values.fetch(:method_name)  }
+  let(:method_line)       { values.fetch(:method_line)  }
+  let(:method_arity)      { values.fetch(:method_arity) }
+  let(:scope)             { values.fetch(:scope)        }
+  let(:node_class)        { values.fetch(:node_class)   }
+                         
+  let(:node)              { mutation_subject.node    }
+  let(:context)           { mutation_subject.context }
+  let(:mutation_subject)  { subject.first   }
+
+  it 'should return one subject' do
+    subject.size.should be(1)
+  end
+
+  it 'should have correct method name' do
+    name(node).should eql(method_name)
+  end
+
+  it 'should have correct line number' do
+    node.line.should eql(method_line)
+  end
+
+  it 'should have correct arity' do
+    arguments(node).required.length.should eql(method_arity)
+  end
+
+  it 'should have correct scope in context' do
+    context.send(:scope).should eql(scope)
+  end
+
+  it 'should have the correct node class' do
+    node.should be_a(node_class)
+  end
+end

data/spec/shared/mutator_behavior.rb

@@ -0,0 +1,46 @@
+shared_examples_for 'a mutator' do
+  subject { object.each(node) { |item| yields << item } }
+
+  let(:yields)        { []              }
+  let(:object)        { described_class }
+
+  unless instance_methods.map(&:to_s).include?('node')
+    let(:node)          { source.to_ast   }
+  end
+
+  it_should_behave_like 'a command method'
+
+  context 'with no block' do
+    subject { object.each(node) }
+
+    it { should be_instance_of(to_enum.class) }
+
+    let(:expected_mutations)  do
+      mutations.map do |mutation|
+        if mutation.respond_to?(:to_ast)
+          mutation.to_ast.to_sexp
+        else
+          mutation
+        end
+      end.to_set
+    end
+
+    it 'generates the expected mutations' do
+      generated = self.subject.map(&:to_sexp).to_set
+
+      missing    = (expected_mutations - generated).to_a
+      unexpected = (generated - expected_mutations).to_a
+
+      unless generated == expected_mutations
+        message = "Missing mutations: %s\nUnexpected mutations: %s" % [missing, unexpected].map(&:inspect)
+        fail message
+      end
+    end
+  end
+end
+
+shared_examples_for 'a noop mutator' do
+  let(:mutations) { [] }
+
+  it_should_behave_like 'a mutator'
+end

data/spec/spec_helper.rb

@@ -1,18 +1,15 @@
-require 'mutant'
-require 'aruba/api'
+# encoding: utf-8
 
-Dir['./spec/support/*.rb'].map {|f| require f }
+require 'rspec'
 
-RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-  config.extend ExampleGroupHelpers
-  config.include ExampleHelpers
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require(f) }
+
+$: << File.join(TestApp.root,'lib')
 
-  {:example_group => {:file_path => /spec\/functional/}}.tap do |options|
-    config.include Aruba::Api, options
-    config.before(:suite, options) { @aruba_timeout_seconds = 5 }
-    config.after(:each, options) { FileUtils.remove_dir('tmp/aruba') }
-  end
+require 'test_app'
+require 'mutant'
+
+RSpec.configure do |config|
+  config.include(CompressHelper)
 end

data/spec/support/compress_helper.rb

@@ -0,0 +1,10 @@
+module CompressHelper
+  def strip_indent(string)
+    lines = string.lines
+    match = /\A( *)/.match(lines.first)
+    whitespaces = match[1].to_s.length
+    stripped = lines.map do |line|
+      line[whitespaces..-1]
+    end.join
+  end
+end

data/spec/support/rspec.rb

@@ -0,0 +1,22 @@
+# Patch rspec to allow nested execution
+module Rspec
+  # Run block in clean rspec environment
+  #
+  # @return [Object]
+  #   returns the value of block
+  #
+  # @api private
+  #
+  def self.nest
+    original_world, original_configuration = 
+      ::RSpec.instance_variable_get(:@world),
+      ::RSpec.instance_variable_get(:@configuration)
+
+    ::RSpec.reset
+
+    yield
+  ensure
+    ::RSpec.instance_variable_set(:@world, original_world)
+    ::RSpec.instance_variable_set(:@configuration, original_configuration)
+  end
+end

data/spec/support/test_app.rb

@@ -0,0 +1,5 @@
+module TestApp
+  def self.root
+    File.expand_path('../../../test_app', __FILE__)
+  end
+end

data/spec/support/zombie.rb

@@ -0,0 +1,141 @@
+module Zombie
+  # Setup zombie
+  #
+  # @return [self]
+  #
+  # @api private
+  #
+  def self.setup
+    files.each do |path|
+      path = "#{File.expand_path(path, root)}.rb"
+      ast = File.read(path).to_ast
+      zombify(ast, path)
+    end
+
+    self
+  end
+
+  # Return library root directory
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def self.root
+    File.expand_path('../../../lib',__FILE__)
+  end
+  private_class_method :root
+
+
+  # Replace Mutant with Zombie namespace
+  #
+  # @param [Rubinius::AST::Node]
+  #
+  # @api private
+  #
+  # @return [undefined]
+  #
+  def self.zombify(root, path)
+    node = find_mutant(root)
+    unless node
+      raise "unable to find mutant in AST from: #{path.inspect}"
+    end
+
+    name = node.name
+
+    node.name = Rubinius::AST::ModuleName.new(name.line, :Zombie)
+
+    scope = node.body
+
+    unless scope.kind_of?(Rubinius::AST::EmptyBody)
+      node.body = Rubinius::AST::ModuleScope.new(scope.line, node.name, scope.body)
+    end
+
+    ::Mutant::Loader::Eval.run(root)
+  end
+  private_class_method :zombify
+
+  # Find mutant module in AST
+  #
+  # @param [Rubinius::AST::Node]
+  #
+  # @return [Rubinius::AST::Node]
+  #
+  def self.find_mutant(root)
+    if is_mutant?(root)
+      return root
+    end
+
+    unless root.kind_of?(Rubinius::AST::Block)
+      raise "Cannot find mutant in: #{root.class}"
+    end
+
+    root.array.each do |node|
+      return node if is_mutant?(node)
+    end
+
+    nil
+  end
+  private_class_method :find_mutant
+
+  # Test if node is mutant module
+  #
+  # @param [Rubinius::AST::Node]
+  #
+  # @return [true]
+  #   returns true if node is the mutant module
+  #
+  # @return [false]
+  #   returns false otherwise
+  #
+  # @api private
+  #
+  def self.is_mutant?(node)
+    node.kind_of?(Rubinius::AST::Module) && is_mutant_name?(node.name)
+  end
+  private_class_method :is_mutant?
+
+  # Test if node is mutant module name
+  #
+  # @param [Rubinius::AST::ModuleName]
+  #
+  # @return [true]
+  #   returns true if node is the mutant module name
+  #
+  # @return [false]
+  #   returns false otherwise
+  #
+  # @api private
+  #
+  def self.is_mutant_name?(node)
+    node.name == :Mutant
+  end
+  private_class_method :is_mutant_name?
+
+  # Return all library files the mutant is made of.
+  #
+  # @return [Array<String>]
+  #
+  # @api private
+  #
+  # FIXME: 
+  #  Yeah looks very ugly but im currently to exited to do a cleanup.
+  #
+  def self.files
+    block = File.read("lib/mutant.rb").to_ast
+    files = block.array.select do |node|
+      node.class          == Rubinius::AST::SendWithArguments &&
+      node.receiver.class == Rubinius::AST::Self              &&
+      node.name           == :require
+    end.map do |node|
+      arguments = node.arguments.array
+      raise unless arguments.one?
+      argument = arguments.first
+      raise unless argument.class == Rubinius::AST::StringLiteral
+      argument.string
+    end.select do |file|
+      file =~ /\Amutant/
+    end
+  end
+  private_class_method :files
+end