ably 0.1.5 → 0.1.6

data/spec/acceptance/rest/stats_spec.rb

@@ -2,54 +2,55 @@ require "spec_helper"
 require "securerandom"
 
 describe "REST" do
-  let(:client) do
-    Ably::Rest::Client.new(api_key: api_key, environment: environment)
-  end
-
-  describe "fetching application stats" do
-    def number_of_channels()             3 end
-    def number_of_messages_per_channel() 5 end
+  [:json, :msgpack].each do |protocol|
+    context "over #{protocol}" do
+      describe "fetching application stats" do
+        before(:context) do
+          reload_test_app
+        end
 
-    before(:context) do
-      @context_client = Ably::Rest::Client.new(api_key: api_key, environment: environment)
+        def number_of_channels()             3 end
+        def number_of_messages_per_channel() 5 end
 
-      # Wait until the start of the next minute according to the service
-      # time because stats are created in 1 minute intervals
-      service_time    = @context_client.time
-      @interval_start = (service_time.to_i / 60 + 1) * 60
-      sleep_time      = @interval_start - Time.now.to_i
+        before(:context) do
+          @context_client = Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
 
-      if sleep_time > 30
-        @interval_start -= 60 # there is enough time to generate the stats in this minute interval
-      elsif sleep_time > 0
-        sleep sleep_time
-      end
+          # Wait until the start of the next minute according to the service
+          # time because stats are created in 1 minute intervals
+          service_time    = @context_client.time
+          @interval_start = (service_time.to_i / 60 + 1) * 60
+          sleep_time      = @interval_start - Time.now.to_i
 
-      number_of_channels.times do |i|
-        channel = @context_client.channel("stats-#{i}")
+          if sleep_time > 30
+            @interval_start -= 60 # there is enough time to generate the stats in this minute interval
+          elsif sleep_time > 0
+            sleep sleep_time
+          end
 
-        number_of_messages_per_channel.times do |j|
-          channel.publish("event-#{j}", "data-#{j}") || raise("Unable to publish message")
-        end
-      end
+          number_of_channels.times do |i|
+            channel = @context_client.channel("stats-#{i}")
 
-      sleep(10)
-    end
+            number_of_messages_per_channel.times do |j|
+              channel.publish("event-#{j}", "data-#{j}") || raise("Unable to publish message")
+            end
+          end
 
-    [:minute, :hour, :day, :month].each do |interval|
-      context "by #{interval}" do
-        it "should return all the stats for the application" do
-          stats = @context_client.stats(start: @interval_start * 1000, by: interval.to_s, direction: 'forwards')
+          sleep(10)
+        end
 
-          expect(stats.size).to eql(1)
+        [:minute, :hour, :day, :month].each do |interval|
+          context "by #{interval}" do
+            it "should return all the stats for the application" do
+              stats = @context_client.stats(start: @interval_start * 1000, by: interval.to_s, direction: 'forwards')
 
-          stat = stats.first
+              expect(stats.size).to eql(1)
 
-          expect(stat[:inbound][:all][:all][:count]).to eql(number_of_channels * number_of_messages_per_channel)
-          expect(stat[:inbound][:rest][:all][:count]).to eql(number_of_channels * number_of_messages_per_channel)
+              stat = stats.first
 
-          # TODO: Review number of Channels opened issue for intervals other than minute
-          expect(stat[:channels][:opened]).to eql(number_of_channels) if interval == :minute
+              expect(stat[:inbound][:all][:messages][:count]).to eql(number_of_channels * number_of_messages_per_channel)
+              expect(stat[:inbound][:rest][:messages][:count]).to eql(number_of_channels * number_of_messages_per_channel)
+            end
+          end
         end
       end
     end

data/spec/acceptance/rest/time_spec.rb

@@ -2,13 +2,17 @@ require "spec_helper"
 require "securerandom"
 
 describe "REST" do
-  let(:client) do
-    Ably::Rest::Client.new(api_key: api_key, environment: environment)
-  end
+  [: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
 
-  describe "fetching the service time" do
-    it "should return the service time as a Time object" do
-      expect(client.time).to be_within(2).of(Time.now)
+      describe "fetching the service time" do
+        it "should return the service time as a Time object" do
+          expect(client.time).to be_within(2).of(Time.now)
+        end
+      end
     end
   end
 end

data/spec/integration/modules/{state_spec.rb → state_emitter_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Ably::Modules::State do
+describe Ably::Modules::StateEmitter do
   class ExampleStateWithEventEmitter
     include Ably::Modules::EventEmitter
     extend  Ably::Modules::Enum
@@ -11,7 +11,7 @@ describe Ably::Modules::State do
       :connected,
       :disconnected
     )
-    include Ably::Modules::State
+    include Ably::Modules::StateEmitter
 
     def initialize
       @state = :initializing
@@ -34,6 +34,20 @@ describe Ably::Modules::State do
     expect { subject.change_state :connecting }.to change { subject.state }.to(:connecting)
   end
 
+  context '#change_state with arguments' do
+    let(:args) { [5,3,1] }
+    let(:callback_status) { { called: false } }
+
+    it 'passes the arguments through to the triggered callback' do
+      subject.on(:connecting) do |*callback_args|
+        expect(callback_args).to eql(args)
+        callback_status[:called] = true
+      end
+      expect { subject.change_state :connecting, *args }.to change { subject.state }.to(:connecting)
+      expect(callback_status).to eql(called: true)
+    end
+  end
+
   context '#state?' do
     it 'returns true if state matches' do
       expect(subject.state?(initial_state)).to eql(true)

data/spec/spec_helper.rb

@@ -16,6 +16,14 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 
+  config.mock_with :rspec do |mocks|
+    # This option should be set when all dependencies are being loaded
+    # before a spec run, as is the case in a typical spec helper. It will
+    # cause any verifying double instantiation for a class that does not
+    # exist to raise, protecting against incorrectly spelt names.
+    mocks.verify_doubled_constant_names = true
+  end
+
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
@@ -27,6 +35,12 @@ RSpec.configure do |config|
   end
 
   config.before(:example, :webmock => true) do
+    allow(TestApp).to receive(:instance).and_return(instance_double('TestApp',
+      app_id: 'app_id',
+      key_id: 'app_id.key_id',
+      api_key: 'app_id.key_id:secret',
+      environment: 'sandbox'
+    ))
     WebMock.enable!
   end
 end

data/spec/support/api_helper.rb

@@ -25,6 +25,10 @@ module ApiHelper
     TestApp.instance.environment
   end
 
+  def reload_test_app
+    TestApp.reload
+  end
+
   def encode64(text)
     Base64.encode64(text).gsub("\n", '')
   end

data/spec/support/model_helper.rb

@@ -1,7 +1,8 @@
 require 'securerandom'
 
-shared_examples 'a realtime model' do |shared_options = {}|
-  let(:args) { ([model_options] + model_args) }
+shared_examples 'a model' do |shared_options = {}|
+  let(:base_model_options) { shared_options.fetch(:base_model_options, {}) }
+  let(:args) { ([base_model_options.merge(model_options)] + model_args) }
   let(:model) { subject.new(*args) }
 
   context 'attributes' do
@@ -17,18 +18,18 @@ shared_examples 'a realtime model' do |shared_options = {}|
       end
     end
 
-    context '#json' do
+    context '#hash' do
       let(:model_options) { { action: 5 } }
 
-      it 'provides access to #json' do
-        expect(model.json).to eq(model_options)
+      it 'provides access to #hash' do
+        expect(model.hash).to eq(model_options)
       end
     end
 
     context '#[]' do
       let(:model_options) { { unusual: 'attribute' } }
 
-      it 'provides accessor method to #json' do
+      it 'provides accessor method to #hash' do
         expect(model[:unusual]).to eql('attribute')
       end
     end
@@ -51,17 +52,35 @@ shared_examples 'a realtime model' do |shared_options = {}|
     end
   end
 
+  context '#to_msgpack' do
+    let(:model_options) { { name: 'test', action: 0, channel_snake_case: 'unique' } }
+    let(:serialized)    { model.to_msgpack }
+
+    it 'returns a msgpack object with Ably payload naming' do
+      expect(MessagePack.unpack(serialized)).to include('channelSnakeCase' => 'unique')
+    end
+  end
+
+  context '#to_json' do
+    let(:model_options) { { name: 'test', action: 0, channel_snake_case: 'unique' } }
+    let(:serialized)    { model.to_json }
+
+    it 'returns a JSON string with Ably payload naming' do
+      expect(JSON.parse(serialized)).to include('channelSnakeCase' => 'unique')
+    end
+  end
+
   context 'is immutable' do
     let(:model_options) { { channel: 'name' } }
 
     it 'prevents changes' do
-      expect { model.json[:channel] = 'new' }.to raise_error RuntimeError, /can't modify frozen Hash/
+      expect { model.hash[:channel] = 'new' }.to raise_error RuntimeError, /can't modify frozen Hash/
     end
 
     it 'dups options' do
-      expect(model.json[:channel]).to eql('name')
+      expect(model.hash[:channel]).to eql('name')
       model_options[:channel] = 'new'
-      expect(model.json[:channel]).to eql('name')
+      expect(model.hash[:channel]).to eql('name')
     end
   end
 end

data/spec/support/protocol_msgbus_helper.rb

@@ -1,6 +1,13 @@
 shared_examples 'a protocol message bus' do
   describe '__protocol_msgbus__ PubSub' do
-    let(:message) { double(:message, name: 'name', channel: 'channel', messages: []) }
+    let(:message) do
+      Ably::Models::ProtocolMessage.new(
+        action: 15,
+        channel: 'channel',
+        msg_serial: 0,
+        messages: []
+      )
+    end
 
     specify 'supports valid ProtocolMessage messages' do
       received = 0

data/spec/support/test_app.rb

@@ -5,7 +5,7 @@ class TestApp
     'keys' => [
       {},
       {
-        'capability' => '{ "*":["subscribe"], "canpublish:*":["publish"], "canpublish:andpresence":["presence","publish"] }'
+        'capability' => '{ "cansubscribe:*":["subscribe"], "canpublish:*":["publish"], "canpublish:andpresence":["presence","publish"] }'
       }
     ],
     'namespaces' => [
@@ -15,28 +15,25 @@ class TestApp
       {
         'name' => 'persisted:presence_fixtures',
         'presence' => [
-          { 'clientId' => 'client_bool',    'clientData' => true },
-          { 'clientId' => 'client_int',     'clientData' => 24 },
+          { 'clientId' => 'client_bool',    'clientData' => 'true' },
+          { 'clientId' => 'client_int',     'clientData' => '24' },
           { 'clientId' => 'client_string',  'clientData' => 'This is a string clientData payload' },
-          { 'clientId' => 'client_json',    'clientData' => { "test" => 'This is a JSONObject clientData payload'} }
+          { 'clientId' => 'client_json',    'clientData' => '{ "test" => \'This is a JSONObject clientData payload\'}' }
         ]
       }
     ]
   }
 
+  # If an app has already been created and we need a new app, create a new test app
+  # This is sometimes needed when a test needs to be isolated from any other tests
+  def self.reload
+    instance.create_test_app if instance_variable_get('@singleton__instance__')
+  end
+
   include Singleton
 
   def initialize
-    url = "#{sandbox_client.endpoint}/apps"
-
-    headers = {
-      "Accept"       => "application/json",
-      "Content-Type" => "application/json"
-    }
-
-    response = Faraday.post(url, APP_SPEC.to_json, headers)
-
-    @attributes = JSON.parse(response.body)
+    create_test_app
   end
 
   def app_id
@@ -80,6 +77,19 @@ class TestApp
     'sandbox'
   end
 
+  def create_test_app
+    url = "#{sandbox_client.endpoint}/apps"
+
+    headers = {
+      "Accept"       => "application/json",
+      "Content-Type" => "application/json"
+    }
+
+    response = Faraday.post(url, APP_SPEC.to_json, headers)
+
+    @attributes = JSON.parse(response.body)
+  end
+
   private
   def sandbox_client
     @sandbox_client ||= Ably::Rest::Client.new(api_key: 'app.key:secret', tls: true, environment: environment)

data/spec/unit/{realtime → models}/error_info_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 require 'support/model_helper'
 
-describe Ably::Realtime::Models::ErrorInfo do
-  subject { Ably::Realtime::Models::ErrorInfo }
+describe Ably::Models::ErrorInfo do
+  subject { Ably::Models::ErrorInfo }
 
-  it_behaves_like 'a realtime model', with_simple_attributes: %w(code status_code message) do
+  it_behaves_like 'a model', with_simple_attributes: %w(code status_code message) do
     let(:model_args) { [] }
   end
 
   context '#status' do
-    subject { Ably::Realtime::Models::ErrorInfo.new('statusCode' => 401) }
+    subject { Ably::Models::ErrorInfo.new('statusCode' => 401) }
     it 'is an alias for #status_code' do
       expect(subject.status).to eql(subject.status_code)
       expect(subject.status).to eql(401)

data/spec/unit/models/idiomatic_ruby_wrapper_spec.rb

@@ -15,7 +15,7 @@ describe Ably::Models::IdiomaticRubyWrapper do
         {
           'mixedCaseChild' => 'exists'
         }
-      ],
+      ]
     }
   end
   subject { Ably::Models::IdiomaticRubyWrapper.new(mixed_case_data) }
@@ -58,8 +58,8 @@ describe Ably::Models::IdiomaticRubyWrapper do
     expect { subject.no_key_exists_for_this }.to raise_error NoMethodError
   end
 
-  specify '#json returns raw JSON object' do
-    expect(subject.json).to eql(mixed_case_data)
+  specify '#hash returns raw Hash object' do
+    expect(subject.hash).to eql(mixed_case_data)
   end
 
   context 'recursively wrapping child objects' do
@@ -154,17 +154,29 @@ describe Ably::Models::IdiomaticRubyWrapper do
       end
 
       it 'uses mixedCase' do
-        expect(subject.json['newKey']).to eql('new_value')
+        expect(subject.hash['newKey']).to eql('new_value')
         expect(subject.new_key).to eql('new_value')
       end
     end
   end
 
   context 'acts like a duck' do
+    let(:parsed_json) { JSON.parse(subject.to_json) }
     specify '#to_json returns JSON stringified' do
       expect(subject.to_json).to eql(mixed_case_data.to_json)
     end
 
+    specify '#to_json returns child JSON objects in the JSON stringified' do
+      expect(parsed_json['arrayObject']).to eql(mixed_case_data['arrayObject'])
+    end
+
+    context 'with snake case JSON' do
+      let(:subject) { Ably::Models::IdiomaticRubyWrapper.new('wrong_case' => 'will_be_corrected')}
+      specify '#to_json uses mixedCase for any non mixedCase keys' do
+        expect(parsed_json['wrongCase']).to eql('will_be_corrected')
+      end
+    end
+
     context '#to_json with changes' do
       before do
         @original_mixed_case_data = mixed_case_data.to_json
@@ -263,13 +275,38 @@ describe Ably::Models::IdiomaticRubyWrapper do
     context '#to_hash' do
       let(:mixed_case_data) do
         {
-          'key' => 'value'
+          'key' => 'value',
+          'childObject' => {
+            'child' => true
+          }
         }
       end
 
       it 'returns a hash' do
         expect(subject.to_hash).to include(key: 'value')
       end
+
+      it 'converts hashes within hashes' do
+        expect(subject.to_hash[:child_object]).to include(child: true)
+      end
+    end
+
+    context '#to_msgpack' do
+      let(:mixed_case_data) do
+        {
+          'key' => 'value',
+          'child' => {
+            'with_attributes' => true
+          }
+        }
+      end
+      let(:msg_packed) { subject.to_msgpack }
+      let(:unpacked)   { MessagePack.unpack(msg_packed) }
+
+      it 'returns a msgpack object' do
+        expect(unpacked).to include('key' => 'value')
+        expect(unpacked).to include('child' => { 'withAttributes' => true })
+      end
     end
 
     context '#dup' do
@@ -281,14 +318,14 @@ describe Ably::Models::IdiomaticRubyWrapper do
       let(:dupe) { subject.dup }
 
       it 'returns a new object with the underlying JSON duped' do
-        expect(subject.json).to be_frozen
-        expect(dupe.json).to_not be_frozen
+        expect(subject.hash).to be_frozen
+        expect(dupe.hash).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.json).to be_a(Hash)
-        expect(dupe.json).to eql(mixed_case_data)
+        expect(dupe.hash).to be_a(Hash)
+        expect(dupe.hash).to eql(mixed_case_data)
       end
     end
   end