cql-rb 1.0.0.pre0

data/spec/cql/protocol/encoding_spec.rb

@@ -0,0 +1,338 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe Encoding do
+      let :buffer do
+        ''
+      end
+
+      describe '#write_int' do
+        it 'encodes an int' do
+          Encoding.write_int(buffer, 2323234234)
+          buffer.should == "\x8a\x79\xbd\xba"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_int(buffer, 10)
+          buffer.should == "\xab\x00\x00\x00\x0a"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_int(buffer, 2323234234)
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_short' do
+        it 'encodes a short' do
+          Encoding.write_short(buffer, 0xabcd)
+          buffer.should == "\xab\xcd"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_short(buffer, 10)
+          buffer.should == "\xab\x00\x0a"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_short(buffer, 42)
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_string' do
+        it 'encodes a string' do
+          Encoding.write_string(buffer, 'hello')
+          buffer.should == "\x00\x05hello"
+        end
+
+        it 'encodes an empty string' do
+          Encoding.write_string(buffer, '')
+          buffer.should == "\x00\x00"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_string(buffer, 'foo')
+          buffer.should == "\xab\x00\x03foo"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_string(buffer, 'hello')
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_long_string' do
+        it 'encodes a string' do
+          Encoding.write_long_string(buffer, 'hello world ' * 100_000)
+          buffer.should start_with("\x00\x12\x4f\x80hello world hello world hello world hello")
+        end
+
+        it 'encodes an empty string' do
+          Encoding.write_long_string(buffer, '')
+          buffer.should == "\x00\x00\x00\x00"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_long_string(buffer, 'foo')
+          buffer.should == "\xab\x00\x00\x00\x03foo"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_long_string(buffer, 'hello')
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_uuid' do
+        let :uuid do
+          Uuid.new('a4a70900-24e1-11df-8924-001ff3591711')
+        end
+
+        it 'encodes an UUID' do
+          Encoding.write_uuid(buffer, uuid)
+          buffer.should == "\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11"
+        end
+
+        it 'appends to the buffer' do
+          buffer << 'FOO'
+          Encoding.write_uuid(buffer, uuid)
+          buffer.should start_with('FOO')
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_uuid(buffer, uuid)
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_string_list' do
+        it 'encodes a string list' do
+          Encoding.write_string_list(buffer, %w[foo bar hello world])
+          buffer.should == "\x00\x04\x00\x03foo\x00\x03bar\x00\x05hello\x00\x05world"
+        end
+
+        it 'encodes an empty string list' do
+          Encoding.write_string_list(buffer, [])
+          buffer.should == "\x00\x00"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_string_list(buffer, %w[foo bar])
+          buffer.should == "\xab\x00\x02\x00\x03foo\x00\x03bar"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_string_list(buffer, %w[foo])
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_bytes' do
+        it 'encodes a byte array' do
+          Encoding.write_bytes(buffer, "\xaa" * 2000)
+          buffer.should == ("\x00\x00\x07\xd0" << ("\xaa" * 2000))
+        end
+
+        it 'encodes nil' do
+          Encoding.write_bytes(buffer, nil)
+          buffer.should == "\xff\xff\xff\xff"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_bytes(buffer, "\xf0\x0b\xbar")
+          buffer.should == "\xab\x00\x00\x00\x04\xf0\x0b\xbar"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_bytes(buffer, "\xab")
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_short_bytes' do
+        it 'encodes a byte array' do
+          Encoding.write_short_bytes(buffer, "\xaa\xbb\xcc")
+          buffer.should == "\x00\x03\xaa\xbb\xcc"
+        end
+
+        it 'encodes nil' do
+          Encoding.write_short_bytes(buffer, nil)
+          buffer.should == "\xff\xff"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_short_bytes(buffer, "\xf0\x0b\xbar")
+          buffer.should == "\xab\x00\x04\xf0\x0b\xbar"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_short_bytes(buffer, "\xab")
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_consistency' do
+        {
+          :any => "\x00\x00",
+          :one => "\x00\x01",
+          :two => "\x00\x02",
+          :three => "\x00\x03",
+          :quorum => "\x00\x04",
+          :all => "\x00\x05",
+          :local_quorum => "\x00\x06",
+          :each_quorum => "\x00\x07"
+        }.each do |consistency, expected_encoding|
+          it "encodes #{consistency}" do
+            Encoding.write_consistency(buffer, consistency)
+            buffer.should == expected_encoding
+          end
+        end
+
+        it 'raises an exception for an unknown consistency' do
+          expect { Encoding.write_consistency(buffer, :foo) }.to raise_error(EncodingError)
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_consistency(buffer, :one)
+          buffer.should == "\xab\x00\x01"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_consistency(buffer, :quorum)
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_string_map' do
+        it 'encodes a string map' do
+          Encoding.write_string_map(buffer, 'HELLO' => 'world', 'foo' => 'bar')
+          buffer.should == "\x00\x02\x00\x05HELLO\x00\x05world\x00\x03foo\x00\x03bar"
+        end
+
+        it 'encodes an empty map' do
+          Encoding.write_string_map(buffer, {})
+          buffer.should == "\x00\x00"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\xab"
+          Encoding.write_string_map(buffer, 'foo' => 'bar')
+          buffer.should == "\xab\x00\x01\x00\x03foo\x00\x03bar"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_string_map(buffer, 'HELLO' => 'world')
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_long' do
+        it 'encodes a long' do
+          Encoding.write_long(buffer, 0x0123456789)
+          buffer.should == "\x00\x00\x00\x01\x23\x45\x67\x89"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\x99"
+          Encoding.write_long(buffer, 0x0123456789)
+          buffer.should == "\x99\x00\x00\x00\x01\x23\x45\x67\x89"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_long(buffer, 1)
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_varint' do
+        it 'encodes a variable length integer' do
+          Encoding.write_varint(buffer, 1231312312331283012830129382342342412123)
+          buffer.should == "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a["
+        end
+
+        it 'encodes a negative variable length integer' do
+          Encoding.write_varint(buffer, -234234234234)
+          buffer.should == "\xC9v\x8D:\x86"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\x99"
+          Encoding.write_varint(buffer, -234234234234)
+          buffer.should == "\x99\xC9v\x8D:\x86"
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_varint(buffer, -234234234234)
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_decimal' do
+        it 'encodes a BigDecimal as a decimal' do
+          Encoding.write_decimal(buffer, BigDecimal.new('1042342234234.123423435647768234'))
+          buffer.should == "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"
+        end
+
+        it 'appends to the buffer' do
+          buffer << "\x99"
+          Encoding.write_decimal(buffer, BigDecimal.new('1042342234234.123423435647768234'))
+          buffer.should start_with("\x99")
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_decimal(buffer, BigDecimal.new('3.14'))
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_double' do
+        it 'encodes a double' do
+          Encoding.write_double(buffer, 10000.123123123)
+          buffer.should == "@\xC3\x88\x0F\xC2\x7F\x9DU"
+        end
+
+        it 'appends to the buffer' do
+          buffer << 'BEFORE'
+          Encoding.write_double(buffer, 10000.123123123)
+          buffer.should start_with('BEFORE')
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_double(buffer, 10000.123123123)
+          result.should equal(buffer)
+        end
+      end
+
+      describe '#write_float' do
+        it 'encodes a float' do
+          Encoding.write_float(buffer, 12.13)
+          buffer.should == "AB\x14{"
+        end
+
+        it 'appends to the buffer' do
+          buffer << 'BEFORE'
+          Encoding.write_float(buffer, 12.13)
+          buffer.should start_with('BEFORE')
+        end
+
+        it 'returns the buffer' do
+          result = Encoding.write_float(buffer, 12.13)
+          result.should equal(buffer)
+        end
+      end
+    end
+  end
+end

data/spec/cql/protocol/request_frame_spec.rb

@@ -0,0 +1,359 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe RequestFrame do
+      context 'with OPTIONS requests' do
+        it 'encodes an OPTIONS request' do
+          bytes = RequestFrame.new(OptionsRequest.new).write('')
+          bytes.should == "\x01\x00\x00\x05\x00\x00\x00\x00"
+        end
+      end
+
+      context 'with STARTUP requests' do
+        it 'encodes the request' do
+          bytes = RequestFrame.new(StartupRequest.new('3.0.0', 'snappy')).write('')
+          bytes.should == "\x01\x00\x00\x01\x00\x00\x00\x2b\x00\x02\x00\x0bCQL_VERSION\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x06snappy"
+        end
+
+        it 'defaults to CQL 3.0.0 and no compression' do
+          bytes = RequestFrame.new(StartupRequest.new).write('')
+          bytes.should == "\x01\x00\x00\x01\x00\x00\x00\x16\x00\x01\x00\x0bCQL_VERSION\x00\x053.0.0"
+        end
+      end
+
+      context 'with REGISTER requests' do
+        it 'encodes the request' do
+          bytes = RequestFrame.new(RegisterRequest.new('TOPOLOGY_CHANGE', 'STATUS_CHANGE')).write('')
+          bytes.should == "\x01\x00\x00\x0b\x00\x00\x00\x22\x00\x02\x00\x0fTOPOLOGY_CHANGE\x00\x0dSTATUS_CHANGE"
+        end
+      end
+
+      context 'with QUERY requests' do
+        it 'encodes the request' do
+          bytes = RequestFrame.new(QueryRequest.new('USE system', :all)).write('')
+          bytes.should == "\x01\x00\x00\x07\x00\x00\x00\x10\x00\x00\x00\x0aUSE system\x00\x05"
+        end
+      end
+
+      context 'with PREPARE requests' do
+        it 'encodes the request' do
+          bytes = RequestFrame.new(PrepareRequest.new('UPDATE users SET email = ? WHERE user_name = ?')).write('')
+          bytes.should == "\x01\x00\x00\x09\x00\x00\x00\x32\x00\x00\x00\x2eUPDATE users SET email = ? WHERE user_name = ?"
+        end
+      end
+
+      context 'with EXECUTE requests' do
+        let :id do
+          "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"
+        end
+
+        let :column_metadata do
+          [['ks', 'tbl', 'col1', :varchar], ['ks', 'tbl', 'col2', :int], ['ks', 'tbl', 'col3', :varchar]]
+        end
+
+        it 'encodes the request' do
+          bytes = RequestFrame.new(ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], :each_quorum)).write('')
+          bytes.should == "\x01\x00\x00\x0a\x00\x00\x00\x2e\x00\x10\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/\x00\x03\x00\x00\x00\x05hello\x00\x00\x00\x04\x00\x00\x00\x2a\x00\x00\x00\x03foo\x00\x07"
+        end
+
+        specs = [
+          [:ascii, 'test', "test"],
+          [:bigint, 1012312312414123, "\x00\x03\x98\xB1S\xC8\x7F\xAB"],
+          [:blob, "\xab\xcd", "\xab\xcd"],
+          [:boolean, false, "\x00"],
+          [:boolean, true, "\x01"],
+          [:decimal, BigDecimal.new('1042342234234.123423435647768234'), "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"],
+          [:double, 10000.123123123, "@\xC3\x88\x0F\xC2\x7F\x9DU"],
+          [:float, 12.13, "AB\x14{"],
+          [:inet, IPAddr.new('8.8.8.8'), "\x08\x08\x08\x08"],
+          [:inet, IPAddr.new('::1'), "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"],
+          [:int, 12348098, "\x00\xBCj\xC2"],
+          [:text, 'FOOBAR', 'FOOBAR'],
+          [:timestamp, Time.at(1358013521.123), "\x00\x00\x01</\xE9\xDC\xE3"],
+          [:timeuuid, Uuid.new('a4a70900-24e1-11df-8924-001ff3591711'), "\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11"],
+          [:uuid, Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'), "\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6"],
+          [:varchar, 'hello', 'hello'],
+          [:varint, 1231312312331283012830129382342342412123, "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a["],
+          [:varint, -234234234234, "\xC9v\x8D:\x86"]
+        ]
+        specs.each do |type, value, expected_bytes|
+          it "encodes #{type} values" do
+            metadata = [['ks', 'tbl', 'id_column', type]]
+            bytes = RequestFrame.new(ExecuteRequest.new(id, metadata, [value], :one)).write('')
+            bytes.slice!(0, 8 + 2 + 16 + 2)
+            length = bytes.slice!(0, 4).unpack('N').first
+            result_bytes = bytes[0, length]
+            result_bytes.should == expected_bytes
+          end
+        end
+
+        it 'raises an error when the metadata and values don\'t have the same size' do
+          expect { ExecuteRequest.new(id, column_metadata, ['hello', 42], :each_quorum) }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an error for unsupported column types' do
+          column_metadata[2][3] = :imaginary
+          expect { RequestFrame.new(ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], :each_quorum)).write('') }.to raise_error(UnsupportedColumnTypeError)
+        end
+
+        it 'raises an error when it cannot encode the argument' do
+          expect { ExecuteRequest.new(id, column_metadata, ['hello', 'not an int', 'foo'], :each_quorum).write('') }.to raise_error(TypeError, /cannot be encoded as INT/)
+        end
+      end
+
+      context 'with a stream ID' do
+        it 'encodes the stream ID in the header' do
+          bytes = RequestFrame.new(QueryRequest.new('USE system', :all), 42).write('')
+          bytes[2].should == "\x2a"
+        end
+
+        it 'defaults to zero' do
+          bytes = RequestFrame.new(QueryRequest.new('USE system', :all)).write('')
+          bytes[2].should == "\x00"
+        end
+
+        it 'raises an exception if the stream ID is outside of 0..127' do
+          expect { RequestFrame.new(QueryRequest.new('USE system', :all), -1) }.to raise_error(InvalidStreamIdError)
+          expect { RequestFrame.new(QueryRequest.new('USE system', :all), 128) }.to raise_error(InvalidStreamIdError)
+          expect { RequestFrame.new(QueryRequest.new('USE system', :all), 99999999) }.to raise_error(InvalidStreamIdError)
+        end
+      end
+
+      describe StartupRequest do
+        describe '#to_s' do
+          it 'returns a pretty string' do
+            request = StartupRequest.new
+            request.to_s.should == 'STARTUP {"CQL_VERSION"=>"3.0.0"}'
+          end
+        end
+      end
+
+      describe OptionsRequest do
+        describe '#to_s' do
+          it 'returns a pretty string' do
+            request = OptionsRequest.new
+            request.to_s.should == 'OPTIONS'
+          end
+        end
+      end
+
+      describe RegisterRequest do
+        describe '#to_s' do
+          it 'returns a pretty string' do
+            request = RegisterRequest.new('TOPOLOGY_CHANGE', 'STATUS_CHANGE')
+            request.to_s.should == 'REGISTER ["TOPOLOGY_CHANGE", "STATUS_CHANGE"]'
+          end
+        end
+      end
+
+      describe QueryRequest do
+        describe '#to_s' do
+          it 'returns a pretty string' do
+            request = QueryRequest.new('SELECT * FROM system.peers', :local_quorum)
+            request.to_s.should == 'QUERY "SELECT * FROM system.peers" LOCAL_QUORUM'
+          end
+        end
+
+        describe '#eql?' do
+          it 'returns true when the CQL and consistency are the same' do
+            q1 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2.should eql(q2)
+          end
+
+          it 'returns false when the consistency is different' do
+            q1 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2 = QueryRequest.new('SELECT * FROM system.peers', :three)
+            q1.should_not eql(q2)
+          end
+
+          it 'returns false when the CQL is different' do
+            q1 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2 = QueryRequest.new('SELECT * FROM peers', :two)
+            q1.should_not eql(q2)
+          end
+
+          it 'does not know about CQL syntax' do
+            q1 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2 = QueryRequest.new('SELECT   *   FROM   system.peers', :two)
+            q1.should_not eql(q2)
+          end
+
+          it 'is aliased as ==' do
+            q1 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q1.should == q2
+          end
+        end
+
+        describe '#hash' do
+          it 'has the same hash code as another identical object' do
+            q1 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q1.hash.should == q2.hash
+          end
+
+          it 'does not have the same hash code when the consistency is different' do
+            q1 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2 = QueryRequest.new('SELECT * FROM system.peers', :three)
+            q1.hash.should_not == q2.hash
+          end
+
+          it 'does not have the same hash code when the CQL is different' do
+            q1 = QueryRequest.new('SELECT * FROM system.peers', :two)
+            q2 = QueryRequest.new('SELECT * FROM peers', :two)
+            q1.hash.should_not == q2.hash
+          end
+        end
+      end
+
+      describe PrepareRequest do
+        describe '#to_s' do
+          it 'returns a pretty string' do
+            request = PrepareRequest.new('UPDATE users SET email = ? WHERE user_name = ?')
+            request.to_s.should == 'PREPARE "UPDATE users SET email = ? WHERE user_name = ?"'
+          end
+        end
+
+        describe '#eql?' do
+          it 'returns true when the CQL is the same' do
+            p1 = PrepareRequest.new('SELECT * FROM system.peers')
+            p2 = PrepareRequest.new('SELECT * FROM system.peers')
+            p1.should eql(p2)
+          end
+
+          it 'returns false when the CQL is different' do
+            p1 = PrepareRequest.new('SELECT * FROM system.peers')
+            p2 = PrepareRequest.new('SELECT * FROM peers')
+            p1.should_not eql(p2)
+          end
+
+          it 'does not know about CQL syntax' do
+            p1 = PrepareRequest.new('SELECT * FROM system.peers')
+            p2 = PrepareRequest.new('SELECT   *   FROM   system.peers')
+            p1.should_not eql(p2)
+          end
+
+          it 'is aliased as ==' do
+            p1 = PrepareRequest.new('SELECT * FROM system.peers')
+            p2 = PrepareRequest.new('SELECT * FROM system.peers')
+            p1.should == p2
+          end
+        end
+
+        describe '#hash' do
+          it 'has the same hash code as another identical object' do
+            p1 = PrepareRequest.new('SELECT * FROM system.peers')
+            p2 = PrepareRequest.new('SELECT * FROM system.peers')
+            p1.hash.should == p2.hash
+          end
+
+          it 'does not have the same hash code when the CQL is different' do
+            p1 = PrepareRequest.new('SELECT * FROM system.peers')
+            p2 = PrepareRequest.new('SELECT * FROM peers')
+            p1.hash.should_not == p2.hash
+          end
+        end
+      end
+
+      describe ExecuteRequest do
+        let :id do
+          "\xCAH\x7F\x1Ez\x82\xD2<N\x8A\xF35Qq\xA5/"
+        end
+
+        let :metadata do
+          [
+            ['ks', 'tbl', 'col1', :varchar],
+            ['ks', 'tbl', 'col2', :int],
+            ['ks', 'tbl', 'col3', :varchar]
+          ]
+        end
+
+        let :values do
+          ['hello', 42, 'foo']
+        end
+
+        describe '#to_s' do
+          it 'returns a pretty string' do
+            request = ExecuteRequest.new(id, metadata, values, :each_quorum)
+            request.to_s.should == 'EXECUTE ca487f1e7a82d23c4e8af3355171a52f ["hello", 42, "foo"] EACH_QUORUM'
+          end
+        end
+
+        describe '#eql?' do
+          it 'returns true when the ID, metadata, values and consistency are the same' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata, values, :one)
+            e1.should eql(e2)
+          end
+
+          it 'returns false when the ID is different' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id.reverse, metadata, values, :one)
+            e1.should_not eql(e2)
+          end
+
+          it 'returns false when the metadata is different' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata.reverse, values, :one)
+            e1.should_not eql(e2)
+          end
+
+          it 'returns false when the values are different' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata, values.reverse, :one)
+            e1.should_not eql(e2)
+          end
+
+          it 'returns false when the consistency is different' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata, values, :two)
+            e1.should_not eql(e2)
+          end
+
+          it 'is aliased as ==' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata, values, :one)
+            e1.should == e2
+          end
+        end
+
+        describe '#hash' do
+          it 'has the same hash code as another identical object' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata, values, :one)
+            e1.hash.should == e2.hash
+          end
+
+          it 'does not have the same hash code when the ID is different' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id.reverse, metadata, values, :one)
+            e1.hash.should_not == e2.hash
+          end
+
+          it 'does not have the same hash code when the metadata is different' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata.reverse, values, :one)
+            e1.hash.should_not == e2.hash
+          end
+
+          it 'does not have the same hash code when the values are different' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata, values.reverse, :one)
+            e1.hash.should_not == e2.hash
+          end
+
+          it 'does not have the same hash code when the consistency is different' do
+            e1 = ExecuteRequest.new(id, metadata, values, :one)
+            e2 = ExecuteRequest.new(id, metadata, values, :two)
+            e1.hash.should_not == e2.hash
+          end
+        end
+      end
+    end
+  end
+end