kicks 3.0.0.pre

data/spec/sneakers/configuration_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Sneakers::Configuration do
+
+  describe 'with a connection' do
+    let(:connection) { Object.new }
+
+    it 'does not use vhost option if it is specified' do
+      url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      with_env('RABBITMQ_URL', url) do
+        config = Sneakers::Configuration.new
+        config.merge!({ :vhost => 'test_host', :connection => connection })
+        _(config.has_key?(:vhost)).must_equal false
+      end
+    end
+
+    it 'does not amqp option if it is specified' do
+      url = 'amqp://foo:bar@localhost:5672'
+      config = Sneakers::Configuration.new
+      config.merge!({ :amqp => url, :connection => connection })
+      _(config.has_key?(:vhost)).must_equal false
+    end
+  end
+
+  describe 'without a connection' do
+    it 'should assign a default value for :amqp' do
+      with_env('RABBITMQ_URL', nil) do
+        config = Sneakers::Configuration.new
+        _(config[:amqp]).must_equal 'amqp://guest:guest@localhost:5672'
+      end
+    end
+
+    it 'should assign a default value for :vhost' do
+      with_env('RABBITMQ_URL', nil) do
+        config = Sneakers::Configuration.new
+        _(config[:vhost]).must_equal '/'
+      end
+    end
+
+    it 'should read the value for amqp from RABBITMQ_URL' do
+      url = 'amqp://foo:bar@localhost:5672'
+      with_env('RABBITMQ_URL', url) do
+        config = Sneakers::Configuration.new
+        _(config[:amqp]).must_equal url
+      end
+    end
+
+    it 'should read the value for vhost from RABBITMQ_URL' do
+      url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      with_env('RABBITMQ_URL', url) do
+        config = Sneakers::Configuration.new
+        _(config[:vhost]).must_equal 'foobarvhost'
+      end
+    end
+
+    it 'should parse vhost from amqp option' do
+      env_url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      with_env('RABBITMQ_URL', env_url) do
+        url = 'amqp://foo:bar@localhost:5672/testvhost'
+        config = Sneakers::Configuration.new
+        config.merge!({ :amqp => url })
+        _(config[:vhost]).must_equal 'testvhost'
+      end
+    end
+
+    it 'should not parse vhost from amqp option if vhost is specified explicitly' do
+      url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      config = Sneakers::Configuration.new
+      config.merge!({ :amqp => url, :vhost => 'test_host' })
+      _(config[:vhost]).must_equal 'test_host'
+    end
+
+    it 'should use vhost option if it is specified' do
+      url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      with_env('RABBITMQ_URL', url) do
+        config = Sneakers::Configuration.new
+        config.merge!({ :vhost => 'test_host' })
+        _(config[:vhost]).must_equal 'test_host'
+      end
+    end
+
+    it 'should use default vhost if vhost is not specified in amqp option' do
+      url = 'amqp://foo:bar@localhost:5672'
+      config = Sneakers::Configuration.new
+      config.merge!({ :amqp => url })
+      _(config[:vhost]).must_equal '/'
+    end
+  end
+
+  def with_env(key, value)
+    old_value = ENV[key]
+    ENV[key] = value
+    yield
+  ensure
+    ENV[key] = old_value
+  end
+end

data/spec/sneakers/content_encoding_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'gzip_helper'
+require 'sneakers/content_encoding'
+
+describe Sneakers::ContentEncoding do
+  after do
+    Sneakers::ContentEncoding.reset!
+  end
+
+  describe '.decode' do
+    it 'uses the given decoder' do
+      Sneakers::ContentEncoding.register(
+        content_encoding: 'gzip',
+        encoder: ->(_) {},
+        decoder: ->(payload) { gzip_decompress(payload) },
+      )
+
+      _(Sneakers::ContentEncoding.decode(gzip_compress('foobar'), 'gzip')).must_equal('foobar')
+    end
+  end
+
+  describe '.encode' do
+    it 'uses the given encoder' do
+      Sneakers::ContentEncoding.register(
+        content_encoding: 'gzip',
+        encoder: ->(payload) { gzip_compress(payload) },
+        decoder: ->(_) {},
+      )
+
+      _(gzip_decompress(Sneakers::ContentEncoding.encode('foobar', 'gzip'))).must_equal('foobar')
+    end
+
+    it 'passes the payload through by default' do
+      payload = "just some text"
+      _(Sneakers::ContentEncoding.encode(payload, 'unknown/encoding')).must_equal(payload)
+      _(Sneakers::ContentEncoding.decode(payload, 'unknown/encoding')).must_equal(payload)
+      _(Sneakers::ContentEncoding.encode(payload, nil)).must_equal(payload)
+      _(Sneakers::ContentEncoding.decode(payload, nil)).must_equal(payload)
+    end
+
+    it 'passes the payload through if type not found' do
+      Sneakers::ContentEncoding.register(content_encoding: 'found/encoding', encoder: ->(_) {}, decoder: ->(_) {})
+      payload = "just some text"
+
+      _(Sneakers::ContentEncoding.encode(payload, 'unknown/encoding')).must_equal(payload)
+      _(Sneakers::ContentEncoding.decode(payload, 'unknown/encoding')).must_equal(payload)
+    end
+  end
+
+  describe '.register' do
+    it 'provides a mechnism to register a given encoding' do
+      Sneakers::ContentEncoding.register(
+        content_encoding: 'gzip',
+        encoder: ->(payload) { gzip_compress(payload) },
+        decoder: ->(payload) { gzip_decompress(payload) },
+      )
+
+      ce = Sneakers::ContentEncoding
+      _(ce.decode(ce.encode('hello world', 'gzip'), 'gzip')).must_equal('hello world')
+    end
+
+    it 'requires a content encoding' do
+      _(proc { Sneakers::ContentEncoding.register(encoder: -> { }, decoder: -> { }) }).must_raise ArgumentError
+    end
+
+    it 'expects encoder and decoder to be present' do
+      _(proc { Sneakers::ContentEncoding.register(content_encoding: 'foo', decoder: -> { }) }).must_raise ArgumentError
+      _(proc { Sneakers::ContentEncoding.register(content_encoding: 'foo', encoder: -> { }) }).must_raise ArgumentError
+    end
+
+    it 'expects encoder and decoder to be a proc' do
+      _(proc { Sneakers::ContentEncoding.register(content_encoding: 'foo', encoder: 'not a proc', decoder: ->(_) { }) }).must_raise ArgumentError
+      _(proc { Sneakers::ContentEncoding.register(content_encoding: 'foo', encoder: ->(_) {}, decoder: 'not a proc' ) }).must_raise ArgumentError
+    end
+
+    it 'expects encoder and deseridecoderalizer to have the correct arity' do
+      _(proc { Sneakers::ContentEncoding.register(content_encoding: 'foo', encoder: ->(_,_) {}, decoder: ->(_) {}) }).must_raise ArgumentError
+      _(proc { Sneakers::ContentEncoding.register(content_encoding: 'foo', encoder: ->(_) {}, decoder: ->() {} ) }).must_raise ArgumentError
+    end
+  end
+end

data/spec/sneakers/content_type_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'sneakers/content_type'
+require 'base64'
+
+describe Sneakers::ContentType do
+  after do
+    Sneakers::ContentType.reset!
+  end
+
+  describe '.deserialize' do
+    it 'uses the given deserializer' do
+      Sneakers::ContentType.register(
+        content_type: 'application/json',
+        serializer: ->(_) {},
+        deserializer: ->(payload) { JSON.parse(payload) },
+      )
+
+      _(Sneakers::ContentType.deserialize('{"foo":"bar"}', 'application/json')).must_equal('foo' => 'bar')
+    end
+  end
+
+  describe '.serialize' do
+     it 'uses the given serializer' do
+      Sneakers::ContentType.register(
+        content_type: 'application/json',
+        serializer: ->(payload) { JSON.dump(payload) },
+        deserializer: ->(_) {},
+      )
+
+      _(Sneakers::ContentType.serialize({ 'foo' => 'bar' }, 'application/json')).must_equal('{"foo":"bar"}')
+    end
+
+    it 'passes the payload through by default' do
+      payload = "just some text"
+      _(Sneakers::ContentType.serialize(payload, 'unknown/type')).must_equal(payload)
+      _(Sneakers::ContentType.deserialize(payload, 'unknown/type')).must_equal(payload)
+      _(Sneakers::ContentType.serialize(payload, nil)).must_equal(payload)
+      _(Sneakers::ContentType.deserialize(payload, nil)).must_equal(payload)
+    end
+
+    it 'passes the payload through if type not found' do
+      Sneakers::ContentType.register(content_type: 'found/type', serializer: ->(_) {}, deserializer: ->(_) {})
+      payload = "just some text"
+
+      _(Sneakers::ContentType.serialize(payload, 'unknown/type')).must_equal(payload)
+      _(Sneakers::ContentType.deserialize(payload, 'unknown/type')).must_equal(payload)
+    end
+  end
+
+  describe '.register' do
+    it 'provides a mechnism to register a given type' do
+      Sneakers::ContentType.register(
+        content_type: 'text/base64',
+        serializer: ->(payload) { Base64.encode64(payload) },
+        deserializer: ->(payload) { Base64.decode64(payload) },
+      )
+
+      ct = Sneakers::ContentType
+      _(ct.deserialize(ct.serialize('hello world', 'text/base64'), 'text/base64')).must_equal('hello world')
+    end
+
+    it 'requires a content type' do
+      _(proc { Sneakers::ContentType.register(serializer: -> { }, deserializer: -> { }) }).must_raise ArgumentError
+    end
+
+    it 'expects serializer and deserializer to be present' do
+      _(proc { Sneakers::ContentType.register(content_type: 'foo', deserializer: -> { }) }).must_raise ArgumentError
+      _(proc { Sneakers::ContentType.register(content_type: 'foo', serializer: -> { }) }).must_raise ArgumentError
+    end
+
+    it 'expects serializer and deserializer to be a proc' do
+      _(proc { Sneakers::ContentType.register(content_type: 'foo', serializer: 'not a proc', deserializer: ->(_) { }) }).must_raise ArgumentError
+      _(proc { Sneakers::ContentType.register(content_type: 'foo', serializer: ->(_) {}, deserializer: 'not a proc' ) }).must_raise ArgumentError
+    end
+
+    it 'expects serializer and deserializer to have the correct arity' do
+      _(proc { Sneakers::ContentType.register(content_type: 'foo', serializer: ->(_,_) {}, deserializer: ->(_) {}) }).must_raise ArgumentError
+      _(proc { Sneakers::ContentType.register(content_type: 'foo', serializer: ->(_) {}, deserializer: ->() {} ) }).must_raise ArgumentError
+    end
+  end
+end

data/spec/sneakers/integration_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'sneakers'
+require 'sneakers/runner'
+require 'fixtures/integration_worker'
+
+require "rabbitmq/http/client"
+require 'timeout'
+
+
+describe "integration" do
+  describe 'first' do
+    before :each do
+      skip unless ENV['INTEGRATION']
+      prepare
+    end
+
+    def integration_log(msg)
+      puts msg if ENV['INTEGRATION_LOG']
+    end
+
+    def rmq_addr
+      @rmq_addr ||= compose_or_localhost("rabbitmq")
+    end
+
+    def admin
+      @admin ||=
+        begin
+          puts "RABBITMQ is at #{rmq_addr}"
+          RabbitMQ::HTTP::Client.new("http://#{rmq_addr}:15672/", username: "guest", password: "guest")
+        rescue
+          fail "Rabbitmq admin seems to not exist? you better be running this on Travis or Docker. proceeding.\n#{$!}"
+        end
+    end
+
+    def prepare
+      # clean up all integration queues; admin interface must be installed
+      # in integration env
+      qs = admin.list_queues
+      qs.each do |q|
+        name = q.name
+        if name.start_with? 'integration_'
+          admin.delete_queue('/', name)
+          integration_log "cleaning up #{name}."
+        end
+      end
+
+      Sneakers.clear!
+      Sneakers.configure(:amqp => "amqp://guest:guest@#{rmq_addr}:5672")
+      Sneakers.logger.level = Logger::ERROR
+
+      # configure integration worker on a random generated queue
+      random_queue = "integration_#{rand(10**36).to_s(36)}"
+
+      redis_addr = compose_or_localhost("redis")
+      @redis = Redis.new(:host => redis_addr)
+      @redis.del(random_queue)
+      IntegrationWorker.from_queue(random_queue)
+    end
+
+    def assert_all_accounted_for(opts)
+      integration_log 'waiting for publishes to stabilize (5s).'
+      sleep 5
+
+      integration_log "polling for changes (max #{opts[:within_sec]}s)."
+      pid = opts[:pid]
+      opts[:within_sec].times do
+        sleep 1
+        count = @redis.get(opts[:queue]).to_i
+        if count == opts[:jobs]
+          integration_log "#{count} jobs accounted for successfully."
+          Process.kill("TERM", pid)
+          sleep 1
+          return
+        end
+      end
+
+      integration_log "failed test. killing off workers."
+      Process.kill("TERM", pid)
+      sleep 1
+      fail "incomplete!"
+    end
+
+    def start_worker(w)
+      integration_log "starting workers."
+      r = Sneakers::Runner.new([w])
+      pid = fork {
+         r.run
+      }
+
+      integration_log "waiting for workers to stabilize (5s)."
+      sleep 5
+
+      pid
+    end
+
+    def consumers_count
+      qs = admin.list_queues
+      qs.each do |q|
+        if q.name.start_with? 'integration_'
+          return [q.consumers, q.name]
+        end
+      end
+      return [0, nil]
+    end
+
+    def assert_any_consumers(consumers_should_be_there, maximum_wait_time = 15)
+      Timeout::timeout(maximum_wait_time) do
+        loop do
+          consumers, queue = consumers_count
+          fail 'no queues so no consumers' if consumers_should_be_there && !queue
+          puts "We see #{consumers} consumers on #{queue}"
+          (consumers_should_be_there == consumers.zero?) ? sleep(1) : return
+        end
+      end
+    rescue Timeout::Error
+      fail "Consumers should #{'not' unless consumers_should_be_there} be here but #{consumers} consumers were after #{maximum_wait_time}s waiting."
+    end
+
+    it 'should be possible to terminate when queue is full' do
+      job_count = 40000
+
+      pid = start_worker(IntegrationWorker)
+      Process.kill("TERM", pid)
+
+      integration_log "publishing #{job_count} messages..."
+      p = Sneakers::Publisher.new
+      job_count.times do |i|
+        p.publish("m #{i}", to_queue: IntegrationWorker.queue_name)
+      end
+
+      pid = start_worker(IntegrationWorker)
+      assert_any_consumers true
+      integration_log "Killing #{pid} now!"
+      Process.kill("TERM", pid)
+      assert_any_consumers false
+    end
+
+    it 'should pull down 100 jobs from a real queue' do
+      job_count = 100
+
+      pid = start_worker(IntegrationWorker)
+
+      integration_log "publishing..."
+      p = Sneakers::Publisher.new
+      job_count.times do |i|
+        p.publish("m #{i}", to_queue: IntegrationWorker.queue_name)
+      end
+
+      assert_all_accounted_for(
+         queue: IntegrationWorker.queue_name,
+         pid: pid,
+         within_sec: 15,
+         jobs: job_count,
+      )
+    end
+
+  end
+end

data/spec/sneakers/publisher_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'gzip_helper'
+require 'sneakers'
+require 'serverengine'
+
+describe Sneakers::Publisher do
+  let :pub_vars do
+    {
+      :prefetch => 25,
+      :durable => true,
+      :ack => true,
+      :heartbeat => 2,
+      :vhost => '/',
+      :exchange => "sneakers",
+      :exchange_type => :direct,
+      :exchange_arguments => { 'x-arg' => 'value' }
+    }
+  end
+
+  describe '#publish' do
+    before do
+      Sneakers.clear!
+      Sneakers.configure(:log => 'sneakers.log')
+    end
+
+    it 'should publish a message to an exchange' do
+      xchg = Object.new
+      mock(xchg).publish('test msg', { routing_key: 'downloads' })
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish('test msg', to_queue: 'downloads')
+    end
+
+    it 'should publish with the persistence specified' do
+      xchg = Object.new
+      mock(xchg).publish('test msg', { routing_key: 'downloads', persistence: true })
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish('test msg', to_queue: 'downloads', persistence: true)
+    end
+
+    it 'should publish with arbitrary metadata specified' do
+      xchg = Object.new
+      mock(xchg).publish('test msg', { routing_key: 'downloads', expiration: 1, headers: {foo: 'bar'} })
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish('test msg', to_queue: 'downloads', expiration: 1, headers: {foo: 'bar'})
+    end
+
+    it 'should not reconnect if already connected' do
+      xchg = Object.new
+      mock(xchg).publish('test msg', { routing_key: 'downloads' })
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).connected? { true }
+      mock(p).connect!.times(0)
+
+      p.publish('test msg', to_queue: 'downloads')
+    end
+
+    it 'should connect to rabbitmq configured on Sneakers.configure' do
+      logger = Logger.new('/dev/null')
+      Sneakers.configure(
+        amqp: 'amqp://someuser:somepassword@somehost:5672',
+        heartbeat: 1,
+        exchange: 'another_exchange',
+        exchange_options: { :type => :topic, :arguments => { 'x-arg' => 'value' } },
+        log: logger,
+        properties: { key: "value" },
+        durable: false)
+
+      channel = Object.new
+      mock(channel).exchange('another_exchange', type: :topic, durable: false, :auto_delete => false, arguments: { 'x-arg' => 'value' }) do
+        mock(Object.new).publish('test msg', { routing_key: 'downloads' })
+      end
+
+      bunny = Object.new
+      mock(bunny).start
+      mock(bunny).create_channel { channel }
+
+      mock(Bunny).new('amqp://someuser:somepassword@somehost:5672', heartbeat: 1, vhost: '/', logger: logger, properties: { key: "value" }) { bunny }
+
+      p = Sneakers::Publisher.new
+
+      p.publish('test msg', to_queue: 'downloads')
+    end
+
+    describe 'externally instantiated bunny session' do
+      let(:my_vars) { pub_vars.merge(to_queue: 'downloads') }
+      before do
+        logger = Logger.new('/dev/null')
+        channel = Object.new
+        exchange = Object.new
+        existing_session = Bunny.new
+
+        mock(existing_session).start
+        mock(existing_session).create_channel { channel }
+
+        mock(channel).exchange('another_exchange', type: :topic, durable: false, :auto_delete => false, arguments: { 'x-arg' => 'value' }) do
+          exchange
+        end
+
+        mock(exchange).publish('test msg', my_vars)
+
+        Sneakers.configure(
+          connection: existing_session,
+          heartbeat: 1, exchange: 'another_exchange',
+          exchange_type: :topic,
+          exchange_arguments: { 'x-arg' => 'value' },
+          log: logger,
+          durable: false
+        )
+        @existing_session = existing_session
+      end
+
+      it 'can handle an existing connection that is offline' do
+        p = Sneakers::Publisher.new
+        p.publish('test msg', my_vars)
+        _(p.instance_variable_get(:@bunny)).must_equal @existing_session
+      end
+
+      it 'can handle an existing connection that is online' do
+        mock(@existing_session).connected? { true }
+        p = Sneakers::Publisher.new
+        p.publish('test msg', my_vars)
+        _(p.instance_variable_get(:@bunny)).must_equal @existing_session
+      end
+    end
+
+    it 'should publish using the content type serializer' do
+      Sneakers::ContentType.register(
+        content_type: 'application/json',
+        serializer: ->(payload) { JSON.dump(payload) },
+        deserializer: ->(_) {},
+      )
+
+      xchg = Object.new
+      mock(xchg).publish('{"foo":"bar"}', { routing_key: 'downloads', content_type: 'application/json' })
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish({ 'foo' => 'bar' }, to_queue: 'downloads', content_type: 'application/json')
+
+      Sneakers::ContentType.reset!
+    end
+
+    it 'should publish using the content encoding encoder' do
+      Sneakers::ContentEncoding.register(
+        content_encoding: 'gzip',
+        encoder: ->(payload) { gzip_compress(payload) },
+        decoder: ->(_) {},
+      )
+
+      xchg = Object.new
+      mock(xchg).publish(gzip_compress('foobar'), { routing_key: 'downloads', content_encoding: 'gzip' })
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish('foobar', to_queue: 'downloads', content_encoding: 'gzip')
+
+      Sneakers::ContentEncoding.reset!
+    end
+  end
+end