mutant 0.1.1 → 0.2.0

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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+shared_examples_for 'an invalid cli run' do
+  it 'should raise error' do
+    expect { subject }.to raise_error(described_class::Error, expected_message) 
+  end
+end
+
+shared_examples_for 'a cli parser' do
+  its(:filter)   { should eql(expected_filter) }
+  its(:killer)   { should eql(expected_killer)          }
+  its(:reporter) { should eql(expected_reporter)        }
+  its(:matcher)  { should eql(expected_matcher)         }
+end
+
+describe Mutant::CLI, '.new' do
+
+  before do
+    pending
+  end
+
+  let(:object) { described_class }
+
+  # Defaults
+  let(:expected_filter)          { Mutant::Mutation::Filter::ALL      }
+  let(:expected_killer)          { Mutant::Killer::Rspec::Forking     }
+  let(:expected_reporter)        { Mutant::Reporter::CLI.new($stderr) }
+
+  subject { object.new(arguments) }
+
+  context 'with unknown option' do
+    let(:arguments) { %w(--invalid Foo) }
+
+    let(:expected_message) { 'Unknown option: "--invalid"' }
+
+    it_should_behave_like 'an invalid cli run'
+  end
+
+  context 'without arguments' do
+    let(:arguments) { [] }
+
+    let(:expected_message) { 'No matchers given' }
+
+    it_should_behave_like 'an invalid cli run'
+  end
+
+  context 'with code filter and missing argument' do
+    let(:arguments) { %w(--rspec-unit --code) }
+
+    let(:expected_message) { '"--code" is missing an argument' } 
+
+    it_should_behave_like 'an invalid cli run'
+  end
+
+  context 'with explicit method matcher' do
+    let(:arguments) { %w(TestApp::Literal#float) }
+
+    let(:expected_matcher) { Mutant::Matcher::Method.parse('TestApp::Literal#float') }
+
+    it_should_behave_like 'a cli parser'
+
+  end
+
+  context 'with library name' do
+    let(:arguments) { %w(::TestApp) }
+    
+    let(:expected_matcher) { Mutant::Matcher::ObjectSpace.new(%r(\ATestApp(\z|::))) }
+
+    it_should_behave_like 'a cli parser'
+  end
+
+  context 'with code filter' do
+    let(:arguments) { %w(--code faa --code bbb TestApp::Literal#float) }
+
+    let(:filters) do
+      [
+        Mutant::Mutation::Filter::Code.new('faa'),
+        Mutant::Mutation::Filter::Code.new('bbb'),
+      ]
+    end
+
+    let(:expected_matcher) { Mutant::Matcher::Method.parse('TestApp::Literal#float') }
+    let(:expected_filter)  { Mutant::Mutation::Filter::Whitelist.new(filters)        }
+
+    it_should_behave_like 'a cli parser'
+  end
+end

data/spec/unit/mutant/cli/class_methods/run_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Mutant::CLI, '.run' do
+  subject { object.run(argv) }
+
+  let(:object)     { described_class                                       }
+  let(:argv)       { mock('ARGV')                                          }
+  let(:attributes) { mock('Options')                                       }
+  let(:runner)     { mock('Runner', :fail? => failure)                     }
+  let(:instance)   { mock(described_class.name, :attributes => attributes) }
+
+  before do 
+    described_class.stub(:new => instance)
+    Mutant::Runner.stub(:run => runner)
+  end
+
+  context 'when runner does NOT fail' do
+    let(:failure) { false }
+
+    it { should be(0) }
+
+    it 'should run with attributes' do
+      Mutant::Runner.should_receive(:run).with(instance).and_return(runner)
+      should be(0)
+    end
+  end
+
+  context 'when runner fails' do
+    let(:failure) { true }
+
+    it { should be(1) }
+
+    it 'should run with attributes' do
+      Mutant::Runner.should_receive(:run).with(instance).and_return(runner)
+      should be(1)
+    end
+  end
+end

data/spec/unit/mutant/context/root_spec.rb

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

data/spec/unit/mutant/context/scope/class_methods/build_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Mutant::Context::Scope, '.build' do
+  subject { described_class.build(constant, path) }
+
+  let(:object)  { described_class }
+  let(:context) { mock('Context') }
+  let(:path)    { mock('Path')    }
+
+  context 'when constant is a module' do
+    let(:constant) { Module.new }
+
+    it { should be_kind_of(described_class::Module) }
+  end
+
+  context 'when constant is a class' do
+    let(:constant) { Class.new }
+
+    it { should be_kind_of(described_class::Class) }
+  end
+
+  context 'when constant is not a class nor a module' do
+    let(:constant) { Object.new }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(ArgumentError, 'Can only build mutation scope from class or module got: Object')
+    end
+  end
+end

data/spec/unit/mutant/context/scope/root_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Mutant::Context::Scope, '#root' do
+  subject { object.root(node) }
+
+  let(:object) { described_class.build(TestApp::Literal, path) }
+  let(:path)   { mock('Path') }
+  let(:node)   { mock('Node') } 
+
+  let(:scope)      { subject.body }
+  let(:scope_body) { scope.body    }
+
+  it 'should wrap the ast under constant' do
+    scope.should be_kind_of(Rubinius::AST::ClassScope)
+  end
+
+  it 'should place the ast under scope inside of block' do
+    scope_body.should be_a(Rubinius::AST::Block)
+    scope_body.array.should eql([node])
+    scope_body.array.first.should be(node)
+  end
+end

data/spec/unit/mutant/context/scope/unqualified_name_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Mutant::Context::Scope, '#unqualified_name' do
+  subject { object.unqualified_name }
+
+  let(:path)   { mock('Path') }
+
+  context 'with top level constant name' do
+    let(:object) { described_class.build(TestApp, path) }
+
+    it 'should return the unqualified name' do
+      should eql('TestApp')
+    end
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'with scoped constant name' do
+    let(:object) { described_class.build(TestApp::Literal, path) }
+
+    it 'should return the unqualified name' do
+      should eql('Literal')
+    end
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/mutant/killer/fail_ques_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Mutant::Killer,'#fail?' do
+  subject { object.fail? }
+
+  let(:object)           { class_under_test.new(strategy, mutation) }
+  let(:strategy)         { mock('Strategy')                         }
+  let(:mutation)         { mock('Mutation')                         }
+
+  before do
+    mutation.stub(:insert)
+    mutation.stub(:reset)
+  end
+
+  let(:class_under_test) do
+    kill_state = self.kill_state
+    Class.new(described_class) do
+      define_method :run do
+        kill_state
+      end
+    end
+  end
+
+  context 'when mutant was killed' do
+    let(:kill_state) { true }
+    
+    it_should_behave_like 'an idempotent method'
+
+    it { should be(false) }
+  end
+
+  context 'when mutant was NOT killed' do
+    let(:kill_state) { false }
+    
+    it_should_behave_like 'an idempotent method'
+
+    it { should be(true) }
+  end
+end

data/spec/unit/mutant/killer/rspec/class_methods/new_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Mutant::Killer::Rspec, '.new' do
+
+  subject { object.new(strategy, mutation) }
+
+  let(:strategy) { mock('Strategy', :spec_files => ['foo']) }
+  let(:context)  { mock('Context')  }
+  let(:mutation) { mock('Mutation') }
+
+  let(:object)  { described_class }
+
+  before do
+    mutation.stub(:insert)
+    mutation.stub(:reset)
+    RSpec::Core::Runner.stub(:run => exit_status)
+  end
+
+  context 'when run exits zero' do
+    let(:exit_status) { 0 }
+
+    its(:fail?) { should be(true)  }
+    it { should be_a(described_class) }
+  end
+
+  context 'when run exits nonzero' do
+    let(:exit_status) { 1 }
+
+    its(:fail?) { should be(false)   }
+    it { should be_a(described_class) }
+  end
+end

data/spec/unit/mutant/loader/eval/class_methods/run_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Mutant::Loader::Eval, '.run' do
+
+  subject { object.run(node) }
+
+  let(:object) { described_class }
+
+  let(:source) do
+    # This test case will blow up when not executed
+    # under toplevel binding.
+    <<-RUBY
+      class SomeNamespace
+        class Bar
+        end
+
+        class SomeOther
+          class Foo < Bar
+          end
+        end
+      end
+    RUBY
+  end
+
+  let(:node) do
+    source.to_ast
+  end
+
+  it 'should load nodes into vm' do
+    subject
+    ::SomeNamespace::SomeOther::Foo
+  end
+end

data/spec/unit/mutant/loader/rubinius/class_methods/run_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Mutant::Loader::Rubinius, '.run' do
+  before do
+    pending
+  end
+
+  subject { object.run(node) }
+
+  let(:object) { described_class }
+
+  after do
+    Object.send(:remove_const, :SomeNamespace)
+  end
+
+  let(:source) do
+    # This test case will blow up when not executed
+    # under toplevel binding.
+    <<-RUBY
+      class SomeNamespace
+        class Bar
+        end
+
+        class SomeOther
+          class Foo < Bar
+          end
+        end
+      end
+    RUBY
+  end
+
+  let(:node) do
+    Rubinius::AST::Script.new(source.to_ast).tap do |source|
+      source.file = "/some/source"
+    end
+  end
+
+  it 'should load nodes into vm' do
+    subject
+    SomeNamespace::SomeOther::Foo
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Chain, '#each' do
+  subject { object.each { |entry| yields << entry } }
+
+  let(:object) { described_class.new(matchers) }
+
+  let(:matchers) { [matcher_a, matcher_b] }
+
+  let(:matcher_a) { mock('Matcher A') }
+  let(:matcher_b) { mock('Matcher B') }
+
+  let(:subject_a) { mock('Subject A') }
+  let(:subject_b) { mock('Subject B') }
+  
+  before do
+    matcher_a.stub(:each).and_yield(subject_a).and_return(matcher_a)
+    matcher_b.stub(:each).and_yield(subject_b).and_return(matcher_b)
+  end
+
+  # it_should_behave_like 'an #each 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
+
+  let(:yields) { [] }
+
+  it 'should yield subjects' do
+    expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
+  end
+end

data/spec/unit/mutant/matcher/chain/matchers_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Chain, '#matchers' do
+  subject { object.matchers }
+
+  let(:object)   { described_class.new(matchers) }
+  let(:matchers) { mock('Matchers')              } 
+
+  it { should be(matchers) }
+
+  it_should_behave_like 'an idempotent method'
+end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Mutant::Matcher, '.from_string' do
+  subject { object.from_string(input) }
+
+  let(:input)   { mock('Input')   }
+  let(:matcher) { mock('Matcher') }
+
+  let(:descendant_a) { mock('Descendant A', :parse => nil) }
+  let(:descendant_b) { mock('Descendant B', :parse => nil) }
+
+  let(:object) { described_class }
+
+  before do
+    described_class.stub(:descendants => [descendant_a, descendant_b])
+  end
+
+  context 'when no descendant takes the input' do
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'when one descendant handles input' do
+    before do
+      descendant_a.stub(:parse => matcher)
+    end
+
+    it { should be(matcher) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'when more than one descendant handles input' do
+    let(:matcher_b) { mock('Matcher B') }
+
+    before do
+      descendant_a.stub(:parse => matcher)
+      descendant_b.stub(:parse => matcher_b)
+    end
+
+    it 'should return the first matcher' do 
+      should be(matcher)
+    end
+
+    it_should_behave_like 'an idempotent method'
+  end
+end
+