mutant 0.2.20 → 0.3.0.beta2

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

@@ -2,75 +2,89 @@ 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) 
+    expect { subject }.to raise_error(Mutant::CLI::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)         }
+  subject { cli.config }
+  its(:filter)   { should eql(expected_filter)   }
+  its(:strategy) { should eql(expected_strategy) }
+  its(:reporter) { should eql(expected_reporter) }
+  its(:matcher)  { should eql(expected_matcher)  }
 end
 
 describe Mutant::CLI, '.new' do
 
+  let(:object) { described_class }
+  let(:time)   { Time.now }
+
   before do
-    pending
+    Time.stub(:now => time)
   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) }
+  let(:expected_filter)   { Mutant::Mutation::Filter::ALL      }
+  let(:expected_strategy) { Mutant::Strategy::Rspec::Unit      }
+  let(:expected_reporter) { Mutant::Reporter::CLI.new($stdout) }
+
+  let(:cli) { object.new(arguments) }
+
+  subject { cli }
+
+  context 'with unknown flag' do
+    let(:arguments) { %w(--invalid) }
+
+    let(:expected_message) { 'invalid option: --invalid' }
 
-  subject { object.new(arguments) }
+    it_should_behave_like 'an invalid cli run'
+  end
 
   context 'with unknown option' do
     let(:arguments) { %w(--invalid Foo) }
 
-    let(:expected_message) { 'Unknown option: "--invalid"' }
+    let(:expected_message) { 'invalid option: --invalid' }
 
     it_should_behave_like 'an invalid cli run'
   end
 
+  context 'with many strategy flags' do
+    let(:arguments) { %w(--rspec-unit --rspec-dm2) }
+
+    let(:expected_strategy) { Mutant::Strategy::Rspec::DM2 }
+  end
+
   context 'without arguments' do
     let(:arguments) { [] }
 
-    let(:expected_message) { 'No matchers given' }
+    let(:expected_message) { 'No strategy was set!' }
 
     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' } 
+    let(:arguments)        { %w(--rspec-unit --code)    }
+    let(:expected_message) { 'missing argument: --code' }
 
     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') }
+    let(:arguments)        { %w(--rspec-unit TestApp::Literal#float)                       }
+    let(:expected_matcher) { Mutant::CLI::Classifier::Method.new('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|::))) }
+  context 'with namespace matcher' do
+    let(:arguments)        { %w(--rspec-unit ::TestApp*)                                     }
+    let(:expected_matcher) { Mutant::CLI::Classifier::Namespace::Recursive.new('::TestApp*') }
 
     it_should_behave_like 'a cli parser'
   end
 
   context 'with code filter' do
-    let(:arguments) { %w(--code faa --code bbb TestApp::Literal#float) }
+    let(:arguments) { %w(--rspec-unit --code faa --code bbb TestApp::Literal#float) }
 
     let(:filters) do
       [
@@ -79,8 +93,8 @@ describe Mutant::CLI, '.new' do
       ]
     end
 
-    let(:expected_matcher) { Mutant::Matcher::Method.parse('TestApp::Literal#float') }
-    let(:expected_filter)  { Mutant::Mutation::Filter::Whitelist.new(filters)        }
+    let(:expected_matcher) { Mutant::CLI::Classifier::Method.new('TestApp::Literal#float') }
+    let(:expected_filter)  { Mutant::Mutation::Filter::Whitelist.new(filters)              }
 
     it_should_behave_like 'a cli parser'
   end

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

@@ -3,36 +3,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 
+  let(:object)     { described_class                               }
+  let(:argv)       { mock('ARGV')                                  }
+  let(:attributes) { mock('Options')                               }
+  let(:runner)     { mock('Runner', :success? => success)          }
+  let(:config)     { mock('Config')                                }
+  let(:instance)   { mock(described_class.name, :config => config) }
+
+  before do
     described_class.stub(:new => instance)
-    Mutant::Runner.stub(:run => runner)
+    Mutant::Runner::Config.stub(:run => runner)
   end
 
-  context 'when runner does NOT fail' do
-    let(:failure) { false }
+  context 'when runner is successful' do
+    let(:success) { true }
 
     it { should be(0) }
 
     it 'should run with attributes' do
-      Mutant::Runner.should_receive(:run).with(instance).and_return(runner)
+      Mutant::Runner::Config.should_receive(:run).with(config).and_return(runner)
       should be(0)
     end
   end
 
   context 'when runner fails' do
-    let(:failure) { true }
+    let(:success) { false }
 
     it { should be(1) }
 
     it 'should run with attributes' do
-      Mutant::Runner.should_receive(:run).with(instance).and_return(runner)
+      Mutant::Runner::Config.should_receive(:run).with(config).and_return(runner)
       should be(1)
     end
   end
+
 end

data/spec/unit/mutant/cli/classifier/class_methods/build_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Mutant::CLI::Classifier, '.build' do
+  subject { described_class.build(input) }
+
+  this_spec = 'Mutant::CLI::Classifier.build'
+
+  shared_examples_for this_spec do
+    it 'shoud return expected instance' do
+      should eql(expected_class.new(expected_class::REGEXP.match(input)))
+    end
+  end
+
+  context 'with explicit toplevel scope' do
+
+    let(:input)           { '::TestApp::Literal#string' }
+    let(:expected_class)  { Mutant::CLI::Classifier::Method }
+
+    it_should_behave_like this_spec
+  end
+
+  context 'with instance method notation' do
+
+    let(:input)           { 'TestApp::Literal#string' }
+    let(:expected_class)  { Mutant::CLI::Classifier::Method }
+
+    it_should_behave_like this_spec
+  end
+
+  context 'with singleton method notation' do
+    let(:input)           { 'TestApp::Literal.string' }
+    let(:expected_class)  { Mutant::CLI::Classifier::Method }
+
+    it_should_behave_like this_spec
+  end
+
+  context 'with invalid notation' do
+    let(:input) { '::' }
+
+    it 'should return nil' do
+      should be(nil)
+    end
+  end
+end

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

@@ -5,13 +5,13 @@ describe Mutant::Context::Scope, '#root' do
 
   let(:object) { described_class.new(TestApp::Literal, path) }
   let(:path)   { mock('Path') }
-  let(:node)   { ':node'.to_ast } 
+  let(:node)   { parse(':node') }
 
   let(:scope)      { subject.body }
   let(:scope_body) { scope.body    }
 
   let(:expected_source) do
-    ToSource.to_source(<<-RUBY.to_ast)
+    generate(parse(<<-RUBY))
       module TestApp
         class Literal
           :node
@@ -21,11 +21,11 @@ describe Mutant::Context::Scope, '#root' do
   end
 
   let(:generated_source) do
-    ToSource.to_source(subject)
+    Unparser.unparse(subject)
   end
 
   let(:round_tripped_source) do
-    ToSource.to_source(expected_source.to_ast)
+    Unparser.unparse(parse(expected_source))
   end
 
   it 'should create correct source' do

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

@@ -4,9 +4,10 @@ describe Mutant::Killer::Rspec, '.new' do
 
   subject { object.new(strategy, mutation) }
 
-  let(:strategy) { mock('Strategy', :spec_files => ['foo'], :error_stream => $stderr, :output_stream => $stdout) }
-  let(:context)  { mock('Context')  }
-  let(:mutation) { mock('Mutation') }
+  let(:strategy)         { mock('Strategy', :spec_files => ['foo'], :error_stream => $stderr, :output_stream => $stdout) }
+  let(:context)          { mock('Context')                                }
+  let(:mutation)         { mock('Mutation', :subject => mutation_subject) }
+  let(:mutation_subject) { mock('Mutation Subject')                       }
 
   let(:object)  { described_class }
 
@@ -19,14 +20,14 @@ describe Mutant::Killer::Rspec, '.new' do
   context 'when run exits zero' do
     let(:exit_status) { 0 }
 
-    its(:fail?) { should be(true)  }
+    its(:killed?) { should be(false)  }
     it { should be_a(described_class) }
   end
 
   context 'when run exits nonzero' do
     let(:exit_status) { 1 }
 
-    its(:fail?) { should be(false)   }
+    its(:killed?) { should be(true)   }
     it { should be_a(described_class) }
   end
 end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Mutant::Killer, '#success?' do
+  subject { object.success? }
+
+  let(:object)           { class_under_test.new(strategy, mutation)  }
+  let(:strategy)         { mock('Strategy')                          }
+  let(:mutation)         { mock('Mutation', :success? => kill_state) }
+  let(:kill_state)       { mock('Kill State')                        }
+
+  before do
+    kill_state.stub(:freeze => kill_state, :dup => kill_state)
+  end
+
+  let(:class_under_test) do
+    Class.new(described_class) do
+      def run
+      end
+    end
+  end
+
+  it_should_behave_like 'an idempotent method'
+
+  it 'should use kill state to gather success' do
+    mutation.should_receive(:success?).with(object).and_return(kill_state)
+    should be(kill_state)
+  end
+end

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

@@ -26,7 +26,7 @@ describe Mutant::Loader::Eval, '.run' do
   end
 
   let(:node) do
-    source.to_ast
+    parse(source)
   end
 
   it 'should load nodes into vm' do

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

@@ -12,7 +12,7 @@ describe Mutant::Matcher::Chain, '#each' do
 
   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)

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

@@ -4,7 +4,7 @@ describe Mutant::Matcher::Chain, '#matchers' do
   subject { object.matchers }
 
   let(:object)   { described_class.new(matchers) }
-  let(:matchers) { mock('Matchers')              } 
+  let(:matchers) { mock('Matchers')              }
 
   it { should be(matchers) }
 

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

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Method::Instance, '#each' do
+  let(:object) { described_class.new(scope, method) }
+  let(:method) { scope.instance_method(method_name) }
+
+  let(:yields) { [] }
+
+  let(:namespace) do
+    klass = self.class
+  end
+
+  let(:scope) { self.class::Foo }
+
+  subject { object.each { |subject| yields << subject } }
+
+  let(:type)         { :def }
+  let(:method_name)  { :bar }
+  let(:method_arity) { 0    }
+
+  def name
+    node.children[0]
+  end
+
+  def arguments
+    node.children[1]
+  end
+
+  context 'when method is defined once' do
+    let(:base) { __LINE__ }
+    class self::Foo
+      def bar; end
+    end
+
+    let(:method_line) { 2 }
+
+    it_should_behave_like 'a method matcher'
+  end
+
+  context 'when method is defined multiple times' do
+    context 'on differend lines' do
+      let(:base) { __LINE__ }
+      class self::Foo
+        def bar; end
+        def bar(arg); end
+      end
+
+      let(:method_line)  { 3 }
+      let(:method_arity) { 1 }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'on the same line' do
+      let(:base) { __LINE__ }
+      class self::Foo
+        def bar; end; def bar(arg); end
+      end
+
+      let(:method_line)  { 2 }
+      let(:method_arity) { 1 }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'on the same line with differend scope' do
+      let(:base) { __LINE__ }
+      class self::Foo
+        def self.bar; end; def bar(arg); end
+      end
+
+      let(:method_line) { 2 }
+      let(:method_arity) { 1 }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'when nested' do
+      let(:pattern) { 'Foo::Bar#baz' }
+
+      context 'in class' do
+        let(:base) { __LINE__ }
+        class self::Foo
+          class Bar
+            def baz; end
+          end
+        end
+
+        let(:method_line) { 3 }
+        let(:method_name) { :baz }
+        let(:scope)       { self.class::Foo::Bar }
+
+        it_should_behave_like 'a method matcher'
+      end
+
+      context 'in module' do
+        let(:base) { __LINE__ }
+        module self::Foo
+          class Bar
+            def baz; end
+          end
+        end
+
+        let(:method_line) { 3 }
+        let(:method_name) { :baz }
+        let(:scope)       { self.class::Foo::Bar }
+
+        it_should_behave_like 'a method matcher'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Method::Singleton, '#each' do
+  let(:object) { described_class.new(scope, method) }
+  let(:method) { scope.method(method_name) }
+
+  let(:yields) { [] }
+
+  let(:namespace) do
+    klass = self.class
+  end
+
+  let(:scope) { self.class::Foo }
+
+  subject { object.each { |subject| yields << subject } }
+
+  let(:type)         { :defs }
+  let(:method_arity) { 0     }
+
+  def name
+    node.children[1]
+  end
+
+  def arguments
+    node.children[2]
+  end
+
+  context 'on singleton methods' do
+
+    context 'when defined on self' do
+      let(:base) { __LINE__ }
+      class self::Foo
+        def self.bar; end
+      end
+
+      let(:method_name) { :bar }
+      let(:method_line) { 2    }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'when defined on constant' do
+
+      context 'inside namespace' do
+        let(:base) { __LINE__ }
+        module self::Namespace
+          class Foo
+            def Foo.bar; end
+          end
+        end
+
+        let(:scope)       { self.class::Namespace::Foo }
+        let(:method_name) { :bar                       }
+        let(:method_line) { 3                          }
+
+        it_should_behave_like 'a method matcher'
+      end
+
+      context 'outside namespace' do
+        let(:base) { __LINE__ }
+        module self::Namespace
+          class Foo; end;
+          def Foo.bar; end
+        end
+
+        let(:method_name) { :bar }
+        let(:method_line) { 3    }
+        let(:scope)       { self.class::Namespace::Foo }
+
+        it_should_behave_like 'a method matcher'
+      end
+    end
+
+    context 'when defined multiple times in the same line' do
+      context 'with method on differend scope' do
+        let(:base) { __LINE__ }
+        module self::Namespace
+          module Foo; end
+          module Bar
+            def self.baz; end; def Foo.baz(arg); end
+          end
+        end
+
+        let(:scope)        { self.class::Namespace::Bar }
+        let(:method_name)  { :baz                       }
+        let(:method_line)  { 4                          }
+        let(:method_arity) { 0                          }
+
+        it_should_behave_like 'a method matcher'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Methods::Instance, '#each' do
+  let(:object) { described_class.new(Foo) }
+
+  subject { object.each { |matcher| yields << matcher } }
+
+  let(:yields) { [] }
+
+  module Bar
+    def method_d
+    end
+
+    def method_e
+    end
+  end
+
+  class Foo
+    include Bar
+
+    private :method_d
+
+  public
+
+    def method_a
+    end
+
+  protected
+
+    def method_b
+    end
+
+  private
+
+    def method_c
+    end
+
+  end
+
+  let(:subject_a) { mock('Subject A') }
+  let(:subject_b) { mock('Subject B') }
+  let(:subject_c) { mock('Subject C') }
+
+  let(:subjects) { [subject_a, subject_b, subject_c] }
+
+  before do
+    matcher = Mutant::Matcher::Method::Instance
+    matcher.stub(:new).with(Foo, Foo.instance_method(:method_a)).and_return([subject_a])
+    matcher.stub(:new).with(Foo, Foo.instance_method(:method_b)).and_return([subject_b])
+    matcher.stub(:new).with(Foo, Foo.instance_method(:method_c)).and_return([subject_c])
+  end
+
+  it 'should yield expected subjects' do
+    subject
+    yields.should eql(subjects)
+  end
+
+  it_should_behave_like 'an #each method'
+end

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Methods::Singleton, '#each' do
+  let(:object) { described_class.new(Foo) }
+
+  subject { object.each { |matcher| yields << matcher } }
+
+  let(:yields) { [] }
+
+  module Bar
+    def method_d
+    end
+
+    def method_e
+    end
+  end
+
+  class Foo
+    extend Bar
+
+    def self.method_a
+    end
+
+    def self.method_b
+    end
+    class << self; protected :method_b; end
+
+    def self.method_c
+    end
+    private_class_method :method_c
+
+  end
+
+  let(:subject_a) { mock('Subject A') }
+  let(:subject_b) { mock('Subject B') }
+  let(:subject_c) { mock('Subject C') }
+
+  let(:subjects) { [subject_a, subject_b, subject_c] }
+
+  before do
+    matcher = Mutant::Matcher::Method::Singleton
+    matcher.stub(:new).with(Foo, Foo.method(:method_a)).and_return([subject_a])
+    matcher.stub(:new).with(Foo, Foo.method(:method_b)).and_return([subject_b])
+    matcher.stub(:new).with(Foo, Foo.method(:method_c)).and_return([subject_c])
+  end
+
+  it 'should yield expected subjects' do
+    subject
+    yields.should eql(subjects)
+  end
+
+  it_should_behave_like 'an #each method'
+end