ably 0.8.15 → 1.0.0

data/spec/unit/models/token_details_spec.rb

@@ -146,4 +146,79 @@ describe Ably::Models::TokenDetails do
       end
     end
   end
+
+  context 'from_json (#TD7)' do
+    let(:issued_time) { Time.now }
+    let(:expires_time) { Time.now + 24*60*60 }
+    let(:capabilities) { { '*' => ['publish'] } }
+
+    context 'with Ruby idiomatic Hash object' do
+      subject { Ably::Models::TokenDetails.from_json(token_details_object) }
+
+      let(:token_details_object) do
+        {
+          token: 'val1',
+          key_name: 'val2',
+          issued: issued_time.to_i * 1000,
+          expires: expires_time.to_i * 1000,
+          capability: capabilities,
+          client_id: 'val3'
+        }
+      end
+
+      it 'returns a valid TokenDetails object' do
+        expect(subject.token).to eql('val1')
+        expect(subject.key_name).to eql('val2')
+        expect(subject.issued.to_f).to be_within(1).of(issued_time.to_f)
+        expect(subject.expires.to_f).to be_within(1).of(expires_time.to_f)
+        expect(subject.capability).to eql(capabilities)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+
+    context 'with JSON-like object' do
+      subject { Ably::Models::TokenDetails.from_json(token_details_object) }
+
+      let(:token_details_object) do
+        {
+          'keyName' => 'val2',
+          'issued' => issued_time.to_i * 1000,
+          'expires' => expires_time.to_i * 1000,
+          'capability' => JSON.dump(capabilities),
+          'clientId' => 'val3'
+        }
+      end
+
+      it 'returns a valid TokenDetails object' do
+        expect(subject.token).to be_nil
+        expect(subject.key_name).to eql('val2')
+        expect(subject.issued.to_f).to be_within(1).of(issued_time.to_f)
+        expect(subject.expires.to_f).to be_within(1).of(expires_time.to_f)
+        expect(subject.capability).to eql(capabilities)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+
+    context 'with JSON string' do
+      subject { Ably::Models::TokenDetails.from_json(JSON.dump(token_details_object)) }
+
+      let(:token_details_object) do
+        {
+          'keyName' => 'val2',
+          'issued' => issued_time.to_i * 1000,
+          'expires' => expires_time.to_i * 1000,
+          'clientId' => 'val3'
+        }
+      end
+
+      it 'returns a valid TokenDetails object' do
+        expect(subject.token).to be_nil
+        expect(subject.key_name).to eql('val2')
+        expect(subject.issued.to_f).to be_within(1).of(issued_time.to_f)
+        expect(subject.expires.to_f).to be_within(1).of(expires_time.to_f)
+        expect(subject.capability).to be_nil
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+  end
 end

data/spec/unit/models/token_request_spec.rb

@@ -107,4 +107,78 @@ describe Ably::Models::TokenRequest do
       end
     end
   end
+
+  context 'from_json (#TE6)' do
+    let(:timestamp) { Time.now }
+    let(:capabilities) { { '*' => ['publish'] } }
+    let(:ttl_seconds) { 60 * 1000 }
+
+    context 'with Ruby idiomatic Hash object' do
+      subject { Ably::Models::TokenRequest.from_json(token_request_object) }
+
+      let(:token_request_object) do
+        {
+          nonce: 'val1',
+          key_name: 'val2',
+          ttl: ttl_seconds * 1000,
+          timestamp: timestamp.to_i * 1000,
+          capability: capabilities,
+          client_id: 'val3'
+        }
+      end
+
+      it 'returns a valid TokenRequest object' do
+        expect(subject.nonce).to eql('val1')
+        expect(subject.key_name).to eql('val2')
+        expect(subject.timestamp.to_f).to be_within(1).of(timestamp.to_f)
+        expect(subject.ttl).to eql(ttl_seconds)
+        expect(subject.capability).to eql(capabilities)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+
+    context 'with JSON-like object' do
+      subject { Ably::Models::TokenRequest.from_json(token_request_object) }
+
+      let(:token_request_object) do
+        {
+          'keyName' => 'val2',
+          'ttl' => ttl_seconds * 1000,
+          'timestamp' => timestamp.to_i * 1000,
+          'clientId' => 'val3'
+        }
+      end
+
+      it 'returns a valid TokenRequest object' do
+        expect { subject.nonce }.to raise_error(Ably::Exceptions::InvalidTokenRequest)
+        expect(subject.key_name).to eql('val2')
+        expect(subject.timestamp.to_f).to be_within(1).of(timestamp.to_f)
+        expect(subject.ttl).to eql(ttl_seconds)
+        expect { subject.capability }.to raise_error(Ably::Exceptions::InvalidTokenRequest)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+
+    context 'with JSON string' do
+      subject { Ably::Models::TokenRequest.from_json(JSON.dump(token_request_object)) }
+
+      let(:token_request_object) do
+        {
+          'nonce' => 'val1',
+          'ttl' => ttl_seconds * 1000,
+          'capability' => JSON.dump(capabilities),
+          'clientId' => 'val3'
+        }
+      end
+
+      it 'returns a valid TokenRequest object' do
+        expect(subject.nonce).to eql('val1')
+        expect { subject.key_name }.to raise_error(Ably::Exceptions::InvalidTokenRequest)
+        expect { subject.timestamp }.to raise_error(Ably::Exceptions::InvalidTokenRequest)
+        expect(subject.ttl).to eql(ttl_seconds)
+        expect(subject.capability).to eql(capabilities)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+  end
 end

data/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/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) }

data/spec/unit/modules/event_emitter_spec.rb

@@ -83,13 +83,13 @@ describe Ably::Modules::EventEmitter do
           allow(obj).to receive(:received_message)
         end
 
-        it 'is unaffected and processes the prior event callbacks once' do
+        it 'is unaffected and processes the prior event callbacks once (#RTE6b)' do
           expect(obj).to receive(:received_message).with(msg).twice
           expect(obj).to_not receive(:received_message_from_new_callbacks).with(msg)
           subject.emit :message, msg
         end
 
-        it 'adds them for the next emitted event' do
+        it 'adds them for the next emitted event (#RTE6b)' do
           expect(obj).to receive(:received_message_from_new_callbacks).with(msg).twice
 
           # New callbacks are added in this emit
@@ -110,12 +110,12 @@ describe Ably::Modules::EventEmitter do
           end
         end
 
-        it 'is unaffected and processes the prior event callbacks once' do
+        it 'is unaffected and processes the prior event callbacks once (#RTE6b)' do
           expect(obj).to receive(:received_message).with(msg).twice
           subject.emit :message, msg
         end
 
-        it 'removes them for the next emitted event' do
+        it 'removes them for the next emitted event (#RTE6b)' do
           expect(obj).to receive(:received_message).with(msg).twice
 
           # Callbacks are removed in this emit
@@ -127,7 +127,7 @@ describe Ably::Modules::EventEmitter do
     end
   end
 
-  context '#on' do
+  context '#on (#RTE3)' do
     context 'with event specified' do
       it 'calls the block every time an event is emitted only' do
         block_called = 0
@@ -137,7 +137,9 @@ describe Ably::Modules::EventEmitter do
       end
 
       it 'catches exceptions in the provided block, logs the error and continues' do
-        expect(subject.logger).to receive(:error).with(/Intentional exception/)
+        expect(subject.logger).to receive(:error) do |*args, &block|
+          expect(args.concat([block ? block.call : nil]).join(',')).to match(/Intentional exception/)
+        end
         subject.on(:event) { raise 'Intentional exception' }
         subject.emit :event
       end
@@ -152,7 +154,9 @@ describe Ably::Modules::EventEmitter do
       end
 
       it 'catches exceptions in the provided block, logs the error and continues' do
-        expect(subject.logger).to receive(:error).with(/Intentional exception/)
+        expect(subject.logger).to receive(:error) do |*args, &block|
+          expect(args.concat([block ? block.call : nil]).join(',')).to match(/Intentional exception/)
+        end
         subject.on { raise 'Intentional exception' }
         subject.emit :event
       end
@@ -173,7 +177,7 @@ describe Ably::Modules::EventEmitter do
     end
   end
 
-  context '#once' do
+  context '#once (#RTE4)' do
     context 'with event specified' do
       it 'calls the block the first time an event is emitted only' do
         block_called = 0
@@ -191,7 +195,9 @@ describe Ably::Modules::EventEmitter do
       end
 
       it 'catches exceptions in the provided block, logs the error and continues' do
-        expect(subject.logger).to receive(:error).with(/Intentional exception/)
+        expect(subject.logger).to receive(:error) do |*args, &block|
+          expect(args.concat([block ? block.call : nil]).join(',')).to match(/Intentional exception/)
+        end
         subject.once(:event) { raise 'Intentional exception' }
         subject.emit :event
       end
@@ -214,7 +220,9 @@ describe Ably::Modules::EventEmitter do
       end
 
       it 'catches exceptions in the provided block, logs the error and continues' do
-        expect(subject.logger).to receive(:error).with(/Intentional exception/)
+        expect(subject.logger).to receive(:error) do |*args, &block|
+          expect(args.concat([block ? block.call : nil]).join(',')).to match(/Intentional exception/)
+        end
         subject.once { raise 'Intentional exception' }
         subject.emit :event
       end
@@ -248,12 +256,12 @@ describe Ably::Modules::EventEmitter do
       end
 
       context 'with event names as arguments' do
-        it 'deletes matching callbacks' do
+        it 'deletes matching callbacks when a block is provided' do
           expect(obj).to_not receive(:received_message).with(msg)
           subject.off(:message, &callback)
         end
 
-        it 'deletes all callbacks if not block given' do
+        it 'deletes all matching callbacks when a block is not provided' do
           expect(obj).to_not receive(:received_message).with(msg)
           subject.off(:message)
         end
@@ -277,18 +285,137 @@ describe Ably::Modules::EventEmitter do
       end
     end
 
-    it 'removes handler added with no event specified' do
-      subject.on(&callback)
-      expect(obj).to_not receive(:received_message).with(msg)
-      subject.off(&callback)
-      subject.emit :message, msg
+    context 'when on callback is configured for all events' do
+      before do
+        subject.on(&callback)
+      end
+
+      after do
+        subject.emit :message, msg
+      end
+
+      context 'with event names as arguments' do
+        it 'does not remove the all events callback when a block is provided' do
+          expect(obj).to receive(:received_message).with(msg)
+          subject.off(:message, &callback)
+        end
+
+        it 'does not remove the all events callback when a block is not provided' do
+          expect(obj).to receive(:received_message).with(msg)
+          subject.off(:message)
+        end
+
+        it 'does not remove the all events callback when the block does not match' do
+          expect(obj).to receive(:received_message).with(msg)
+          subject.off(:message) { true }
+        end
+      end
+
+      context 'without any event names' do
+        it 'deletes all matching callbacks' do
+          expect(obj).to_not receive(:received_message).with(msg)
+          subject.off(&callback)
+        end
+
+        it 'deletes all callbacks if not block given' do
+          expect(obj).to_not receive(:received_message).with(msg)
+          subject.off
+        end
+      end
     end
 
-    it 'leaves handler when event specified' do
-      subject.on(&callback)
-      expect(obj).to receive(:received_message).with(msg)
-      subject.off(:foo, &callback)
-      subject.emit :message, msg
+    context 'with unsafe_on subscribers' do
+      before do
+        subject.unsafe_on(&callback)
+      end
+
+      after do
+        subject.emit :message, msg
+      end
+
+      it 'does not deregister them' do
+        expect(obj).to receive(:received_message).with(msg)
+        subject.off
+      end
+    end
+
+    context 'with unsafe_once subscribers' do
+      before do
+        subject.unsafe_once(&callback)
+      end
+
+      after do
+        subject.emit :message, msg
+      end
+
+      it 'does not deregister them' do
+        expect(obj).to receive(:received_message).with(msg)
+        subject.off
+      end
+    end
+  end
+
+  context '#unsafe_off' do
+    let(:callback) { Proc.new { |msg| obj.received_message msg } }
+
+    context 'with unsafe_on subscribers' do
+      before do
+        subject.unsafe_on(&callback)
+      end
+
+      after do
+        subject.emit :message, msg
+      end
+
+      it 'deregisters them' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.unsafe_off
+      end
+    end
+
+    context 'with unsafe_once subscribers' do
+      before do
+        subject.unsafe_once(&callback)
+      end
+
+      after do
+        subject.emit :message, msg
+      end
+
+      it 'deregister them' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.unsafe_off
+      end
+    end
+
+    context 'with on subscribers' do
+      before do
+        subject.on(&callback)
+      end
+
+      after do
+        subject.emit :message, msg
+      end
+
+      it 'does not deregister them' do
+        expect(obj).to receive(:received_message).with(msg)
+        subject.unsafe_off
+      end
+    end
+
+    context 'with once subscribers' do
+      before do
+        subject.once(&callback)
+      end
+
+      after do
+        subject.emit :message, msg
+      end
+
+      it 'does not deregister them' do
+        expect(obj).to receive(:received_message).with(msg)
+        subject.unsafe_off
+      end
     end
   end
 end