mutant 0.9.7 → 0.9.12

data/spec/unit/mutant/matcher/namespace_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Namespace, '#call' do
-  let(:object)      { described_class.new(parse_expression('TestApp*')) }
-  let(:env)         { instance_double(Mutant::Env)                      }
-  let(:raw_scope_a) { instance_double(Class, name: 'TestApp::Literal')  }
-  let(:raw_scope_b) { instance_double(Class, name: 'TestApp::Foo')      }
-  let(:raw_scope_c) { instance_double(Class, name: 'TestAppOther')      }
-  let(:subject_a)   { instance_double(Mutant::Subject)                  }
-  let(:subject_b)   { instance_double(Mutant::Subject)                  }
-
-  before do
-    [
-      [Mutant::Matcher::Methods::Singleton, raw_scope_b, [subject_b]],
-      [Mutant::Matcher::Methods::Instance,  raw_scope_b, []],
-      [Mutant::Matcher::Methods::Singleton, raw_scope_a, [subject_a]],
-      [Mutant::Matcher::Methods::Instance,  raw_scope_a, []]
-    ].each do |klass, scope, subjects|
-      matcher = instance_double(Mutant::Matcher)
-      expect(matcher).to receive(:call).with(env).and_return(subjects)
-
-      expect(klass).to receive(:new)
-        .with(scope)
-        .and_return(matcher)
-    end
-
-    allow(env).to receive(:matchable_scopes).and_return(
-      [raw_scope_a, raw_scope_b, raw_scope_c].map do |raw_scope|
-        Mutant::Scope.new(raw_scope, parse_expression(raw_scope.name))
-      end
-    )
-  end
-
-  it 'returns subjects' do
-    expect(object.call(env)).to eql([subject_a, subject_b])
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Null, '#call' do
-  let(:object) { described_class.new          }
-  let(:env)    { instance_double(Mutant::Env) }
-
-  subject { object.call(env) }
-
-  it 'returns no subjects' do
-    should eql([])
-  end
-end

data/spec/unit/mutant/matcher/scope_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Scope, '#call' do
-  let(:scope)     { TestApp }
-  let(:object)    { described_class.new(scope)       }
-  let(:env)       { instance_double(Mutant::Env)     }
-  let(:matcher_a) { instance_double(Mutant::Matcher) }
-  let(:matcher_b) { instance_double(Mutant::Matcher) }
-  let(:subject_a) { instance_double(Mutant::Subject) }
-  let(:subject_b) { instance_double(Mutant::Subject) }
-
-  subject { object.call(env) }
-
-  before do
-    expect(Mutant::Matcher::Methods::Singleton).to receive(:new)
-      .with(scope)
-      .and_return(matcher_a)
-
-    expect(Mutant::Matcher::Methods::Instance).to receive(:new)
-      .with(scope)
-      .and_return(matcher_b)
-
-    expect(matcher_a).to receive(:call)
-      .with(env)
-      .and_return([subject_a])
-
-    expect(matcher_b).to receive(:call)
-      .with(env)
-      .and_return([subject_b])
-  end
-
-  it 'concatenates subjects from matched singleton and instance methods' do
-    should eql([subject_a, subject_b])
-  end
-end

data/spec/unit/mutant/matcher/static_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Static, '#call' do
-  let(:object)   { described_class.new(subjects) }
-  let(:env)      { instance_double(Mutant::Env)  }
-  let(:subjects) { instance_double(Array)        }
-
-  subject { object.call(env) }
-
-  it 'returns its predefined subjects' do
-    should be(subjects)
-  end
-end

data/spec/unit/mutant/matcher_spec.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher do
-  describe '.from_config' do
-    def apply
-      described_class.from_config(config)
-    end
-
-    let(:anon_matcher)       { instance_double(Mutant::Matcher)    }
-    let(:env)                { instance_double(Mutant::Env)        }
-    let(:ignore_expressions) { []                                  }
-    let(:match_expression_a) { expression('Foo::Bar#a', matcher_a) }
-    let(:match_expression_b) { expression('Foo::Bar#b', matcher_b) }
-    let(:subject_filters)    { []                                  }
-
-    let(:matcher_a) do
-      instance_double(Mutant::Matcher, call: [subject_a])
-    end
-
-    let(:matcher_b) do
-      instance_double(Mutant::Matcher, call: [subject_b])
-    end
-
-    let(:expression_class) do
-      Class.new(Mutant::Expression) do
-        include Concord.new(:child, :matcher)
-
-        %w[syntax prefix?].each do |name|
-          define_method(name) do |*arguments, &block|
-            child.public_send(name, *arguments, &block)
-          end
-        end
-
-        public :matcher
-      end
-    end
-
-    let(:config) do
-      Mutant::Matcher::Config.new(
-        ignore_expressions: ignore_expressions,
-        match_expressions:  [match_expression_a, match_expression_b],
-        subject_filters:    subject_filters
-      )
-    end
-
-    let(:subject_a) do
-      instance_double(Mutant::Subject, 'subject a', expression: expression('Foo::Bar#a'))
-    end
-
-    let(:subject_b) do
-      instance_double(Mutant::Subject, 'subject b', expression: expression('Foo::Bar#b'))
-    end
-
-    def expression(input, matcher = anon_matcher)
-      expression_class.new(parse_expression(input), matcher)
-    end
-
-    context 'empty ignores and empty filter' do
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([subject_a, subject_b])
-      end
-    end
-
-    context 'with ignore matching a subject' do
-      let(:ignore_expressions) { [subject_b.expression] }
-
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([subject_a])
-      end
-    end
-
-    context 'with ignore matching many subjects' do
-      let(:ignore_expressions) { [expression('Foo*')] }
-
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([])
-      end
-    end
-
-    context 'with subject filter' do
-      let(:subject_filters) do
-        [subject_a.method(:eql?)]
-      end
-
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([subject_a])
-      end
-    end
-
-    context 'with subject ignore and filter' do
-      let(:ignore_expressions) { [subject_b.expression] }
-
-      let(:subject_filters) do
-        [subject_b.method(:eql?)]
-      end
-
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([])
-      end
-    end
-  end
-end

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