chasqui 1.0.0.pre.rc1 → 1.0.0

data/spec/integration/setup/sidekiq.rb

@@ -5,4 +5,43 @@ Sidekiq.configure_server do |config|
   config.redis = { url: ENV['REDIS_URL'], namespace: ENV['REDIS_NAMESPACE'] }
 end
 
-require './spec/integration/setup/subscribers'
+def log_event(worker, event, *args)
+  queue = worker.sidekiq_options_hash['queue']
+  event['worker_args'] = args
+
+  Chasqui.redis.rpush "#{queue}:event_log", event.to_json
+end
+
+class UserSignupWorker
+  include Sidekiq::Worker
+  sidekiq_options queue: 'app1'
+
+  def perform(event, *args)
+    log_event self, event, *args
+  end
+end
+
+class TransactionWorker
+  include Sidekiq::Worker
+  sidekiq_options queue: 'app2'
+
+  def perform(event, *args)
+    log_event self, event, *args
+  end
+end
+
+class UserCancelWorker
+  include Sidekiq::Worker
+  sidekiq_options queue: 'app2'
+
+  def perform(event, *args)
+    log_event self, event, *args
+  end
+end
+
+Chasqui.subscribe do
+  on 'user.signup', UserSignupWorker
+  on 'user.cancel', UserCancelWorker
+  on 'account.credit', TransactionWorker
+  on 'account.debit', TransactionWorker
+end

data/spec/lib/chasqui/brokers/redis_broker_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
 
 class Worker1
-  include Chasqui::Subscriber
-  subscribe channel: 'app1', queue: 'queue1'
+  @queue = 'queue1'
+  def self.perform(event, *args); end
 end
 
 class Worker2
-  include Chasqui::Subscriber
-  subscribe channel: 'app2', queue: 'queue2'
+  @queue = 'queue2'
+  def self.perform(event, *args); end
 end
 
 class Worker3
-  include Chasqui::Subscriber
-  subscribe channel: 'app1', queue: 'queue3'
+  @queue = 'queue3'
+  def self.perform(event, *args); end
 end
 
 describe Chasqui::RedisBroker do
@@ -27,9 +27,11 @@ describe Chasqui::RedisBroker do
 
   describe '#forward_event' do
     before do
-      Chasqui.register Worker1
-      Chasqui.register Worker2
-      Chasqui.register Worker3
+      Chasqui.subscribe do
+        on 'app1', Worker1
+        on 'app2', Worker2
+        on 'app1', Worker3
+      end
     end
 
     it 'places the event on all subscriber queues' do
@@ -65,7 +67,7 @@ describe Chasqui::RedisBroker do
           Chasqui.publish 'app2', foo: 'bar'
 
           job = JSON.parse nnredis.blpop('queue:queue2')[1]
-          expect(job).to include('class' => 'Chasqui::Workers::Worker2')
+          expect(job).to include('class' => 'Worker2')
 
           event = {
             'channel' => 'app2',

data/spec/lib/chasqui/config_spec.rb

@@ -4,11 +4,11 @@ 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.default_queue).to eq('chasqui-workers') }
+    it { expect(subject.inbox_queue).to eq('chasqui-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 { expect(subject.queue_adapter).to eq(Chasqui::QueueAdapter::RedisQueueAdapter) }
 
     it do
       # remove chasqui's test environment logger

data/spec/lib/chasqui/{queue_adapters → queue_adapter}/redis_queue_adapter_spec.rb

@@ -1,14 +1,11 @@
 require 'spec_helper'
 
-class MySubscriber
-  include Chasqui::Subscriber
-  subscribe channel: 'channel-name', queue: 'queue-name'
-end
-
-describe Chasqui::QueueAdapters::RedisQueueAdapter do
+describe Chasqui::QueueAdapter::RedisQueueAdapter do
   it_behaves_like 'a queue adapter'
 
-  let(:subscriber) { MySubscriber }
+  let(:subscriber) do
+    Chasqui::Subscriber.new('channel-name', 'queue-name', FakeWorker)
+  end
 
   describe '#bind / #unbind' do
     let(:key) { 'subscriptions:channel-name' }
@@ -26,12 +23,7 @@ describe Chasqui::QueueAdapters::RedisQueueAdapter do
       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)
+        expect(subscriptions).to eq(['resque/FakeWorker/resque:queue:queue-name'])
 
         redis.sadd key, 'random'
 
@@ -52,14 +44,9 @@ describe Chasqui::QueueAdapters::RedisQueueAdapter do
         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(subscriptions).to eq(['sidekiq/FakeWorker/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)

data/spec/lib/chasqui/subscriber_spec.rb

@@ -1,119 +1,9 @@
 require 'spec_helper'
 
 describe Chasqui::Subscriber do
-  let(:subscriber_class) { Class.new { include Chasqui::Subscriber } }
-  let(:redis) { Redis.new }
+  subject { Chasqui::Subscriber.new 'foo', 'bar', 'worker' }
 
-  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 '#redis' do
-    let(:subscriber) { subscriber_class.new event: nil }
-
-    context 'default' do
-      it { expect(subscriber.redis).to eq(Chasqui.redis) }
-    end
-
-    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
-
-  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 '.channels' do
-    before do
-      expect(Chasqui).to receive(:register).with(subscriber_class).at_least(:once)
-      subscriber_class.subscribe channel: 'some.channel'
-    end
-
-    context 'default' do
-      it { expect(subscriber_class.channels).to include('some.channel') }
-    end
-
-    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
-    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
+  it { expect(subject.channel).to eq('foo') }
+  it { expect(subject.queue).to eq('bar') }
+  it { expect(subject.worker).to eq('worker') }
 end

data/spec/lib/chasqui/subscription_builder/resque_subscription_builder_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Chasqui::ResqueSubscriptionBuilder do
+  resque_worker = Class.new do
+    @queue = 'pubsub'
+
+    def self.perform(event, *args)
+    end
+  end
+
+  it_behaves_like 'a subscription builder', resque_worker
+
+  def queue_name(worker)
+    worker.instance_variable_get(:@queue)
+  end
+
+  def perform(worker, *perform_args)
+    worker.perform *perform_args
+  end
+end

data/spec/lib/chasqui/subscription_builder/sidekiq_subscription_builder_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+if sidekiq_supported_ruby_version?
+  describe Chasqui::SidekiqSubscriptionBuilder do
+    sidekiq_worker = Class.new do
+      include Sidekiq::Worker
+      sidekiq_options queue: 'pubsub'
+
+      def perform(event, *args)
+      end
+    end
+
+    it_behaves_like 'a subscription builder', sidekiq_worker
+
+    def queue_name(worker)
+      worker.sidekiq_options['queue']
+    end
+
+    def perform(worker, *perform_args)
+      worker.new.perform *perform_args
+    end
+
+    def expect_worker_to_support_backend(worker)
+      expect(worker.included_modules).to include(Sidekiq::Worker)
+    end
+  end
+end

data/spec/lib/chasqui/subscription_builder_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Chasqui::SubscriptionBuilder do
+  describe '.builder' do
+    let(:subscriptions) { double }
+    let(:options) { { foo: 'bar' } }
+
+    before { reset_config }
+
+    context 'resque' do
+      it do
+        Chasqui.config.worker_backend = :resque
+
+        builder = described_class.builder subscriptions, options
+        expect(builder.subscriptions).to eq(subscriptions)
+        expect(builder.default_options).to eq(options)
+        expect(builder).to be_instance_of(Chasqui::ResqueSubscriptionBuilder)
+      end
+    end
+
+    context 'sidekiq' do
+      it do
+        Chasqui.config.worker_backend = :sidekiq
+
+        builder = described_class.builder subscriptions, options
+        expect(builder.subscriptions).to eq(subscriptions)
+        expect(builder.default_options).to eq(options)
+        expect(builder).to be_instance_of(Chasqui::SidekiqSubscriptionBuilder)
+      end
+    end
+
+    context 'neither' do
+      it do
+        Chasqui.config.worker_backend = :unknown
+        expect(-> {
+          described_class.builder subscriptions, options
+        }).to raise_error(Chasqui::ConfigurationError)
+      end
+    end
+  end
+end

data/spec/lib/chasqui/subscriptions_spec.rb

@@ -5,10 +5,10 @@ describe Chasqui::Subscriptions do
 
   subject { Chasqui::Subscriptions.new queue_adapter }
 
-  let(:a) { new_subscriber 'SubscriberA', channel: 'ch1', queue: 'foo' }
-  let(:b) { new_subscriber 'SubscriberB', channel: 'ch1', queue: 'bar' }
-  let(:c) { new_subscriber 'SubscriberC', channel: 'ch2', queue: 'foo' }
-  let(:d) { new_subscriber 'SubscriberD', channel: 'ch1', queue: 'foo' }
+  let(:a) { Chasqui::Subscriber.new 'ch1', 'foo', double('workerA') }
+  let(:b) { Chasqui::Subscriber.new 'ch1', 'bar', double('workerB') }
+  let(:c) { Chasqui::Subscriber.new 'ch2', 'foo', double('workerC') }
+  let(:d) { Chasqui::Subscriber.new 'ch1', 'foo', double('workerD') }
 
   before do
     reset_config

data/spec/lib/chasqui_spec.rb

@@ -31,16 +31,7 @@ describe Chasqui do
     subject { Chasqui.subscriptions }
 
     it { should be_instance_of(Chasqui::Subscriptions) }
-    it { expect(subject.queue_adapter).to be_instance_of(Chasqui::QueueAdapters::RedisQueueAdapter) }
-  end
-
-  describe 'subscription management delegates' do
-    [:register, :unregister].each do |m|
-      it "delegates :#{m} to #subscriptions" do
-        expect(Chasqui.subscriptions).to receive(m)
-        Chasqui.send m
-      end
-    end
+    it { expect(subject.queue_adapter).to be_instance_of(Chasqui::QueueAdapter::RedisQueueAdapter) }
   end
 
   describe '.publish' do
@@ -57,7 +48,7 @@ describe Chasqui do
       end
 
       payloads.each do |payload|
-        event = JSON.load Chasqui.redis.rpop('inbox')
+        event = JSON.load Chasqui.redis.rpop(Chasqui.config.inbox_queue)
         expect(event['channel']).to eq('test.event')
         expect(event['payload']).to eq(payload)
         expect(event['created_at'].to_f).to be_within(0.1).of(Time.now.to_f)
@@ -67,8 +58,81 @@ describe Chasqui do
 
     it 'supports retries' do
       Chasqui.publish 'test.event', :foo, :bar, foo: 'bar', job_options: { retry: false }
-      event = JSON.load Chasqui.redis.rpop('inbox')
+      event = JSON.load Chasqui.redis.rpop(Chasqui.config.inbox_queue)
       expect(event['retry']).to eq(false)
     end
   end
+
+  describe '.subscribe' do
+    let(:fake_builder) do
+      Class.new(Chasqui::SubscriptionBuilder) do
+        def self.handlers
+          @handlers ||= []
+        end
+
+        def on(channel, worker, options={})
+          self.class.handlers << [channel, worker, options]
+        end
+      end
+    end
+
+    before { reset_config }
+
+    it 'evaluates the block with a subscription builder binding' do
+      results = {}
+      worker = Class.new
+      allow(Chasqui::SubscriptionBuilder).to receive(:builder)
+        .and_return(fake_builder.new(nil))
+
+      Chasqui.subscribe queue: 'foo' do
+        results[:builder] = self
+        on 'channel', worker
+      end
+
+      builder = results[:builder]
+      expect(fake_builder.handlers.first).to eq(['channel', worker, {}])
+    end
+  end
+
+  FakeWorker1 = Class.new
+  FakeWorker2 = Class.new
+
+  describe '.unsubscribe' do
+    let(:subscriptions) { Chasqui.subscriptions }
+
+    before do
+      reset_chasqui
+      Chasqui.config.queue_adapter = FakeQueueAdapter
+      allow_any_instance_of(FakeQueueAdapter).to receive(:bind)
+    end
+
+    it 'unsubscribes all workers' do
+      sub1 = Chasqui::Subscriber.new 'channel', 'queue', FakeWorker1
+      sub2 = Chasqui::Subscriber.new 'channel', 'queue', FakeWorker2
+
+      subscriptions.register sub1
+      subscriptions.register sub2
+      expect(subscriptions.find 'channel', 'queue').to eq([sub1, sub2])
+
+      expect_any_instance_of(FakeQueueAdapter).to receive(:unbind).with(sub1)
+      expect_any_instance_of(FakeQueueAdapter).to receive(:unbind).with(sub2)
+
+      Chasqui.unsubscribe('channel', 'queue')
+      expect(subscriptions.find 'channel', 'queue').to be_empty
+    end
+
+    it 'unsubscribes a single worker' do
+      sub1 = Chasqui::Subscriber.new 'channel', 'queue', FakeWorker1
+      sub2 = Chasqui::Subscriber.new 'channel', 'queue', FakeWorker2
+
+      subscriptions.register sub1
+      subscriptions.register sub2
+      expect(subscriptions.find 'channel', 'queue').to eq([sub1, sub2])
+
+      expect_any_instance_of(FakeQueueAdapter).to receive(:unbind).with(sub1)
+
+      Chasqui.unsubscribe('channel', 'queue', FakeWorker1)
+      expect(subscriptions.find 'channel', 'queue').to eq([sub2])
+    end
+  end
 end