ably 0.8.12 → 0.8.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83a334452c78f5a9522b8aef6edef8a376da22c4
-  data.tar.gz: e00a360302db7a510633beeb840c1a81d565d3f8
+  metadata.gz: 7859d1961b34f4db85c4e3b4dd9148aa17b456e6
+  data.tar.gz: df4339d846d3bb29ce58dc311b7e844d6a21fadb
 SHA512:
-  metadata.gz: 46211a7336813fdcbc6160b161c97a7a66af8cc95ad02b40757d55326f30839a9754db67c95235a394805d1cea7afe52618311556c55436127f99f92349a26e0
-  data.tar.gz: 67674b15c02b127e72d0b982b40735f1366b6b0384e8e0cbe0945334e6c724fd2e1c162dac12c99d9c8a12a8d19fa78685749036da4ab3ac972ba9e3274890d8
+  metadata.gz: 711fd1f07710b81c319378740f0b193d0166f16ab00a1528de10c22a105a796212ab77954a7813d631afff1aa82ed7bf1e75f9984a90346b72a636cf5ff74d6d
+  data.tar.gz: 00e82298ba240966faae98bb7d33065bfa58ba118c40152ac906b92f6344f85d951130f23e40947d107dd809f4cd317e9f975b68324babb376a6ad1a36bd0edf

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Change Log
 
-## [v0.8.12](https://github.com/ably/ably-ruby/tree/v0.8.12)
+## [Unreleased](https://github.com/ably/ably-ruby/tree/v0.8.13)
+
+[Full Changelog](https://github.com/ably/ably-ruby/compare/v0.8.12...v0.8.13)
+
+**Merged pull requests:**
+
+- Ensure interoperability with other libraries with JSON protocol [\#94](https://github.com/ably/ably-ruby/pull/94) ([mattheworiordan](https://github.com/mattheworiordan))
+
+## [v0.8.12](https://github.com/ably/ably-ruby/tree/v0.8.12) (2016-05-23)
 
 [Full Changelog](https://github.com/ably/ably-ruby/compare/v0.8.11...v0.8.12)
 

data/README.md

@@ -1,6 +1,5 @@
 # [Ably](https://www.ably.io)
 
-[![Build Status](https://travis-ci.org/ably/ably-ruby.png)](https://travis-ci.org/ably/ably-ruby)
 [![Gem Version](https://badge.fury.io/rb/ably.svg)](http://badge.fury.io/rb/ably)
 [![Coverage Status](https://coveralls.io/repos/ably/ably-ruby/badge.svg)](https://coveralls.io/r/ably/ably-ruby)
 

data/ably.gemspec

@@ -22,7 +22,11 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'em-http-request', '~> 1.1'
   spec.add_runtime_dependency 'statesman', '~> 1.0.0'
   spec.add_runtime_dependency 'faraday', '~> 0.9'
-  spec.add_runtime_dependency 'json'
+  if RUBY_VERSION.match(/^1/)
+    spec.add_runtime_dependency 'json', '< 2.0'
+  else
+    spec.add_runtime_dependency 'json'
+  end
   spec.add_runtime_dependency 'websocket-driver', '~> 0.6'
   spec.add_runtime_dependency 'msgpack', '>= 0.6.2'
   spec.add_runtime_dependency 'addressable', '>= 2.0.0'
@@ -37,7 +41,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'coveralls'
 
-  if RUBY_VERSION.match(/^2/)
+  unless RUBY_VERSION.match(/^1/)
     spec.add_development_dependency 'pry'
     spec.add_development_dependency 'pry-byebug'
   end

data/lib/ably/auth.rb

@@ -290,7 +290,14 @@ module Ably
         nonce:      token_params[:nonce] || SecureRandom.hex.force_encoding('UTF-8')
       }
 
-      token_request[:capability] = JSON.dump(token_request[:capability]) if token_request[:capability].is_a?(Hash)
+      if token_request[:capability].is_a?(Hash)
+        lexicographic_ordered_capabilities = Hash[
+          token_request[:capability].sort_by { |key, value| key }.map do |key, value|
+            [key, value.sort]
+          end
+        ]
+        token_request[:capability] = JSON.dump(lexicographic_ordered_capabilities)
+      end
 
       token_request[:mac] = sign_params(token_request, request_key_secret)
 

data/lib/ably/realtime/connection.rb

@@ -194,15 +194,15 @@ module Ably
 
       # Sends a ping to Ably and yields the provided block when a heartbeat ping request is echoed from the server.
       # This can be useful for measuring true roundtrip client to Ably server latency for a simple message, or checking that an underlying transport is responding currently.
-      # The elapsed milliseconds is passed as an argument to the block and represents the time taken to echo a ping heartbeat once the connection is in the `:connected` state.
+      # The elapsed time in seconds is passed as an argument to the block and represents the time taken to echo a ping heartbeat once the connection is in the `:connected` state.
       #
-      # @yield [Integer] if a block is passed to this method, then this block will be called once the ping heartbeat is received with the time elapsed in milliseconds.
+      # @yield [Integer] if a block is passed to this method, then this block will be called once the ping heartbeat is received with the time elapsed in seconds.
       #                  If the ping is not received within an acceptable timeframe, the block will be called with +nil+ as he first argument
       #
       # @example
       #    client = Ably::Rest::Client.new(key: 'key.id:secret')
-      #    client.connection.ping do |ms_elapsed|
-      #      puts "Ping took #{ms_elapsed}ms"
+      #    client.connection.ping do |elapsed_s|
+      #      puts "Ping took #{elapsed_s}s"
       #    end
       #
       # @return [void]
@@ -219,7 +219,7 @@ module Ably
           if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Heartbeat
             finished = true
             __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
-            time_passed = (Time.now.to_f * 1000 - started.to_f * 1000).to_i
+            time_passed = Time.now.to_f - started.to_f
             safe_yield block, time_passed if block_given?
           end
         end
@@ -387,7 +387,9 @@ module Ably
             auth_deferrable.callback do |auth_params|
               url_params = auth_params.merge(
                 format:    client.protocol,
-                echo:      client.echo_messages
+                echo:      client.echo_messages,
+                v:         Ably::PROTOCOL_VERSION,
+                lib:       Ably::LIB_VERSION_ID,
               )
 
               url_params['clientId'] = client.auth.client_id if client.auth.has_client_id?

data/lib/ably/rest/client.rb

@@ -352,6 +352,8 @@ module Ably
             unless options[:send_auth_header] == false
               request.headers[:authorization] = auth.auth_header
             end
+            request.headers['X-Ably-Version'] = Ably::PROTOCOL_VERSION
+            request.headers['X-Ably-Lib'] = Ably::LIB_VERSION_ID
           end
 
         rescue Faraday::TimeoutError, Faraday::ClientError, Ably::Exceptions::ServerError => error

data/lib/ably/version.rb

@@ -1,3 +1,5 @@
 module Ably
-  VERSION = '0.8.12'
+  VERSION = '0.8.13'
+  PROTOCOL_VERSION = '0.8'
+  LIB_VERSION_ID = "ruby-#{Ably::VERSION}"
 end

data/spec/acceptance/realtime/connection_spec.rb

@@ -1356,5 +1356,25 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
     end
+
+    context 'version params' do
+      it 'sends the protocol version param v' do
+        expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+          uri = URI.parse(url)
+          expect(CGI::parse(uri.query)['v'][0]).to eql(Ably::PROTOCOL_VERSION)
+          stop_reactor
+        end
+        client
+      end
+
+      it 'sends the lib version param lib' do
+        expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+          uri = URI.parse(url)
+          expect(CGI::parse(uri.query)['lib'][0]).to eql("ruby-#{Ably::VERSION}")
+          stop_reactor
+        end
+        client
+      end
+    end
   end
 end

data/spec/acceptance/realtime/message_spec.rb

@@ -483,11 +483,13 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           payload_description = "#{payload.class}#{" #{payload.encoding}" if payload.kind_of?(String)}"
 
           it "delivers a #{payload_description} payload to the receiver" do
-            encrypted_channel_client1.publish 'example', payload
-            encrypted_channel_client2.subscribe do |message|
-              expect(message.data).to eql(payload)
-              expect(message.encoding).to be_nil
-              stop_reactor
+            encrypted_channel_client2.attach do
+              encrypted_channel_client1.publish 'example', payload
+              encrypted_channel_client2.subscribe do |message|
+                expect(message.data).to eql(payload)
+                expect(message.encoding).to be_nil
+                stop_reactor
+              end
             end
           end
         end
@@ -520,11 +522,13 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
         let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
         it 'delivers the message but still encrypted with a value in the #encoding attribute' do
-          encrypted_channel_client1.publish 'example', payload
-          unencrypted_channel_client2.subscribe do |message|
-            expect(message.data).to_not eql(payload)
-            expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
-            stop_reactor
+          unencrypted_channel_client2.attach do
+            encrypted_channel_client1.publish 'example', payload
+            unencrypted_channel_client2.subscribe do |message|
+              expect(message.data).to_not eql(payload)
+              expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
+              stop_reactor
+            end
           end
         end
 
@@ -732,4 +736,122 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
     end
   end
+
+  context 'message encoding interoperability' do
+    let(:client_options)  { { key: api_key, environment: environment, protocol: :json } }
+    let(:channel_name) { "subscribe_send_text-#{random_str}" }
+
+    fixtures_path = File.expand_path('../../../../lib/submodules/ably-common/test-resources/messages-encoding.json', __FILE__)
+
+    context 'over a JSON transport' do
+      let(:realtime_client) do
+        auto_close Ably::Realtime::Client.new(client_options)
+      end
+      let(:rest_client) do
+        Ably::Rest::Client.new(client_options)
+      end
+      let(:realtime_channel) { realtime_client.channels.get(channel_name) }
+
+      JSON.parse(File.read(fixtures_path))['messages'].each do |encoding_spec|
+        context "when decoding #{encoding_spec['expectedType']}" do
+          it 'ensures that client libraries have compatible encoding and decoding using common fixtures' do
+            realtime_channel.attach do
+              realtime_channel.subscribe do |message|
+                if encoding_spec['expectedHexValue']
+                  expect(message.data.unpack('H*').first).to eql(encoding_spec['expectedHexValue'])
+                else
+                  expect(message.data).to eql(encoding_spec['expectedValue'])
+                end
+                stop_reactor
+              end
+
+              raw_message = { "data" => encoding_spec['data'], "encoding" => encoding_spec['encoding'] }
+              rest_client.post("/channels/#{channel_name}/messages", JSON.dump(raw_message))
+            end
+          end
+        end
+
+        context "when encoding #{encoding_spec['expectedType']}" do
+          it 'ensures that client libraries have compatible encoding and decoding using common fixtures' do
+            data = if encoding_spec['expectedHexValue']
+              encoding_spec['expectedHexValue'].scan(/../).map { |x| x.hex }.pack('c*')
+            else
+              encoding_spec['expectedValue']
+            end
+
+            realtime_channel.publish("event", data) do
+              response = rest_client.get("/channels/#{channel_name}/messages")
+              message = response.body[0]
+              expect(message['encoding']).to eql(encoding_spec['encoding'])
+              if message['encoding'] == 'json'
+                expect(JSON.parse(encoding_spec['data'])).to eql(JSON.parse(message['data']))
+              else
+                expect(encoding_spec['data']).to eql(message['data'])
+              end
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
+
+    context 'over a MsgPack transport' do
+      JSON.parse(File.read(fixtures_path))['messages'].each do |encoding_spec|
+        context "when publishing a #{encoding_spec['expectedType']} using JSON protocol" do
+          let(:rest_publish_client) do
+            Ably::Rest::Client.new(client_options.merge(protocol: :json))
+          end
+          let(:realtime_subscribe_client) do
+            Ably::Realtime::Client.new(client_options.merge(protocol: :msgpack))
+          end
+          let(:realtime_subscribe_channel) { realtime_subscribe_client.channels.get(channel_name) }
+
+          it 'receives the message over MsgPack and the data matches' do
+            expect(realtime_subscribe_client).to be_protocol_binary
+
+            realtime_subscribe_channel.attach do
+              realtime_subscribe_channel.subscribe do |message|
+                if encoding_spec['expectedHexValue']
+                  expect(message.data.unpack('H*').first).to eql(encoding_spec['expectedHexValue'])
+                else
+                  expect(message.data).to eql(encoding_spec['expectedValue'])
+                end
+                stop_reactor
+              end
+
+              raw_message = { "data" => encoding_spec['data'], "encoding" => encoding_spec['encoding'] }
+              rest_publish_client.post("/channels/#{channel_name}/messages", JSON.dump(raw_message))
+            end
+          end
+        end
+
+        context "when retrieving a #{encoding_spec['expectedType']} using JSON protocol" do
+          let(:rest_publish_client) do
+            Ably::Rest::Client.new(client_options.merge(protocol: :msgpack))
+          end
+          let(:rest_retrieve_client) do
+            Ably::Rest::Client.new(client_options.merge(protocol: :json))
+          end
+          let(:rest_publish_channel) { rest_publish_client.channels.get(channel_name) }
+
+          it 'is compatible with a publishes using MsgPack' do
+            expect(rest_publish_client).to be_protocol_binary
+
+            data = if encoding_spec['expectedHexValue']
+              encoding_spec['expectedHexValue'].scan(/../).map { |x| x.hex }.pack('c*')
+            else
+              encoding_spec['expectedValue']
+            end
+            rest_publish_channel.publish "event", data
+
+            response = rest_retrieve_client.get("/channels/#{channel_name}/messages")
+            message = response.body[0]
+            expect(message['encoding']).to eql(encoding_spec['encoding'])
+            expect(encoding_spec['data']).to eql(message['data'])
+            stop_reactor
+          end
+        end
+      end
+    end
+  end
 end

data/spec/acceptance/rest/auth_spec.rb

@@ -974,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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ably
 version: !ruby/object:Gem::Version
-  version: 0.8.12
+  version: 0.8.13
 platform: ruby
 authors:
 - Lewis Marshall
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-23 00:00:00.000000000 Z
+date: 2016-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine