mutant 0.1.1 → 0.2.0

data/spec/unit/mutant/matcher/class_methods/parse_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Mutant::Matcher, '.parse' do
+  subject { object.parse(input) }
+
+  let(:input) { mock('Input') }
+  let(:object) { described_class }
+
+  it { should be(nil) }
+
+  it_should_behave_like 'an idempotent method'
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+# This spec is only present to ensure 100% test coverage.
+# The code should not be triggered on runtime.
+
+describe Mutant::Matcher, '#each' do
+  subject { object.send(:each) }
+
+  let(:object) { described_class.allocate }
+
+  it 'should raise error' do
+    expect { subject }.to raise_error(NotImplementedError, 'Mutant::Matcher#each is not implemented')
+  end
+end

data/spec/unit/mutant/matcher/method/class_methods/parse_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Method, '.parse' do
+  subject { described_class.parse(input) }
+
+  let(:response) { mock('Response') }
+  let(:input)    { mock('Input')    }
+
+  let(:classifier) { described_class::Classifier }
+
+  before do
+    classifier.stub(:run => response)
+  end
+
+  it { should be(response) }
+
+  it 'should call classifier' do
+    classifier.should_receive(:run).with(input).and_return(response)
+    subject
+  end
+end

data/spec/unit/mutant/matcher/method/classifier/class_methods/run_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Method::Classifier, '.run' do
+  subject { described_class.run(input) }
+
+  context 'with explicit toplevel scope' do
+    let(:input)          { '::TestApp::Literal#string' }
+    let(:expected_class) { Mutant::Matcher::Method::Instance }
+
+    it_should_behave_like 'a method filter parse result'
+  end
+
+  context 'with instance method notation' do
+    let(:input)          { 'TestApp::Literal#string' }
+    let(:expected_class) { Mutant::Matcher::Method::Instance }
+
+    it_should_behave_like 'a method filter parse result'
+  end
+
+  context 'with singleton method notation' do
+    let(:input)          { 'TestApp::Literal.string' }
+    let(:expected_class) { Mutant::Matcher::Method::Singleton }
+
+    it_should_behave_like 'a method filter parse result'
+  end
+
+  context 'with invalid notation' do
+    let(:input) { 'Foo' }
+
+    it 'should return nil' do
+      should be(nil)
+    end
+  end
+end

data/spec/unit/mutant/matcher/method/method_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Method, '#method' do
+  subject { object.send(:method) }
+
+  let(:object) { described_class.allocate }
+
+  it 'should raise error' do
+    expect { subject }.to raise_error(NotImplementedError, 'Mutant::Matcher::Method#method is not implemented')
+  end
+end

data/spec/unit/mutant/matcher/object_space/class_methods/parse_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::ObjectSpace, '.parse' do
+  subject { object.parse(input) }
+
+  let(:object) { described_class }
+
+  let(:matcher) { mock('Matcher') }
+
+  context 'with valid notation' do
+    let(:input) { '::TestApp::Literal' }
+
+    it 'should return matcher' do
+      described_class.should_receive(:new).with(%r(\ATestApp::Literal(\z|::))).and_return(matcher)
+      should be(matcher)
+    end
+  end
+
+  context 'with invalid notation' do
+    let(:input) { 'TestApp' }
+
+    it { should be(nil) }
+  end
+end

data/spec/unit/mutant/matcher/object_space/each_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::ObjectSpace, '#each' do
+  before do
+    pending "defunct"
+  end
+  subject { object.each { |item| yields << item } }
+
+  let(:yields) { []                                               }
+  let(:object) { described_class.new(/\ATestApp::Literal(\z|::)/) }
+
+  before do
+    Mutant::Matcher::Method::Singleton.stub(:each).and_yield(matcher_a)
+    Mutant::Matcher::Method::Instance.stub(:each).and_yield(matcher_b)
+    matcher_a.stub(:each).and_yield(subject_a)
+    matcher_b.stub(:each).and_yield(subject_b)
+  end
+
+
+  let(:matcher_a) { mock('Matcher A') }
+  let(:matcher_b) { mock('Matcher B') }
+
+  let(:subject_a) { mock('Subject A') }
+  let(:subject_b) { mock('Subject B') }
+  
+  it_should_behave_like 'an #each method'
+
+  it 'should yield subjects' do
+    expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
+  end
+end

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

@@ -0,0 +1,25 @@
+# This file is the sandbox for new mutations.
+# Once finished mutation test will be moved to class specfic
+# file.
+
+require 'spec_helper'
+
+describe Mutant::Mutator, '.each' do
+
+  pending 'interpolated string literal (DynamicString)' do
+    let(:source) { '"foo#{1}bar"' }
+
+    let(:random_string) { 'this-is-random' }
+
+    let(:mutations) do
+      mutations = []
+      mutations << 'nil'
+    end
+
+    before do
+      Mutant::Random.stub(:hex_string => random_string)
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, '#emit_new' do
+  subject { object.send(:emit_new) { generated } }
+
+  class Block
+    def arguments; @arguments; end
+
+    def called?
+      defined?(@arguments)
+    end
+
+    def call(*arguments)
+      @arguments = arguments
+    end
+  end
+
+  let(:object) { class_under_test.new(input, block) }
+  let(:block)  { Block.new                          }
+  let(:input)  { :input                             }
+
+  let(:class_under_test) do
+    Class.new(described_class) do
+      def dispatch
+        #noop
+      end
+    end
+  end
+
+  context 'when new object generated' do
+    let(:generated) { :generated }
+
+    it 'should call block' do
+      subject
+      block.should be_called
+    end
+
+    it 'should call block with generated object' do
+      subject
+      block.arguments.should eql([generated])
+    end
+  end
+
+  context 'when new AST could not be generated' do
+    let(:generated) { input }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(RuntimeError, 'New AST could not be generated after 3 attempts')
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, '#emit' do
+  subject { object.send(:emit, generated) }
+
+  class Block
+    def arguments; @arguments; end
+
+    def called?
+      defined?(@arguments)
+    end
+
+    def call(*arguments)
+      @arguments = arguments
+    end
+  end
+
+  let(:object) { class_under_test.new(input, block) }
+  let(:block)  { Block.new                          }
+  let(:input)  { :nput                              }
+
+  let(:class_under_test) do
+    Class.new(described_class) do
+      def dispatch
+        #noop
+      end
+    end
+  end
+
+  context 'with generated that is not equal to input' do
+    let(:generated) { :generated }
+
+    it 'should call block' do
+      subject
+      block.should be_called
+    end
+
+    it 'should call block with generated' do
+      subject
+      block.arguments.should eql([generated])
+    end
+  end
+
+  context 'with generated object that is equal to input' do
+    let(:generated) { input }
+
+    it 'should not call block' do
+      subject
+      block.should_not be_called
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, 'block' do
+
+  context 'with more than one statement' do
+    let(:source) { "self.foo\nself.bar" }
+
+    let(:mutations) do
+      mutations = []
+
+      # Mutation of each statement in block
+      mutations << "foo\nself.bar"
+      mutations << "self.foo\nbar"
+
+     ## Remove statement in block
+      mutations << [:block, 'self.foo'.to_sexp]
+      mutations << [:block, 'self.bar'.to_sexp]
+      mutations << [:block]
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+
+  context 'with one statement' do
+    let(:node) { Rubinius::AST::Block.new(1, ['self.foo'.to_ast]) }
+
+    let(:mutations) do
+      mutations = []
+      mutations << [:block, 'foo'.to_sexp]
+      mutations << [:block]
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, 'define' do
+
+  context 'with no arguments' do
+    let(:source) { 'def foo; self.bar; self.baz; end' }
+
+    let(:mutations) do
+      mutations = []
+
+      # Mutation of each statement in block
+      mutations << 'def foo; bar; self.baz; end'
+      mutations << 'def foo; self.bar; baz; end'
+
+      # Remove statement in block
+      mutations << 'def foo; self.baz; end'
+      mutations << 'def foo; self.bar; end'
+
+      # Remove all statements
+      mutations << [:defn, :foo, [:args], [:scope, [:block]]]
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'define on singleton' do
+    let(:source) { 'def self.foo; self.bar; self.baz; end' }
+
+    let(:mutations) do
+      mutations = []
+
+      # Body presence mutations
+      mutations << 'def self.foo; bar; self.baz; end' 
+      mutations << 'def self.foo; self.bar; baz; end' 
+     
+      # Body presence mutations
+      mutations << 'def self.foo; self.bar; end'
+      mutations << 'def self.foo; self.baz; end'
+
+      # Remove all statements
+      mutations << [:defs, [:self], :foo, [:args], [:scope, [:block]]]
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, 'if statement' do
+  let(:source) { 'if self.condition; true; else false; end' }
+
+  let(:mutations) do
+    mutants = []
+
+    # mutations of condition
+    mutants << 'if condition; true; else false; end'
+
+    mutants << 'if !self.condition; true; else false; end'
+
+    # Deleted else branch
+    mutants << 'if self.condition; true end'
+
+    # Deleted if branch with promoting else branch to if branch
+    mutants << 'if self.condition; false end'
+
+    # mutations of body
+    mutants << 'if self.condition; false; else false; end' 
+    mutants << 'if self.condition; nil;   else false; end' 
+
+    # mutations of else body
+    mutants << 'if self.condition; true;  else true;  end' 
+    mutants << 'if self.condition; true;  else nil;   end' 
+  end
+
+  it_should_behave_like 'a mutator'
+end

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

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

data/spec/unit/mutant/mutator/node/literal/boolean/mutation_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Literal, 'boolean' do
+  context 'true literal' do
+    let(:source) { 'true' }
+
+    let(:mutations) do
+      %w(nil false)
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'false literal' do
+    let(:source) { 'false' }
+
+    let(:mutations) do
+      %w(nil true)
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+end