mutiny 0.1.0

data/spec/support/in_example_project.rb

@@ -0,0 +1,17 @@
+require 'aruba/api'
+require 'aruba/reporting'
+
+module InExampleProject
+  def in_example_project(example_name, should_require = false)
+    in_sub_process do
+      $LOAD_PATH << File.join(Dir.pwd, "examples", example_name, "lib")
+      Dir.chdir(File.join("examples", example_name))
+      require example_name if should_require
+      yield
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include InExampleProject
+end

data/spec/support/shared_examples/shared_examples_for_an_operator_replacement_mutation.rb

@@ -0,0 +1,26 @@
+shared_examples "an operator replacement mutation" do |operators|
+  operators.each do |original_operator|
+    it "mutates #{original_operator} to every other operator" do
+      program = "foo #{original_operator} bar"
+      mutants = subject.mutate(program)
+      expected_mutants = operators
+                         .reject { |op| op == original_operator }
+                         .map { |op| program.gsub(original_operator.to_s, op.to_s) }
+
+      expect(mutants).to eq(expected_mutants)
+    end
+  end
+end
+
+shared_examples "an operator replacement mutation with extra replacements" do |replacements|
+  replacements.each do |original_operator, replacement_operators|
+    it "mutates #{original_operator} to every other operator" do
+      program = "foo #{original_operator} bar"
+      mutants = subject.mutate(program)
+      expected_mutants = replacement_operators
+                         .map { |op| program.gsub(original_operator.to_s, op.to_s) }
+
+      expect(mutants).to eq(expected_mutants)
+    end
+  end
+end

data/spec/unit/integration/rspec/parser_spec.rb

@@ -0,0 +1,23 @@
+module Mutiny
+  class Integration
+    class RSpec
+      describe Parser do
+        let(:test_set) { subject.call }
+
+        it "should be able to count tests" do
+          in_example_project("calculator") do
+            expect(test_set.size).to eq(6)
+            expect(test_set.empty?).to be_falsey
+          end
+        end
+
+        it "should be able to report that there are no tests" do
+          in_example_project("untested_calculator") do
+            expect(test_set.size).to eq(0)
+            expect(test_set.empty?).to be_truthy
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/integration/rspec/runner_spec.rb

@@ -0,0 +1,47 @@
+module Mutiny
+  class Integration
+    class RSpec
+      describe Runner do
+        let(:test_set) { Parser.new.call }
+        let(:test_run) { subject.call }
+        subject { Runner.new(test_set) }
+
+        it "should be able to run a passing test set" do
+          in_example_project("calculator") do
+            expect(test_run.passed?).to be_truthy
+            expect(test_run.failed_tests.empty?).to be_truthy
+          end
+        end
+
+        it "should be able to run a failing test set" do
+          in_example_project("buggy_calculator") do
+            expect(test_run.passed?).to be_falsey
+            expect(test_run.failed_tests.locations).to eq([
+              "./examples/buggy_calculator/spec/calculator/max_spec.rb:9",
+              "./examples/buggy_calculator/spec/calculator/max_spec.rb:13"
+            ])
+          end
+        end
+
+        it "should be able to run a partial test set" do
+          in_example_project("buggy_calculator") do
+            partial_test_set = test_set.take(1)
+            test_run = Runner.new(partial_test_set).call
+
+            # Note: This would be false if the whole test set was run
+            expect(test_run.passed?).to be_truthy
+          end
+        end
+
+        it "should be able to run an empty test set" do
+          in_example_project("calculator") do
+            test_run = Runner.new(TestSet.empty).call
+
+            expect(test_run.passed?).to be_truthy
+            expect(test_run.failed_tests.empty?).to be_truthy
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutant_set_spec.rb

@@ -0,0 +1,57 @@
+module Mutiny
+  module Mutants
+    class ObservableMutantSet < MutantSet
+      def create_mutant(subject, code)
+        MutantSpy.new(subject: subject, code: code)
+      end
+    end
+
+    class MutantSpy < Mutant
+      attr_reader :directory, :index
+
+      def store(directory, index)
+        @directory = directory
+        @index = index
+      end
+    end
+
+    describe MutantSet do
+      subject(:mutant_set) { ObservableMutantSet.new }
+
+      before(:each) do
+        mutant_set.add(:min, [:min_mutant_1, :min_mutant_2])
+        mutant_set.add(:max, [:max_mutant_1])
+        mutant_set.add(:min, [:min_mutant_3])
+      end
+
+      it "groups mutants by subject" do
+        groups = mutant_set.group_by_subject.to_a
+        first = groups.first
+        second = groups.last
+
+        expect(first).to eq(mutants_for(:min, :min_mutant_1, :min_mutant_2, :min_mutant_3))
+        expect(second).to eq(mutants_for(:max, :max_mutant_1))
+      end
+
+      it "counts mutants" do
+        expect(mutant_set.size).to eq(4)
+      end
+
+      it "stores by delegating to mutants" do
+        mutant_set.store(:mutant_dir)
+
+        mutant_set.group_by_subject.each do |_, mutants|
+          mutants.each_with_index do |mutant, index|
+            expect(mutant.directory).to eq(:mutant_dir)
+            expect(mutant.index).to eq(index)
+          end
+        end
+      end
+
+      def mutants_for(subject, *code)
+        mutants = code.map { |c| Mutant.new(subject: subject, code: c) }
+        [subject, mutants]
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/binary_operator_replacement_spec.rb

@@ -0,0 +1,11 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe BinaryArithmeticOperatorReplacement do
+          it_behaves_like "an operator replacement mutation", %i(+ - * / %)
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/conditional_operator_deletion_spec.rb

@@ -0,0 +1,17 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe ConditionalOperatorDeletion do
+          it "mutates negated literal to literal" do
+            expect(subject.mutate("a = !true")).to eq(["a = true"])
+          end
+
+          it "mutates negated variable to variable" do
+            expect(subject.mutate("a = !b")).to eq(["a = b"])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/conditional_operator_insertion_spec.rb

@@ -0,0 +1,17 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe ConditionalOperatorInsertion do
+          it "mutates literal to negated literal" do
+            expect(subject.mutate("return true")).to eq(["return !true"])
+          end
+
+          it "mutates variable to negated variable" do
+            expect(subject.mutate("return a")).to eq(["return !a"])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/conditional_operator_replacement_spec.rb

@@ -0,0 +1,16 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe ConditionalOperatorReplacement do
+          it_behaves_like "an operator replacement mutation with extra replacements",
+                          '^': %i(&& ||),
+                          '&&': %i(^ ||),
+                          '||': %i(^ &&),
+                          and: %i(^ ||),
+                          or: %i(^ &&)
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/logical_operator_deletion_spec.rb

@@ -0,0 +1,17 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe LogicalOperatorDeletion do
+          it "mutates inverted integer to integer" do
+            expect(subject.mutate("a = ~42")).to eq(["a = 42"])
+          end
+
+          it "mutates inverted variable to variable" do
+            expect(subject.mutate("a = ~b")).to eq(["a = b"])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/logical_operator_insertion_spec.rb

@@ -0,0 +1,17 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe LogicalOperatorInsertion do
+          it "mutates integer to inverted integer" do
+            expect(subject.mutate("return 42")).to eq(["return ~42"])
+          end
+
+          it "mutates variable to inverted variable" do
+            expect(subject.mutate("return a")).to eq(["return ~a"])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/logical_operator_replacement_spec.rb

@@ -0,0 +1,11 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe LogicalOperatorReplacement do
+          it_behaves_like "an operator replacement mutation", %i(& | ^)
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/relational_expression_replacement_spec.rb

@@ -0,0 +1,18 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe RelationalExpressionReplacement do
+          %i(< <= == != >= >).each do |operator|
+            it "mutates #{operator} to true and false" do
+              program = "foo #{operator} bar"
+              mutants = subject.mutate(program)
+
+              expect(mutants).to eq(%w(true false))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/relational_operator_replacement_spec.rb

@@ -0,0 +1,11 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe RelationalOperatorReplacement do
+          it_behaves_like "an operator replacement mutation", %i(< <= == != >= >)
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/shortcut_assignment_operator_replacement_spec.rb

@@ -0,0 +1,12 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe ShortcutAssignmentOperatorReplacement do
+          it_behaves_like "an operator replacement mutation",
+                          %i(+= -= *= /= %= **= &= |= ^= <<= >>= &&= ||=)
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/unary_arithmetic_operator_deletion_spec.rb

@@ -0,0 +1,21 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe UnaryArithmeticOperatorDeletion do
+          it "mutates negative integer to positive integer" do
+            expect(subject.mutate("a = -42")).to eq(["a = 42"])
+          end
+
+          it "mutates negative float to positive float" do
+            expect(subject.mutate("a = -4.2")).to eq(["a = 4.2"])
+          end
+
+          it "mutates negative variable to positive variable" do
+            expect(subject.mutate("a = -b")).to eq(["a = b"])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutations/method/unary_arithmetic_operator_insertion_spec.rb

@@ -0,0 +1,21 @@
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        describe UnaryArithmeticOperatorInsertion do
+          it "mutates positive integer to negative integer" do
+            expect(subject.mutate("a = 42")).to eq(["a = -42"])
+          end
+
+          it "mutates positive float to negative float" do
+            expect(subject.mutate("a = 4.2")).to eq(["a = -4.2"])
+          end
+
+          it "mutates positive variable to negative variable" do
+            expect(subject.mutate("a = b")).to eq(["a = -b"])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/pattern_spec.rb

@@ -0,0 +1,28 @@
+module Mutiny
+  describe Pattern do
+    context "wildcard" do
+      subject { Pattern.new("*") }
+
+      it "should match all" do
+        expect(subject.match?("Calculator")).to be_truthy
+        expect(subject.match?("Calculator::Max")).to be_truthy
+      end
+    end
+
+    context "fully qualified name" do
+      subject { Pattern.new("Calculator::Max") }
+
+      it "should match same name" do
+        expect(subject.match?("Calculator::Max")).to be_truthy
+      end
+
+      it "should match a more specific name" do
+        expect(subject.match?("Calculator::Max::Float")).to be_truthy
+      end
+
+      it "should not match a less specific name" do
+        expect(subject.match?("Calculator")).to be_falsey
+      end
+    end
+  end
+end

data/spec/unit/subjects/environment/type_spec.rb

@@ -0,0 +1,54 @@
+module Mutiny
+  module Subjects
+    class Environment
+      describe Type do
+        context "relevance" do
+          it "should include named class that are in scope and that are on the load path" do
+            configuration = Configuration.new(patterns: ["*"], loads: ["spec"])
+            type = Type.new(Person, configuration)
+
+            expect(type.relevant?).to be_truthy
+          end
+
+          it "should exclude anonymous classes" do
+            type = Type.new(Class.new, Configuration.new(patterns: ["*"], loads: ["spec"]))
+
+            expect(type.relevant?).to be_falsey
+          end
+
+          it "should exclude classes that are not in scope" do
+            configuration = Configuration.new(patterns: ["Department"], loads: ["spec"])
+            type = Type.new(Person, configuration)
+
+            expect(type.relevant?).to be_falsey
+          end
+
+          it "should exclude classes that are not on the load path" do
+            configuration = Configuration.new(patterns: ["*"], loads: ["lib"])
+            type = Type.new(Person, configuration)
+
+            expect(type.relevant?).to be_falsey
+          end
+        end
+
+        context "to_subject" do
+          it "should build a valid subject" do
+            configuration = Configuration.new(patterns: ["*"], loads: ["spec"])
+            type = Type.new(Person, configuration)
+            expected_subject = Subject.new(
+              name: "Mutiny::Subjects::Environment::Person",
+              path: __FILE__,
+              root: __FILE__.match(%r{.*/spec})[0]
+            )
+
+            expect(type.to_subject).to eq(expected_subject)
+          end
+        end
+
+        class Person
+          attr_accessor :name
+        end
+      end
+    end
+  end
+end

data/spec/unit/subjects/environment_spec.rb

@@ -0,0 +1,71 @@
+module Mutiny
+  module Subjects
+    describe Environment do
+      let(:module_names) { %w(Calculator Calculator::Max Calculator::Min) }
+
+      context "initialization" do
+        it "should add the required class and all dependences to available modules" do
+          in_sub_process do
+            configuration = Configuration.new(
+              loads: ["examples/calculator/lib"],
+              requires: ["calculator"]
+            )
+
+            expect { Environment.new(configuration) }
+              .to change { ObjectSpace.each_object(Module).map(&:name).reject(&:nil?).sort }
+              .by(module_names)
+          end
+        end
+
+        it "should not add any classes without a require" do
+          in_sub_process do
+            configuration = Configuration.new(
+              loads: ["examples/calculator/lib/calculator"]
+            )
+
+            expect { Environment.new(configuration) }
+              .not_to change { ObjectSpace.each_object(Module).map(&:name) }
+          end
+        end
+
+        it "should raise when require not found" do
+          in_sub_process do
+            configuration = Configuration.new(
+              requires: ["calculator"]
+            )
+
+            expect { Environment.new(configuration) }
+              .to raise_error(LoadError)
+          end
+        end
+      end
+
+      context "subjects" do
+        let(:mutatable_module_names) { %w(Calculator::Max Calculator::Min) }
+
+        let(:configuration) do
+          Configuration.new(
+            loads: ["examples/calculator/lib"],
+            requires: ["calculator"],
+            patterns: ["Calculator"]
+          )
+        end
+
+        let(:environment) { Environment.new(configuration) }
+
+        it "should return all subjects matching pattern" do
+          in_sub_process do
+            expect(environment.subjects.names).to eq(mutatable_module_names)
+          end
+        end
+
+        it "should function in the presence of anonymous modules" do
+          in_sub_process do
+            Class.new   # create anonymous class
+            expect(environment.subjects.names).to eq(mutatable_module_names)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/subjects/subject_spec.rb

@@ -0,0 +1,25 @@
+module Mutiny
+  module Subjects
+    describe Subject do
+      context "relative_path" do
+        it "should return path relative from root" do
+          subject = Subject.new(name: "Foo::Bar::Baz", path: "/foo/bar/baz.rb", root: "/foo")
+
+          expect(subject.relative_path).to eq("bar/baz.rb")
+        end
+
+        it "should return path relative from nested root" do
+          subject = Subject.new(name: "Foo::Bar::Baz", path: "/foo/bar/baz.rb", root: "/foo/bar")
+
+          expect(subject.relative_path).to eq("baz.rb")
+        end
+
+        it "should return path relative from root with trailing slash" do
+          subject = Subject.new(name: "Foo::Bar::Baz", path: "/foo/bar/baz.rb", root: "/foo/")
+
+          expect(subject.relative_path).to eq("bar/baz.rb")
+        end
+      end
+    end
+  end
+end

data/spec/unit/subjects/test_set_spec.rb

@@ -0,0 +1,75 @@
+module Mutiny
+  module Tests
+    describe TestSet do
+      let(:tests) { %w(test1 test2 test3) }
+      subject { TestSet.new(tests) }
+
+      context "take" do
+        it "(n) should return TestSet containing first n tests" do
+          expect(subject.take(2)).to eq(TestSet.new(tests.take(2)))
+        end
+
+        it "(0) should return an empty TestSet" do
+          expect(subject.take(0)).to eq(TestSet.empty)
+        end
+
+        it "(n) of an empty TestSet should return an empty TestSet" do
+          expect(TestSet.empty.take(2)).to eq(TestSet.empty)
+        end
+      end
+
+      context "subset" do
+        it "should return TestSet containing tests that match condition" do
+          subset = subject.subset { |t| t.end_with? "2" }
+          expected = TestSet.new(tests.select { |t| t.end_with? "2" })
+
+          expect(subset).to eq(expected)
+        end
+
+        it "should return empty TestSet when no tests match condition" do
+          subset = subject.subset { |_| false }
+
+          expect(subset).to eq(TestSet.empty)
+        end
+      end
+
+      context "for" do
+        it "should return only those tests (whose expression) matches a subject" do
+          subject_set = subject_set_for("Max", "Min")
+          test_set = test_set_for("Subtract", "Min", "Add")
+
+          expect(test_set.for(subject_set)).to eq(test_set.subset { |t| t.expression == "Min" })
+        end
+
+        it "should return multiple tests for a single subject" do
+          subject_set = subject_set_for("Min")
+          test_set = test_set_for("Min", "Max", "Min", "Max", "Min")
+
+          expect(test_set.for(subject_set)).to eq(test_set.subset { |t| t.expression == "Min" })
+        end
+
+        it "should return no tests when there are no tests" do
+          subject_set = subject_set_for("Max", "Min")
+          test_set = TestSet.empty
+
+          expect(test_set.for(subject_set)).to eq(TestSet.empty)
+        end
+
+        it "should return no tests when there are no relevant subjects" do
+          subject_set = subject_set_for("Max", "Min")
+          test_set = test_set_for("Subtract", "Add")
+
+          expect(test_set.for(subject_set)).to eq(TestSet.empty)
+        end
+
+        def subject_set_for(*names)
+          Subjects::SubjectSet.new(names.map { |n| Subjects::Subject.new(name: n) })
+        end
+
+        def test_set_for(*expressions)
+          TestSet.new(expressions.map { |e| Test.new(expression: e) })
+        end
+      end
+    end
+  end
+end