distribot 0.1.1

data/spec/distribot/handler_finished_handler_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Distribot::HandlerFinishedHandler do
+  before do
+    Distribot.stub(:subscribe)
+  end
+  describe 'definition' do
+    it 'subscribes to the correct queue' do
+      expect(Distribot::Handler.queue_for(described_class)).to eq 'distribot.flow.handler.finished'
+    end
+    it 'declares a valid handler' do
+      expect(Distribot::Handler.handler_for(described_class)).to eq :callback
+    end
+    it 'has a method matching the handler name' do
+      expect(described_class.new).to respond_to :callback
+    end
+  end
+
+  describe '#callback(message)' do
+    before do
+      @message = {
+        task_queue: 'task-queue',
+        flow_id: 'flow-id',
+        phase: 'phase1'
+      }
+      @handler = described_class.new
+    end
+    context 'when all the handler\'s tasks' do
+      context 'are complete' do
+        before do
+          expect(Distribot::Flow).to receive(:find).with(@message[:flow_id]) do
+            Distribot::Flow.new(id: @message[:flow_id], phases: [{name:'phase1', handlers: []}])
+          end
+          expect(@handler).to receive(:all_phase_handler_tasks_are_complete?){ true }
+        end
+        it 'announces that this phase has completed and that everyone should stop consuming its task.finished queue' do
+          # Describe what 'nothing' looks like:
+          expect(Distribot).to receive(:publish!).with('distribot.flow.phase.finished', {
+            flow_id: @message[:flow_id],
+            phase: 'phase1'
+          })
+
+          # Finally:
+          @handler.callback(@message)
+        end
+      end
+      context 'are not yet complete' do
+        before do
+          expect(Distribot::Flow).to receive(:find).with(@message[:flow_id]) do
+            Distribot::Flow.new(id: @message[:flow_id], phases: [{name:'phase1', handlers: []}])
+          end
+          expect(@handler).to receive(:all_phase_handler_tasks_are_complete?){ false }
+        end
+        it 'does nothing' do
+          # Describe what 'nothing' looks like:
+          expect(Distribot).not_to receive(:publish!)
+          expect(Distribot).not_to receive(:broadcast!)
+
+          # Finally:
+          @handler.callback(@message)
+        end
+      end
+    end
+  end
+
+  describe '#all_phase_handler_tasks_are_complete?(flow, phase)' do
+    context 'when all tasks are complete' do
+      before do
+        @flow = Distribot::Flow.new(id: 123)
+        handlers = ['handler1']
+        task_counts = {
+          "distribot.flow.123.phase1.handler1.tasks" => 0,
+        }
+        @phase = Distribot::Phase.new(name: 'phase1', handlers: [
+          'handler1'
+        ])
+        expect(Distribot).to receive(:redis) do
+          redis = double('redis')
+          expect(redis).to receive(:get).exactly(1).times do |key|
+            task_counts[key]
+          end
+          redis
+        end
+      end
+      it 'returns true' do
+        expect(described_class.new.all_phase_handler_tasks_are_complete?(@flow, @phase)).to be_truthy
+      end
+    end
+    context 'when some tasks remain' do
+      before do
+        @flow = Distribot::Flow.new(id: 123)
+        handlers = ['handler1']
+        task_counts = {
+          "distribot.flow.123.phase1.handler1.tasks" => 1,
+        }
+        @phase = Distribot::Phase.new(name: 'phase1', handlers: [
+          'handler1'
+        ])
+        expect(Distribot).to receive(:redis) do
+          redis = double('redis')
+          expect(redis).to receive(:get).exactly(1).times do |key|
+            task_counts[key]
+          end
+          redis
+        end
+      end
+      it 'returns false' do
+        expect(described_class.new.all_phase_handler_tasks_are_complete?(@flow, @phase)).to be_falsey
+      end
+    end
+  end
+end

data/spec/distribot/handler_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Distribot::Handler do
+  before do
+    Distribot.stub(:subscribe)
+    Distribot.stub(:subscribe_multi)
+  end
+  describe '.subscribe_to' do
+    before do
+      @id = SecureRandom.hex(8)
+      @queue_name = "queue-#{@id}"
+      @klass_name = "Foo#{@id}"
+      expect(Distribot).to receive(:subscribe).with(@queue_name, {}) do |queue_name, args, &block|
+        block.call(queue_name, args, block)
+      end
+    end
+    it 'subscribes to the queue provided' do
+      eval <<-EOF
+      class #{@klass_name}
+        include Distribot::Handler
+        subscribe_to '#{@queue_name}', handler: :callback
+        def callback(message)
+        end
+      end
+      EOF
+      @klass_ref = Kernel.const_get(@klass_name)
+      @klass_ref.new
+      expect(@klass_ref.handler).to eq :callback
+      expect(@klass_ref.queue).to eq @queue_name
+    end
+  end
+end

data/spec/distribot/module_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Distribot do
+  describe '.debug' do
+    it 'allows true and false values' do
+      Distribot.debug = true
+      expect(Distribot.debug).to be_truthy
+      Distribot.debug = false
+      expect(Distribot.debug).to be_falsey
+    end
+  end
+
+  describe '.configure' do
+    it 'executes the given block and uses the result as the configuration' do
+      Distribot.reset_configuration!
+      Distribot.configuration
+      Distribot.configure do |config|
+        config.foo=:bar
+      end
+      expect(Distribot.configuration.foo).to eq :bar
+    end
+  end
+
+  describe '.redis' do
+    context 'when configuration.redis_url' do
+      context 'is nil' do
+        before do
+          Distribot.reset_configuration!
+          Distribot.configure do |config|
+            config.redis_url = nil
+          end
+        end
+        it 'returns a new Redis instance without argument' do
+          expect(Redis).to receive(:new).with(no_args){ 'HELLO' }
+          expect(Distribot.redis).to eq 'HELLO'
+        end
+      end
+      context 'is given' do
+        before do
+          @redis_url = 'redis://foo:6379/0'
+          Distribot.reset_configuration!
+          Distribot.configure do |config|
+            config.redis_url = @redis_url
+          end
+        end
+        it 'returns a new Redis instance' do
+          expect(Redis).to receive(:new).with(url: @redis_url){ 'HELLO' }
+          expect(Distribot.redis).to eq 'HELLO'
+        end
+      end
+    end
+  end
+
+  describe '.connector' do
+    before do
+      Distribot.configure do |config|
+        config.rabbitmq_url = 'fake-rabbit-url'
+      end
+    end
+    it 'returns a BunnyConnector' do
+      expect(Distribot::BunnyConnector).to receive(:new).with('fake-rabbit-url'){ 'connector' }
+      expect(Distribot.connector).to eq 'connector'
+    end
+  end
+
+  describe '.queue_exists?(name)' do
+    context 'when the queue exists' do
+      before do
+        @queue_name = "queue-#{SecureRandom.uuid}"
+        expect(Distribot).to receive(:connector) do
+          connector = double('connector')
+          expect(connector).to receive(:queue_exists?).with(@queue_name){ true }
+          connector
+        end
+      end
+      it 'returns true' do
+        expect(Distribot.queue_exists?(@queue_name)).to be_truthy
+      end
+    end
+    context 'when the queue does not exist' do
+      before do
+        @queue_name = "queue-#{SecureRandom.uuid}"
+        expect(Distribot).to receive(:connector) do
+          connector = double('connector')
+          expect(connector).to receive(:queue_exists?).with(@queue_name){ false }
+          connector
+        end
+      end
+      it 'returns false' do
+        expect(Distribot.queue_exists?(@queue_name)).to be_falsey
+      end
+    end
+  end
+
+  describe '.subscribe(queue_name, options={}, &block)' do
+    before do
+      @topic = "queue-#{SecureRandom.uuid}"
+      expect(Distribot).to receive(:connector) do
+        connector = double('connector')
+        expect(connector).to receive(:subscribe).with(@topic, {}) do |&block|
+          block.call( hello: 'world' )
+        end
+        connector
+      end
+    end
+    it 'subscribes properly' do
+      Distribot.subscribe(@topic) do |message|
+        expect(message).to have_key :hello
+        expect(message[:hello]).to eq 'world'
+      end
+    end
+  end
+
+  describe '.subscribe_multi(topic, options={}, &block)' do
+    before do
+      @topic = "queue-#{SecureRandom.uuid}"
+      expect(Distribot).to receive(:connector) do
+        connector = double('connector')
+        expect(connector).to receive(:subscribe_multi).with(@topic, {}) do |&block|
+          block.call( hello: 'world' )
+        end
+        connector
+      end
+    end
+    it 'subscribes properly' do
+      Distribot.subscribe_multi(@topic) do |message|
+        expect(message).to have_key :hello
+        expect(message[:hello]).to eq 'world'
+      end
+    end
+  end
+
+  describe '.publish!(topic, data)' do
+    before do
+      @topic = SecureRandom.uuid
+      @data = { id: SecureRandom.uuid }
+      expect(Distribot).to receive(:connector) do
+        connector = double('connector')
+        expect(connector).to receive(:publish).with(@topic, @data)
+        connector
+      end
+    end
+    it 'publishes the message to the topic' do
+      Distribot.publish!(@topic, @data)
+    end
+  end
+
+  describe '.broadcast!(topic, data)' do
+    before do
+      @topic = SecureRandom.uuid
+      @data = { id: SecureRandom.uuid }
+      expect(Distribot).to receive(:connector) do
+        connector = double('connector')
+        expect(connector).to receive(:broadcast).with(@topic, @data)
+        connector
+      end
+    end
+    it 'publishes the message to the topic' do
+      Distribot.broadcast!(@topic, @data)
+    end
+  end
+
+end

data/spec/distribot/multi_subscription_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Distribot::MultiSubscription do
+  describe 'inheritance' do
+    let(:subject){ described_class.new(nil) }
+    it { should be_a Distribot::ConnectionSharer }
+  end
+
+  describe '#start(topic, options={}, &block)' do
+    it 'subscribes to the rabbit queue' do
+      # Arrange:
+      @topic = 'my.topic'
+      subscription = described_class.new(nil)
+
+      queue = double('queue')
+      channel = double('channel')
+      expect(channel).to receive(:queue).with('', exclusive: true, auto_delete: true){ queue }
+      expect(channel).to receive(:fanout).with(@topic){ 'exchange' }
+      expect(queue).to receive(:bind).with('exchange') do
+        exchange = double('exchange')
+        expect(exchange).to receive(:subscribe) do |&block|
+          block.call(nil, nil, {id: :good_message} )
+          block.call(nil, nil, {id: :bad_message} )
+        end
+        exchange
+      end
+      expect(subscription).to receive(:channel).exactly(2).times{ channel }
+
+      # Act:
+      subscription.start(@topic) do |msg|
+        raise "Test error" if msg[:id] == 'bad_message'
+      end
+
+      # Assert:
+    end
+  end
+end

data/spec/distribot/phase_finished_handler_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Distribot::PhaseFinishedHandler do
+  describe 'definition' do
+    it 'subscribes to the correct queue' do
+      expect(Distribot::Handler.queue_for(described_class)).to eq 'distribot.flow.phase.finished'
+    end
+    it 'declares a valid handler' do
+      expect(Distribot::Handler.handler_for(described_class)).to eq :callback
+    end
+    it 'has a method matching the handler name' do
+      expect(Distribot).to receive(:subscribe)
+      expect(described_class.new).to respond_to :callback
+    end
+  end
+
+  describe '#callback( :flow_id, :phase )' do
+    before do
+      expect(Distribot).to receive(:subscribe)
+    end
+    context 'when flow is' do
+      before do
+        @flow = double('flow')
+        @flow_id = 'xxx'
+        expect(Distribot::Flow).to receive(:find).with(@flow_id) { @flow }
+      end
+      context 'still in :phase' do
+        before do
+          expect(@flow).to receive(:current_phase){ 'start' }
+        end
+        context 'and the flow' do
+          context 'has a next phase' do
+            before do
+              expect(@flow).to receive(:next_phase).exactly(2).times{ 'finish' }
+            end
+            it 'tells the flow to transition to the next phase' do
+              expect(@flow).to receive(:transition_to!).with('finish')
+              described_class.new.callback(flow_id: @flow_id, phase: 'start')
+            end
+          end
+          context 'does not have a next phase' do
+            before do
+              expect(@flow).to receive(:next_phase){ nil }
+              expect(@flow).to receive(:id){ @flow_id }
+            end
+            it 'publishes to distribot.flow.finished' do
+              expect(Distribot).to receive(:publish!).with('distribot.flow.finished', {
+                flow_id: @flow_id
+              })
+              described_class.new.callback(flow_id: @flow_id, phase: 'start')
+            end
+          end
+        end
+      end
+      context 'no longer in :phase' do
+        it 'does nothing'
+      end
+    end
+  end
+
+end

data/spec/distribot/phase_started_handler_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe Distribot::PhaseStartedHandler do
+  describe 'definition' do
+    it 'subscribes to the correct queue' do
+      expect(Distribot::Handler.queue_for(described_class)).to eq 'distribot.flow.phase.started'
+    end
+    it 'declares a valid handler' do
+      expect(Distribot::Handler.handler_for(described_class)).to eq :callback
+    end
+    it 'has a method matching the handler name' do
+      expect(Distribot).to receive(:subscribe)
+      expect(described_class.new).to respond_to :callback
+    end
+  end
+
+  describe '#callback' do
+    before do
+      @flow = Distribot::Flow.new(
+        id: 1,
+        name: 'test',
+        phases: [{
+          name: 'phase1',
+          is_initial: true,
+        }]
+      )
+      expect(Distribot::Flow).to receive(:find).with(1){ @flow }
+      @phase = double('phase')
+      expect(@phase).to receive(:handlers).at_least(1).times{ @handlers }
+      expect(@flow).to receive(:phase).with('phase1'){ @phase }
+    end
+    context 'when this phase has' do
+      context 'no handlers' do
+        before do
+          @handlers = [ ]
+          expect(@phase).to receive(:name){ 'phase1' }
+        end
+        it 'considers this phase finished and publishes a message to that effect' do
+          expect(Distribot).to receive(:publish!).with('distribot.flow.phase.finished', {
+            flow_id: @flow.id,
+            phase: 'phase1'
+          })
+          expect(Distribot).to receive(:subscribe)
+          described_class.new.callback(flow_id: @flow.id, phase: 'phase1')
+        end
+      end
+      context 'some handlers' do
+        before do
+          @handlers = [
+            Distribot::PhaseHandler.new( name: 'FooHandler' ),
+            Distribot::PhaseHandler.new(
+              name: 'BarHandler',
+              version: '>= 1.0'
+            )
+          ]
+          expect(Distribot).to receive(:subscribe)
+          @worker = described_class.new
+        end
+        context 'and all the handlers have suitable version matches' do
+          before do
+            expect(@worker).to receive(:best_version).ordered.with(@handlers[0]){ '1.0' }
+            expect(@worker).to receive(:best_version).ordered.with(@handlers[1]){ '2.0' }
+            expect(@worker).to receive(:init_handler).ordered.with(
+              @flow,
+              @phase,
+              @handlers[0],
+              '1.0'
+            )
+            expect(@worker).to receive(:init_handler).ordered.with(
+              @flow,
+              @phase,
+              @handlers[1],
+              '2.0'
+            )
+          end
+          it 'jumpstarts each handler' do
+            @worker.callback(flow_id: @flow.id, phase: 'phase1')
+          end
+        end
+        context 'any of the handlers cannot find a suitable version' do
+          before do
+            expect(@worker).to receive(:best_version)
+            expect(@worker).not_to receive(:init_handler)
+          end
+          it 'raises an exception' do
+            expect{@worker.callback(flow_id: @flow.id, phase: 'phase1')}.to raise_error RuntimeError
+          end
+        end
+      end
+    end
+  end
+
+  describe '#best_version(handler)' do
+    before do
+      expect(Distribot).to receive(:connector) do
+        connector = double('connector')
+        expect(connector).to receive(:queues) {
+          %w(
+            distribot.flow.handler.FooHandler.0.9.0.tasks
+            distribot.flow.handler.FooHandler.1.0.0.tasks
+            distribot.flow.handler.FooHandler.1.0.1.tasks
+            distribot.flow.handler.FooHandler.2.0.0.tasks
+            distribot.flow.handler.BarHandler.1.0.0.tasks
+          )
+        }
+        connector
+      end
+      expect(Distribot).to receive(:subscribe)
+      @worker = described_class.new
+    end
+    context 'when the handler version' do
+      context 'is specified in the flow ' do
+        before do
+          @handler = Distribot::PhaseHandler.new(name: 'FooHandler', version: '~> 1.0')
+        end
+        it 'returns the highest available *matching* version for that handler' do
+          expect(@worker.best_version(@handler)).to eq '1.0.1'
+        end
+      end
+      context 'is not specified in the flow' do
+        before do
+          @handler = Distribot::PhaseHandler.new(name: 'FooHandler')
+        end
+        it 'returns the highest available version for that handler' do
+          expect(@worker.best_version(@handler)).to eq '2.0.0'
+        end
+      end
+    end
+  end
+
+  describe '#init_handler(flow, phase, handler, version)' do
+    before do
+      @flow = Distribot::Flow.new(id: 'xxx')
+      @phase = Distribot::Phase.new(name: 'phase1')
+      @handler = Distribot::PhaseHandler.new(name: 'FooHandler', version: '1.0')
+      @version = '1.0'
+      expect(Distribot).to receive(:subscribe)
+      expect(Distribot).to receive(:publish!).with("distribot.flow.handler.#{@handler}.#{@version}.enumerate",
+        flow_id: @flow.id,
+        phase: @phase.name,
+        task_queue: a_string_matching(/\.#{@handler}\.#{@version}\.tasks/),
+        task_counter: a_string_matching(/\.#{@flow.id}\.#{@phase.name}\.#{@handler}\.finished/),
+        finished_queue: 'distribot.flow.task.finished',
+      )
+    end
+    it 'publishes a message for the handler with everything it needs to begin task enumeration' do
+      described_class.new.init_handler(@flow, @phase, @handler, @version)
+    end
+  end
+end

data/spec/distribot/subscription_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Distribot::Subscription do
+  describe 'inheritance' do
+    let(:subject){ described_class.new(nil) }
+    it { should be_a Distribot::ConnectionSharer }
+  end
+
+  describe '#start(topic, options={}, &block)' do
+    it 'subscribes to the rabbit queue' do
+      # Arrange:
+      @topic = 'my.topic'
+      subscription = described_class.new(nil)
+
+      channel = double('channel')
+      expect(channel).to receive(:queue).ordered.with(@topic, anything) do
+        queue = double('queue')
+        expect(queue).to receive(:subscribe).with(hash_including(manual_ack: true)) do |args, &block|
+          # Send a good message:
+          delivery_info1 = OpenStruct.new(delivery_tag: 'tag1')
+          delivery_info2 = OpenStruct.new(delivery_tag: 'tag2')
+          block.call(delivery_info1, nil, {id: :good_message}.to_json )
+          block.call(delivery_info2, nil, {id: :bad_message}.to_json )
+        end
+        queue
+      end
+      expect(channel).to receive(:acknowledge).with('tag1', false)
+      expect(channel).to receive(:basic_reject).with('tag2', true)
+
+      expect(subscription).to receive(:channel).exactly(3).times{ channel }
+
+      # Act:
+      subscription.start(@topic) do |msg|
+        raise "Test error" if msg[:id] == 'bad_message'
+      end
+
+      # Assert:
+    end
+  end
+end

data/spec/distribot/task_finished_handler_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Distribot::TaskFinishedHandler do
+  before do
+    Distribot.stub(:subscribe)
+  end
+  describe 'definition' do
+    it 'subscribes to the correct queue' do
+      expect(Distribot::Handler.queue_for(described_class)).to eq 'distribot.flow.task.finished'
+    end
+    it 'declares a valid handler' do
+      expect(Distribot::Handler.handler_for(described_class)).to eq :callback
+    end
+    it 'has a method matching the handler name' do
+      expect(described_class.new).to respond_to :callback
+    end
+  end
+
+  describe '#callback(message)' do
+    before do
+      @message = {
+        task_queue: 'task-queue',
+        finished_queue: 'finished-queue',
+        phase: 'the-phase',
+        handler: 'the-hander',
+        flow_id: 'flow-id'
+      }
+    end
+    context 'when the redis task counter' do
+      context 'is nil' do
+        before do
+          @redis = double('redis')
+          expect(@redis).to receive(:get){ nil }
+          expect(Distribot).to receive(:redis) do
+            @redis
+          end
+        end
+        it 'does nothing, because the handler is not yet finished' do
+          # Finally, action:
+          handler = Distribot::TaskFinishedHandler.new
+          handler.callback(@message)
+        end
+      end
+      context 'is not nil' do
+        before do
+          @redis = double('redis')
+          expect(Distribot).to receive(:redis).at_least(1).times do
+            @redis
+          end
+        end
+        context 'when the task count after decrementing' do
+          context 'is == 0' do
+            before do
+              expect(@redis).to receive(:get){ 0 }
+              expect(@redis).to receive(:del).ordered
+            end
+            it 'publishes a message to the handler finished queue' do
+              handler = Distribot::TaskFinishedHandler.new
+
+              expect(Distribot).to receive(:publish!).with("distribot.flow.handler.finished", @message.except(:finished_queue))
+
+              # Finally, action:
+              handler.callback(@message)
+            end
+          end
+        end
+      end
+    end
+  end
+
+end