mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/matcher/method/singleton_spec.rb

@@ -0,0 +1,85 @@
+RSpec.describe Mutest::Matcher::Method::Singleton, '#call' do
+  subject { object.call(env) }
+
+  let(:object)       { described_class.new(scope, method)                }
+  let(:method)       { scope.method(method_name)                         }
+  let(:type)         { :defs                                             }
+  let(:method_name)  { :foo                                              }
+  let(:method_arity) { 0                                                 }
+  let(:base)         { TestApp::SingletonMethodTests                     }
+  let(:source_path)  { MutestSpec::ROOT.join('test_app/lib/test_app.rb') }
+
+  let(:env) do
+    instance_double(
+      Mutest::Env::Bootstrap,
+      config: Mutest::Config::DEFAULT,
+      parser: Fixtures::TEST_ENV.parser
+    )
+  end
+
+  def name
+    node.children.fetch(1)
+  end
+
+  def arguments
+    node.children.fetch(2)
+  end
+
+  let(:source_file) do
+    Mutest::SourceFile.new(
+      source_path,
+      *Parser::CurrentRuby.parse_with_comments(source_path.read)
+    )
+  end
+
+  context 'when also defined on lvar' do
+    let(:scope) { base::DefinedOnLvar }
+    let(:expected_warnings) do
+      [
+        'Can only match :defs on :self or :const got :lvar unable to match'
+      ]
+    end
+
+    include_examples 'skipped candidate'
+  end
+
+  context 'when defined on self' do
+    let(:scope)       { base::DefinedOnSelf }
+    let(:method_line) { 61                  }
+
+    it_should_behave_like 'a method matcher'
+  end
+
+  context 'when defined on constant' do
+    context 'inside namespace' do
+      let(:scope)       { base::DefinedOnConstant::InsideNamespace }
+      let(:method_line) { 71                                       }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'outside namespace' do
+      let(:scope)       { base::DefinedOnConstant::OutsideNamespace }
+      let(:method_line) { 78                                        }
+
+      it_should_behave_like 'a method matcher'
+    end
+  end
+
+  context 'when defined multiple times in the same line' do
+    context 'with method on different scope' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLine::DifferentScope }
+      let(:method_line)  { 97                                                   }
+      let(:method_arity) { 1                                                    }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'with different name' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLine::DifferentName }
+      let(:method_line)  { 101                                                 }
+
+      it_should_behave_like 'a method matcher'
+    end
+  end
+end

data/spec/unit/mutest/matcher/methods/instance_spec.rb

@@ -0,0 +1,58 @@
+RSpec.describe Mutest::Matcher::Methods::Instance, '#call' do
+  let(:object) { described_class.new(class_under_test) }
+  let(:env)    { Fixtures::TEST_ENV                    }
+
+  let(:class_under_test) do
+    parent =
+      Module.new do
+        def method_d
+        end
+
+        def method_e
+        end
+      end
+
+    Class.new do
+      include parent
+
+      private :method_d
+
+      def method_a
+      end
+
+      protected
+
+      def method_b
+      end
+
+      private
+
+      def method_c
+      end
+    end
+  end
+
+  let(:subject_a) { instance_double(Mutest::Subject) }
+  let(:subject_b) { instance_double(Mutest::Subject) }
+  let(:subject_c) { instance_double(Mutest::Subject) }
+  let(:subjects)  { [subject_a, subject_b, subject_c] }
+
+  before do
+    {
+      method_a: subject_a,
+      method_b: subject_b,
+      method_c: subject_c
+    }.each do |method, subject|
+      matcher = instance_double(Mutest::Matcher)
+      expect(matcher).to receive(:call).with(env).and_return([subject])
+
+      expect(Mutest::Matcher::Method::Instance).to receive(:new)
+        .with(class_under_test, class_under_test.instance_method(method))
+        .and_return(matcher)
+    end
+  end
+
+  it 'returns expected subjects' do
+    expect(object.call(env)).to eql(subjects)
+  end
+end

data/spec/unit/mutest/matcher/methods/singleton_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe Mutest::Matcher::Methods::Singleton, '#call' do
+  let(:object) { described_class.new(class_under_test) }
+  let(:env)    { Fixtures::TEST_ENV                    }
+
+  let(:class_under_test) do
+    parent =
+      Module.new do
+        def method_d
+        end
+
+        def method_e
+        end
+      end
+
+    Class.new do
+      extend parent
+
+      def self.method_a
+      end
+
+      def self.method_b
+      end
+      class << self; protected :method_b; end
+
+      def self.method_c
+      end
+      private_class_method :method_c
+    end
+  end
+
+  let(:subject_a) { instance_double(Mutest::Subject, 'A') }
+  let(:subject_b) { instance_double(Mutest::Subject, 'B') }
+  let(:subject_c) { instance_double(Mutest::Subject, 'C') }
+
+  let(:subjects) { [subject_a, subject_b, subject_c] }
+
+  before do
+    matcher = Mutest::Matcher::Method::Singleton
+
+    {
+      method_a: subject_a,
+      method_b: subject_b,
+      method_c: subject_c
+    }.each do |method, subject|
+      allow(matcher).to receive(:new)
+        .with(class_under_test, class_under_test.method(method))
+        .and_return(Mutest::Matcher::Static.new([subject]))
+    end
+  end
+
+  it 'returns expected subjects' do
+    expect(object.call(env)).to eql(subjects)
+  end
+end

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

@@ -0,0 +1,35 @@
+RSpec.describe Mutest::Matcher::Namespace, '#call' do
+  let(:object)      { described_class.new(parse_expression('TestApp*')) }
+  let(:env)         { instance_double(Mutest::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(Mutest::Subject)                  }
+  let(:subject_b)   { instance_double(Mutest::Subject)                  }
+
+  before do
+    [
+      [Mutest::Matcher::Methods::Singleton, raw_scope_b, [subject_b]],
+      [Mutest::Matcher::Methods::Instance,  raw_scope_b, []],
+      [Mutest::Matcher::Methods::Singleton, raw_scope_a, [subject_a]],
+      [Mutest::Matcher::Methods::Instance,  raw_scope_a, []]
+    ].each do |klass, scope, subjects|
+      matcher = instance_double(Mutest::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|
+        Mutest::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/mutest/matcher/null_spec.rb

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

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

@@ -0,0 +1,33 @@
+RSpec.describe Mutest::Matcher::Scope, '#call' do
+  subject { object.call(env) }
+
+  let(:scope)     { TestApp }
+  let(:object)    { described_class.new(scope)       }
+  let(:env)       { instance_double(Mutest::Env)     }
+  let(:matcher_a) { instance_double(Mutest::Matcher) }
+  let(:matcher_b) { instance_double(Mutest::Matcher) }
+  let(:subject_a) { instance_double(Mutest::Subject) }
+  let(:subject_b) { instance_double(Mutest::Subject) }
+
+  before do
+    expect(Mutest::Matcher::Methods::Singleton).to receive(:new)
+      .with(scope)
+      .and_return(matcher_a)
+
+    expect(Mutest::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
+    is_expected.to eql([subject_a, subject_b])
+  end
+end

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

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

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

@@ -0,0 +1,123 @@
+RSpec.describe Mutest::Meta::Example::DSL do
+  describe '.call' do
+    subject { described_class.call(file, type, block) }
+
+    let(:file)     { 'foo.rb'  }
+    let(:node)     { s(:false) }
+    let(:type)     { node.type }
+    let(:expected) { []        }
+
+    let(:expected_example) do
+      Mutest::Meta::Example.new(
+        file:      file,
+        node:      node,
+        node_type: type,
+        expected:  expected
+      )
+    end
+
+    def self.expect_example(&block)
+      let(:block) { block }
+
+      specify do
+        # Kill mutations to warnings
+        warnings =
+          Mutest::WarningFilter.use do
+            is_expected.to 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 'using #regexp_mutations' do
+      let(:expected) do
+        [s(:regexp, s(:regopt)), s(:regexp, s(:str, 'nomatch\\A'), s(:regopt))]
+      end
+
+      let(:node) do
+        s(:regexp, s(:str, 'foo'), s(:regopt))
+      end
+
+      expect_example do
+        source '/foo/'
+
+        regexp_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/mutest/meta/example/verification_spec.rb

@@ -0,0 +1,120 @@
+RSpec.describe Mutest::Meta::Example::Verification do
+  let(:object) { described_class.new(example, mutations) }
+
+  let(:example) do
+    Mutest::Meta::Example.new(
+      file:      'foo.rb',
+      node:      s(:true),
+      node_type: :true,
+      expected:  expected_nodes
+    )
+  end
+
+  let(:mutations) do
+    generated_nodes.map do |node|
+      Mutest::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 { is_expected.to be(true) }
+    end
+
+    context 'when expected node is missing' do
+      let(:expected_nodes) { [s(:false)] }
+
+      it { is_expected.to be(false) }
+    end
+
+    context 'when there is extra generated node' do
+      let(:generated_nodes) { [s(:false)] }
+
+      it { is_expected.to be(false) }
+    end
+
+    context 'when there is no diff to original source' do
+      let(:expected_nodes)  { [s(:true)] }
+      let(:generated_nodes) { [s(:true)] }
+
+      it { is_expected.to 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
+        is_expected.to eql(strip_indent(<<-'REPORT'))
+          ---
+          file: foo.rb
+          original_ast: s(:true)
+          original_source: 'true'
+          missing:
+          - node: s(:false)
+            source: 'false'
+          - node: s(:nil)
+            source: nil
+          unexpected: []
+          no_diff: []
+        REPORT
+      end
+    end
+
+    context 'when there is extra generated node' do
+      let(:generated_nodes) { [s(:false), s(:nil)] }
+
+      specify do
+        is_expected.to eql(strip_indent(<<-'REPORT'))
+          ---
+          file: foo.rb
+          original_ast: s(:true)
+          original_source: 'true'
+          missing: []
+          unexpected:
+          - node: s(:false)
+            source: 'false'
+          - node: s(:nil)
+            source: nil
+          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
+        is_expected.to eql(strip_indent(<<-'REPORT'))
+          ---
+          file: foo.rb
+          original_ast: s(:true)
+          original_source: 'true'
+          missing: []
+          unexpected: []
+          no_diff:
+          - node: s(:true)
+            source: 'true'
+        REPORT
+      end
+    end
+  end
+end