chasqui 0.9.3 → 1.0.0.pre.rc1

data/spec/lib/chasqui/subscriptions_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chasqui::Subscriptions do
+  let(:queue_adapter) { FakeQueueAdapter.new }
+
+  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' }
+
+  before do
+    reset_config
+
+    allow(Chasqui).to receive(:register)
+
+    [a, b, c, d].each do |subscriber|
+      expect(queue_adapter).to receive(:bind).with(subscriber)
+      subject.register subscriber
+    end
+  end
+
+  it 'registers subscribers' do
+    [a, b, c, d].each do |subscriber|
+      expect(subject.subscribed? subscriber).to be true
+    end
+
+    expect(subject.subscribers.size).to eq(4)
+
+    group1 = subject.find 'ch1', 'foo'
+    expect(group1).to include(a)
+    expect(group1).to include(d)
+
+    group2 = subject.find 'ch1', 'bar'
+    expect(group2.size).to eq(1)
+    expect(subject.find 'ch1', 'bar').to include(b)
+
+    group3 = subject.find 'ch2', 'foo'
+    expect(group3.size).to eq(1)
+    expect(subject.find 'ch2', 'foo').to include(c)
+  end
+
+  it 'unregisters subscribers' do
+    [a, b, c].each do |subscriber|
+      expect(queue_adapter).to receive(:unbind).with(subscriber)
+      subject.unregister subscriber
+      expect(subject.subscribed? subscriber).to be false
+    end
+
+    expect(subject.subscribed? d).to be true
+
+    expect(subject.find 'ch1', 'bar').to be_empty
+    expect(subject.find 'ch2', 'foo').to be_empty
+
+    remaining = subject.find 'ch1', 'foo'
+    expect(remaining.size).to eq(1)
+    expect(remaining).to include(d)
+  end
+end

data/spec/lib/chasqui/worker_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+class MockSubscriber
+  include Chasqui::Subscriber
+  subscribe channel: 'foo-channel', prefix: nil, queue: 'foo-queue'
+
+  def perform(payload)
+    self.class.info[:event] = event
+    self.class.info[:payload] = payload
+    self.class.info[:redis] = redis
+    self.class.info[:logger] = logger
+  end
+
+  class << self
+    def info
+      @info ||= {}
+    end
+  end
+end
+
+describe Chasqui::Worker do
+  before do
+    reset_config
+    Chasqui::Worker.workers.clear
+    MockSubscriber.instance_variable_set :@info, nil
+  end
+
+  let(:subscriber) { MockSubscriber }
+
+  context 'no worker backend' do
+    describe '.create' do
+      it 'raises' do
+        Chasqui.config.worker_backend = :does_not_exist
+
+        expect(-> {
+          Chasqui::Worker.create subscriber
+        }).to raise_error(Chasqui::ConfigurationError)
+      end
+    end
+  end
+
+  context 'resque' do
+    before { Chasqui.config.worker_backend = :resque }
+    after { Chasqui::Workers.send :remove_const, :MockSubscriber }
+
+    describe '.create' do
+      let(:worker) { Chasqui::Worker.create subscriber }
+
+      it { expect(worker.name).to eq('Chasqui::Workers::MockSubscriber') }
+      it { expect(worker.instance_variable_get(:@queue)).to eq(subscriber.queue) }
+      it { expect(worker.instance_variable_get(:@subscriber)).to eq(subscriber) }
+
+      it 'delegates #perform to the subscriber' do
+        event = {
+          'channel' => 'foo-channel',
+          'payload' => { 'some' => 'data' }
+        }
+
+        worker.perform event
+
+        expect(subscriber.info[:event]).to eq(event)
+        expect(subscriber.info[:payload]).to eq(event['payload'])
+      end
+    end
+  end
+
+  if sidekiq_supported_ruby_version?
+    context 'sidekiq' do
+      before { Chasqui.config.worker_backend = :sidekiq }
+      after { Chasqui::Workers.send :remove_const, :MockSubscriber }
+
+      describe '.create' do
+        let(:worker) { Chasqui::Worker.create subscriber }
+
+        it { expect(worker.name).to eq('Chasqui::Workers::MockSubscriber') }
+        it { expect(worker.instance_variable_get(:@subscriber)).to eq(subscriber) }
+        it { expect(worker.sidekiq_options).to include('queue' => 'foo-queue') }
+        it { expect(worker.included_modules).to include(Sidekiq::Worker) }
+
+        it 'delegates #perform to the subscriber' do
+          event = {
+            'channel' => 'foo-channel',
+            'payload' => { 'some' => 'data' }
+          }
+
+          sidekiq_worker = worker.new
+          sidekiq_worker.perform event
+
+          expect(subscriber.info[:event]).to eq(event)
+          expect(subscriber.info[:payload]).to eq(event['payload'])
+          expect(subscriber.info[:logger]).to eq(sidekiq_worker.logger)
+        end
+      end
+    end
+  end
+end

data/spec/lib/chasqui_spec.rb

@@ -5,90 +5,40 @@ describe Chasqui do
     expect(Chasqui::VERSION).not_to be nil
   end
 
-  describe '.configure' do
-    before { reset_config }
-
-    context 'defaults' do
-      it { expect(Chasqui.channel).to eq('__default') }
-      it { expect(Chasqui.inbox_queue).to eq('inbox') }
-      it { expect(Chasqui.redis.client.db).to eq(0) }
-      it { expect(Chasqui.config.broker_poll_interval).to eq(3) }
-      it { expect(Chasqui.config.worker_backend).to eq(nil) }
-
-      it do
-        # remove chasqui's test environment logger
-        Chasqui.config[:logger] = nil
-        expect(Chasqui.logger).to be_kind_of(Logger)
-      end
-
-      it { expect(Chasqui.logger.level).to eq(Logger::INFO) }
-      it { expect(Chasqui.logger.progname).to eq('chasqui') }
-    end
-
-    it 'configures the channel' do
-      Chasqui.config.channel = 'com.example.test'
-      expect(Chasqui.channel).to eq('com.example.test')
-    end
-
-    it 'accepts a block' do
-      Chasqui.configure { |config| config.channel = 'com.example.test' }
-      expect(Chasqui.channel).to eq('com.example.test')
-    end
-
-    it 'configures the inbox queue' do
-      Chasqui.config.inbox_queue = 'foo'
-      expect(Chasqui.inbox).to eq('foo')
-    end
-
-    it 'configures the broker poll interval' do
-      Chasqui.config.broker_poll_interval = 1
-      expect(Chasqui.config.broker_poll_interval).to eq(1)
+  describe '.config' do
+    it 'returns a config object' do
+      expect(Chasqui.config).to be_instance_of(Chasqui::Config)
     end
+  end
 
-    context 'redis' do
-      it 'accepts config options' do
-        redis_config = { host: '10.0.3.24' }
-        Chasqui.config.redis = redis_config
-        expect(Chasqui.redis.client.host).to eq('10.0.3.24')
-      end
-
-      it 'accepts an initialized client' do
-        redis = Redis.new db: 2
-        Chasqui.config.redis = redis
-        expect(Chasqui.redis.client.db).to eq(2)
-      end
-
-      it 'accepts URLs' do
-        Chasqui.config.redis = 'redis://10.0.1.21:12345/0'
-        expect(Chasqui.redis.client.host).to eq('10.0.1.21')
+  describe '.configure' do
+    it 'yields a config object' do
+      Chasqui.configure do |c|
+        expect(c).to be_instance_of(Chasqui::Config)
       end
+    end
+  end
 
-      it 'uses a namespace' do
-        Chasqui.redis.set 'foo', 'bar'
-        expect(Chasqui.redis.redis.get 'chasqui:foo').to eq('bar')
+  describe 'config delegates' do
+    Chasqui::CONFIG_SETTINGS.each do |setting|
+      it "responds to #{setting}" do
+        expect(Chasqui).to respond_to(setting)
       end
     end
+  end
 
-    describe 'logger' do
-      it 'accepts a log device' do
-        logs = StringIO.new
-        Chasqui.config.logger = logs
-        Chasqui.logger.info "status"
-        Chasqui.logger.warn "error"
-
-        logs.rewind
-        output = logs.read
+  describe '.subscriptions' do
+    subject { Chasqui.subscriptions }
 
-        %w(chasqui INFO status WARN error).each do |text|
-          expect(output).to match(text)
-        end
-      end
+    it { should be_instance_of(Chasqui::Subscriptions) }
+    it { expect(subject.queue_adapter).to be_instance_of(Chasqui::QueueAdapters::RedisQueueAdapter) }
+  end
 
-      it 'accepts a logger-like object' do
-        fake_logger = FakeLogger.new
-        Chasqui.config.logger = fake_logger
-        expect(Chasqui.logger).to eq(fake_logger)
-        expect(Chasqui.logger.progname).to eq('chasqui')
+  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
   end
@@ -106,128 +56,19 @@ describe Chasqui do
         Chasqui.publish 'test.event', *args
       end
 
-      payloads.each do |data|
+      payloads.each do |payload|
         event = JSON.load Chasqui.redis.rpop('inbox')
-        expect(event['event']).to eq('test.event')
-        expect(event['channel']).to eq('__default')
-        expect(event['data']).to eq(data)
-        expect(event['created_at'].to_f).to be_within(0.01).of(Time.now.to_f)
+        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)
+        expect(event['retry']).to eq(true)
       end
     end
 
-    it 'supports channels' do
-      Chasqui.config.channel = 'my.app'
-      Chasqui.publish 'test.event', :foo
-      event = JSON.load Chasqui.redis.rpop('inbox')
-      expect(event['event']).to eq('test.event')
-      expect(event['channel']).to eq('my.app')
-      expect(event['data']).to eq(['foo'])
-    end
-
     it 'supports retries' do
-      Chasqui.publish 'test.event', :foo, :bar, foo: 'bar', job_options: { retry: true }
+      Chasqui.publish 'test.event', :foo, :bar, foo: 'bar', job_options: { retry: false }
       event = JSON.load Chasqui.redis.rpop('inbox')
-      expect(event['retry']).to eq(true)
-    end
-  end
-
-  describe '.subscribe' do
-    before do
-      reset_chasqui
-      Resque.redis.namespace = :resque
-      Chasqui.config.worker_backend = :resque
-    end
-
-    context 'with defaults' do
-      it 'subscribes to events on the default channel' do
-        sub = Chasqui.subscribe queue: 'my-queue'
-
-        channel = Chasqui.config.channel
-        queues = Chasqui.redis.smembers Chasqui.subscription_key(channel)
-        expect(queues).to eq(['resque/resque:queue:my-queue'])
-      end
-    end
-
-    context 'resque worker subscriptions' do
-      before { Resque.redis.namespace = 'blah' }
-
-      it 'creates subscriptions using the appropriate redis namespace' do
-        sub1 = Chasqui.subscribe channel: 'com.example.admin', queue: 'app1-queue'
-        sub2 = Chasqui.subscribe channel: 'com.example.admin', queue: 'app2-queue'
-        sub3 = Chasqui.subscribe channel: 'com.example.video', queue: 'app1-queue'
-
-        queues = Chasqui.redis.smembers Chasqui.subscription_key("com.example.admin")
-        expect(queues.sort).to eq(['resque/blah:queue:app1-queue', 'resque/blah:queue:app2-queue'])
-
-        queues = Chasqui.redis.smembers Chasqui.subscription_key("com.example.video")
-        expect(queues).to eq(['resque/blah:queue:app1-queue'])
-
-        expect(Chasqui.subscription('app1-queue')).to eq(sub1)
-        expect(Chasqui.subscription('app2-queue')).to eq(sub2)
-        expect(sub1).to eq(sub3)
-      end
-    end
-
-    if sidekiq_supported_ruby_version?
-      context 'sidekiq worker subscriptions' do
-        before do
-          Chasqui.config.worker_backend = :sidekiq
-        end
-
-        it 'creates subscriptions using the appropriate redis namespace' do
-          Chasqui.subscribe channel: 'com.example.admin', queue: 'app1-queue'
-          queues = Chasqui.redis.smembers Chasqui.subscription_key("com.example.admin")
-          expect(queues.sort).to eq(['sidekiq/queue:app1-queue'])
-
-          Sidekiq.redis = { url: redis.client.options[:url], namespace: 'foobar' }
-          Chasqui.subscribe channel: 'com.example.video', queue: 'app2-queue'
-          queues = Chasqui.redis.smembers Chasqui.subscription_key("com.example.video")
-          expect(queues.sort).to eq(['sidekiq/foobar:queue:app2-queue'])
-        end
-      end
-    end
-
-    it 'returns a subscription' do
-      subscription = Chasqui.subscribe channel: 'com.example.admin', queue: 'app1-queue'
-      expect(subscription.subscriber).to be_kind_of(Chasqui::Subscriber)
-    end
-
-    it 'yields a subscriber configuration context' do
-      $context = nil
-      Chasqui.subscribe channel: 'bar', queue: 'foo' do
-        $context = self
-      end
-      expect($context).to be_kind_of(Chasqui::Subscriber)
-    end
-  end
-
-  describe '.unsubscribe' do
-    before do
-      reset_chasqui
-      Chasqui.config.worker_backend = :resque
-      Resque.redis.namespace = 'ns0'
-      Chasqui.subscribe channel: 'com.example.admin', queue: 'app1-queue'
-      Chasqui.subscribe channel: 'com.example.admin', queue: 'app2-queue'
-      Chasqui.subscribe channel: 'com.example.video', queue: 'app1-queue'
-    end
-
-    it 'removes the subscription' do
-      subscription_id = Chasqui.unsubscribe 'com.example.admin', queue: 'app1-queue'
-      expect(subscription_id).to eq('resque/ns0:queue:app1-queue')
-      expect(redis.smembers(Chasqui.subscription_key 'com.example.admin').sort).to eq(['resque/ns0:queue:app2-queue'])
-      expect(redis.smembers(Chasqui.subscription_key 'com.example.video').sort).to eq(['resque/ns0:queue:app1-queue'])
-    end
-
-    it 'returns nil for unknown subscriptions' do
-      subscription_id = Chasqui.unsubscribe 'unknown', queue: 'unknown'
-      expect(subscription_id).to be nil
-    end
-  end
-
-  describe '.subscriber_class_name' do
-    it 'transforms queue name into a subscribe class name' do
-      expect(Chasqui.subscriber_class_name('my-queue')).to eq(:Subscriber__my_queue)
-      expect(Chasqui.subscriber_class_name('queue:my-queue')).to eq(:Subscriber__my_queue)
+      expect(event['retry']).to eq(false)
     end
   end
 end

data/spec/spec_helper.rb

@@ -7,7 +7,7 @@ require 'chasqui'
 require 'resque'
 require 'pp'
 
-Dir['spec/support/*.rb'].each { |file| require File.expand_path(file) }
+Dir['spec/support/**/*.rb'].each { |file| require File.expand_path(file) }
 
 RSpec.configure do |c|
   c.include ChasquiSpecHelpers

data/spec/support/chasqui_spec_helpers.rb

@@ -3,13 +3,23 @@ module ChasquiSpecHelpers
   def reset_chasqui
     flush_redis
     reset_config
+    reset_chasqui_workers
   end
 
   def reset_config
     Chasqui.instance_variable_set(:@config, nil)
+    Chasqui.instance_variable_set(:@subscriptions, nil)
     Chasqui.config.logger = './tmp/test.log'
   end
 
+  def reset_chasqui_workers
+    Chasqui::Worker.workers.clear
+
+    Chasqui::Workers.constants.each do |c|
+      Chasqui::Workers.send :remove_const, c
+    end
+  end
+
   def redis
     Chasqui.redis
   end
@@ -23,4 +33,22 @@ module ChasquiSpecHelpers
     nnredis.keys('*').each { |k| nnredis.del k }
   end
 
+  def new_subscriber(class_name, options={})
+    queue = options.fetch :queue
+    channel = options.fetch :channel
+
+    @subscriber_registry ||= {}
+
+    if @subscriber_registry[class_name] && options[:force]
+      Object.send :remove_const, class_name
+      @subscriber_registry[class_name] = nil
+    end
+
+    @subscriber_registry[class_name] ||= Class.new
+    
+    @subscriber_registry[class_name].tap do |sub|
+      sub.send :include, Chasqui::Subscriber
+      sub.subscribe channel: channel, queue: queue
+    end
+  end
 end