ably-rest 0.8.9 → 0.8.13

data/lib/submodules/ably-ruby/spec/acceptance/realtime/presence_spec.rb

@@ -1463,6 +1463,25 @@ describe Ably::Realtime::Presence, :event_machine do
           stop_reactor
         end
       end
+
+      context 'with a callback that raises an exception' do
+        let(:exception) { StandardError.new("Intentional error") }
+
+        it 'logs the error and continues' do
+          emitted_exception = false
+          expect(client_one.logger).to receive(:error).with(/#{exception.message}/)
+          presence_client_one.subscribe do |presence_message|
+            emitted_exception = true
+            raise exception
+          end
+          presence_client_one.enter do
+            EventMachine.add_timer(1) do
+              expect(emitted_exception).to eql(true)
+              stop_reactor
+            end
+          end
+        end
+      end
     end
 
     context '#unsubscribe' do

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

@@ -612,6 +612,87 @@ describe Ably::Auth do
         end
       end
 
+      context 'query_time: true' do
+        let(:local_time)  { @now - 60 }
+        let(:server_time) { @now }
+
+        before do
+          @now = Time.now
+          allow(Time).to receive(:now).and_return(local_time)
+        end
+
+        it 'only queries the server time once and then works out the offset, query_time option is never persisted' do
+          expect(client).to receive(:time).once.and_return(server_time)
+
+          auth.authorise({}, query_time: true)
+          auth.authorise({}, force: true)
+          expect(auth.auth_options).to_not have_key(:query_time)
+        end
+      end
+
+      context 'TokenParams argument' do
+        let(:default_token_params) { { ttl: 23 } }
+
+        before do
+          auth.authorise default_token_params
+        end
+
+        it 'has no effect on the defaults when null and TokenParam defaults remain the same' do
+          old_token = auth.current_token_details
+          auth.authorise(nil, force: true)
+          expect(old_token).to_not eql(auth.current_token_details)
+          expect(auth.token_params[:ttl]).to eql(23)
+        end
+
+        it 'updates defaults when present and all previous configured TokenParams are discarded' do
+          old_token = auth.current_token_details
+          auth.authorise({ client_id: 'bob' }, { force: true })
+          expect(old_token).to_not eql(auth.current_token_details)
+          expect(auth.token_params[:ttl]).to_not eql(23)
+          expect(auth.token_params[:client_id]).to eql('bob')
+        end
+
+        it 'updates Auth#token_params attribute with an immutable hash' do
+          auth.authorise({ client_id: 'bob' }, { force: true })
+          expect { auth.token_params['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
+        end
+      end
+
+      context 'AuthOptions argument' do
+        let(:token_ttl) { 2 }
+        let(:auth_callback) { Proc.new do
+          auth.create_token_request(ttl: token_ttl)
+        end }
+        let(:default_auth_options) { { auth_callback: auth_callback } }
+
+        before do
+          stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0 # allow token to be used even if about to expire
+          stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0) # Ensure tokens issued expire immediately after issue
+
+          auth.authorise(nil, default_auth_options)
+          @old_token = auth.current_token_details
+          sleep token_ttl + 0.5
+        end
+
+        it 'has no effect on the defaults when null and AuthOptions defaults remain the same' do
+          auth.authorise(nil, nil)
+          expect(@old_token).to_not eql(auth.current_token_details)
+          expect(auth.options[:auth_callback]).to eql(auth_callback)
+        end
+
+        it 'updates defaults when present and all previous configured AuthOptions are discarded' do
+          auth.authorise(nil, auth_method: :post)
+          expect(@old_token).to_not eql(auth.current_token_details)
+          expect(auth.options[:auth_callback]).to be_nil
+          expect(auth.options[:auth_method]).to eql(:post)
+        end
+
+        it 'updates Auth#options attribute with an immutable hash' do
+          auth.authorise(nil, auth_callback: Proc.new { '1231232.12321:12321312' })
+          expect { auth.options['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
+        end
+      end
+
       context 'with previous authorisation' do
         before do
           auth.authorise
@@ -640,10 +721,10 @@ describe Ably::Auth do
         expect(auth.token_params[:ttl]).to eql(26)
       end
 
-      it 'updates the persisted token params that are then used for subsequent authorise requests' do
-        expect(auth.options[:query_time]).to_not eql(true)
-        auth.authorise({}, query_time: true)
-        expect(auth.options[:query_time]).to eql(true)
+      it 'updates the persisted auth options that are then used for subsequent authorise requests' do
+        expect(auth.options[:authUrl]).to be_nil
+        auth.authorise({}, authUrl: 'http://foo.com')
+        expect(auth.options[:authUrl]).to eql('http://foo.com')
       end
 
       context 'with a Proc for the :auth_callback option' do
@@ -893,6 +974,43 @@ describe Ably::Auth do
           hmac = hmac_for(Ably::Models::TokenRequest(token_request_attributes).attributes, key_secret)
           expect(subject['mac']).to eql(hmac)
         end
+
+        context 'lexicographic ordering of channels and operations' do
+          let(:token_attributes) do
+            {
+              key_name:   key_name,
+              ttl:        600,
+              capability: {
+                "channel2" => ["subscribe", "publish"],
+                "channel1" => ["subscribe", "history"]
+              },
+              client_id:  random_str,
+              nonce:      random_str,
+              timestamp:  Time.now.to_i
+            }
+          end
+
+          let(:token_attributes_ordered) do
+            token_attributes.merge(capability: {
+              "channel1" => ["history", "subscribe"],
+              "channel2" => ["publish", "subscribe"]
+            })
+          end
+
+          specify 'HMAC is lexicographic ordered and thus the HMAC is identical' do
+            hmac = auth.create_token_request(token_attributes).mac
+            hmac_ordered = auth.create_token_request(token_attributes_ordered).mac
+            expect(hmac).to eql(hmac_ordered)
+          end
+
+          it 'is valid when used for authentication' do
+            auth_callback = Proc.new do
+              auth.create_token_request(token_attributes)
+            end
+            client = Ably::Rest::Client.new(auth_callback: auth_callback, environment: environment, protocol: protocol)
+            client.auth.authorise
+          end
+        end
       end
     end
 

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

@@ -545,5 +545,22 @@ describe Ably::Rest::Client do
         expect(client.auth.options[:auth_url]).to eql(dummy_auth_url)
       end
     end
+
+    context 'version headers', :webmock do
+      let(:client_options) { default_options.merge(key: api_key) }
+      let!(:publish_message_stub) do
+        stub_request(:post, "#{client.endpoint.to_s.gsub('://', "://#{api_key}@")}/channels/foo/publish").
+          with(headers: {
+            'X-Ably-Version' => Ably::PROTOCOL_VERSION,
+            'X-Ably-Lib' => "ruby-#{Ably::VERSION}"
+          }).
+          to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'sends a protocol version and lib version header' do
+        client.channels.get('foo').publish("event")
+        expect(publish_message_stub).to have_been_requested
+      end
+    end
   end
 end

data/lib/submodules/ably-ruby/spec/shared/client_initializer_behaviour.rb

@@ -106,18 +106,18 @@ shared_examples 'a client initializer' do
         allow_any_instance_of(subject.class).to receive(:auto_connect).and_return(false)
       end
 
-      let(:client_options) { 'app.key:secret' }
+      let(:client_options) { 'App.k3y:sec-r3t' }
 
       it 'sets the key' do
         expect(subject.auth.key).to eql(client_options)
       end
 
       it 'sets the key_name' do
-        expect(subject.auth.key_name).to eql('app.key')
+        expect(subject.auth.key_name).to eql('App.k3y')
       end
 
       it 'sets the key_secret' do
-        expect(subject.auth.key_secret).to eql('secret')
+        expect(subject.auth.key_secret).to eql('sec-r3t')
       end
 
       it 'uses basic auth' do

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

@@ -118,4 +118,32 @@ describe Ably::Models::TokenDetails do
       end
     end
   end
+
+  context 'to_json' do
+    let(:token_json_parsed) { JSON.parse(Ably::Models::TokenDetails(token_attributes).to_json) }
+
+    context 'with all attributes and values' do
+      let(:token_attributes) do
+        { token: random_str, capability: random_str, keyName: random_str, issued: Time.now.to_i, expires: Time.now.to_i + 10, clientId: random_str }
+      end
+
+      it 'returns all attributes' do
+        token_attributes.each do |key, val|
+          expect(token_json_parsed[key.to_s]).to eql(val)
+        end
+        expect(token_attributes.keys.length).to eql(token_json_parsed.keys.length)
+      end
+    end
+
+    context 'with only a token string' do
+      let(:token_attributes) do
+        { token: random_str }
+      end
+
+      it 'returns populated attributes' do
+        expect(token_json_parsed['token']).to eql(token_attributes[:token])
+        expect(token_json_parsed.keys.length).to eql(1)
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ably-rest
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.8.13
 platform: ruby
 authors:
 - Matthew O'Riordan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-01 00:00:00.000000000 Z
+date: 2016-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday