mutant 0.1.1 → 0.2.0

data/spec/unit/mutant/mutator/node/literal/empty_array_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'empty array' do
+  let(:source) { '[]' }
+
+  let(:mutations) do
+    mutations = []
+
+    # Literal replaced with nil
+    mutations << [:nil]
+
+    # Extra element
+    mutations << '[nil]'
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/literal/fixnum_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'fixnum' do
+  let(:random_fixnum) { 5 }
+
+  let(:source) { '10' }
+
+  let(:mutations) do
+    %W(nil 0 1 #{random_fixnum}) << [:lit, -10]
+  end
+
+  before do
+    Mutant::Random.stub(:fixnum => random_fixnum)
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/literal/float_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'float' do
+  let(:source) { '10.0' }
+
+  let(:mutations) do
+    mutations = []
+    mutations << 'nil'
+    mutations << '0.0'
+    mutations << '1.0'
+    mutations << random_float.to_s
+    mutations << '0.0/0.0'
+    mutations << '1.0/0.0'
+    mutations << [:negate, [:call, [:lit, 1.0], :/, [:arglist, [:lit, 0.0]]]]
+    mutations << [:lit, -10.0]
+  end
+
+  let(:random_float) { 7.123 }
+
+  before do
+    Mutant::Random.stub(:float => random_float)
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/literal/hash_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'hash' do
+  let(:source) { '{true => true, false => false}' }
+
+  let(:mutations) do
+    mutations = []
+
+    # Literal replaced with nil
+    mutations << [:nil]
+
+    # Mutation of each key and value in hash
+    mutations << [:hash, [:false ], [:true ], [:false], [:false]]
+    mutations << [:hash, [:nil   ], [:true ], [:false], [:false]]
+    mutations << [:hash, [:true  ], [:false], [:false], [:false]]
+    mutations << [:hash, [:true  ], [:nil  ], [:false], [:false]]
+    mutations << [:hash, [:true  ], [:true ], [:true ], [:false]]
+    mutations << [:hash, [:true  ], [:true ], [:nil  ], [:false]]
+    mutations << [:hash, [:true  ], [:true ], [:false], [:true ]]
+    mutations << [:hash, [:true  ], [:true ], [:false], [:nil  ]]
+
+    # Remove each key once
+    mutations << [:hash, [:true  ], [:true ]]
+    mutations << [:hash, [:false ], [:false ]]
+
+    # Empty hash
+    mutations << [:hash]
+
+    # Extra element
+    mutations << [:hash, [:true  ], [:true ], [:false], [:false ], [:nil], [:nil] ]
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/literal/nil_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'nil' do
+  let(:source) { 'nil' }
+
+  let(:mutations) do
+    mutations = []
+
+    mutations << 'Object.new'
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/literal/range_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'range' do
+  context 'inclusive range literal' do
+    let(:source) { '1..100' }
+
+    let(:mutations) do
+      mutations = []
+      mutations << 'nil'
+      mutations << '1...100'
+      mutations << '(0.0/0.0)..100'
+      mutations << [:dot2, [:negate, [:call, [:lit, 1.0], :/, [:arglist, [:lit, 0.0]]]], [:lit, 100]]
+      mutations << '1..(1.0/0.0)'
+      mutations << '1..(0.0/0.0)'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'exclusive range literal' do
+    let(:source) { '1...100' }
+
+    let(:mutations) do
+      mutations = []
+      mutations << 'nil'
+      mutations << '1..100'
+      mutations << '(0.0/0.0)...100'
+      mutations << [:dot3, [:negate, [:call, [:lit, 1.0], :/, [:arglist, [:lit, 0.0]]]], [:lit, 100]]
+      mutations << '1...(1.0/0.0)'
+      mutations << '1...(0.0/0.0)'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+end

data/spec/unit/mutant/mutator/node/literal/regex_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'regex' do
+  let(:random_string) { 'bar' }
+
+  let(:source) { '/foo/' }
+
+  let(:base_mutations) do
+    mutations = []
+    mutations << 'nil'
+    mutations << "/#{random_string}/"
+    mutations << '//' # match all
+    mutations << '/a\A/' # match nothing
+  end
+
+  before do
+    Mutant::Random.stub(:hex_string => random_string)
+  end
+
+  let(:mutations) { base_mutations }
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/literal/string_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'string' do
+  let(:random_string) { 'bar' }
+
+  let(:source) { '"foo"' }
+
+  let(:mutations) do
+    %W(nil "#{random_string}")
+  end
+
+  before do
+    Mutant::Random.stub(:hex_string => random_string)
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/literal/symbol_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'symbol' do
+  let(:random_string) { 'bar' }
+
+  let(:source) { ':foo' }
+
+  let(:mutations) do
+    %w(nil) << ":s#{random_string}"
+  end
+
+  before do
+    Mutant::Random.stub(:hex_string => random_string)
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/receiver_case/mutation_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::ReceiverCase do
+  let(:source) { 'case self.condition; when true; true; when false; false; else raise; end' }
+
+  let(:mutations) do
+    mutations = []
+
+    # Delete each when once
+    mutations << 'case self.condition; when true; true; else raise; end'
+    mutations << 'case self.condition; when false; false; else raise; end'
+
+    # Mutate receiver
+    mutations << 'case condition; when true; true; when false; false; else raise; end'
+
+    # Remove else branch
+    mutations << 'case self.condition; when true; true; when false; false; end'
+
+    # Mutate when branch bodies
+    mutations << 'case self.condition; when true; nil;   when false; false; else raise; end'
+    mutations << 'case self.condition; when true; false; when false; false; else raise; end'
+    mutations << 'case self.condition; when true; true;  when false; nil;   else raise; end'
+    mutations << 'case self.condition; when true; true;  when false; true;  else raise; end'
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/return/mutation_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, 'return' do
+
+  context 'return without value' do
+    let(:source) { 'return' }
+
+    let(:mutations) { ['nil'] }
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'return with value' do
+    let(:source) { 'return foo' }
+
+    let(:mutations) { ['foo'] }
+
+    it_should_behave_like 'a mutator'
+  end
+
+end

data/spec/unit/mutant/mutator/node/send/mutation_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, 'call' do
+  context 'send without arguments' do
+    # This could not be reproduced in a test case but happens in the mutant source code?
+    context 'block given' do
+      context 'implicit self' do
+        let(:source) { 'block_given?' }
+
+        it_should_behave_like 'a noop mutator'
+      end
+      
+      context 'explicit self' do
+        let(:source) { 'self.block_given?' }
+
+        it_should_behave_like 'a noop mutator'
+      end
+    end
+
+    context 'with self as receiver' do
+
+      context 'implicit' do
+        let(:source) { 'foo' }
+
+        it_should_behave_like 'a noop mutator'
+      end
+
+      context 'explict' do
+        let(:source) { 'self.foo' }
+
+        let(:mutations) do
+          mutations = []
+          # with implicit receiver (send privately)
+          mutations << 'foo' 
+        end
+
+        it_should_behave_like 'a mutator'
+      end
+    end
+
+    context 'to some object' do
+      let(:source) { '1.foo' }
+
+      it_should_behave_like 'a noop mutator'
+    end
+  end
+
+  context 'send with arguments' do
+
+    context 'with self as receiver' do
+      context 'implicit' do
+        let(:source) { 'foo(nil)' }
+
+        let(:mutations) do 
+          mutations = []
+          mutations << 'foo()'
+          mutations << 'foo(Object.new)'
+        end
+
+        it_should_behave_like 'a mutator'
+      end
+
+      context 'explicit' do
+        let(:source) { 'self.foo(nil)' }
+
+        let(:mutations) do
+          mutations = []
+          # with implicit receiver (send privately)
+          mutations << 'foo(nil)'
+          mutations << 'self.foo(Object.new)'
+          mutations << 'self.foo()'
+        end
+
+        it_should_behave_like 'a mutator'
+      end
+    end
+  end
+end

data/spec/unit/mutant/mutator/self_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, 'self' do
+  let(:source) { 'self' }
+
+  it_should_behave_like 'a noop mutator'
+end

data/spec/unit/mutant/subject/class_methods/new_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Mutant::Subject, '.new' do
+  subject { object.new(matcher, context, ast) }
+
+  let(:object) { described_class }
+
+  let(:matcher) { mock('Matcher') }
+  let(:context) { mock('Context') }
+  let(:ast)     { mock('AST')     }
+
+  it { should be_frozen }
+end

data/spec/unit/mutant/subject/context_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Mutant::Subject, '#context' do
+  subject { object.context }
+
+  let(:object)  { described_class.new(matcher, context, ast) }
+  let(:matcher) { mock('Matcher') }
+  let(:ast)     { mock('AST')     }
+  let(:context) { mock('Context') }
+
+  it { should be(context) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/mutant/subject/each_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Mutant::Subject, '#each' do
+  subject { object.each { |item| yields << item }   }
+
+  let(:object)   { described_class.new(matcher, context, ast) }
+  let(:matcher)  { mock('Matcher')                            }
+  let(:root)     { mock('Root AST')                           }
+  let(:ast)      { mock('AST')                                }
+  let(:context)  { mock('Context', :root => root)             }
+  let(:mutant)   { mock('Mutant')                             }
+  let(:mutation) { mock('Mutation')                           }
+  let(:yields)   { []                                         }
+
+  before do
+    Mutant::Mutator.stub(:each).with(ast).and_yield(mutant).and_return(Mutant::Mutator)
+    Mutant::Mutation.stub(:new => mutation)
+  end
+
+  it_should_behave_like 'an #each method'
+
+  it 'should initialize mutator with ast' do
+    Mutant::Mutator.should_receive(:each).with(ast).and_yield(mutation).and_return(Mutant::Mutator)
+    subject
+  end
+
+  it 'should yield mutations' do
+    expect { subject }.to change { yields.dup }.from([]).to([mutation])
+  end
+
+  it 'should initialize mutation' do
+    Mutant::Mutation.should_receive(:new).with(object, mutant).and_return(mutation)
+    subject
+  end
+end

data/spec/unit/mutant/subject/node_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Mutant::Subject, '#node' do
+  subject { object.node }
+  let(:object)  { described_class.new(matcher, context, node) }
+  let(:matcher) { mock('Matcher') }
+  let(:node)    { mock('Node')    }
+  let(:context) { mock('Context') }
+
+  it { should be(node) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/tasks/metrics/ci.rake

@@ -0,0 +1,7 @@
+desc 'Run metrics with Heckle'
+task :ci => %w[ ci:metrics heckle ]
+
+namespace :ci do
+  desc 'Run metrics'
+  task :metrics => %w[ verify_measurements flog flay reek roodi metrics:all ]
+end

data/tasks/metrics/flay.rake

@@ -0,0 +1,41 @@
+begin
+  require 'flay'
+  require 'yaml'
+
+  config      = YAML.load_file(File.expand_path('../../../config/flay.yml', __FILE__)).freeze
+  threshold   = config.fetch('threshold').to_i
+  total_score = config.fetch('total_score').to_f
+  files       = Flay.expand_dirs_to_files(config.fetch('path', 'lib'))
+
+  # original code by Marty Andrews:
+  # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
+  desc 'Analyze for code duplication'
+  task :flay do
+    # run flay once without a threshold to ensure the max mass matches the threshold
+    flay = Flay.new(:fuzzy => false, :verbose => false, :mass => 0)
+    flay.process(*files)
+
+    max = flay.masses.map { |hash, mass| mass.to_f / flay.hashes[hash].size }.max
+    unless max >= threshold
+      raise "Adjust flay threshold down to #{max}"
+    end
+
+    total = flay.masses.reduce(0.0) { |total, (hash, mass)| total + (mass.to_f / flay.hashes[hash].size) }
+    unless total == total_score
+      raise "Flay total is now #{total}, but expected #{total_score}"
+    end
+
+    # run flay a second time with the threshold set
+    flay = Flay.new(:fuzzy => false, :verbose => false, :mass => threshold.succ)
+    flay.process(*files)
+
+    if flay.masses.any?
+      flay.report
+      raise "#{flay.masses.size} chunks of code have a duplicate mass > #{threshold}"
+    end
+  end
+rescue LoadError
+  task :flay do
+    abort 'Flay is not available. In order to run flay, you must: gem install flay'
+  end
+end