exel 1.4.0 → 1.5.1

data/spec/exel/middleware/logging_spec.rb

@@ -1,33 +1,31 @@
 # frozen_string_literal: true
-module EXEL
-  module Middleware
-    describe Logging do
-      TestProcessor = Class.new
 
-      describe '#call' do
-        it 'yields to the given block' do
-          called = false
+describe EXEL::Middleware::Logging do
+  class TestProcessor
+  end
 
-          subject.call(Object, {}, {}) do
-            called = true
-          end
+  describe '#call' do
+    it 'yields to the given block' do
+      called = false
 
-          expect(called).to be_truthy
-        end
+      subject.call(Object, {}, {}) do
+        called = true
+      end
 
-        it 'logs with context[:log_prefix] and the processor class as the prefix' do
-          expect(EXEL::Logging).to receive(:with_prefix).with('[prefix][EXEL::Middleware::TestProcessor] ')
-          subject.call(TestProcessor, {log_prefix: '[prefix]'}, {}) {}
-        end
+      expect(called).to be_truthy
+    end
+
+    it 'logs with context[:log_prefix] and the processor class as the prefix' do
+      expect(EXEL::Logging).to receive(:with_prefix).with('[prefix][TestProcessor] ')
+      subject.call(TestProcessor, {log_prefix: '[prefix]'}, {}) {}
+    end
 
-        it 'raises rescued exceptions' do
-          expect do
-            subject.call(Object, {}, {}) do
-              raise Exception, 're-raise me'
-            end
-          end.to raise_error Exception, 're-raise me'
+    it 'raises rescued exceptions' do
+      expect do
+        subject.call(Object, {}, {}) do
+          raise Exception, 're-raise me'
         end
-      end
+      end.to raise_error Exception, 're-raise me'
     end
   end
 end

data/spec/exel/middleware_spec.rb

@@ -1,69 +1,68 @@
 # frozen_string_literal: true
-module EXEL
-  describe Middleware do
-    class IORecorder
-      def initialize(input, output)
-        @input = input
-        @output = output
-      end
 
-      def call(_processor, context, args)
-        @input << args[:input]
-        yield
-        @output << context[:output]
-      end
+describe EXEL::Middleware do
+  class IORecorder
+    def initialize(input, output)
+      @input = input
+      @output = output
     end
 
-    class RescueErrors
-      def call(_processor, _context, _args)
-        yield
-      rescue
-        nil
-      end
+    def call(_processor, context, args)
+      @input << args[:input]
+      yield
+      @output << context[:output]
     end
+  end
 
-    class AddProcessor
-      def initialize(context)
-        @context = context
-      end
-
-      def process(_)
-        @context[:output] = @context[:input] + 1
-        raise 'rescue me'
-      end
+  class RescueErrors
+    def call(_processor, _context, _args)
+      yield
+    rescue
+      nil
     end
+  end
 
-    before :all do
-      EXEL::Job.define :middleware_test_job do
-        process with: AddProcessor, input: 1
-      end
+  class AddProcessor
+    def initialize(context)
+      @context = context
     end
 
-    let(:input) { [] }
-    let(:output) { [] }
-
-    before do
-      EXEL.configure do |config|
-        config.middleware.add(IORecorder, input, output)
-        config.middleware.add(RescueErrors)
-      end
+    def process(_)
+      @context[:output] = @context[:input] + 1
+      raise 'rescue me'
     end
+  end
 
-    after do
-      EXEL.configure do |config|
-        config.middleware.remove(IORecorder)
-        config.middleware.remove(RescueErrors)
-      end
+  before :all do # rubocop:disable RSpec/BeforeAfterAll
+    EXEL::Job.define :middleware_test_job do
+      process with: AddProcessor, input: 1
     end
+  end
 
-    it 'can configure custom middleware' do
-      expect(EXEL.configuration.middleware.entries.map(&:klass)).to eq([IORecorder, RescueErrors])
+  let(:input) { [] }
+  let(:output) { [] }
+
+  before do
+    EXEL.configure do |config|
+      config.middleware.add(IORecorder, input, output)
+      config.middleware.add(RescueErrors)
     end
+  end
 
-    it 'invokes the middleware around the processor' do
-      EXEL::Job.run(:middleware_test_job)
-      expect(input).to eq([1])
-      expect(output).to eq([2])
+  after do
+    EXEL.configure do |config|
+      config.middleware.remove(IORecorder)
+      config.middleware.remove(RescueErrors)
     end
   end
+
+  it 'can configure custom middleware' do
+    expect(EXEL.configuration.middleware.entries.map(&:klass)).to eq([IORecorder, RescueErrors])
+  end
+
+  it 'invokes the middleware around the processor' do
+    EXEL::Job.run(:middleware_test_job)
+    expect(input).to eq([1])
+    expect(output).to eq([2])
+  end
 end

data/spec/exel/null_instruction_spec.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
-module EXEL
-  describe NullInstruction do
-    it { is_expected.to respond_to :execute }
-  end
+
+describe EXEL::NullInstruction do
+  it { is_expected.to respond_to :execute }
 end

data/spec/exel/processors/async_processor_spec.rb

@@ -1,25 +1,23 @@
 # frozen_string_literal: true
-module EXEL
-  module Processors
-    describe AsyncProcessor do
-      subject(:processor) { described_class.new(context) }
-      let(:context) { EXEL::Context.new }
-      let(:block) { instance_double(SequenceNode) }
 
-      before do
-        allow(EXEL).to receive(:async_provider).and_return(EXEL::Providers::DummyAsyncProvider)
-      end
+describe EXEL::Processors::AsyncProcessor do
+  subject(:processor) { described_class.new(context) }
 
-      it 'looks up the async provider on initialization' do
-        expect(processor.provider).to be_an_instance_of(EXEL::Providers::DummyAsyncProvider)
-      end
+  let(:context) { EXEL::Context.new }
+  let(:block) { instance_double(EXEL::SequenceNode) }
 
-      describe '#process' do
-        it 'calls do_async on the async provider' do
-          expect(processor.provider).to receive(:do_async).with(block)
-          processor.process(block)
-        end
-      end
+  before do
+    allow(EXEL).to receive(:async_provider).and_return(EXEL::Providers::DummyAsyncProvider)
+  end
+
+  it 'looks up the async provider on initialization' do
+    expect(processor.provider).to be_an_instance_of(EXEL::Providers::DummyAsyncProvider)
+  end
+
+  describe '#process' do
+    it 'calls do_async on the async provider' do
+      expect(processor.provider).to receive(:do_async).with(block)
+      processor.process(block)
     end
   end
 end

data/spec/exel/processors/run_processor_spec.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
-module EXEL
-  module Processors
-    describe RunProcessor do
-      subject { RunProcessor.new(context) }
-      let(:context) { EXEL::Context.new(job: :test_job) }
 
-      describe '#process' do
-        it 'runs the job named in context[:job] with the current context' do
-          expect(EXEL::Job).to receive(:run).with(:test_job, context)
-          subject.process
-        end
-      end
+describe EXEL::Processors::RunProcessor do
+  subject { EXEL::Processors::RunProcessor.new(context) }
+
+  let(:context) { EXEL::Context.new(job: :test_job) }
+
+  describe '#process' do
+    it 'runs the job named in context[:job] with the current context' do
+      expect(EXEL::Job).to receive(:run).with(:test_job, context)
+      subject.process
     end
   end
 end

data/spec/exel/processors/split_processor_spec.rb

@@ -1,123 +1,121 @@
 # frozen_string_literal: true
-module EXEL
-  module Processors
-    describe SplitProcessor do
-      let(:chunk_file) { instance_double(File) }
-      let(:file) { create_file(1) }
-      let(:context) { Context.new(resource: file) }
-      let(:callback) { instance_double(SequenceNode) }
-      subject(:splitter) { SplitProcessor.new(context) }
-
-      before do
-        allow_any_instance_of(StringIO).to receive(:path).and_return('/text.txt')
-        allow(File).to receive(:delete)
-      end
 
-      describe '#process' do
-        let(:file) { create_file(3) }
+describe EXEL::Processors::SplitProcessor do
+  subject(:splitter) { EXEL::Processors::SplitProcessor.new(context) }
 
-        it 'processes file with 3 lines line by line' do
-          allow(CSV).to receive(:foreach).and_yield('line0').and_yield('line1').and_yield('line2')
+  let(:chunk_file) { instance_double(File) }
+  let(:file) { create_file(1) }
+  let(:context) { EXEL::Context.new(resource: file) }
+  let(:callback) { instance_double(EXEL::SequenceNode) }
 
-          3.times do |i|
-            expect(splitter).to receive(:process_line).with("line#{i}", callback)
-          end
-          expect(splitter).to receive(:process_line).with(:eof, callback)
+  before do
+    allow_any_instance_of(StringIO).to receive(:path).and_return('/text.txt')
+    allow(File).to receive(:delete)
+  end
 
-          expect(File).to receive(:delete).with(file.path)
-          expect(file).to receive(:close)
+  describe '#process' do
+    let(:file) { create_file(3) }
 
-          splitter.process(callback)
-        end
+    it 'processes file with 3 lines line by line' do
+      allow(CSV).to receive(:foreach).and_yield('line0').and_yield('line1').and_yield('line2')
 
-        it 'aborts parsing the csv file if it is malformed' do
-          allow(CSV).to receive(:foreach).and_raise(CSV::MalformedCSVError)
-          expect(splitter).to receive(:process_line).with(:eof, callback)
+      3.times do |i|
+        expect(splitter).to receive(:process_line).with("line#{i}", callback)
+      end
+      expect(splitter).to receive(:process_line).with(:eof, callback)
 
-          splitter.process(callback)
-        end
+      expect(File).to receive(:delete).with(file.path)
+      expect(file).to receive(:close)
 
-        it 'does not delete the resource file if :delete_resource is set to false in the context' do
-          allow(CSV).to receive(:foreach).and_yield(:eof)
-          expect(File).not_to receive(:delete).with(file.path)
+      splitter.process(callback)
+    end
 
-          context[:delete_resource] = false
-          splitter.process(callback)
-        end
+    it 'aborts parsing the csv file if it is malformed' do
+      allow(CSV).to receive(:foreach).and_raise(CSV::MalformedCSVError.new('message', '1'))
+      expect(splitter).to receive(:process_line).with(:eof, callback)
 
-        it 'stops splitting at :max_chunks if it is set in the context' do
-          allow(CSV).to receive(:foreach).and_yield(['line0']).and_yield(['line1']).and_yield(['line2'])
+      splitter.process(callback)
+    end
 
-          chunk_file = create_file(0)
+    it 'does not delete the resource file if :delete_resource is set to false in the context' do
+      allow(CSV).to receive(:foreach).and_yield(:eof)
+      expect(File).not_to receive(:delete).with(file.path)
 
-          allow(Tempfile).to receive(:new).and_return(chunk_file)
-          expect(callback).to receive(:run).once
-          allow_any_instance_of(StringIO).to receive(:path).and_return('test path')
+      context[:delete_resource] = false
+      splitter.process(callback)
+    end
 
-          expect(File).to receive(:delete).with(file.path)
+    it 'stops splitting at :max_chunks if it is set in the context' do
+      allow(CSV).to receive(:foreach).and_yield(['line0']).and_yield(['line1']).and_yield(['line2'])
 
-          context[:chunk_size] = 2
-          context[:max_chunks] = 1
-          splitter.process(callback)
+      chunk_file = create_file(0)
 
-          expect(chunk_file.read).to eq("line0\nline1\n")
-        end
+      allow(Tempfile).to receive(:new).and_return(chunk_file)
+      expect(callback).to receive(:run).once
+      allow_any_instance_of(StringIO).to receive(:path).and_return('test path')
 
-        it 'ensures that the source file gets closed and deleted' do
-          allow(CSV).to receive(:foreach).and_raise(Interrupt)
+      expect(File).to receive(:delete).with(file.path)
 
-          expect(File).to receive(:delete).with(file.path)
-          expect(file).to receive(:close)
+      context[:chunk_size] = 2
+      context[:max_chunks] = 1
+      splitter.process(callback)
 
-          begin
-            splitter.process(callback)
-          rescue Interrupt
-            nil
-          end
-        end
-      end
+      expect(chunk_file.read).to eq("line0\nline1\n")
+    end
 
-      describe '#process_line' do
-        [
-          {input: 1, chunks: %W(0\n)},
-          {input: 3, chunks: %W(0\n1\n 2\n)},
-          {input: 4, chunks: %W(0\n1\n 2\n3\n)}
-        ].each do |data|
-          it "produces #{data[:chunks].size} chunks with #{data[:input]} input lines" do
-            context[:chunk_size] = 2
-
-            data[:chunks].each do |chunk|
-              expect(splitter).to receive(:generate_chunk).with(chunk).and_return(chunk_file)
-              expect(callback).to receive(:run).with(context) do
-                expect(context[:resource]).to eq(chunk_file)
-              end
-            end
-
-            data[:input].times { |i| splitter.process_line([i.to_s], callback) }
-            splitter.process_line(:eof, callback)
-          end
-        end
-      end
+    it 'ensures that the source file gets closed and deleted' do
+      allow(CSV).to receive(:foreach).and_raise(Interrupt)
 
-      describe '#generate_chunk' do
-        it 'creates a file with the contents of the given string' do
-          file = splitter.generate_chunk('abc')
-          content = file.read
-          expect(content).to eq('abc')
-        end
+      expect(File).to receive(:delete).with(file.path)
+      expect(file).to receive(:close)
+
+      begin
+        splitter.process(callback)
+      rescue Interrupt
+        nil
+      end
+    end
+  end
 
-        it 'creates a file with a unique name' do
-          3.times do |i|
-            file = splitter.generate_chunk('content')
-            expect(file.path).to include("text_#{i + 1}_")
+  describe '#process_line' do
+    [
+        {input: 1, chunks: %W(0\n)},
+        {input: 3, chunks: %W(0\n1\n 2\n)},
+        {input: 4, chunks: %W(0\n1\n 2\n3\n)},
+    ].each do |data|
+      it "produces #{data[:chunks].size} chunks with #{data[:input]} input lines" do
+        context[:chunk_size] = 2
+
+        data[:chunks].each do |chunk|
+          expect(splitter).to receive(:generate_chunk).with(chunk).and_return(chunk_file)
+          expect(callback).to receive(:run).with(context) do
+            expect(context[:resource]).to eq(chunk_file)
           end
         end
+
+        data[:input].times { |i| splitter.process_line([i.to_s], callback) }
+        splitter.process_line(:eof, callback)
       end
+    end
+  end
 
-      def create_file(lines)
-        content = Array.new(lines) { |i| CSV.generate_line(["line#{i}"]) }.join
-        StringIO.new(content)
+  describe '#generate_chunk' do
+    it 'creates a file with the contents of the given string' do
+      file = splitter.generate_chunk('abc')
+      content = file.read
+      expect(content).to eq('abc')
+    end
+
+    it 'creates a file with a unique name' do
+      3.times do |i|
+        file = splitter.generate_chunk('content')
+        expect(file.path).to include("text_#{i + 1}_")
       end
     end
   end
+
+  def create_file(lines)
+    content = Array.new(lines) { |i| CSV.generate_line(["line#{i}"]) }.join
+    StringIO.new(content)
+  end
 end