zmqp 0.0.1

data/.gitignore

@@ -0,0 +1,24 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+log
+.idea
+.bundle
+
+## PROJECT::SPECIFIC

data/HISTORY

@@ -0,0 +1,7 @@
+== 0.0.0 / 2010-11-12
+
+* Birthday!
+
+== 0.0.1 / 2010-11-12
+
+* README and initial setup

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Arvicco
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,76 @@
+by: Arvicco
+url: http://github.com/arvicco/zmqp
+
+Description
+===========
+
+[Asynchronous AMQP library](http://github.com/tmm1/amqp) sets a standard for messaging.
+It is well documented and has clean and simple interfaces for most common messaging tasks.
+However, it implements AMQP standard that has some serious
+[problems and limitation](http://www.imatix.com/articles:whats-wrong-with-amqp).
+
+[ZeroMQ](http://www.zeromq.org) offers a viable alternative to AMQP, as well as 3-10 times
+performance boost for most common messaging tasks. However, its interfaces are a very similar
+to socket programming and look a bit frightening for uninitiated.
+
+This library wraps ZeroMQ/ZMQMachine with interfaces that are very similar to the ones
+offered by [tmm1/amqp](http://github.com/tmm1/amqp). That way, you'll be able to leverage
+your existing code developed for AMQP, getting additional benefits such as:
+
+ * Performance boost (3-10 times for most common messaging tasks)
+ * No broker-related bottleneck for high-throughput applications
+ * Ability to flexibly extend your messaging architecture
+ * No external dependency on 3rd-party broker software (such as RabbitMQ)
+
+Because ZMQis inherently threaded, it does not make sense to use this library with
+anything less than MRI 1.9.2, JRuby or Rubinius. MRI 1.9.1 may or may not work, MRI 1.8.7
+and its below are broken beyond repair (as far as threading goes).
+
+!!! Currently this library is at pre-alpha stage. Please do not use it for anything serious.
+
+Getting started
+===============
+
+First things first, start with:
+
+  $ gem install zmqp
+
+Documentation
+=============
+
+To be added...
+
+Credits
+=======
+
+(c) 2010 [Arvicco](http://github.com/arvicco)
+
+This project was inspired by [tmm1/amqp](http://github.com/tmm1/amqp).
+It is based on [ZMQMachine](http://github.com/chuckremes/zmqmachine).
+Special thanks to Aman Gupta and Chuck Remes.
+
+Resources
+=========
+
+ * [ZeroMQ](http://www.zeromq.org) (iMatix/FastMQ/Intel, C++, GPL3)
+
+ * [Ruby bindings to ZeroMQ](http://github.com/chuckremes/ffi-rzmq)
+
+ * [Learn ZeroMQ by Example](http://github.com/andrewvc/learn-ruby-zeromq)
+
+ * Analysis of AMQP [problems](http://www.imatix.com/articles:whats-wrong-with-amqp)
+
+ * ZeroMQ's [analysis of the messaging technology market](http://www.zeromq.org/whitepapers:market-analysis)
+
+ * [A Critique of the Remote Procedure Call Paradigm](http://www.cs.vu.nl/~ast/publications/euteco-1988.pdf)
+
+ * [A Note on Distributed Computing](http://research.sun.com/techrep/1994/smli_tr-94-29.pdf)
+
+ * [Convenience Over Correctness](http://steve.vinoski.net/pdf/IEEE-Convenience_Over_Correctness.pdf)
+
+ * [Metaprotocol Taxonomy and Communications Patterns](http://hessian.caucho.com/doc/metaprotocol-taxonomy.xtp)
+
+ * Joe Armstrong on [Erlang messaging vs RPC](http://armstrongonsoftware.blogspot.com/2008/05/road-we-didnt-go-down.html)
+
+== LICENSE:
+Copyright (c) 2010 Arvicco. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'pathname'
+BASE_PATH = Pathname.new(__FILE__).dirname
+LIB_PATH =  BASE_PATH + 'lib'
+PKG_PATH =  BASE_PATH + 'pkg'
+DOC_PATH =  BASE_PATH + 'rdoc'
+
+$LOAD_PATH.unshift LIB_PATH.to_s
+
+require 'version'
+require 'rake'
+
+NAME = 'zmqp'
+CLASS_NAME = ZMQP
+VERSION = CLASS_NAME::VERSION
+
+# Load rakefile tasks
+Dir['tasks/*.rake'].sort.each { |file| load file }
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/zmqp

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require Pathname.new(__FILE__).dirname + '../lib/zmqp'
+
+# Put your code here
+

data/features/support/env.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+
+require 'pathname'
+require 'bundler'
+Bundler.setup
+Bundler.require :cucumber
+
+require 'zmqp'
+
+BASE_PATH = Pathname.new(__FILE__).dirname + '../..'

data/features/support/world.rb

@@ -0,0 +1,12 @@
+module SystemHelper
+
+  def windows?
+    RUBY_PLATFORM =~ /mswin|windows|mingw/ || cygwin?
+  end
+
+  def cygwin?
+    RUBY_PLATFORM =~ /cygwin/
+  end
+end
+
+World(WinGui, SystemHelper)

data/features/zmqp.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/lib/version.rb

@@ -0,0 +1,8 @@
+require 'pathname'
+
+module ZMQP
+
+  VERSION_FILE = Pathname.new(__FILE__).dirname + '../VERSION'   # :nodoc:
+  VERSION = VERSION_FILE.exist? ? VERSION_FILE.read.strip : nil
+
+end

data/lib/zmqp.rb

@@ -0,0 +1,127 @@
+require 'version'
+
+module ZMQP
+
+  require "bundler/setup"
+  Bundler.require :default
+
+  # Requires ruby source file(s). Accepts either single filename/glob or Array of filenames/globs.
+  # Accepts following options:
+  # :*file*:: Lib(s) required relative to this file - defaults to __FILE__
+  # :*dir*:: Required lib(s) located under this dir name - defaults to gem name
+  #
+  def self.require_libs( libs, opts={} )
+    file = Pathname.new(opts[:file] || __FILE__)
+    [libs].flatten.each do |lib|
+      name = file.dirname + (opts[:dir] || file.basename('.*')) + lib.gsub(/(?<!.rb)$/, '.rb')
+      Pathname.glob(name.to_s).sort.each {|rb| require rb}
+    end
+  end
+end  # module ZMQP
+
+require 'zmqmachine'
+
+# Did I say that ZMQP is a drop-in substitution for AMQP?
+AMQP = ZMQP unless defined? AMQP
+EM = ZM unless defined? EM
+
+# Require all ruby source files located under directory lib/zmqp
+# If you need files in specific order, you should specify it here before the glob
+ZMQP.require_libs %W[**/*]
+
+
+module ZMQP
+  class << self
+    @logging = false
+    attr_accessor :logging
+    attr_reader :conn, :closing
+    alias :closing? :closing
+    alias :connection :conn
+  end
+
+  def self.connect *args
+    Client.connect *args
+  end
+
+  def self.settings
+    @settings ||= {
+      # broker address
+      :host => '127.0.0.1',
+      :port => PORT,
+
+      # login details
+      :user => 'guest',
+      :pass => 'guest',
+      :vhost => '/',
+
+      # connection timeout
+      :timeout => nil,
+
+      # logging
+      :logging => false,
+
+      # ssl
+      :ssl => false
+    }
+  end
+
+  # Must be called to startup the connection to lightweight service broker (was:the AMQP server).
+  #
+  # The method takes several arguments and an optional block.
+  #
+  # This takes any option that is also accepted by *??* ZMQMachine::connect.
+  # Additionally, there are several ZMQP-specific options.
+  #
+  # * :user => String (default 'guest')
+  # The username as defined by the AMQP server.
+  # * :pass => String (default 'guest')
+  # The password for the associated :user as defined by the AMQP server.
+  # * :vhost => String (default '/')
+  # The virtual host as defined by the AMQP server.
+  # * :timeout => Numeric (default nil)
+  # Measured in seconds.
+  # * :logging => true | false (default false)
+  # Toggle the extremely verbose logging of all protocol communications
+  # between the client and the server. Extremely useful for debugging.
+  #
+  #  AMQP.start do
+  #    # default is to connect to localhost:5672
+  #
+  #    # define queues, exchanges and bindings here.
+  #    # also define all subscriptions and/or publishers
+  #    # here.
+  #
+  #    # this block never exits unless EM.stop_event_loop
+  #    # is called.
+  #  end
+  #
+  # Most code will use the MQ api. Any calls to MQ.direct / MQ.fanout /
+  # MQ.topic / MQ.queue will implicitly call #start. In those cases,
+  # it is sufficient to put your code inside of an EventMachine.run
+  # block. See the code examples in MQ for details.
+  #
+  def self.start *args, &blk
+    EM.run{
+      @conn ||= connect *args
+      @conn.callback(&blk) if blk
+      @conn
+    }
+  end
+
+  class << self
+    alias :run :start
+  end
+
+  def self.stop
+    if @conn and not @closing
+      @closing = true
+      @conn.close{
+        yield if block_given?
+        @conn = nil
+        @closing = false
+      }
+    end
+  end
+
+end
+

data/lib/zmqp/client.rb

@@ -0,0 +1,17 @@
+module AMQP
+
+  # ZMQP Client impersonates AMQP Client/Connection.
+  # As such, it hides the difference between AMQP and ZMQ communication.
+  # This means that the Client should be encapsulating all the knowledge about
+  # ZMQ Sockets, socket handlers etc. It should probably do all the ZMQ "frame processing"
+  # inside, accepting only raw sum/pub/pop/etc from MQ and feeding it back raw
+  # data/exceptions
+  #
+  # Do we need Client at all? What is its role exactly?
+  # Maybe MQ instance alone is enough to hide Z/A difference, and actual communication
+  # will flow through "pseudo"-Exchanges and Queues anyway.
+  #
+  module Client
+
+  end
+end

data/lib/zmqp/spec.rb

@@ -0,0 +1,7 @@
+# This file contains all specifications and conventions
+# that allow ZMQP to impersonate AMQP
+
+module ZMQP
+  # PORT to be used by lightweight ZMQP broker (more like service registry, in fact)
+  PORT          = 5673 # 5672
+end

data/spec/amqp.yml

@@ -0,0 +1,28 @@
+# AMQP client configuration file
+
+# These values will be used to configure the ampq gem, any values
+# omitted will let the gem use it's own defaults.
+
+# The configuration specifies the following keys:
+# * user - Username for the broker
+# * pass - Password for the broker
+# * host     - Hostname where the broker is running
+# * vhost    - Vhost to connect to
+# * port     - Port where the broker is running
+# * ssl      - Use ssl or not
+# * timeout  - Timeout
+
+defaults: &defaults
+  user: guest
+  pass: guest
+  host: 10.211.55.2
+  vhost: /
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults

data/spec/mq_spec.rb

@@ -0,0 +1,436 @@
+require 'spec_helper'
+require 'amqp-spec/rspec'
+
+require 'mq'
+
+# Mocking AMQP::Client::EM_CONNECTION_CLASS in order to
+# specify MQ instance behavior without the need to start EM loop.
+class MockConnection
+
+  def initialize
+    EM.should_receive(:reactor_running?).and_return(true)
+  end
+
+  def callback &block
+    callbacks << block
+    block.call(self) if block
+  end
+
+  def add_channel mq
+    channels[key = (channels.keys.max || 0) + 1] = mq
+    key
+  end
+
+  def send data, opts = {}
+    messages << {data: data, opts: opts}
+  end
+
+  def connected?
+    true
+  end
+
+  def channels
+    @channels||={}
+  end
+
+  # Not part of AMQP::Client::EM_CONNECTION_CLASS interface, for mock introspection only
+  def callbacks
+    @callbacks||=[]
+  end
+
+  def messages
+    @messages||=[]
+  end
+
+  def close
+  end
+end
+
+describe 'MQ', 'as a class' do
+#  after{AMQP.cleanup_state} # Tips off Thread.current[:mq] call
+  subject { MQ }
+
+  its(:logging) { should be_false }
+
+  describe '.logging=' do
+    it 'is independent from AMQP.logging' do
+      #
+      AMQP.logging = true
+      MQ.logging.should be_false
+      MQ.logging = false
+      AMQP.logging.should == true
+
+      #
+      AMQP.logging = false
+      MQ.logging = true
+      AMQP.logging.should be_false
+      MQ.logging = false
+    end
+  end
+
+  describe '.default' do
+    it 'creates MQ object and stashes it in Thread-local Hash' do
+      MQ.should_receive(:new).with(no_args).and_return('MQ mock')
+      Thread.current.should_receive(:[]).with(:mq)
+      Thread.current.should_receive(:[]=).with(:mq, 'MQ mock')
+      MQ.default.should == 'MQ mock'
+    end
+  end
+
+  describe '.id' do
+    it 'returns Thread-local uuid for mq' do
+      Thread.current.should_receive(:[]).with(:mq_id)
+      Thread.current.should_receive(:[]=).with(:mq_id, /.*-[0-9]{4,5}-[0-9]{10}/)
+      MQ.id.should =~ /.*-[0-9]{4,5}-[0-9]{10}/
+    end
+  end
+
+  describe '.error' do
+    it 'is noop unless @error_callback was previously set' do
+      MQ.instance_variable_get(:@error_callback).should be_nil
+      MQ.error("Whatever").should be_nil
+    end
+
+    it 'is setting @error_callback if block is given' do
+      MQ.error("Whatever") { |message| message.should == "Whatever"; @callback_fired = true }
+      MQ.instance_variable_get(:@error_callback).should_not be_nil
+      @callback_fired.should be_false
+    end
+
+    it 'is causes @error_callback to fire if it was set' do
+      MQ.error("Whatever")
+      @callback_fired.should be_true
+    end
+  end
+
+  describe '.method_missing' do
+    it 'routes all unrecognized methods to MQ.default' do
+      MQ.should_receive(:new).with(no_args).and_return(mock('schmock'))
+      MQ.default.should_receive(:abracadabra).with("Whatever")
+      MQ.abracadabra("Whatever")
+    end
+  end
+end
+
+describe 'MQ', 'object, also vaguely known as "channel"' do
+
+  context 'when initialized with a mock connection' do
+    before { @conn = MockConnection.new }
+    after { AMQP.cleanup_state }
+    subject { MQ.new(@conn).tap { |mq| mq.succeed } } # Indicates that channel is connected
+    # its(:connection) { should be_nil } - relies on subject.send(:connection), not working
+
+    it 'has public accessors' do
+      subject.channel.should == 1 # Essentially, channel number
+      subject.consumers.should be_a Hash
+      subject.consumers.should be_empty
+      subject.exchanges.should be_a Hash
+      subject.exchanges.should be_empty
+      subject.queues.should be_a Hash
+      subject.queues.should be_empty
+      subject.rpcs.should be_a Hash
+      subject.rpcs.should be_empty
+
+      #connection was declared as both private and public accessor for some reason... Why?
+      subject.connection.should == @conn
+      subject.conn.should == @conn
+    end
+
+    describe '#process_frame' do # The meat of mq operations
+      describe ' Frame::Header'
+      describe ' Frame::Body'
+      describe ' Frame::Method'
+      describe ' Protocol::Channel::OpenOk'
+      describe ' Protocol::Access::RequestOk'
+      describe ' Protocol::Basic::CancelOk'
+      describe ' Protocol::Queue::DeclareOk'
+      describe ' Protocol::Basic::GetOk'
+      describe ' Protocol::Basic::Deliver'
+      describe ' Protocol::Basic::GetEmpty'
+      describe ' Protocol::Channel::Close'
+      describe ' Protocol::Basic::ConsumeOk'
+
+      describe 'Protocol::Channel::CloseOk' do
+        it 'closes the channel down' do
+          @conn.channels.should_receive(:delete) { |key| key.should == 1; @conn.channels.clear }
+          subject.process_frame AMQP::Frame::Method.new(AMQP::Protocol::Channel::CloseOk.new)
+        end
+
+        it 'closes down connection if no other channels' do
+          @conn.should_receive(:close)
+          subject.process_frame AMQP::Frame::Method.new(AMQP::Protocol::Channel::CloseOk.new)
+        end
+      end
+    end
+
+    describe '#send' do
+      it 'sends given data through its connection' do
+        args = [mock('data1'), mock('data2'), mock('data3')]
+
+        subject.send *args
+
+        @conn.messages[-3..-1].map { |message| message[:data] }.should == args
+      end
+
+      it 'sets data`s ticket property if @ticket is set for MQ object' do
+        subject.instance_variable_set(:@ticket, ticket = 'mock ticket')
+        data = mock('data1')
+        data.should_receive(:ticket=).with(ticket)
+
+        subject.send data
+      end
+
+      it 'is Mutex-synchronized' do
+        mutex = subject.instance_variable_get(:@_send_mutex)
+        mutex.should_receive(:synchronize)
+        subject.send mock('data1')
+      end
+    end
+
+    describe '#reset' do
+      it 'resets and reinitializes the channel, clears and resets its queues/exchanges' do
+        subject.queue('test').should_receive(:reset)
+        subject.fanout('fanout').should_receive(:reset)
+        subject.should_receive(:initialize).with(@conn)
+
+        subject.reset
+        subject.queues.should be_empty
+        subject.exchanges.should be_empty
+        subject.consumers.should be_empty
+      end
+    end
+
+    describe '#prefetch' do
+      it 'sends Protocol::Basic::Qos, setting :prefetch_count for broker' do
+        subject.prefetch 13
+        @conn.messages.last[:data].should be_an AMQP::Protocol::Basic::Qos
+        @conn.messages.last[:data].instance_variable_get(:@prefetch_count).should == 13
+      end
+
+      it 'returns MQ object itself, allowing for method chains' do
+        subject.prefetch(1).should == subject
+      end
+    end
+
+    describe '#recover' do
+      it 'sends Protocol::Basic::Recover, asking broker to redeliver all unack`ed messages on this channel' do
+        subject.recover
+        @conn.messages.last[:data].should be_an AMQP::Protocol::Basic::Recover
+      end
+
+      it 'by default, requeue property is nil, so messages will be redelivered to the original recipient' do
+        subject.recover
+        @conn.messages.last[:data].instance_variable_get(:@requeue).should == nil
+      end
+
+      it 'you can set requeue to true, prompting broker to requeue the messages (to other subscribers, potentially)' do
+        subject.recover true
+        @conn.messages.last[:data].instance_variable_get(:@requeue).should == true
+      end
+
+      it 'returns MQ object itself, allowing for method chains' do
+        subject.recover.should == subject
+      end
+    end
+
+    describe '#close' do
+      it 'can be simplified, getting rid of @closing ivar? Just set callback sending Protocol::Channel::Close...'
+
+      it 'sends Protocol::Channel::Close through @connection' do
+        subject.close
+        @conn.messages.last[:data].should be_an AMQP::Protocol::Channel::Close
+      end
+
+      it 'does not actually delete the channel or close connection' do
+        @conn.channels.should_not_receive(:delete)
+        @conn.should_not_receive(:close)
+        subject.close
+      end
+
+      it 'actual channel closing happens ONLY when Protocol::Channel::CloseOk is received' do
+        @conn.channels.should_receive(:delete) { |key| key.should == 1; @conn.channels.clear }
+        @conn.should_receive(:close)
+        subject.process_frame AMQP::Frame::Method.new(AMQP::Protocol::Channel::CloseOk.new)
+      end
+    end
+
+    describe '#get_queue' do
+      it 'yields a FIFO queue to a given block' do
+        subject.get_queue do |fifo|
+          fifo.should == []
+        end
+      end
+
+      it 'FIFO queue contains consumers that called Queue#pop' do
+        queue = subject.queue('test')
+        queue.pop
+        queue.pop
+        subject.get_queue do |fifo|
+          fifo.should have(2).consumers
+          fifo.each { |consumer| consumer.should == queue }
+        end
+      end
+
+      it 'is Mutex-synchronized' do
+        subject # Evaluates subject, tripping add_channel Mutex at initialize
+        mutex = Mutex.new
+        Mutex.should_receive(:new).and_return(mutex)
+        mutex.should_receive(:synchronize)
+        subject.get_queue {}
+      end
+    end
+
+    describe '#connected?' do # This is an addition to standard MQ interface
+      it 'delegates to @connection to determine its connectivity status' do
+        @conn.should_receive(:connected?).with(no_args)
+        subject.connected?
+      end
+    end
+
+    describe 'setting up exchanges/queues/rpcs' do
+      describe '#rpc' do
+        it 'creates new rpc and saves it into @rpcs Hash' do
+          MQ::RPC.should_receive(:new).with(subject, 'name', nil).and_return('mock_rpc')
+          subject.rpcs.should_receive(:[]=).with('name', 'mock_rpc')
+          rpc = subject.rpc 'name'
+          rpc.should == 'mock_rpc'
+        end
+
+        it 'raises error rpc if no name given' do
+          expect { subject.rpc }.to raise_error ArgumentError
+        end
+
+        it 'does not replace rpc with existing name' do
+          MQ::RPC.should_receive(:new).with(subject, 'name', nil).and_return('mock_rpc')
+          subject.rpc 'name'
+          MQ::RPC.should_not_receive(:new)
+          subject.rpcs.should_not_receive(:[]=)
+          rpc = subject.rpc 'name'
+          rpc.should == 'mock_rpc'
+        end
+      end
+
+      describe '#queue' do
+        it 'creates new Queue and saves it into @queues Hash' do
+          MQ::Queue.should_receive(:new).with(subject, 'name', {}).and_return('mock_queue')
+          subject.queues.should_receive(:[]=).with('name', 'mock_queue')
+          queue = subject.queue 'name'
+          queue.should == 'mock_queue'
+        end
+
+        it 'raises error Queue if no name given' do
+          expect { subject.queue }.to raise_error ArgumentError
+        end
+
+        it 'does not replace queue with existing name' do
+          MQ::Queue.should_receive(:new).with(subject, 'name', {}).and_return('mock_queue')
+          subject.queue 'name'
+          MQ::Queue.should_not_receive(:new)
+          subject.queues.should_not_receive(:[]=)
+          queue = subject.queue 'name'
+          queue.should == 'mock_queue'
+        end
+      end
+
+      describe '#direct' do
+        it 'creates new :direct Exchange and saves it into @exchanges Hash' do
+          MQ::Exchange.should_receive(:new).with(subject, :direct, 'name', {}).and_return('mock_exchange')
+          subject.exchanges.should_receive(:[]=).with('name', 'mock_exchange')
+          exchange = subject.direct 'name'
+          exchange.should == 'mock_exchange'
+        end
+
+        it 'creates "amq.direct" Exchange if no name given' do
+          MQ::Exchange.should_receive(:new).with(subject, :direct, 'amq.direct', {}).and_return('mock_exchange')
+          subject.exchanges.should_receive(:[]=).with('amq.direct', 'mock_exchange')
+          exchange = subject.direct
+          exchange.should == 'mock_exchange'
+        end
+
+        it 'does not replace exchange with existing name' do
+          MQ::Exchange.should_receive(:new).with(subject, :direct, 'name', {}).and_return('mock_exchange')
+          subject.direct 'name'
+          MQ::Exchange.should_not_receive(:new)
+          subject.exchanges.should_not_receive(:[]=)
+          exchange = subject.direct 'name'
+          exchange.should == 'mock_exchange'
+        end
+      end
+
+      describe '#fanout' do
+        it 'creates new :fanout Exchange and saves it into @exchanges Hash' do
+          MQ::Exchange.should_receive(:new).with(subject, :fanout, 'name', {}).and_return('mock_exchange')
+          subject.exchanges.should_receive(:[]=).with('name', 'mock_exchange')
+          exchange = subject.fanout 'name'
+          exchange.should == 'mock_exchange'
+        end
+
+        it 'creates "amq.fanout" Exchange if no name given' do
+          MQ::Exchange.should_receive(:new).with(subject, :fanout, 'amq.fanout', {}).and_return('mock_exchange')
+          subject.exchanges.should_receive(:[]=).with('amq.fanout', 'mock_exchange')
+          exchange = subject.fanout
+          exchange.should == 'mock_exchange'
+        end
+
+        it 'does not replace exchange with existing name' do
+          MQ::Exchange.should_receive(:new).with(subject, :fanout, 'name', {}).and_return('mock_exchange')
+          subject.fanout 'name'
+          MQ::Exchange.should_not_receive(:new)
+          subject.exchanges.should_not_receive(:[]=)
+          exchange = subject.fanout 'name'
+          exchange.should == 'mock_exchange'
+        end
+      end
+
+      describe '#topic' do
+        it 'creates new :topic Exchange and saves it into @exchanges Hash' do
+          MQ::Exchange.should_receive(:new).with(subject, :topic, 'name', {}).and_return('mock_exchange')
+          subject.exchanges.should_receive(:[]=).with('name', 'mock_exchange')
+          exchange = subject.topic 'name'
+          exchange.should == 'mock_exchange'
+        end
+
+        it 'creates "amq.topic" Exchange if no name given' do
+          MQ::Exchange.should_receive(:new).with(subject, :topic, 'amq.topic', {}).and_return('mock_exchange')
+          subject.exchanges.should_receive(:[]=).with('amq.topic', 'mock_exchange')
+          exchange = subject.topic
+          exchange.should == 'mock_exchange'
+        end
+
+        it 'does not replace exchange with existing name' do
+          MQ::Exchange.should_receive(:new).with(subject, :topic, 'name', {}).and_return('mock_exchange')
+          subject.topic 'name'
+          MQ::Exchange.should_not_receive(:new)
+          subject.exchanges.should_not_receive(:[]=)
+          exchange = subject.topic 'name'
+          exchange.should == 'mock_exchange'
+        end
+      end
+
+      describe '#headers' do
+        it 'creates new :headers Exchange and saves it into @exchanges Hash' do
+          MQ::Exchange.should_receive(:new).with(subject, :headers, 'name', {}).and_return('mock_exchange')
+          subject.exchanges.should_receive(:[]=).with('name', 'mock_exchange')
+          exchange = subject.headers 'name'
+          exchange.should == 'mock_exchange'
+        end
+
+        it 'creates "amq.match" Exchange if no name given' do
+          MQ::Exchange.should_receive(:new).with(subject, :headers, 'amq.match', {}).and_return('mock_exchange')
+          subject.exchanges.should_receive(:[]=).with('amq.match', 'mock_exchange')
+          exchange = subject.headers
+          exchange.should == 'mock_exchange'
+        end
+
+        it 'does not replace exchange with existing name' do
+          MQ::Exchange.should_receive(:new).with(subject, :headers, 'name', {}).and_return('mock_exchange')
+          subject.headers 'name'
+          MQ::Exchange.should_not_receive(:new)
+          subject.exchanges.should_not_receive(:[]=)
+          exchange = subject.headers 'name'
+          exchange.should == 'mock_exchange'
+        end
+      end
+    end
+  end
+end