defmastership 1.0.17 → 1.0.19

data/spec/unit/def_mastership/csv_formatter_body_spec.rb

@@ -1,10 +1,10 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/csv_formatter_body')
 
 RSpec.describe(DefMastership::CSVFormatterBody) do
-  subject(:formatter) { described_class.new(document) }
+  subject(:formatter) { described_class.new(document, definition) }
 
   let(:document)   { instance_double(DefMastership::Document, 'document')     }
   let(:definition) { instance_double(DefMastership::Definition, 'definition') }
@@ -18,35 +18,35 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       allow(definition).to(receive(:type).with(no_args).and_return('a'))
       allow(definition).to(receive(:reference).with(no_args).and_return('b'))
       allow(definition).to(receive(:value).with(no_args).and_return('c'))
-      allow(definition).to(receive(:sha256).with(no_args).and_return('d'))
-      formatter.fixed(definition)
+      allow(definition).to(receive(:sha256_short).with(no_args).and_return('d'))
+      formatter.fixed
     end
 
     it { expect(definition).to(have_received(:type).with(no_args)) }
     it { expect(definition).to(have_received(:reference).with(no_args)) }
     it { expect(definition).to(have_received(:value).with(no_args)) }
-    it { expect(definition).to(have_received(:sha256).with(no_args)) }
-    it { expect(formatter.fixed(definition)).to(eq(%w[a b c d])) }
+    it { expect(definition).to(have_received(:sha256_short).with(no_args)) }
+    it { expect(formatter.fixed).to(eq(%w[a b c d])) }
   end
 
   describe '#wrong_explicit_checksum' do
     context 'when no wrong_explicit checksum' do
       before do
         allow(definition).to(receive(:wrong_explicit_checksum).with(no_args).and_return(nil))
-        formatter.wrong_explicit_checksum(definition)
+        formatter.wrong_explicit_checksum
       end
 
       it { expect(definition).to(have_received(:wrong_explicit_checksum).with(no_args)) }
-      it { expect(formatter.wrong_explicit_checksum(definition)).to(eq([''])) }
+      it { expect(formatter.wrong_explicit_checksum).to(eq([''])) }
     end
 
     context 'when explicit checksum' do
       before do
         allow(definition).to(receive(:wrong_explicit_checksum).with(no_args).and_return('ab12'))
-        formatter.wrong_explicit_checksum(definition)
+        formatter.wrong_explicit_checksum
       end
 
-      it { expect(formatter.wrong_explicit_checksum(definition)).to(eq(['ab12'])) }
+      it { expect(formatter.wrong_explicit_checksum).to(eq(['ab12'])) }
     end
   end
 
@@ -54,20 +54,20 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no explicit_version' do
       before do
         allow(definition).to(receive(:explicit_version).with(no_args).and_return(nil))
-        formatter.explicit_version(definition)
+        formatter.explicit_version
       end
 
       it { expect(definition).to(have_received(:explicit_version).with(no_args)) }
-      it { expect(formatter.explicit_version(definition)).to(eq([''])) }
+      it { expect(formatter.explicit_version).to(eq([''])) }
     end
 
     context 'when explicit_version' do
       before do
         allow(definition).to(receive(:explicit_version).with(no_args).and_return('ab12'))
-        formatter.explicit_version(definition)
+        formatter.explicit_version
       end
 
-      it { expect(formatter.explicit_version(definition)).to(eq(['ab12'])) }
+      it { expect(formatter.explicit_version).to(eq(['ab12'])) }
     end
   end
 
@@ -77,21 +77,21 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no labels on definition' do
       before do
         allow(definition).to(receive(:labels).with(no_args).and_return([]))
-        formatter.labels(definition)
+        formatter.labels
       end
 
       it { expect(definition).to(have_received(:labels).once.with(no_args)) }
-      it { expect(formatter.labels(definition)).to(eq([''])) }
+      it { expect(formatter.labels).to(eq([''])) }
     end
 
     context 'when labels on definition' do
       before do
-        allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu]))
-        formatter.labels(definition)
+        allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu].to_set))
+        formatter.labels
       end
 
       it { expect(definition).to(have_received(:labels).once.with(no_args)) }
-      it { expect(formatter.labels(definition)).to(eq(["toto\ntutu"])) }
+      it { expect(formatter.labels).to(eq(["toto\ntutu"])) }
     end
   end
 
@@ -99,11 +99,11 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no eref on the document' do
       before do
         allow(document).to(receive(:eref).with(no_args).and_return({}))
-        formatter.eref(definition)
+        formatter.eref
       end
 
       it { expect(document).to(have_received(:eref).with(no_args)) }
-      it { expect(formatter.eref(nil)).to(eq([])) }
+      it { expect(formatter.eref).to(eq([])) }
     end
 
     context 'when eref on the document' do
@@ -114,11 +114,26 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
           )
         )
         allow(definition).to(receive(:eref).with(no_args).and_return(a: %w[A B], b: [], c: ['C']))
-        formatter.eref(definition)
+        formatter.eref
       end
 
       it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
-      it { expect(formatter.eref(definition)).to(eq(["A\nB", '', 'C'])) }
+      it { expect(formatter.eref).to(eq(["A\nB", '', 'C'])) }
+    end
+
+    context 'when missing eref on the definition' do
+      before do
+        allow(document).to(
+          receive(:eref).with(no_args).and_return(
+            a: 'whatever', b: 'whatever'
+          )
+        )
+        allow(definition).to(receive(:eref).with(no_args).and_return(b: ['B']))
+        formatter.eref
+      end
+
+      it { expect(definition).to(have_received(:eref).exactly(2).times.with(no_args)) }
+      it { expect(formatter.eref).to(eq(['', 'B'])) }
     end
   end
 
@@ -128,21 +143,21 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no iref on the definition' do
       before do
         allow(definition).to(receive(:iref).with(no_args).and_return([]))
-        formatter.iref(definition)
+        formatter.iref
       end
 
       it { expect(definition).to(have_received(:iref).with(no_args)) }
-      it { expect(formatter.iref(definition)).to(eq([''])) }
+      it { expect(formatter.iref).to(eq([''])) }
     end
 
     context 'when iref on the definition' do
       before do
         allow(definition).to(receive(:iref).with(no_args).and_return(%w[A B]))
-        formatter.iref(definition)
+        formatter.iref
       end
 
       it { expect(definition).to(have_received(:iref).with(no_args)) }
-      it { expect(formatter.iref(definition)).to(eq(["A\nB"])) }
+      it { expect(formatter.iref).to(eq(["A\nB"])) }
     end
   end
 
@@ -150,11 +165,11 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     context 'when no attributes on the document' do
       before do
         allow(document).to(receive(:attributes).with(no_args).and_return({}))
-        formatter.attributes(definition)
+        formatter.attributes
       end
 
       it { expect(document).to(have_received(:attributes).with(no_args)) }
-      it { expect(formatter.attributes(nil)).to(eq([])) }
+      it { expect(formatter.attributes).to(eq([])) }
     end
 
     context 'when attributes on the document' do
@@ -164,11 +179,25 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
             .and_return(a: 'whatever', b: 'whatever', c: 'whatever')
         )
         allow(definition).to(receive(:attributes).and_return(a: 'X', b: '', c: 'Y'))
-        formatter.attributes(definition)
+        formatter.attributes
+      end
+
+      it { expect(definition).to(have_received(:attributes).exactly(3).times) }
+      it { expect(formatter.attributes).to(eq(['X', '', 'Y'])) }
+    end
+
+    context 'when miing attribute on the definition' do
+      before do
+        allow(document).to(
+          receive(:attributes).with(no_args)
+            .and_return(a: 'whatever', b: 'whatever', c: 'whatever')
+        )
+        allow(definition).to(receive(:attributes).and_return(a: 'X', b: ''))
+        formatter.attributes
       end
 
       it { expect(definition).to(have_received(:attributes).exactly(3).times) }
-      it { expect(formatter.attributes(definition)).to(eq(['X', '', 'Y'])) }
+      it { expect(formatter.attributes).to(eq(['X', '', ''])) }
     end
   end
 end

data/spec/unit/def_mastership/csv_formatter_header_spec.rb

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

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