mutant 0.2.20 → 0.3.0.beta2

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

@@ -4,9 +4,7 @@ describe Mutant::Mutator::Node::Literal, 'nil' do
   let(:source) { 'nil' }
 
   let(:mutations) do
-    mutations = []
-
-    mutations << 'Object.new'
+    [ '::Object.new' ]
   end
 
   it_should_behave_like 'a mutator'

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

@@ -1,23 +1,15 @@
 require 'spec_helper'
 
 describe Mutant::Mutator::Node::Literal, 'regex' do
-  let(:random_string) { 'bar' }
 
   let(:source) { '/foo/' }
 
-  let(:base_mutations) do
+  let(: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/return/mutation_spec.rb

@@ -11,9 +11,13 @@ describe Mutant::Mutator, 'return' do
   end
 
   context 'return with value' do
-    let(:source) { 'return foo' }
+    let(:source) { 'return nil' }
 
-    let(:mutations) { ['foo'] }
+    let(:mutations) do
+      mutations = []
+      mutations << 'nil'
+      mutations << 'return ::Object.new'
+    end
 
     it_should_behave_like 'a mutator'
   end

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

@@ -2,129 +2,119 @@ require 'spec_helper'
 
 # FIXME: This spec needs to be structured better!
 describe Mutant::Mutator, 'send' do
-  context 'send without arguments' do
-    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
+  context 'index assign' do
+    let(:source) { 'foo[bar]=baz' }
 
-        it_should_behave_like 'a mutator'
-      end
-
-      context 'explicit with keyword message name' do
-        Mutant::KEYWORDS.each do |keyword|
-          context "with keyword: #{keyword}" do
-            let(:source) { "self.#{keyword}" }
-            it_should_behave_like 'a noop mutator'
-          end
-        end
-      end
+    let(:mutations) do
+      mutations = []
+      mutations << 'foo'
     end
 
-    context 'to some object' do
-      let(:source) { 'foo.bar' }
+    it_should_behave_like 'a mutator'
+  end
 
-      let(:mutations) do
-        mutations = []
-        mutations << 'foo'
-      end
 
-      it_should_behave_like 'a mutator'
+  context 'with only a splat arg' do
+    let(:source) { 'foo(*bar)' }
+
+    let(:mutations) do
+      mutations = []
+      mutations << 'foo'
     end
 
-    context 'to self.class.foo' do
-      let(:source) { 'self.class.foo' }
+    it_should_behave_like 'a mutator'
+  end
 
-      let(:mutations) do
-        mutations = []
-        mutations << 'self.class'
-      end
+  context 'with only a block arg' do
+    let(:source) { 'foo(&bar)' }
 
-      it_should_behave_like 'a mutator'
+    let(:mutations) do
+      mutations = []
+      mutations << 'foo'
     end
+
+    it_should_behave_like 'a mutator'
   end
 
-  context 'with block' do
-    let(:source) { 'foo() { a; b }' }
+  context 'single splat arg splat' do
+    let(:source) { 'foo[*bar]' }
 
-    let(:mutations) do 
+    let(:mutations) do
       mutations = []
-      mutations << 'foo() { a }'
-      mutations << 'foo() { b }'
-      mutations << 'foo() { }'
       mutations << 'foo'
     end
 
     it_should_behave_like 'a mutator'
   end
 
-  context 'with block args' do
-
-    let(:source) { 'foo { |a, b| }' }
+  context 'with self as' do
+    context 'implicit' do
+      let(:source) { 'foo' }
 
-    before do
-      Mutant::Random.stub(:hex_string => :random)
+      it_should_behave_like 'a noop mutator'
     end
 
-    let(:mutations) do 
-      mutations = []
-      mutations << 'foo'
-      mutations << 'foo { |a, b| Object.new }'
-      mutations << 'foo { |a, srandom| }'
-      mutations << 'foo { |srandom, b| }'
-      mutations << 'foo { |a| }'
-      mutations << 'foo { |b| }'
-      mutations << 'foo { || }'
+    context 'explict receiver' do
+      let(:source) { 'self.foo' }
+
+      let(:mutations) do
+        mutations = []
+        mutations << 'foo'
+        mutations << 'self'
+      end
+
+      it_should_behave_like 'a mutator'
     end
 
-    it_should_behave_like 'a mutator'
+    context 'explicit receiver with keyword message name' do
+      Unparser::Constants::KEYWORDS.each do |keyword|
+        context "with keyword: #{keyword}" do
+          let(:source) { "self.#{keyword}" }
+          let(:mutations) do
+            ['self']
+          end
+        end
+      end
+    end
   end
 
-  context 'with block pattern args' do
+  context 'without arguments' do
 
-    before do
-      Mutant::Random.stub(:hex_string => :random)
-    end
+    context 'to some object' do
+      let(:source) { 'foo.bar' }
 
-    let(:source) { 'foo { |(a, b), c| }' }
+      let(:mutations) do
+        mutations = []
+        mutations << 'foo'
+      end
 
-    let(:mutations) do 
-      mutations = []
-      mutations << 'foo { || }'
-      mutations << 'foo { |a, b, c| }'
-      mutations << 'foo { |(a, b), c| Object.new }'
-      mutations << 'foo { |(a, b)| }'
-      mutations << 'foo { |c| }'
-      mutations << 'foo { |(srandom, b), c| }'
-      mutations << 'foo { |(a, srandom), c| }'
-      mutations << 'foo { |(a, b), srandom| }'
-      mutations << 'foo'
+      it_should_behave_like 'a mutator'
     end
 
-    it_should_behave_like 'a mutator'
+    context 'to self.class.foo' do
+      let(:source) { 'self.class.foo' }
+
+      let(:mutations) do
+        mutations = []
+        mutations << 'self.class'
+        mutations << 'self.foo'
+      end
+
+      it_should_behave_like 'a mutator'
+    end
   end
 
-  context 'send with arguments' do
+  context 'with arguments' do
 
     context 'one argument' do
       let(:source) { 'foo(nil)' }
 
-      let(:mutations) do 
+      let(:mutations) do
         mutations = []
         mutations << 'foo'
         mutations << 'nil'
-        mutations << 'foo(Object.new)'
+        mutations << 'foo(::Object.new)'
       end
 
       it_should_behave_like 'a mutator'
@@ -133,28 +123,29 @@ describe Mutant::Mutator, 'send' do
     context 'with explicit self as receiver' do
       let(:source) { 'self.foo(nil)' }
 
-      let(:mutations) do 
+      let(:mutations) do
         mutations = []
+        mutations << 'self'
         mutations << 'self.foo'
         mutations << 'foo(nil)'
         mutations << 'nil'
-        mutations << 'self.foo(Object.new)'
+        mutations << 'self.foo(::Object.new)'
       end
 
       it_should_behave_like 'a mutator'
     end
 
     context 'to some object with keyword in method name' do
-      Mutant::KEYWORDS.each do |keyword|
+      Unparser::Constants::KEYWORDS.each do |keyword|
         context "with keyword #{keyword}" do
           let(:source) { "foo.#{keyword}(nil)" }
 
-          let(:mutations) do 
+          let(:mutations) do
             mutations = []
             mutations << "foo.#{keyword}"
-            mutations << "foo"
+            mutations << 'foo'
             mutations << 'nil'
-            mutations << "foo.#{keyword}(Object.new)"
+            mutations << "foo.#{keyword}(::Object.new)"
           end
 
           it_should_behave_like 'a mutator'
@@ -162,37 +153,49 @@ describe Mutant::Mutator, 'send' do
       end
     end
 
-    context 'binary operator methods' do
-      Mutant::BINARY_METHOD_OPERATORS.each do |operator|
-        let(:source) { "true #{operator} false" }
-
-        let(:mutations) do 
-          mutations = []
-          mutations << "((false) #{operator} (false))"
-          mutations << "((nil) #{operator} (false))"
-          mutations << "((true) #{operator} (true))"
-          mutations << "((true) #{operator} (nil))"
-          mutations << 'true'
-          mutations << 'false'
-        end
-
-        it_should_behave_like 'a mutator'
-      end
-    end
-
     context 'two arguments' do
       let(:source) { 'foo(nil, nil)' }
 
-      let(:mutations) do 
+      let(:mutations) do
         mutations = []
         mutations << 'foo()'
         mutations << 'foo(nil)'
-        mutations << 'foo(Object.new, nil)'
-        mutations << 'foo(nil, Object.new)'
+        mutations << 'foo(::Object.new, nil)'
+        mutations << 'foo(nil, ::Object.new)'
       end
 
       it_should_behave_like 'a mutator'
     end
 
+    context 'binary operator methods' do
+      Mutant::BINARY_METHOD_OPERATORS.each do |operator|
+        context 'on literal scalar arguments' do
+          let(:source) { "true #{operator} false" }
+
+          let(:mutations) do
+            mutations = []
+            mutations << "false #{operator} false"
+            mutations << "nil   #{operator} false"
+            mutations << "true  #{operator} true"
+            mutations << "true  #{operator} nil"
+            mutations << 'true'
+            mutations << 'false'
+          end
+
+          it_should_behave_like 'a mutator'
+        end
+
+        context 'on non literal scalar arguments' do
+          let(:source) { "left #{operator} right" }
+          let(:mutations) do
+            mutations = []
+            mutations << 'left'
+            mutations << 'right'
+          end
+
+          it_should_behave_like 'a mutator'
+        end
+      end
+    end
   end
 end

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

@@ -19,21 +19,6 @@ describe Mutant::Mutator, 'super' do
     it_should_behave_like 'a mutator'
   end
 
-  context 'with explicit empty arguments and block' do
-    let(:source) { 'super() { foo; bar }' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'super() { foo }'
-      mutations << 'super() { bar }'
-      mutations << 'super() { }'
-      mutations << 'super()'
-      mutations << 'super'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
   context 'super with arguments' do
     let(:source) { 'super(foo, bar)' }
 
@@ -47,22 +32,4 @@ describe Mutant::Mutator, 'super' do
 
     it_should_behave_like 'a mutator'
   end
-
-  context 'super with arguments and block' do
-    let(:source) { 'super(foo, bar) { foo; bar }' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'super(foo, bar) { foo; }'
-      mutations << 'super(foo, bar) { bar; }'
-      mutations << 'super(foo, bar) { nil }'
-      mutations << 'super(foo, bar)'
-      mutations << 'super'
-      mutations << 'super(foo) { foo; bar }'
-      mutations << 'super(bar) { foo; bar }'
-      mutations << 'super() { foo; bar }'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
 end

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

@@ -9,9 +9,9 @@ describe Mutant::Mutator::Node::While do
       mutations = []
       mutations << 'while true; bar; end'
       mutations << 'while true; foo; end'
-      mutations << 'while true; nil; end'
+      mutations << 'while true; end'
       mutations << 'while false; foo; bar; end'
-      mutations << 'while nil; foo; bar; end'
+      mutations << 'while nil;   foo; bar; end'
     end
 
     it_should_behave_like 'a mutator'

data/spec/unit/mutant/runner/config/subjects_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Mutant::Runner::Config, '#subjects' do
+  let(:object) { described_class.run(config) }
+
+  subject { object.subjects }
+
+  let(:config) do
+    mock(
+      'Config',
+      :subjects => [mutation_subject],
+      :strategy => strategy,
+      :reporter => reporter
+    )
+  end
+
+  let(:reporter)         { mock('Reporter')         }
+  let(:strategy)         { mock('Strategy')         }
+  let(:mutation_subject) { mock('Mutation subject') }
+  let(:subject_runner)   { mock('Subject runner')   }
+
+  class DummySubjectRunner
+    include Concord::Public.new(:config, :mutation)
+
+    def self.run(*args); new(*args); end
+  end
+
+  before do
+    strategy.stub(:setup)
+    strategy.stub(:teardown)
+    reporter.stub(:report => reporter)
+    stub_const('Mutant::Runner::Subject', DummySubjectRunner)
+  end
+
+  it { should eql([DummySubjectRunner.new(object, mutation_subject)]) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/mutant/runner/config/success_predicate_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Mutant::Runner::Config, '#success?' do
+  subject { object.success? }
+
+  let(:object) { described_class.run(config) }
+
+  let(:config) do
+    mock(
+      'Config',
+      :reporter => reporter,
+      :strategy => strategy,
+      :subjects => subjects
+    )
+  end
+
+  let(:reporter)  { mock('Reporter')                    }
+  let(:strategy)  { mock('Strategy')                    }
+  let(:subjects)  { [subject_a, subject_b]              }
+  let(:subject_a) { mock('Subject A', :fails? => false) }
+  let(:subject_b) { mock('Subject B', :fails? => false) }
+
+  class DummySubjectRunner
+    include Concord::Public.new(:config, :subject)
+
+    def self.run(*args)
+      new(*args)
+    end
+
+    def failed?
+      @subject.fails?
+    end
+  end
+
+  before do
+    stub_const('Mutant::Runner::Subject', DummySubjectRunner)
+    reporter.stub(:report => reporter)
+    strategy.stub(:setup)
+    strategy.stub(:teardown)
+  end
+
+  context 'without failed subjects' do
+    it { should be(true) }
+  end
+
+  context 'with failing subjects' do
+    before do
+      subject_a.stub(:fails? => true)
+    end
+
+    it { should be(false) }
+  end
+end

data/spec/unit/mutant/runner/failed_predicte_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Mutant::Runner, '#failed?' do
+  subject { object.failed? }
+
+  let(:object) { class_under_test.run(config) }
+
+  let(:config) { mock('Config') }
+  let(:class_under_test) do
+    success = self.success
+
+    Class.new(described_class) do
+      define_method :success? do
+        success
+      end
+
+      define_method :run do
+      end
+    end
+  end
+
+  context 'when runner is successful' do
+    let(:success) { true }
+
+    it { should be(false) }
+  end
+
+  context 'when runner is NOT successful' do
+    let(:success) { false }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/mutant/runner/mutation/killer_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Mutant::Runner::Mutation, '#killer' do
+  let(:object) { described_class.run(config, mutation) }
+
+  let(:config) do
+    mock(
+      'Config',
+      :reporter => reporter,
+      :strategy => strategy
+    )
+  end
+
+  let(:reporter) { mock('Reporter') }
+  let(:mutation) { mock('Mutation') }
+  let(:strategy) { mock('Strategy') }
+  let(:killer)   { mock('Killer')   }
+
+  subject { object.killer }
+
+  before do
+    reporter.stub(:report => reporter)
+    strategy.stub(:kill => killer)
+  end
+
+  it 'should call configuration to identify strategy' do
+    config.should_receive(:strategy).with().and_return(strategy)
+    should be(killer)
+  end
+
+  it 'should run killer' do
+    strategy.should_receive(:kill).with(mutation).and_return(killer)
+    should be(killer)
+  end
+
+  it { should be(killer) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/mutant/runner/subject/success_predicate_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Mutant::Runner::Subject, '#success?' do
+  subject { object.success? }
+
+  let(:object) { described_class.run(config, mutation_subject) }
+
+  let(:reporter)         { mock('Reporter')                      }
+  let(:mutation_subject) { mock('Subject', :map => mutations)    }
+  let(:config)           { mock('Config', :reporter => reporter) }
+  let(:mutation_a)       { mock('Mutation A', :failed? => false) }
+  let(:mutation_b)       { mock('Mutation B', :failed? => false) }
+  let(:mutations)        { [mutation_a, mutation_b]              }
+
+  before do
+    reporter.stub(:report => reporter)
+  end
+
+  class DummyMutationRunner
+    include Concord::Public.new(:config, :mutation)
+
+    def self.run(*args)
+      new(*args)
+    end
+
+    def failed?
+      @mutation.failed?
+    end
+  end
+
+  before do
+    stub_const('Mutant::Runner::Mutation', DummyMutationRunner)
+  end
+
+  context 'without evil failed mutations' do
+    it { should be(true) }
+  end
+
+  context 'with failing noop mutation' do
+  end
+
+  context 'with failing evil mutations' do
+    before do
+      mutation_a.stub(:failed? => true)
+    end
+
+    it { should be(false) }
+  end
+end

data/spec/unit/mutant/strategy/method_expansion/class_methods/run_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Mutant::Strategy::MethodExpansion, '.run' do
+  subject { object.run(name) }
+
+  let(:object) { described_class }
+
+  context 'unexpandable and unmapped name' do
+    let(:name) { :foo }
+
+    it { should be(:foo) }
+  end
+
+  context 'expanded name' do
+
+    context 'predicate' do
+      let(:name) { :foo? }
+
+      it { should be(:foo_predicate) }
+    end
+
+    context 'writer' do
+      let(:name) { :foo= }
+
+      it { should be(:foo_writer) }
+    end
+
+    context 'bang' do
+      let(:name) { :foo! }
+
+      it { should be(:foo_bang) }
+    end
+
+  end
+
+  context 'operator expansions' do
+
+    Mutant::OPERATOR_EXPANSIONS.each do |name, expansion|
+      context "#{name}" do
+        let(:name) { name }
+
+        it "should expand to #{expansion}" do
+          should be(expansion)
+        end
+      end
+    end
+
+  end
+end