141 lines
3.3 KiB
Ruby
141 lines
3.3 KiB
Ruby
RSpec.describe Mutant::Subject do
|
|
let(:class_under_test) do
|
|
Class.new(described_class) do
|
|
def expression
|
|
Mutant::Expression.parse('SubjectA')
|
|
end
|
|
|
|
def match_expressions
|
|
[expression] << Mutant::Expression.parse('SubjectB')
|
|
end
|
|
end
|
|
end
|
|
|
|
let(:object) { class_under_test.new(config, context, node) }
|
|
|
|
let(:config) { Mutant::Config::DEFAULT }
|
|
|
|
let(:node) do
|
|
Parser::CurrentRuby.parse(<<-RUBY)
|
|
def foo
|
|
end
|
|
RUBY
|
|
end
|
|
|
|
let(:location) do
|
|
double('Location', expression: expression)
|
|
end
|
|
|
|
let(:expression) do
|
|
double('Expression', line: 'source_line')
|
|
end
|
|
|
|
let(:context) do
|
|
double(
|
|
'Context',
|
|
source_path: 'source_path',
|
|
source_line: 'source_line'
|
|
)
|
|
end
|
|
|
|
describe '#identification' do
|
|
subject { object.identification }
|
|
|
|
it { should eql('SubjectA:source_path:1') }
|
|
end
|
|
|
|
describe '#source_line' do
|
|
subject { object.source_line }
|
|
|
|
it { should be(1) }
|
|
end
|
|
|
|
describe '#source_lines' do
|
|
subject { object.source_lines }
|
|
|
|
it { should eql(1..2) }
|
|
end
|
|
|
|
describe '#prepare' do
|
|
subject { object.prepare }
|
|
|
|
it_should_behave_like 'a command method'
|
|
end
|
|
|
|
describe '#tests' do
|
|
let(:config) { Mutant::Config::DEFAULT.update(integration: integration) }
|
|
let(:integration) { double('Integration', all_tests: all_tests) }
|
|
let(:test_a) { double('test', expression: Mutant::Expression.parse('SubjectA')) }
|
|
let(:test_b) { double('test', expression: Mutant::Expression.parse('SubjectB')) }
|
|
let(:test_c) { double('test', expression: Mutant::Expression.parse('SubjectC')) }
|
|
|
|
subject { object.tests }
|
|
|
|
context 'without available tests' do
|
|
let(:all_tests) { [] }
|
|
|
|
it { should eql([]) }
|
|
|
|
it_should_behave_like 'an idempotent method'
|
|
end
|
|
|
|
context 'without qualifying tests' do
|
|
let(:all_tests) { [test_c] }
|
|
|
|
it { should eql([]) }
|
|
|
|
it_should_behave_like 'an idempotent method'
|
|
end
|
|
|
|
context 'with qualifying tests for first match expression' do
|
|
let(:all_tests) { [test_a] }
|
|
|
|
it { should eql([test_a]) }
|
|
|
|
it_should_behave_like 'an idempotent method'
|
|
end
|
|
|
|
context 'with qualifying tests for second match expression' do
|
|
let(:all_tests) { [test_b] }
|
|
|
|
it { should eql([test_b]) }
|
|
|
|
it_should_behave_like 'an idempotent method'
|
|
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]) }
|
|
|
|
it_should_behave_like 'an idempotent method'
|
|
end
|
|
end
|
|
|
|
describe '#node' do
|
|
subject { object.node }
|
|
|
|
it { should be(node) }
|
|
|
|
it_should_behave_like 'an idempotent method'
|
|
end
|
|
|
|
describe '#mutations' do
|
|
subject { object.mutations }
|
|
|
|
before do
|
|
expect(Mutant::Mutator).to receive(:each).with(node).and_yield(mutation_a).and_yield(mutation_b)
|
|
end
|
|
|
|
let(:mutation_a) { double('Mutation A') }
|
|
let(:mutation_b) { double('Mutation B') }
|
|
|
|
it 'generates neutral and evil mutations' do
|
|
should eql([
|
|
Mutant::Mutation::Neutral.new(object, node),
|
|
Mutant::Mutation::Evil.new(object, mutation_a),
|
|
Mutant::Mutation::Evil.new(object, mutation_b)
|
|
])
|
|
end
|
|
end
|
|
end
|