defmastership 1.3.2 → 1.3.4

data/spec/unit/defmastership/export/csv/formatter_spec.rb

@@ -1,10 +1,13 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/document')
 require('defmastership/export/csv/formatter')
 
+COLUMN_METHODS = %i[type reference value checksum].freeze
+
 RSpec.describe(Defmastership::Export::CSV::Formatter) do
-  subject(:formatter) { described_class.new(document, ';') }
+  subject(:formatter) { described_class.new(document, separator: ';') }
 
   let(:document) { instance_double(Defmastership::Document, 'document') }
 
@@ -20,6 +23,7 @@ RSpec.describe(Defmastership::Export::CSV::Formatter) do
         instance_double(Defmastership::Export::BodyFormatter, 'bodies[1]')
       ]
     end
+
     let(:csv) { instance_double(CSV, 'csv') }
 
     before do
@@ -45,10 +49,8 @@ RSpec.describe(Defmastership::Export::CSV::Formatter) do
     end
 
     context 'when no variable columns' do
-      methods = %i[type reference value checksum]
-
       before do
-        methods.each do |method|
+        COLUMN_METHODS.each do |method|
           allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
           bodies.each_with_index do |body, index|
             allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
@@ -59,88 +61,7 @@ RSpec.describe(Defmastership::Export::CSV::Formatter) do
 
       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)) }
-
-        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" })) }
-    end
-
-    context 'when summary' do
-      methods = %i[type reference summary value checksum]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          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(:summaries?).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)) }
-
-        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" })) }
-    end
-
-    context 'when wrong_explicit_checksum' do
-      methods = %i[type reference value checksum wrong_explicit_checksum]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          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')
-      end
-
-      methods.each do |method|
-        it { expect(header).to(have_received(method).with(no_args)) }
-
-        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" })) }
-    end
-
-    context 'when explicit_version' do
-      methods = %i[type reference value checksum explicit_version]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          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')
-      end
-
-      methods.each do |method|
+      COLUMN_METHODS.each do |method|
         it { expect(header).to(have_received(method).with(no_args)) }
 
         2.times do |index|
@@ -148,162 +69,55 @@ RSpec.describe(Defmastership::Export::CSV::Formatter) do
         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(COLUMN_METHODS.map { |method| "#{method} header" })) }
+      it { expect(csv).to(have_received(:<<).with(COLUMN_METHODS.map { |method| "#{method} def0 body" })) }
+      it { expect(csv).to(have_received(:<<).with(COLUMN_METHODS.map { |method| "#{method} def1 body" })) }
     end
+  end
 
-    context 'when labels' do
-      methods = %i[type reference value checksum labels]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          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')
-      end
-
-      methods.each do |method|
-        it { expect(header).to(have_received(method).with(no_args)) }
-
-        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" })) }
-    end
-
-    context 'when eref' do
-      methods = %i[type reference value checksum eref]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          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')
-      end
-
-      methods.each do |method|
-        it { expect(header).to(have_received(method).with(no_args)) }
-
-        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" })) }
-    end
-
-    context 'when iref' do
-      methods = %i[type reference value checksum iref]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          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')
-      end
-
-      methods.each do |method|
-        it { expect(header).to(have_received(method).with(no_args)) }
+  describe '#export_to with default separator' do
+    subject(:formatter) { described_class.new(document) }
 
-        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" })) }
+    let(:header) { instance_double(Defmastership::Export::HeaderFormatter, 'header') }
+    let(:bodies) do
+      [
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[0]'),
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[1]')
+      ]
     end
 
-    context 'when attributes' do
-      methods = %i[type reference value checksum attributes]
+    let(:csv) { instance_double(CSV, 'csv') }
 
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          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')
+    before do
+      allow(CSV).to(receive(:open).with('whatever', 'w:ISO-8859-1', col_sep: ',').and_yield(csv))
+      allow(csv).to(receive(:<<))
+      allow(Defmastership::Export::HeaderFormatter).to(receive(:new).with(document).and_return(header))
+      bodies.each_with_index do |body, index|
+        allow(Defmastership::Export::BodyFormatter).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(:summaries?).with(no_args).and_return(false))
+      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([]))
 
-      methods.each do |method|
-        it { expect(header).to(have_received(method).with(no_args)) }
-
-        2.times do |index|
-          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+      %i[type reference value checksum].each do |method|
+        allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+        bodies.each_with_index do |body, index|
+          allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
         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" })) }
+      formatter.export_to('whatever')
     end
 
-    context 'when every colums' do
-      methods = %i[
-        type
-        reference
-        summary
-        value
-        checksum
-        wrong_explicit_checksum
-        explicit_version
-        labels
-        eref
-        iref
-        attributes
-      ]
-
-      before do
-        methods.each do |method|
-          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
-          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(:summaries?).with(no_args).and_return(true))
-        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)) }
-
-        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" })) }
-    end
+    it { expect(CSV).to(have_received(:open).with('whatever', 'w:ISO-8859-1', col_sep: ',')) }
   end
 end

data/spec/unit/defmastership/export/formatter_spec.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/export/formatter')
+
+# Defmastership::Export::Formatter is an abstract class and need to be derived for test
+class ConcreteFormatter < Defmastership::Export::Formatter
+  def export_to(_filename)
+    # allow to indirectly test a private method
+    build_column_list
+  end
+end
+
+RSpec.describe(Defmastership::Export::Formatter) do
+  context('when class is not derived') do
+    subject(:formatter) { described_class.new(:whatever) }
+
+    describe '#export_to' do
+      it {
+        expect { formatter.export_to(:something) }
+          .to(raise_error(
+                NotImplementedError,
+                'Defmastership::Export::Formatter has not implemented the \'export_to\' method'
+              ))
+      }
+    end
+  end
+
+  context('when class is derived') do
+    subject(:formatter) { ConcreteFormatter.new(document) }
+
+    let(:document) { instance_double(Defmastership::Document, 'document') }
+
+    describe '#export_to' do
+      it {
+        expect { formatter.export_to(:something) }
+          .not_to(raise_error(NotImplementedError))
+      }
+    end
+
+    describe '#header' do
+      let(:header_formatter) { instance_double(Defmastership::Export::HeaderFormatter, 'header_formatter') }
+
+      before do
+        allow(Defmastership::Export::HeaderFormatter).to(receive(:new).and_return(header_formatter))
+        allow(header_formatter).to(receive_messages(type: ['type value'], reference: ['reference value']))
+        formatter.header(%i[type reference])
+      end
+
+      it { expect(Defmastership::Export::HeaderFormatter).to(have_received(:new).with(document)) }
+      it { expect(header_formatter).to(have_received(:type)) }
+      it { expect(header_formatter).to(have_received(:reference)) }
+      it { expect(formatter.header(%i[type reference])).to(eq(['type value', 'reference value'])) }
+    end
+
+    describe '#body' do
+      let(:body_formatter) { instance_double(Defmastership::Export::BodyFormatter, 'body_formatter') }
+
+      before do
+        allow(Defmastership::Export::BodyFormatter).to(receive(:new).and_return(body_formatter))
+        allow(body_formatter).to(receive_messages(type: ['type value'], reference: ['reference value']))
+        formatter.body(:definition, %i[type reference])
+      end
+
+      it { expect(Defmastership::Export::BodyFormatter).to(have_received(:new).with(document, :definition)) }
+      it { expect(body_formatter).to(have_received(:type)) }
+      it { expect(body_formatter).to(have_received(:reference)) }
+      it { expect(formatter.body(:definition, %i[type reference])).to(eq(['type value', 'reference value'])) }
+    end
+
+    describe '#build_column_list' do
+      before do
+        allow(document).to(
+          receive_messages(
+            summaries?: true,
+            wrong_explicit_checksum?: false,
+            explicit_version?: false,
+            labels: ['toto'],
+            eref: [],
+            iref: false,
+            attributes: []
+          )
+        )
+        formatter.export_to(:whatever)
+      end
+
+      it { expect(document).to(have_received(:summaries?)) }
+      it { expect(document).to(have_received(:wrong_explicit_checksum?)) }
+      it { expect(document).to(have_received(:explicit_version?)) }
+      it { expect(document).to(have_received(:labels)) }
+      it { expect(document).to(have_received(:eref)) }
+      it { expect(document).to(have_received(:iref)) }
+      it { expect(document).to(have_received(:attributes)) }
+      it { expect(formatter.export_to(:whatever)).to(eq(%i[type reference summary value checksum labels])) }
+    end
+  end
+end

data/spec/unit/defmastership/export/header_formatter_spec.rb

@@ -1,6 +1,7 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require('defmastership/document')
 require('defmastership/export/header_formatter')
 
 RSpec.describe(Defmastership::Export::HeaderFormatter) do
@@ -110,12 +111,7 @@ RSpec.describe(Defmastership::Export::HeaderFormatter) do
 
       context 'when eref' do
         before do
-          allow(document).to(
-            receive(:eref).and_return(
-              whatever: { prefix: 'A' },
-              other: { prefix: 'C', url: 'D' }
-            )
-          )
+          allow(document).to(receive(:eref).and_return(whatever: { prefix: 'A' }, other: { prefix: 'C', url: 'D' }))
         end
 
         it { expect(formatter.eref).to(eq(%w[A C])) }

data/spec/unit/defmastership/export/json/formatter_spec.rb

@@ -0,0 +1,85 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/document')
+require('defmastership/export/json/formatter')
+
+RSpec.describe(Defmastership::Export::JSON::Formatter) do
+  subject(:formatter) { described_class.new(document) }
+
+  let(:document) { instance_double(Defmastership::Document, 'document') }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '#export_to' do
+    let(:header) { instance_double(Defmastership::Export::HeaderFormatter, 'header') }
+    let(:bodies) do
+      [
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[0]'),
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[1]')
+      ]
+    end
+
+    let(:json) { instance_double(JSON, 'json') }
+    let(:expected_hash_array) do
+      [
+        {
+          'checksum header': 'checksum def0 body',
+          'reference header': 'reference def0 body',
+          'type header': 'type def0 body',
+          'value header': 'value def0 body'
+        },
+        {
+          'checksum header': 'checksum def1 body',
+          'reference header': 'reference def1 body',
+          'type header': 'type def1 body',
+          'value header': 'value def1 body'
+        }
+      ]
+    end
+
+    before do
+      allow(Defmastership::Export::HeaderFormatter).to(receive(:new).with(document).and_return(header))
+      bodies.each_with_index do |body, index|
+        allow(Defmastership::Export::BodyFormatter).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(:summaries?).with(no_args).and_return(false))
+      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([]))
+
+      COLUMN_METHODS.each do |method|
+        allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+        bodies.each_with_index do |body, index|
+          allow(body).to(receive(method).with(no_args).and_return(["#{method} def#{index} body"]))
+        end
+      end
+
+      allow(JSON).to(receive(:pretty_generate)).and_return('the generated json')
+      allow(File).to(receive(:write).with('filename', 'the generated json'))
+      formatter.export_to('filename')
+    end
+
+    COLUMN_METHODS.each do |method|
+      it { expect(header).to(have_received(method).with(no_args)) }
+
+      2.times do |index|
+        it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+      end
+    end
+
+    it { expect(JSON).to(have_received(:pretty_generate).with(expected_hash_array)) }
+    it { expect(File).to(have_received(:write).with('filename', 'the generated json')) }
+  end
+end

data/spec/unit/defmastership/export/xlsx/formatter_spec.rb

@@ -0,0 +1,82 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('defmastership/export/xlsx/formatter')
+require('rubyXL')
+
+RSpec.describe(Defmastership::Export::XLSX::Formatter) do
+  subject(:formatter) { described_class.new(document) }
+
+  let(:document) { instance_double(Defmastership::Document, 'document') }
+
+  describe '.new' do
+    it { is_expected.not_to(be_nil) }
+  end
+
+  describe '#export_to' do
+    let(:header) { instance_double(Defmastership::Export::HeaderFormatter, 'header') }
+    let(:bodies) do
+      [
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[0]'),
+        instance_double(Defmastership::Export::BodyFormatter, 'bodies[1]')
+      ]
+    end
+    let(:workbook)  { instance_double(RubyXL::Workbook, 'workbook')   }
+    let(:worksheet) { instance_double(RubyXL::Worksheet, 'worksheet') }
+
+    before do
+      allow(RubyXL::Workbook).to(receive(:new).and_return(workbook))
+      allow(workbook).to(receive(:worksheets).with(no_args).and_return([worksheet]))
+      allow(worksheet).to(receive(:add_cell))
+      allow(workbook).to(receive(:write))
+      allow(Defmastership::Export::HeaderFormatter).to(receive(:new).with(document).and_return(header))
+      bodies.each_with_index do |body, index|
+        allow(Defmastership::Export::BodyFormatter).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(:summaries?).with(no_args).and_return(false))
+      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
+      before do
+        COLUMN_METHODS.each do |method|
+          allow(header).to(receive(method).with(no_args).and_return(["#{method} header"]))
+          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(RubyXL::Workbook).to(have_received(:new)) }
+      it { expect(workbook).to(have_received(:worksheets)) }
+
+      COLUMN_METHODS.each do |method|
+        it { expect(header).to(have_received(method).with(no_args)) }
+
+        2.times do |index|
+          it { expect(bodies[index]).to(have_received(method).with(no_args)) }
+        end
+      end
+
+      COLUMN_METHODS.each_with_index do |method, index|
+        it { expect(worksheet).to(have_received(:add_cell).with(0, index, "#{method} header")) }
+        it { expect(worksheet).to(have_received(:add_cell).with(1, index, "#{method} def0 body")) }
+        it { expect(worksheet).to(have_received(:add_cell).with(2, index, "#{method} def1 body")) }
+      end
+
+      it { expect(workbook).to(have_received(:write).with('whatever')) }
+    end
+  end
+end