mutant 0.9.10 → 0.10.0

data/spec/unit/mutant/meta/example/dsl_spec.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Meta::Example::DSL do
-  describe '.call' do
-    subject { described_class.call(file, types, block) }
-
-    let(:file)     { 'foo.rb'             }
-    let(:node)     { s(:false)            }
-    let(:types)    { Set.new([node.type]) }
-    let(:expected) { []                   }
-
-    let(:expected_example) do
-      Mutant::Meta::Example.new(
-        file:     file,
-        node:     node,
-        types:    types,
-        expected: expected
-      )
-    end
-
-    def self.expect_example(&block)
-      let(:block) { block }
-
-      specify do
-        # Kill mutations to warnings
-        warnings = Mutant::WORLD.warnings.call do
-          should eql(expected_example)
-        end
-        expect(warnings).to eql([])
-      end
-    end
-
-    def self.expect_error(message, &block)
-      let(:block) { block }
-
-      specify do
-        expect { subject }.to raise_error(RuntimeError, message)
-      end
-    end
-
-    context 'source as node' do
-      expect_example do
-        source s(:false)
-      end
-    end
-
-    context 'source as string' do
-      expect_example do
-        source 'false'
-      end
-    end
-
-    context 'on node that needs unparser preprocessing to be normalized' do
-      let(:node) { s(:send, s(:float, -1.0), :/, s(:float, 0.0)) }
-
-      expect_example do
-        source '(-1.0) / 0.0'
-      end
-    end
-
-    context 'using #mutation' do
-      let(:expected) { [s(:nil)] }
-
-      expect_example do
-        source 'false'
-
-        mutation 'nil'
-      end
-    end
-
-    context 'using #singleton_mutations' do
-      let(:expected) { [s(:nil), s(:self)] }
-
-      expect_example do
-        source 'false'
-
-        singleton_mutations
-      end
-    end
-
-    context 'no definition of source' do
-      expect_error('source not defined') do
-      end
-    end
-
-    context 'duplicate definition of source' do
-      expect_error('source already defined') do
-        source 'true'
-        source 'false'
-      end
-    end
-
-    context 'uncoercable source' do
-      expect_error('Cannot coerce to node: nil') do
-        source nil
-      end
-    end
-
-    context 'duplicate mutation expectation' do
-      expect_error('Mutation for input: "true" is already expected') do
-        source 'false'
-
-        mutation 'true'
-        mutation 'true'
-      end
-    end
-  end
-end

data/spec/unit/mutant/meta/example/verification_spec.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Meta::Example::Verification do
-  let(:object) { described_class.new(example, mutations) }
-
-  let(:example) do
-    Mutant::Meta::Example.new(
-      file:     'foo.rb',
-      node:     s(:true),
-      types:    [:true],
-      expected: expected_nodes
-    )
-  end
-
-  let(:mutations) do
-    generated_nodes.map do |node|
-      Mutant::Mutation::Evil.new(example, node)
-    end
-  end
-
-  let(:generated_nodes) { [] }
-  let(:expected_nodes)  { [] }
-
-  describe '#success?' do
-    subject { object.success? }
-
-    context 'when generated nodes equal expected nodes' do
-      it { should be(true) }
-    end
-
-    context 'when expected node is missing' do
-      let(:expected_nodes) { [s(:false)] }
-
-      it { should be(false) }
-    end
-
-    context 'when there is extra generated node' do
-      let(:generated_nodes) { [s(:false)] }
-
-      it { should be(false) }
-    end
-
-    context 'when there is no diff to original source' do
-      let(:expected_nodes)  { [s(:true)] }
-      let(:generated_nodes) { [s(:true)] }
-
-      it { should be(false) }
-    end
-  end
-
-  describe '#error_report' do
-    subject { object.error_report }
-
-    context 'on success' do
-      specify do
-        expect { subject }.to raise_error(
-          RuntimeError,
-          'no error report on successful validation'
-        )
-      end
-    end
-
-    context 'when expected node is missing' do
-      let(:expected_nodes) { [s(:false), s(:nil)] }
-
-      specify do
-        should eql(<<~'REPORT')
-          ---
-          file: foo.rb
-          original_ast: s(:true)
-          original_source: 'true'
-          missing:
-          - node: s(:false)
-            source: 'false'
-          - node: s(:nil)
-            source: nil
-          unexpected: []
-          invalid_syntax: []
-          no_diff: []
-        REPORT
-      end
-    end
-
-    context 'when there is extra generated node' do
-      let(:generated_nodes) { [s(:false), s(:nil)] }
-
-      specify do
-        should eql(<<~'REPORT')
-          ---
-          file: foo.rb
-          original_ast: s(:true)
-          original_source: 'true'
-          missing: []
-          unexpected:
-          - node: s(:false)
-            source: 'false'
-          - node: s(:nil)
-            source: nil
-          invalid_syntax: []
-          no_diff: []
-        REPORT
-      end
-    end
-
-    context 'when there is no diff to original source' do
-      let(:expected_nodes)  { [s(:true)] }
-      let(:generated_nodes) { [s(:true)] }
-
-      specify do
-        should eql(<<~'REPORT')
-          ---
-          file: foo.rb
-          original_ast: s(:true)
-          original_source: 'true'
-          missing: []
-          unexpected: []
-          invalid_syntax: []
-          no_diff:
-          - node: s(:true)
-            source: 'true'
-        REPORT
-      end
-    end
-
-    context 'when the generated node is invalid syntax after unparsed' do
-      let(:invalid_node) do
-        s(:op_asgn, s(:send, s(:self), :at, s(:int, 1)), :+, s(:int, 1))
-      end
-
-      let(:expected_nodes)  { [invalid_node] }
-      let(:generated_nodes) { [invalid_node] }
-
-      specify do
-        should eql(<<~'REPORT')
-          ---
-          file: foo.rb
-          original_ast: s(:true)
-          original_source: 'true'
-          missing: []
-          unexpected: []
-          invalid_syntax:
-          - node: |-
-              s(:op_asgn,
-                s(:send,
-                  s(:self), :at,
-                  s(:int, 1)), :+,
-                s(:int, 1))
-            source: self.at(1) += 1
-          no_diff: []
-        REPORT
-      end
-    end
-  end
-end

data/spec/unit/mutant/meta/example_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Meta::Example do
-  let(:object) do
-    described_class.new(
-      file:     file,
-      node:     node,
-      types:    [node.type],
-      expected: mutation_nodes
-    )
-  end
-
-  let(:file)           { 'foo/bar.rb' }
-  let(:node)           { s(:true)     }
-  let(:mutation_nodes) { [s(:false)]  }
-
-  let(:mutations) do
-    mutation_nodes.map do |node|
-      Mutant::Mutation::Evil.new(object, node)
-    end
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    it { should eql('true') }
-  end
-
-  describe '#verification' do
-    subject { object.verification }
-
-    it { should eql(Mutant::Meta::Example::Verification.new(object, mutations)) }
-  end
-end

data/spec/unit/mutant/mutation_spec.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Mutation do
-  let(:mutation_class) do
-    Class.new(Mutant::Mutation) do
-      const_set(:SYMBOL, 'test')
-      const_set(:TEST_PASS_SUCCESS, true)
-    end
-  end
-
-  let(:context) { instance_double(Mutant::Context) }
-
-  let(:object) do
-    mutation_class.new(mutation_subject, Mutant::AST::Nodes::N_NIL)
-  end
-
-  let(:mutation_subject) do
-    instance_double(
-      Mutant::Subject,
-      identification: 'subject',
-      context:        context,
-      source:         'original'
-    )
-  end
-
-  describe '#insert' do
-    subject { object }
-
-    def apply
-      subject.insert(kernel)
-    end
-
-    let(:expected_source) { '1'                                     }
-    let(:kernel)          { instance_double(Kernel)                 }
-    let(:loader_result)   { instance_double(Mutant::Loader::Result) }
-    let(:root_node)       { s(:int, 1)                              }
-
-    before do
-      expect(context).to receive(:root)
-        .with(object.node)
-        .and_return(root_node)
-
-      expect(mutation_subject).to receive(:prepare)
-        .ordered
-        .and_return(mutation_subject)
-
-      expect(Mutant::Loader).to receive(:call)
-        .ordered
-        .with(
-          binding: TOPLEVEL_BINDING,
-          kernel:  kernel,
-          source:  expected_source,
-          subject: mutation_subject
-        )
-        .and_return(loader_result)
-    end
-
-    it 'returns loader result' do
-      expect(apply).to be(loader_result)
-    end
-  end
-
-  describe '#code' do
-    subject { object.code }
-
-    it { should eql('8771a') }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#original_source' do
-    subject { object.original_source }
-
-    it { should eql('original') }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    it { should eql('nil') }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '.success?' do
-    subject { mutation_class.success?(test_result) }
-
-    let(:test_result) do
-      instance_double(
-        Mutant::Result::Test,
-        passed: passed
-      )
-    end
-
-    context 'on mutation with positive pass expectation' do
-      context 'when Result::Test#passed equals expectation' do
-        let(:passed) { true }
-
-        it { should be(true) }
-      end
-
-      context 'when Result::Test#passed NOT equals expectation' do
-        let(:passed) { false }
-
-        it { should be(false) }
-      end
-    end
-
-    context 'on mutation with negative pass expectation' do
-      let(:mutation_class) do
-        Class.new(super()) do
-          const_set(:TEST_PASS_SUCCESS, false)
-        end
-      end
-
-      context 'when Result::Test#passed equals expectation' do
-        let(:passed) { true }
-
-        it { should be(false) }
-      end
-
-      context 'when Result::Test#passed NOT equals expectation' do
-        let(:passed) { false }
-
-        it { should be(true) }
-      end
-    end
-  end
-
-  describe '#identification' do
-
-    subject { object.identification }
-
-    it { should eql('test:subject:8771a') }
-
-    it_should_behave_like 'an idempotent method'
-  end
-end

data/spec/unit/mutant/mutator/node_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-aggregate = Hash.new { |hash, key| hash[key] = [] }
-
-Mutant::Meta::Example::ALL
-  .each_with_object(aggregate) do |example, agg|
-    example.types.each do |type|
-      agg[Mutant::Mutator::REGISTRY.lookup(type)] << example
-    end
-  end
-
-aggregate.each do |mutator, examples|
-  RSpec.describe mutator do
-    it 'generates expected mutations' do
-      examples.each do |example|
-        verification = example.verification
-        fail verification.error_report unless verification.success?
-      end
-    end
-  end
-end
-
-RSpec.describe Mutant::Mutator::Node do
-  describe 'internal DSL' do
-    let(:klass) do
-      Class.new(described_class) do
-        children(:left, :right)
-
-        def dispatch
-          left
-          emit_left(s(:nil))
-          emit_right_mutations do |node|
-            node.eql?(s(:nil))
-          end
-        end
-      end
-    end
-
-    def apply
-      klass.call(s(:and, s(:true), s(:true)))
-    end
-
-    specify do
-      expect(apply).to eql([s(:and, s(:nil), s(:true))].to_set)
-    end
-  end
-end