ably-rest 0.9.3 → 1.0.0

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

@@ -6,6 +6,7 @@ describe Ably::Models::ConnectionDetails do
 
   subject { Ably::Models::ConnectionDetails }
 
+  # Spec model items CD2*
   it_behaves_like 'a model', with_simple_attributes: %w(client_id connection_key max_message_size max_frame_size max_inbound_rate) do
     let(:model_args) { [] }
   end
@@ -13,13 +14,23 @@ describe Ably::Models::ConnectionDetails do
   context 'attributes' do
     let(:connection_state_ttl_ms) { 5_000 }
 
-    context '#connection_state_ttl' do
+    context '#connection_state_ttl (#CD2f)' do
       subject { Ably::Models::ConnectionDetails.new({ connection_state_ttl: connection_state_ttl_ms }) }
 
       it 'retrieves attribute :connection_state_ttl and converts it from ms to s' do
         expect(subject.connection_state_ttl).to eql(connection_state_ttl_ms / 1000)
       end
     end
+
+    let(:max_idle_interval) { 6_000 }
+
+    context '#max_idle_interval (#CD2h)' do
+      subject { Ably::Models::ConnectionDetails.new({ max_idle_interval: max_idle_interval }) }
+
+      it 'retrieves attribute :max_idle_interval and converts it from ms to s' do
+        expect(subject.max_idle_interval).to eql(max_idle_interval / 1000)
+      end
+    end
   end
 
   context '==' do

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

@@ -6,7 +6,7 @@ describe Ably::Models::ConnectionStateChange do
 
   subject { Ably::Models::ConnectionStateChange }
 
-  context '#current' do
+  context '#current (#TA2)' do
     it 'is required' do
       expect { subject.new(previous: true) }.to raise_error ArgumentError
     end
@@ -16,7 +16,7 @@ describe Ably::Models::ConnectionStateChange do
     end
   end
 
-  context '#previous' do
+  context '#previous(#TA2)' do
     it 'is required' do
       expect { subject.new(current: true) }.to raise_error ArgumentError
     end
@@ -26,7 +26,18 @@ describe Ably::Models::ConnectionStateChange do
     end
   end
 
-  context '#retry_in' do
+  context '#event(#TA5)' do
+    it 'is not required' do
+      expect { subject.new(previous: true, current: true) }.to_not raise_error
+    end
+
+    it 'is an attribute' do
+      expect(subject.new(event: unique, current: true, previous: true).event).to eql(unique)
+    end
+  end
+
+
+  context '#retry_in (#TA2)' do
     it 'is not required' do
       expect { subject.new(previous: true, current: true) }.to_not raise_error
     end
@@ -36,7 +47,7 @@ describe Ably::Models::ConnectionStateChange do
     end
   end
 
-  context '#reason' do
+  context '#reason (#TA3)' do
     it 'is not required' do
       expect { subject.new(previous: true, current: true) }.to_not raise_error
     end

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

@@ -25,6 +25,38 @@ describe Ably::Models::Message do
     end
   end
 
+  context '#extras (#TM2i)' do
+    let(:model) { subject.new({ extras: extras }, protocol_message: protocol_message) }
+
+    context 'when missing' do
+      let(:model) { subject.new({}, protocol_message: protocol_message) }
+      it 'is nil' do
+        expect(model.extras).to be_nil
+      end
+    end
+
+    context 'when a string' do
+      let(:extras) { 'string' }
+      it 'raises an exception' do
+        expect { model.extras }.to raise_error ArgumentError, /extras contains an unsupported type/
+      end
+    end
+
+    context 'when a Hash' do
+      let(:extras) { { key: 'value' } }
+      it 'contains a Hash Json object' do
+        expect(model.extras).to eq(extras)
+      end
+    end
+
+    context 'when a Json Array' do
+      let(:extras) { [{ 'key' => 'value' }] }
+      it 'contains a Json Array object' do
+        expect(model.extras).to eq(extras)
+      end
+    end
+  end
+
   context '#connection_id attribute' do
     let(:protocol_connection_id) { random_str }
     let(:protocol_message) { Ably::Models::ProtocolMessage.new('connectionId' => protocol_connection_id, action: 1, timestamp: protocol_message_timestamp) }
@@ -380,7 +412,7 @@ describe Ably::Models::Message do
     end
   end
 
-  context '#from_encoded (TM3)' do
+  context '#from_encoded (#TM3)' do
     context 'with no encoding' do
       let(:message_data) do
         { name: 'name', data: 'data-string' }
@@ -482,7 +514,7 @@ describe Ably::Models::Message do
     end
   end
 
-  context '#from_encoded_array (TM3)' do
+  context '#from_encoded_array (#TM3)' do
     context 'with no encoding' do
       let(:message_data) do
         [{ name: 'name1', data: 'data-string' }, { name: 'name2', data: 'data-string' }]

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

@@ -385,7 +385,7 @@ describe Ably::Models::PresenceMessage do
   end
 
 
-  context '#from_encoded (TP4)' do
+  context '#from_encoded (#TP4)' do
     context 'with no encoding' do
       let(:message_data) do
         { action: 2, data: 'data-string' }
@@ -486,7 +486,7 @@ describe Ably::Models::PresenceMessage do
     end
   end
 
-  context '#from_encoded_array (TP4)' do
+  context '#from_encoded_array (#TP4)' do
     context 'with no encoding' do
       let(:message_data) do
         [{ action: 1, data: 'data-string' }, { action: 2, data: 'data-string' }]
@@ -504,4 +504,75 @@ describe Ably::Models::PresenceMessage do
       end
     end
   end
+
+  context '#shallow_clone' do
+    context 'with inherited attributes from ProtocolMessage' do
+      let(:protocol_message) {
+        Ably::Models::ProtocolMessage.new('id' => 'fooId', 'connectionId' => protocol_connection_id, 'action' =>  1, 'timestamp' => protocol_message_timestamp)
+      }
+      let(:protocol_connection_id) { random_str }
+      let(:model) { subject.new({ 'action' => 2 }, protocol_message: protocol_message) }
+
+      it 'creates a duplicate of the message without any ProtocolMessage dependency' do
+        clone = model.shallow_clone
+        expect(clone.id).to match(/fooId/)
+        expect(clone.connection_id).to eql(protocol_connection_id)
+        expect(as_since_epoch(clone.timestamp)).to eq(protocol_message_timestamp)
+        expect(clone.action).to eq(2)
+      end
+    end
+
+    context 'with embedded attributes for all fields' do
+      let(:message_timestamp) { as_since_epoch(Time.now) + 100 }
+      let(:connection_id) { random_str }
+      let(:model) { subject.new({ 'action' => 3, 'id' => 'fooId', 'connectionId' => connection_id, 'timestamp' => message_timestamp }) }
+
+      it 'creates a duplicate of the message without any ProtocolMessage dependency' do
+        clone = model.shallow_clone
+        expect(clone.id).to eql('fooId')
+        expect(clone.connection_id).to eql(connection_id)
+        expect(as_since_epoch(clone.timestamp)).to eq(message_timestamp)
+        expect(clone.action).to eq(3)
+      end
+    end
+
+    context 'with new attributes passed in to the method' do
+      let(:protocol_message) {
+        Ably::Models::ProtocolMessage.new('id' => 'fooId', 'connectionId' => protocol_connection_id, 'action' =>  1, 'timestamp' => protocol_message_timestamp)
+      }
+      let(:protocol_connection_id) { random_str }
+      let(:model) { subject.new({ 'action' => 2 }, protocol_message: protocol_message) }
+
+      it 'creates a duplicate of the message without any ProtocolMessage dependency' do
+        clone = model.shallow_clone(id: 'newId', action: 1, timestamp: protocol_message_timestamp + 1000)
+        expect(clone.id).to match(/newId/)
+        expect(clone.connection_id).to eql(protocol_connection_id)
+        expect(as_since_epoch(clone.timestamp)).to eq(protocol_message_timestamp + 1000)
+        expect(clone.action).to eq(1)
+      end
+
+      context 'with an invalid ProtocolMessage (missing an ID)' do
+        let(:protocol_message) {
+          Ably::Models::ProtocolMessage.new('connectionId' => protocol_connection_id, 'action' =>  1, 'timestamp' => protocol_message_timestamp)
+        }
+        it 'allows an ID to be passed in to the shallow clone that takes precedence' do
+          clone = model.shallow_clone(id: 'newId', action: 1, timestamp: protocol_message_timestamp + 1000)
+          expect(clone.id).to match(/newId/)
+        end
+      end
+
+      context 'with mixing of cases' do
+        it 'resolves case issues and can use camelCase or snake_case' do
+          clone = model.shallow_clone(connectionId: 'camelCaseSym')
+          expect(clone.connection_id).to match(/camelCaseSym/)
+
+          clone = model.shallow_clone('connectionId' => 'camelCaseStr')
+          expect(clone.connection_id).to match(/camelCaseStr/)
+
+          clone = model.shallow_clone(connection_id: 'snake_case_sym')
+          expect(clone.connection_id).to match(/snake_case_sym/)
+        end
+      end
+    end
+  end
 end

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

@@ -10,6 +10,7 @@ describe Ably::Models::ProtocolMessage do
     subject.new({ action: 1 }.merge(options))
   end
 
+  # TR4n, TR4b, TR4c, TR4d, TR4e
   it_behaves_like 'a model',
     with_simple_attributes: %w(id channel channel_serial connection_id connection_key),
     base_model_options: { action: 1 } do
@@ -134,7 +135,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#flags' do
+    context '#flags (#TR4i)' do
       context 'when nil' do
         let(:protocol_message) { new_protocol_message({}) }
 
@@ -151,12 +152,40 @@ describe Ably::Models::ProtocolMessage do
         end
       end
 
-      context 'when has_presence' do
+      context 'when presence flag present' do
         let(:protocol_message) { new_protocol_message(flags: 1) }
 
         it '#has_presence_flag? is true' do
           expect(protocol_message.has_presence_flag?).to be_truthy
         end
+
+        it '#has_channel_resumed_flag? is false' do
+          expect(protocol_message.has_channel_resumed_flag?).to be_falsey
+        end
+      end
+
+      context 'when channel resumed flag present' do
+        let(:protocol_message) { new_protocol_message(flags: 4) }
+
+        it '#has_channel_resumed_flag? is true' do
+          expect(protocol_message.has_channel_resumed_flag?).to be_truthy
+        end
+
+        it '#has_presence_flag? is false' do
+          expect(protocol_message.has_presence_flag?).to be_falsey
+        end
+      end
+
+      context 'when channel resumed and presence flags present' do
+        let(:protocol_message) { new_protocol_message(flags: 5) }
+
+        it '#has_channel_resumed_flag? is true' do
+          expect(protocol_message.has_channel_resumed_flag?).to be_truthy
+        end
+
+        it '#has_presence_flag? is true' do
+          expect(protocol_message.has_presence_flag?).to be_truthy
+        end
       end
 
       context 'when has another future flag' do
@@ -165,6 +194,10 @@ describe Ably::Models::ProtocolMessage do
         it '#has_presence_flag? is false' do
           expect(protocol_message.has_presence_flag?).to be_falsey
         end
+
+        it '#has_backlog_flag? is true' do
+          expect(protocol_message.has_backlog_flag?).to be_truthy
+        end
       end
     end
 
@@ -265,7 +298,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#messages' do
+    context '#messages (#TR4k)' do
       let(:protocol_message) { new_protocol_message(messages: [{ name: 'test' }]) }
 
       it 'contains Message objects' do
@@ -275,7 +308,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#presence' do
+    context '#presence (#TR4l)' do
       let(:protocol_message) { new_protocol_message(presence: [{ action: 1, data: 'test' }]) }
 
       it 'contains PresenceMessage objects' do
@@ -285,7 +318,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#connection_details' do
+    context '#connection_details (#TR4o)' do
       let(:connection_details) { protocol_message.connection_details }
 
       context 'with a JSON value' do
@@ -312,7 +345,32 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#connection_key' do
+    context '#auth (#TR4p)' do
+      let(:auth) { protocol_message.auth }
+
+      context 'with a JSON value' do
+        let(:protocol_message) { new_protocol_message(auth: { accesstoken: 'foo' }) }
+
+        it 'contains a AuthDetails object' do
+          expect(auth).to be_a(Ably::Models::AuthDetails)
+        end
+
+        it 'contains the attributes from the JSON auth details' do
+          expect(auth.access_token).to eql('foo')
+        end
+      end
+
+      context 'without a JSON value' do
+        let(:protocol_message) { new_protocol_message({}) }
+
+        it 'contains an empty AuthDetails object' do
+          expect(auth).to be_a(Ably::Models::AuthDetails)
+          expect(auth.access_token).to eql(nil)
+        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' }) }
 

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

@@ -147,7 +147,7 @@ describe Ably::Models::TokenDetails do
     end
   end
 
-  context 'from_json (TD7)' do
+  context 'from_json (#TD7)' do
     let(:issued_time) { Time.now }
     let(:expires_time) { Time.now + 24*60*60 }
     let(:capabilities) { { '*' => ['publish'] } }

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

@@ -108,7 +108,7 @@ describe Ably::Models::TokenRequest do
     end
   end
 
-  context 'from_json (TE6)' do
+  context 'from_json (#TE6)' do
     let(:timestamp) { Time.now }
     let(:capabilities) { { '*' => ['publish'] } }
     let(:ttl_seconds) { 60 * 1000 }

data/lib/submodules/ably-ruby/spec/unit/modules/async_wrapper_spec.rb

@@ -59,7 +59,8 @@ describe Ably::Modules::AsyncWrapper, :api_private do
           subject.operation do |result|
             raise 'Intentional exception'
           end
-          expect(subject.logger).to receive(:error).with(/Intentional exception/) do
+          expect(subject.logger).to receive(:error) do |*args, &block|
+            expect(args.concat([block ? block.call : nil]).join(',')).to match(/Intentional exception/)
             stop_reactor
           end
         end

data/lib/submodules/ably-ruby/spec/unit/modules/enum_spec.rb

@@ -41,6 +41,41 @@ describe Ably::Modules::Enum, :api_private do
     end
   end
 
+  context 'using include? to compare Enum values' do
+    subject { enum }
+
+    it 'allows same type comparison' do
+      expect([subject.ValueZero].include?(subject.ValueZero)).to eql(true)
+    end
+
+    it 'allows different type comparison 1' do
+      expect([subject.ValueZero].include?(:value_zero)).to eql(true)
+    end
+
+    it 'allows different type comparison 2' do
+      skip 'Unless we monkeypath Symbols, the == operator is never invoked'
+      expect([:value_zero].include?(subject.ValueZero)).to eql(true)
+    end
+
+    context '#match_any? replacement for include?' do
+      it 'matches any value in the arguments provided' do
+        expect(subject.ValueZero.match_any?(:value_foo, :value_zero)).to eql(true)
+      end
+
+      it 'returns false if there are no matches in any value in the arguments provided' do
+        expect(subject.ValueZero.match_any?(:value_x, :value_y)).to eql(false)
+      end
+    end
+  end
+
+  context 'class method #to_sym_arr' do
+    subject { enum }
+
+    it 'returns all keys as symbols' do
+      expect(enum.to_sym_arr).to contain_exactly(:value_zero, :value_1, :value_snake_case_2, :sentence_case)
+    end
+  end
+
   context 'defined Enum from Array class' do
     subject { enum }
 
@@ -212,6 +247,40 @@ describe Ably::Modules::Enum, :api_private do
     end
   end
 
+  context 'two similar Enums with shared symbol values' do
+    class ExampleEnumOne
+      extend Ably::Modules::Enum
+      ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', :pear, :orange, :litchi, :apple)
+    end
+
+    class ExampleEnumTwo
+      extend Ably::Modules::Enum
+      ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', :pear, :grape, :apple)
+    end
+
+    let(:enum_one) { ExampleEnumOne::ENUMEXAMPLE }
+    let(:enum_two) { ExampleEnumTwo::ENUMEXAMPLE }
+
+    it 'provides compatability for the equivalent symbol values' do
+      expect(enum_one.Pear).to eq(enum_two.Pear)
+      expect(enum_two.Pear).to eq(enum_one.Pear)
+      expect(enum_one.Apple).to eq(enum_two.Apple)
+      expect(enum_two.Apple).to eq(enum_one.Apple)
+    end
+
+    it 'does not consider different symbol values the same' do
+      expect(enum_one.Orange).to_not eq(enum_two.Grape)
+    end
+
+    it 'matches symbols when used with a converter method' do
+      expect(ExampleEnumOne::ENUMEXAMPLE(enum_two.Pear)).to eq(:pear)
+    end
+
+    it 'fails to match when using an incompatible method with a converter method' do
+      expect { ExampleEnumOne::ENUMEXAMPLE(enum_two.Grape) }.to raise_error KeyError
+    end
+  end
+
   context 'Enum instance' do
     context '#==' do
       subject { enum.get(:value_snake_case_2) }