ably-rest 1.1.2 → 1.2.2

data/lib/submodules/ably-ruby/spec/acceptance/rest/channel_spec.rb

@@ -5,11 +5,13 @@ describe Ably::Rest::Channel do
   include Ably::Modules::Conversions
 
   vary_by_protocol do
-    let(:default_options) { { key: api_key, environment: environment, protocol: protocol} }
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol, max_frame_size: max_frame_size, max_message_size: max_message_size, idempotent_rest_publishing: false } }
     let(:client_options)  { default_options }
     let(:client) do
       Ably::Rest::Client.new(client_options)
     end
+    let(:max_message_size) { nil }
+    let(:max_frame_size) { nil }
 
     describe '#publish' do
       let(:channel_name) { random_str }
@@ -40,7 +42,7 @@ describe Ably::Rest::Channel do
 
         it 'publishes the message without a client_id' do
           expect(client).to receive(:post).
-            with("/channels/#{channel_name}/publish", hash_excluding(client_id: client_id)).
+            with("/channels/#{channel_name}/publish", hash_excluding(client_id: client_id), {}).
             and_return(double('response', status: 201))
 
           expect(channel.publish(name, data)).to eql(true)
@@ -60,6 +62,9 @@ describe Ably::Rest::Channel do
         end
 
         it 'publishes an array of messages in one HTTP request' do
+          expect(client.max_message_size).to eq(Ably::Rest::Client::MAX_MESSAGE_SIZE)
+          expect(messages.sum(&:size) < Ably::Rest::Client::MAX_MESSAGE_SIZE).to eq(true)
+
           expect(client).to receive(:post).once.and_call_original
           expect(channel.publish(messages)).to eql(true)
           expect(channel.history.items.map(&:name)).to match_array(messages.map { |message| message[:name] })
@@ -68,17 +73,116 @@ describe Ably::Rest::Channel do
       end
 
       context 'with an array of Message objects' do
+        context 'when max_message_size and max_frame_size is not set' do
+          before do
+            expect(client.max_message_size).to eq(Ably::Rest::Client::MAX_MESSAGE_SIZE)
+            expect(client.max_frame_size).to eq(Ably::Rest::Client::MAX_FRAME_SIZE)
+          end
+
+          context 'and messages size (130 bytes) is smaller than the max_message_size' do
+            let(:messages) do
+              10.times.map do |index|
+                Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+              end
+            end
+
+            it 'publishes an array of messages in one HTTP request' do
+              expect(messages.sum &:size).to eq(130)
+              expect(client).to receive(:post).once.and_call_original
+              expect(channel.publish(messages)).to eql(true)
+              expect(channel.history.items.map(&:name)).to match_array(messages.map(&:name))
+              expect(channel.history.items.map(&:data)).to match_array(messages.map(&:data))
+            end
+          end
+
+          context 'and messages size (177784 bytes) is bigger than the max_message_size' do
+            let(:messages) do
+              10000.times.map do |index|
+                Ably::Models::Message(name: index.to_s, data: { "index" => index + 1 })
+              end
+            end
+
+            it 'should not publish and raise Ably::Exceptions::MaxMessageSizeExceeded' do
+              expect(messages.sum &:size).to eq(177784)
+              expect { channel.publish(messages) }.to raise_error(Ably::Exceptions::MaxMessageSizeExceeded)
+            end
+          end
+        end
+
+        context 'when max_message_size is 655 bytes' do
+          let(:max_message_size) { 655 }
+
+          before do
+            expect(client.max_message_size).to eq(max_message_size)
+            expect(client.max_frame_size).to eq(Ably::Rest::Client::MAX_FRAME_SIZE)
+          end
+
+          context 'and messages size (130 bytes) is smaller than the max_message_size' do
+            let(:messages) do
+              10.times.map do |index|
+                Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+              end
+            end
+
+            it 'publishes an array of messages in one HTTP request' do
+              expect(messages.sum &:size).to eq(130)
+              expect(client).to receive(:post).once.and_call_original
+              expect(channel.publish(messages)).to eql(true)
+              expect(channel.history.items.map(&:name)).to match_array(messages.map(&:name))
+              expect(channel.history.items.map(&:data)).to match_array(messages.map(&:data))
+            end
+          end
+
+          context 'and messages size (177784 bytes) is bigger than the max_message_size' do
+            let(:messages) do
+              10000.times.map do |index|
+                Ably::Models::Message(name: index.to_s, data: { "index" => index + 1 })
+              end
+            end
+
+            it 'should not publish and raise Ably::Exceptions::MaxMessageSizeExceeded' do
+              expect(messages.sum &:size).to eq(177784)
+              expect { channel.publish(messages) }.to raise_error(Ably::Exceptions::MaxMessageSizeExceeded)
+            end
+          end
+        end
+      end
+
+      context 'with a Message object' do
+        let(:name) { random_str }
+
+        let(:message) do
+          Ably::Models::Message(name: name, data: data)
+        end
+
+        it 'publishes the message' do
+          expect(client).to receive(:post).once.and_call_original
+          expect(channel.publish(message)).to eql(true)
+          expect(channel.history.items.first.name).to eql(name)
+        end
+      end
+
+      context 'with a Message object and query params' do
+        let(:message) do
+          Ably::Models::Message(name: name, data: data)
+        end
+
+        it 'should fail to publish the message (RSL1l1)' do
+          expect(client).to receive(:post).once.and_call_original
+          expect { channel.publish(message, { _forceNack: 'true' }) }.to raise_error(Ably::Exceptions::InvalidRequest, /40099/)
+        end
+      end
+
+      context 'with Messages and query params' do
         let(:messages) do
           10.times.map do |index|
-            Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+            { name: index.to_s, data: { "index" => index + 10 } }
           end
         end
 
-        it 'publishes an array of messages in one HTTP request' do
+        it 'should fail to publish the message (RSL1l1)' do
           expect(client).to receive(:post).once.and_call_original
-          expect(channel.publish(messages)).to eql(true)
-          expect(channel.history.items.map(&:name)).to match_array(messages.map(&:name))
-          expect(channel.history.items.map(&:data)).to match_array(messages.map(&:data))
+          expect { channel.publish(messages, { _forceNack: 'true' }) }.to raise_error(Ably::Exceptions::InvalidRequest, /40099/)
         end
       end
 
@@ -96,7 +200,7 @@ describe Ably::Rest::Channel do
           let(:data) { random_str }
 
           it 'publishes the message without a name attribute in the payload' do
-            expect(client).to receive(:post).with(anything, { "data" => data }).once.and_call_original
+            expect(client).to receive(:post).with(anything, { "data" => data }, {}).once.and_call_original
             expect(channel.publish(nil, data)).to eql(true)
             expect(channel.history.items.first.name).to be_nil
             expect(channel.history.items.first.data).to eql(data)
@@ -107,7 +211,7 @@ describe Ably::Rest::Channel do
           let(:name) { random_str }
 
           it 'publishes the message without a data attribute in the payload' do
-            expect(client).to receive(:post).with(anything, { "name" => name }).once.and_call_original
+            expect(client).to receive(:post).with(anything, { "name" => name }, {}).once.and_call_original
             expect(channel.publish(name)).to eql(true)
             expect(channel.history.items.first.name).to eql(name)
             expect(channel.history.items.first.data).to be_nil
@@ -118,7 +222,7 @@ describe Ably::Rest::Channel do
           let(:name) { random_str }
 
           it 'publishes the message without any attributes in the payload' do
-            expect(client).to receive(:post).with(anything, {}).once.and_call_original
+            expect(client).to receive(:post).with(anything, {}, {}).once.and_call_original
             expect(channel.publish(nil)).to eql(true)
             expect(channel.history.items.first.name).to be_nil
             expect(channel.history.items.first.data).to be_nil
@@ -312,6 +416,15 @@ describe Ably::Rest::Channel do
           end
         end
       end
+
+      context 'message size is exceeded (#TO3l8)' do
+        let(:data) { 101.times.map { { data: 'x' * 655 } } }
+
+        it 'should raise Ably::Exceptions::MaxMessageSizeExceeded exception' do
+          expect { channel.publish([ data: data ]) }.to \
+            raise_error(Ably::Exceptions::MaxMessageSizeExceeded)
+        end
+      end
     end
 
     describe '#history' do
@@ -482,5 +595,23 @@ describe Ably::Rest::Channel do
         expect(channel.presence).to be_a(Ably::Rest::Presence)
       end
     end
+
+    context '#status' do
+      let(:channel_name) { "persisted:#{random_str(4)}" }
+      let(:channel) { client.channel(channel_name) }
+      let(:channel_details) { channel.status }
+
+      it 'should return channel details status (#RSL8, #RSL8a)' do
+        expect(channel_details.channel_id).to eq(channel_name)
+        expect(channel_details.name).to eq(channel_name)
+        expect(channel_details.status).to be_a(Ably::Models::ChannelStatus)
+        expect(channel_details.status.is_active).to eq(true)
+        expect(channel_details.status.occupancy.metrics.publishers).to eq(0)
+        expect(channel_details.status.occupancy.metrics.subscribers).to eq(0)
+        expect(channel_details.status.occupancy.metrics.presence_connections).to eq(0)
+        expect(channel_details.status.occupancy.metrics.presence_members).to eq(0)
+        expect(channel_details.status.occupancy.metrics.presence_subscribers).to eq(0)
+      end
+    end
   end
 end

data/lib/submodules/ably-ruby/spec/acceptance/rest/channels_spec.rb

@@ -5,11 +5,11 @@ describe Ably::Rest::Channels do
   shared_examples 'a channel' do
     it 'returns a channel object' do
       expect(channel).to be_a Ably::Rest::Channel
-      expect(channel.name).to eql(channel_name)
+      expect(channel.name).to eq(channel_name)
     end
 
     it 'returns channel object and passes the provided options' do
-      expect(channel_with_options.options).to eql(options)
+      expect(channel_with_options.options.to_h).to eq(options)
     end
   end
 
@@ -32,12 +32,29 @@ describe Ably::Rest::Channels do
       it_behaves_like 'a channel'
     end
 
+    describe '#set_options (#RTL16)' do
+      let(:channel) { client.channel(channel_name) }
+
+      it "updates channel's options" do
+        expect { channel.options = options }.to change { channel.options.to_h }.from({}).to(options)
+      end
+
+      context 'when providing Ably::Models::ChannelOptions object' do
+        let(:options_object) { Ably::Models::ChannelOptions.new(options) }
+
+        it "updates channel's options" do
+          expect { channel.options =  options_object}.to change { channel.options.to_h }.from({}).to(options)
+        end
+      end
+    end
+
     describe 'accessing an existing channel object with different options' do
       let(:new_channel_options) { { encrypted: true } }
       let(:original_channel)    { client.channels.get(channel_name, options) }
 
-      it 'overrides the existing channel options and returns the channel object' do
-        expect(original_channel.options).to_not include(:encrypted)
+      it 'overrides the existing channel options and returns the channel object (RSN3c)' do
+        expect(original_channel.options.to_h).to_not include(:encrypted)
+
         new_channel = client.channels.get(channel_name, new_channel_options)
         expect(new_channel).to be_a(Ably::Rest::Channel)
         expect(new_channel.options[:encrypted]).to eql(true)
@@ -48,10 +65,10 @@ describe Ably::Rest::Channels do
       let(:original_channel) { client.channels.get(channel_name, options) }
 
       it 'returns the existing channel without modifying the channel options' do
-        expect(original_channel.options).to eql(options)
+        expect(original_channel.options.to_h).to eq(options)
         new_channel = client.channels.get(channel_name)
         expect(new_channel).to be_a(Ably::Rest::Channel)
-        expect(original_channel.options).to eql(options)
+        expect(original_channel.options.to_h).to eq(options)
       end
     end
 

data/lib/submodules/ably-ruby/spec/acceptance/rest/client_spec.rb

@@ -12,7 +12,7 @@ describe Ably::Rest::Client do
     http_defaults = Ably::Rest::Client::HTTP_DEFAULTS
 
     def encode64(text)
-      Base64.encode64(text).gsub("\n", '')
+      Base64.urlsafe_encode64(text)
     end
 
     context '#initialize' do
@@ -56,14 +56,6 @@ describe Ably::Rest::Client do
         end
       end
 
-      context 'with a :client_id configured' do
-        let(:client) { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: random_str)) }
-
-        it 'uses token authentication' do
-          expect(client.auth).to be_using_token_auth
-        end
-      end
-
       context 'with a non string :client_id' do
         let(:client) { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: 1)) }
 
@@ -144,11 +136,12 @@ describe Ably::Rest::Client do
         let(:history_querystring) { history_params.map { |k, v| "#{k}=#{v}" }.join("&") }
 
         context 'with basic auth', webmock: true do
-          let(:client_options)      { default_options.merge(key: api_key) }
+          let(:client_options)      { default_options.merge(key: api_key, client_id: client_id) }
 
           let!(:get_message_history_stub) do
-            stub_request(:get, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}").
-              to_return(body: [], headers: { 'Content-Type' => 'application/json' })
+            stub_request(:get, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}")
+              .with(headers: { 'X-Ably-ClientId' => encode64(client_id) })
+              .to_return(body: [], headers: { 'Content-Type' => 'application/json' })
           end
 
           it 'sends the API key in authentication part of the secure URL (the Authorization: Basic header is not used with the Faraday HTTP library by default)' do
@@ -308,30 +301,44 @@ describe Ably::Rest::Client do
       context 'configured' do
         let(:client_options) { default_options.merge(key: api_key, environment: 'production') }
 
-        it 'should make connection attempts to A.ably-realtime.com, B.ably-realtime.com, C.ably-realtime.com, D.ably-realtime.com, E.ably-realtime.com (#RSC15a)' do
+        it 'should make connection attempts to a.ably-realtime.com, b.ably-realtime.com, c.ably-realtime.com, d.ably-realtime.com, e.ably-realtime.com (#RSC15a)' do
           hosts = []
           5.times do
             hosts << client.fallback_connection.host
           end
-          expect(hosts).to match_array(%w(A.ably-realtime.com B.ably-realtime.com C.ably-realtime.com D.ably-realtime.com E.ably-realtime.com))
+          expect(hosts).to match_array(%w(a.ably-realtime.com b.ably-realtime.com c.ably-realtime.com d.ably-realtime.com e.ably-realtime.com))
         end
       end
 
       context 'when environment is NOT production (#RSC15b)' do
-        let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key) }
-        let!(:default_host_request_stub) do
-          stub_request(:post, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
-            raise Faraday::TimeoutError.new('timeout error message')
+        context 'and custom fallback hosts are empty' do
+          let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key, fallback_hosts: []) }
+          let!(:default_host_request_stub) do
+            stub_request(:post, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+              raise Faraday::TimeoutError.new('timeout error message')
+            end
+          end
+
+          it 'does not retry failed requests with fallback hosts when there is a connection error' do
+            expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionTimeout
           end
         end
 
-        it 'does not retry failed requests with fallback hosts when there is a connection error' do
-          expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionTimeout
+        context 'and no custom fallback hosts are provided' do
+          let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key) }
+
+          it 'should make connection attempts to sandbox-a-fallback.ably-realtime.com, sandbox-b-fallback.ably-realtime.com, sandbox-c-fallback.ably-realtime.com, sandbox-d-fallback.ably-realtime.com, sandbox-e-fallback.ably-realtime.com (#RSC15a)' do
+            hosts = []
+            5.times do
+              hosts << client.fallback_connection.host
+            end
+            expect(hosts).to match_array(%w(a b c d e).map { |id| "sandbox-#{id}-fallback.ably-realtime.com" })
+          end
         end
       end
 
       context 'when environment is production' do
-        let(:custom_hosts)       { %w(A.ably-realtime.com B.ably-realtime.com) }
+        let(:custom_hosts)       { %w(a.ably-realtime.com b.ably-realtime.com) }
         let(:max_retry_count)    { 2 }
         let(:max_retry_duration) { 0.5 }
         let(:fallback_block)     { proc { raise Faraday::SSLError.new('ssl error message') } }
@@ -830,11 +837,12 @@ describe Ably::Rest::Client do
       end
 
       context 'when environment is not production and server returns a 50x error' do
+        let(:env)                { 'custom-env' }
+        let(:default_fallbacks)  { %w(a b c d e).map { |id| "#{env}-#{id}-fallback.ably-realtime.com" } }
         let(:custom_hosts)       { %w(A.foo.com B.foo.com) }
         let(:max_retry_count)    { 2 }
         let(:max_retry_duration) { 0.5 }
         let(:fallback_block)     { proc { raise Faraday::SSLError.new('ssl error message') } }
-        let(:env)                { 'custom-env' }
         let(:production_options) do
           default_options.merge(
             environment: env,
@@ -858,6 +866,26 @@ describe Ably::Rest::Client do
           stub_request(:post, "https://#{env}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
         end
 
+        context 'with no fallback hosts provided (#TBC, see https://github.com/ably/wiki/issues/361)' do
+          let(:client_options) {
+            production_options.merge(log_level: :fatal)
+          }
+
+          it 'uses the default fallback hosts for that environment as this is not an authentication failure' do
+            fallbacks_called_count = 0
+            default_fallbacks.each do |host|
+              counting_fallback_proc = proc do
+                fallbacks_called_count += 1
+                fallback_block.call
+              end
+              stub_request(:post, "https://#{host}#{path}").to_return(&counting_fallback_proc)
+            end
+            expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
+            expect(default_host_request_stub).to have_been_requested
+            expect(fallbacks_called_count).to be >= 2
+          end
+        end
+
         context 'with custom fallback hosts provided (#RSC15b, #TO3k6)' do
           let!(:first_fallback_request_stub) do
             stub_request(:post, "https://#{custom_hosts[0]}#{path}").to_return(&fallback_block)
@@ -1053,29 +1081,15 @@ describe Ably::Rest::Client do
     end
 
     context 'version headers', :webmock do
-      [nil, 'foo'].each do |variant|
-        context "with variant #{variant ? variant : 'none'}" do
-          if variant
-            before do
-              Ably.lib_variant = variant
-            end
+      [nil, 'ably-ruby/1.1.1 ruby/3.1.1'].each do |agent|
+        context "with #{agent ? "custom #{agent}" : 'default'} agent" do
+          let(:client_options) { default_options.merge(key: api_key, agent: agent) }
 
-            after do
-              Ably.lib_variant = nil
-            end
-          end
-
-          let(:client_options) { default_options.merge(key: api_key) }
           let!(:publish_message_stub) do
-            lib = ['ruby']
-            lib << variant if variant
-            lib << Ably::VERSION
-
-
             stub_request(:post, "#{client.endpoint}/channels/foo/publish").
               with(headers: {
                 'X-Ably-Version' => Ably::PROTOCOL_VERSION,
-                'X-Ably-Lib' => lib.join('-')
+                'Ably-Agent' => agent || Ably::AGENT
               }).
               to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
           end
@@ -1083,14 +1097,16 @@ describe Ably::Rest::Client do
           it 'sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)' do
             client.channels.get('foo').publish("event")
             expect(publish_message_stub).to have_been_requested
-            expect(Ably::PROTOCOL_VERSION).to eql('1.1')
+            expect(Ably::PROTOCOL_VERSION).to eql('1.2')
           end
         end
       end
     end
 
-    context '#request (#RSC19*)' do
+    context '#request (#RSC19*, #TO3l9)' do
       let(:client_options) { default_options.merge(key: api_key) }
+      let(:device_id) { random_str }
+      let(:endpoint) { client.endpoint }
 
       context 'get' do
         it 'returns an HttpPaginatedResponse object' do
@@ -1130,13 +1146,96 @@ describe Ably::Rest::Client do
           end
         end
       end
+
+      context 'post', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/deviceRegistrations/#{device_id}/resetUpdateToken").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports post' do
+          response = client.request(:delete, "push/deviceRegistrations/#{device_id}/resetUpdateToken")
+
+          expect(response).to be_success
+        end
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:post, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        end
+      end
+
+      context 'delete', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/channelSubscriptions?deviceId=#{device_id}").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports delete' do
+          response = client.request(:delete, "/push/channelSubscriptions", { deviceId: device_id})
+
+          expect(response).to be_success
+        end
+      end
+
+      context 'patch', :webmock do
+        let(:body_params) { { 'metadata' => { 'key' => 'value' } } }
+
+        before do
+          stub_request(:patch, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports patch' do
+          response = client.request(:patch, "/push/deviceRegistrations/#{device_id}", {}, body_params)
+
+          expect(response).to be_success
+        end
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:patch, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        end
+      end
+
+      context 'put', :webmock do
+        let(:body_params) do
+          {
+            'id' => random_str,
+            'platform' => 'ios',
+            'formFactor' => 'phone',
+            'metadata' => { 'key' => 'value' }
+          }
+        end
+
+        before do
+          stub_request(:put, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports put' do
+          response = client.request(:put, "/push/deviceRegistrations/#{device_id}", {}, body_params)
+
+          expect(response).to be_success
+        end
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:put, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        end
+      end
     end
 
-    context 'request_id generation' do
+    context 'request_id generation (#RSC7c)' do
       context 'Timeout error' do
-        context 'with option add_request_ids: true', :webmock, :prevent_log_stubbing do
+        context 'with option add_request_ids: true and no fallback hosts', :webmock, :prevent_log_stubbing do
           let(:custom_logger_object) { TestLogger.new }
-          let(:client_options) { default_options.merge(key: api_key, logger: custom_logger_object, add_request_ids: true) }
+          let(:client_options) { default_options.merge(key: api_key, logger: custom_logger_object, add_request_ids: true, fallback_hosts: []) }
 
           before do
             @request_id = nil
@@ -1226,8 +1325,8 @@ describe Ably::Rest::Client do
           end
         end
 
-        context 'without request_id' do
-          let(:client_options) { default_options.merge(key: api_key, http_request_timeout: 0) }
+        context 'without request_id and no fallback hosts' do
+          let(:client_options) { default_options.merge(key: api_key, http_request_timeout: 0, fallback_hosts: []) }
 
           it 'does not include request_id in ConnectionTimeout error' do
             begin

data/lib/submodules/ably-ruby/spec/acceptance/rest/message_spec.rb

@@ -24,6 +24,57 @@ describe Ably::Rest::Channel, 'messages' do
       end
     end
 
+    context 'a single Message object (#RSL1a)' do
+      let(:name) { random_str }
+      let(:data) { random_str }
+      let(:message) { Ably::Models::Message.new(name: name, data: data) }
+
+      it 'publishes the message' do
+        channel.publish(message)
+        expect(channel.history.items.length).to eql(1)
+        message = channel.history.items.first
+        expect(message.name).to eq(name)
+        expect(message.data).to eq(data)
+      end
+    end
+
+    context 'an array of Message objects (#RSL1a)' do
+      let(:data) { random_str }
+      let(:message1) { Ably::Models::Message.new(name: random_str, data: data) }
+      let(:message2) { Ably::Models::Message.new(name: random_str, data: data) }
+      let(:message3) { Ably::Models::Message.new(name: random_str, data: data) }
+
+      it 'publishes three messages' do
+        channel.publish([message1, message2, message3])
+        expect(channel.history.items.length).to eql(3)
+      end
+    end
+
+    context 'an array of hashes (#RSL1a)' do
+      let(:data) { random_str }
+      let(:message1) { { name: random_str, data: data } }
+      let(:message2) { { name: random_str, data: data } }
+      let(:message3) { { name: random_str, data: data } }
+
+      it 'publishes three messages' do
+        channel.publish([message1, message2, message3])
+        expect(channel.history.items.length).to eql(3)
+      end
+    end
+
+    context 'a name with data payload (#RSL1a, #RSL1b)' do
+      let(:name) { random_str }
+      let(:data) { random_str }
+
+      it 'publishes the message' do
+        channel.publish(name, data)
+        expect(channel.history.items.length).to eql(1)
+        message = channel.history.items.first
+        expect(message.name).to eq(name)
+        expect(message.data).to eq(data)
+      end
+    end
+
     context 'with supported data payload content type' do
       context 'JSON Object (Hash)' do
         let(:data) { { 'Hash' => 'true' } }
@@ -153,13 +204,20 @@ describe Ably::Rest::Channel, 'messages' do
         end
       end
 
-      specify 'idempotent publishing is disabled by default with 1.1 (#TO3n)' do
+      specify 'idempotent publishing is disabled by default with <= 1.1 (#TO3n)' do
+        stub_const 'Ably::PROTOCOL_VERSION', '1.0'
+        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
+        expect(client.idempotent_rest_publishing).to be_falsey
+        stub_const 'Ably::PROTOCOL_VERSION', '1.1'
         client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
         expect(client.idempotent_rest_publishing).to be_falsey
       end
 
-      specify 'idempotent publishing is enabled by default with 1.2 (#TO3n)' do
-        stub_const 'Ably::VERSION', '1.2.0'
+      specify 'idempotent publishing is enabled by default with >= 1.2 (#TO3n)' do
+        stub_const 'Ably::PROTOCOL_VERSION', '1.2'
+        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
+        expect(client.idempotent_rest_publishing).to be_truthy
+        stub_const 'Ably::PROTOCOL_VERSION', '1.3'
         client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
         expect(client.idempotent_rest_publishing).to be_truthy
       end