mutant 0.5.17 → 0.5.18

data/spec/unit/mutant/cli/classifier_spec.rb

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::CLI::Classifier, '.run' do
-  subject { described_class.run(cache, input) }
-
-  let(:cache) { double('Cache') }
-
-  this_spec = 'Mutant::CLI::Classifier.build'
-
-  shared_examples_for this_spec do
-    it 'shoud return expected instance' do
-      should eql(expected_matcher)
-    end
-
-    let(:expected_class) { Mutant::CLI::Classifier::Method }
-  end
-
-  context 'with explicit toplevel scope' do
-
-    let(:input) { '::TestApp::Literal#string' }
-
-    let(:expected_matcher) do
-      Mutant::Matcher::Method::Instance.new(cache, TestApp::Literal, TestApp::Literal.instance_method(:string))
-    end
-
-    include_examples this_spec
-  end
-
-  context 'with instance method notation' do
-
-    let(:input) { 'TestApp::Literal#string' }
-
-    let(:expected_matcher) do
-      Mutant::Matcher::Method::Instance.new(cache, TestApp::Literal, TestApp::Literal.instance_method(:string))
-    end
-
-    include_examples this_spec
-  end
-
-  context 'with singleton method notation' do
-    let(:input) { 'TestApp::Literal.string' }
-
-    let(:expected_matcher) do
-      Mutant::Matcher::Method::Singleton.new(cache, TestApp::Literal, TestApp::Literal.method(:string))
-    end
-
-    include_examples this_spec
-  end
-
-  context 'with invalid notation' do
-    let(:input) { '::' }
-
-    it 'should return nil' do
-      expect { subject }.to raise_error(Mutant::CLI::Error, "No matcher handles: #{input.inspect}")
-    end
-  end
-end

data/spec/unit/mutant/mutator/node/and_asgn_spec.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::OpAsgn, 'and_asgn' do
-  let(:source)  { 'a &&= 1' }
-
-  let(:mutations) do
-    mutations = []
-    mutations << 'a__mutant__ &&= 1'
-    mutations << 'a &&= nil'
-    mutations << 'a &&= 0'
-    mutations << 'a &&= -1'
-    mutations << 'a &&= 2'
-    mutations << 'nil'
-  end
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/mutator/node/begin_spec.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator, 'begin' do
-
-  # This mutation and only this mutation can result in
-  # and empty emit that is parsed into nil, unparser cannot
-  # handle this so we guard this here!
-  def generate(node)
-    return '' if node.nil?
-    super
-  end
-
-  let(:source) { "true\nfalse" }
-
-  let(:mutations) do
-    mutations = []
-
-    # Mutation of each statement in block
-    mutations << "true\ntrue"
-    mutations << "false\nfalse"
-    mutations << "nil\nfalse"
-    mutations << "true\nnil"
-
-    # Remove statement in block
-    mutations << 'true'
-    mutations << 'false'
-  end
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/mutator/node/binary_spec.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Binary, 'mutations' do
-  context 'and' do
-    let(:source) { 'true and false' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'true'
-      mutations << 'false'
-
-      mutations << 'true or false'
-
-      mutations << 'not true and false'
-      mutations << 'not(true and false)'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'or' do
-    let(:source) { 'true or false' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'true'
-      mutations << 'false'
-
-      mutations << 'true and false'
-
-      mutations << 'not true or false'
-      mutations << 'not(true or false)'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end

data/spec/unit/mutant/mutator/node/block_pass_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::NamedValue::Access, 'block_pass' do
-  let(:source) { 'foo(&bar)' }
-
-  let(:mutations) do
-    mutants = []
-    mutants << 'foo'
-    mutants << 'nil'
-  end
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/mutator/node/block_spec.rb

@@ -1,83 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator, 'block' do
-  context 'with block' do
-    let(:source) { 'foo() { a; b }' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo { a }'
-      mutations << 'foo { b }'
-      mutations << 'foo {}'
-      mutations << 'foo { raise }'
-      mutations << 'foo { a; nil }'
-      mutations << 'foo { nil; b }'
-      mutations << 'foo'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with block args' do
-
-    let(:source) { 'foo { |a, b| }' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo'
-      mutations << 'foo { |a, b| raise }'
-      mutations << 'foo { |a, b__mutant__| }'
-      mutations << 'foo { |a__mutant__, b| }'
-      mutations << 'foo { |a| }'
-      mutations << 'foo { |b| }'
-      mutations << 'foo { || }'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with block pattern args' do
-
-    let(:source) { 'foo { |(a, b), c| }' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo { || }'
-      mutations << 'foo { |a, b, c| }'
-      mutations << 'foo { |(a, b), c| raise }'
-      mutations << 'foo { |(a), c| }'
-      mutations << 'foo { |(b), c| }'
-      mutations << 'foo { |(a, b)| }'
-      mutations << 'foo { |c| }'
-      mutations << 'foo { |(a__mutant__, b), c| }'
-      mutations << 'foo { |(a, b__mutant__), c| }'
-      mutations << 'foo { |(a, b), c__mutant__| }'
-      mutations << 'foo'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with mini block pattern arg' do
-
-    let(:source) { 'foo { |(a)| }' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo { || }'
-      mutations << 'foo { |a| }'
-      mutations << 'foo { |(a)| raise }'
-      mutations << 'foo { |(a__mutant__)| }'
-      mutations << 'foo'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-
-  end
-end

data/spec/unit/mutant/mutator/node/blockarg_spec.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Blockarg, 'blockarg' do
-  let(:source)  { 'foo { |&bar| }' }
-
-  let(:mutations) do
-    mutations = []
-    mutations << 'foo { |&bar| raise }'
-    mutations << 'foo {}'
-    mutations << 'foo'
-    mutations << 'nil'
-  end
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/mutator/node/case_spec.rb

@@ -1,329 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Case do
-  context 'without condition' do
-    let(:source) do
-      <<-RUBY
-        case
-        when true
-        else
-        end
-      RUBY
-    end
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << <<-RUBY
-        case
-        when true
-          raise
-        else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case
-        when false
-        else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case
-        when nil
-        else
-        end
-      RUBY
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with multiple when branches' do
-    let(:source) do
-      <<-RUBY
-        case :condition
-        when :foo
-        when :bar, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-    end
-
-    let(:mutations) do
-      mutations = []
-
-      # Presence of branches
-      mutations << <<-RUBY
-        case :condition
-        when :bar, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar, :baz
-          :barbaz
-        end
-      RUBY
-
-      # Mutations of condition
-      mutations << <<-RUBY
-        case nil
-        when :foo
-        when :bar, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition__mutant__
-        when :foo
-        when :bar, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-
-      # Mutations of branch bodies
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-          raise
-        when :bar, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar, :baz
-          :barbaz__mutant__
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar, :baz
-          nil
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar, :baz
-          :barbaz
-        else
-          :else__mutant__
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar, :baz
-          :barbaz
-        else
-          nil
-        end
-      RUBY
-
-      # Mutations of when conditions
-      mutations << <<-RUBY
-        case :condition
-        when :foo__mutant__
-        when :bar, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when nil
-        when :bar, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar__mutant__, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when nil, :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar, nil
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar, :baz__mutant__
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :baz
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-        when :bar
-          :barbaz
-        else
-          :else
-        end
-      RUBY
-
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with one when branch' do
-    let(:source) do
-      <<-RUBY
-        case :condition
-        when :foo
-          :foo
-        else
-          :else
-        end
-      RUBY
-    end
-
-    let(:mutations) do
-      mutations = []
-
-      # Presence of branches
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-          :foo
-        end
-      RUBY
-
-      # Mutations of condition
-      mutations << <<-RUBY
-        case nil
-        when :foo
-          :foo
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition__mutant__
-        when :foo
-          :foo
-        else
-          :else
-        end
-      RUBY
-
-      # Mutations of branch bodies
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-          nil
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-          :foo__mutant__
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-          :foo
-        else
-          :else__mutant__
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when :foo
-          :foo
-        else
-          nil
-        end
-      RUBY
-
-      # Mutations of when conditions
-      mutations << <<-RUBY
-        case :condition
-        when :foo__mutant__
-          :foo
-        else
-          :else
-        end
-      RUBY
-      mutations << <<-RUBY
-        case :condition
-        when nil
-          :foo
-        else
-          :else
-        end
-      RUBY
-
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end