ably 0.1.4 → 0.1.5

data/spec/integration/modules/state_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Ably::Modules::State do
+  class ExampleStateWithEventEmitter
+    include Ably::Modules::EventEmitter
+    extend  Ably::Modules::Enum
+
+    STATE = ruby_enum('STATE',
+      :initializing,
+      :connecting,
+      :connected,
+      :disconnected
+    )
+    include Ably::Modules::State
+
+    def initialize
+      @state = :initializing
+    end
+  end
+
+  let(:initial_state) { :initializing }
+
+  subject { ExampleStateWithEventEmitter.new }
+
+  specify '#state returns current state' do
+    expect(subject.state).to eq(:initializing)
+  end
+
+  specify '#state= sets current state' do
+    expect { subject.state = :connecting }.to change { subject.state }.to(:connecting)
+  end
+
+  specify '#change_state sets current state' do
+    expect { subject.change_state :connecting }.to change { subject.state }.to(:connecting)
+  end
+
+  context '#state?' do
+    it 'returns true if state matches' do
+      expect(subject.state?(initial_state)).to eql(true)
+    end
+
+    it 'returns false if state does not match' do
+      expect(subject.state?(:connecting)).to eql(false)
+    end
+
+    context 'and convenience predicates for states' do
+      it 'returns true if state matches' do
+        expect(subject.initializing?).to eql(true)
+      end
+
+      it 'returns false if state does not match' do
+        expect(subject.connecting?).to eql(false)
+      end
+    end
+  end
+
+  context '#state STATE coercion' do
+    it 'allows valid STATE values' do
+      expect { subject.state = :connected }.to_not raise_error
+    end
+
+    it 'prevents invalid STATE values' do
+      expect { subject.state = :invalid }.to raise_error KeyError
+    end
+  end
+end

data/spec/support/api_helper.rb

@@ -17,6 +17,10 @@ module ApiHelper
     TestApp.instance.api_key
   end
 
+  def restricted_api_key
+    TestApp.instance.restricted_api_key
+  end
+
   def environment
     TestApp.instance.environment
   end
@@ -31,11 +35,10 @@ RSpec.configure do |config|
 
   config.before(:suite) do
     WebMock.disable!
-    TestApp.instance
   end
 
   config.after(:suite) do
     WebMock.disable!
-    TestApp.instance.delete
+    TestApp.instance.delete if TestApp.instance_variable_get('@singleton__instance__')
   end
 end

data/spec/support/protocol_msgbus_helper.rb

@@ -0,0 +1,29 @@
+shared_examples 'a protocol message bus' do
+  describe '__protocol_msgbus__ PubSub' do
+    let(:message) { double(:message, name: 'name', channel: 'channel', messages: []) }
+
+    specify 'supports valid ProtocolMessage messages' do
+      received = 0
+      msgbus.subscribe(:message) { received += 1 }
+      expect { msgbus.publish(:message, message) }.to change { received }.to(1)
+    end
+
+    specify 'fail with unacceptable STATE event names' do
+      expect { msgbus.subscribe(:invalid) }.to raise_error KeyError
+      expect { msgbus.publish(:invalid) }.to raise_error KeyError
+      expect { msgbus.unsubscribe(:invalid) }.to raise_error KeyError
+    end
+  end
+end
+
+shared_examples 'an incoming protocol message bus' do
+  it_behaves_like 'a protocol message bus' do
+    let(:msgbus) { subject.__incoming_protocol_msgbus__ }
+  end
+end
+
+shared_examples 'an outgoing protocol message bus' do
+  it_behaves_like 'a protocol message bus' do
+    let(:msgbus) { subject.__outgoing_protocol_msgbus__ }
+  end
+end

data/spec/support/test_app.rb

@@ -3,7 +3,10 @@ require "singleton"
 class TestApp
   APP_SPEC = {
     'keys' => [
-      {}
+      {},
+      {
+        'capability' => '{ "*":["subscribe"], "canpublish:*":["publish"], "canpublish:andpresence":["presence","publish"] }'
+      }
     ],
     'namespaces' => [
       { 'id' => 'persisted', 'persisted' => true }
@@ -44,18 +47,26 @@ class TestApp
     @attributes["keys"].first
   end
 
+  def restricted_key
+    @attributes["keys"][1]
+  end
+
   def key_id
-    "#{app_id}.#{key["id"]}"
+    "#{app_id}.#{key['id']}"
   end
 
   def key_value
-    key["value"]
+    key['value']
   end
 
   def api_key
     "#{key_id}:#{key_value}"
   end
 
+  def restricted_api_key
+    "#{app_id}.#{restricted_key['id']}:#{restricted_key['value']}"
+  end
+
   def delete
     url = "#{sandbox_client.endpoint}/apps/#{app_id}"
 

data/spec/unit/{conversions.rb → modules/conversions_spec.rb}

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Ably::Modules::Conversions do
   let(:class_with_module) { Class.new do; include Ably::Modules::Conversions; end }

data/spec/unit/modules/enum_spec.rb

@@ -0,0 +1,263 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe Ably::Modules::Enum do
+  class ExampleClassWithEnum
+    extend Ably::Modules::Enum
+    ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', :value_zero, 'value_1', :value_snake_case_2, :SentenceCase)
+  end
+
+  let(:enum) { ExampleClassWithEnum::ENUMEXAMPLE }
+  let(:enum_name) { 'ENUMEXAMPLE' }
+
+  context 'convertor method added to class' do
+    subject { ExampleClassWithEnum }
+
+    it 'converts symbols' do
+      expect(subject.ENUMEXAMPLE(:value_zero)).to eql(enum.get(:value_zero))
+    end
+
+    it 'converts strings' do
+      expect(subject.ENUMEXAMPLE('ValueZero')).to eql(enum.get(:value_zero))
+    end
+
+    it 'converts integer index' do
+      expect(subject.ENUMEXAMPLE(0)).to eql(enum.get(:value_zero))
+    end
+  end
+
+  context 'convertor method added to instance' do
+    subject { ExampleClassWithEnum.new }
+
+    it 'converts symbols' do
+      expect(subject.ENUMEXAMPLE(:value_zero)).to eql(enum.get(:value_zero))
+    end
+
+    it 'converts strings' do
+      expect(subject.ENUMEXAMPLE('ValueZero')).to eql(enum.get(:value_zero))
+    end
+
+    it 'converts integer index' do
+      expect(subject.ENUMEXAMPLE(0)).to eql(enum.get(:value_zero))
+    end
+  end
+
+  context 'defined Enum from Array class' do
+    subject { enum }
+
+    it 'provides a MixedCase const for each provided value' do
+      expect(subject.ValueZero).to be_a(subject)
+      expect(subject.ValueSnakeCase2).to be_a(subject)
+    end
+
+    context '#get' do
+      context 'by integer index' do
+        let(:return_val) { subject.get(0) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_zero)
+        end
+      end
+
+      context 'by string value' do
+        let(:return_val) { subject.get('value_zero') }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_zero)
+        end
+      end
+
+      context 'by symbol' do
+        let(:return_val) { subject.get(:sentence_case) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:sentence_case)
+        end
+      end
+
+      context 'by enum' do
+        let(:return_val) { subject.get(subject.get(:sentence_case)) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:sentence_case)
+        end
+      end
+
+      context 'by invalid type' do
+        let(:return_val) { subject.get(Array.new) }
+        it 'raises an error' do
+          expect { return_val }.to raise_error KeyError
+        end
+      end
+    end
+
+    context '#[]' do
+      let(:argument) { SecureRandom.hex }
+      before do
+        expect(subject).to receive(:get).with(argument).once.and_return(true)
+      end
+
+      it 'is an alias for get' do
+        subject[argument]
+      end
+    end
+
+    it 'returns the provided Enum name' do
+      expect(subject.name).to eql(enum_name)
+    end
+
+    specify '#to_s returns the Enum name' do
+      expect("#{subject}").to eql(enum_name)
+    end
+
+    context '#size' do
+      it 'returns the number of enum items' do
+        expect(subject.size).to eql(4)
+      end
+
+      it 'has alias #length' do
+        expect(subject.length).to eql(subject.size)
+      end
+    end
+
+    it 'freezes the Enum' do
+      expect(subject.send(:by_index)).to be_frozen
+    end
+
+    it 'prevents modification' do
+      expect { subject.send(:define_values, :enum_id) }.to raise_error RuntimeError, /cannot be modified/
+    end
+
+    it 'behaves like Enumerable' do
+      expect(subject.map(&:to_sym)).to eql([:value_zero, :value_1, :value_snake_case_2, :sentence_case])
+    end
+  end
+
+  context 'defined Enum from Hash class' do
+    class ExampleClassWithEnumFromHash
+      extend Ably::Modules::Enum
+      ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE',
+        value_one:  1,
+        value_five: 5
+      )
+    end
+
+    subject { ExampleClassWithEnumFromHash::ENUMEXAMPLE }
+
+    it 'provides a MixedCase const for each provided value' do
+      expect(subject.ValueOne).to be_a(subject)
+      expect(subject.ValueFive).to be_a(subject)
+    end
+
+    context '#get' do
+      context 'by integer index for 1' do
+        let(:return_val) { subject.get(1) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_one)
+        end
+      end
+
+      context 'by integer index for 5' do
+        let(:return_val) { subject.get(5) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_five)
+        end
+      end
+
+      context 'by invalid integer index' do
+        let(:return_val) { subject.get(0) }
+        it 'raises an exception' do
+          expect { return_val }.to raise_error KeyError
+        end
+      end
+
+      context 'by string value' do
+        let(:return_val) { subject.get('value_five') }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_five)
+          expect(return_val.to_i).to eql(5)
+        end
+      end
+    end
+  end
+
+  context 'defined Enum from another Enum' do
+    class ExampleBaseEnum
+      extend Ably::Modules::Enum
+      ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', :one, :second_enum)
+    end
+
+    class ExampleOtherEnum
+      extend Ably::Modules::Enum
+      ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', ExampleBaseEnum::ENUMEXAMPLE)
+    end
+
+    subject { ExampleOtherEnum::ENUMEXAMPLE }
+
+    it 'provides a MixedCase const for each provided value' do
+      expect(subject.One).to be_a(subject)
+      expect(subject.SecondEnum).to be_a(subject)
+    end
+  end
+
+  context 'Enum instance' do
+    context '#==' do
+      subject { enum.get(:value_snake_case_2) }
+
+      it 'compares with a symbol' do
+        expect(subject).to eq(:value_Snake_Case_2)
+      end
+
+      it 'compares with a string' do
+        expect(subject).to eq('ValueSnakeCase2')
+      end
+
+      it 'compares with a integer index' do
+        expect(subject).to eq(subject.to_i)
+      end
+
+      it 'compares with itself' do
+        expect(subject).to eq(subject)
+      end
+
+      it 'compares with other Objects' do
+        expect(subject).to_not eq(Object.new)
+      end
+    end
+
+    context '#to_s' do
+      subject { enum.get(:value_zero) }
+
+      it 'returns ENUMNAME.CamelCase name' do
+        expect(subject.to_s).to eql("#{enum_name}.ValueZero")
+      end
+    end
+
+    context '#to_sym' do
+      subject { enum.get(:value_zero) }
+
+      it 'returns a snake_case symbol' do
+        expect(subject.to_sym).to eql(:value_zero)
+      end
+    end
+
+    context '#to_i' do
+      subject { enum.get(:value_1) }
+
+      it 'returns the Enum index' do
+        expect(subject.to_i).to eql(1)
+      end
+    end
+
+    context '#to_json' do
+      subject { enum.get(:value_1) }
+
+      it 'returns a symbol string key value' do
+        expect(subject.to_json).to eql('"value_1"')
+      end
+    end
+  end
+end

data/spec/unit/modules/event_emitter_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Ably::Modules::EventEmitter do
+  let(:options) { {} }
+  let(:klass) do
+    callback_opts = options
+    Class.new do
+      include Ably::Modules::EventEmitter
+      configure_event_emitter callback_opts
+    end
+  end
+  let(:obj) { double('example') }
+  let(:msg) { double('message') }
+
+  subject { klass.new }
+
+  context 'event fan out' do
+    specify do
+      expect(obj).to receive(:received_message).with(msg).twice
+      2.times do
+        subject.on(:message) { |msg| obj.received_message msg }
+      end
+      subject.trigger :message, msg
+    end
+
+    it 'sends only messages to matching event names' do
+      expect(obj).to receive(:received_message).with(msg).once
+      subject.on(:valid) { |msg| obj.received_message msg }
+      subject.trigger :valid, msg
+      subject.trigger :ignored, msg
+      subject.trigger 'valid', msg
+    end
+
+    context 'with coercion' do
+      let(:options) do
+        { coerce_into: Proc.new { |event| String(event) } }
+      end
+
+      it 'calls the provided proc to coerce the event name' do
+        expect(obj).to receive(:received_message).with(msg).once
+        subject.on('valid') { |msg| obj.received_message msg }
+        subject.trigger :valid, msg
+      end
+    end
+
+    context 'without coercion' do
+      it 'only matches event names on type matches' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.on('valid') { |msg| obj.received_message msg }
+        subject.trigger :valid, msg
+      end
+    end
+  end
+
+  context '#off' do
+    let(:callback) { Proc.new { |msg| obj.received_message msg } }
+
+    before do
+      subject.on(:message, &callback)
+    end
+
+    after do
+      subject.trigger :message, msg
+    end
+
+    it 'deletes matching callbacks' do
+      expect(obj).to_not receive(:received_message).with(msg)
+      subject.off(:message, &callback)
+    end
+
+    it 'deletes all callbacks if not block given' do
+      expect(obj).to_not receive(:received_message).with(msg)
+      subject.off(:message)
+    end
+
+    it 'continues if the block does not exist' do
+      expect(obj).to receive(:received_message).with(msg)
+      subject.off(:message) { true }
+    end
+  end
+end