ably 0.8.8 → 0.8.9

data/spec/acceptance/rest/auth_spec.rb

@@ -18,7 +18,7 @@ describe Ably::Auth do
       :client_id,
       :timestamp,
       :nonce
-    ].map { |key| "#{token_request.hash[key]}\n" }.join("")
+    ].map { |key| "#{token_request.attributes[key]}\n" }.join("")
 
     encode64(
       OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, secret, text)
@@ -702,7 +702,7 @@ describe Ably::Auth do
 
           it 'calls the Proc once the token has expired and the new token is used' do
             client.stats
-            expect(@block_called).to be_nil
+            expect(@block_called).to eql(0)
             sleep 3.5
             expect { client.stats }.to change { client.auth.current_token_details }
             expect(@block_called).to eql(1)
@@ -824,9 +824,9 @@ describe Ably::Auth do
       context 'with additional invalid attributes' do
         let(:token_params) { { nonce: 'valid', is_not_used_by_token_request: 'invalid' } }
         specify 'are ignored' do
-          expect(subject.hash.keys).to_not include(:is_not_used_by_token_request)
-          expect(subject.hash.keys).to_not include(convert_to_mixed_case(:is_not_used_by_token_request))
-          expect(subject.hash.keys).to include(:nonce)
+          expect(subject.attributes.keys).to_not include(:is_not_used_by_token_request)
+          expect(subject.attributes.keys).to_not include(convert_to_mixed_case(:is_not_used_by_token_request))
+          expect(subject.attributes.keys).to include(:nonce)
           expect(subject.nonce).to eql('valid')
         end
       end
@@ -890,7 +890,7 @@ describe Ably::Auth do
         end
 
         it 'generates a valid HMAC' do
-          hmac = hmac_for(Ably::Models::TokenRequest(token_request_attributes).hash, key_secret)
+          hmac = hmac_for(Ably::Models::TokenRequest(token_request_attributes).attributes, key_secret)
           expect(subject['mac']).to eql(hmac)
         end
       end
@@ -918,7 +918,7 @@ describe Ably::Auth do
 
         it 'disallows publishing on unspecified capability channels' do
           expect { token_auth_client.channel('bar').publish('event', 'data') }.to raise_error do |error|
-            expect(error).to be_a(Ably::Exceptions::InvalidRequest)
+            expect(error).to be_a(Ably::Exceptions::UnauthorizedRequest)
             expect(error.status).to eql(401)
             expect(error.code).to eql(40160)
           end
@@ -926,7 +926,7 @@ describe Ably::Auth do
 
         it 'fails if timestamp is invalid' do
           expect { auth.request_token(timestamp: Time.now - 180) }.to raise_error do |error|
-            expect(error).to be_a(Ably::Exceptions::InvalidRequest)
+            expect(error).to be_a(Ably::Exceptions::UnauthorizedRequest)
             expect(error.status).to eql(401)
             expect(error.code).to eql(40101)
           end

data/spec/acceptance/rest/base_spec.rb

@@ -75,10 +75,10 @@ describe Ably::Rest do
         it 'should raise an InvalidRequest exception with a valid error message and code' do
           invalid_client = Ably::Rest::Client.new(key: 'appid.keyuid:keysecret', environment: environment)
           expect { invalid_client.channel('test').publish('foo', 'choo') }.to raise_error do |error|
-            expect(error).to be_a(Ably::Exceptions::InvalidRequest)
-            expect(error.message).to match(/invalid credentials/)
-            expect(error.code).to eql(40100)
-            expect(error.status).to eql(401)
+            expect(error).to be_a(Ably::Exceptions::ResourceMissing)
+            expect(error.message).to match(/No application found/)
+            expect(error.code).to eql(40400)
+            expect(error.status).to eql(404)
           end
         end
       end

data/spec/acceptance/rest/channel_spec.rb

@@ -87,7 +87,7 @@ describe Ably::Rest::Channel do
         let(:client_options) { default_options.merge(use_token_auth: true, token_params: { capability: capability }) }
 
         it 'raises a permission error when publishing' do
-          expect { channel.publish(name, data) }.to raise_error(Ably::Exceptions::InvalidRequest, /not permitted/)
+          expect { channel.publish(name, data) }.to raise_error(Ably::Exceptions::UnauthorizedRequest, /not permitted/)
         end
       end
 

data/spec/acceptance/rest/client_spec.rb

@@ -382,7 +382,7 @@ describe Ably::Rest::Client do
           end
 
           it 'does not attempt the fallback hosts as this is an authentication failure' do
-            expect { publish_block.call }.to raise_error(Ably::Exceptions::InvalidRequest)
+            expect { publish_block.call }.to raise_error(Ably::Exceptions::UnauthorizedRequest)
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to_not have_been_requested
             expect(second_fallback_request_stub).to_not have_been_requested

data/spec/acceptance/rest/encoders_spec.rb

@@ -9,12 +9,12 @@ describe Ably::Models::MessageEncoders do
   let(:channel)                { client.channel('test', channel_options) }
   let(:response)               { instance_double('Faraday::Response', status: 201) }
 
-  let(:cipher_params)          { { key: random_str, algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+  let(:cipher_params)          { { key: Ably::Util::Crypto.generate_random_key(128), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
   let(:crypto)                 { Ably::Util::Crypto.new(cipher_params) }
 
   let(:utf_8_data)             { random_str.encode(Encoding::UTF_8) }
   let(:binary_data)            { MessagePack.pack(random_str).encode(Encoding::ASCII_8BIT) }
-  let(:json_data)              { { 'key' => random_str } }
+  let(:json_data)              { { 'some_id' => random_str } }
 
   after do
     channel.publish 'event', published_data
@@ -70,7 +70,7 @@ describe Ably::Models::MessageEncoders do
     end
 
     context 'with encryption' do
-      let(:channel_options) { { encrypted: true, cipher_params: cipher_params } }
+      let(:channel_options) { { cipher: cipher_params } }
 
       context 'with UTF-8 data' do
         let(:published_data) { utf_8_data }
@@ -146,7 +146,7 @@ describe Ably::Models::MessageEncoders do
     end
 
     context 'with encryption' do
-      let(:channel_options) { { encrypted: true, cipher_params: cipher_params } }
+      let(:channel_options) { { cipher: cipher_params } }
 
       context 'with UTF-8 data' do
         let(:published_data) { utf_8_data }

data/spec/acceptance/rest/message_spec.rb

@@ -97,8 +97,8 @@ describe Ably::Rest::Channel, 'messages' do
 
     describe 'encryption and encoding' do
       let(:channel_name)      { "persisted:#{random_str}" }
-      let(:cipher_options)    { { key: random_str(32) } }
-      let(:encrypted_channel) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+      let(:encrypted_channel) { client.channel(channel_name, cipher: cipher_options) }
+      let(:cipher_options)    { { key: Ably::Util::Crypto.generate_random_key } }
 
       context 'with #publish and #history' do
         shared_examples 'an Ably encrypter and decrypter' do |item, data|
@@ -108,7 +108,7 @@ describe Ably::Rest::Channel, 'messages' do
           let(:secret_key)     { Base64.decode64(data['key']) }
           let(:iv)             { Base64.decode64(data['iv']) }
 
-          let(:cipher_options) { { key: secret_key, iv: iv, algorithm: algorithm, mode: mode, key_length: key_length } }
+          let(:cipher_options) { { key: secret_key, fixed_iv: iv, algorithm: algorithm, mode: mode, key_length: key_length } }
 
           let(:encoded)              { item['encoded'] }
           let(:encoded_data)         { encoded['data'] }
@@ -200,7 +200,7 @@ describe Ably::Rest::Channel, 'messages' do
         context 'when retrieving #history with a different protocol' do
           let(:other_protocol)       { protocol == :msgpack ? :json : :msgpack }
           let(:other_client)         { Ably::Rest::Client.new(default_client_options.merge(protocol: other_protocol)) }
-          let(:other_client_channel) {  other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+          let(:other_client_channel) { other_client.channel(channel_name, cipher: cipher_options) }
 
           before do
             expect(other_client.protocol_binary?).to_not eql(client.protocol_binary?)
@@ -221,7 +221,7 @@ describe Ably::Rest::Channel, 'messages' do
 
         context 'when publishing on an unencrypted channel and retrieving with #history on an encrypted channel' do
           let(:unencrypted_channel)            { client.channel(channel_name) }
-          let(:other_client_encrypted_channel) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+          let(:other_client_encrypted_channel) { other_client.channel(channel_name, cipher: cipher_options) }
 
           let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
@@ -236,8 +236,8 @@ describe Ably::Rest::Channel, 'messages' do
 
         context 'when publishing on an encrypted channel and retrieving with #history on an unencrypted channel' do
           let(:client_options)                   { default_client_options.merge(log_level: :fatal) }
-          let(:cipher_options)                   { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-          let(:encrypted_channel)                { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+          let(:cipher_options)                   { { key: Ably::Util::Crypto.generate_random_key(256), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:encrypted_channel)                { client.channel(channel_name, cipher: cipher_options) }
           let(:other_client_unencrypted_channel) { other_client.channel(channel_name) }
 
           let(:payload) { MessagePack.pack({ 'key' => random_str }) }
@@ -262,10 +262,10 @@ describe Ably::Rest::Channel, 'messages' do
 
         context 'publishing on an encrypted channel and retrieving #history with a different algorithm on another client' do
           let(:client_options)            { default_client_options.merge(log_level: :fatal) }
-          let(:cipher_options_client1)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-          let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client1) }
-          let(:cipher_options_client2)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
-          let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client2) }
+          let(:cipher_options_client1)    { { key: Ably::Util::Crypto.generate_random_key(256), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:encrypted_channel_client1) { client.channel(channel_name, cipher: cipher_options_client1) }
+          let(:cipher_options_client2)    { { key: Ably::Util::Crypto.generate_random_key(128), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+          let(:encrypted_channel_client2) { other_client.channel(channel_name, cipher: cipher_options_client2) }
 
           let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
@@ -289,10 +289,10 @@ describe Ably::Rest::Channel, 'messages' do
 
         context 'publishing on an encrypted channel and subscribing with a different key on another client' do
           let(:client_options)            { default_client_options.merge(log_level: :fatal) }
-          let(:cipher_options_client1)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-          let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client1) }
-          let(:cipher_options_client2)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-          let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client2) }
+          let(:cipher_options_client1)    { { key: Ably::Util::Crypto.generate_random_key(256), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:encrypted_channel_client1) { client.channel(channel_name, cipher: cipher_options_client1) }
+          let(:cipher_options_client2)    { { key: Ably::Util::Crypto.generate_random_key(256), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:encrypted_channel_client2) { other_client.channel(channel_name, cipher: cipher_options_client2) }
 
           let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 

data/spec/acceptance/rest/presence_spec.rb

@@ -26,8 +26,8 @@ describe Ably::Rest::Presence do
     let(:secret_key)       { Base64.decode64(cipher_details.fetch('key')) }
     let(:iv)               { Base64.decode64(cipher_details.fetch('iv')) }
 
-    let(:cipher_options)   { { key: secret_key, algorithm: algorithm, mode: mode, key_length: key_length, iv: iv } }
-    let(:fixtures_channel) { client.channel('persisted:presence_fixtures', encrypted: true, cipher_params: cipher_options, iv: iv) }
+    let(:cipher_options)   { { key: secret_key, algorithm: algorithm, mode: mode, key_length: key_length, fixed_iv: iv } }
+    let(:fixtures_channel) { client.channel('persisted:presence_fixtures', cipher: cipher_options, fixed_iv: iv) }
 
     context 'tested against presence fixture data set up in test app' do
       before(:context) do
@@ -321,8 +321,8 @@ describe Ably::Rest::Presence do
 
       let(:data)            { random_str(32) }
       let(:channel_name)    { "persisted:#{random_str(4)}" }
-      let(:cipher_options)  { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-      let(:presence)        { client.channel(channel_name, encrypted: true, cipher_params: cipher_options).presence }
+      let(:cipher_options)  { { key: Ably::Util::Crypto.generate_random_key(256), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+      let(:presence)        { client.channel(channel_name, cipher: cipher_options).presence }
 
       let(:crypto)          { Ably::Util::Crypto.new(cipher_options) }
 

data/spec/shared/model_behaviour.rb

@@ -18,18 +18,18 @@ shared_examples 'a model' do |shared_options = {}|
       end
     end
 
-    context '#hash', :api_private do
+    context '#attributes', :api_private do
       let(:model_options) { { action: 5 } }
 
-      it 'provides access to #hash' do
-        expect(model.hash).to eq(model_options)
+      it 'provides access to #attributes' do
+        expect(model.attributes).to eq(model_options)
       end
     end
 
     context '#[]', :api_private do
       let(:model_options) { { unusual: 'attribute' } }
 
-      it 'provides accessor method to #hash' do
+      it 'provides accessor method to #attributes' do
         expect(model[:unusual]).to eql('attribute')
       end
     end
@@ -74,13 +74,13 @@ shared_examples 'a model' do |shared_options = {}|
     let(:model_options) { { channel: 'name' } }
 
     it 'prevents changes' do
-      expect { model.hash[:channel] = 'new' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
+      expect { model.attributes[:channel] = 'new' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
     end
 
     it 'dups options' do
-      expect(model.hash[:channel]).to eql('name')
+      expect(model.attributes[:channel]).to eql('name')
       model_options[:channel] = 'new'
-      expect(model.hash[:channel]).to eql('name')
+      expect(model.attributes[:channel]).to eql('name')
     end
   end
 end

data/spec/unit/models/cipher_params_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'base64'
+
+describe Ably::Models::CipherParams do
+  context ':key missing from constructor' do
+    subject { Ably::Models::CipherParams.new }
+
+    it 'raises an exception' do
+      expect { subject }.to raise_error(/key.*required/)
+    end
+  end
+
+  describe '#key' do
+    context 'with :key in constructor' do
+      subject { Ably::Models::CipherParams.new(key: key) }
+
+      context 'as nil' do
+        let(:key) { nil }
+
+        it 'raises an exception' do
+          expect { subject }.to raise_error(/key.*required/)
+        end
+      end
+
+      context 'as a base64 encoded string' do
+        let(:binary_key) { Ably::Util::Crypto.generate_random_key }
+        let(:key) { Base64.encode64(binary_key) }
+
+        it 'is a binary representation of the base64 encoded string' do
+          expect(subject.key).to eql(binary_key)
+          expect(subject.key.encoding).to eql(Encoding::ASCII_8BIT)
+        end
+      end
+
+      context 'as a URL safe base64 encoded string' do
+        let(:base64_key) { "t+8lK21q7/44/YTpKTpHa6Icc/a08wIATyhxbVBb4RE=\n" }
+        let(:binary_key) { Base64.decode64(base64_key) }
+        let(:key) { base64_key.gsub('/', '_').gsub('+', '-') }
+
+        it 'is a binary representation of the URL safe base64 encoded string' do
+          expect(subject.key).to eql(binary_key)
+        end
+      end
+
+      context 'as a binary encoded string' do
+        let(:key) { Ably::Util::Crypto.generate_random_key }
+
+        it 'contains the binary string' do
+          expect(subject.key).to eql(key)
+          expect(subject.key.encoding).to eql(Encoding::ASCII_8BIT)
+        end
+      end
+
+      context 'with an incompatible :key_length constructor param' do
+        let(:key) { Ably::Util::Crypto.generate_random_key(256) }
+        subject { Ably::Models::CipherParams.new(key: key, key_length: 128) }
+
+        it 'raises an exception' do
+          expect { subject }.to raise_error(/Incompatible.*key.*length/)
+        end
+      end
+
+      context 'with an unsupported :key_length for aes-cbc encryption' do
+        let(:key) { "A" * 48 }
+        subject { Ably::Models::CipherParams.new(key: key, algorithm: 'aes', mode: 'cbc') }
+
+        it 'raises an exception' do
+          expect { subject }.to raise_error(/Unsupported key length/)
+        end
+      end
+
+      context 'with an invalid type' do
+        let(:key) { 111 }
+        subject { Ably::Models::CipherParams.new(key: key) }
+
+        it 'raises an exception' do
+          expect { subject }.to raise_error(/key param must/)
+        end
+      end
+    end
+  end
+
+  context 'with specified params in the constructor' do
+    let(:key) { Ably::Util::Crypto.generate_random_key(128) }
+    subject { Ably::Models::CipherParams.new(key: key, algorithm: 'aes', key_length: 128, mode: 'cbc') }
+
+    describe '#cipher_type' do
+      it 'contains the complete algorithm string as an upper case string' do
+        expect(subject.cipher_type).to eql ('AES-128-CBC')
+      end
+    end
+
+    describe '#mode' do
+      it 'contains the mode' do
+        expect(subject.mode).to eql ('cbc')
+      end
+    end
+
+    describe '#algorithm' do
+      it 'contains the algorithm' do
+        expect(subject.algorithm).to eql ('aes')
+      end
+    end
+
+    describe '#key_length' do
+      it 'contains the key_length' do
+        expect(subject.key_length).to eql(128)
+      end
+    end
+  end
+
+  context 'with combined param in the constructor' do
+    let(:key) { Ably::Util::Crypto.generate_random_key(128) }
+    subject { Ably::Models::CipherParams.new(key: key, combined: "FOO-128-BAR") }
+
+    describe '#cipher_type' do
+      it 'contains the complete algorithm string as an upper case string' do
+        expect(subject.cipher_type).to eql ('FOO-128-BAR')
+      end
+    end
+
+    describe '#mode' do
+      it 'contains the mode' do
+        expect(subject.mode).to eql ('bar')
+      end
+    end
+
+    describe '#algorithm' do
+      it 'contains the algorithm' do
+        expect(subject.algorithm).to eql ('foo')
+      end
+    end
+
+    describe '#key_length' do
+      it 'contains the key_length' do
+        expect(subject.key_length).to eql(128)
+      end
+    end
+  end
+end

data/spec/unit/models/idiomatic_ruby_wrapper_spec.rb

@@ -57,8 +57,8 @@ describe Ably::Models::IdiomaticRubyWrapper, :api_private do
     expect { subject.no_key_exists_for_this }.to raise_error NoMethodError
   end
 
-  specify '#hash returns raw Hash object' do
-    expect(subject.hash).to eql(mixed_case_data)
+  specify '#attributes returns raw Hash object' do
+    expect(subject.attributes).to eql(mixed_case_data)
   end
 
   context 'recursively wrapping child objects' do
@@ -153,7 +153,7 @@ describe Ably::Models::IdiomaticRubyWrapper, :api_private do
       end
 
       it 'uses mixedCase' do
-        expect(subject.hash['newKey']).to eql('new_value')
+        expect(subject.attributes['newKey']).to eql('new_value')
         expect(subject.new_key).to eql('new_value')
       end
     end
@@ -329,20 +329,27 @@ describe Ably::Models::IdiomaticRubyWrapper, :api_private do
     context '#dup' do
       let(:mixed_case_data) do
         {
-          'key' => 'value'
+          'key_id' => 'value',
+          'stop'   => { client_id: "case won't change" }
         }.freeze
       end
       let(:dupe) { subject.dup }
+      subject { Ably::Models::IdiomaticRubyWrapper.new(mixed_case_data, stop_at: [:stop]) }
 
       it 'returns a new object with the underlying JSON duped' do
-        expect(subject.hash).to be_frozen
-        expect(dupe.hash).to_not be_frozen
+        expect(subject.attributes).to be_frozen
+        expect(dupe.attributes).to_not be_frozen
       end
 
       it 'returns a new IdiomaticRubyWrapper with the same underlying Hash object' do
         expect(dupe).to be_a(Ably::Models::IdiomaticRubyWrapper)
-        expect(dupe.hash).to be_a(Hash)
-        expect(dupe.hash).to eql(mixed_case_data)
+        expect(dupe.attributes).to be_a(Hash)
+        expect(dupe.attributes).to eql(mixed_case_data)
+      end
+
+      it 'keeps the stop_at list intact' do
+        expect(dupe.stop_at.keys).to eql([:stop])
+        expect(dupe.attributes['stop']).to eql({ client_id: "case won't change" })
       end
     end
   end