exel 1.2.1 → 1.5.2

data/spec/exel/listen_instruction_spec.rb

@@ -1,14 +1,15 @@
-module EXEL
-  describe ListenInstruction do
-    subject(:instruction) { EXEL::ListenInstruction.new(:event, listener) }
-    let(:listener) { double(:listener) }
-    let(:context) { EXEL::Context.new }
+# frozen_string_literal: true
 
-    describe '#execute' do
-      it 'registers the event listener' do
-        expect(instruction).to receive(:register_listener).with(context, :event, listener)
-        instruction.execute(context)
-      end
+describe EXEL::ListenInstruction do
+  subject(:instruction) { EXEL::ListenInstruction.new(:event, listener) }
+
+  let(:listener) { double(:listener) }
+  let(:context) { EXEL::Context.new }
+
+  describe '#execute' do
+    it 'registers the event listener' do
+      expect(instruction).to receive(:register_listener).with(context, :event, listener)
+      instruction.execute(context)
     end
   end
 end

data/spec/exel/logging/logger_wrapper_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+describe EXEL::Logging::LoggerWrapper do
+  subject(:wrapper) { EXEL::Logging::LoggerWrapper.new(logger) }
+
+  let(:logger) { instance_double(Logger) }
+
+  it { is_expected.to be_a(SimpleDelegator) }
+
+  LOG_LEVELS = %i(debug info warn error fatal unknown).freeze # rubocop:disable Airbnb/SpecConstantAssignment
+
+  context 'without a Logging prefix' do
+    LOG_LEVELS.each do |level|
+      describe "##{level}" do
+        context 'when passed a message string' do
+          it 'passes the message to its wrapped logger' do
+            expect(logger).to receive(level).with('message')
+            wrapper.send(level, 'message')
+          end
+        end
+
+        context 'when passed a message block' do
+          it 'passes the block to its wrapped logger' do
+            block = proc {}
+            expect(logger).to receive(level).with(nil, &block)
+
+            wrapper.send(level, &block)
+          end
+
+          context 'and a progname' do
+            it 'passes the block and progname to its wrapped logger' do
+              block = proc {}
+              expect(logger).to receive(level).with('test', &block)
+
+              wrapper.send(level, 'test', &block)
+            end
+          end
+        end
+      end
+    end
+
+    describe '#add' do
+      it 'passes the message to its wrapped logger' do
+        expect(logger).to receive(:add).with(Logger::FATAL, 'message', 'progname')
+        wrapper.add(Logger::FATAL, 'message', 'progname')
+      end
+    end
+  end
+
+  context 'with a Logging prefix' do
+    before { allow(EXEL::Logging).to receive(:prefix).and_return('prefix: ') }
+
+    LOG_LEVELS.each do |level|
+      describe "##{level}" do
+        context 'when passed a message string' do
+          it 'passes the prefixed message to its wrapped logger' do
+            expect(logger).to receive(level).with('prefix: message')
+            wrapper.send(level, 'message')
+          end
+        end
+
+        context 'when passed a message block' do
+          it 'passes the prefixed block to its wrapped logger' do
+            expect(logger).to receive(level) do |progname, &block|
+              expect(progname).to be_nil
+              expect(block.call).to eq('prefix: message')
+            end
+
+            wrapper.send(level) { 'message' }
+          end
+
+          context 'and a progname' do
+            it 'passes the prefixed block and progname to its wrapped logger' do
+              expect(logger).to receive(level) do |progname, &block|
+                expect(progname).to eq('test')
+                expect(block.call).to eq('prefix: message')
+              end
+
+              wrapper.send(level, 'test') { 'message' }
+            end
+          end
+        end
+      end
+    end
+
+    describe '#add' do
+      it 'passes the prefixed message to its wrapped logger' do
+        expect(logger).to receive(:add).with(Logger::FATAL, 'prefix: message', 'progname')
+        wrapper.add(Logger::FATAL, 'message', 'progname')
+      end
+    end
+  end
+end

data/spec/exel/logging_helper_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+describe EXEL::LoggingHelper do
+  class HelperClass
+    include EXEL::LoggingHelper
+  end
+
+  let(:helper) { HelperClass.new }
+
+  describe '#logger' do
+    it 'returns EXEL.logger' do
+      expect(helper.logger).to eq(EXEL.logger)
+    end
+  end
+
+  %i(debug info warn error fatal).each do |level|
+    describe "#log_#{level}" do
+      it "logs a #{level} message" do
+        expect(EXEL.logger).to receive(level).with('test')
+        helper.send("log_#{level}", 'test')
+      end
+    end
+  end
+end

data/spec/exel/logging_spec.rb

@@ -1,35 +1,80 @@
-module EXEL
-  describe Logging do
-    before { @restore_logger = Logging.logger }
-    after { Logging.logger = @restore_logger }
-
-    describe '.logger=' do
-      it 'sets a logger' do
-        logger = double(:logger)
-        Logging.logger = logger
-        expect(Logging.logger).to be(logger)
+# frozen_string_literal: true
+
+describe EXEL::Logging do
+  before { @restore_logger = EXEL::Logging.logger }
+
+  after { EXEL::Logging.logger = @restore_logger }
+
+  describe EXEL::Logging::PrefixFormatter do
+    context 'without a Logging prefix' do
+      it 'formats the message' do
+        expect(subject.call('warn', Time.new(2007, 11, 1, 15, 25, 0, '+09:00'), 'test', 'message'))
+            .to eq("2007-11-01 06:25:00 UTC severity=warn, message\n")
       end
+    end
 
-      it 'sets a null logger when nil given' do
-        expect(Logger).to receive(:new).with('/dev/null')
-        Logging.logger = nil
+    context 'with a Logging prefix' do
+      it 'adds the prefix to the formatted message' do
+        EXEL::Logging.with_prefix('[prefix] ') do
+          expect(subject.call('warn', Time.new(2007, 11, 1, 15, 25, 0, '+09:00'), 'test', 'message'))
+              .to eq("2007-11-01 06:25:00 UTC severity=warn, [prefix] message\n")
+        end
       end
     end
+  end
+
+  describe '.logger=' do
+    it 'sets a wrapped logger' do
+      logger = instance_double(Logger)
+      EXEL::Logging.logger = logger
+      expect(EXEL::Logging.logger).to be_a(EXEL::Logging::LoggerWrapper)
+      expect(EXEL::Logging.logger.__getobj__).to be(logger)
+    end
+
+    it 'sets a null logger when nil given' do
+      expect(Logger).to receive(:new).with('/dev/null')
+      EXEL::Logging.logger = nil
+    end
+  end
 
-    describe '.logger' do
-      before { Logging.instance_variable_set(:@logger, nil) }
+  describe '.logger' do
+    before { EXEL::Logging.instance_variable_set(:@logger, nil) }
 
-      it 'initializes the logger on first read if not already set' do
-        EXEL.configure do |config|
-          config.log_level = :warn
-          config.log_filename = 'log.txt'
-        end
+    it 'initializes the logger on first read if not already set' do
+      EXEL.configure do |config|
+        config.log_level = :warn
+        config.log_filename = 'log.txt'
+      end
+
+      logger = instance_double(Logger)
+      expect(Logger).to receive(:new).with('log.txt').and_return(logger)
+      expect(logger).to receive(:level=).with(Logger::WARN)
+      expect(logger).to receive(:formatter=).with(EXEL::Logging::PrefixFormatter)
+
+      EXEL::Logging.logger
+    end
+  end
+
+  describe '.with_prefix' do
+    it 'sets the prefix before yielding to the block and clears it after' do
+      expect(EXEL::Logging.prefix).to be_nil
 
-        logger = instance_double(Logger)
-        expect(Logger).to receive(:new).with('log.txt').and_return(logger)
-        expect(logger).to receive(:level=).with(Logger::WARN)
+      EXEL::Logging.with_prefix('testing') do
+        expect(EXEL::Logging.prefix).to eq('testing')
+      end
+
+      expect(EXEL::Logging.prefix).to be_nil
+    end
+
+    it 'handles nesting' do
+      EXEL::Logging.with_prefix('outer') do
+        expect(EXEL::Logging.prefix).to eq('outer')
+
+        EXEL::Logging.with_prefix('inner') do
+          expect(EXEL::Logging.prefix).to eq('inner')
+        end
 
-        Logging.logger
+        expect(EXEL::Logging.prefix).to eq('outer')
       end
     end
   end

data/spec/exel/middleware/chain_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+describe EXEL::Middleware::Chain do
+  subject(:chain) { EXEL::Middleware::Chain.new }
+
+  class TestMiddleware
+    def initialize(*)
+    end
+
+    def call
+    end
+  end
+
+  class AnotherTestMiddleware < TestMiddleware
+  end
+
+  describe '#add' do
+    it 'adds a middleware to the chain' do
+      chain.add(TestMiddleware)
+      expect(chain).to include(TestMiddleware)
+    end
+
+    it 'removes and adds to end if already present' do
+      chain.add(TestMiddleware)
+      chain.add(AnotherTestMiddleware)
+      chain.add(TestMiddleware)
+      expect(chain.entries.map(&:klass)).to eq([AnotherTestMiddleware, TestMiddleware])
+    end
+  end
+
+  describe '#remove' do
+    it 'removes a middleware from the chain' do
+      chain.add(TestMiddleware)
+      chain.add(AnotherTestMiddleware)
+      chain.remove(TestMiddleware)
+      expect(chain.entries.map(&:klass)).to eq([AnotherTestMiddleware])
+    end
+  end
+
+  describe '#include?' do
+    it 'returns true if the middleware class is in the chain' do
+      chain.add(TestMiddleware)
+      expect(chain).to include(TestMiddleware)
+    end
+
+    it 'returns false if the middleware class is not in the chain' do
+      chain.add(TestMiddleware)
+      expect(chain).not_to include(AnotherTestMiddleware)
+    end
+  end
+
+  describe '#invoke' do
+    it 'calls each middleware' do
+      chain.add(TestMiddleware)
+      expect_any_instance_of(TestMiddleware).to receive(:call).with(1, 2, 3)
+      chain.invoke(1, 2, 3)
+    end
+
+    it 'initializes middleware with given constructor arguments' do
+      chain.add(TestMiddleware, 1, 2)
+      expect(TestMiddleware).to receive(:new).with(1, 2).and_return(TestMiddleware.new)
+      chain.invoke
+    end
+  end
+end

data/spec/exel/middleware/logging_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+describe EXEL::Middleware::Logging do
+  class TestProcessor
+  end
+
+  describe '#call' do
+    it 'yields to the given block' do
+      called = false
+
+      subject.call(Object, {}, {}) do
+        called = true
+      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'
+    end
+  end
+end

data/spec/exel/middleware_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+describe EXEL::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
+  end
+
+  class RescueErrors
+    def call(_processor, _context, _args)
+      yield
+    rescue
+      nil
+    end
+  end
+
+  class AddProcessor
+    def initialize(context)
+      @context = context
+    end
+
+    def process(_)
+      @context[:output] = @context[:input] + 1
+      raise 'rescue me'
+    end
+  end
+
+  before :all do # rubocop:disable RSpec/BeforeAfterAll
+    EXEL::Job.define :middleware_test_job do
+      process with: AddProcessor, input: 1
+    end
+  end
+
+  let(:input) { [] }
+  let(:output) { [] }
+
+  before do
+    EXEL.configure do |config|
+      config.middleware.add(IORecorder, input, output)
+      config.middleware.add(RescueErrors)
+    end
+  end
+
+  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,5 +1,5 @@
-module EXEL
-  describe NullInstruction do
-    it { is_expected.to respond_to :execute }
-  end
+# frozen_string_literal: true
+
+describe EXEL::NullInstruction do
+  it { is_expected.to respond_to :execute }
 end

data/spec/exel/processors/async_processor_spec.rb

@@ -1,24 +1,23 @@
-module EXEL
-  module Processors
-    describe AsyncProcessor do
-      subject(:processor) { described_class.new(context) }
-      let(:context) { EXEL::Context.new }
-      let(:block) { instance_double(SequenceNode) }
+# frozen_string_literal: true
 
-      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