defmastership 1.0.17 → 1.0.18

data/spec/unit/def_mastership/csv_formatter_spec.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require('csv')
-require('defmastership')
+require('defmastership/csv_formatter')
 require('ostruct')
 
 RSpec.describe(DefMastership::CSVFormatter) do
@@ -16,15 +16,22 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
   describe '#export_to' do
     let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
-    let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
-    let(:csv)  { instance_double(CSV, 'csv')                              }
+    let(:bodies) do
+      [
+        instance_double(DefMastership::CSVFormatterBody, 'bodies[0]'),
+        instance_double(DefMastership::CSVFormatterBody, 'bodies[1]')
+      ]
+    end
+    let(:csv) { instance_double(CSV, 'csv') }
 
     before do
-      allow(CSV).to(receive(:open).and_yield(csv))
+      allow(CSV).to(receive(:open).with('whatever', 'w:ISO-8859-1', col_sep: ';').and_yield(csv))
       allow(csv).to(receive(:<<))
       allow(DefMastership::CSVFormatterHeader).to(receive(:new).with(document).and_return(header))
-      allow(DefMastership::CSVFormatterBody).to(receive(:new).with(document).and_return(body))
-      allow(document).to(receive(:definitions).and_return(%i[def1 def2]))
+      bodies.each_with_index do |body, index|
+        allow(DefMastership::CSVFormatterBody).to(receive(:new).with(document, :"def#{index}").and_return(body))
+      end
+      allow(document).to(receive(:definitions).and_return(%i[def0 def1]))
       allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
       allow(document).to(receive(:explicit_version?).with(no_args).and_return(false))
       allow(document).to(receive(:labels).with(no_args).and_return([]))
@@ -39,21 +46,26 @@ RSpec.describe(DefMastership::CSVFormatter) do
       before do
         methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
-          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+          bodies.each_with_index do |body, index|
+            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+          end
         end
         formatter.export_to('whatever')
       end
 
+      it { expect(CSV).to(have_received(:open).with('whatever', 'w:ISO-8859-1', col_sep: ';')) }
+
       methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
-        it { expect(body).to(have_received(method).with(:def1)) }
-        it { expect(body).to(have_received(method).with(:def2)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
       end
 
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
     context 'when wrong_explicit_checksum' do
@@ -62,8 +74,9 @@ RSpec.describe(DefMastership::CSVFormatter) do
       before do
         methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
-          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+          bodies.each_with_index do |body, index|
+            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+          end
         end
         allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
         formatter.export_to('whatever')
@@ -71,13 +84,15 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
       methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
-        it { expect(body).to(have_received(method).with(:def1)) }
-        it { expect(body).to(have_received(method).with(:def2)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
       end
 
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
     context 'when explicit_version' do
@@ -86,8 +101,9 @@ RSpec.describe(DefMastership::CSVFormatter) do
       before do
         methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
-          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+          bodies.each_with_index do |body, index|
+            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+          end
         end
         allow(document).to(receive(:explicit_version?).with(no_args).and_return(true))
         formatter.export_to('whatever')
@@ -95,13 +111,15 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
       methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
-        it { expect(body).to(have_received(method).with(:def1)) }
-        it { expect(body).to(have_received(method).with(:def2)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
       end
 
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
     context 'when labels' do
@@ -110,8 +128,9 @@ RSpec.describe(DefMastership::CSVFormatter) do
       before do
         methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
-          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+          bodies.each_with_index do |body, index|
+            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+          end
         end
         allow(document).to(receive(:labels).with(no_args).and_return([:whatever]))
         formatter.export_to('whatever')
@@ -119,13 +138,15 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
       methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
-        it { expect(body).to(have_received(method).with(:def1)) }
-        it { expect(body).to(have_received(method).with(:def2)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
       end
 
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
     context 'when eref' do
@@ -134,8 +155,9 @@ RSpec.describe(DefMastership::CSVFormatter) do
       before do
         methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
-          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+          bodies.each_with_index do |body, index|
+            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+          end
         end
         allow(document).to(receive(:eref).with(no_args).and_return([:whatever]))
         formatter.export_to('whatever')
@@ -143,13 +165,15 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
       methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
-        it { expect(body).to(have_received(method).with(:def1)) }
-        it { expect(body).to(have_received(method).with(:def2)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
       end
 
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
     context 'when iref' do
@@ -158,8 +182,9 @@ RSpec.describe(DefMastership::CSVFormatter) do
       before do
         methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
-          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+          bodies.each_with_index do |body, index|
+            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+          end
         end
         allow(document).to(receive(:iref).with(no_args).and_return(true))
         formatter.export_to('whatever')
@@ -167,13 +192,15 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
       methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
-        it { expect(body).to(have_received(method).with(:def1)) }
-        it { expect(body).to(have_received(method).with(:def2)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
       end
 
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
     context 'when attributes' do
@@ -182,8 +209,9 @@ RSpec.describe(DefMastership::CSVFormatter) do
       before do
         methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
-          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+          bodies.each_with_index do |body, index|
+            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+          end
         end
         allow(document).to(receive(:attributes).with(no_args).and_return([:whatever]))
         formatter.export_to('whatever')
@@ -191,13 +219,15 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
       methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
-        it { expect(body).to(have_received(method).with(:def1)) }
-        it { expect(body).to(have_received(method).with(:def2)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
       end
 
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
     end
 
     context 'when every colums' do
@@ -206,8 +236,9 @@ RSpec.describe(DefMastership::CSVFormatter) do
       before do
         methods.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          allow(body).to(receive(method).with(:def1).and_return(["#{method} def1 body"]))
-          allow(body).to(receive(method).with(:def2).and_return(["#{method} def2 body"]))
+          bodies.each_with_index do |body, index|
+            allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+          end
         end
         allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
         allow(document).to(receive(:explicit_version?).with(no_args).and_return(true))
@@ -220,54 +251,15 @@ RSpec.describe(DefMastership::CSVFormatter) do
 
       methods.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
-        it { expect(body).to(have_received(method).with(:def1)) }
-        it { expect(body).to(have_received(method).with(:def2)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
       end
 
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def0 body" })) }
       it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def1 body" })) }
-      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} def2 body" })) }
-    end
-  end
-
-  context 'when #export_to csv file' do
-    let(:target_file) { 'export.csv' }
-    let(:definitions) { [double, double] }
-
-    before do
-      setup_aruba
-      allow(document).to(receive(:labels).with(no_args).and_return([]))
-      allow(document).to(receive(:eref).with(no_args).and_return({}))
-      allow(document).to(receive(:iref).with(no_args).and_return(false))
-      allow(document).to(receive(:attributes).with(no_args).and_return({}))
-      allow(document).to(receive(:definitions).with(no_args).and_return(definitions))
-      allow(definitions[0]).to(receive(:type).and_return('a'))
-      allow(definitions[0]).to(receive(:reference).and_return('b'))
-      allow(definitions[0]).to(receive(:value).and_return('c'))
-      allow(definitions[0]).to(receive(:sha256).and_return('d'))
-      allow(definitions[1]).to(receive(:type).and_return('d'))
-      allow(definitions[1]).to(receive(:reference).and_return('e'))
-      allow(definitions[1]).to(receive(:value).and_return('f'))
-      allow(definitions[1]).to(receive(:sha256).and_return('g'))
-      allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
-      allow(document).to(receive(:explicit_version?).with(no_args).and_return(false))
-      formatter.export_to("#{aruba.current_directory}/#{target_file}")
-    end
-
-    it { expect(document).to(have_received(:labels).with(no_args)) }
-    it { expect(document).to(have_received(:eref).with(no_args)) }
-    it { expect(document).to(have_received(:iref).with(no_args)) }
-    it { expect(document).to(have_received(:attributes).with(no_args)) }
-    it { expect(document).to(have_received(:definitions).with(no_args)) }
-    it { expect(document).to(have_received(:wrong_explicit_checksum?).with(no_args)) }
-    it { expect(document).to(have_received(:explicit_version?).with(no_args)) }
-
-    it do
-      expect(target_file).to(have_file_content(<<~CSV_FILE))
-        Type;Reference;Value;Checksum
-        a;b;c;d
-        d;e;f;g
-      CSV_FILE
     end
   end
 end

data/spec/unit/def_mastership/definition_parser_spec.rb

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/definition_parser')
 
 RSpec.describe(DefMastership::DefinitionParser) do
   subject(:parser) { described_class.new(callback_object) }

data/spec/unit/def_mastership/definition_spec.rb

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/definition')
 
 RSpec.describe(DefMastership::Definition) do
   describe '.new' do
@@ -101,9 +101,14 @@ RSpec.describe(DefMastership::Definition) do
       expect(definition.lines).to(eq(['first line', 'second line']))
     end
 
-    it 'calculates sha256 of value' do
+    it 'calculates sha256_short of value' do
       definition << 'first line' << 'second line'
-      expect(definition.sha256).to(eq('~beb0535a'))
+      expect(definition.sha256_short).to(eq('~beb0535a'))
+    end
+
+    it 'returns the definition and not the "line"' do
+      expect { (definition << 'first line').sha256_short }
+        .not_to(raise_error)
     end
   end
 
@@ -115,9 +120,14 @@ RSpec.describe(DefMastership::Definition) do
       )
     end
 
-    it 'shall accept to add one eref' do
-      definition.add_eref(:foo, '   tutu, titi  ,   pouet')
-      expect(definition.eref[:foo]).to(eq(%w[tutu titi pouet]))
+    [
+      'tutu,titi,pouet',
+      '   tutu    ,  titi  ,   pouet   '
+    ].each do |erefs_cs|
+      it 'shall accept to add comma separated erefs' do
+        definition.add_eref(:foo, erefs_cs)
+        expect(definition.eref[:foo]).to(eq(%w[tutu titi pouet]))
+      end
     end
   end
 

data/spec/unit/def_mastership/document_spec.rb

@@ -1,7 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/document')
 
 RSpec.describe(DefMastership::Document) do
   subject(:document) { described_class.new }
@@ -15,16 +15,32 @@ RSpec.describe(DefMastership::Document) do
     it { is_expected.to(have_attributes(variables: {})) }
   end
 
+  describe '.method_missing' do
+    it do
+      expect { document.not_implemented_random_method }
+        .to(raise_error(NoMethodError))
+    end
+  end
+
+  describe '.respond_to_missing?' do
+    it { expect(document.respond_to?(:add_new_definition)).to(be(true)) }
+    it { expect(document.respond_to?(:not_implemented_random_method)).to(be(false)) }
+  end
+
   describe '#parse' do
     context 'with valid definitions' do
       let(:definition) { instance_double(DefMastership::Definition, 'definition') }
 
       before do
         allow(DefMastership::Definition).to(receive(:new).and_return(definition))
-        allow(definition).to(receive(:labels).and_return(Set.new))
-        allow(definition).to(receive(:<<).and_return(definition))
-        allow(definition).to(receive(:add_eref).and_return(definition))
-        allow(definition).to(receive(:add_iref).and_return(definition))
+        allow(definition).to(
+          receive_messages(
+            labels: Set.new,
+            '<<': definition,
+            add_eref: definition,
+            add_iref: definition
+          )
+        )
       end
 
       context 'when simple definition line' do
@@ -401,8 +417,12 @@ RSpec.describe(DefMastership::Document) do
 
       before do
         allow(DefMastership::Definition).to(receive(:new).and_return(definition))
-        allow(definition).to(receive(:labels).and_return(Set.new))
-        allow(definition).to(receive(:<<).and_return(definition))
+        allow(definition).to(
+          receive_messages(
+            labels: Set.new,
+            '<<': definition
+          )
+        )
         document.parse(input_lines)
       end
 
@@ -431,6 +451,18 @@ RSpec.describe(DefMastership::Document) do
         it { expect(definition).to(have_received(:<<).with('bef {variable} aft')) }
       end
 
+      context 'when badly defined variable' do
+        let(:input_lines) do
+          [
+            ':variable:one value',
+            '[define, requirement, TOTO-0001]',
+            'bef {variable} aft'
+          ]
+        end
+
+        it { expect(definition).to(have_received(:<<).with('bef {variable} aft')) }
+      end
+
       context 'when multiple defined variables' do
         let(:input_lines) do
           [
@@ -503,8 +535,12 @@ RSpec.describe(DefMastership::Document) do
       allow(adoc_doc).to(receive(:reader).and_return(adoc_reader))
       allow(adoc_reader).to(receive(:read_lines).and_return(input_lines))
       allow(DefMastership::Definition).to(receive(:new).and_return(definition))
-      allow(definition).to(receive(:<<).and_return(definition))
-      allow(definition).to(receive(:labels).and_return(Set.new))
+      allow(definition).to(
+        receive_messages(
+          '<<': definition,
+          labels: Set.new
+        )
+      )
       document.parse_file_with_preprocessor('the_file.adoc')
     end
 
@@ -539,30 +575,29 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
-      allow(defs[0]).to(receive(:labels)).and_return([])
-      allow(defs[1]).to(receive(:labels)).and_return([])
-      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
-      allow(defs[1]).to(receive(:<<).and_return(defs[1]))
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs.first, defs[1]))
+      defs.each do |definition|
+        allow(definition).to(receive(:labels)).and_return([])
+        allow(definition).to(receive(:<<)).and_return(definition)
+      end
     end
 
     context 'when no wrong explicit checksum' do
       before do
-        allow(defs[0]).to(receive(:wrong_explicit_checksum)).and_return(nil)
-        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return(nil)
+        defs.each { |definition| allow(definition).to(receive(:wrong_explicit_checksum)).and_return(nil) }
         document.parse(input_lines)
         document.wrong_explicit_checksum?
       end
 
-      it { expect(defs[0]).to(have_received(:wrong_explicit_checksum)) }
+      it { expect(defs.first).to(have_received(:wrong_explicit_checksum)) }
       it { expect(defs[1]).to(have_received(:wrong_explicit_checksum)) }
       it { expect(document.wrong_explicit_checksum?).to(be(false)) }
     end
 
     context 'when one req has wrong explicit checksum' do
       before do
-        allow(defs[0]).to(receive(:wrong_explicit_checksum)).and_return(nil)
-        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return('toto')
+        allow(defs.first).to(receive(:wrong_explicit_checksum)).and_return('toto')
+        allow(defs[1]).to(receive(:wrong_explicit_checksum)).and_return(nil)
         document.parse(input_lines)
         document.wrong_explicit_checksum?
       end
@@ -589,30 +624,30 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
-      allow(defs[0]).to(receive(:labels)).and_return([])
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs.first, defs[1]))
+      allow(defs.first).to(receive(:labels)).and_return([])
       allow(defs[1]).to(receive(:labels)).and_return([])
-      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
+      allow(defs.first).to(receive(:<<).and_return(defs.first))
       allow(defs[1]).to(receive(:<<).and_return(defs[1]))
     end
 
     context 'when no explicit version' do
       before do
-        allow(defs[0]).to(receive(:explicit_version)).and_return(nil)
+        allow(defs.first).to(receive(:explicit_version)).and_return(nil)
         allow(defs[1]).to(receive(:explicit_version)).and_return(nil)
         document.parse(input_lines)
         document.explicit_version?
       end
 
-      it { expect(defs[0]).to(have_received(:explicit_version)) }
+      it { expect(defs.first).to(have_received(:explicit_version)) }
       it { expect(defs[1]).to(have_received(:explicit_version)) }
       it { expect(document.explicit_version?).to(be(false)) }
     end
 
     context 'when one req has explicit version' do
       before do
-        allow(defs[0]).to(receive(:explicit_version)).and_return(nil)
-        allow(defs[1]).to(receive(:explicit_version)).and_return('toto')
+        allow(defs.first).to(receive(:explicit_version)).and_return('toto')
+        allow(defs[1]).to(receive(:explicit_version)).and_return(nil)
         document.parse(input_lines)
         document.explicit_version?
       end
@@ -622,10 +657,10 @@ RSpec.describe(DefMastership::Document) do
   end
 
   describe '#ref_to_def?' do
-    let(:defs) do
+    let(:definitions) do
       [
-        instance_double(DefMastership::Definition, 'definition'),
-        instance_double(DefMastership::Definition, 'definition')
+        instance_double(DefMastership::Definition, 'def1'),
+        instance_double(DefMastership::Definition, 'def2')
       ]
     end
     let(:input_lines) do
@@ -639,17 +674,25 @@ RSpec.describe(DefMastership::Document) do
     end
 
     before do
-      allow(DefMastership::Definition).to(receive(:new).twice.and_return(defs[0], defs[1]))
-      allow(defs[0]).to(receive(:labels)).and_return([])
-      allow(defs[1]).to(receive(:labels)).and_return([])
-      allow(defs[0]).to(receive(:<<).and_return(defs[0]))
-      allow(defs[1]).to(receive(:<<).and_return(defs[1]))
-      allow(defs[0]).to(receive(:reference).and_return('TOTO-0001'))
-      allow(defs[1]).to(receive(:reference).and_return('TOTO-0002'))
+      allow(DefMastership::Definition).to(receive(:new).twice.and_return(definitions.first, definitions[1]))
+      allow(definitions.first).to(
+        receive_messages(
+          labels: [],
+          '<<': definitions.first,
+          reference: 'TOTO-0001'
+        )
+      )
+      allow(definitions[1]).to(
+        receive_messages(
+          labels: [],
+          '<<': definitions[1],
+          reference: 'TOTO-0002'
+        )
+      )
       document.parse(input_lines)
     end
 
-    it { expect(document.ref_to_def('TOTO-0001')).to(eq(defs[0])) }
-    it { expect(document.ref_to_def('TOTO-0002')).to(eq(defs[1])) }
+    it { expect(document.ref_to_def('TOTO-0001')).to(eq(definitions.first)) }
+    it { expect(document.ref_to_def('TOTO-0002')).to(eq(definitions[1])) }
   end
 end

data/spec/unit/def_mastership/matching_line_spec.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2024 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/matching_line')
+
+RSpec.describe(DefMastership::MatchingLine) do
+  describe '.new' do
+    subject(:matching_line) do
+      described_class.new(:a_match, :a_line)
+    end
+
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(match: :a_match)) }
+    it { is_expected.to(have_attributes(line: :a_line)) }
+  end
+
+  describe '#[]' do
+    subject(:matching_line) do
+      described_class.new(match, :a_line)
+    end
+
+    let(:match) { instance_double(Hash, 'match') }
+
+    before do
+      allow(match).to(receive(:[]).with(:whatever).and_return('Whatever'))
+      allow(match).to(receive(:[]).with(:line).and_return(nil))
+    end
+
+    it do
+      matching_line[:whatever]
+      expect(match).to(have_received(:[]).with(:whatever))
+    end
+
+    it { expect(matching_line[:whatever]).to(eq('Whatever')) }
+    it { expect(matching_line[:line]).to(eq(:a_line)) }
+  end
+end