pubnub 4.0.27 → 4.0.28

data/spec/lib/events/publish_spec.rb

@@ -1,39 +1,33 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Pubnub::Publish do
-  it_behaves_like 'an event'
+  it_behaves_like "an event"
 
-  around :each do |example|
-    Celluloid.boot
-    example.run
-    Celluloid.shutdown
-  end
-
-  context 'given basic parameters' do
+  context "given basic parameters" do
     before :each do
       @pubnub = Pubnub::Client.new(
-          subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-          publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-          auth_key: 'ruby-test-auth',
-          uuid: 'ruby-test-uuid'
+        subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+        publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+        auth_key: "ruby-test-auth",
+        uuid: "ruby-test-uuid",
       )
     end
-    it 'works' do
-      VCR.use_cassette('lib/events/publish', record: :once) do
+    it "works" do
+      VCR.use_cassette("lib/events/publish", record: :once) do
         envelope = @pubnub.publish(
-            channel: :demo,
-            message: 'whatever'
+          channel: :demo,
+          message: "whatever",
         ).value
 
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
       end
     end
 
-    it 'forms valid ErrorEnvelope on error' do
-      VCR.use_cassette('lib/events/publish-error', record: :once) do
+    it "forms valid ErrorEnvelope on error" do
+      VCR.use_cassette("lib/events/publish-error", record: :once) do
         envelope = @pubnub.publish(
-            channel: :demo,
-            message: 'whatever'
+          channel: :demo,
+          message: "whatever",
         ).value
 
         expect(envelope.is_a?(Pubnub::ErrorEnvelope)).to eq true
@@ -42,39 +36,38 @@ describe Pubnub::Publish do
     end
   end
 
-  context 'store, replicate' do
+  context "store, replicate" do
     before(:each) do
       @pubnub = Pubnub.new(
-          :max_retries => 0,
-          :subscribe_key => :demo,
-          :publish_key => :demo,
-          :auth_key => :demoish_authkey,
-          :error_callback => @error_callback
+        :max_retries => 0,
+        :subscribe_key => :demo,
+        :publish_key => :demo,
+        :auth_key => :demoish_authkey,
+        :error_callback => @error_callback,
       )
 
-      @pubnub.uuid = 'tester'
+      @pubnub.uuid = "tester"
     end
 
-    it 'works' do
-      VCR.use_cassette('integration/publish/publish-store-replicate', record: :once) do
+    it "works" do
+      VCR.use_cassette("integration/publish/publish-store-replicate", record: :once) do
         future = @pubnub.publish(
-            message: { text: 'sometext' },
-            channel: 'ruby_demo_channel',
-            callback: @callback,
-            store: false,
-            replicate: false
+          message: {text: "sometext"},
+          channel: "ruby_demo_channel",
+          callback: @callback,
+          store: false,
+          replicate: false,
         )
 
         future.value
       end
     end
 
-    it 'works with fire method' do
-      VCR.use_cassette('integration/publish/publish-store-replicate', record: :once) do
-
+    it "works with fire method" do
+      VCR.use_cassette("integration/publish/publish-store-replicate", record: :once) do
         future = @pubnub.fire(
-            message: { text: 'sometext' },
-            channel: 'ruby_demo_channel',
+          message: {text: "sometext"},
+          channel: "ruby_demo_channel",
         )
 
         future.value

data/spec/lib/events/revoke_spec.rb

@@ -1,32 +1,26 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Pubnub::Revoke do
-  it_behaves_like 'an event'
+  it_behaves_like "an event"
 
-  around :each do |example|
-    Celluloid.boot
-    example.run
-    Celluloid.shutdown
-  end
-
-  context 'given basic parameters' do
+  context "given basic parameters" do
     before :each do
       Pubnub::Revoke.any_instance.stub(:current_time).and_return 1463307484
-      Pubnub::Revoke.any_instance.stub(:signature).and_return '7FvZ9FQeu9q_uTx8ICyK8CiWDOeD1Qc6nrsNfqP0fyY='
+      Pubnub::Revoke.any_instance.stub(:signature).and_return "7FvZ9FQeu9q_uTx8ICyK8CiWDOeD1Qc6nrsNfqP0fyY="
 
       @pubnub = Pubnub::Client.new(
-          subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-          publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-          secret_key: 'sec-c-OWIyYmVlYWYtYWMxMS00OTcxLTlhZDAtZDBlYTM4ODE1MWUy',
-          auth_key: 'ruby-test-auth',
-          uuid: 'ruby-test-uuid'
+        subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+        publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+        secret_key: "sec-c-OWIyYmVlYWYtYWMxMS00OTcxLTlhZDAtZDBlYTM4ODE1MWUy",
+        auth_key: "ruby-test-auth",
+        uuid: "ruby-test-uuid",
       )
     end
 
-    it 'works' do
-      VCR.use_cassette('lib/events/revoke', record: :once) do
+    it "works" do
+      VCR.use_cassette("lib/events/revoke", record: :once) do
         envelope = @pubnub.revoke(
-            channel: :demo
+          channel: :demo,
         ).value
 
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
@@ -34,10 +28,10 @@ describe Pubnub::Revoke do
       end
     end
 
-    it 'forms valid ErrorEnvelope on error' do
-      VCR.use_cassette('lib/events/revoke-error', record: :once) do
+    it "forms valid ErrorEnvelope on error" do
+      VCR.use_cassette("lib/events/revoke-error", record: :once) do
         envelope = @pubnub.revoke(
-            channel: :demo
+          channel: :demo,
         ).value
 
         expect(envelope.is_a?(Pubnub::ErrorEnvelope)).to eq true
@@ -46,4 +40,4 @@ describe Pubnub::Revoke do
       end
     end
   end
-end
+end

data/spec/lib/events/state_spec.rb

@@ -1,29 +1,23 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Pubnub::State do
-  it_behaves_like 'an event'
+  it_behaves_like "an event"
 
-  around :each do |example|
-    Celluloid.boot
-    example.run
-    Celluloid.shutdown
-  end
-
-  context 'given basic parameters' do
+  context "given basic parameters" do
     before :each do
       @pubnub = Pubnub::Client.new(
-          subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-          publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-          auth_key: 'ruby-test-auth',
-          uuid: 'ruby-test-uuid'
+        subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+        publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+        auth_key: "ruby-test-auth",
+        uuid: "ruby-test-uuid",
       )
     end
 
-    it 'works' do
-      VCR.use_cassette('lib/events/state', record: :once) do
+    it "works" do
+      VCR.use_cassette("lib/events/state", record: :once) do
         envelope = @pubnub.state(
-            channel: :demo,
-            uuid: :whatever
+          channel: :demo,
+          uuid: :whatever,
         ).value
 
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
@@ -31,11 +25,11 @@ describe Pubnub::State do
       end
     end
 
-    it 'forms valid ErrorEnvelope on error' do
-      VCR.use_cassette('lib/events/state-error', record: :once) do
+    it "forms valid ErrorEnvelope on error" do
+      VCR.use_cassette("lib/events/state-error", record: :once) do
         envelope = @pubnub.state(
-            channel: :demo,
-            uuid: :whatever
+          channel: :demo,
+          uuid: :whatever,
         ).value
 
         expect(envelope.is_a?(Pubnub::ErrorEnvelope)).to eq true
@@ -43,4 +37,4 @@ describe Pubnub::State do
       end
     end
   end
-end
+end

data/spec/lib/events/subscribe_spec.rb

@@ -1,34 +1,33 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Pubnub::Subscribe do
   # it_behaves_like 'an event'
 
   around :each do |example|
-    Celluloid.boot
-    example.run
-    Celluloid.shutdown
+    example.run_with_retry retry: 10
   end
 
-  context 'given basic parameters' do
+
+  context "given basic parameters" do
     before :each do
       @messages = []
       @statuses = []
 
       @callbacks = Pubnub::SubscribeCallback.new(
-          message: ->(envelope) { @messages << envelope },
-          presence: ->(_envelope) {},
-          status: ->(envelope) { @statuses << envelope }
+        message: -> (envelope) { @messages << envelope },
+        presence: -> (_envelope) { },
+        status: -> (envelope) { @statuses << envelope },
       )
     end
 
-    context 'async' do
-      it 'works' do
-        VCR.use_cassette('lib/events/subscribe-async', record: :once) do
+    context "async" do
+      it "works" do
+        VCR.use_cassette("lib/events/subscribe-async", record: :once) do
           @pubnub = Pubnub::Client.new(
-              subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-              publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-              auth_key: 'ruby-test-auth',
-              uuid: 'ruby-test-uuid'
+            subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+            publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+            auth_key: "ruby-test-auth",
+            uuid: "ruby-test-uuid",
           )
 
           @pubnub.add_listener(callback: @callbacks)
@@ -40,53 +39,51 @@ describe Pubnub::Subscribe do
             expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
             expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema
           end
-
         end
       end
 
-      it 'works with cipher key' do
+      it "works with cipher key" do
         @pubnub = Pubnub::Client.new(
-            subscribe_key: 'demo',
-            publish_key: 'demo',
-            uuid: 'ruby-test-uuid',
-            cipher_key: 'demo'
+          subscribe_key: "demo",
+          publish_key: "demo",
+          uuid: "ruby-test-uuid",
+          cipher_key: "demo",
         )
 
         @pubnub.add_listener(callback: @callbacks)
 
-        VCR.use_cassette('lib/events/subscribe-cipher-async', record: :once) do
+        VCR.use_cassette("lib/events/subscribe-cipher-async", record: :once) do
           @pubnub.subscribe(channel: :whatever)
 
           eventually do
-            expect(@messages.first.result[:data][:message]).to eq('text' => 'hey')
+            expect(@messages.first.result[:data][:message]).to eq("text" => "hey")
           end
         end
       end
 
-      it 'allows subscribing additional channels' do
+      it "allows subscribing additional channels" do
         @pubnub = Pubnub::Client.new(
-            subscribe_key: 'demo',
-            publish_key: 'demo',
-            uuid: 'ruby-test-uuid'
+          subscribe_key: "demo",
+          publish_key: "demo",
+          uuid: "ruby-test-uuid",
         )
 
-        VCR.use_cassette('lib/events/subscribe-playing-async', record: :once) do
+        VCR.use_cassette("lib/events/subscribe-playing-async", record: :once) do
           @pubnub.subscribe(channel: :demo)
           #sleep(0.1)
           @pubnub.subscribe(channel: :whatever)
           #sleep(0.1)
           @pubnub.leave(channel: [:whatever, :demo])
         end
-
       end
 
-      it 'fires status callback on error' do
-        VCR.use_cassette('lib/events/subscribe-async-error', record: :once) do
+      it "fires status callback on error" do
+        VCR.use_cassette("lib/events/subscribe-async-error", record: :once) do
           @pubnub = Pubnub::Client.new(
-              subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-              publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-              auth_key: 'ruby-test-auth',
-              uuid: 'ruby-test-uuid'
+            subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+            publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+            auth_key: "ruby-test-auth",
+            uuid: "ruby-test-uuid",
           )
 
           @pubnub.add_listener(callback: @callbacks)
@@ -99,56 +96,53 @@ describe Pubnub::Subscribe do
             expect(envelope).to be_a_kind_of Pubnub::ErrorEnvelope
             expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
           end
-
         end
       end
     end
 
-    context 'sync' do
-      it 'works with cipher key' do
+    context "sync" do
+      it "works with cipher key" do
         @pubnub = Pubnub::Client.new(
-            subscribe_key: 'demo',
-            publish_key: 'demo',
-            uuid: 'ruby-test-uuid',
-            cipher_key: 'demo'
+          subscribe_key: "demo",
+          publish_key: "demo",
+          uuid: "ruby-test-uuid",
+          cipher_key: "demo",
         )
 
-        VCR.use_cassette('lib/events/subscribe-cipher-async', record: :once) do
+        VCR.use_cassette("lib/events/subscribe-cipher-async", record: :once) do
           @pubnub.subscribe(channel: :whatever, http_sync: true)
           @messages = @pubnub.subscribe(channel: :whatever, http_sync: true)
           eventually do
-            expect(@messages.first.result[:data][:message]).to eq('text' => 'hey')
+            expect(@messages.first.result[:data][:message]).to eq("text" => "hey")
           end
         end
       end
 
-      it 'works' do
-        VCR.use_cassette('lib/events/subscribe-sync', record: :once) do
+      it "works" do
+        VCR.use_cassette("lib/events/subscribe-sync", record: :once) do
           @pubnub = Pubnub::Client.new(
-              subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-              publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-              auth_key: 'ruby-test-auth',
-              uuid: 'ruby-test-uuid'
+            subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+            publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+            auth_key: "ruby-test-auth",
+            uuid: "ruby-test-uuid",
           )
 
           @pubnub.subscribe(channel: :demo, http_sync: true)
           envelopes = @pubnub.subscribe(channel: :demo, http_sync: true)
 
-
           envelope = envelopes.first
           expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
           expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema
-
         end
       end
 
-      it 'fires status callback on error' do
-        VCR.use_cassette('lib/events/subscribe-sync-error', record: :once) do
+      it "fires status callback on error" do
+        VCR.use_cassette("lib/events/subscribe-sync-error", record: :once) do
           @pubnub = Pubnub::Client.new(
-              subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-              publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-              auth_key: 'ruby-test-auth',
-              uuid: 'ruby-test-uuid'
+            subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+            publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+            auth_key: "ruby-test-auth",
+            uuid: "ruby-test-uuid",
           )
 
           @pubnub.subscribe(channel: :demo, http_sync: true)
@@ -157,40 +151,36 @@ describe Pubnub::Subscribe do
           envelope = envelopes.first
           expect(envelope).to be_a_kind_of Pubnub::ErrorEnvelope
           expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
-
         end
       end
     end
 
-    context 'aliases' do
-      it 'pass channels to channel' do
-        VCR.use_cassette('lib/events/subscribe-sync', record: :once) do
+    context "aliases" do
+      it "pass channels to channel" do
+        VCR.use_cassette("lib/events/subscribe-sync", record: :once) do
           @pubnub = Pubnub::Client.new(
-              subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-              publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-              auth_key: 'ruby-test-auth',
-              uuid: 'ruby-test-uuid'
+            subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+            publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+            auth_key: "ruby-test-auth",
+            uuid: "ruby-test-uuid",
           )
 
           @pubnub.subscribe(channels: :demo, http_sync: true)
           envelopes = @pubnub.subscribe(channels: :demo, http_sync: true)
 
-
           envelope = envelopes.first
           expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
           expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema
-
         end
       end
 
-      it 'pass channel_groups to channel_group' do
-        VCR.use_cassette('lib/events/subscribe-channel-groups', record: :once) do
-
+      it "pass channel_groups to channel_group" do
+        VCR.use_cassette("lib/events/subscribe-channel-groups", record: :once) do
           @pubnub = Pubnub::Client.new(
-              subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-              publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-              auth_key: 'ruby-test-auth',
-              uuid: 'ruby-test-uuid'
+            subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+            publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+            auth_key: "ruby-test-auth",
+            uuid: "ruby-test-uuid",
           )
 
           @pubnub.subscribe(channel_groups: :demo, http_sync: true)
@@ -203,18 +193,18 @@ describe Pubnub::Subscribe do
       end
     end
 
-    context 'flags' do
-      it 'with with_presence' do
-        VCR.use_cassette('lib/events/subscribe-with-presence', record: :once) do
+    context "flags" do
+      it "with with_presence" do
+        VCR.use_cassette("lib/events/subscribe-with-presence", record: :once) do
           @pubnub = Pubnub::Client.new(
-            subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-            publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-            auth_key: 'ruby-test-auth',
-            uuid: 'ruby-test-uuid'
+            subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+            publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+            auth_key: "ruby-test-auth",
+            uuid: "ruby-test-uuid",
           )
 
-          @pubnub.subscribe(channels: [:demo, :demo1, 'demo.*'], with_presence: true, http_sync: true)
-          envelopes = @pubnub.subscribe(channels: [:demo, :demo1, 'demo.*'], with_presence: true, http_sync: true)
+          @pubnub.subscribe(channels: [:demo, :demo1, "demo.*"], with_presence: true, http_sync: true)
+          envelopes = @pubnub.subscribe(channels: [:demo, :demo1, "demo.*"], with_presence: true, http_sync: true)
 
           envelope = envelopes.first
           expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
@@ -223,4 +213,4 @@ describe Pubnub::Subscribe do
       end
     end
   end
-end
+end