defmastership 1.0.17 → 1.0.19

data/spec/unit/def_mastership/update_def_checksum_modifier_spec.rb

@@ -1,75 +1,107 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('defmastership')
+require('defmastership/update_def_checksum_modifier')
 
 RSpec.describe(DefMastership::UpdateDefChecksumModifier) do
-  subject(:modifier) do
-    described_class.new(
-      'fake config'
-    )
-  end
-
-  let(:adoc_texts) do
-    {
-      'file1.adoc' => "file1 line1\nfile1 line2",
-      'file2.adoc' => "file2 line1\nfile2 line2"
-    }
-  end
+  subject(:modifier) { described_class.new({}) }
 
   describe '.new' do
+    it { expect(described_class.ancestors).to(include(DefMastership::Modifier)) }
     it { is_expected.not_to(be_nil) }
-    it { is_expected.to(have_attributes(config: 'fake config')) }
-    it { is_expected.to(have_attributes(changes: [])) }
+    it { is_expected.to(have_attributes(def_type: '')) }
+  end
+
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_reference])) }
   end
 
   describe '#do_modifications' do
-    let(:line_modifier) { instance_double(DefMastership::UpdateDefChecksumLineModifier, 'lineModifier') }
-    let(:document)      { instance_double(DefMastership::Document, 'document')                          }
+    subject(:modifier) { described_class.new({ def_type: 'req' })                 }
+
+    let(:document)     { instance_double(DefMastership::Document, 'document')     }
+    let(:definition)   { instance_double(DefMastership::Definition, 'definition') }
+    let(:definitions)  { { 'REFERENCE' => definition }                            }
+    let(:adoc_sources) do
+      {
+        'file1.adoc' => "[define,req,REFERENCE]\nfile1 line2",
+        'file2.adoc' => "file2 line1\nfile2 line2"
+      }
+    end
+    let(:new_adoc_sources) { nil }
 
     before do
-      allow(DefMastership::UpdateDefChecksumLineModifier).to(
-        receive(:from_config).with('fake config').and_return(line_modifier)
-      )
       allow(DefMastership::Document).to(receive(:new).and_return(document))
       allow(document).to(receive(:parse_file_with_preprocessor))
-      allow(line_modifier).to(receive(:'document=').with(document))
-      allow(line_modifier).to(receive(:replace).with("file1 line1\n").and_return("new file1 line1\n"))
-      allow(line_modifier).to(receive(:replace).with('file1 line2').and_return('new file1 line2'))
-      allow(line_modifier).to(receive(:replace).with("file2 line1\n").and_return("new file2 line1\n"))
-      allow(line_modifier).to(receive(:replace).with('file2 line2').and_return('new file2 line2'))
-      allow(line_modifier).to(receive(:config).and_return('new fake config'))
-      allow(line_modifier).to(receive(:changes).and_return([%w[from1 to1], %w[from2 to2]]))
+      allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+      allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+
+      modifier.do_modifications(adoc_sources)
     end
 
-    context 'when detailed expectations' do
-      before { modifier.do_modifications(adoc_texts) }
+    it { expect(DefMastership::Document).to(have_received(:new)) }
+
+    it do
+      expect(document).to(
+        have_received(:parse_file_with_preprocessor)
+          .once.with('file1.adoc')
+          .once.with('file2.adoc')
+      )
+    end
+
+    it do
+      expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc')).to(include('abcd1234'))
+    end
+  end
+
+  describe '#replace' do
+    subject(:modifier) do
+      described_class.new(
+        def_type: 'requirement'
+      )
+    end
 
+    let(:definition)  { instance_double(DefMastership::Definition, 'definition') }
+    let(:document)    { instance_double(DefMastership::Document, 'document')     }
+    let(:definitions) { { 'REFERENCE' => definition }                            }
+
+    before do
+      allow(File).to(receive(:rename))
+    end
+
+    context 'when definition has not the good type' do
       it do
-        expect(DefMastership::UpdateDefChecksumLineModifier).to(
-          have_received(:from_config).with('fake config')
-        )
+        expect(modifier.replace_reference('[define,req,REFERENCE]'))
+          .to(eq('[define,req,REFERENCE]'))
       end
-
-      it { expect(document).to(have_received(:parse_file_with_preprocessor).with('file1.adoc')) }
-      it { expect(document).to(have_received(:parse_file_with_preprocessor).with('file2.adoc')) }
-      it { expect(line_modifier).to(have_received(:'document=').with(document)) }
-      it { expect(line_modifier).to(have_received(:replace).with("file1 line1\n")) }
-      it { expect(line_modifier).to(have_received(:replace).with('file1 line2')) }
-      it { expect(line_modifier).to(have_received(:replace).with("file2 line1\n")) }
-      it { expect(line_modifier).to(have_received(:replace).with('file2 line2')) }
-      it { expect(line_modifier).to(have_received(:config)) }
-      it { expect(line_modifier).to(have_received(:changes)) }
-      it { is_expected.to(have_attributes(config: 'new fake config')) }
-      it { is_expected.to(have_attributes(changes: [%w[from1 to1], %w[from2 to2]])) }
     end
 
-    it do
-      expected_adoc = {
-        'file1.adoc' => "new file1 line1\nnew file1 line2",
-        'file2.adoc' => "new file2 line1\nnew file2 line2"
-      }
-      expect(modifier.do_modifications(adoc_texts)).to(eq(expected_adoc))
+    context 'when definition has the good type' do
+      before do
+        allow(DefMastership::Document).to(receive(:new).and_return(document))
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE]'))
+          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(~bad)]'))
+          .to(eq('[define,requirement,REFERENCE(~abcd1234)]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(toto~bad)]'))
+          .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(toto)]'))
+          .to(eq('[define,requirement,REFERENCE(toto~abcd1234)]'))
+      end
     end
   end
 end

data/spec/unit/def_mastership/update_def_modifier_spec.rb

@@ -0,0 +1,121 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/update_def_modifier')
+
+module DefMastership
+  # Just a class for tests
+  class ConcreteRefModifier < UpdateDefModifier
+    private
+
+    # This method smells of :reek:UtilityFunction
+    def reference_replacement(reference, match)
+      "#{reference}_something_#{match[:explicit_version]}"
+    end
+  end
+end
+
+RSpec.describe(DefMastership::UpdateDefModifier) do
+  subject(:modifier) { DefMastership::ConcreteRefModifier.new({}) }
+
+  describe '.new' do
+    it { expect(described_class.ancestors).to(include(DefMastership::Modifier)) }
+    it { is_expected.not_to(be_nil) }
+    it { is_expected.to(have_attributes(def_type: '')) }
+  end
+
+  describe '.replacement_methods' do
+    it { expect(described_class.replacement_methods).to(eq(%i[replace_reference])) }
+  end
+
+  describe '#do_modifications' do
+    subject(:modifier) { DefMastership::ConcreteRefModifier.new({ def_type: 'req' }) }
+
+    let(:document)     { instance_double(DefMastership::Document, 'document')        }
+    let(:definition)   { instance_double(DefMastership::Definition, 'definition')    }
+    let(:definitions)  { { 'REFERENCE' => definition }                               }
+    let(:adoc_sources) do
+      {
+        'file1.adoc' => "[define,req,REFERENCE]\nfile1 line2",
+        'file2.adoc' => "file2 line1\nfile2 line2"
+      }
+    end
+    let(:new_adoc_sources) { nil }
+
+    before do
+      allow(DefMastership::Document).to(receive(:new).and_return(document))
+      allow(document).to(receive(:parse_file_with_preprocessor).with('file1.adoc'))
+      allow(document).to(receive(:parse_file_with_preprocessor).with('file2.adoc'))
+
+      modifier.do_modifications(adoc_sources)
+    end
+
+    it { expect(DefMastership::Document).to(have_received(:new)) }
+
+    it do
+      expect(document).to(
+        have_received(:parse_file_with_preprocessor)
+          .once.with('file1.adoc')
+          .once.with('file2.adoc')
+      )
+    end
+
+    it do
+      expect(modifier.do_modifications(adoc_sources).fetch('file1.adoc'))
+        .to(include('REFERENCE_something_'))
+    end
+  end
+
+  describe '#replace_reference' do
+    subject(:modifier) do
+      DefMastership::ConcreteRefModifier.new(
+        def_type: 'requirement'
+      )
+    end
+
+    let(:definition)  { instance_double(DefMastership::Definition, 'definition') }
+    let(:document)    { instance_double(DefMastership::Document, 'document')     }
+    let(:definitions) { { 'REFERENCE' => definition }                            }
+
+    before do
+      allow(File).to(receive(:rename))
+    end
+
+    context 'when line do not match' do
+      it do
+        expect(modifier.replace_reference('[define---,req,REFERENCE(abcd)]'))
+          .to(eq('[define---,req,REFERENCE(abcd)]'))
+      end
+    end
+
+    context 'when definition has not the good type' do
+      it do
+        expect(modifier.replace_reference('[define,req,REFERENCE(abcd)]'))
+          .to(eq('[define,req,REFERENCE(abcd)]'))
+      end
+    end
+
+    context 'when definition has the good type' do
+      before do
+        allow(DefMastership::Document).to(receive(:new).and_return(document))
+        allow(document).to(receive(:ref_to_def).with('REFERENCE').and_return(definition))
+        allow(definition).to(receive(:sha256_short).and_return('~abcd1234'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd)]'))
+          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('[define,requirement,REFERENCE(abcd~bad)]'))
+          .to(eq('[define,requirement,REFERENCE_something_abcd]'))
+      end
+
+      it do
+        expect(modifier.replace_reference('// [define,requirement,REFERENCE(abcd~bad)]'))
+          .to(eq('// [define,requirement,REFERENCE(abcd~bad)]'))
+      end
+    end
+  end
+end