exel 1.4.0 → 1.5.1

data/spec/exel/listen_instruction_spec.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
-module EXEL
-  describe 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
+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

@@ -1,94 +1,92 @@
 # frozen_string_literal: true
-module EXEL
-  module Logging
-    describe LoggerWrapper do
-      subject(:wrapper) { 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
-
-      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)
+describe EXEL::Logging::LoggerWrapper do
+  subject(:wrapper) { EXEL::Logging::LoggerWrapper.new(logger) }
 
-                wrapper.send(level, &block)
-              end
+  let(:logger) { instance_double(Logger) }
 
-              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)
+  it { is_expected.to be_a(SimpleDelegator) }
 
-                  wrapper.send(level, 'test', &block)
-                end
-              end
-            end
+  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
 
-        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')
+        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
 
-      context 'with a Logging prefix' do
-        before { allow(Logging).to receive(:prefix).and_return('prefix: ') }
+    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
 
-        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 'with a Logging prefix' do
+    before { allow(EXEL::Logging).to receive(:prefix).and_return('prefix: ') }
 
-            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
+    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
 
-                wrapper.send(level) { 'message' }
-              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
 
-              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) { 'message' }
+          end
 
-                  wrapper.send(level, 'test') { '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
+    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

data/spec/exel/logging_helper_spec.rb

@@ -1,24 +1,23 @@
 # frozen_string_literal: true
-module EXEL
-  describe LoggingHelper do
-    class HelperClass
-      include LoggingHelper
-    end
 
-    let(:helper) { HelperClass.new }
+describe EXEL::LoggingHelper do
+  class HelperClass
+    include EXEL::LoggingHelper
+  end
 
-    describe '#logger' do
-      it 'returns EXEL.logger' do
-        expect(helper.logger).to eq(EXEL.logger)
-      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
+  %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

data/spec/exel/logging_spec.rb

@@ -1,80 +1,80 @@
 # frozen_string_literal: true
-module EXEL
-  describe Logging do
-    before { @restore_logger = Logging.logger }
-    after { Logging.logger = @restore_logger }
-
-    describe 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
+
+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
 
-      context 'with a Logging prefix' do
-        it 'adds the prefix to the formatted message' do
-          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
+    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)
-        Logging.logger = logger
-        expect(Logging.logger).to be_a(Logging::LoggerWrapper)
-        expect(Logging.logger.__getobj__).to be(logger)
-      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')
-        Logging.logger = nil
-      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(Logging::PrefixFormatter)
+      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)
 
-        Logging.logger
-      end
+      EXEL::Logging.logger
     end
+  end
 
-    describe '.with_prefix' do
-      it 'sets the prefix before yielding to the block and clears it after' do
-        expect(Logging.prefix).to be_nil
-
-        Logging.with_prefix('testing') do
-          expect(Logging.prefix).to eq('testing')
-        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
 
-        expect(Logging.prefix).to be_nil
+      EXEL::Logging.with_prefix('testing') do
+        expect(EXEL::Logging.prefix).to eq('testing')
       end
 
-      it 'handles nesting' do
-        Logging.with_prefix('outer') do
-          expect(Logging.prefix).to eq('outer')
+      expect(EXEL::Logging.prefix).to be_nil
+    end
 
-          Logging.with_prefix('inner') do
-            expect(Logging.prefix).to eq('inner')
-          end
+    it 'handles nesting' do
+      EXEL::Logging.with_prefix('outer') do
+        expect(EXEL::Logging.prefix).to eq('outer')
 
-          expect(Logging.prefix).to eq('outer')
+        EXEL::Logging.with_prefix('inner') do
+          expect(EXEL::Logging.prefix).to eq('inner')
         end
+
+        expect(EXEL::Logging.prefix).to eq('outer')
       end
     end
   end

data/spec/exel/middleware/chain_spec.rb

@@ -1,67 +1,65 @@
 # frozen_string_literal: true
-module EXEL
-  module Middleware
-    describe Chain do
-      subject(:chain) { EXEL::Middleware::Chain.new }
 
-      class TestMiddleware
-        def initialize(*)
-        end
+describe EXEL::Middleware::Chain do
+  subject(:chain) { EXEL::Middleware::Chain.new }
 
-        def call
-        end
-      end
+  class TestMiddleware
+    def initialize(*)
+    end
 
-      AnotherTestMiddleware = Class.new(TestMiddleware)
+    def call
+    end
+  end
 
-      describe '#add' do
-        it 'adds a middleware to the chain' do
-          chain.add(TestMiddleware)
-          expect(chain).to include(TestMiddleware)
-        end
+  class AnotherTestMiddleware < 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 '#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 '#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
+  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
+    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
+  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
+    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