proletariat 0.0.2 → 0.0.3

data/lib/proletariat/subscriber.rb

@@ -8,19 +8,17 @@ module Proletariat
 
     # Public: Creates a new Subscriber instance.
     #
-    # connection    - An open Bunny::Session object.
-    # exchange_name - A String of the RabbitMQ topic exchange.
-    # queue_config  - A QueueConfig value object.
-    def initialize(connection, listener, queue_config)
-      @connection   = connection
+    # listener     - Object to delegate new messages to.
+    # queue_config - A QueueConfig value object.
+    def initialize(listener, queue_config)
       @listener     = listener
       @queue_config = queue_config
 
-      @channel      = @connection.create_channel
+      @channel      = Proletariat.connection.create_channel
 
-      @channel.prefetch queue_config.prefetch
+      @channel.prefetch Proletariat.worker_threads
 
-      @exchange     = @channel.topic queue_config.exchange_name, durable: true
+      @exchange     = @channel.topic Proletariat.exchange_name, durable: true
       @bunny_queue  = @channel.queue queue_config.queue_name,
                                      durable: true,
                                      auto_delete: queue_config.auto_delete

data/lib/proletariat/testing/expectation_guarantor.rb

@@ -19,7 +19,6 @@ module Proletariat
       # block        - The block of code within which the expectations should
       #                be satisfied.
       def initialize(expectations, &block)
-        @connection  = Proletariat.runner.connection
         @counters    = []
         @subscribers = []
 
@@ -27,7 +26,7 @@ module Proletariat
           queue_config = generate_queue_config_for_topic(expectation.topics)
           counter = MessageCounter.new(expectation.quantity)
           counters << counter
-          subscribers << Subscriber.new(connection, counter, queue_config)
+          subscribers << Subscriber.new(counter, queue_config)
         end
 
         @block = block
@@ -40,7 +39,7 @@ module Proletariat
       def guarantee
         run_subscribers
 
-        block.call
+        block.call if block
 
         timer = 0.0
 
@@ -61,9 +60,6 @@ module Proletariat
       #           satisfied.
       attr_reader :block
 
-      # Internal: Returns an open Bunny::Session object.
-      attr_reader :connection
-
       # Internal: Returns an array of MessageCounter instances.
       attr_reader :counters
 
@@ -71,7 +67,7 @@ module Proletariat
       attr_reader :subscribers
 
       def generate_queue_config_for_topic(topics)
-        QueueConfig.new('', Proletariat.runner.exchange_name, topics, 1, true)
+        QueueConfig.new('', topics, true)
       end
 
       # Internal: Checks each counter to ensure expected messages have arrived.
@@ -107,8 +103,8 @@ module Proletariat
         # Public: Creates a new MessageCounter instance.
         #
         # expected - The number of messages expected.
-        def initialize(expected)
-          @count    = 0
+        def initialize(expected, count = 0)
+          @count    = count
           @expected = expected
         end
 

data/lib/proletariat/testing.rb

@@ -4,7 +4,7 @@ require 'proletariat/testing/fixnum_extension'
 
 module Proletariat
   # Public: Mixin to aid solve test synchronization issues while still running
-  #         Proletariat the same way you would in production,
+  #         Proletariat the same way you would in production.
   module Testing
     # Public: Builds an Expectation instance which listens for a single message
     #         on any topic.

data/lib/proletariat/util/worker_description_parser.rb

@@ -0,0 +1,37 @@
+module Proletariat
+  # Internal: Helper utility to parse and constantize strings into arrays of
+  #           Worker classes.
+  module WorkerDescriptionParser
+    # Public: Parse given string into array of Worker classes.
+    #
+    # description - String to be parsed. Should contain comma-separated class
+    #               names.
+    #
+    # Examples
+    #
+    #   WorkerDescriptionParser.parse('FirstWorker,SecondWorker')
+    #   # => [FirstWorker, SecondWorker]
+    #
+    # Returns an Array of Worker classes.
+    def self.parse(description)
+      description.split(',').map(&:strip).map do |string|
+        constantize string
+      end.compact
+    end
+
+    private
+
+    # Intenal: Performs constantizing of worker names into Classes.
+    #
+    # name - The name to be constantized.
+    #
+    # Returns the Worker class if valid.
+    # Returns the nil if Worker class cannot be found.
+    def self.constantize(name)
+      name.split('::').reduce(Object) { |a, e| a.const_get(e) }
+    rescue NameError => e
+      Proletariat.logger.warn "Missing worker class: #{e.name}"
+      nil
+    end
+  end
+end

data/lib/proletariat/version.rb

@@ -1,4 +1,4 @@
 # Public: Adds a constant for the current version number.
 module Proletariat
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/proletariat/worker.rb

@@ -1,48 +1,39 @@
+require 'proletariat/concerns/logging'
+
 module Proletariat
-  # Public: Handles messages from a RabbitMQ queue. Subclasses should
+  # Public: Handles messages for Background processing. Subclasses should
   #         overwrite the #work method.
-  class Worker < Concurrent::Actor
+  class Worker
     include Concerns::Logging
 
-    # Internal: Called by the Concurrent framework to handle new mailbox
-    #           messages. Overridden in this subclass to call the #work method
-    #           with the given message.
-    #
-    # message - The incoming message.
+    # Public: Logs the 'online' status of the worker.
     #
     # Returns nil.
-    def act(message)
-      work message
+    def started
+      log_info 'Now online'
+
+      nil
     end
 
-    # Internal: Called by the Concurrent framework on actor start. Overridden
-    #           in this subclass to log the status of the worker.
+    # Public: Logs the 'offline' status of the worker.
     #
     # Returns nil.
-    def on_run
-      super
-
-      log_info 'Now online'
+    def stopped
+      log_info 'Now offline'
 
       nil
     end
 
-    # Internal: Called by the Concurrent framework on actor start. Overridden
-    #         in this subclass to log the status of the worker.
+    # Public: Logs the 'shutting down' status of the worker.
     #
     # Returns nil.
-    def on_stop
+    def stopping
       log_info 'Attempting graceful shutdown.'
-      wait_for_work_queue unless queue.empty?
-
-      super
-
-      log_info 'Now offline'
 
       nil
     end
 
-    # Public: Handles RabbitMQ messages.
+    # Public: Handles an incoming message to perform background work.
     #
     # message - The incoming message.
     #
@@ -51,8 +42,6 @@ module Proletariat
       fail NotImplementedError
     end
 
-    protected
-
     # Public: Helper method to ease accessing the logger from within #work.
     #         Sends #info to logger if message provided.
     #
@@ -90,19 +79,6 @@ module Proletariat
       nil
     end
 
-    private
-
-    # Internal: Blocks until each message has been handled by #work.
-    #
-    # Returns nil.
-    def wait_for_work_queue
-      log_info 'Waiting for work queue to drain.'
-
-      work(*queue.pop.message) until queue.empty?
-
-      nil
-    end
-
     # Internal: Class methods on Worker to provide configuration DSL.
     module ConfigurationMethods
       # Public: A configuration method for adding a routing key to be used when
@@ -111,8 +87,8 @@ module Proletariat
       # routing_key - A routing key for queue-binding as a String.
       #
       # Returns nil.
-      def listen_on(routing_key)
-        routing_keys << routing_key
+      def listen_on(*new_routing_keys)
+        routing_keys.concat new_routing_keys
 
         nil
       end

data/lib/proletariat.rb

@@ -5,8 +5,12 @@ require 'bunny'
 require 'logger'
 require 'forwardable'
 
-require 'proletariat/concerns/logging'
+require 'proletariat/concurrency/actor'
+require 'proletariat/concurrency/supervisor'
 
+require 'proletariat/util/worker_description_parser'
+
+require 'proletariat/configuration'
 require 'proletariat/manager'
 require 'proletariat/publisher'
 require 'proletariat/queue_config'
@@ -15,73 +19,42 @@ require 'proletariat/subscriber'
 require 'proletariat/worker'
 
 # Public: Creates the Proletariat namespace and holds a process-wide Runner
-#         instance as well as a logger.
+#         instance as well as access to the configuration attributes.
 module Proletariat
-  # Public: The default name used for the RabbitMQ topic exchange.
-  DEFAULT_EXCHANGE_NAME = 'proletariat'
-
   class << self
     extend Forwardable
 
     # Public: Delegate lifecycle calls to the process-wide Runner.
     def_delegators :runner, :run, :run!, :stop, :running?, :publish, :purge
 
-    # Public: Allows the setting of an alternate logger.
+    # Public: Allows configuration of Proletariat via given block.
     #
-    # logger - An object which fulfills the role of a Logger.
-    attr_writer :logger
-
-    # Public: Sets the process-wide Runner to an instance initialized with a
-    #         given hash of options.
+    # block - Block containing configuration calls.
     #
-    # options - A Hash of options (default: {}):
-    #             :connection        - An open RabbitMQ::Session object.
-    #             :exchange_name     - The RabbitMQ topic exchange name as a
-    #                                  String.
-    #             :logger            - An object which fulfills the role of a
-    #                                  Logger.
-    #             :publisher_threads - The size of the publisher thread pool.
-    #             :supervisor        - A Supervisor instance.
-    #             :worker_classes    - An Array of Worker subclasses.
-    #             :worker_threads    - The size of the worker thread pool.
-    def configure(options = {})
-      self.logger = options.fetch(:logger, default_logger)
+    # Returns nil.
+    def configure(&block)
+      config.configure_with_block(&block)
 
-      @runner = Runner.new(defaults.merge(options))
-    end
-
-    # Internal: The logger used if no other is specified via .configure.
-    #
-    # Returns a Logger which logs to STDOUT.
-    def default_logger
-      Logger.new(STDOUT)
+      nil
     end
 
-    # Internal: Default process-wide Runner options.
-    #
-    # Returns a Hash of options.
-    def defaults
-      {
-        worker_classes: workers_from_env || []
-      }
+    def runner
+      @runner ||= Runner.new
     end
 
-    def logger
-      @logger ||= default_logger
+    def method_missing(method_sym, *arguments, &block)
+      if config.respond_to? method_sym
+        config.send method_sym
+      else
+        super
+      end
     end
 
-    def runner
-      @runner ||= Runner.new(defaults)
-    end
+    private
 
-    def workers_from_env
-      if ENV['WORKERS']
-        ENV['WORKERS'].split(',').map(&:strip).map do |string|
-          string
-            .split('::')
-            .reduce(Object) { |a, e| a.const_get(e) }
-        end
-      end
+    # Internal: Global configuration object.
+    def config
+      @config ||= Configuration.new
     end
   end
 end

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,85 @@
+require 'proletariat'
+
+FirstWorker = Class.new
+SecondWorker = Class.new
+
+module Proletariat
+  describe Configuration do
+    describe '#configure_with_block' do
+      it 'should allow configuration via `config.[attribute]=`' do
+        configuration = Configuration.new
+        expect(configuration).to receive(:connection=).with('new connection')
+        configuration.configure_with_block do
+          config.connection = 'new connection'
+        end
+      end
+    end
+
+    describe '#connection' do
+      let(:new_session) { double.as_null_object }
+
+      before do
+        stub_const 'Bunny', double(new: new_session)
+      end
+
+      it 'should default to a creating a new bunny session' do
+        expect(Bunny).to receive(:new)
+        Configuration.new.connection
+      end
+
+      it 'should open any new bunny sessions' do
+        expect(new_session).to receive(:start)
+        Configuration.new.connection
+      end
+    end
+
+    describe '#exchange_name' do
+      it 'should default to proletariat' do
+        expect(Configuration.new.exchange_name).to eq 'proletariat'
+      end
+    end
+
+    describe '#logger' do
+      it 'should default to STDOUT' do
+        expect(Logger).to receive(:new).with(STDOUT)
+        Configuration.new.logger
+      end
+    end
+
+    describe '#publisher_threads' do
+      it 'should default to 2' do
+        expect(Configuration.new.publisher_threads).to eq 2
+      end
+    end
+
+    describe '#worker_classes' do
+      context 'WORKERS env variable is set' do
+        before do
+          ENV['WORKERS'] = 'FirstWorker,SecondWorker'
+        end
+
+        after do
+          ENV['WORKERS'] = nil
+        end
+
+        it 'should default to workers in env variable' do
+          expect(Configuration.new.worker_classes).to \
+            eq [FirstWorker, SecondWorker]
+        end
+      end
+
+      context 'WORKERS env variable is not set' do
+        it 'should default to an empty array' do
+          expect(Configuration.new.worker_classes).to \
+            eq []
+        end
+      end
+    end
+
+    describe '#worker_threads' do
+      it 'should default to 3' do
+        expect(Configuration.new.worker_threads).to eq 3
+      end
+    end
+  end
+end

data/spec/lib/proletariat_spec.rb

@@ -40,10 +40,11 @@ end
 
 describe Proletariat do
   it 'should roughly work' do
-    Proletariat.configure(
-      logger: Logger.new('/dev/null'),
-      worker_classes: [PingWorker, PongWorker]
-    )
+    Proletariat.configure do
+      config.logger         = Logger.new('/dev/null')
+      config.worker_classes = [PingWorker, PongWorker]
+    end
+
     Proletariat.run!
     sleep 2
     Proletariat.publish 'ping', ''

data/spec/lib/publisher_spec.rb

@@ -0,0 +1,36 @@
+require 'proletariat/publisher'
+
+module Proletariat
+  describe Publisher do
+    let(:connection) { double.as_null_object }
+    let(:exchange_name) { 'great-exchange' }
+    let(:logger) { double }
+
+    before do
+      allow(Proletariat).to receive(:connection).and_return(connection)
+      allow(Proletariat).to receive(:exchange_name).and_return(exchange_name)
+      allow(Proletariat).to receive(:logger).and_return(logger)
+    end
+
+    describe '#started' do
+      it 'should log status' do
+        expect(logger).to receive(:info).with /online/
+        Publisher.new.started
+      end
+    end
+
+    describe '#stopped' do
+      it 'should log status' do
+        expect(logger).to receive(:info).with /offline/
+        Publisher.new.stopped
+      end
+    end
+
+    describe '#stopping' do
+      it 'should log status' do
+        expect(logger).to receive(:info).with /graceful shutdown/
+        Publisher.new.stopping
+      end
+    end
+  end
+end

data/spec/lib/queue_config_spec.rb

@@ -0,0 +1,12 @@
+require 'proletariat/queue_config'
+
+module Proletariat
+  describe QueueConfig do
+    describe '#queue_name' do
+      it 'should return an underscored version of the worker name' do
+        queue_config = QueueConfig.new('ExampleWorker', ['lolcats'], false)
+        expect(queue_config.queue_name).to eq 'example_worker'
+      end
+    end
+  end
+end

data/spec/lib/testing/expectation_guarantor_spec.rb

@@ -0,0 +1,55 @@
+require 'proletariat/testing/expectation_guarantor'
+
+module Proletariat
+  module Testing
+    describe ExpectationGuarantor::MessageCounter do
+      describe '#expected_messages_received?' do
+        context 'count is equal or greater than expected' do
+          it 'should return true' do
+            counter = ExpectationGuarantor::MessageCounter.new(1, 3)
+            expect(counter.expected_messages_received?).to be_truthy
+          end
+        end
+
+        context 'count is less than expected' do
+          it 'should return false' do
+            counter = ExpectationGuarantor::MessageCounter.new(5, 3)
+            expect(counter.expected_messages_received?).to be_falsey
+          end
+        end
+      end
+
+      describe '#post?' do
+        class FakeBlockTaker
+          attr_reader :block
+
+          def initialize(&block)
+            @block = block
+          end
+        end
+
+        before do
+          stub_const 'Concurrent::Future', FakeBlockTaker
+        end
+
+        it 'should increment the count' do
+          counter = ExpectationGuarantor::MessageCounter.new(1)
+          counter.post?('message')
+          expect(counter.expected_messages_received?).to be_truthy
+        end
+
+        it 'should return a future containing :ok' do
+          counter = ExpectationGuarantor::MessageCounter.new(1)
+          expect(Concurrent::Future).to receive(:new)
+          counter.post?('message')
+        end
+
+        it 'should ensure the returned future contains :ok' do
+          counter = ExpectationGuarantor::MessageCounter.new(1)
+          future = counter.post?('message')
+          expect(future.block.call).to eq :ok
+        end
+      end
+    end
+  end
+end

data/spec/lib/testing/expectation_spec.rb

@@ -0,0 +1,15 @@
+require 'proletariat/testing/expectation'
+
+module Proletariat
+  module Testing
+    describe Expectation do
+      describe '#on_topic' do
+        it 'should return a new expectation with given topic' do
+          expectation = Expectation.new([], 2)
+          expect(expectation.on_topic('lolcats', 'dogs').topics).to \
+            eq %w(lolcats dogs)
+        end
+      end
+    end
+  end
+end

data/spec/lib/util/worker_description_parser_spec.rb

@@ -0,0 +1,42 @@
+require 'proletariat/util/worker_description_parser'
+
+FakeWorker = Class.new
+AnotherFakeWorker = Class.new
+
+module Proletariat
+  describe WorkerDescriptionParser do
+    describe '.parse' do
+      let(:logger) { double.as_null_object }
+
+      before do
+        stub_const 'Proletariat', double(logger: logger)
+      end
+
+      context 'worker classes exist' do
+        it 'should return the worker classes' do
+          parsed = WorkerDescriptionParser.parse 'FakeWorker,AnotherFakeWorker'
+          expect(parsed).to eq [FakeWorker, AnotherFakeWorker]
+        end
+      end
+
+      context 'worker classes do not exist' do
+        it 'should return an empty array' do
+          parsed = WorkerDescriptionParser.parse('NonexistantWorker')
+          expect(parsed).to eq []
+        end
+
+        it 'should log a warning for the missing class' do
+          expect(logger).to receive(:warn).with(/Missing worker class/)
+          WorkerDescriptionParser.parse('NonexistantWorker')
+        end
+      end
+
+      context 'some worker classes exist' do
+        it 'should return only the existing classes' do
+          parsed = WorkerDescriptionParser.parse 'FakeWorker,NonexistantWorker'
+          expect(parsed).to eq [FakeWorker]
+        end
+      end
+    end
+  end
+end