cql-rb 1.0.0.pre0

data/spec/cql/io/io_reactor_spec.rb

@@ -0,0 +1,290 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Io
+    describe IoReactor do
+      let :host do
+        Socket.gethostname
+      end
+
+      let :port do
+        34535
+      end
+
+      let :server do
+        FakeServer.new(port)
+      end
+
+      let :io_reactor do
+        described_class.new(connection_timeout: 1)
+      end
+
+      before do
+        server.start!
+      end
+
+      after do
+        io_reactor.stop.get if io_reactor.running?
+        server.stop!
+      end
+
+      describe '#initialize' do
+        it 'does not connect' do
+          described_class.new
+          sleep(0.1)
+          server.connects.should == 0
+        end
+      end
+
+      describe '#running?' do
+        it 'is initially false' do
+          io_reactor.should_not be_running
+        end
+
+        it 'is true when started' do
+          io_reactor.start.get
+          io_reactor.should be_running
+        end
+
+        it 'is true when starting' do
+          f = io_reactor.start
+          io_reactor.should be_running
+          f.get
+        end
+
+        it 'is false when stopped' do
+          io_reactor.start.get
+          io_reactor.stop.get
+          io_reactor.should_not be_running
+        end
+      end
+
+      describe '#stop' do
+        it 'closes all connections' do
+          io_reactor.start.get
+          f1 = io_reactor.add_connection(host, port)
+          f2 = io_reactor.add_connection(host, port)
+          f3 = io_reactor.add_connection(host, port)
+          f4 = io_reactor.add_connection(host, port)
+          Future.combine(f1, f2, f3, f4).get
+          io_reactor.stop.get
+          server.await_disconnects!(4)
+          server.disconnects.should == 4
+        end
+
+        it 'succeeds connection futures when stopping while connecting' do
+          f = io_reactor.add_connection(host, port + 9)
+          io_reactor.start
+          io_reactor.stop
+          f.get
+        end
+      end
+
+      describe '#add_connection' do
+        before do
+          io_reactor.start.get
+        end
+
+        it 'connects to the specified host and port' do
+          future = io_reactor.add_connection(host, port)
+          future.get
+          server.await_connects!(1)
+          server.connects.should == 1
+        end
+
+        it 'yields the connection ID when completed' do
+          future = io_reactor.add_connection(host, port)
+          future.get.should_not be_nil
+        end
+
+        it 'fails the returned future when it cannot connect to the host' do
+          future = io_reactor.add_connection('example.com', port)
+          expect { future.get }.to raise_error(ConnectionError)
+        end
+
+        it 'fails the returned future when it cannot connect to the port' do
+          future = io_reactor.add_connection(host, 9999)
+          expect { future.get }.to raise_error(ConnectionError)
+        end
+
+        it 'times out quickly when it cannot connect' do
+          started_at = Time.now
+          begin
+            future = io_reactor.add_connection(host, 9999)
+            future.get
+          rescue ConnectionError
+          end
+          time_taken = (Time.now - started_at).to_f
+          time_taken.should be < 1.5
+        end
+
+        it 'can be called before the reactor is started' do
+          r = described_class.new(connection_timeout: 1)
+          f1 = r.add_connection(host, port)
+          f2 = r.start
+          f2.get
+          f1.get
+        end
+      end
+
+      describe '#queue_request' do
+        it 'eventually sends the request' do
+          io_reactor.start
+          io_reactor.add_connection(host, port).get
+          io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
+          sleep(0.01) until server.received_bytes.size > 0
+          server.received_bytes[3, 1].should == "\x01"
+        end
+
+        it 'can be called before the reactor is started' do
+          io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
+          io_reactor.start
+          io_reactor.add_connection(host, port).get
+          sleep(0.01) until server.received_bytes.size > 0
+          server.received_bytes[3, 1].should == "\x01"
+        end
+
+        it 'queues requests when all connections are busy' do
+          request = Cql::Protocol::QueryRequest.new('UPDATE x SET y = 1 WHERE z = 2', :one)
+
+          io_reactor.start
+          io_reactor.add_connection(host, port).get
+
+          futures = 200.times.map do
+            io_reactor.queue_request(request)
+          end
+
+          128.times do |i|
+            server.broadcast!("\x81\x00#{[i].pack('c')}\b\x00\x00\x00\x04\x00\x00\x00\x01")
+          end
+
+          Future.combine(*futures.shift(128)).get
+
+          128.times do |i|
+            server.broadcast!("\x81\x00#{[i].pack('c')}\b\x00\x00\x00\x04\x00\x00\x00\x01")
+          end
+
+          Future.combine(*futures).get
+        end
+
+        it 'performs the request using the connection with the given ID' do
+          future = Future.new
+          request = Cql::Protocol::StartupRequest.new
+          response = "\x81\x00\x00\x02\x00\x00\x00\x00"
+
+          io_reactor.start.on_complete do
+            io_reactor.add_connection(host, port).on_complete do |c1_id|
+              io_reactor.add_connection(host, port).on_complete do |c2_id|
+                q1_future = io_reactor.queue_request(request, c2_id)
+                q2_future = io_reactor.queue_request(request, c1_id)
+
+                Future.combine(q1_future, q2_future).on_complete do |(_, q1_id), (_, q2_id)|
+                  future.complete!([c1_id, c2_id, q1_id, q2_id])
+                end
+
+                server.await_connects!(2)
+                server.broadcast!(response.dup)
+              end
+            end
+          end
+
+          connection1_id, connection2_id, query1_id, query2_id = future.value
+
+          connection1_id.should_not be_nil
+          connection2_id.should_not be_nil
+          query1_id.should == connection2_id
+          query2_id.should == connection1_id
+        end
+
+        it 'fails if the connection does not exist' do
+          f = io_reactor.start.flat_map do
+            io_reactor.add_connection(host, port).flat_map do
+              io_reactor.queue_request(Cql::Protocol::StartupRequest.new, 1234)
+            end
+          end
+          expect { f.get }.to raise_error(ConnectionNotFoundError)
+        end
+
+        it 'fails if the connection is busy' do
+          f = io_reactor.start.flat_map do
+            io_reactor.add_connection(host, port).flat_map do
+              io_reactor.add_connection(host, port).flat_map do |connection_id|
+                200.times do
+                  io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
+                end
+                io_reactor.queue_request(Cql::Protocol::OptionsRequest.new, connection_id)
+              end
+            end
+          end
+          expect { f.get }.to raise_error(ConnectionBusyError)
+        end
+
+        it 'fails if the connection is busy, when there is only one connection' do
+          pending 'as it is the reactor doesn\'t try to deliver requests when all connections are busy'
+        end
+
+        it 'yields the response when completed' do
+          response = nil
+          io_reactor.start
+          io_reactor.add_connection(host, port).get
+          f = io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
+          f.on_complete do |r, _|
+            response = r
+          end
+          server.broadcast!("\x81\x00\x00\x02\x00\x00\x00\x00")
+          sleep(0.01) until response
+          response.should == Cql::Protocol::ReadyResponse.new
+        end
+
+        it 'yields the connection ID when completed' do
+          connection = nil
+          io_reactor.start
+          io_reactor.add_connection(host, port).get
+          f = io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
+          f.on_complete do |_, c|
+            connection = c
+          end
+          server.broadcast!("\x81\x00\x00\x02\x00\x00\x00\x00")
+          sleep(0.01) until connection
+          connection.should_not be_nil
+        end
+      end
+
+      describe '#add_event_listener' do
+        it 'calls the listener when frames with stream ID -1 arrives' do
+          event = nil
+          io_reactor.start
+          io_reactor.add_connection(host, port).get
+          io_reactor.add_event_listener { |e| event = e }
+          server.broadcast!("\x81\x00\xFF\f\x00\x00\x00+\x00\rSCHEMA_CHANGE\x00\aDROPPED\x00\nkeyspace01\x00\x05users")
+          sleep(0.01) until event
+          event.should == Cql::Protocol::SchemaChangeEventResponse.new('DROPPED', 'keyspace01', 'users')
+        end
+      end
+
+      context 'when errors occur' do
+        context 'in the IO loop' do
+          before do
+            bad_request = stub(:request)
+            bad_request.stub(:opcode).and_raise(StandardError.new('Blurgh'))
+            io_reactor.start
+            io_reactor.add_connection(host, port).get
+            io_reactor.queue_request(bad_request)
+          end
+
+          it 'stops' do
+            sleep(0.1)
+            io_reactor.should_not be_running
+          end
+
+          it 'fails the future returned from #stop' do
+            expect { io_reactor.stop.get }.to raise_error('Blurgh')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cql/protocol/decoding_spec.rb

@@ -0,0 +1,464 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe Decoding do
+      describe '#read_byte!' do
+        let :buffer do
+          "\xab"
+        end
+
+        it 'decodes a raw byte' do
+          Decoding.read_byte!(buffer).should == 0xab
+        end
+
+        it 'consumes the byte' do
+          Decoding.read_byte!(buffer)
+          buffer.should be_empty
+        end
+
+        it 'raises an error when there is no byte available' do
+          expect { Decoding.read_byte!('') }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_varint!' do
+        it 'decodes a variable length integer' do
+          Decoding.read_varint!("\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[", 17).should == 1231312312331283012830129382342342412123
+        end
+
+        it 'decodes a negative variable length integer' do
+          Decoding.read_varint!("\xC9v\x8D:\x86", 5).should == -234234234234
+        end
+
+        it 'decodes an unsigned variable length integer' do
+          Decoding.read_varint!("\xC9v\x8D:\x86", 5, false).should == 865277393542
+        end
+
+        it 'consumes the bytes' do
+          buffer = "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[\x01\x02\x03"
+          Decoding.read_varint!(buffer, 17)
+          buffer.should == "\x01\x02\x03"
+        end
+
+        it 'raises an error when there is not enough bytes available' do
+          expect { Decoding.read_varint!("\xC9v\x8D:", 7) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_decimal!' do
+        let :buffer do
+          "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"
+        end
+
+        it 'decodes a decimal to a BigDecimal' do
+          Decoding.read_decimal!(buffer, buffer.length).should == BigDecimal.new('1042342234234.123423435647768234')
+        end
+
+        it 'consumes the bytes' do
+          buffer << 'HELLO'
+          Decoding.read_decimal!(buffer, buffer.length - 5)
+          buffer.should == 'HELLO'
+        end
+
+        it 'defaults to using the buffer length' do
+          Decoding.read_decimal!(buffer.dup).should == Decoding.read_decimal!(buffer, buffer.length)
+        end
+
+        it 'raises an error when there is not enough bytes available' do
+          expect { Decoding.read_decimal!(buffer[0, 3], 7) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_long!' do
+        it 'decodes a long' do
+          Decoding.read_long!("\x00\x00\xca\xfe\xba\xbe\x00\x00").should == 0x0000cafebabe0000
+        end
+
+        it 'consumes the bytes' do
+          buffer = "\xca\xfe\xba\xbe\xca\xfe\xba\xbe\xca\xfe\xba\xbe"
+          Decoding.read_long!(buffer)
+          buffer.should == "\xca\xfe\xba\xbe"
+        end
+
+        it 'raises an error when there is not enough bytes available' do
+          expect { Decoding.read_long!("\xca\xfe\xba\xbe\x00") }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_double!' do
+        it 'decodes a double' do
+          Decoding.read_double!("@\xC3\x88\x0F\xC2\x7F\x9DU").should == 10000.123123123
+        end
+
+        it 'consumes the bytes' do
+          buffer = "@\xC3\x88\x0F\xC2\x7F\x9DUxyz"
+          Decoding.read_double!(buffer)
+          buffer.should == 'xyz'
+        end
+
+        it 'raises an error when there is not enough bytes available' do
+          expect { Decoding.read_double!("@\xC3\x88\x0F") }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_float!' do
+        it 'decodes a float' do
+          Decoding.read_float!("AB\x14{").should be_within(0.00001).of(12.13)
+        end
+
+        it 'consumes the bytes' do
+          buffer = "AB\x14{xyz"
+          Decoding.read_float!(buffer)
+          buffer.should == 'xyz'
+        end
+
+        it 'raises an error when there is not enough bytes available' do
+          expect { Decoding.read_float!("\x0F") }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_int!' do
+        let :buffer do
+          "\x00\xff\x00\xff"
+        end
+
+        it 'decodes an int' do
+          Decoding.read_int!(buffer).should == 0x00ff00ff
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xab\xcd"
+          Decoding.read_int!(buffer)
+          buffer.should == "\xab\xcd"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_int!("\x01\xab") }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_short!' do
+        let :buffer do
+          "\x00\x02"
+        end
+
+        it 'decodes a short' do
+          Decoding.read_short!(buffer).should == 2
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xff\xff"
+          Decoding.read_short!(buffer)
+          buffer.should == "\xff\xff"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_short!("\x01") }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_string!' do
+        let :buffer do
+          "\x00\x0bhej och hå"
+        end
+
+        it 'decodes a string' do
+          Decoding.read_string!(buffer).should == 'hej och hå'.force_encoding(::Encoding::UTF_8)
+        end
+
+        it 'decodes a string as UTF-8' do
+          Decoding.read_string!(buffer).encoding.should == ::Encoding::UTF_8
+        end
+
+        it 'decodes an empty string' do
+          Decoding.read_string!("\x00\x00").should be_empty
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xff\xff"
+          Decoding.read_string!(buffer)
+          buffer.should == "\xff\xff"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_string!(buffer.slice(0, 5)) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_long_string!' do
+        let :buffer do
+          "\x00\x01\x00\00" << ('x' * 0x10000)
+        end
+
+        it 'decodes a string' do
+          Decoding.read_long_string!(buffer.dup).should start_with('xxx')
+          Decoding.read_long_string!(buffer).length.should == 0x10000
+        end
+
+        it 'decodes a string as UTF-8' do
+          Decoding.read_long_string!(buffer).encoding.should == ::Encoding::UTF_8
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xff\xff"
+          Decoding.read_long_string!(buffer)
+          buffer.should == "\xff\xff"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_long_string!(buffer.slice(0, 246)) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_uuid!' do
+        let :buffer do
+          "\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11"
+        end
+
+        it 'decodes a UUID' do
+          Decoding.read_uuid!(buffer).should == Uuid.new('a4a70900-24e1-11df-8924-001ff3591711')
+        end
+        
+        it 'consumes the bytes' do
+          Decoding.read_uuid!(buffer)
+          buffer.should be_empty
+        end
+        
+        it 'raises an error when there a not enough bytes in the buffer' do
+          expect { Decoding.read_uuid!(buffer[2, 5]) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_string_list!' do
+        let :buffer do
+          "\x00\x02\x00\x05hello\x00\x05world"
+        end
+
+        it 'decodes a string list' do
+          Decoding.read_string_list!(buffer).should == %w[hello world]
+        end
+
+        it 'decodes an empty string list' do
+          Decoding.read_string_list!("\x00\x00").should == []
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xff\xff"
+          Decoding.read_string_list!(buffer)
+          buffer.should == "\xff\xff"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_string_list!(buffer.slice(0, 13)) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_bytes!' do
+        let :buffer do
+          "\x00\x01\x00\x00" << ("\x42" * 0x10000)
+        end
+
+        it 'decodes a byte array' do
+          Decoding.read_bytes!(buffer).should == ("\x42" * 0x10000)
+        end
+
+        it 'decodes an empty byte array' do
+          Decoding.read_bytes!("\x00\x00\x00\x00").should == ''
+        end
+
+        it 'returns an ASCII-8BIT encoded string' do
+          Decoding.read_bytes!("\x00\x00\x00\x01\xaa").encoding.should == ::Encoding::BINARY
+        end
+
+        it 'decodes null' do
+          Decoding.read_bytes!("\x80\x00\x00\x00").should be_nil
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xab\xcd"
+          Decoding.read_bytes!(buffer)
+          buffer.should == "\xab\xcd"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_bytes!(buffer[0, 10]) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_short_bytes!' do
+        let :buffer do
+          "\x01\x00" << ("\x42" * 0x100)
+        end
+
+        it 'decodes a byte array' do
+          Decoding.read_short_bytes!(buffer).should == ("\x42" * 0x100)
+        end
+
+        it 'decodes an empty byte array' do
+          Decoding.read_short_bytes!("\x00\x00\x00\x00").should == ''
+        end
+
+        it 'returns an ASCII-8BIT encoded string' do
+          Decoding.read_short_bytes!("\x00\x00\x00\x01\xaa").encoding.should == ::Encoding::BINARY
+        end
+
+        it 'decodes null' do
+          Decoding.read_short_bytes!("\x80\x00").should be_nil
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xab\xcd"
+          Decoding.read_short_bytes!(buffer)
+          buffer.should == "\xab\xcd"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_short_bytes!(buffer[0, 10]) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_option!' do
+        it 'decodes an option ID and value with instructions from a block' do
+          id, value = Decoding.read_option!("\x00\x01\x00\x03foo") do |id, buffer|
+            Decoding.read_string!(buffer)
+          end
+          id.should == 1
+          value.should == 'foo'
+        end
+
+        it 'decodes an option ID and nil value when there is no block' do
+          id, value = Decoding.read_option!("\xaa\xbb")
+          id.should == 0xaabb
+          value.should be_nil
+        end
+
+        it 'consumes the bytes' do
+          buffer = "\x00\x01\x00\x03\xab"
+          id, value = Decoding.read_option!(buffer) do |id, buffer|
+            Decoding.read_short!(buffer)
+          end
+          buffer.should == "\xab"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_option!("\xaa") }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_inet!' do
+        it 'decodes an IPv4 + port pair' do
+          ip_addr, port = Decoding.read_inet!("\x04\x00\x00\x00\x00\x00\x00#R")
+          ip_addr.should == IPAddr.new('0.0.0.0')
+          port.should == 9042
+        end
+
+        it 'decodes an IPv6 + port pair' do
+          ip_addr, port = Decoding.read_inet!("\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00#R")
+          ip_addr.should == IPAddr.new('::1')
+          port.should == 9042
+        end
+
+        it 'consumes the bytes' do
+          buffer = "\x04\x00\x00\x00\x00\x00\x00#R\xff\xaa"
+          Decoding.read_inet!(buffer)
+          buffer.should == "\xff\xaa"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_inet!("\x04\x00\x00\x00\x00\x00\x00") }.to raise_error(DecodingError)
+          expect { Decoding.read_inet!("\x04\x00\x00\x00") }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_consistency!' do
+        it 'decodes ANY' do
+          Decoding.read_consistency!("\x00\x00").should == :any
+        end
+
+        it 'decodes ONE' do
+          Decoding.read_consistency!("\x00\x01").should == :one
+        end
+
+        it 'decodes TWO' do
+          Decoding.read_consistency!("\x00\x02").should == :two
+        end
+
+        it 'decodes THREE' do
+          Decoding.read_consistency!("\x00\x03").should == :three
+        end
+
+        it 'decodes QUORUM' do
+          Decoding.read_consistency!("\x00\x04").should == :quorum
+        end
+
+        it 'decodes ALL' do
+          Decoding.read_consistency!("\x00\x05").should == :all
+        end
+
+        it 'decodes LOCAL_QUORUM' do
+          Decoding.read_consistency!("\x00\x06").should == :local_quorum
+        end
+
+        it 'decodes EACH_QUORUM' do
+          Decoding.read_consistency!("\x00\x07").should == :each_quorum
+        end
+
+        it 'raises an exception for an unknown consistency' do
+          expect { Decoding.read_consistency!("\xff\xff") }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_string_map!' do
+        let :buffer do
+          "\x00\x02\x00\x05hello\x00\x05world\x00\x03foo\x00\x03bar"
+        end
+
+        it 'decodes a string multimap' do
+          Decoding.read_string_map!(buffer).should == {'hello' => 'world', 'foo' => 'bar'}
+        end
+
+        it 'decodes an empty string map' do
+          Decoding.read_string_map!("\x00\x00").should == {}
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xff"
+          Decoding.read_string_map!(buffer)
+          buffer.should == "\xff"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_string_map!(buffer.slice(0, 20)) }.to raise_error(DecodingError)
+        end
+      end
+
+      describe '#read_string_multimap!' do
+        let :buffer do
+          "\x00\x02\x00\x0bCQL_VERSION\x00\x01\x00\x053.0.0\x00\x0bCOMPRESSION\x00\x02\x00\x06snappy\x00\x04gzip"
+        end
+
+        it 'decodes a string multimap' do
+          Decoding.read_string_multimap!(buffer).should == {'CQL_VERSION' => ['3.0.0'], 'COMPRESSION' => ['snappy', 'gzip']}
+        end
+
+        it 'decodes an empty string multimap' do
+          Decoding.read_string_multimap!("\x00\x00").should == {}
+        end
+
+        it 'consumes the bytes' do
+          buffer << "\xff"
+          Decoding.read_string_multimap!(buffer)
+          buffer.should == "\xff"
+        end
+
+        it 'raises an error when there are not enough bytes in the buffer' do
+          expect { Decoding.read_string_multimap!(buffer.slice(0, 40)) }.to raise_error(DecodingError)
+        end
+      end
+    end
+  end
+end