mutant 0.9.10 → 0.10.0

data/spec/unit/mutant/result/test_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Result::Test::VoidValue do
-  describe '.new' do
-    it 'returns expected attributes' do
-      expect(described_class.instance.to_h).to eql(
-        output:  '',
-        passed:  false,
-        runtime: 0.0,
-        tests:   []
-      )
-    end
-  end
-end

data/spec/unit/mutant/result_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Result do
-  let(:object) do
-    Class.new do
-      include Mutant::Result, Concord.new(:runtime, :killtime)
-
-      def collection
-        [[1]]
-      end
-
-      sum :length, :collection
-    end.new(3.0, 1.0)
-  end
-
-  describe '.included' do
-    it 'includes mixin to freeze instances' do
-      expect(object.frozen?).to be(true)
-    end
-
-    it 'it makes DSL methods from Mutant::Result available' do
-      expect(object.length).to be(1)
-    end
-  end
-
-  describe '#overhead' do
-    subject { object.overhead }
-
-    it 'returns difference between runtime and killtime' do
-      should eql(2.0)
-    end
-  end
-end

data/spec/unit/mutant/runner/sink_spec.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-describe Mutant::Runner::Sink do
-  setup_shared_context
-
-  shared_context 'one result' do
-    before do
-      object.result(mutation_a_result)
-    end
-  end
-
-  shared_context 'two results' do
-    before do
-      object.result(mutation_a_result)
-      object.result(mutation_b_result)
-    end
-  end
-
-  let(:object) { described_class.new(env) }
-
-  before do
-    allow(Mutant::Timer).to receive_messages(now: Mutant::Timer.now)
-  end
-
-  describe '#result' do
-    subject { object.result(mutation_a_result) }
-
-    it 'aggregates results in #status' do
-      subject
-      object.result(mutation_b_result)
-      expect(object.status).to eql(
-        Mutant::Result::Env.new(
-          env:             env,
-          runtime:         0.0,
-          subject_results: [subject_a_result]
-        )
-      )
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#status' do
-    subject { object.status }
-
-    context 'no results' do
-      let(:expected_status) do
-        Mutant::Result::Env.new(
-          env:             env,
-          runtime:         0.0,
-          subject_results: []
-        )
-      end
-
-      it { should eql(expected_status) }
-    end
-
-    context 'one result' do
-      include_context 'one result'
-
-      with(:subject_a_result) { { mutation_results: [mutation_a_result] } }
-
-      let(:expected_status) do
-        Mutant::Result::Env.new(
-          env:             env,
-          runtime:         0.0,
-          subject_results: [subject_a_result]
-        )
-      end
-
-      it { should eql(expected_status) }
-    end
-
-    context 'two results' do
-      include_context 'two results'
-
-      let(:expected_status) do
-        Mutant::Result::Env.new(
-          env:             env,
-          runtime:         0.0,
-          subject_results: [subject_a_result]
-        )
-      end
-
-      it { should eql(expected_status) }
-    end
-  end
-
-  describe '#stop?' do
-    subject { object.stop? }
-
-    context 'without fail fast' do
-      context 'no results' do
-        it { should be(false) }
-      end
-
-      context 'one result' do
-        include_context 'one result'
-
-        context 'when result is successful' do
-          it { should be(false) }
-        end
-
-        context 'when result failed' do
-          with(:mutation_a_test_result) { { passed: true } }
-
-          it { should be(false) }
-        end
-      end
-
-      context 'two results' do
-        include_context 'two results'
-
-        context 'when results are successful' do
-          it { should be(false) }
-        end
-
-        context 'when first result is unsuccessful' do
-          with(:mutation_a_test_result) { { passed: true } }
-
-          it { should be(false) }
-        end
-
-        context 'when second result is unsuccessful' do
-          with(:mutation_b_test_result) { { passed: true } }
-
-          it { should be(false) }
-        end
-      end
-    end
-
-    context 'with fail fast' do
-      with(:config) { { fail_fast: true } }
-
-      context 'no results' do
-        it { should be(false) }
-      end
-
-      context 'one result' do
-        include_context 'one result'
-
-        context 'when result is successful' do
-          it { should be(false) }
-        end
-
-        context 'when result failed' do
-          with(:mutation_a_test_result) { { passed: true } }
-
-          it { should be(true) }
-        end
-      end
-
-      context 'two results' do
-        include_context 'two results'
-
-        context 'when results are successful' do
-          it { should be(false) }
-        end
-
-        context 'when first result is unsuccessful' do
-          with(:mutation_a_test_result) { { passed: true } }
-
-          it { should be(true) }
-        end
-
-        context 'when second result is unsuccessful' do
-          with(:mutation_b_test_result) { { passed: true } }
-
-          it { should be(true) }
-        end
-      end
-    end
-  end
-end

data/spec/unit/mutant/runner_spec.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Runner do
-  describe '.call' do
-    let(:condition_variable) { class_double(ConditionVariable)                 }
-    let(:delay)              { instance_double(Float)                          }
-    let(:driver)             { instance_double(Mutant::Parallel::Driver)       }
-    let(:env_result)         { instance_double(Mutant::Result::Env)            }
-    let(:kernel)             { class_double(Kernel)                            }
-    let(:mutex)              { class_double(Mutex)                             }
-    let(:processor)          { instance_double(Method)                         }
-    let(:reporter)           { instance_double(Mutant::Reporter, delay: delay) }
-    let(:thread)             { class_double(Thread)                            }
-
-    let(:env) do
-      instance_double(
-        Mutant::Env,
-        config:    config,
-        mutations: [],
-        world:     world
-      )
-    end
-
-    let(:config) do
-      instance_double(
-        Mutant::Config,
-        jobs:     1,
-        reporter: reporter
-      )
-    end
-
-    let(:world) do
-      instance_double(
-        Mutant::World,
-        condition_variable: condition_variable,
-        kernel:             kernel,
-        mutex:              mutex,
-        thread:             thread
-      )
-    end
-
-    let(:status_a) do
-      instance_double(
-        Mutant::Parallel::Status,
-        done?: false
-      )
-    end
-
-    let(:status_b) do
-      instance_double(
-        Mutant::Parallel::Status,
-        done?:   true,
-        payload: env_result
-      )
-    end
-
-    let(:parallel_config) do
-      Mutant::Parallel::Config.new(
-        condition_variable: condition_variable,
-        jobs:               1,
-        mutex:              mutex,
-        processor:          processor,
-        sink:               Mutant::Runner::Sink.new(env),
-        source:             Mutant::Parallel::Source::Array.new(env.mutations),
-        thread:             thread
-      )
-    end
-
-    def apply
-      described_class.apply(env)
-    end
-
-    let(:raw_expectations) do
-      [
-        {
-          receiver:  reporter,
-          selector:  :start,
-          arguments: [env]
-        },
-        {
-          receiver:  env,
-          selector:  :method,
-          arguments: [:kill],
-          reaction:  { return: processor }
-        },
-        {
-          receiver:  Mutant::Parallel,
-          selector:  :async,
-          arguments: [parallel_config],
-          reaction:  { return: driver }
-        },
-        {
-          receiver:  driver,
-          selector:  :wait_timeout,
-          arguments: [delay],
-          reaction:  { return: status_a }
-        },
-        {
-          receiver:  reporter,
-          selector:  :progress,
-          arguments: [status_a]
-        },
-        {
-          receiver:  driver,
-          selector:  :wait_timeout,
-          arguments: [delay],
-          reaction:  { return: status_b }
-        },
-        {
-          receiver:  reporter,
-          selector:  :report,
-          arguments: [env_result]
-        }
-      ]
-    end
-
-    it 'returns env result' do
-      verify_events { expect(apply).to eql(Mutant::Either::Right.new(env_result)) }
-    end
-  end
-end

data/spec/unit/mutant/selector/expression_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Selector::Expression do
-  describe '#call' do
-    let(:object) { described_class.new(integration) }
-
-    let(:mutation_subject) { subject_class.new(context: context, node: node, warnings: warnings)     }
-    let(:context)          { instance_double(Mutant::Context)                                        }
-    let(:node)             { instance_double(Parser::AST::Node)                                      }
-    let(:integration)      { instance_double(Mutant::Integration, all_tests: all_tests)              }
-    let(:test_a)           { instance_double(Mutant::Test, expression: parse_expression('SubjectA')) }
-    let(:test_b)           { instance_double(Mutant::Test, expression: parse_expression('SubjectB')) }
-    let(:test_c)           { instance_double(Mutant::Test, expression: parse_expression('SubjectC')) }
-    let(:warnings)         { instance_double(Mutant::Warnings)                                       }
-
-    let(:subject_class) do
-      parse = method(:parse_expression)
-
-      Class.new(Mutant::Subject) do
-        define_method(:expression) do
-          parse.call('SubjectA')
-        end
-
-        define_method(:match_expressions) do
-          [expression] << parse.call('SubjectB')
-        end
-      end
-    end
-
-    subject { object.call(mutation_subject) }
-
-    context 'without available tests' do
-      let(:all_tests) { [] }
-
-      it { should eql([]) }
-    end
-
-    context 'without qualifying tests' do
-      let(:all_tests) { [test_c] }
-
-      it { should eql([]) }
-    end
-
-    context 'with qualifying tests for first match expression' do
-      let(:all_tests) { [test_a] }
-
-      it { should eql([test_a]) }
-    end
-
-    context 'with qualifying tests for second match expression' do
-      let(:all_tests) { [test_b] }
-
-      it { should eql([test_b]) }
-    end
-
-    context 'with qualifying tests for the first and second match expression' do
-      let(:all_tests) { [test_a, test_b] }
-
-      it { should eql([test_a]) }
-    end
-  end
-end

data/spec/unit/mutant/selector/null_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Selector::Null do
-  describe '#call' do
-    subject { described_class.new }
-
-    let(:mutant_subject) { instance_double(Mutant::Subject) }
-
-    def apply
-      subject.call(mutant_subject)
-    end
-
-    it 'returns no tests' do
-      expect(apply).to eql([])
-    end
-  end
-end

data/spec/unit/mutant/subject/method/instance_spec.rb

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Subject::Method::Instance do
-  let(:object) do
-    described_class.new(
-      context:  context,
-      node:     node,
-      warnings: warnings
-    )
-  end
-
-  let(:call_block?) { true                              }
-  let(:warnings)    { instance_double(Mutant::Warnings) }
-
-  let(:context) do
-    Mutant::Context.new(
-      scope,
-      instance_double(Pathname)
-    )
-  end
-
-  let(:node) do
-    s(:def, :foo, s(:args))
-  end
-
-  let(:scope) do
-    Class.new do
-      attr_reader :bar
-
-      def initialize
-        @bar = :boo
-      end
-
-      def foo; end
-
-      def self.name
-        'Test'
-      end
-    end
-  end
-
-  before do
-    allow(warnings).to receive(:call) do |&block|
-      block.call if call_block?
-    end
-  end
-
-  describe '#expression' do
-    subject { object.expression }
-
-    it { should eql(parse_expression('Test#foo')) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#match_expression' do
-    subject { object.match_expressions }
-
-    it { should eql(%w[Test#foo Test*].map(&method(:parse_expression))) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#prepare' do
-    subject { object.prepare }
-
-    it 'undefines method on scope' do
-      expect { subject }
-        .to change { scope.instance_methods.include?(:foo) }
-        .from(true)
-        .to(false)
-    end
-
-    context 'within warning capture' do
-      let(:call_block?) { false }
-
-      it 'undefines method on scope' do
-        expect { subject }
-          .to_not change { scope.instance_methods.include?(:foo) }
-          .from(true)
-      end
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    it { should eql("def foo\nend") }
-  end
-end
-
-RSpec.describe Mutant::Subject::Method::Instance::Memoized do
-  let(:object) do
-    described_class.new(
-      context:  context,
-      node:     node,
-      warnings: warnings
-    )
-  end
-
-  let(:context) do
-    Mutant::Context.new(scope, double('Source Path'))
-  end
-
-  let(:warnings) { instance_double(Mutant::Warnings) }
-
-  let(:node) do
-    s(:def, :foo, s(:args))
-  end
-
-  before do
-    allow(warnings).to receive(:call).and_yield
-  end
-
-  shared_context 'memoizable scope setup' do
-    let(:scope) do
-      Class.new do
-        include Memoizable
-        def foo; end
-        memoize :foo
-      end
-    end
-  end
-
-  shared_context 'adamantium scope setup' do
-    let(:scope) do
-      memoize_options  = self.memoize_options
-      memoize_provider = self.memoize_provider
-
-      Class.new do
-        include memoize_provider
-        def foo; end
-        memoize :foo, **memoize_options
-      end
-    end
-  end
-
-  describe '#prepare' do
-    include_context 'memoizable scope setup'
-
-    subject { object.prepare }
-
-    it 'undefines memoizer' do
-      expect { subject }.to change { scope.memoized?(:foo) }.from(true).to(false)
-    end
-
-    it 'undefines method on scope' do
-      expect { subject }.to change { scope.instance_methods.include?(:foo) }.from(true).to(false)
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#mutations' do
-    subject { object.mutations }
-
-    let(:expected) do
-      [
-        Mutant::Mutation::Neutral.new(
-          object,
-          s(:begin, s(:def, :foo, s(:args)), memoize_node)
-        ),
-        Mutant::Mutation::Evil.new(
-          object,
-          s(:begin, s(:def, :foo, s(:args), s(:send, nil, :raise)), memoize_node)
-        ),
-        Mutant::Mutation::Evil.new(
-          object,
-          s(:begin, s(:def, :foo, s(:args), s(:zsuper)), memoize_node)
-        ),
-        Mutant::Mutation::Evil.new(
-          object,
-          s(:begin, s(:def, :foo, s(:args), nil), memoize_node)
-        )
-      ]
-    end
-
-    let(:memoize_node) do
-      s(:send, nil, :memoize, s(:args, s(:sym, :foo), *options_node))
-    end
-
-    let(:options_node) { nil }
-
-    context 'when Memoizable is included in scope' do
-      include_context 'memoizable scope setup'
-
-      it { should eql(expected) }
-    end
-
-    context 'when Adamantium is included in scope' do
-      include_context 'adamantium scope setup'
-
-      {
-        Adamantium       => :deep,
-        Adamantium::Flat => :flat
-      }.each do |memoize_provider, default_freezer_option|
-        context "as include #{memoize_provider}" do
-          let(:memoize_provider)       { memoize_provider       }
-          let(:default_freezer_option) { default_freezer_option }
-
-          let(:options_node) do
-            [s(:hash, s(:pair, s(:sym, :freezer), s(:sym, freezer_option)))]
-          end
-
-          context 'when no memoize options are given' do
-            let(:memoize_options) { Mutant::EMPTY_HASH     }
-            let(:freezer_option)  { default_freezer_option }
-
-            it { should eql(expected) }
-          end
-
-          context 'when memoize options are given' do
-            let(:memoize_options) { { freezer: freezer_option } }
-
-            %i[deep flat noop].each do |option|
-              context "as #{option.inspect}" do
-                let(:freezer_option) { option }
-
-                it { should eql(expected) }
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    context 'when Memoizable is included in scope' do
-      include_context 'memoizable scope setup'
-
-      let(:source) { "def foo\nend\nmemoize(:foo)" }
-
-      it { should eql(source) }
-    end
-
-    context 'when Adamantium is included in scope' do
-      include_context 'adamantium scope setup'
-
-      let(:source) do
-        "def foo\nend\nmemoize(:foo, { freezer: #{freezer_option.inspect} })"
-      end
-
-      {
-        Adamantium       => :deep,
-        Adamantium::Flat => :flat
-      }.each do |memoize_provider, default_freezer_option|
-        context "as include #{memoize_provider}" do
-          let(:memoize_provider) { memoize_provider }
-
-          context 'when no memoize options are given' do
-            let(:memoize_options) { Mutant::EMPTY_HASH     }
-            let(:freezer_option)  { default_freezer_option }
-
-            it { should eql(source) }
-          end
-
-          context 'when memoize options are given' do
-            %i[deep flat noop].each do |freezer_option|
-              context "as #{freezer_option.inspect}" do
-                let(:memoize_options) { { freezer: freezer_option } }
-                let(:freezer_option)  { freezer_option              }
-
-                it { should eql(source) }
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end