mutant 0.0.1 → 0.1.0

data/spec/functional/singleton_method/float_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'Mutating floats' do
+  context 'for a singleton method' do
+    context 'that contains 42.05' do
+      before do
+        write_file 'life.rb', """
+          class Life
+            def self.answer
+              42.05
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that the return value is 42.05' do
+        before do
+          write_file 'spec/life_spec.rb', """
+            $: << '.'
+            require 'life'
+
+            describe 'Life.answer' do
+              specify { Life.answer.should eq(42.05) }
+            end
+          """
+          mutate 'Life.answer spec/life_spec.rb'
+        end
+
+        specify 'the mutation passes' do
+          all_output.should include('passed')
+        end
+      end
+
+      context 'with an expectation that the return value is a Float' do
+        before do
+          write_file 'spec/life_spec.rb', """
+            $: << '.'
+            require 'life'
+
+            describe 'Life.answer' do
+              specify { Life.answer.should be_a(Float) }
+            end
+          """
+          mutate 'Life.answer spec/life_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/functional/singleton_method/hash_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'Mutating hashes' do
+  context 'for a singleton method' do
+    context 'that contains {:foo => {:bar => 3}}' do
+      before do
+        write_file 'thing.rb', """
+          class Thing
+            def self.to_hash
+              {:foo => {:bar => 3}}
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that hash[:foo][:bar] is 3' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.to_hash' do
+              specify { Thing.to_hash[:foo][:bar].should eq(3) }
+            end
+          """
+          mutate 'Thing.to_hash spec/thing_spec.rb'
+        end
+
+        specify 'the mutation passes' do
+          all_output.should include('passed')
+        end
+      end
+
+      context 'with an expectation that hash[:foo][:bar] is a Fixnum' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.to_hash' do
+              specify { Thing.to_hash[:foo][:bar].should be_kind_of(Fixnum) }
+            end
+          """
+          mutate 'Thing.to_hash spec/thing_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/functional/singleton_method/if_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe 'Mutating If clauses' do
+  context 'for an instance method' do
+    context 'that contains an if-else that returns 42' do
+      before do
+        write_file 'life.rb', """
+          class Life
+            def self.answer
+              if true
+                42
+              else
+                24
+              end
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that the answer is 42' do
+        before do
+          write_file 'spec/life_spec.rb', """
+            $: << '.'
+            require 'life'
+
+            describe 'Life.answer' do
+              specify { Life.answer.should eq(42) }
+            end
+          """
+          run_simple '../../bin/mutate Life.answer spec/life_spec.rb'
+        end
+
+        specify 'the mutation passes' do
+          all_output.should include('passed')
+        end
+      end
+
+      context 'with an expectation that the answer is a Fixnum' do
+        before do
+          write_file 'spec/life_spec.rb', """
+            $: << '.'
+            require 'life'
+
+            describe 'Life.answer' do
+              specify { Life.answer.should be_kind_of(Fixnum) }
+            end
+          """
+          run_simple '../../bin/mutate Life.answer spec/life_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/functional/singleton_method/range_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'Mutating ranges' do
+  context 'for a singleton method' do
+    context 'that contains a..z' do
+      before do
+        write_file 'thing.rb', """
+          class Thing
+            def self.a_range
+              'a'..'z'
+            end
+          end
+        """
+      end
+
+      context "with an expectation that the return value is `'a'..'z'`" do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing#a_range' do
+              specify { Thing.a_range.should eq('a'..'z') }
+            end
+          """
+          mutate 'Thing.a_range spec/thing_spec.rb'
+        end
+
+        specify 'the mutation passes' do
+          all_output.should include('passed')
+        end
+      end
+
+      context "with an expectation that the return value is a range" do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.a_string' do
+              specify { Thing.a_range.should be_a(Range) }
+            end
+          """
+          mutate 'Thing.a_range spec/thing_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/functional/singleton_method/regex_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'Mutating regexen' do
+  context 'for a singleton method' do
+    context 'that contains `.*`' do
+      before do
+        write_file 'thing.rb', """
+          class Thing
+            def self.regex
+              /.*/
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that a string matches the regex' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.regex' do
+              specify do
+                'hello'.should match(Thing.regex)
+              end
+            end
+          """
+          mutate 'Thing.regex spec/thing_spec.rb'
+        end
+
+        specify 'the mutation passes' do
+          all_output.should include('passed')
+        end
+      end
+
+      context 'with an expectation that the regex is a Regexp' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.regex' do
+              specify { Thing.regex.should be_kind_of(Regexp) }
+            end
+          """
+          mutate 'Thing.regex spec/thing_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/functional/singleton_method/string_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'Mutating string' do
+  context 'for a singleton method' do
+    context 'that contains "foo"' do
+      before do
+        write_file 'thing.rb', """
+          class Thing
+            def self.a_string
+              'foo'
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that the return value is "foo"' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.a_string' do
+              specify { Thing.a_string.should eq('foo') }
+            end
+          """
+          mutate 'Thing.a_string spec/thing_spec.rb'
+        end
+
+        specify 'the mutation passes' do
+          all_output.should include('passed')
+        end
+      end
+
+      context 'with an expectation that the return value is a string' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.a_string' do
+              specify { Thing.a_string.should be_a(String) }
+            end
+          """
+          mutate 'Thing.a_string spec/thing_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/functional/singleton_method/symbol_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'Mutating symbols' do
+  context 'for a singleton method' do
+    context 'that contains :foo' do
+      before do
+        write_file 'thing.rb', """
+          class Thing
+            def self.a_symbol
+              :foo
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that the return value is :foo' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.a_symbol' do
+              specify { Thing.a_symbol.should eq(:foo) }
+            end
+          """
+          mutate 'Thing.a_symbol spec/thing_spec.rb'
+        end
+
+        specify 'the mutation passes' do
+          all_output.should include('passed')
+        end
+      end
+
+      context 'with an expectation that the return value is a symbol' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.a_symbol' do
+              specify { Thing.a_symbol.should be_a(Symbol) }
+            end
+          """
+          mutate 'Thing.a_symbol spec/thing_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/mutant/extensions_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Class do
+  describe '#basename' do
+    context 'when called on Thing::Spirit' do
+      setup_thing { class Spirit; end }
+
+      it 'returns "Spirit"' do
+        Thing::Spirit.basename.should eq('Spirit')
+      end
+    end
+  end
+end

data/spec/mutant/implementation_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+describe Mutant::Implementation do
+  describe '#scope_type' do
+    context 'given "Thing.alive?"' do
+      it 'returns :singleton' do
+        Mutant::Implementation.new('Thing.alive?').scope_type.should eq(:singleton)
+      end
+    end
+
+    context 'given "Thing#alive?"' do
+      it 'returns :instance' do
+        Mutant::Implementation.new('Thing#alive?').scope_type.should eq(:instance)
+      end
+    end
+  end
+
+  describe '#class_name' do
+    context 'given "Thing"' do
+      it 'returns "Thing"' do
+        Mutant::Implementation.new('Thing').class_name.should eq('Thing')
+      end
+    end
+
+    context 'given "Thing.alive?"' do
+      it 'returns "Thing"' do
+        Mutant::Implementation.new('Thing.alive?').class_name.should eq('Thing')
+      end
+    end
+
+    context 'given "Thing::Spirit#alive?"' do
+      it 'returns "Thing::Spirit"' do
+        Mutant::Implementation.new('Thing::Spirit#alive?').
+          class_name.should eq('Thing::Spirit')
+      end
+    end
+  end
+
+  describe '#method_scope' do
+    context 'given "Thing"' do
+      it 'returns nil' do
+        Mutant::Implementation.new('Thing').method_scope.should be_nil
+      end
+    end
+
+    context 'given "Thing.alive?"' do
+      it 'returns "."' do
+        Mutant::Implementation.new('Thing.alive?').method_scope.should eq('.')
+      end
+    end
+
+    context 'given "Thing#alive?"' do
+      it 'returns "#"' do
+        Mutant::Implementation.new('Thing#alive?').method_scope.should eq('#')
+      end
+    end
+  end
+
+  describe '#method_name' do
+    context 'given "Thing"' do
+      it 'returns nil' do
+        Mutant::Implementation.new('Thing').method_name.should be_nil
+      end
+    end
+
+    context 'given "Thing.alive?"' do
+      it 'returns "alive?"' do
+        Mutant::Implementation.new('Thing.alive?').method_name.should eq('alive?')
+      end
+    end
+
+    context 'given "Thing#alive?"' do
+      it 'returns "alive?"' do
+        Mutant::Implementation.new('Thing#alive?').method_name.should eq('alive?')
+      end
+    end
+  end
+
+  describe '#constant' do
+    context 'given "Thing"' do
+      setup_thing
+
+      let(:implementation) { Mutant::Implementation.new('Thing') }
+
+      it 'returns Thing' do
+        implementation.constant.should eq(Thing)
+      end
+    end
+
+    context 'given "Thing::Spirit"' do
+      setup_thing { class Spirit; end }
+
+      let(:implementation) { Mutant::Implementation.new('Thing::Spirit') }
+
+      it 'returns Thing::Spirit' do
+        implementation.constant.should eq(Thing::Spirit)
+      end
+    end
+  end
+
+  describe '#all_implementations' do
+    let(:implementation) { Mutant::Implementation.allocate }
+
+    before do
+      implementation.should_receive(:all_methods) { ['Thing.alive?'] }
+    end
+
+    let(:all_implementations) { implementation.all_implementations }
+
+    it 'returns an array of Implementation instances' do
+      all_implementations.should have(1).implementation
+      all_implementations.first.should be_a(Mutant::Implementation)
+    end
+  end
+
+  describe '#all_methods' do
+    let(:implementation) { Mutant::Implementation.allocate }
+
+    before do
+      implementation.stub(
+        :all_singleton_methods => [:a], :all_instance_methods => [:b]
+      )
+    end
+
+    it 'concatenates #all_singleton_methods and #all_instance_methods' do
+      implementation.all_methods.should eq([:a, :b])
+    end
+  end
+
+  describe '#all_singleton_methods' do
+    context 'given "Thing"' do
+      context 'and Thing has no singleton methods' do
+        setup_thing
+
+        it 'returns an empty array' do
+          Mutant::Implementation.new('Thing').all_singleton_methods.should be_empty
+        end
+      end
+
+      context 'and Thing has a singleton method' do
+        setup_thing do
+          def self.alive?() end
+        end
+
+        it 'returns the singleton method in an array' do
+          Mutant::Implementation.new('Thing').all_singleton_methods.should eq(
+            ['Thing.alive?']
+          )
+        end
+      end
+    end
+  end
+
+  describe '#all_instance_methods' do
+    context 'given "Thing"' do
+      context 'and Thing has no instance methods' do
+        setup_thing
+
+        it 'returns an empty array' do
+          Mutant::Implementation.new('Thing').all_instance_methods.should be_empty
+        end
+      end
+
+      context 'and Thing has an instance method named "alive?"' do
+        setup_thing do
+          def alive?() end
+        end
+
+        it 'returns "Thing#alive?" in an array' do
+          Mutant::Implementation.new('Thing').all_instance_methods.should eq(
+            ['Thing#alive?']
+          )
+        end
+      end
+    end
+  end
+
+  describe '#mutatees' do
+    context 'given "Thing.alive?"' do
+      let(:implementation) { Mutant::Implementation.new('Thing.alive?') }
+
+      it 'returns an array with one mutatee' do
+        implementation.mutatees.should have(1).mutatee
+        implementation.mutatees.first.should be_a(Mutant::Mutatee)
+      end
+    end
+
+    context 'given "Thing#alive?"' do
+      let(:implementation) { Mutant::Implementation.new('Thing#alive?') }
+
+      it 'returns an array with one mutatee' do
+        implementation.mutatees.should have(1).mutatee
+        implementation.mutatees.first.should be_a(Mutant::Mutatee)
+      end
+    end
+
+    context 'given "Thing"' do
+      context 'and Thing has no methods' do
+        setup_thing
+
+        it 'returns an empty array' do
+          Mutant::Implementation.new('Thing').mutatees.should be_empty
+        end
+      end
+
+      context 'and Thing has a singleton and instance method' do
+        setup_thing do
+          def self.alive?() end
+          def alive?() end
+        end
+
+        let(:implementation) { Mutant::Implementation.new('Thing') }
+
+        it 'returns an array with two mutatees' do
+          implementation.should have(2).mutatees
+          implementation.mutatees.each do |mutatee|
+            mutatee.should be_a(Mutant::Mutatee)
+          end
+        end
+      end
+    end
+  end
+end