mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/diff_spec.rb

@@ -0,0 +1,185 @@
+RSpec.describe Mutest::Diff do
+  let(:object) { described_class }
+
+  describe '.build' do
+    subject { object.build(old_string, new_string) }
+
+    let(:old_string) { "foo\nbar" }
+    let(:new_string) { "bar\nbaz" }
+
+    it { is_expected.to eql(described_class.new(%w[foo bar], %w[bar baz])) }
+  end
+
+  describe '#colorized_diff' do
+    subject { object.colorized_diff }
+
+    let(:object) { described_class.new(old, new) }
+
+    context 'when there is a diff at begin of hunk' do
+      let(:old) { %w[foo bar] }
+      let(:new) { %w[baz bar] }
+
+      let(:expectation) do
+        [
+          "@@ -1,3 +1,3 @@\n",
+          Mutest::Color::RED.format("-foo\n"),
+          Mutest::Color::GREEN.format("+baz\n"),
+          " bar\n"
+        ].join
+      end
+
+      it { is_expected.to eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when there is no diff' do
+      let(:old) { '' }
+      let(:new) { '' }
+
+      it { is_expected.to be(nil) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+  end
+
+  describe '#diff' do
+    subject { object.diff }
+
+    let(:object) { described_class.new(old, new) }
+
+    context 'when there is a diff at begin and end' do
+      let(:old) { %w[foo bar foo] }
+      let(:new) { %w[baz bar baz] }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,4 +1,4 @@
+          -foo
+          +baz
+           bar
+          -foo
+          +baz
+        STR
+      end
+
+      it { is_expected.to eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when there is a diff at begin of hunk' do
+      let(:old) { %w[foo bar] }
+      let(:new) { %w[baz bar] }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,3 +1,3 @@
+          -foo
+          +baz
+           bar
+        STR
+      end
+
+      it { is_expected.to eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when there is a diff NOT at begin of hunk' do
+      let(:old) { %w[foo bar]     }
+      let(:new) { %w[foo baz bar] }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,3 +1,4 @@
+           foo
+          +baz
+           bar
+        STR
+      end
+
+      it { is_expected.to eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when the diff has a long context at begin' do
+      let(:old) { %w[foo bar baz boz a b c]       }
+      let(:new) { %w[foo bar baz boz a b c other] }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,8 +1,9 @@
+           foo
+           bar
+           baz
+           boz
+           a
+           b
+           c
+          +other
+        STR
+      end
+
+      it { is_expected.to eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when the diff has a long context at end, deleting' do
+      let(:old) { %w[other foo bar baz boz a b c] }
+      let(:new) { %w[foo bar baz boz a b c]       }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,9 +1,8 @@
+          -other
+           foo
+           bar
+           baz
+           boz
+           a
+           b
+           c
+        STR
+      end
+
+      it { is_expected.to eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when the diff has a long context at end, inserting' do
+      let(:old) { %w[foo bar baz boz a b c]       }
+      let(:new) { %w[other foo bar baz boz a b c] }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,8 +1,9 @@
+          +other
+           foo
+           bar
+           baz
+           boz
+           a
+           b
+           c
+        STR
+      end
+
+      it { is_expected.to eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when there is no diff' do
+      let(:old) { '' }
+      let(:new) { '' }
+
+      it { is_expected.to be(nil) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+  end
+end

data/spec/unit/mutest/env/bootstrap_spec.rb

@@ -0,0 +1,188 @@
+# This spec is a good example for:
+#
+# If test look that ugly the class under test sucks.
+#
+# As the bootstrap needs to infect global VM state
+# this is to some degree acceptable.
+#
+# Still the bootstrap needs to be cleaned up.
+# And the change that added this warning did the groundwork.
+RSpec.describe Mutest::Env::Bootstrap do
+  let(:matcher_config)       { Mutest::Matcher::Config::DEFAULT     }
+  let(:integration)          { instance_double(Mutest::Integration) }
+  let(:integration_class)    { instance_double(Class)               }
+  let(:object_space_modules) { []                                   }
+
+  let(:config) do
+    Mutest::Config::DEFAULT.with(
+      includes:    [],
+      integration: integration_class,
+      jobs:        1,
+      matcher:     matcher_config,
+      reporter:    instance_double(Mutest::Reporter),
+      requires:    []
+    )
+  end
+
+  let(:expected_env) do
+    Mutest::Env.new(
+      actor_env:        Mutest::Actor::Env.new(Thread),
+      config:           config,
+      integration:      integration,
+      matchable_scopes: [],
+      mutations:        [],
+      parser:           Mutest::Parser.new,
+      selector:         Mutest::Selector::Expression.new(integration),
+      subjects:         []
+    )
+  end
+
+  shared_examples_for 'bootstrap call' do
+    it { is_expected.to eql(expected_env) }
+  end
+
+  def expect_warning
+    expect(config.reporter).to receive(:warn)
+      .with(expected_warning)
+      .and_return(config.reporter)
+  end
+
+  before do
+    expect(integration_class).to receive(:new)
+      .with(config)
+      .and_return(integration)
+
+    expect(integration).to receive_messages(setup: integration)
+
+    expect(ObjectSpace).to receive(:each_object)
+      .with(Module)
+      .and_return(object_space_modules.each)
+  end
+
+  describe '#warn' do
+    subject { object.warn(expected_warning) }
+
+    let(:object)           { described_class.new(config) }
+    let(:expected_warning) { instance_double(String)     }
+
+    before { expect_warning }
+
+    it_behaves_like 'a command method'
+  end
+
+  describe '.call' do
+    subject { described_class.call(config) }
+
+    context 'when Module#name calls result in exceptions' do
+      let(:object_space_modules) { [invalid_class] }
+
+      let(:expected_warning) do
+        "Class#name from: #{invalid_class} raised an error: " \
+        "RuntimeError. #{Mutest::Env::SEMANTICS_MESSAGE}"
+      end
+
+      let(:invalid_class) do
+        Class.new do
+          def self.name
+            fail
+          end
+        end
+      end
+
+      after do
+        # Fix Class#name so other specs do not see this one
+        class << invalid_class
+          undef :name
+          def name
+          end
+        end
+      end
+
+      before { expect_warning }
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when requires are configured' do
+      let(:config) { super().with(requires: %w[foo bar]) }
+
+      before do
+        %w[foo bar].each do |component|
+          expect(Kernel).to receive(:require)
+            .with(component)
+            .and_return(true)
+        end
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when includes are configured' do
+      let(:config) { super().with(includes: %w[foo bar]) }
+
+      before do
+        %w[foo bar].each do |component|
+          expect($LOAD_PATH).to receive(:<<)
+            .with(component)
+            .and_return($LOAD_PATH)
+        end
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when Module#name does not return a String or nil' do
+      let(:object_space_modules) { [invalid_class] }
+
+      let(:invalid_class) do
+        Class.new do
+          def self.name
+            Object
+          end
+        end
+      end
+
+      let(:expected_warning) do
+        "Class#name from: #{invalid_class} " \
+        "returned Object. #{Mutest::Env::SEMANTICS_MESSAGE}"
+      end
+
+      after do
+        # Fix Class#name so other specs do not see this one
+        class << invalid_class
+          undef :name
+          def name
+          end
+        end
+      end
+
+      before { expect_warning }
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when scope matches expression' do
+      let(:object_space_modules) { [TestApp::Literal, TestApp::Empty]                               }
+      let(:match_expressions)    { object_space_modules.map(&:name).map(&method(:parse_expression)) }
+
+      let(:matcher_config) do
+        super().with(match_expressions: match_expressions)
+      end
+
+      let(:expected_env) do
+        subjects = Mutest::Matcher::Scope.new(TestApp::Literal).call(Fixtures::TEST_ENV)
+
+        super().with(
+          matchable_scopes: [
+            Mutest::Scope.new(TestApp::Empty,   match_expressions.last),
+            Mutest::Scope.new(TestApp::Literal, match_expressions.first)
+          ],
+          mutations:        subjects.flat_map(&:mutations),
+          subjects:         subjects
+        )
+      end
+
+      include_examples 'bootstrap call'
+    end
+  end
+end

data/spec/unit/mutest/env_spec.rb

@@ -0,0 +1,100 @@
+RSpec.describe Mutest::Env do
+  context '#kill' do
+    subject { object.kill(mutation) }
+
+    let(:object) do
+      described_class.new(
+        actor_env:        Mutest::Actor::Env.new(Thread),
+        config:           config,
+        integration:      integration,
+        matchable_scopes: [],
+        mutations:        [],
+        selector:         selector,
+        subjects:         [],
+        parser:           Mutest::Parser.new
+      )
+    end
+
+    let(:integration)       { instance_double(Mutest::Integration)     }
+    let(:test_a)            { instance_double(Mutest::Test)            }
+    let(:test_b)            { instance_double(Mutest::Test)            }
+    let(:tests)             { [test_a, test_b]                         }
+    let(:selector)          { instance_double(Mutest::Selector)        }
+    let(:integration_class) { Mutest::Integration::Null                }
+    let(:isolation)         { instance_double(Mutest::Isolation::Fork) }
+    let(:mutation_subject)  { instance_double(Mutest::Subject)         }
+
+    let(:mutation) do
+      instance_double(
+        Mutest::Mutation,
+        subject: mutation_subject
+      )
+    end
+
+    let(:config) do
+      Mutest::Config::DEFAULT.with(
+        isolation:   isolation,
+        integration: integration_class,
+        kernel:      class_double(Kernel)
+      )
+    end
+
+    shared_examples_for 'mutation kill' do
+      specify do
+        is_expected.to eql(
+          Mutest::Result::Mutation.new(
+            mutation:    mutation,
+            test_result: test_result
+          )
+        )
+      end
+    end
+
+    before do
+      expect(selector).to receive(:call)
+        .with(mutation_subject)
+        .and_return(tests)
+
+      allow(Time).to receive_messages(now: Time.at(0))
+    end
+
+    context 'when isolation does not raise error' do
+      let(:test_result) { instance_double(Mutest::Result::Test) }
+
+      before do
+        expect(isolation).to receive(:call)
+          .ordered
+          .and_yield
+
+        expect(mutation).to receive(:insert)
+          .ordered
+          .with(config.kernel)
+
+        expect(integration).to receive(:call)
+          .ordered
+          .with(tests)
+          .and_return(test_result)
+      end
+
+      include_examples 'mutation kill'
+    end
+
+    context 'when isolation does raise error' do
+      before do
+        expect(isolation).to receive(:call)
+          .and_raise(Mutest::Isolation::Error, 'test-error')
+      end
+
+      let(:test_result) do
+        Mutest::Result::Test.new(
+          output:  'test-error',
+          passed:  false,
+          runtime: 0.0,
+          tests:   tests
+        )
+      end
+
+      include_examples 'mutation kill'
+    end
+  end
+end