mutant 0.3.1 → 0.3.2

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

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator, '#emit_new' do
-  subject { object.send(:emit_new) { generated } }
-
-  class Block
-    attr_reader :arguments
-
-    def called?
-      defined?(@arguments)
-    end
-
-    def call(*arguments)
-      @arguments = arguments
-    end
-  end
-
-  let(:object) { class_under_test.new(input, parent, block) }
-  let(:block)  { Block.new                                  }
-  let(:input)  { :input                                     }
-  let(:parent) { :parent                                    }
-
-  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 do
-        subject
-      end.to raise_error(
-        RuntimeError,
-        'New AST could not be generated after 3 attempts'
-      )
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator, '#emit' do
-  subject { object.send(:emit, generated) }
-
-  class Block
-    attr_reader :arguments
-
-    def called?
-      defined?(@arguments)
-    end
-
-    def call(*arguments)
-      @arguments = arguments
-    end
-  end
-
-  let(:object) { class_under_test.new(input, parent, block) }
-  let(:block)  { Block.new                                  }
-  let(:input)  { :input                                     }
-  let(:parent) { :parent                                    }
-
-  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/while/mutation_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::While do
-
-  context 'with more than one statement' do
-    let(:source) { 'while true; foo; bar; end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'while true; bar; end'
-      mutations << 'while true; foo; end'
-      mutations << 'while true; end'
-      mutations << 'while false; foo; bar; end'
-      mutations << 'while nil;   foo; bar; end'
-      mutations << 'while true;  foo; nil; end'
-      mutations << 'while true;  nil; bar; end'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end

data/spec/unit/mutant/node_helpers/n_not_spec.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::NodeHelpers, '#n_not' do
-  subject { object.n_not(node) }
-
-  let(:object) { Object.new.extend(described_class) }
-  let(:node)   { described_class::N_TRUE            }
-
-  it 'returns the negated node' do
-    expect(subject).to eq(parse('not true'))
-  end
-end

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

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Runner::Config, '#subjects' do
-  let(:object) { described_class.run(config) }
-
-  subject { object.subjects }
-
-  let(:config) do
-    double(
-      'Config',
-      class:    Mutant::Config,
-      subjects: [subject_a, subject_b],
-      strategy: strategy,
-      reporter: reporter
-    )
-  end
-
-  let(:reporter)  { double('Reporter')                }
-  let(:strategy)  { double('Strategy')                }
-  let(:subject_a) { double('Subject A')               }
-  let(:subject_b) { double('Subject B')               }
-  let(:runner_a)  { double('Runner A', stop?: stop_a) }
-  let(:runner_b)  { double('Runner B', stop?: stop_b) }
-
-  before do
-    strategy.stub(:setup)
-    strategy.stub(:teardown)
-    reporter.stub(report: reporter)
-    Mutant::Runner.stub(:run).with(config, subject_a).and_return(runner_a)
-    Mutant::Runner.stub(:run).with(config, subject_b).and_return(runner_b)
-  end
-
-  context 'without early stop' do
-    let(:stop_a) { false }
-    let(:stop_b) { false }
-
-    it { should eql([runner_a, runner_b]) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  context 'with early stop' do
-    let(:stop_a) { true  }
-    let(:stop_b) { false }
-
-    it { should eql([runner_a]) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-end

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

@@ -1,57 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Runner::Config, '#success?' do
-  subject { object.success? }
-
-  let(:object) { described_class.new(config) }
-
-  let(:config) do
-    double(
-      'Config',
-      reporter: reporter,
-      strategy: strategy,
-      subjects: [subject_a, subject_b]
-    )
-  end
-
-  let(:reporter)  { double('Reporter')  }
-  let(:strategy)  { double('Strategy')  }
-  let(:subject_a) { double('Subject A') }
-  let(:subject_b) { double('Subject B') }
-
-  let(:runner_a) do
-    double('Runner A', stop?: stop_a, success?: success_a)
-  end
-
-  let(:runner_b) do
-    double('Runner B', stop?: stop_b, success?: success_b)
-  end
-
-  before do
-    reporter.stub(report: reporter)
-    strategy.stub(:setup)
-    strategy.stub(:teardown)
-    Mutant::Runner.stub(:run).with(config, subject_a).and_return(runner_a)
-    Mutant::Runner.stub(:run).with(config, subject_b).and_return(runner_b)
-  end
-
-  context 'without failed subjects' do
-    let(:stop_a)    { false }
-    let(:stop_b)    { false }
-    let(:success_a) { true  }
-    let(:success_b) { true  }
-
-    it { should be(true) }
-  end
-
-  context 'with failing subjects' do
-    let(:stop_a)    { false }
-    let(:stop_b)    { false }
-    let(:success_a) { false }
-    let(:success_b) { true  }
-
-    it { should be(false) }
-  end
-end