ably 0.1.6 → 0.2.0

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe 'Ably::Realtime::Presence Messages' do
+  include RSpec::EventMachine
+
+  [:msgpack, :json].each do |protocol|
+    context "over #{protocol}" do
+      let(:default_options) { { api_key: api_key, environment: environment, protocol: protocol } }
+
+      let(:channel_name)        { "persisted:#{SecureRandom.hex(2)}" }
+
+      let(:client_one)          { Ably::Realtime::Client.new(default_options.merge(client_id: SecureRandom.hex(4))) }
+      let(:channel_client_one)  { client_one.channel(channel_name) }
+      let(:presence_client_one) { channel_client_one.presence }
+
+      let(:client_two)          { Ably::Realtime::Client.new(default_options.merge(client_id: SecureRandom.hex(4))) }
+      let(:channel_client_two)  { client_two.channel(channel_name) }
+      let(:presence_client_two) { channel_client_two.presence }
+
+      let(:data)         { SecureRandom.hex(8) }
+
+      it 'provides up to the moment presence history' do
+        run_reactor do
+          presence_client_one.enter(data: data) do
+            presence_client_one.leave do
+              history = presence_client_one.history
+              expect(history.count).to eql(2)
+
+              expect(history[1].action).to eq(:enter)
+              expect(history[1].client_id).to eq(client_one.client_id)
+
+              expect(history[0].action).to eq(:leave)
+              expect(history[0].client_id).to eq(client_one.client_id)
+              expect(history[0].data).to eql(data)
+
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      it 'ensures REST presence history message IDs match ProtocolMessage wrapped message IDs via Realtime' do
+        run_reactor do
+          presence_client_one.subscribe(:enter) do |message|
+            history = presence_client_one.history
+            expect(history.count).to eql(1)
+
+            expect(history[0].id).to eql(message.id)
+            stop_reactor
+          end
+
+          presence_client_one.enter(data: data)
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/realtime/presence_spec.rb

@@ -22,7 +22,7 @@ describe 'Ably::Realtime::Presence Messages' do
       let(:channel_client_two)        { client_two.channel(channel_name) }
       let(:presence_client_two)       { channel_client_two.presence }
 
-      let(:client_data_payload) { SecureRandom.hex(8) }
+      let(:data_payload) { SecureRandom.hex(8) }
 
       specify 'an attached channel that is not presence maintains presence state' do
         run_reactor do
@@ -126,7 +126,7 @@ describe 'Ably::Realtime::Presence Messages' do
 
       specify 'verify two clients appear in members from #get' do
         run_reactor do
-          presence_client_one.enter(client_data: client_data_payload)
+          presence_client_one.enter(data: data_payload)
           presence_client_two.enter
 
           entered_callback = Proc.new do
@@ -140,7 +140,7 @@ describe 'Ably::Realtime::Presence Messages' do
               member_client_two = members.find { |presence| presence.client_id == client_two.client_id }
 
               expect(member_client_one).to be_a(Ably::Models::PresenceMessage)
-              expect(member_client_one.client_data).to eql(client_data_payload)
+              expect(member_client_one.data).to eql(data_payload)
               expect(member_client_two).to be_a(Ably::Models::PresenceMessage)
 
               stop_reactor
@@ -158,7 +158,7 @@ describe 'Ably::Realtime::Presence Messages' do
 
           subscribe_client_one_leaving_callback = Proc.new do |presence_message|
             expect(presence_message.client_id).to eql(client_one.client_id)
-            expect(presence_message.client_data).to eql(client_data_payload)
+            expect(presence_message.data).to eql(data_payload)
             expect(presence_message.action).to eq(:leave)
 
             stop_reactor
@@ -171,7 +171,7 @@ describe 'Ably::Realtime::Presence Messages' do
               presence_client_two.unsubscribe &subscribe_self_callback
               presence_client_two.subscribe &subscribe_client_one_leaving_callback
 
-              presence_client_one.leave client_data: client_data_payload
+              presence_client_one.leave data: data_payload
             end
           end
 
@@ -182,24 +182,24 @@ describe 'Ably::Realtime::Presence Messages' do
         end
       end
 
-      specify 'verify REST #get returns current members' do
+      specify 'REST #get returns current members' do
         run_reactor do
-          presence_client_one.enter(client_data: client_data_payload) do
+          presence_client_one.enter(data: data_payload) do
             members = channel_rest_client_one.presence.get
             this_member = members.first
 
             expect(this_member).to be_a(Ably::Models::PresenceMessage)
             expect(this_member.client_id).to eql(client_one.client_id)
-            expect(this_member.client_data).to eql(client_data_payload)
+            expect(this_member.data).to eql(data_payload)
 
             stop_reactor
           end
         end
       end
 
-      specify 'verify REST #get returns no members once left' do
+      specify 'REST #get returns no members once left' do
         run_reactor do
-          presence_client_one.enter(client_data: client_data_payload) do
+          presence_client_one.enter(data: data_payload) do
             presence_client_one.leave do
               members = channel_rest_client_one.presence.get
               expect(members.count).to eql(0)
@@ -209,6 +209,148 @@ describe 'Ably::Realtime::Presence Messages' do
         end
       end
 
+      context 'encoding and decoding of presence message data' do
+        let(:secret_key)              { SecureRandom.hex(32) }
+        let(:cipher_options)          { { key: secret_key, algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+        let(:channel_name)            { SecureRandom.hex(32) }
+        let(:encrypted_channel)       { client_one.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+        let(:channel_rest_client_one) { client_one.rest_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+
+        let(:crypto)                  { Ably::Util::Crypto.new(cipher_options) }
+
+        let(:data)                    { { 'key' => SecureRandom.hex(64) } }
+        let(:data_as_json)            { data.to_json }
+        let(:data_as_cipher)          { crypto.encrypt(data.to_json) }
+
+        it 'encrypts presence message data' do
+          run_reactor do
+            encrypted_channel.attach do
+              encrypted_channel.presence.enter data: data
+            end
+
+            encrypted_channel.presence.__incoming_msgbus__.unsubscribe(:presence) # remove all subscribe callbacks that could decrypt the message
+            encrypted_channel.presence.__incoming_msgbus__.subscribe(:presence) do |presence|
+              if protocol == :json
+                expect(presence['encoding']).to eql('json/utf-8/cipher+aes-256-cbc/base64')
+                expect(crypto.decrypt(Base64.decode64(presence['data']))).to eql(data_as_json)
+              else
+                expect(presence['encoding']).to eql('json/utf-8/cipher+aes-256-cbc')
+                expect(crypto.decrypt(presence['data'])).to eql(data_as_json)
+              end
+              stop_reactor
+            end
+          end
+        end
+
+        it '#subscribe emits decrypted enter events' do
+          run_reactor do
+            encrypted_channel.attach do
+              encrypted_channel.presence.enter data: data
+            end
+
+            encrypted_channel.presence.subscribe(:enter) do |presence_message|
+              expect(presence_message.encoding).to be_nil
+              expect(presence_message.data).to eql(data)
+              stop_reactor
+            end
+          end
+        end
+
+        it '#subscribe emits decrypted update events' do
+          run_reactor do
+            encrypted_channel.attach do
+              encrypted_channel.presence.enter(data: 'to be updated') do
+                encrypted_channel.presence.update data: data
+              end
+            end
+
+            encrypted_channel.presence.subscribe(:update) do |presence_message|
+              expect(presence_message.encoding).to be_nil
+              expect(presence_message.data).to eql(data)
+              stop_reactor
+            end
+          end
+        end
+
+        it '#subscribe emits decrypted leave events' do
+          run_reactor do
+            encrypted_channel.attach do
+              encrypted_channel.presence.enter(data: 'to be updated') do
+                encrypted_channel.presence.leave data: data
+              end
+            end
+
+            encrypted_channel.presence.subscribe(:leave) do |presence_message|
+              expect(presence_message.encoding).to be_nil
+              expect(presence_message.data).to eql(data)
+              stop_reactor
+            end
+          end
+        end
+
+        it '#get returns a list of members with decrypted data' do
+          run_reactor do
+            encrypted_channel.attach do
+              encrypted_channel.presence.enter(data: data) do
+                member = encrypted_channel.presence.get.first
+                expect(member.encoding).to be_nil
+                expect(member.data).to eql(data)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        it 'REST #get returns a list of members with decrypted data' do
+          run_reactor do
+            encrypted_channel.attach do
+              encrypted_channel.presence.enter(data: data) do
+                member = channel_rest_client_one.presence.get.first
+                expect(member.encoding).to be_nil
+                expect(member.data).to eql(data)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'when cipher settings do not match publisher' do
+          let(:incompatible_cipher_options)    { { key: secret_key, algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+          let(:incompatible_encrypted_channel) { client_two.channel(channel_name, encrypted: true, cipher_params: incompatible_cipher_options) }
+
+          it 'delivers an unencoded presence message left with encoding value' do
+            run_reactor do
+              incompatible_encrypted_channel.attach do
+                encrypted_channel.attach do
+                  encrypted_channel.presence.enter(data: data) do
+                    member = incompatible_encrypted_channel.presence.get.first
+                    expect(member.encoding).to match(/cipher\+aes-256-cbc/)
+                    expect(member.data).to_not eql(data)
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+
+          it 'emits an error when cipher does not match and presence data cannot be decoded' do
+            run_reactor do
+              incompatible_encrypted_channel.attach do
+                incompatible_encrypted_channel.on(:error) do |error|
+                  expect(error).to be_a(Ably::Exceptions::CipherError)
+                  expect(error.message).to match(/Cipher algorithm AES-128-CBC does not match/)
+                  stop_reactor
+                end
+
+                encrypted_channel.attach do
+                  encrypted_channel.presence.enter data: data
+                end
+              end
+            end
+          end
+        end
+      end
+
       specify 'expect :left event once underlying connection is closed' do
         run_reactor do
           presence_client_one.on(:left) do
@@ -221,14 +363,14 @@ describe 'Ably::Realtime::Presence Messages' do
         end
       end
 
-      specify 'expect :left event with no client data to retain original client_data in Leave event' do
+      specify 'expect :left event with no client data to retain original data in Leave event' do
         run_reactor do
           presence_client_one.subscribe(:leave) do |message|
             expect(presence_client_one.get.count).to eq(0)
-            expect(message.client_data).to eq(client_data_payload)
+            expect(message.data).to eq(data_payload)
             stop_reactor
           end
-          presence_client_one.enter(client_data: client_data_payload) do
+          presence_client_one.enter(data: data_payload) do
             presence_client_one.leave
           end
         end
@@ -236,20 +378,20 @@ describe 'Ably::Realtime::Presence Messages' do
 
       specify '#update automatically connects' do
         run_reactor do
-          presence_client_one.update(client_data: client_data_payload) do
+          presence_client_one.update(data: data_payload) do
             expect(presence_client_one.state).to eq(:entered)
             stop_reactor
           end
         end
       end
 
-      specify '#update changes the client_data' do
+      specify '#update changes the data' do
         run_reactor do
-          presence_client_one.enter(client_data: 'prior') do
-            presence_client_one.update(client_data: client_data_payload)
+          presence_client_one.enter(data: 'prior') do
+            presence_client_one.update(data: data_payload)
           end
           presence_client_one.subscribe(:update) do |message|
-            expect(message.client_data).to eql(client_data_payload)
+            expect(message.data).to eql(data_payload)
             stop_reactor
           end
         end

data/spec/acceptance/rest/auth_spec.rb

@@ -1,19 +1,45 @@
-require "spec_helper"
-require "securerandom"
+require 'spec_helper'
+require 'securerandom'
+
+describe Ably::Auth do
+  include Ably::Modules::Conversions
 
-describe "REST" do
   [:msgpack, :json].each do |protocol|
     context "over #{protocol}" do
       let(:client) do
         Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
       end
       let(:auth) { client.auth }
+      let(:content_type) do
+        if protocol == :msgpack
+          'application/x-msgpack'
+        else
+          'application/json'
+        end
+      end
+
+      def request_body_includes(request, protocol, key, val)
+        body = if protocol == :msgpack
+          MessagePack.unpack(request.body)
+        else
+          JSON.parse(request.body)
+        end
+        body[key.to_s].to_s == val.to_s
+      end
+
+      def serialize(object, protocol)
+        if protocol == :msgpack
+          MessagePack.pack(token_response)
+        else
+          JSON.dump(token_response)
+        end
+      end
 
       describe "#request_token" do
         let(:ttl)        { 30 * 60 }
-        let(:capability) { { :foo => ["publish"] } }
+        let(:capability) { { :foo => ['publish'] } }
 
-        it "returns the requested token" do
+        it 'returns the requested token' do
           actual_token = auth.request_token(
             ttl:        ttl,
             capability: capability
@@ -25,16 +51,21 @@ describe "REST" do
           expect(actual_token.expires_at).to be_within(2).of(Time.now + ttl)
         end
 
-        %w(client_id ttl timestamp capability nonce).each do |option|
+        %w(client_id capability nonce timestamp ttl).each do |option|
           context "option :#{option}", webmock: true do
             let(:random)         { SecureRandom.random_number(1_000_000_000).to_s }
             let(:options)        { { option.to_sym => random } }
 
-            let(:token_response) { { access_token: {} }.to_json }
+            let(:token_response) { { access_token: {} } }
             let!(:request_token_stub) do
               stub_request(:post, "#{client.endpoint}/keys/#{key_id}/requestToken").
-                with(:body => hash_including({ option => random })).
-                to_return(:status => 201, :body => token_response, :headers => { 'Content-Type' => 'application/json' })
+                with do |request|
+                  request_body_includes(request, protocol, option, random)
+                end.to_return(
+                  :status => 201,
+                  :body => serialize(token_response, protocol),
+                  :headers => { 'Content-Type' => content_type }
+                )
             end
 
             before { auth.request_token options }
@@ -55,11 +86,15 @@ describe "REST" do
             hmac_for(token_request, key_secret)
           end
 
-          let(:token_response) { { access_token: {} }.to_json }
+          let(:token_response) { { access_token: {} } }
           let!(:request_token_stub) do
             stub_request(:post, "#{client.endpoint}/keys/#{key_id}/requestToken").
-              with(:body => hash_including({ 'mac' => mac })).
-              to_return(:status => 201, :body => token_response, :headers => { 'Content-Type' => 'application/json' })
+              with do |request|
+                request_body_includes(request, protocol, 'mac', mac)
+              end.to_return(
+                :status => 201,
+                :body => serialize(token_response, protocol),
+                :headers => { 'Content-Type' => content_type })
           end
 
           let!(:token) { auth.request_token(token_options) }
@@ -69,7 +104,7 @@ describe "REST" do
           end
         end
 
-        context "with :query_time option" do
+        context 'with :query_time option' do
           let(:options) { { query_time: true } }
 
           it 'queries the server for the time' do
@@ -78,7 +113,7 @@ describe "REST" do
           end
         end
 
-        context "without :query_time option" do
+        context 'without :query_time option' do
           let(:options) { { query_time: false } }
 
           it 'queries the server for the time' do
@@ -89,8 +124,8 @@ describe "REST" do
 
         context 'with :auth_url option', webmock: true do
           let(:auth_url)          { 'https://www.fictitious.com/get_token' }
-          let(:token_request)     { { id: key_id }.to_json }
-          let(:token_response)    { { access_token: { } }.to_json }
+          let(:token_request)     { { id: key_id } }
+          let(:token_response)    { { access_token: { } } }
           let(:query_params)      { nil }
           let(:headers)           { nil }
           let(:auth_method)       { :get }
@@ -105,15 +140,24 @@ describe "REST" do
 
           let!(:auth_url_request_stub) do
             stub = stub_request(auth_method, auth_url)
-            stub.with(:query => hash_including(query_params)) unless query_params.nil?
-            stub.with(:header => hash_including(headers)) unless headers.nil?
-            stub.to_return(:status => 201, :body => token_request, :headers => { 'Content-Type' => 'application/json' })
+            stub.with(:query => query_params) unless query_params.nil?
+            stub.with(:headers => headers) unless headers.nil?
+            stub.to_return(
+              :status => 201,
+              :body => token_request.to_json,
+              :headers => { 'Content-Type' => 'application/json' }
+            )
           end
 
           let!(:request_token_stub) do
             stub_request(:post, "#{client.endpoint}/keys/#{key_id}/requestToken").
-              with(:body => hash_including({ 'id' => key_id })).
-              to_return(:status => 201, :body => token_response, :headers => { 'Content-Type' => 'application/json' })
+              with do |request|
+                request_body_includes(request, protocol, 'id', key_id)
+              end.to_return(
+                :status => 201,
+                :body => serialize(token_response, protocol),
+                :headers => { 'Content-Type' => content_type }
+              )
           end
 
           context 'valid' do
@@ -244,30 +288,30 @@ describe "REST" do
         end
       end
 
-      describe "#create_token_request" do
+      describe '#create_token_request' do
         let(:ttl)           { 60 * 60 }
         let(:capability)    { { :foo => ["publish"] } }
         let(:options)       { Hash.new }
         subject { auth.create_token_request(options) }
 
-        it "uses the key ID from the client" do
+        it 'uses the key ID from the client' do
           expect(subject[:id]).to eql(key_id)
         end
 
-        it "uses the default TTL" do
+        it 'uses the default TTL' do
           expect(subject[:ttl]).to eql(Ably::Models::Token::DEFAULTS[:ttl])
         end
 
-        it "uses the default capability" do
+        it 'uses the default capability' do
           expect(subject[:capability]).to eql(Ably::Models::Token::DEFAULTS[:capability].to_json)
         end
 
-        it "has a unique nonce" do
+        it 'has a unique nonce' do
           unique_nonces = 100.times.map { auth.create_token_request[:nonce] }
           expect(unique_nonces.uniq.length).to eql(100)
         end
 
-        it "has a nonce of at least 16 characters" do
+        it 'has a nonce of at least 16 characters' do
           expect(subject[:nonce].length).to be >= 16
         end
 
@@ -283,7 +327,7 @@ describe "REST" do
           end
         end
 
-        context "invalid attributes" do
+        context 'invalid attributes' do
           let(:options) { { nonce: 'valid', is_not_used_by_token_request: 'invalid' } }
           specify 'are ignored' do
             expect(subject.keys).to_not include(:is_not_used_by_token_request)
@@ -292,19 +336,19 @@ describe "REST" do
           end
         end
 
-        context "missing key ID and/or secret" do
+        context 'missing key ID and/or secret' do
           let(:client) { Ably::Rest::Client.new(auth_url: 'http://example.com', protocol: protocol) }
 
-          it "should raise an exception if key secret is missing" do
+          it 'should raise an exception if key secret is missing' do
             expect { auth.create_token_request(key_id: 'id') }.to raise_error Ably::Exceptions::TokenRequestError
           end
 
-          it "should raise an exception if key id is missing" do
+          it 'should raise an exception if key id is missing' do
             expect { auth.create_token_request(key_secret: 'secret') }.to raise_error Ably::Exceptions::TokenRequestError
           end
         end
 
-        context "with :query_time option" do
+        context 'with :query_time option' do
           let(:time)    { Time.now - 30 }
           let(:options) { { query_time: true } }
 
@@ -314,7 +358,7 @@ describe "REST" do
           end
         end
 
-        context "with :timestamp option" do
+        context 'with :timestamp option' do
           let(:token_request_time) { Time.now + 5 }
           let(:options) { { timestamp: token_request_time } }
 
@@ -323,7 +367,7 @@ describe "REST" do
           end
         end
 
-        context "signing" do
+        context 'signing' do
           let(:options) do
             {
               id: SecureRandom.hex,
@@ -342,7 +386,7 @@ describe "REST" do
         end
       end
 
-      context "client with token authentication" do
+      context 'client with token authentication' do
         let(:capability) { { :foo => ["publish"] } }
 
         describe "with token_id argument" do
@@ -358,19 +402,19 @@ describe "REST" do
             Ably::Rest::Client.new(token_id: token_id, environment: environment, protocol: protocol)
           end
 
-          it "authenticates successfully" do
-            expect(token_auth_client.channel("foo").publish("event", "data")).to be_truthy
+          it 'authenticates successfully' do
+            expect(token_auth_client.channel('foo').publish('event', 'data')).to be_truthy
           end
 
-          it "disallows publishing on unspecified capability channels" do
-            expect { token_auth_client.channel("bar").publish("event", "data") }.to raise_error do |error|
+          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::InvalidToken)
               expect(error.status).to eql(401)
               expect(error.code).to eql(40160)
             end
           end
 
-          it "fails if timestamp is invalid" 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::InvalidToken)
               expect(error.status).to eql(401)
@@ -379,7 +423,7 @@ describe "REST" do
           end
         end
 
-        describe "implicit through client id" do
+        describe 'implicit through client id' do
           let(:client_id) { '999' }
           let(:client) do
             Ably::Rest::Client.new(api_key: api_key, client_id: client_id, environment: environment, protocol: protocol)
@@ -404,25 +448,25 @@ describe "REST" do
                 to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
             end
 
-            it "will create a token request" do
-              client.channel("foo").publish("event", "data")
+            it 'will create a token request' do
+              client.channel('foo').publish('event', 'data')
               expect(request_token_stub).to have_been_requested
             end
           end
 
-          context "will create a token" do
+          context 'will create a token' do
             let(:token) { client.auth.current_token }
 
-            it "before a request is made" do
+            it 'before a request is made' do
               expect(token).to be_nil
             end
 
-            it "when a message is published" do
-              expect(client.channel("foo").publish("event", "data")).to be_truthy
+            it 'when a message is published' do
+              expect(client.channel('foo').publish('event', 'data')).to be_truthy
             end
 
-            it "with capability and TTL defaults" do
-              client.channel("foo").publish("event", "data")
+            it 'with capability and TTL defaults' do
+              client.channel('foo').publish('event', 'data')
 
               expect(token).to be_a(Ably::Models::Token)
               capability_with_str_key = Ably::Models::Token::DEFAULTS[:capability]