mutant 0.0.1 → 0.1.0

data/lib/mutant/node.rb

@@ -0,0 +1,26 @@
+module Mutant
+  class Node
+    attr_reader :item, :copy
+
+    def initialize(item)
+      @item = item
+      @copy = item.clone
+    end
+
+    def line
+      item.line
+    end
+
+    def from
+      @from ||= Formatter.new(item)
+    end
+
+    def to
+      @to ||= Formatter.new(copy)
+    end
+
+    def swap
+      @copy = Literal.new(copy).swap
+    end
+  end
+end

data/lib/mutant/random.rb

@@ -0,0 +1,37 @@
+module Mutant
+  class Random
+    ALLOWED_SYMBOL_CHARACTERS = Array('a'..'z') + Array('A'..'Z')
+    RANDOM_METHOD = Rubinius.ruby19? ? :sample : :choice
+
+    def self.string
+      ENV.fetch('RANDOM_STRING') {
+        Array.new(rand(50)) { rand(126).chr }.join
+      }
+    end
+
+    def self.symbol
+      ENV.fetch('RANDOM_SYMBOL') {
+        Array.new(rand(50).next) { ALLOWED_SYMBOL_CHARACTERS.send RANDOM_METHOD }.join
+      }.to_sym
+    end
+
+    def self.fixnum
+      ENV.fetch('RANDOM_FIXNUM') { rand(100) }
+    end
+
+    def self.float
+      ENV.fetch('RANDOM_FLOAT') { (rand(100) + 0.5) }
+    end
+
+    def self.range
+      if ENV['RANDOM_RANGE_MIN'] and ENV['RANDOM_RANGE_MAX']
+        min, max = ENV['RANDOM_RANGE_MIN'].to_i, ENV['RANDOM_RANGE_MAX'].to_i
+      else
+        min, max = rand(50)
+        max = min + rand(50)
+      end
+
+      Range.new(min, max)
+    end
+  end
+end

data/lib/mutant/reporter.rb

@@ -0,0 +1,38 @@
+module Mutant
+  class Reporter
+    WIDTH = 70
+
+    def self.mutating(mutation)
+      puts "Mutating line #{mutation.line}"
+      puts "  #{mutation.from} >>>#{mutation.to.nested? ? "\n  " : " "}#{mutation.to}"
+      puts
+    end
+
+    def self.method_loaded(mutatee)
+      info "#{mutatee} loaded with #{mutatee.mutations.size} " \
+           "possible #{pluralize(mutatee.mutations.size, 'mutation')}"
+    end
+
+    def self.no_mutations(mutatee)
+      warning "#{mutatee} has no possible mutations"
+    end
+
+    def self.info(message)
+      puts "*" * WIDTH
+      puts "***  #{message}"
+      puts "*" * WIDTH
+      puts
+    end
+
+    def self.warning(message)
+      puts "!" * WIDTH
+      puts "!!!  #{message}"
+      puts "!" * WIDTH
+      puts
+    end
+
+    def self.pluralize(count, singular, plural = nil)
+      count == 1 ? singular : plural || singular.insert(-1, 's')
+    end
+  end
+end

data/lib/mutant/runners/rspec.rb

@@ -2,11 +2,33 @@ require 'rspec/core'
 
 module Mutant
   module Runners
-    module RSpec
-      def self.run(args, output)
-        raise ::RSpec::Core::Runner.run(args, $stderr, output).inspect
-        output.puts 'passed'
+    class RSpec
+      ABORT_MESSAGE = 'Initial run of specs failed... fix and run mutant again'
+
+      def self.run(args)
+        runner = new(args)
+        runner.initial_run
+        runner.mutate
+        puts runner.run.zero? ? 'failed' : 'passed'
+      end
+
+      def initialize(args)
+        @implementation = Implementation.new(args.shift)
+        @args = args
+      end
+
+      def initial_run
+        abort ABORT_MESSAGE unless run.zero?
+      end
+
+      def run
+        ::RSpec::Core::Runner.run(@args)
+      end
+
+      def mutate
+        Mutant.mutate(@implementation)
       end
     end
   end
 end
+

data/lib/mutant/version.rb

@@ -1,3 +1,3 @@
 module Mutant
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/mutant.gemspec

@@ -5,8 +5,8 @@ require "mutant/version"
 Gem::Specification.new do |s|
   s.name        = 'mutant'
   s.version     = Mutant::VERSION
-  s.authors     = ["Justin Ko"]
-  s.email       = ["jko170@gmail.com"]
+  s.authors     = ["Justin Ko", "Josep M. Bach"]
+  s.email       = ["justin@kospecinc.com", "josep.m.bach@gmail.com"]
   s.homepage    = ""
   s.summary     = %q{Mutation tester}
   s.description = %q{Mutation tester}
@@ -15,9 +15,11 @@ Gem::Specification.new do |s|
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- spec/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.bindir        = 'exe'
+  s.executables   = `git ls-files -- exe/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.add_runtime_dependency 'to_source'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '~> 2.7'
   s.add_development_dependency 'aruba'

data/spec/functional/class_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'Mutating a class' do
+  before do
+    write_file 'thing.rb', """
+      class Thing
+        def alive?; true end
+        def dead?; false end
+        def mood; :happy end
+        def gender; 'male' end
+        def alphabet_range; 'a'..'k' end
+      end
+    """
+    write_file 'spec/thing_spec.rb', """
+      $: << '.'
+      require 'thing'
+
+      describe Thing do
+        describe '#alive?' do
+          specify { Thing.new.should be_alive }
+        end
+
+        describe '#dead?' do
+          specify { Thing.new.should_not be_dead }
+        end
+
+        describe '#mood' do
+          specify { Thing.new.mood.should eq(:happy) }
+        end
+
+        describe '#gender' do
+          specify { Thing.new.gender.should eq('male') }
+        end
+
+        describe '#alphabet_range' do
+          specify { Thing.new.alphabet_range.should eq('a'..'k') }
+        end
+      end
+    """
+    mutate 'Thing spec/thing_spec.rb'
+  end
+
+  it 'runs all possible mutations' do
+    all_output.should include('passed')
+  end
+end

data/spec/functional/instance_method/array_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'Mutating arrays' do
+  context 'for an instance method' do
+    context 'that contains [1,2,3]' do
+      before do
+        write_file 'thing.rb', """
+          class Thing
+            def to_a
+              [1,2,3]
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that the array is [1,2,3]' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing#to_a' do
+              specify { Thing.new.to_a.should eq([1,2,3]) }
+            end
+          """
+          mutate 'Thing#to_a spec/thing_spec.rb'
+        end
+
+        specify 'the mutation passes' do
+          all_output.should include('passed')
+        end
+      end
+
+      context 'with an expectation that the array responds to length' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing#to_a' do
+              specify { Thing.new.to_a.should respond_to(:length) }
+            end
+          """
+          mutate 'Thing#to_a spec/thing_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/functional/instance_method/boolean_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe 'Mutating booleans' do
+  context 'for an instance method' do
+    context 'that contains `true`' do
+      before do
+        write_file 'thing.rb', """
+          class Thing
+            def alive?
+              true
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that the return value is true' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing#alive?' do
+              specify { Thing.new.should be_alive }
+            end
+          """
+          mutate 'Thing#alive? 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 true or false' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing#alive?' do
+              specify { String(Thing.new.alive?).should =~ /true|false/ }
+            end
+          """
+          mutate 'Thing#alive? spec/thing_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+
+    context 'that contains `false`' do
+      before do
+        write_file 'thing.rb', """
+          class Thing
+            def alive?
+              false
+            end
+          end
+        """
+      end
+
+      context 'with an expectation that the return value is false' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing.alive?' do
+              specify { Thing.new.should_not be_alive }
+            end
+          """
+          mutate 'Thing#alive? 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 true or false' do
+        before do
+          write_file 'spec/thing_spec.rb', """
+            $: << '.'
+            require 'thing'
+
+            describe 'Thing#alive?' do
+              specify { String(Thing.new.alive?).should =~ /true|false/ }
+            end
+          """
+          mutate 'Thing#alive? spec/thing_spec.rb'
+        end
+
+        specify 'the mutation fails' do
+          all_output.should include('failed')
+        end
+      end
+    end
+  end
+end

data/spec/functional/instance_method/call_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe 'Mutating calls' do
+  context 'for an instance method' do
+    context 'that contains a method call without arguments' do
+      before do
+        write_file 'life.rb', """
+          class Life
+            def helper
+              42
+            end
+
+            def answer
+              helper
+            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.new.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 life respond to :answer' do
+        before do
+          write_file 'spec/life_spec.rb', """
+            $: << '.'
+            require 'life'
+
+            describe 'Life#answer' do
+              specify { Life.new.should respond_to(:answer) }
+            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
+
+    context 'that contains a method call with arguments' do
+      before do
+        write_file 'life.rb', """
+          class Life
+            def helper(num)
+              num + 2
+            end
+
+            def answer
+              helper(40)
+            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.new.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 life respond to :answer' do
+        before do
+          write_file 'spec/life_spec.rb', """
+            $: << '.'
+            require 'life'
+
+            describe 'Life#answer' do
+              specify { Life.new.should respond_to(:answer) }
+            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
+
+    context 'that contains a method call with a block' do
+      before do
+        write_file 'life.rb', """
+          class Life
+            def helper
+              yield
+            end
+
+            def answer
+              helper { 42 }
+            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.new.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 life respond to :answer' do
+        before do
+          write_file 'spec/life_spec.rb', """
+            $: << '.'
+            require 'life'
+
+            describe 'Life#answer' do
+              specify { Life.new.should respond_to(:answer) }
+            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