defmastership 1.0.16 → 1.0.18

data/spec/unit/{defmastership → def_mastership}/csv_formatter_spec.rb

@@ -1,9 +1,9 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
-require('ostruct')
 require('csv')
+require('defmastership/csv_formatter')
+require('ostruct')
 
 RSpec.describe(DefMastership::CSVFormatter) do
   subject(:formatter) { described_class.new(document, ';') }
@@ -11,20 +11,27 @@ RSpec.describe(DefMastership::CSVFormatter) do
   let(:document) { instance_double(DefMastership::Document, 'document') }
 
   describe '.new' do
-    it { is_expected.not_to(be(nil)) }
+    it { is_expected.not_to(be_nil) }
   end
 
   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,51 +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) 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

data/spec/unit/{defmastership → def_mastership}/definition_parser_spec.rb

@@ -1,12 +1,12 @@
 # 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) }
 
-  let(:callback_object) { instance_double('callback_object') }
+  let(:callback_object) { double }
 
   before do
     allow(callback_object).to(receive(:add_new_definition).with(any_args))

data/spec/unit/{defmastership → 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
@@ -13,7 +13,7 @@ RSpec.describe(DefMastership::Definition) do
         )
       end
 
-      it { is_expected.not_to(be(nil)) }
+      it { is_expected.not_to(be_nil) }
       it { is_expected.to(have_attributes(type:       'req')) }
       it { is_expected.to(have_attributes(reference:  'TUTU-001')) }
       it { is_expected.to(have_attributes(lines:      [])) }
@@ -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