chasqui 0.9.3 → 1.0.0.pre.rc1

data/spec/integration/sidekiq_spec.rb

@@ -3,7 +3,7 @@ require 'integration/pubsub_examples'
 
 if sidekiq_supported_ruby_version?
   describe "sidekiq integration", integration: true do
-    include_examples 'pubsub', :sidekiq, :start_sidekiq_workers
+    include_examples 'pubsub', :start_sidekiq_workers
 
     def start_sidekiq_workers
       @pids << fork do

data/spec/lib/chasqui/{multi_broker_spec.rb → brokers/redis_broker_spec.rb}

@@ -1,7 +1,22 @@
 require 'spec_helper'
 
-describe Chasqui::MultiBroker do
-  let(:broker) { Chasqui::MultiBroker.new }
+class Worker1
+  include Chasqui::Subscriber
+  subscribe channel: 'app1', queue: 'queue1'
+end
+
+class Worker2
+  include Chasqui::Subscriber
+  subscribe channel: 'app2', queue: 'queue2'
+end
+
+class Worker3
+  include Chasqui::Subscriber
+  subscribe channel: 'app1', queue: 'queue3'
+end
+
+describe Chasqui::RedisBroker do
+  let(:broker) { Chasqui::RedisBroker.new }
 
   before do
     reset_chasqui
@@ -12,14 +27,13 @@ describe Chasqui::MultiBroker do
 
   describe '#forward_event' do
     before do
-      Chasqui.config.channel = 'app1'
-      Chasqui.subscribe channel: 'app1', queue: 'queue1'
-      Chasqui.subscribe channel: 'app2', queue: 'queue2'
-      Chasqui.subscribe channel: 'app1', queue: 'queue3'
+      Chasqui.register Worker1
+      Chasqui.register Worker2
+      Chasqui.register Worker3
     end
 
     it 'places the event on all subscriber queues' do
-      Chasqui.publish 'foo.bar', 'A'
+      Chasqui.publish 'app1', foo: 'bar'
       broker.forward_event
 
       expect(nnredis.llen(broker.inbox_queue)).to eq(0)
@@ -28,7 +42,12 @@ describe Chasqui::MultiBroker do
       expect(nnredis.llen('queue:queue2')).to eq(0)
       expect(nnredis.llen('queue:queue3')).to eq(1)
 
-      event = { 'event' => 'foo.bar', 'channel' => 'app1', 'data' => ['A'], 'created_at' => Time.now.to_f.to_s }
+      event = {
+        'channel' => 'app1',
+        'payload' => [{ 'foo' => 'bar' }],
+        'created_at' => Time.now.to_f.to_s,
+        'retry' => true
+      }
 
       job1 = JSON.parse nnredis.lpop('queue:queue1')
       expect(job1['args']).to include(event)
@@ -43,13 +62,19 @@ describe Chasqui::MultiBroker do
       begin
         Timeout::timeout(1) do
           Chasqui.config.redis = Redis.new
-          Chasqui.config.channel = 'app2'
-          Chasqui.publish 'foo.bar', 'A'
+          Chasqui.publish 'app2', foo: 'bar'
 
           job = JSON.parse nnredis.blpop('queue:queue2')[1]
-          expect(job).to include('class' => 'Chasqui::Subscriber__queue2')
-          expect(job).to include('args' =>
-            [{ 'event' => 'foo.bar', 'channel' => 'app2', 'data' => ['A'], 'created_at' => Time.now.to_f.to_s }])
+          expect(job).to include('class' => 'Chasqui::Workers::Worker2')
+
+          event = {
+            'channel' => 'app2',
+            'payload' => [{ 'foo' => 'bar' }],
+            'created_at' => Time.now.to_f.to_s,
+            'retry' => true
+          }
+
+          expect(job).to include('args' => [event])
         end
       ensure
         thread.kill
@@ -57,9 +82,8 @@ describe Chasqui::MultiBroker do
     end
 
     it "doesn't lose events if the broker fails" do
-      Chasqui.config.channel = 'app2'
-      Chasqui.publish 'foo', 'process'
-      Chasqui.publish 'foo', 'keep in queue'
+      Chasqui.publish 'app2', 'process'
+      Chasqui.publish 'app2', 'keep in queue'
       allow(broker.redis).to receive(:smembers).and_raise(Redis::ConnectionError)
 
       expect(-> { broker.forward_event }).to raise_error(Redis::ConnectionError)
@@ -72,7 +96,11 @@ describe Chasqui::MultiBroker do
 
       job = JSON.parse nnredis.lpop('queue:queue2')
       expect(job['args']).to include(
-        'event' => 'foo', 'channel' => 'app2', 'data' => ['process'], 'created_at' => Time.now.to_f.to_s)
+        'channel' => 'app2',
+        'payload' => ['process'],
+        'created_at' => Time.now.to_f.to_s,
+        'retry' => true
+      )
       expect(nnredis.llen(broker.in_progress_queue)).to eq(0)
     end
 
@@ -84,33 +112,33 @@ describe Chasqui::MultiBroker do
 
   describe '#build_job' do
     it 'includes useful metadata' do
-      event = { 'event' => 'foo', 'channel' => 'bar', 'data' => [] }
-      job = JSON.parse broker.build_job('my-queue', event)
+      event = { 'channel' => 'fox4', 'payload' => [] }
+      job = JSON.parse broker.build_job('my-queue', 'MyWorker', event)
 
-      expect(job['class']).to eq('Chasqui::Subscriber__my_queue')
+      expect(job['class']).to eq('MyWorker')
       expect(job['args']).to include(event)
       expect(job['queue']).to eq('my-queue')
       expect(job['jid']).to match(/^[0-9a-f]{24}/i)
       expect(job['created_at']).to be_within(0.01).of(Time.now.to_f)
       expect(job['enqueued_at']).to be_within(0.01).of(Time.now.to_f)
-      expect(job['retry']).to eq(false)
+      expect(job['retry']).to be nil
     end
 
     it 'uses the event created_at time' do
       created_at = (Time.now - 3).to_f
-      job = JSON.parse broker.build_job('my-queue', 'created_at' => created_at.to_s)
+      job = JSON.parse broker.build_job('my-queue', 'MyWorker', 'created_at' => created_at.to_s)
       expect(job['created_at']).to eq(created_at)
     end
 
     it 'uses the event retry value' do
-      job = JSON.parse broker.build_job('my-queue', 'retry' => true)
+      job = JSON.parse broker.build_job('my-queue', 'MyWorker', 'retry' => true)
       expect(job['retry']).to be true
 
-      job = JSON.parse broker.build_job('my-queue', 'retry' => false)
+      job = JSON.parse broker.build_job('my-queue', 'MyWorker', 'retry' => false)
       expect(job['retry']).to be false
 
-      job = JSON.parse broker.build_job('my-queue', 'retry' => nil)
-      expect(job['retry']).to be false
+      job = JSON.parse broker.build_job('my-queue', 'MyWorker', 'retry' => nil)
+      expect(job['retry']).to be nil
     end
   end
 end

data/spec/lib/chasqui/cli_spec.rb

@@ -33,7 +33,7 @@ describe Chasqui::CLI do
         expect(cli.inbox_queue).to eq('inbox2')
 
         cli.configure
-        expect(Chasqui.inbox).to eq('inbox2')
+        expect(Chasqui.inbox_queue).to eq('inbox2')
     end
 
     it 'enables verbose mode (debug logging)' do

data/spec/lib/chasqui/config_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Chasqui::Config do
+
+  context 'defaults' do
+    it { expect(subject.channel_prefix).to be nil }
+    it { expect(subject.default_queue).to eq('chasqui-subscribers') }
+    it { expect(subject.inbox_queue).to eq('inbox') }
+    it { expect(subject.redis.client.db).to eq(0) }
+    it { expect(subject.broker_poll_interval).to eq(3) }
+    it { expect(subject.queue_adapter).to eq(Chasqui::QueueAdapters::RedisQueueAdapter) }
+
+    it do
+      # remove chasqui's test environment logger
+      subject[:logger] = nil
+      expect(subject.logger).to be_kind_of(Logger)
+    end
+
+    it { expect(subject.logger.level).to eq(Logger::INFO) }
+    it { expect(subject.logger.progname).to eq('chasqui') }
+  end
+
+  it 'configures the channel prefix' do
+    subject.channel_prefix = 'com.example.test'
+    expect(subject.channel_prefix).to eq('com.example.test')
+  end
+
+  it 'configures the default queue' do
+    subject.default_queue = 'my-app'
+    expect(subject.default_queue).to eq('my-app')
+  end
+
+  it 'configures the inbox queue' do
+    subject.inbox_queue = 'foo'
+    expect(subject.inbox_queue).to eq('foo')
+  end
+
+  it 'configures the broker poll interval' do
+    subject.broker_poll_interval = 1
+    expect(subject.broker_poll_interval).to eq(1)
+  end
+
+  it 'configures the queue adapter' do
+    subject.queue_adapter = FakeQueueAdapter
+    expect(subject.queue_adapter).to eq(FakeQueueAdapter)
+  end
+
+  context 'redis' do
+    it 'accepts config options' do
+      redis_config = { host: '10.0.3.24' }
+      subject.redis = redis_config
+      expect(subject.redis.client.host).to eq('10.0.3.24')
+    end
+
+    it 'accepts an initialized client' do
+      redis = Redis.new db: 2
+      subject.redis = redis
+      expect(subject.redis.client.db).to eq(2)
+    end
+
+    it 'accepts URLs' do
+      subject.redis = 'redis://10.0.1.21:12345/0'
+      expect(subject.redis.client.host).to eq('10.0.1.21')
+    end
+
+    it 'uses a namespace' do
+      subject.redis.set 'foo', 'bar'
+      expect(subject.redis.redis.get 'chasqui:foo').to eq('bar')
+    end
+  end
+
+  describe 'logger' do
+    it 'accepts a log device' do
+      logs = StringIO.new
+      subject.logger = logs
+      subject.logger.info "status"
+      subject.logger.warn "error"
+
+      logs.rewind
+      output = logs.read
+
+      %w(chasqui INFO status WARN error).each do |text|
+        expect(output).to match(text)
+      end
+    end
+
+    it 'accepts a logger-like object' do
+      fake_logger = FakeLogger.new
+      subject.logger = fake_logger
+      expect(subject.logger).to eq(fake_logger)
+      expect(subject.logger.progname).to eq('chasqui')
+    end
+  end
+
+  context 'worker_backend' do
+    it 'chooses resque' do
+      allow(Object).to receive(:const_defined?).with(:Resque).and_return true
+      allow(Object).to receive(:const_defined?).with(:Sidekiq).and_return false
+      expect(subject.worker_backend).to eq(:resque)
+    end
+
+    it 'chooses sidekiq' do
+      allow(Object).to receive(:const_defined?).with(:Resque).and_return true
+      allow(Object).to receive(:const_defined?).with(:Sidekiq).and_return true
+      expect(subject.worker_backend).to eq(:sidekiq)
+    end
+
+    it 'refuses to guess' do
+      allow(Object).to receive(:const_defined?).with(:Resque).and_return false
+      allow(Object).to receive(:const_defined?).with(:Sidekiq).and_return false
+      expect(subject.worker_backend).to be nil
+    end
+
+    it 'allows you to choose the worker backend' do
+      allow(Object).to receive(:const_defined?).with(:Resque).and_return true
+      allow(Object).to receive(:const_defined?).with(:Sidekiq).and_return true
+      subject.worker_backend = :resque
+      expect(subject.worker_backend).to eq(:resque)
+    end
+  end
+end

data/spec/lib/chasqui/fake_queue_adapter_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe FakeQueueAdapter do
+  it_behaves_like 'a queue adapter'
+end

data/spec/lib/chasqui/queue_adapters/redis_queue_adapter_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+class MySubscriber
+  include Chasqui::Subscriber
+  subscribe channel: 'channel-name', queue: 'queue-name'
+end
+
+describe Chasqui::QueueAdapters::RedisQueueAdapter do
+  it_behaves_like 'a queue adapter'
+
+  let(:subscriber) { MySubscriber }
+
+  describe '#bind / #unbind' do
+    let(:key) { 'subscriptions:channel-name' }
+
+    before { reset_chasqui_workers }
+    after { reset_chasqui_workers }
+
+    context 'resque backend' do
+      before do
+        reset_chasqui
+        Chasqui.config.worker_backend = :resque
+        Resque.redis.namespace = :resque
+      end
+
+      it 'persists the subscriptions to redis' do
+        subject.bind(subscriber)
+        subscriptions = redis.smembers(key)
+        expect(subscriptions).to eq(
+          ['resque/Chasqui::Workers::MySubscriber/resque:queue:queue-name'])
+
+        expect(Chasqui::Workers.constants).to include(:MySubscriber)
+        worker = Chasqui::Workers.const_get :MySubscriber
+        expect(worker.subscriber).to eq(MySubscriber)
+
+        redis.sadd key, 'random'
+
+        subject.unbind(subscriber)
+        subscriptions = redis.smembers('subscriptions:channel-name')
+        expect(subscriptions).to eq(['random'])
+      end
+    end
+
+    if sidekiq_supported_ruby_version?
+      context 'sidekiq backend' do
+        before do
+          reset_chasqui
+          Chasqui.config.worker_backend = :sidekiq
+          Sidekiq.configure_client { |c| c.redis = { namespace: nil } }
+        end
+
+        it 'persists the subscription to redis' do
+          subject.bind(subscriber)
+          subscriptions = redis.smembers('subscriptions:channel-name')
+          expect(subscriptions).to eq(
+            ['sidekiq/Chasqui::Workers::MySubscriber/queue:queue-name'])
+          expect(redis_no_namespace.smembers 'queues').to eq(['queue-name'])
+
+          expect(Chasqui::Workers.constants).to include(:MySubscriber)
+          worker = Chasqui::Workers.const_get :MySubscriber
+          expect(worker.subscriber).to eq(MySubscriber)
+
+          redis.sadd key, 'random'
+
+          subject.unbind(subscriber)
+          subscriptions = redis.smembers('subscriptions:channel-name')
+          expect(subscriptions).to eq(['random'])
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/chasqui/subscriber_spec.rb

@@ -1,67 +1,119 @@
 require 'spec_helper'
 
 describe Chasqui::Subscriber do
-  let(:subscriber) { Chasqui::Subscriber.new 'my-queue', 'my.channel' }
+  let(:subscriber_class) { Class.new { include Chasqui::Subscriber } }
+  let(:redis) { Redis.new }
 
-  it { expect(subscriber.queue).to eq('my-queue') }
-  it { expect(subscriber.channel).to eq('my.channel') }
+  describe '#event' do
+    it { expect(subscriber_class.new(event: 'foo').event).to eq('foo') }
+    it { expect(-> { subscriber_class.new }).to raise_error(KeyError) }
+  end
 
-  describe '#on' do
-    it 'registers the event handlers' do
-      subscriber.on('foo') { |foo| foo }
-      subscriber.on('zig.zag') { |*args| args }
+  describe '#redis' do
+    let(:subscriber) { subscriber_class.new event: nil }
 
-      pattern = subscriber.matching_handler_patterns_for('foo').first
-      expect(subscriber.call_handler(pattern, 'bar')).to eq('bar')
+    context 'default' do
+      it { expect(subscriber.redis).to eq(Chasqui.redis) }
+    end
 
-      pattern = subscriber.matching_handler_patterns_for('zig.zag').first
-      expect(subscriber.call_handler(pattern, 1, 2, 3, 4)).to eq([1, 2, 3, 4])
+    context 'custom' do
+      let(:redis) { Redis.new }
+      let(:subscriber)  { subscriber_class.new event: nil, redis: redis }
+      it { expect(subscriber.redis.object_id).to eq(redis.object_id) }
     end
+  end
 
-    it 'raises when registering duplicate handlers' do
-      subscriber.on('foo') { |foo| foo }
-      expect(-> {
-        subscriber.on('foo') { |a, b| a + b }
-      }).to raise_error(Chasqui::HandlerAlreadyRegistered)
+  describe '#logger' do
+    let(:subscriber) { subscriber_class.new event: nil }
+
+    context 'default' do
+      it { expect(subscriber.logger).to eq(Chasqui.logger) }
+    end
+
+    context 'custom' do
+      let(:logger) { FakeLogger.new }
+      let(:subscriber) { subscriber_class.new event: nil, logger: logger }
+      it { expect(subscriber.logger).to eq(logger) }
     end
   end
 
-  describe '#matching_handler_patterns_for' do
-    it 'always returns an array' do
-      expect(subscriber.matching_handler_patterns_for('unknown')).to eq([])
+  describe '.channels' do
+    before do
+      expect(Chasqui).to receive(:register).with(subscriber_class).at_least(:once)
+      subscriber_class.subscribe channel: 'some.channel'
     end
 
-    it 'matches single event' do
-      p = Proc.new { }
-      subscriber.on('foo', &p)
-      expect(subscriber.matching_handler_patterns_for('foo')).to eq([/\Afoo\z/])
+    context 'default' do
+      it { expect(subscriber_class.channels).to include('some.channel') }
     end
 
-    it 'matches wildcards' do
-      p = 6.times.map { Proc.new { } }
-      subscriber.on('foo*', &p[0])
-      subscriber.on('bar', &p[1])
-      subscriber.on('*bar', &p[2])
-      subscriber.on('*', &p[3])
-      subscriber.on('*a*', &p[4])
-      subscriber.on('*z*', &p[5])
-      expect(subscriber.matching_handler_patterns_for('foo.bar')).to eq([
-        /\Afoo.*\z/,
-        /\A.*bar\z/,
-        /\A.*\z/,
-        /\A.*a.*\z/
-      ])
+    context 'with default prefix' do
+      before do
+        Chasqui.config.channel_prefix = 'prefix'
+        subscriber_class.subscribe channel: 'some.channel'
+      end
+
+      it { expect(subscriber_class.channels).to include('prefix.some.channel') }
+    end
+
+    context 'with custom prefix' do
+      before { Chasqui.config.channel_prefix = 'prefix' }
+
+      it 'uses the custom prefix' do
+        subscriber_class.subscribe channel: 'another.channel', prefix: 'custom'
+        expect(subscriber_class.channels).to include('custom.another.channel')
+      end
+
+      it 'removes the prefix' do
+        subscriber_class.subscribe channel: 'another.channel', prefix: nil
+        expect(subscriber_class.channels).to include('another.channel')
+      end
+    end
+
+    context 'multiple channels' do
+      before { subscriber_class.subscribe channel: ['foo', 'bar'], prefix: 'custom' }
+
+      it 'subscribes to multiple channels' do
+        expect(subscriber_class.channels).to eq(['custom.foo', 'custom.bar'])
+      end
+    end
+  end
+
+  describe '.queue' do
+    context 'default' do
+      it { expect(subscriber_class.queue).to eq(Chasqui.default_queue) }
+    end
+
+    context 'custom' do
+      before do
+        expect(Chasqui).to receive(:register).with(subscriber_class)
+        subscriber_class.subscribe queue: 'custom-queue'
+      end
+
+      it { expect(subscriber_class.queue).to eq('custom-queue') }
     end
   end
 
   describe '#perform' do
-    it 'calls the matching event handlers' do
-      calls = []
-      subscriber.on('foo.bar') { |a, b| calls << a + b }
-      subscriber.on('foo.*') { |a, b| calls << a ** b }
-      subscriber.perform(redis, { 'event' => 'foo.bar', 'data' => [3, 4] })
-      expect(calls.sort).to eq([7, 81])
+    let(:subscriber) { subscriber_class.new event: nil }
+
+    it 'is not implemented' do
+      expect(-> {
+        subscriber.perform foo: 'bar'
+      }).to raise_error(NotImplementedError)
     end
   end
 
+  describe '.inherited' do
+    before { allow(Chasqui).to receive(:register) }
+
+    it 'maintains a registry of inherited classes' do
+      klass = Class.new do
+        include Chasqui::Subscriber
+        subscribe
+      end
+
+      expect(Chasqui::Subscriber.subscribers).to include(klass)
+    end
+  end
 end