defmastership 1.0.7 → 1.0.8

data/lib/defmastership/csv_formatter_body.rb

@@ -19,8 +19,13 @@ module DefMastership
       wrong_explicit_checksum ? [wrong_explicit_checksum] : ['']
     end
 
+    def explicit_version(definition)
+      explicit_version = definition.explicit_version
+      explicit_version ? [explicit_version] : ['']
+    end
+
     def labels(definition)
-      @doc.labels.empty? ? [] : [definition.labels.to_a.join("\n")]
+      [definition.labels.to_a.join("\n")]
     end
 
     def eref(definition)
@@ -28,13 +33,11 @@ module DefMastership
     end
 
     def iref(definition)
-      @doc.iref ? [definition.iref.join("\n")] : []
+      [definition.iref.join("\n")]
     end
 
     def attributes(definition)
-      @doc.attributes.map do |key, _|
-        definition.attributes[key]
-      end
+      @doc.attributes.map { |key, _| definition.attributes[key] }
     end
   end
 end

data/lib/defmastership/csv_formatter_header.rb

@@ -11,13 +11,17 @@ module DefMastership
     end
 
     def fixed
-      %w[Type Reference Value sha256]
+      %w[Type Reference Value Checksum]
     end
 
     def wrong_explicit_checksum
       @doc.wrong_explicit_checksum? ? ['Wrong explicit checksum'] : []
     end
 
+    def explicit_version
+      @doc.explicit_version? ? ['Version'] : []
+    end
+
     def labels
       @doc.labels.empty? ? [] : %w[Labels]
     end

data/lib/defmastership/definition.rb

@@ -6,19 +6,19 @@ require 'digest'
 module DefMastership
   # DefMastership definition: contains all data of a definition
   class Definition
-    attr_reader :type, :reference, :lines, :labels, :eref, :iref, :attributes
+    attr_reader :type, :reference, :lines, :labels, :eref, :iref, :attributes, :explicit_version
 
     def initialize(match)
       @type = match[:type]
       @reference = match[:reference]
       @lines = []
       @labels = Set.new
-      labels = match[:labels]
-      @labels.merge(labels.split(/\s*,\s*/).to_set) if labels
+      @labels.merge(match[:labels].split(/\s*,\s*/).to_set) if match[:labels]
       @eref = Hash.new([])
       @iref = []
       @attributes = {}
       @explicit_checksum = match[:explicit_checksum]
+      @explicit_version = match[:explicit_version]
     end
 
     def <<(new_line)
@@ -31,7 +31,7 @@ module DefMastership
     end
 
     def sha256
-      Digest::SHA2.new(256).hexdigest(value).split(//).last(8).join
+      "~#{Digest::SHA2.new(256).hexdigest(value).split(//).last(8).join}"
     end
 
     def wrong_explicit_checksum

data/lib/defmastership/document.rb

@@ -18,7 +18,6 @@ module DefMastership
       @attributes    = {}
       @in_literal    = true
       @variables     = {}
-
       @definition_parser = DefinitionParser.new(self)
     end
 
@@ -44,6 +43,12 @@ module DefMastership
       end
     end
 
+    def explicit_version?
+      @definitions.reduce(false) do |res, definition|
+        res || !definition.explicit_version.nil?
+      end
+    end
+
     def code_block_delimiter(_match, line)
       @in_literal ^= true
       line
@@ -67,17 +72,12 @@ module DefMastership
 
     def new_eref_setup(match, line)
       @eref[match[:refname].to_sym] ||= {}
-
-      @eref[match[:refname].to_sym][match[:symb].to_sym] =
-        match[:value]
+      @eref[match[:refname].to_sym][match[:symb].to_sym] = match[:value]
       line
     end
 
     def new_eref_def(match, line)
-      @definitions.last.add_eref(
-        match[:refname].to_sym,
-        match[:extrefs]
-      )
+      @definitions.last.add_eref(match[:refname].to_sym, match[:extrefs])
       line
     end
 
@@ -95,10 +95,7 @@ module DefMastership
     end
 
     def new_attribute_value(match, line)
-      @definitions.last.set_attribute(
-        match[:attr].to_sym,
-        match[:value]
-      )
+      @definitions.last.set_attribute(match[:attr].to_sym, match[:value])
       line
     end
 
@@ -108,14 +105,13 @@ module DefMastership
     end
 
     def new_variable_use(_match, line)
-      new_line = line.dup
       line.scan(DMRegexp::VARIABLE_USE) do |_|
         varname = Regexp.last_match[:varname]
         next if @variables[varname.to_sym].nil?
 
-        new_line.gsub!("{#{varname}}", @variables[varname.to_sym])
+        line = line.gsub("{#{varname}}", @variables[varname.to_sym])
       end
-      new_line
+      line
     end
 
     private

data/lib/defmastership/version.rb

@@ -2,6 +2,6 @@
 # frozen_string_literal: true
 
 module DefMastership
-  VERSION = '1.0.7'
+  VERSION = '1.0.8'
   public_constant :VERSION
 end

data/spec/unit/defmastership/batch_modifier_spec.rb

@@ -111,5 +111,13 @@ RSpec.describe(DefMastership::BatchModifier) do
       it { is_expected.to(have_attributes(config: config_modified)) }
       it { is_expected.to(have_attributes(changes: [%w[modifier2 from1 to1], %w[modifier3 from2 to2]])) }
     end
+
+    context 'with wrong modification' do
+      it do
+        expect { batchmodifier.apply('wrong-modification') }.to(
+          raise_error(ArgumentError, 'wrong-modification is not a known modification')
+        )
+      end
+    end
   end
 end

data/spec/unit/defmastership/csv_formatter_body_spec.rb

@@ -23,13 +23,9 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     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])) }
   end
 
@@ -41,7 +37,6 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(definition).to(have_received(:wrong_explicit_checksum).with(no_args)) }
-
       it { expect(formatter.wrong_explicit_checksum(definition)).to(eq([''])) }
     end
 
@@ -55,42 +50,48 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
     end
   end
 
-  describe '#labels' do
-    context 'when no labels on document' do
+  describe '#explicit_version' do
+    context 'when no explicit_version' do
       before do
-        allow(document).to(receive(:labels).with(no_args).and_return([]))
-        formatter.labels(definition)
+        allow(definition).to(receive(:explicit_version).with(no_args).and_return(nil))
+        formatter.explicit_version(definition)
       end
 
-      it { expect(document).to(have_received(:labels).once.with(no_args)) }
-
-      it { expect(formatter.labels(definition)).to(eq([])) }
+      it { expect(definition).to(have_received(:explicit_version).with(no_args)) }
+      it { expect(formatter.explicit_version(definition)).to(eq([''])) }
     end
 
-    context 'when labels on document' do
-      before { allow(document).to(receive(:labels).with(no_args).and_return(['whatever'])) }
+    context 'when explicit_version' do
+      before do
+        allow(definition).to(receive(:explicit_version).with(no_args).and_return('ab12'))
+        formatter.explicit_version(definition)
+      end
 
-      context 'when no labels on definition' do
-        before do
-          allow(definition).to(receive(:labels).with(no_args).and_return([]))
-          formatter.labels(definition)
-        end
+      it { expect(formatter.explicit_version(definition)).to(eq(['ab12'])) }
+    end
+  end
 
-        it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+  describe '#labels' do
+    before { allow(document).to(receive(:labels).with(no_args).and_return(['whatever'])) }
 
-        it { expect(formatter.labels(definition)).to(eq([''])) }
+    context 'when no labels on definition' do
+      before do
+        allow(definition).to(receive(:labels).with(no_args).and_return([]))
+        formatter.labels(definition)
       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)
-        end
-
-        it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+      it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+      it { expect(formatter.labels(definition)).to(eq([''])) }
+    end
 
-        it { expect(formatter.labels(definition)).to(eq(["toto\ntutu"])) }
+    context 'when labels on definition' do
+      before do
+        allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu]))
+        formatter.labels(definition)
       end
+
+      it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+      it { expect(formatter.labels(definition)).to(eq(["toto\ntutu"])) }
     end
   end
 
@@ -102,7 +103,6 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(document).to(have_received(:eref).with(no_args)) }
-
       it { expect(formatter.eref(nil)).to(eq([])) }
     end
 
@@ -118,47 +118,31 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
-
       it { expect(formatter.eref(definition)).to(eq(["A\nB", '', 'C'])) }
     end
   end
 
   describe '#iref' do
-    context 'when no iref on the document' do
+    before { allow(document).to(receive(:iref).with(no_args).and_return(true)) }
+
+    context 'when no iref on the definition' do
       before do
-        allow(document).to(receive(:iref).with(no_args).and_return(false))
+        allow(definition).to(receive(:iref).with(no_args).and_return([]))
         formatter.iref(definition)
       end
 
-      it { expect(document).to(have_received(:iref).with(no_args)) }
-
-      it { expect(formatter.iref(definition)).to(eq([])) }
+      it { expect(definition).to(have_received(:iref).with(no_args)) }
+      it { expect(formatter.iref(definition)).to(eq([''])) }
     end
 
-    context 'when iref on the document' do
-      before { allow(document).to(receive(:iref).with(no_args).and_return(true)) }
-
-      context 'when no iref on the definition' do
-        before do
-          allow(definition).to(receive(:iref).with(no_args).and_return([]))
-          formatter.iref(definition)
-        end
-
-        it { expect(definition).to(have_received(:iref).with(no_args)) }
-
-        it { expect(formatter.iref(definition)).to(eq([''])) }
+    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)
       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)
-        end
-
-        it { expect(definition).to(have_received(:iref).with(no_args)) }
-
-        it { expect(formatter.iref(definition)).to(eq(["A\nB"])) }
-      end
+      it { expect(definition).to(have_received(:iref).with(no_args)) }
+      it { expect(formatter.iref(definition)).to(eq(["A\nB"])) }
     end
   end
 
@@ -170,7 +154,6 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(document).to(have_received(:attributes).with(no_args)) }
-
       it { expect(formatter.attributes(nil)).to(eq([])) }
     end
 
@@ -185,7 +168,6 @@ RSpec.describe(DefMastership::CSVFormatterBody) do
       end
 
       it { expect(definition).to(have_received(:attributes).exactly(3).times) }
-
       it { expect(formatter.attributes(definition)).to(eq(['X', '', 'Y'])) }
     end
   end

data/spec/unit/defmastership/csv_formatter_header_spec.rb

@@ -14,7 +14,29 @@ RSpec.describe(DefMastership::CSVFormatterHeader) do
 
   describe '#header' do
     describe '#fixed' do
-      it { expect(formatter.fixed).to(eq(%w[Type Reference Value sha256])) }
+      it { expect(formatter.fixed).to(eq(%w[Type Reference Value Checksum])) }
+    end
+
+    describe '#explicit_version' do
+      context 'when no explicit version' do
+        before do
+          allow(document).to(receive(:explicit_version?).and_return(false))
+          formatter.explicit_version
+        end
+
+        it { expect(document).to(have_received(:explicit_version?)) }
+
+        it { expect(formatter.explicit_version).to(eq([])) }
+      end
+
+      context 'when explicit version' do
+        before do
+          allow(document).to(receive(:explicit_version?).and_return(true))
+          formatter.explicit_version
+        end
+
+        it { expect(formatter.explicit_version).to(eq(['Version'])) }
+      end
     end
 
     describe '#wrong_explicit_checksum' do

data/spec/unit/defmastership/csv_formatter_spec.rb

@@ -15,20 +15,29 @@ RSpec.describe(DefMastership::CSVFormatter) do
   end
 
   describe '#export_to' do
-    context 'when wrong explicit checksum' do
-      let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
-      let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
-      let(:csv)  { instance_double(CSV, 'csv')                              }
+    let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
+    let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
+    let(:csv)  { instance_double(CSV, 'csv')                              }
+
+    before do
+      allow(CSV).to(receive(:open).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]))
+      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([]))
+      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([]))
+    end
+
+    context 'when no variable columns' do
+      methods = %i[fixed]
 
-      methods1 = %i[fixed wrong_explicit_checksum labels eref iref attributes]
       before do
-        allow(CSV).to(receive(:open).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]))
-        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
-        methods1.each do |method|
+        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"]))
@@ -36,98 +45,226 @@ RSpec.describe(DefMastership::CSVFormatter) do
         formatter.export_to('whatever')
       end
 
-      methods1.each do |method|
+      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)) }
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} header" }))
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      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
+      methods = %i[fixed wrong_explicit_checksum]
+
+      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"]))
+        end
+        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(true))
+        formatter.export_to('whatever')
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} def1 body" }))
+      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)) }
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods1.map { |method| "#{method} def2 body" }))
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      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
+      methods = %i[fixed explicit_version]
+
+      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"]))
+        end
+        allow(document).to(receive(:explicit_version?).with(no_args).and_return(true))
+        formatter.export_to('whatever')
+      end
+
+      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)) }
       end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      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 no wrong explicit checksum' do
-      let(:header) { instance_double(DefMastership::CSVFormatterHeader, 'header') }
-      let(:body) { instance_double(DefMastership::CSVFormatterBody, 'body') }
-      let(:csv)  { instance_double(CSV, 'csv')                              }
+    context 'when labels' do
+      methods = %i[fixed labels]
 
-      methods2 = %i[fixed labels eref iref attributes]
       before do
-        allow(CSV).to(receive(:open).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]))
-        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
-        methods2.each do |method|
+        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"]))
         end
+        allow(document).to(receive(:labels).with(no_args).and_return([:whatever]))
         formatter.export_to('whatever')
       end
 
-      methods2.each do |method|
+      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)) }
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} header" }))
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      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
+      methods = %i[fixed eref]
+
+      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"]))
+        end
+        allow(document).to(receive(:eref).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} def1 body" }))
+      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)) }
+      end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      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
+      methods = %i[fixed iref]
+
+      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"]))
+        end
+        allow(document).to(receive(:iref).with(no_args).and_return(true))
+        formatter.export_to('whatever')
       end
 
-      it do
-        expect(csv).to(have_received(:<<).with(methods2.map { |method| "#{method} def2 body" }))
+      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)) }
       end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      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 #export_to csv file' do
-      let(:target_file) { 'export.csv' }
-      let(:definitions) do
-        [
-          OpenStruct.new(type: 'a', reference: 'b', value: 'c', sha256: 'd'),
-          OpenStruct.new(type: 'd', reference: 'e', value: 'f', sha256: 'g')
-        ]
+    context 'when attributes' do
+      methods = %i[fixed attributes]
+
+      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"]))
+        end
+        allow(document).to(receive(:attributes).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
+      end
+
+      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)) }
       end
 
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      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
+      methods = %i[fixed wrong_explicit_checksum explicit_version labels eref iref attributes]
+
       before do
-        setup_aruba
-        allow(document).to(receive(:labels).exactly(3).times.with(no_args).and_return([]))
-        allow(document).to(receive(:eref).exactly(3).times.with(no_args).and_return({}))
-        allow(document).to(receive(:iref).exactly(3).times.with(no_args).and_return(false))
-        allow(document).to(receive(:attributes).exactly(3).times.with(no_args).and_return({}))
-        allow(document).to(receive(:definitions).with(no_args).and_return(definitions))
-        allow(document).to(receive(:wrong_explicit_checksum?).with(no_args).and_return(false))
-        formatter.export_to("#{aruba.current_directory}/#{target_file}")
-      end
-
-      it { expect(document).to(have_received(:labels).exactly(3).times.with(no_args)) }
-      it { expect(document).to(have_received(:eref).exactly(3).times.with(no_args)) }
-      it { expect(document).to(have_received(:iref).exactly(3).times.with(no_args)) }
-      it { expect(document).to(have_received(:attributes).exactly(3).times.with(no_args)) }
-      it { expect(document).to(have_received(:definitions).with(no_args)) }
-
-      it do
-        expect(target_file).to(have_file_content(<<~CSV_FILE))
-          Type;Reference;Value;sha256
-          a;b;c;d
-          d;e;f;g
-        CSV_FILE
+        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"]))
+        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))
+        allow(document).to(receive(:labels).with(no_args).and_return([:whatever]))
+        allow(document).to(receive(:eref).with(no_args).and_return([:whatever]))
+        allow(document).to(receive(:iref).with(no_args).and_return(true))
+        allow(document).to(receive(:attributes).with(no_args).and_return([:whatever]))
+        formatter.export_to('whatever')
       end
+
+      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)) }
+      end
+
+      it { expect(csv).to(have_received(:<<).with(methods.map { |method| "#{method} header" })) }
+      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) do
+      [
+        OpenStruct.new(type: 'a', reference: 'b', value: 'c', sha256: 'd'),
+        OpenStruct.new(type: 'd', reference: 'e', value: 'f', sha256: 'g')
+      ]
+    end
+
+    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(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