ably-rest 1.1.7 → 1.1.8

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 } }
     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 }
@@ -60,7 +62,8 @@ describe Ably::Rest::Channel do
         end
 
         it 'publishes an array of messages in one HTTP request' do
-          expect(messages.sum(&:size) < Ably::Rest::Channel::MAX_MESSAGE_SIZE).to eq(true)
+          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)
@@ -70,19 +73,78 @@ describe Ably::Rest::Channel do
       end
 
       context 'with an array of Message objects' do
-        let(:messages) do
-          10.times.map do |index|
-            Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+        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
 
-        it 'publishes an array of messages in one HTTP request' do
-          expect(messages.sum(&:size) < Ably::Rest::Channel::MAX_MESSAGE_SIZE).to eq(true)
+        context 'when max_message_size is 655 bytes' do
+          let(:max_message_size) { 655 }
 
-          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))
+          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
 

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

@@ -36,7 +36,7 @@ describe Ably::Rest::Channels 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
+      it 'overrides the existing channel options and returns the channel object (RSN3c)' do
         expect(original_channel.options).to_not include(:encrypted)
         new_channel = client.channels.get(channel_name, new_channel_options)
         expect(new_channel).to be_a(Ably::Rest::Channel)

data/lib/submodules/ably-ruby/spec/support/test_app.rb

@@ -59,7 +59,7 @@ class TestApp
 
     url = "#{sandbox_client.endpoint}/apps/#{app_id}"
 
-    basic_auth = Base64.encode64(api_key).chomp
+    basic_auth = Base64.urlsafe_encode64(api_key).chomp
     headers    = { "Authorization" => "Basic #{basic_auth}" }
 
     Faraday.delete(url, nil, headers)

data/lib/submodules/ably-ruby/spec/unit/models/delta_extras_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Models::DeltaExtras do
+  subject { described_class.new({ format: 'vcdiff', from: '1234-4567-8910-1001-1111'}) }
+
+  it 'should have `from` attribute' do
+    expect(subject.from).to eq('1234-4567-8910-1001-1111')
+  end
+
+  it 'should have `format` attribute' do
+    expect(subject.format).to eq('vcdiff')
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/models/error_info_spec.rb

@@ -5,7 +5,7 @@ describe Ably::Models::ErrorInfo do
   subject { Ably::Models::ErrorInfo }
 
   context '#TI1, #TI4' do
-    it_behaves_like 'a model', with_simple_attributes: %w(code status_code href message) do
+    it_behaves_like 'a model', with_simple_attributes: %w(code status_code href message request_id cause) do
       let(:model_args) { [] }
     end
   end
@@ -18,6 +18,22 @@ describe Ably::Models::ErrorInfo do
     end
   end
 
+  context '#request_id #RSC7c' do
+    subject { Ably::Models::ErrorInfo.new('request_id' => '123-456-789-001') }
+
+    it 'should return request ID' do
+      expect(subject.request_id).to eql('123-456-789-001')
+    end
+  end
+
+  context '#cause #TI1' do
+    subject { Ably::Models::ErrorInfo.new('cause' => Ably::Models::ErrorInfo.new({})) }
+
+    it 'should return cause attribute' do
+      expect(subject.cause).to be_kind_of(Ably::Models::ErrorInfo)
+    end
+  end
+
   context 'log entries container help link #TI5' do
     context 'without an error code' do
       subject { Ably::Models::ErrorInfo.new('statusCode' => 401) }

data/lib/submodules/ably-ruby/spec/unit/models/message_spec.rb

@@ -606,4 +606,28 @@ describe Ably::Models::Message do
       end
     end
   end
+
+  context '#delta_extras (TM2i)' do
+    let(:delta_extras) { message.delta_extras }
+
+    context 'when delta' do
+      let(:message) { subject.new({ extras: { delta: { from: '1234-1234-5678-9009', format: 'vcdiff' } } }) }
+
+      it 'should return vcdiff format' do
+        expect(delta_extras.format).to eq('vcdiff')
+      end
+
+      it 'should return 1234-1234-5678-9009 message id' do
+        expect(delta_extras.from).to eq('1234-1234-5678-9009')
+      end
+    end
+
+    context 'when no delta' do
+      let(:message) { subject.new({ extras: {} }) }
+
+      it 'should return nil' do
+        expect(delta_extras).to eq(nil)
+      end
+    end
+  end
 end

data/lib/submodules/ably-ruby/spec/unit/models/protocol_message_spec.rb

@@ -10,9 +10,9 @@ describe Ably::Models::ProtocolMessage do
     subject.new({ action: 1 }.merge(options))
   end
 
-  # TR4n, TR4b, TR4c, TR4d, TR4e
+  # TR4n, TR4b, TR4c, TR4d
   it_behaves_like 'a model',
-    with_simple_attributes: %w(id channel channel_serial connection_id connection_key),
+    with_simple_attributes: %w(id channel channel_serial connection_id),
     base_model_options: { action: 1 } do
 
     let(:model_args) { [] }
@@ -176,6 +176,28 @@ describe Ably::Models::ProtocolMessage do
         end
       end
 
+      context 'when attach resumed flag' do
+        context 'flags is 34' do
+          let(:protocol_message) { new_protocol_message(flags: 34) }
+
+          it '#has_attach_resume_flag? is true' do
+            expect(protocol_message.has_attach_resume_flag?).to be_truthy
+          end
+
+          it '#has_attach_presence_flag? is false' do
+            expect(protocol_message.has_attach_presence_flag?).to be_falsey
+          end
+        end
+
+        context 'flags is 0' do
+          let(:protocol_message) { new_protocol_message(flags: 0) }
+
+          it 'should raise an exception if flags is a float number' do
+            expect(protocol_message.has_attach_resume_flag?).to be_falsy
+          end
+        end
+      end
+
       context 'when channel resumed and presence flags present' do
         let(:protocol_message) { new_protocol_message(flags: 5) }
 
@@ -417,24 +439,6 @@ describe Ably::Models::ProtocolMessage do
         end
       end
     end
-
-    context '#connection_key (#TR4e)' do
-      context 'existing only in #connection_details.connection_key' do
-        let(:protocol_message) { new_protocol_message(connectionDetails: { connectionKey: 'key' }) }
-
-        it 'is returned' do
-          expect(protocol_message.connection_key).to eql('key')
-        end
-      end
-
-      context 'existing in both #connection_key and #connection_details.connection_key' do
-        let(:protocol_message) { new_protocol_message(connectionKey: 'deprecated', connectionDetails: { connectionKey: 'key' }) }
-
-        it 'returns #connection_details.connection_key as #connection_key will be deprecated > 0.8' do
-          expect(protocol_message.connection_key).to eql('key')
-        end
-      end
-    end
   end
 
   context '#to_json', :api_private do

data/lib/submodules/ably-ruby/spec/unit/realtime/channel_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 require 'shared/protocol_msgbus_behaviour'
 
 describe Ably::Realtime::Channel do
-  let(:client)       { double('client').as_null_object }
+  let(:client)       { Ably::Realtime::Client.new(token: 'valid') }
   let(:channel_name) { 'test' }
 
   subject do
@@ -71,6 +71,7 @@ describe Ably::Realtime::Channel do
     let(:message) { instance_double('Ably::Models::Message', client_id: nil, size: 0) }
 
     before do
+      allow(subject).to receive(:enqueue_messages_on_connection).and_return(message)
       allow(subject).to receive(:create_message).and_return(message)
       allow(subject).to receive(:attach).and_return(:true)
     end

data/lib/submodules/ably-ruby/spec/unit/realtime/channels_spec.rb

@@ -11,19 +11,19 @@ describe Ably::Realtime::Channels do
 
   context 'creating channels' do
     context '#get' do
-      it 'creates a channel if it does not exist' do
+      it 'creates a channel if it does not exist (RSN3a)' do
         expect(Ably::Realtime::Channel).to receive(:new).with(client, channel_name, options)
         subject.get(channel_name, options)
       end
 
       context 'when an existing channel exists' do
-        it 'will reuse a channel object if it exists' do
+        it 'will reuse a channel object if it exists (RSN3a)' do
           channel = subject.get(channel_name, options)
           expect(channel).to be_a(Ably::Realtime::Channel)
           expect(subject.get(channel_name, options).object_id).to eql(channel.object_id)
         end
 
-        it 'will update the options on the channel if provided' do
+        it 'will update the options on the channel if provided (RSN3c)' do
           channel = subject.get(channel_name, options)
           expect(channel.options).to eql(options)
           expect(channel.options).to_not include(:encrypted)

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

@@ -7,17 +7,14 @@ describe Ably::Rest::Channel do
       'Ably::Rest::Client',
       encoders: [],
       post: instance_double('Faraday::Response', status: 201),
-      idempotent_rest_publishing: false,
+      idempotent_rest_publishing: false, max_message_size: max_message_size
     )
   end
   let(:channel_name) { 'unique' }
+  let(:max_message_size) { nil }
 
   subject { Ably::Rest::Channel.new(client, channel_name) }
 
-  it 'should return Ably::Rest::Channel::MAX_MESSAGE_SIZE equal 65536 (TO3l8)' do
-    expect(Ably::Rest::Channel::MAX_MESSAGE_SIZE).to eq(65536)
-  end
-
   describe '#initializer' do
     let(:channel_name) { random_str.encode(encoding) }
 
@@ -132,8 +129,44 @@ describe Ably::Rest::Channel do
     end
 
     context 'max message size exceeded' do
-      it 'should raise Ably::Exceptions::MaxMessageSizeExceeded' do
-        expect { subject.publish('x' * 65537, 'data') }.to raise_error Ably::Exceptions::MaxMessageSizeExceeded
+      context 'when max_message_size is nil' do
+        context 'and a message size is 65537 bytes' do
+          it 'should raise Ably::Exceptions::MaxMessageSizeExceeded' do
+            expect { subject.publish('x' * 65537, 'data') }.to raise_error Ably::Exceptions::MaxMessageSizeExceeded
+          end
+        end
+      end
+
+      context 'when max_message_size is 65536 bytes' do
+        let(:max_message_size) { 65536 }
+
+        context 'and a message size is 65537 bytes' do
+          it 'should raise Ably::Exceptions::MaxMessageSizeExceeded' do
+            expect { subject.publish('x' * 65537, 'data') }.to raise_error Ably::Exceptions::MaxMessageSizeExceeded
+          end
+        end
+
+        context 'and a message size is 10 bytes' do
+          it 'should send a message' do
+            expect(subject.publish('x' * 10, 'data')).to eq(true)
+          end
+        end
+      end
+
+      context 'when max_message_size is 10 bytes' do
+        let(:max_message_size) { 10 }
+
+        context 'and a message size is 11 bytes' do
+          it 'should raise Ably::Exceptions::MaxMessageSizeExceeded' do
+            expect { subject.publish('x' * 11, 'data') }.to raise_error Ably::Exceptions::MaxMessageSizeExceeded
+          end
+        end
+
+        context 'and a message size is 2 bytes' do
+          it 'should send a message' do
+            expect(subject.publish('x' * 2, 'data')).to eq(true)
+          end
+        end
       end
     end
   end

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

@@ -87,6 +87,33 @@ describe Ably::Rest::Client do
         end
       end
     end
+
+    context 'max_message_size' do
+      context 'is not present' do
+        let(:client_options) { { key: 'appid.keyuid:keysecret' } }
+
+        it 'should return default 65536 (#TO3l8)' do
+          expect(subject.max_message_size).to eq(Ably::Rest::Client::MAX_MESSAGE_SIZE)
+        end
+      end
+
+      context 'is nil' do
+        let(:client_options) { { key: 'appid.keyuid:keysecret', max_message_size: nil } }
+
+        it 'should return default 65536 (#TO3l8)' do
+          expect(Ably::Rest::Client::MAX_MESSAGE_SIZE).to eq(65536)
+          expect(subject.max_message_size).to eq(Ably::Rest::Client::MAX_MESSAGE_SIZE)
+        end
+      end
+
+      context 'is customized 131072 bytes' do
+        let(:client_options) { { key: 'appid.keyuid:keysecret', max_message_size: 131072 } }
+
+        it 'should return 131072' do
+          expect(subject.max_message_size).to eq(131072)
+        end
+      end
+    end
   end
 
   context 'request_id generation' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ably-rest
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 1.1.8
 platform: ruby
 authors:
 - Matthew O'Riordan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-04 00:00:00.000000000 Z
+date: 2022-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -294,6 +294,7 @@ files:
 - lib/submodules/ably-ruby/lib/ably/models/cipher_params.rb
 - lib/submodules/ably-ruby/lib/ably/models/connection_details.rb
 - lib/submodules/ably-ruby/lib/ably/models/connection_state_change.rb
+- lib/submodules/ably-ruby/lib/ably/models/delta_extras.rb
 - lib/submodules/ably-ruby/lib/ably/models/device_details.rb
 - lib/submodules/ably-ruby/lib/ably/models/device_push_details.rb
 - lib/submodules/ably-ruby/lib/ably/models/error_info.rb
@@ -431,6 +432,7 @@ files:
 - lib/submodules/ably-ruby/spec/unit/models/cipher_params_spec.rb
 - lib/submodules/ably-ruby/spec/unit/models/connection_details_spec.rb
 - lib/submodules/ably-ruby/spec/unit/models/connection_state_change_spec.rb
+- lib/submodules/ably-ruby/spec/unit/models/delta_extras_spec.rb
 - lib/submodules/ably-ruby/spec/unit/models/device_details_spec.rb
 - lib/submodules/ably-ruby/spec/unit/models/device_push_details_spec.rb
 - lib/submodules/ably-ruby/spec/unit/models/error_info_spec.rb