amq-protocol 0.0.1.pre → 0.5.0

data/spec/amq/protocol/method_spec.rb

@@ -0,0 +1,40 @@
+# encoding: binary
+
+require File.expand_path('../../../spec_helper', __FILE__)
+
+
+module AMQ
+  module Protocol
+    describe Method do
+      describe '.split_headers' do
+        it 'splits user defined headers into properties and headers' do
+          input = {:delivery_mode => 2, :content_type => 'application/octet-stream', :foo => 'bar'}
+          properties, headers = Method.split_headers(input)
+          properties.should == {:delivery_mode => 2, :content_type => 'application/octet-stream'}
+          headers.should == {:foo => 'bar'}
+        end
+      end
+      
+      describe '.encode_body' do
+        context 'when the body fits in a single frame' do
+          it 'encodes a body into a BodyFrame' do
+            body_frames = Method.encode_body('Hello world', 1, 131072)
+            body_frames.first.payload.should == 'Hello world'
+            body_frames.first.channel.should == 1
+            body_frames.should have(1).item
+          end
+        end
+
+        context 'when the body is to big to fit in a single frame' do
+          it 'encodes a body into a list of BodyFrames that each fit within the frame size' do
+            lipsum = 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'
+            frame_size = 100
+            expected_payload_size = 93
+            body_frames = Method.encode_body(lipsum, 1, frame_size)
+            body_frames.map(&:payload).should == lipsum.split('').each_slice(expected_payload_size).map(&:join)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/amq/protocol/queue_spec.rb

@@ -0,0 +1,129 @@
+# encoding: binary
+
+require File.expand_path('../../../spec_helper', __FILE__)
+
+
+module AMQ
+  module Protocol
+    class Queue
+      describe Declare do
+        describe '.encode' do
+          it 'encodes the parameters into a MethodFrame' do
+            channel = 1
+            queue = 'hello.world'
+            passive = false
+            durable = true
+            exclusive = true
+            auto_delete = true
+            nowait = false
+            arguments = nil
+            method_frame = Declare.encode(channel, queue, passive, durable, exclusive, auto_delete, nowait, arguments)
+            method_frame.payload.should == "\x002\x00\n\x00\x00\vhello.world\x0E\x00\x00\x00\x00"
+            method_frame.channel.should == 1
+          end
+        end
+      end
+
+      describe DeclareOk do
+        describe '.decode' do
+          subject do
+            DeclareOk.decode(" amq.gen-KduGSqQrpeUo1otnU0TWSA==\x00\x00\x00\x00\x00\x00\x00\x00")
+          end
+          
+          its(:queue) { should == 'amq.gen-KduGSqQrpeUo1otnU0TWSA==' }
+          its(:message_count) { should == 0 }
+          its(:consumer_count) { should == 0 }
+        end
+      end
+
+      describe Bind do
+        describe '.encode' do
+          it 'encodes the parameters into a MethodFrame' do
+            channel = 1
+            queue = 'hello.world'
+            exchange = 'foo.bar'
+            routing_key = 'xyz'
+            nowait = false
+            arguments = nil
+            method_frame = Bind.encode(channel, queue, exchange, routing_key, nowait, arguments)
+            method_frame.payload.should == "\x002\x00\x14\x00\x00\vhello.world\afoo.bar\x03xyz\x00\x00\x00\x00\x00"
+            method_frame.channel.should == 1
+          end
+        end
+      end
+
+      # describe BindOk do
+      #   describe '.decode' do
+      #   end
+      # end
+
+      describe Purge do
+        describe '.encode' do
+          it 'encodes the parameters into a MethodFrame' do
+            channel = 1
+            queue = 'hello.world'
+            nowait = false
+            method_frame = Purge.encode(channel, queue, nowait)
+            method_frame.payload.should == "\x002\x00\x1E\x00\x00\vhello.world\x00"
+            method_frame.channel.should == 1
+          end
+        end
+      end
+
+      describe PurgeOk do
+        describe '.decode' do
+          subject do
+            PurgeOk.decode("\x00\x00\x00\x02")
+          end
+          
+          its(:message_count) { should == 2 }
+        end
+      end
+
+      describe Delete do
+        describe '.encode' do
+          it 'encodes the parameters into a MethodFrame' do
+            channel = 1
+            queue = 'hello.world'
+            if_unused = false
+            if_empty = false
+            nowait = false
+            method_frame = Delete.encode(channel, queue, if_unused, if_empty, nowait)
+            method_frame.payload.should == "\x002\x00(\x00\x00\vhello.world\x00"
+            method_frame.channel.should == 1
+          end
+        end
+      end
+
+      describe DeleteOk do
+        describe '.decode' do
+          subject do
+            DeleteOk.decode("\x00\x00\x00\x02")
+          end
+          
+          its(:message_count) { should == 2 }
+        end
+      end
+
+      describe Unbind do
+        describe '.encode' do
+          it 'encodes the parameters into a MethodFrame' do
+            channel = 1
+            queue = 'hello.world'
+            exchange = 'foo.bar'
+            routing_key = 'xyz'
+            arguments = nil
+            method_frame = Unbind.encode(channel, queue, exchange, routing_key, arguments)
+            method_frame.payload.should == "\x002\x002\x00\x00\vhello.world\afoo.bar\x03xyz\x00\x00\x00\x00"
+            method_frame.channel.should == 1
+          end
+        end
+      end
+
+      # describe UnbindOk do
+      #   describe '.decode' do
+      #   end
+      # end
+    end
+  end
+end

data/spec/amq/protocol/table_spec.rb

@@ -1,46 +1,69 @@
-# encoding: utf-8
+# encoding: binary
 
-require_relative "../../spec_helper.rb"
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
 
-describe AMQ::Protocol::Table do
-  DATA = {
-    Hash.new              => "\x00\x00\x00\x00",
-    {"test" => 1}         => "\x00\x00\x00\n\x04testI\x00\x00\x00\x01",
-    {"test" => "string"}  => "\x00\x00\x00\x10\x04testS\x00\x00\x00\x06string",
-    {"test" => Hash.new}  => "\x00\x00\x00\n\x04testF\x00\x00\x00\x00",
-  }
 
-  describe ".encode" do
-    it "should return \"\x00\x00\x00\x00\" for nil" do
-      Table.encode(nil).should eql("\x00\x00\x00\x00")
-    end
+module AMQ
+  module Protocol
+    describe Table do
+      timestamp    = Time.utc(2010, 12, 31, 23, 58, 59)
+      bigdecimal_1 = BigDecimal.new("1.0")
+      bigdecimal_2 = BigDecimal.new("5E-3")
+      bigdecimal_3 = BigDecimal.new("-0.01")
 
-    it "should return \"\x00\x00\x00\n\x04testI\x00\x00\x00\x01\" for {test: true}" do
-      Table.encode(test: true).should eql("\x00\x00\x00\n\x04testI\x00\x00\x00\x01")
-    end
 
-    DATA.each do |data, encoded|
-      it "should return #{encoded.inspect} for #{data.inspect}" do
-        Table.encode(data).should eql(encoded)
+      DATA = if one_point_eight?
+        {
+          {}                       => "\000\000\000\000",
+          {"test" => 1}            => "\000\000\000\n\004testI\000\000\000\001",
+          {"test" => "string"}     => "\000\000\000\020\004testS\000\000\000\006string",
+          {"test" => {}}           => "\000\000\000\n\004testF\000\000\000\000",
+          {"test" => bigdecimal_1} => "\000\000\000\v\004testD\000\000\000\000\001",
+          {"test" => bigdecimal_2} => "\000\000\000\v\004testD\003\000\000\000\005",
+          {"test" => timestamp}    => "\000\000\000\016\004testT\000\000\000\000M\036nC"
+        }
+      else
+        {
+          {}                       => "\x00\x00\x00\x00",
+          {"test" => 1}            => "\x00\x00\x00\n\x04testI\x00\x00\x00\x01",
+          {"test" => "string"}     => "\x00\x00\x00\x10\x04testS\x00\x00\x00\x06string",
+          {"test" => {}}           => "\x00\x00\x00\n\x04testF\x00\x00\x00\x00",
+          {"test" => bigdecimal_1} => "\x00\x00\x00\v\x04testD\x00\x00\x00\x00\x01",
+          {"test" => bigdecimal_2} => "\x00\x00\x00\v\x04testD\x03\x00\x00\x00\x05",
+          {"test" => timestamp}    => "\x00\x00\x00\x0e\x04testT\x00\x00\x00\x00M\x1enC"
+        }
+      end
+
+      describe ".encode" do
+        it "should return \"\x00\x00\x00\x00\" for nil" do
+          encoded_value = if one_point_eight?
+                            "\000\000\000\000"
+                          else
+                            "\x00\x00\x00\x00"
+                          end
+
+          Table.encode(nil).should eql(encoded_value)
+        end
+
+        it "should return \"\x00\x00\x00\n\x04testI\x00\x00\x00\x01\" for {test: true}" do
+          Table.encode(:test => true).should eql("\x00\x00\x00\n\x04testI\x00\x00\x00\x01")
+        end
+
+        DATA.each do |data, encoded|
+          it "should return #{encoded.inspect} for #{data.inspect}" do
+            Table.encode(data).should eql(encoded)
+          end
+        end
       end
-    end
-  end
 
-  describe ".decode" do
-    DATA.each do |data, encoded|
-      it "should return #{data.inspect} for #{encoded.inspect}" do
-        Table.decode(encoded).should eql(data)
+      describe ".decode" do
+        DATA.each do |data, encoded|
+          it "should return #{data.inspect} for #{encoded.inspect}" do
+            Table.decode(encoded).should eql(data)
+          end
+        end
       end
     end
   end
-end
-
-__END__
-# encode({"a":decimal.Decimal("1.0")})
-# "\x00\x00\x00\x07\x01aD\x00\x00\x00\x00\x01"
-#
-# encode({"a":decimal.Decimal("5E-3")})
-# "\x00\x00\x00\x07\x01aD\x03\x00\x00\x00\x05"
-#
-# encode({"a":datetime.datetime(2010,12,31,23,58,59)})
-# "\x00\x00\x00\x0b\x01aT\x00\x00\x00\x00M\x1enC"
+end

data/spec/amq/protocol/tx_spec.rb

@@ -0,0 +1,58 @@
+# encoding: binary
+
+require File.expand_path('../../../spec_helper', __FILE__)
+
+
+module AMQ
+  module Protocol
+    class Tx
+      describe Select do
+        describe '.encode' do
+          it 'encodes the parameters into a MethodFrame' do
+            channel = 1
+            method_frame = Select.encode(channel)
+            method_frame.payload.should == "\000Z\000\n"
+            method_frame.channel.should == 1
+          end
+        end
+      end
+
+      # describe SelectOk do
+      #   describe '.decode' do
+      #   end
+      # end
+
+      describe Commit do
+        describe '.encode' do
+          it 'encodes the parameters into a MethodFrame' do
+            channel = 1
+            method_frame = Commit.encode(channel)
+            method_frame.payload.should == "\000Z\000\024"
+            method_frame.channel.should == 1
+          end
+        end
+      end
+      
+      # describe CommitOk do
+      #   describe '.decode' do
+      #   end
+      # end
+
+      describe Rollback do
+        describe '.encode' do
+          it 'encodes the parameters into a MethodFrame' do
+            channel = 1
+            method_frame = Rollback.encode(channel)
+            method_frame.payload.should == "\000Z\000\036"
+            method_frame.channel.should == 1
+          end
+        end
+      end
+
+      # describe RollbackOk do
+      #   describe '.decode' do
+      #   end
+      # end
+    end
+  end
+end

data/spec/amq/protocol_spec.rb

@@ -1,888 +1,817 @@
-# encoding: utf-8
+# encoding: binary
 
-require_relative "../spec_helper.rb"
+require File.expand_path('../../spec_helper', __FILE__)
 
-describe AMQ::Protocol do
-  it "should have PROTOCOL_VERSION constant" do
-    AMQ::Protocol::PROTOCOL_VERSION.should match(/^\d+\.\d+\.\d$/)
-  end
-
-  it "should have DEFAULT_PORT constant" do
-    AMQ::Protocol::DEFAULT_PORT.should be_kind_of(Integer)
-  end
 
-  it "should have PREAMBLE constant" do
-    AMQ::Protocol::PREAMBLE.should be_kind_of(String)
-  end
-
-  describe ".classes" do
-    it "should include all the AMQP classes" do
-      AMQ::Protocol.classes.should include(Queue)
+module AMQ
+  describe Protocol do
+    it "should have PROTOCOL_VERSION constant" do
+      Protocol::PROTOCOL_VERSION.should match(/^\d+\.\d+\.\d$/)
     end
-  end
 
-  describe ".methods" do
-    it "should include all the AMQP methods" do
-      AMQ::Protocol.methods.should include(Queue::DeclareOk)
+    it "should have DEFAULT_PORT constant" do
+      Protocol::DEFAULT_PORT.should be_kind_of(Integer)
     end
-  end
 
-  describe AMQ::Protocol::Error do
-    it "should be an exception class" do
-      AMQ::Protocol::Error.should < Exception
+    it "should have PREAMBLE constant" do
+      Protocol::PREAMBLE.should be_kind_of(String)
     end
-  end
 
-  describe AMQ::Protocol::Connection do
-    it "should be a subclass of Class" do
-      Connection.should < Class
-    end
-
-    it "should have name equal to connection" do
-      Connection.name.should eql("connection")
-    end
-
-    it "should have method equal to TODO" do
-      pending
-      Connection.method.should eql("TODO")
-    end
-
-    describe AMQ::Protocol::Connection::Start do
-      it "should be a subclass of Method" do
-        Connection::Start.should < Method
+    describe Protocol::Error do
+      it "should be an exception class" do
+        Protocol::Error.should < Exception
       end
+    end
 
-      it "should have method name equal to connection.start" do
-        Connection::Start.name.should eql("connection.start")
+    describe Protocol::Connection do
+      it "should be a subclass of Class" do
+        Protocol::Connection.superclass.should == Protocol::Class
       end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::Start.method.should eql("TODO")
+      it "should have name equal to connection" do
+        Protocol::Connection.name.should eql("connection")
       end
-    end
 
-    describe AMQ::Protocol::Connection::StartOk do
-      it "should be a subclass of Method" do
-        Connection::StartOk.should < Method
+      it "should have method id equal to 10" do
+        Protocol::Connection.method_id.should == 10
       end
 
-      it "should have method name equal to connection.start-ok" do
-        Connection::StartOk.name.should eql("connection.start-ok")
-      end
+      describe Protocol::Connection::Start do
+        it "should be a subclass of Method" do
+          Protocol::Connection::Start.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::StartOk.method.should eql("TODO")
-      end
+        it "should have method name equal to connection.start" do
+          Protocol::Connection::Start.name.should eql("connection.start")
+        end
 
-      describe ".encode" do
-        it do
-          result = Connection::StartOk.encode({client: "AMQ Protocol"}, "PLAIN", "LOGINSguesPASSWORDSguest", "en_GB")
-          result.should eql("\x00\n\x00\v\x00\x00\x00\x18\x06clientS\x00\x00\x00\fAMQ Protocol\x05PLAIN\x00\x00\x00\x18LOGINSguesPASSWORDSguest\x05en_GB")
+        it "should have method id equal to 10" do
+          Protocol::Connection::Start.method_id.should == 10
         end
       end
-    end
 
-    describe AMQ::Protocol::Connection::Secure do
-      it "should be a subclass of Method" do
-        Connection::Secure.should < Method
-      end
+      describe Protocol::Connection::StartOk do
+        it "should be a subclass of Method" do
+          Protocol::Connection::StartOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to connection.secure" do
-        Connection::Secure.name.should eql("connection.secure")
-      end
+        it "should have method name equal to connection.start-ok" do
+          Protocol::Connection::StartOk.name.should eql("connection.start-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::Secure.method.should eql("TODO")
+        it "has method id equal to 11" do
+          Protocol::Connection::StartOk.method_id.should == 11
+        end
       end
-    end
 
-    describe AMQ::Protocol::Connection::SecureOk do
-      it "should be a subclass of Method" do
-        Connection::SecureOk.should < Method
-      end
+      describe Protocol::Connection::Secure do
+        it "should be a subclass of Method" do
+          Protocol::Connection::Secure.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to connection.secure-ok" do
-        Connection::SecureOk.name.should eql("connection.secure-ok")
-      end
+        it "should have method name equal to connection.secure" do
+          Protocol::Connection::Secure.name.should eql("connection.secure")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::SecureOk.method.should eql("TODO")
+        it "has method id equal to 20" do
+          Protocol::Connection::Secure.method_id.should == 20
+        end
       end
-    end
 
-    describe AMQ::Protocol::Connection::Tune do
-      it "should be a subclass of Method" do
-        Connection::Tune.should < Method
-      end
+      describe Protocol::Connection::SecureOk do
+        it "should be a subclass of Method" do
+          Protocol::Connection::SecureOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to connection.tune" do
-        Connection::Tune.name.should eql("connection.tune")
-      end
+        it "should have method name equal to connection.secure-ok" do
+          Protocol::Connection::SecureOk.name.should eql("connection.secure-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::Tune.method.should eql("TODO")
+        it "has method id equal to 21" do
+          Protocol::Connection::SecureOk.method_id.should == 21
+        end
       end
-    end
 
-    describe AMQ::Protocol::Connection::TuneOk do
-      it "should be a subclass of Method" do
-        Connection::TuneOk.should < Method
-      end
+      describe Protocol::Connection::Tune do
+        it "should be a subclass of Method" do
+          Protocol::Connection::Tune.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to connection.tune-ok" do
-        Connection::TuneOk.name.should eql("connection.tune-ok")
-      end
+        it "should have method name equal to connection.tune" do
+          Protocol::Connection::Tune.name.should eql("connection.tune")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::TuneOk.method.should eql("TODO")
+        it "has method id equal to 30" do
+          Protocol::Connection::Tune.method_id.should == 30
+        end
       end
 
-      describe ".encode" do
-        it do
-          result = Connection::TuneOk.encode(0, 131072, 0)
-          result.should eql("\x00\n\x00\x1F\x00\x00\x00\x02\x00\x00\x00\x00")
+      describe Protocol::Connection::TuneOk do
+        it "should be a subclass of Method" do
+          Protocol::Connection::TuneOk.superclass.should == Protocol::Method
         end
-      end
-    end
 
-    describe AMQ::Protocol::Connection::Open do
-      it "should be a subclass of Method" do
-        Connection::Open.should < Method
-      end
+        it "should have method name equal to connection.tune-ok" do
+          Protocol::Connection::TuneOk.name.should eql("connection.tune-ok")
+        end
 
-      it "should have method name equal to connection.open" do
-        Connection::Open.name.should eql("connection.open")
-      end
+        it "has method id equal to 31" do
+          Protocol::Connection::TuneOk.method_id.should == 31
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::Open.method.should eql("TODO")
+        describe ".encode" do
+          it do
+            frame = Protocol::Connection::TuneOk.encode(0, 131072, 0)
+            frame.payload.should eql("\x00\n\x00\x1F\x00\x00\x00\x02\x00\x00\x00\x00")
+          end
+        end
       end
-    end
 
-    describe AMQ::Protocol::Connection::OpenOk do
-      it "should be a subclass of Method" do
-        Connection::OpenOk.should < Method
-      end
+      describe Protocol::Connection::Open do
+        it "should be a subclass of Method" do
+          Protocol::Connection::Open.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to connection.open-ok" do
-        Connection::OpenOk.name.should eql("connection.open-ok")
-      end
+        it "should have method name equal to connection.open" do
+          Protocol::Connection::Open.name.should eql("connection.open")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::OpenOk.method.should eql("TODO")
+        it "has method id equal to 40" do
+          Protocol::Connection::Open.method_id.should == 40
+        end
       end
-    end
 
-    describe AMQ::Protocol::Connection::Close do
-      it "should be a subclass of Method" do
-        Connection::Close.should < Method
-      end
+      describe Protocol::Connection::OpenOk do
+        it "should be a subclass of Method" do
+          Protocol::Connection::OpenOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to connection.close" do
-        Connection::Close.name.should eql("connection.close")
-      end
+        it "should have method name equal to connection.open-ok" do
+          Protocol::Connection::OpenOk.name.should eql("connection.open-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::Close.method.should eql("TODO")
+        it "has method id equal to 41" do
+          Protocol::Connection::OpenOk.method_id.should == 41
+        end
       end
-    end
 
-    describe AMQ::Protocol::Connection::CloseOk do
-      it "should be a subclass of Method" do
-        Connection::CloseOk.should < Method
-      end
+      describe Protocol::Connection::Close do
+        it "should be a subclass of Method" do
+          Protocol::Connection::Close.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to connection.close-ok" do
-        Connection::CloseOk.name.should eql("connection.close-ok")
-      end
+        it "should have method name equal to connection.close" do
+          Protocol::Connection::Close.name.should eql("connection.close")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Connection::CloseOk.method.should eql("TODO")
+        it "has method id equal to 50" do
+          Protocol::Connection::Close.method_id.should == 50
+        end
       end
-    end
-  end
 
-  describe AMQ::Protocol::Channel do
-    it "should be a subclass of Class" do
-      Channel.should < Class
-    end
+      describe Protocol::Connection::CloseOk do
+        it "should be a subclass of Method" do
+          Protocol::Connection::CloseOk.superclass.should == Protocol::Method
+        end
 
-    it "should have name equal to channel" do
-      Channel.name.should eql("channel")
-    end
+        it "should have method name equal to connection.close-ok" do
+          Protocol::Connection::CloseOk.name.should eql("connection.close-ok")
+        end
 
-    it "should have method equal to TODO" do
-      pending
-      Channel.method.should eql("TODO")
+        it "has method id equal to 51" do
+          Protocol::Connection::CloseOk.method_id.should == 51
+        end
+      end
     end
 
-    describe AMQ::Protocol::Channel::Open do
-      it "should be a subclass of Method" do
-        Channel::Open.should < Method
+    describe Protocol::Channel do
+      it "should be a subclass of Class" do
+        Protocol::Channel.superclass.should == Protocol::Class
       end
 
-      it "should have method name equal to channel.open" do
-        Channel::Open.name.should eql("channel.open")
+      it "should have name equal to channel" do
+        Protocol::Channel.name.should eql("channel")
       end
 
-      it "should have method equal to TODO" do
-        pending
-        Channel::Open.method.should eql("TODO")
+      it "has method id equal to 20" do
+        Protocol::Channel.method_id.should == 20
       end
-    end
 
-    describe AMQ::Protocol::Channel::OpenOk do
-      it "should be a subclass of Method" do
-        Channel::OpenOk.should < Method
-      end
+      describe Protocol::Channel::Open do
+        it "should be a subclass of Method" do
+          Protocol::Channel::Open.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to channel.open-ok" do
-        Channel::OpenOk.name.should eql("channel.open-ok")
-      end
+        it "should have method name equal to channel.open" do
+          Protocol::Channel::Open.name.should eql("channel.open")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Channel::OpenOk.method.should eql("TODO")
+        it "has method id equal to 10" do
+          Protocol::Channel::Open.method_id.should == 10
+        end
       end
-    end
 
-    describe AMQ::Protocol::Channel::Flow do
-      it "should be a subclass of Method" do
-        Channel::Flow.should < Method
-      end
+      describe Protocol::Channel::OpenOk do
+        it "should be a subclass of Method" do
+          Protocol::Channel::OpenOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to channel.flow" do
-        Channel::Flow.name.should eql("channel.flow")
-      end
+        it "should have method name equal to channel.open-ok" do
+          Protocol::Channel::OpenOk.name.should eql("channel.open-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Channel::Flow.method.should eql("TODO")
+        it "has method id equal to 11" do
+          Protocol::Channel::OpenOk.method_id.should == 11
+        end
       end
-    end
 
-    describe AMQ::Protocol::Channel::FlowOk do
-      it "should be a subclass of Method" do
-        Channel::FlowOk.should < Method
-      end
+      describe Protocol::Channel::Flow do
+        it "should be a subclass of Method" do
+          Protocol::Channel::Flow.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to channel.flow-ok" do
-        Channel::FlowOk.name.should eql("channel.flow-ok")
-      end
+        it "should have method name equal to channel.flow" do
+          Protocol::Channel::Flow.name.should eql("channel.flow")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Channel::FlowOk.method.should eql("TODO")
+        it "has method id equal to 20" do
+          Protocol::Channel::Flow.method_id.should == 20
+        end
       end
-    end
 
-    describe AMQ::Protocol::Channel::Close do
-      it "should be a subclass of Method" do
-        Channel::Close.should < Method
-      end
+      describe Protocol::Channel::FlowOk do
+        it "should be a subclass of Method" do
+          Protocol::Channel::FlowOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to channel.close" do
-        Channel::Close.name.should eql("channel.close")
-      end
+        it "should have method name equal to channel.flow-ok" do
+          Protocol::Channel::FlowOk.name.should eql("channel.flow-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Channel::Close.method.should eql("TODO")
+        it "has method id equal to 21" do
+          Protocol::Channel::FlowOk.method_id.should == 21
+        end
       end
-    end
 
-    describe AMQ::Protocol::Channel::CloseOk do
-      it "should be a subclass of Method" do
-        Channel::CloseOk.should < Method
-      end
+      describe Protocol::Channel::Close do
+        it "should be a subclass of Method" do
+          Protocol::Channel::Close.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to channel.close-ok" do
-        Channel::CloseOk.name.should eql("channel.close-ok")
-      end
+        it "should have method name equal to channel.close" do
+          Protocol::Channel::Close.name.should eql("channel.close")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Channel::CloseOk.method.should eql("TODO")
+        it "has method id equal to 40" do
+          Protocol::Channel::Close.method_id.should == 40
+        end
       end
-    end
-  end
 
-  describe AMQ::Protocol::Exchange do
-    it "should be a subclass of Class" do
-      Exchange.should < Class
-    end
+      describe Protocol::Channel::CloseOk do
+        it "should be a subclass of Method" do
+          Protocol::Channel::CloseOk.superclass.should == Protocol::Method
+        end
 
-    it "should have name equal to exchange" do
-      Exchange.name.should eql("exchange")
-    end
+        it "should have method name equal to channel.close-ok" do
+          Protocol::Channel::CloseOk.name.should eql("channel.close-ok")
+        end
 
-    it "should have method equal to TODO" do
-      pending
-      Exchange.method.should eql("TODO")
+        it "has method id equal to 41" do
+          Protocol::Channel::CloseOk.method_id.should == 41
+        end
+      end
     end
 
-    describe AMQ::Protocol::Exchange::Declare do
-      it "should be a subclass of Method" do
-        Exchange::Declare.should < Method
+    describe Protocol::Exchange do
+      it "should be a subclass of Class" do
+        Protocol::Exchange.superclass.should == Protocol::Class
       end
 
-      it "should have method name equal to exchange.declare" do
-        Exchange::Declare.name.should eql("exchange.declare")
+      it "should have name equal to exchange" do
+        Protocol::Exchange.name.should eql("exchange")
       end
 
-      it "should have method equal to TODO" do
-        pending
-        Exchange::Declare.method.should eql("TODO")
+      it "has method id equal to 40" do
+        Protocol::Exchange.method_id.should == 40
       end
-    end
 
-    describe AMQ::Protocol::Exchange::DeclareOk do
-      it "should be a subclass of Method" do
-        Exchange::DeclareOk.should < Method
-      end
+      describe Protocol::Exchange::Declare do
+        it "should be a subclass of Method" do
+          Protocol::Exchange::Declare.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to exchange.declare-ok" do
-        Exchange::DeclareOk.name.should eql("exchange.declare-ok")
-      end
+        it "should have method name equal to exchange.declare" do
+          Protocol::Exchange::Declare.name.should eql("exchange.declare")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Exchange::DeclareOk.method.should eql("TODO")
+        it "has method id equal to 10" do
+          Protocol::Exchange::Declare.method_id.should == 10
+        end
       end
-    end
 
-    describe AMQ::Protocol::Exchange::Delete do
-      it "should be a subclass of Method" do
-        Exchange::Delete.should < Method
-      end
+      describe Protocol::Exchange::DeclareOk do
+        it "should be a subclass of Method" do
+          Protocol::Exchange::DeclareOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to exchange.delete" do
-        Exchange::Delete.name.should eql("exchange.delete")
-      end
+        it "should have method name equal to exchange.declare-ok" do
+          Protocol::Exchange::DeclareOk.name.should eql("exchange.declare-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Exchange::Delete.method.should eql("TODO")
+        it "has method id equal to 11" do
+          Protocol::Exchange::DeclareOk.method_id.should == 11
+        end
       end
-    end
 
-    describe AMQ::Protocol::Exchange::DeleteOk do
-      it "should be a subclass of Method" do
-        Exchange::DeleteOk.should < Method
-      end
+      describe Protocol::Exchange::Delete do
+        it "should be a subclass of Method" do
+          Protocol::Exchange::Delete.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to exchange.delete-ok" do
-        Exchange::DeleteOk.name.should eql("exchange.delete-ok")
-      end
+        it "should have method name equal to exchange.delete" do
+          Protocol::Exchange::Delete.name.should eql("exchange.delete")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Exchange::DeleteOk.method.should eql("TODO")
+        it "has method id equal to 20" do
+          Protocol::Exchange::Delete.method_id.should == 20
+        end
       end
-    end
 
-    describe AMQ::Protocol::Exchange::Bind do
-      it "should be a subclass of Method" do
-        Exchange::Bind.should < Method
-      end
+      describe Protocol::Exchange::DeleteOk do
+        it "should be a subclass of Method" do
+          Protocol::Exchange::DeleteOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to exchange.bind" do
-        Exchange::Bind.name.should eql("exchange.bind")
-      end
+        it "should have method name equal to exchange.delete-ok" do
+          Protocol::Exchange::DeleteOk.name.should eql("exchange.delete-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Exchange::Bind.method.should eql("TODO")
+        it "has method id equal to 21" do
+          Protocol::Exchange::DeleteOk.method_id.should == 21
+        end
       end
-    end
 
-    describe AMQ::Protocol::Exchange::BindOk do
-      it "should be a subclass of Method" do
-        Exchange::BindOk.should < Method
-      end
+      describe Protocol::Exchange::Bind do
+        it "should be a subclass of Method" do
+          Protocol::Exchange::Bind.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to exchange.bind-ok" do
-        Exchange::BindOk.name.should eql("exchange.bind-ok")
-      end
+        it "should have method name equal to exchange.bind" do
+          Protocol::Exchange::Bind.name.should eql("exchange.bind")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Exchange::BindOk.method.should eql("TODO")
+        it "has method id equal to 30" do
+          Protocol::Exchange::Bind.method_id.should == 30
+        end
       end
-    end
 
-    describe AMQ::Protocol::Exchange::Unbind do
-      it "should be a subclass of Method" do
-        Exchange::Unbind.should < Method
-      end
+      describe Protocol::Exchange::BindOk do
+        it "should be a subclass of Method" do
+          Protocol::Exchange::BindOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to exchange.unbind" do
-        Exchange::Unbind.name.should eql("exchange.unbind")
-      end
+        it "should have method name equal to exchange.bind-ok" do
+          Protocol::Exchange::BindOk.name.should eql("exchange.bind-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Exchange::Unbind.method.should eql("TODO")
+        it "has method id equal to 31" do
+          Protocol::Exchange::BindOk.method_id.should == 31
+        end
       end
-    end
 
-    describe AMQ::Protocol::Exchange::UnbindOk do
-      it "should be a subclass of Method" do
-        Exchange::UnbindOk.should < Method
-      end
+      describe Protocol::Exchange::Unbind do
+        it "should be a subclass of Method" do
+          Protocol::Exchange::Unbind.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to exchange.unbind-ok" do
-        Exchange::UnbindOk.name.should eql("exchange.unbind-ok")
-      end
+        it "should have method name equal to exchange.unbind" do
+          Protocol::Exchange::Unbind.name.should eql("exchange.unbind")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Exchange::UnbindOk.method.should eql("TODO")
+        it "has method id equal to 40" do
+          Protocol::Exchange::Unbind.method_id.should == 40
+        end
       end
-    end
-  end
 
-  describe AMQ::Protocol::Queue do
-    it "should be a subclass of Class" do
-      Queue.should < Class
-    end
+      describe Protocol::Exchange::UnbindOk do
+        it "should be a subclass of Method" do
+          Protocol::Exchange::UnbindOk.superclass.should == Protocol::Method
+        end
 
-    it "should have name equal to queue" do
-      Queue.name.should eql("queue")
-    end
+        it "should have method name equal to exchange.unbind-ok" do
+          Protocol::Exchange::UnbindOk.name.should eql("exchange.unbind-ok")
+        end
 
-    it "should have method equal to TODO" do
-      pending
-      Queue.method.should eql("TODO")
+        it "has method id equal to 51" do
+          Protocol::Exchange::UnbindOk.method_id.should == 51
+        end
+      end
     end
 
-    describe AMQ::Protocol::Queue::Declare do
-      it "should be a subclass of Method" do
-        Queue::Declare.should < Method
+    describe Protocol::Queue do
+      it "should be a subclass of Class" do
+        Protocol::Queue.superclass.should == Protocol::Class
       end
 
-      it "should have method name equal to queue.declare" do
-        Queue::Declare.name.should eql("queue.declare")
+      it "should have name equal to queue" do
+        Protocol::Queue.name.should eql("queue")
       end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::Declare.method.should eql("TODO")
+      it "has method id equal to 50" do
+        Protocol::Queue.method_id.should == 50
       end
-    end
 
-    describe AMQ::Protocol::Queue::DeclareOk do
-      it "should be a subclass of Method" do
-        Queue::DeclareOk.should < Method
-      end
+      describe Protocol::Queue::Declare do
+        it "should be a subclass of Method" do
+          Protocol::Queue::Declare.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.declare-ok" do
-        Queue::DeclareOk.name.should eql("queue.declare-ok")
-      end
+        it "should have method name equal to queue.declare" do
+          Protocol::Queue::Declare.name.should eql("queue.declare")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::DeclareOk.method.should eql("TODO")
+        it "has method id equal to 10" do
+          Protocol::Queue::Declare.method_id.should == 10
+        end
       end
-    end
 
-    describe AMQ::Protocol::Queue::Bind do
-      it "should be a subclass of Method" do
-        Queue::Bind.should < Method
-      end
+      describe Protocol::Queue::DeclareOk do
+        it "should be a subclass of Method" do
+          Protocol::Queue::DeclareOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.bind" do
-        Queue::Bind.name.should eql("queue.bind")
-      end
+        it "should have method name equal to queue.declare-ok" do
+          Protocol::Queue::DeclareOk.name.should eql("queue.declare-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::Bind.method.should eql("TODO")
+        it "has method id equal to 11" do
+          Protocol::Queue::DeclareOk.method_id.should == 11
+        end
       end
-    end
 
-    describe AMQ::Protocol::Queue::BindOk do
-      it "should be a subclass of Method" do
-        Queue::BindOk.should < Method
-      end
+      describe Protocol::Queue::Bind do
+        it "should be a subclass of Method" do
+          Protocol::Queue::Bind.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.bind-ok" do
-        Queue::BindOk.name.should eql("queue.bind-ok")
-      end
+        it "should have method name equal to queue.bind" do
+          Protocol::Queue::Bind.name.should eql("queue.bind")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::BindOk.method.should eql("TODO")
+        it "has method id equal to 20" do
+          Protocol::Queue::Bind.method_id.should == 20
+        end
       end
-    end
 
-    describe AMQ::Protocol::Queue::Purge do
-      it "should be a subclass of Method" do
-        Queue::Purge.should < Method
-      end
+      describe Protocol::Queue::BindOk do
+        it "should be a subclass of Method" do
+          Protocol::Queue::BindOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.purge" do
-        Queue::Purge.name.should eql("queue.purge")
-      end
+        it "should have method name equal to queue.bind-ok" do
+          Protocol::Queue::BindOk.name.should eql("queue.bind-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::Purge.method.should eql("TODO")
+        it "has method id equal to 21" do
+          Protocol::Queue::BindOk.method_id.should == 21
+        end
       end
-    end
 
-    describe AMQ::Protocol::Queue::PurgeOk do
-      it "should be a subclass of Method" do
-        Queue::PurgeOk.should < Method
-      end
+      describe Protocol::Queue::Purge do
+        it "should be a subclass of Method" do
+          Protocol::Queue::Purge.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.purge-ok" do
-        Queue::PurgeOk.name.should eql("queue.purge-ok")
-      end
+        it "should have method name equal to queue.purge" do
+          Protocol::Queue::Purge.name.should eql("queue.purge")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::PurgeOk.method.should eql("TODO")
+        it "has method id equal to 30" do
+          Protocol::Queue::Purge.method_id.should == 30
+        end
       end
-    end
 
-    describe AMQ::Protocol::Queue::Delete do
-      it "should be a subclass of Method" do
-        Queue::Delete.should < Method
-      end
+      describe Protocol::Queue::PurgeOk do
+        it "should be a subclass of Method" do
+          Protocol::Queue::PurgeOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.delete" do
-        Queue::Delete.name.should eql("queue.delete")
-      end
+        it "should have method name equal to queue.purge-ok" do
+          Protocol::Queue::PurgeOk.name.should eql("queue.purge-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::Delete.method.should eql("TODO")
+        it "has method id equal to 31" do
+          Protocol::Queue::PurgeOk.method_id.should == 31
+        end
       end
-    end
 
-    describe AMQ::Protocol::Queue::DeleteOk do
-      it "should be a subclass of Method" do
-        Queue::DeleteOk.should < Method
-      end
+      describe Protocol::Queue::Delete do
+        it "should be a subclass of Method" do
+          Protocol::Queue::Delete.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.delete-ok" do
-        Queue::DeleteOk.name.should eql("queue.delete-ok")
-      end
+        it "should have method name equal to queue.delete" do
+          Protocol::Queue::Delete.name.should eql("queue.delete")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::DeleteOk.method.should eql("TODO")
+        it "has method id equal to 40" do
+          Protocol::Queue::Delete.method_id.should == 40
+        end
       end
-    end
 
-    describe AMQ::Protocol::Queue::Unbind do
-      it "should be a subclass of Method" do
-        Queue::Unbind.should < Method
-      end
+      describe Protocol::Queue::DeleteOk do
+        it "should be a subclass of Method" do
+          Protocol::Queue::DeleteOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.unbind" do
-        Queue::Unbind.name.should eql("queue.unbind")
-      end
+        it "should have method name equal to queue.delete-ok" do
+          Protocol::Queue::DeleteOk.name.should eql("queue.delete-ok")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::Unbind.method.should eql("TODO")
+        it "has method id equal to 41" do
+          Protocol::Queue::DeleteOk.method_id.should == 41
+        end
       end
-    end
 
-    describe AMQ::Protocol::Queue::UnbindOk do
-      it "should be a subclass of Method" do
-        Queue::UnbindOk.should < Method
-      end
+      describe Protocol::Queue::Unbind do
+        it "should be a subclass of Method" do
+          Protocol::Queue::Unbind.superclass.should == Protocol::Method
+        end
 
-      it "should have method name equal to queue.unbind-ok" do
-        Queue::UnbindOk.name.should eql("queue.unbind-ok")
-      end
+        it "should have method name equal to queue.unbind" do
+          Protocol::Queue::Unbind.name.should eql("queue.unbind")
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Queue::UnbindOk.method.should eql("TODO")
+        it "has method id equal to 50" do
+          Protocol::Queue::Unbind.method_id.should == 50
+        end
       end
-    end
-  end
 
-  describe AMQ::Protocol::Basic do
-    it "should be a subclass of Class" do
-      Basic.should < Class
-    end
+      describe Protocol::Queue::UnbindOk do
+        it "should be a subclass of Method" do
+          Protocol::Queue::UnbindOk.superclass.should == Protocol::Method
+        end
 
-    it "should have name equal to basic" do
-      Basic.name.should eql("basic")
-    end
+        it "should have method name equal to queue.unbind-ok" do
+          Protocol::Queue::UnbindOk.name.should eql("queue.unbind-ok")
+        end
 
-    it "should have method equal to TODO" do
-      pending
-      Basic.method.should eql("TODO")
-    end
-    describe AMQ::Protocol::Basic::Qos do
-      it "should be a subclass of Method" do
-        Basic::Qos.should < Method
+        it "has method id equal to 51" do
+          Protocol::Queue::UnbindOk.method_id.should == 51
+        end
       end
+    end
 
-      it "should have method name equal to basic.qos" do
-        Basic::Qos.name.should eql("basic.qos")
+    describe Protocol::Basic do
+      it "should be a subclass of Class" do
+        Protocol::Basic.superclass.should == Protocol::Class
       end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Qos.method.should eql("TODO")
+      it "should have name equal to basic" do
+        Protocol::Basic.name.should eql("basic")
       end
-    end
 
-    describe AMQ::Protocol::Basic::QosOk do
-      it "should be a subclass of Method" do
-        Basic::QosOk.should < Method
+      it "has method id equal to 60" do
+        Protocol::Basic.method_id.should == 60
       end
 
-      it "should have method name equal to basic.qos-ok" do
-        Basic::QosOk.name.should eql("basic.qos-ok")
-      end
+      describe Protocol::Basic::Qos do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Qos.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::QosOk.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.qos" do
+          Protocol::Basic::Qos.name.should eql("basic.qos")
+        end
 
-    describe AMQ::Protocol::Basic::Consume do
-      it "should be a subclass of Method" do
-        Basic::Consume.should < Method
+        it "has method id equal to 10" do
+          Protocol::Basic::Qos.method_id.should == 10
+        end
       end
 
-      it "should have method name equal to basic.consume" do
-        Basic::Consume.name.should eql("basic.consume")
-      end
+      describe Protocol::Basic::QosOk do
+        it "should be a subclass of Method" do
+          Protocol::Basic::QosOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Consume.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.qos-ok" do
+          Protocol::Basic::QosOk.name.should eql("basic.qos-ok")
+        end
 
-    describe AMQ::Protocol::Basic::ConsumeOk do
-      it "should be a subclass of Method" do
-        Basic::ConsumeOk.should < Method
+        it "has method id equal to 11" do
+          Protocol::Basic::QosOk.method_id.should == 11
+        end
       end
 
-      it "should have method name equal to basic.consume-ok" do
-        Basic::ConsumeOk.name.should eql("basic.consume-ok")
-      end
+      describe Protocol::Basic::Consume do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Consume.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::ConsumeOk.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.consume" do
+          Protocol::Basic::Consume.name.should eql("basic.consume")
+        end
 
-    describe AMQ::Protocol::Basic::Cancel do
-      it "should be a subclass of Method" do
-        Basic::Cancel.should < Method
+        it "has method id equal to 20" do
+          Protocol::Basic::Consume.method_id.should == 20
+        end
       end
 
-      it "should have method name equal to basic.cancel" do
-        Basic::Cancel.name.should eql("basic.cancel")
-      end
+      describe Protocol::Basic::ConsumeOk do
+        it "should be a subclass of Method" do
+          Protocol::Basic::ConsumeOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Cancel.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.consume-ok" do
+          Protocol::Basic::ConsumeOk.name.should eql("basic.consume-ok")
+        end
 
-    describe AMQ::Protocol::Basic::CancelOk do
-      it "should be a subclass of Method" do
-        Basic::CancelOk.should < Method
+        it "has method id equal to 21" do
+          Protocol::Basic::ConsumeOk.method_id.should == 21
+        end
       end
 
-      it "should have method name equal to basic.cancel-ok" do
-        Basic::CancelOk.name.should eql("basic.cancel-ok")
-      end
+      describe Protocol::Basic::Cancel do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Cancel.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::CancelOk.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.cancel" do
+          Protocol::Basic::Cancel.name.should eql("basic.cancel")
+        end
 
-    describe AMQ::Protocol::Basic::Publish do
-      it "should be a subclass of Method" do
-        Basic::Publish.should < Method
+        it "has method id equal to 30" do
+          Protocol::Basic::Cancel.method_id.should == 30
+        end
       end
 
-      it "should have method name equal to basic.publish" do
-        Basic::Publish.name.should eql("basic.publish")
-      end
+      describe Protocol::Basic::CancelOk do
+        it "should be a subclass of Method" do
+          Protocol::Basic::CancelOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Publish.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.cancel-ok" do
+          Protocol::Basic::CancelOk.name.should eql("basic.cancel-ok")
+        end
 
-    describe AMQ::Protocol::Basic::Return do
-      it "should be a subclass of Method" do
-        Basic::Return.should < Method
+        it "has method id equal to 31" do
+          Protocol::Basic::CancelOk.method_id.should == 31
+        end
       end
 
-      it "should have method name equal to basic.return" do
-        Basic::Return.name.should eql("basic.return")
-      end
+      describe Protocol::Basic::Publish do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Publish.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Return.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.publish" do
+          Protocol::Basic::Publish.name.should eql("basic.publish")
+        end
 
-    describe AMQ::Protocol::Basic::Deliver do
-      it "should be a subclass of Method" do
-        Basic::Deliver.should < Method
+        it "has method id equal to 40" do
+          Protocol::Basic::Publish.method_id.should == 40
+        end
       end
 
-      it "should have method name equal to basic.deliver" do
-        Basic::Deliver.name.should eql("basic.deliver")
-      end
+      describe Protocol::Basic::Return do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Return.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Deliver.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.return" do
+          Protocol::Basic::Return.name.should eql("basic.return")
+        end
 
-    describe AMQ::Protocol::Basic::Get do
-      it "should be a subclass of Method" do
-        Basic::Get.should < Method
+        it "has method id equal to 50" do
+          Protocol::Basic::Return.method_id.should == 50
+        end
       end
 
-      it "should have method name equal to basic.get" do
-        Basic::Get.name.should eql("basic.get")
-      end
+      describe Protocol::Basic::Deliver do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Deliver.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Get.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.deliver" do
+          Protocol::Basic::Deliver.name.should eql("basic.deliver")
+        end
 
-    describe AMQ::Protocol::Basic::GetOk do
-      it "should be a subclass of Method" do
-        Basic::GetOk.should < Method
+        it "has method id equal to 60" do
+          Protocol::Basic::Deliver.method_id.should == 60
+        end
       end
 
-      it "should have method name equal to basic.get-ok" do
-        Basic::GetOk.name.should eql("basic.get-ok")
-      end
+      describe Protocol::Basic::Get do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Get.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::GetOk.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.get" do
+          Protocol::Basic::Get.name.should eql("basic.get")
+        end
 
-    describe AMQ::Protocol::Basic::GetEmpty do
-      it "should be a subclass of Method" do
-        Basic::GetEmpty.should < Method
+        it "has method id equal to 70" do
+          Protocol::Basic::Get.method_id.should == 70
+        end
       end
 
-      it "should have method name equal to basic.get-empty" do
-        Basic::GetEmpty.name.should eql("basic.get-empty")
-      end
+      describe Protocol::Basic::GetOk do
+        it "should be a subclass of Method" do
+          Protocol::Basic::GetOk.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::GetEmpty.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.get-ok" do
+          Protocol::Basic::GetOk.name.should eql("basic.get-ok")
+        end
 
-    describe AMQ::Protocol::Basic::Ack do
-      it "should be a subclass of Method" do
-        Basic::Ack.should < Method
+        it "has method id equal to 71" do
+          Protocol::Basic::GetOk.method_id.should == 71
+        end
       end
 
-      it "should have method name equal to basic.ack" do
-        Basic::Ack.name.should eql("basic.ack")
-      end
+      describe Protocol::Basic::GetEmpty do
+        it "should be a subclass of Method" do
+          Protocol::Basic::GetEmpty.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Ack.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.get-empty" do
+          Protocol::Basic::GetEmpty.name.should eql("basic.get-empty")
+        end
 
-    describe AMQ::Protocol::Basic::Reject do
-      it "should be a subclass of Method" do
-        Basic::Reject.should < Method
+        it "has method id equal to 72" do
+          Protocol::Basic::GetEmpty.method_id.should == 72
+        end
       end
 
-      it "should have method name equal to basic.reject" do
-        Basic::Reject.name.should eql("basic.reject")
-      end
+      describe Protocol::Basic::Ack do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Ack.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Reject.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.ack" do
+          Protocol::Basic::Ack.name.should eql("basic.ack")
+        end
 
-    describe AMQ::Protocol::Basic::RecoverAsync do
-      it "should be a subclass of Method" do
-        Basic::RecoverAsync.should < Method
+        it "has method id equal to 80" do
+          Protocol::Basic::Ack.method_id.should == 80
+        end
       end
 
-      it "should have method name equal to basic.recover-async" do
-        Basic::RecoverAsync.name.should eql("basic.recover-async")
-      end
+      describe Protocol::Basic::Reject do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Reject.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::RecoverAsync.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.reject" do
+          Protocol::Basic::Reject.name.should eql("basic.reject")
+        end
 
-    describe AMQ::Protocol::Basic::Recover do
-      it "should be a subclass of Method" do
-        Basic::Recover.should < Method
+        it "has method id equal to 90" do
+          Protocol::Basic::Reject.method_id.should == 90
+        end
       end
 
-      it "should have method name equal to basic.recover" do
-        Basic::Recover.name.should eql("basic.recover")
-      end
+      describe Protocol::Basic::RecoverAsync do
+        it "should be a subclass of Method" do
+          Protocol::Basic::RecoverAsync.superclass.should == Protocol::Method
+        end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::Recover.method.should eql("TODO")
-      end
-    end
+        it "should have method name equal to basic.recover-async" do
+          Protocol::Basic::RecoverAsync.name.should eql("basic.recover-async")
+        end
 
-    describe AMQ::Protocol::Basic::RecoverOk do
-      it "should be a subclass of Method" do
-        Basic::RecoverOk.should < Method
+        it "has method id equal to 100" do
+          Protocol::Basic::RecoverAsync.method_id.should == 100
+        end
       end
 
-      it "should have method name equal to basic.recover-ok" do
-        Basic::RecoverOk.name.should eql("basic.recover-ok")
+      describe Protocol::Basic::Recover do
+        it "should be a subclass of Method" do
+          Protocol::Basic::Recover.superclass.should == Protocol::Method
+        end
+
+        it "should have method name equal to basic.recover" do
+          Protocol::Basic::Recover.name.should eql("basic.recover")
+        end
+
+        it "has method id equal to 110" do
+          Protocol::Basic::Recover.method_id.should == 110
+        end
       end
 
-      it "should have method equal to TODO" do
-        pending
-        Basic::RecoverOk.method.should eql("TODO")
+      describe Protocol::Basic::RecoverOk do
+        it "should be a subclass of Method" do
+          Protocol::Basic::RecoverOk.superclass.should == Protocol::Method
+        end
+
+        it "should have method name equal to basic.recover-ok" do
+          Protocol::Basic::RecoverOk.name.should eql("basic.recover-ok")
+        end
+
+        it "has method id equal to 111" do
+          Protocol::Basic::RecoverOk.method_id.should == 111
+        end
       end
     end
   end
-end
+end