mutant 0.1.1 → 0.2.0

data/spec/mutant/literal_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Literal do
-  describe '.literal_class' do
-    context 'given an instance of Rubinius::AST::TrueLiteral' do
-      let(:true_literal) { Rubinius::AST::TrueLiteral.new(1) }
-
-      it 'returns the Mutant::Rbx::Literal::TrueLiteral class' do
-        Mutant::Literal.literal_class(true_literal).should eq(
-          Mutant::Literal::TrueLiteral
-        )
-      end
-    end
-  end
-
-  describe '#swap' do
-    context 'initialized with an instance of Rubinius::AST::TrueLiteral' do
-      let(:true_literal) { Rubinius::AST::TrueLiteral.new(1) }
-
-      it 'calls Mutant::Rbx::Literal::TrueLiteral#swap' do
-        Mutant::Literal::TrueLiteral.should_receive(:new).with(true_literal) {
-          double(Mutant::Literal::TrueLiteral, :swap => true)
-        }
-        Mutant::Literal.new(true_literal).swap
-      end
-    end
-  end
-
-  describe Mutant::Literal::FalseLiteral do
-    describe '#swap' do
-      let(:node) { double('node', :line => 1) }
-
-      it 'returns an instance of Rubinius::AST::TrueLiteral' do
-        Mutant::Literal::FalseLiteral.new(node).swap.should be_an_instance_of(
-          Rubinius::AST::TrueLiteral
-        )
-      end
-    end
-  end
-
-  describe Mutant::Literal::TrueLiteral do
-    describe '#swap' do
-      let(:node) { double('node', :line => 1) }
-
-      it 'returns an instance of Rubinius::AST::FalseLiteral' do
-        Mutant::Literal::TrueLiteral.new(node).swap.should be_an_instance_of(
-          Rubinius::AST::FalseLiteral
-        )
-      end
-    end
-  end
-
-  describe Mutant::Literal::SymbolLiteral do
-    describe '#swap' do
-      let(:node) { double('node') }
-
-      it "sets the node's value to a random symbol" do
-        node.should_receive(:value=).with(instance_of(Symbol))
-        Mutant::Literal::SymbolLiteral.new(node).swap.should eq(node)
-      end
-    end
-  end
-
-  describe Mutant::Literal::StringLiteral do
-    describe '#swap' do
-      let(:node) { double('node') }
-
-      it "sets the node's string to a random string" do
-        node.should_receive(:string=).with(instance_of(String))
-        Mutant::Literal::StringLiteral.new(node).swap.should eq(node)
-      end
-    end
-  end
-
-  describe Mutant::Literal::FixnumLiteral do
-    describe '#swap' do
-      let(:node) { double('node') }
-
-      it "sets the node's value to a random fixnum" do
-        node.should_receive(:value=).with(instance_of(Fixnum))
-        Mutant::Literal::FixnumLiteral.new(node).swap.should eq(node)
-      end
-    end
-  end
-
-  describe Mutant::Literal::FloatLiteral do
-    describe '#swap' do
-      let(:node) { double('node') }
-
-      it "sets the node's value to a random float" do
-        node.should_receive(:value=).with(instance_of(Float))
-        Mutant::Literal::FloatLiteral.new(node).swap.should eq(node)
-      end
-    end
-  end
-
-  describe Mutant::Literal::Range do
-    describe '#swap' do
-      let(:node) { double('node', :line => 1) }
-
-      it "sets the node's start and finish to an instance of Rubinius::AST::FixnumLiteral" do
-        node.should_receive(:start=).with(
-          instance_of(Rubinius::AST::FixnumLiteral)
-        )
-        node.should_receive(:finish=).with(
-          instance_of(Rubinius::AST::FixnumLiteral)
-        )
-        Mutant::Literal::Range.new(node).swap.should eq(node)
-      end
-    end
-  end
-
-  describe Mutant::Literal::LocalVariableAssignment do
-    describe '#swap' do
-      context "with the node's value set to an instance of Rubinius::AST::TrueLiteral" do
-        let(:node) do
-          double('node', :value => Rubinius::AST::TrueLiteral.new(1))
-        end
-
-        it "sets the node's value to an instance of Rubinius::AST::FalseLiteral" do
-          node.should_receive(:value=).with(
-            instance_of(Rubinius::AST::FalseLiteral)
-          )
-          Mutant::Literal::LocalVariableAssignment.new(node).swap.should eq(node)
-        end
-      end
-    end
-  end
-end

data/spec/mutant/mutatee_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Mutatee do
-  describe '#rbx_method' do
-    setup_thing do
-      def self.bar; end
-      def bar; end
-    end
-
-    context 'given an implementation for a singleton method' do
-      let(:implementation) { Mutant::Implementation.new('Thing.bar') }
-      let(:mutatee) { Mutant::Mutatee.new(implementation) }
-
-      it 'returns a SingletonMethod' do
-        mutatee.rbx_method.should be_an_instance_of(Mutant::SingletonMethod)
-      end
-    end
-
-    context 'given an implementation for an instance method' do
-      let(:implementation) { Mutant::Implementation.new('Thing#bar') }
-      let(:mutatee) { Mutant::Mutatee.new(implementation) }
-
-      it 'returns an InstanceMethod' do
-        mutatee.rbx_method.should be_an_instance_of(Mutant::InstanceMethod)
-      end
-    end
-  end
-end

data/spec/mutant/node_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Node do
-  let(:item) { double('item', :line => 1) }
-  let(:node) { Mutant::Node.new(item) }
-
-  describe '#line' do
-    it "returns the item's line" do
-      Mutant::Node.new(item).line.should eq 1
-    end
-  end
-
-  describe '#from' do
-    it "returns a Formatter instance with its item set to the node's item" do
-      formatter = node.from
-      formatter.should be_an_instance_of(Mutant::Formatter)
-      formatter.item.should eq(item)
-    end
-  end
-
-  describe '#to' do
-    it "returns a Formatter instance with its item set to the node's copy" do
-      formatter = node.to
-      formatter.should be_an_instance_of(Mutant::Formatter)
-      formatter.item.should eq(node.copy)
-    end
-  end
-
-  describe '#swap' do
-    let(:swap) { double('swap') }
-    let(:literal) { double('literal', :swap => swap) }
-
-    before do
-      Mutant::Literal.should_receive(:new).with(node.copy).and_return(literal)
-    end
-
-    it "sets the node's copy to a different Literal" do
-      expect { node.swap }.to change { node.copy }.to swap
-    end
-  end
-end

data/spec/mutant/random_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Random do
-  describe '.string' do
-    it 'returns a random string' do
-      Mutant::Random.string.should be_a(String)
-    end
-  end
-
-  describe '.symbol' do
-    it 'returns a random symbol' do
-      Mutant::Random.symbol.should be_a(Symbol)
-    end
-  end
-
-  describe '.fixnum' do
-    it 'returns a random fixnum' do
-      Mutant::Random.fixnum.should be_a(Fixnum)
-    end
-  end
-
-  describe '.float' do
-    it 'returns a random float' do
-      Mutant::Random.float.should be_a(Float)
-    end
-  end
-
-  describe '.range' do
-    it 'returns a random range' do
-      Mutant::Random.range.should be_a(Range)
-    end
-  end
-end

data/spec/mutant/reporter_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Reporter do
-  describe '.pluralize' do
-    context 'given "mutant" with a count of 1' do
-      it 'returns "mutant"' do
-        Mutant::Reporter.pluralize(1, 'mutant').should eq('mutant')
-      end
-    end
-
-    context 'given "mutant" with a count of 0' do
-      it 'returns "mutants"' do
-        Mutant::Reporter.pluralize(0, 'mutant').should eq('mutants')
-      end
-    end
-  end
-end

data/spec/mutant_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Mutant do
-  describe '.run' do
-    it 'runs the RSpec runner with the given arguments' do
-      Mutant::Runners::RSpec.should_receive(:run).with(:foo)
-      Mutant.run(:foo)
-    end
-  end
-
-  describe '.mutate' do
-    context 'given an implementation' do
-      let(:mutatee) { double('mutatee') }
-      let(:implementation) { double('implementation') }
-      let(:mutator) { double('mutator') }
-
-      before do
-        mutator.should_receive(:mutate)
-        implementation.should_receive(:mutatees).and_return([mutatee])
-      end
-
-      it "mutates each of the implementation's mutatees" do
-        Mutant::Mutator.should_receive(:new).with(mutatee).and_return(mutator)
-        Mutant.mutate(implementation)
-      end
-    end
-  end
-end

data/spec/support/example_group_helpers.rb

@@ -1,11 +0,0 @@
-module ExampleGroupHelpers
-  def setup_thing(&block)
-    before do
-      Object.const_set(:Thing, Class.new(&block))
-    end
-
-    after do
-      Object.send(:remove_const, :Thing) if Object.const_defined?(:Thing)
-    end
-  end
-end

data/spec/support/example_helpers.rb

@@ -1,5 +0,0 @@
-module ExampleHelpers
-  def mutate(cmd, fail_on_error = true)
-    run_simple "../../exe/mutate #{cmd}", fail_on_error
-  end
-end