pubnub 4.0.27 → 4.0.28

data/spec/examples/time_examples_spec.rb

@@ -1,129 +1,113 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Pubnub::Time do
   around :each do |example|
-    Celluloid.boot
-
     @fired = false
 
-    @callback = ->(_envelope) do
+    @callback = -> (_envelope) do
       @fired = true
     end
 
     @pubnub = Pubnub.new(
-      publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-      subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-      uuid: 'ruby-test-uuid-client-one',
-      auth_key: 'ruby-test-auth-client-one'
+      publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+      subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+      uuid: "ruby-test-uuid-client-one",
+      auth_key: "ruby-test-auth-client-one",
     )
 
-    example.run
-    Celluloid.shutdown
+    example.run_with_retry retry: 10
   end
 
-  it '__http_sync__true___callback__nil_' do
-VCR.use_cassette('examples/time/5', record: :none) do
-envelope = @pubnub.time(http_sync: true)
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
-
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
-
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:time)
-
-end
-end
-
-
-it '__http_sync__true___callback___block_' do
-VCR.use_cassette('examples/time/3', record: :none) do
-envelope = @pubnub.time(http_sync: true, &@callback)
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
-
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
-
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:time)
-
-end
-end
-
-
-it '__http_sync__true___callback___lambda_' do
-VCR.use_cassette('examples/time/4', record: :none) do
-envelope = @pubnub.time(http_sync: true, callback: @callback)
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
-
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
-
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:time)
-
-end
-end
+  it "__http_sync__true___callback__nil_" do
+    VCR.use_cassette("examples/time/5", record: :none) do
+      envelope = @pubnub.time(http_sync: true)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
-it '__http_sync__false___callback__nil_' do
-VCR.use_cassette('examples/time/2', record: :none) do
-envelope = @pubnub.time(http_sync: false)
-envelope = envelope.value
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:time)
+    end
+  end
 
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
+  it "__http_sync__true___callback___block_" do
+    VCR.use_cassette("examples/time/3", record: :none) do
+      envelope = @pubnub.time(http_sync: true, &@callback)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:time)
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
-end
-end
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:time)
+    end
+  end
 
+  it "__http_sync__true___callback___lambda_" do
+    VCR.use_cassette("examples/time/4", record: :none) do
+      envelope = @pubnub.time(http_sync: true, callback: @callback)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
-it '__http_sync__false___callback___block_' do
-VCR.use_cassette('examples/time/0', record: :none) do
-envelope = @pubnub.time(http_sync: false, &@callback)
-envelope = envelope.value
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:time)
+    end
+  end
 
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:time)
+  it "__http_sync__false___callback__nil_" do
+    VCR.use_cassette("examples/time/2", record: :none) do
+      envelope = @pubnub.time(http_sync: false)
+      envelope = envelope.value
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
-end
-end
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:time)
+    end
+  end
 
-it '__http_sync__false___callback___lambda_' do
-VCR.use_cassette('examples/time/1', record: :none) do
-envelope = @pubnub.time(http_sync: false, callback: @callback)
-envelope = envelope.value
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
+  it "__http_sync__false___callback___block_" do
+    VCR.use_cassette("examples/time/0", record: :none) do
+      envelope = @pubnub.time(http_sync: false, &@callback)
+      envelope = envelope.value
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:time)
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:time)
+    end
+  end
 
-end
-end
+  it "__http_sync__false___callback___lambda_" do
+    VCR.use_cassette("examples/time/1", record: :none) do
+      envelope = @pubnub.time(http_sync: false, callback: @callback)
+      envelope = envelope.value
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:time)
+    end
+  end
 end

data/spec/examples/where_now_examples_spec.rb

@@ -1,135 +1,119 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Pubnub::WhereNow do
   around :each do |example|
-    Celluloid.boot
-
     @fired = false
 
-    @callback = ->(_envelope) do
+    @callback = -> (_envelope) do
       @fired = true
     end
 
     @pubnub = Pubnub.new(
-      publish_key: 'pub-c-b42cec2f-f468-4784-8833-dd2b074538c4',
-      subscribe_key: 'sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f',
-      uuid: 'ruby-test-uuid-client-one',
-      auth_key: 'ruby-test-auth-client-one'
+      publish_key: "pub-c-b42cec2f-f468-4784-8833-dd2b074538c4",
+      subscribe_key: "sub-c-b7fb805a-1777-11e6-be83-0619f8945a4f",
+      uuid: "ruby-test-uuid-client-one",
+      auth_key: "ruby-test-auth-client-one",
     )
 
-    example.run
-    Celluloid.shutdown
+    example.run_with_retry retry: 10
   end
 
-  it '__uuid___ruby-test-uuid____http_sync__true___callback__nil_' do
-VCR.use_cassette('examples/where_now/5', record: :none) do
-envelope = @pubnub.where_now(uuid: 'ruby-test-uuid', http_sync: true)
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
-
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
-
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:where_now)
-expect(envelope.result[:data]).to eq({"channels"=>[]})
-
-end
-end
-
-
-it '__uuid___ruby-test-uuid____http_sync__true___callback___block_' do
-VCR.use_cassette('examples/where_now/3', record: :none) do
-envelope = @pubnub.where_now(uuid: 'ruby-test-uuid', http_sync: true, &@callback)
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
-
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
-
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:where_now)
-expect(envelope.result[:data]).to eq({"channels"=>[]})
-
-end
-end
-
-
-it '__uuid___ruby-test-uuid____http_sync__true___callback___lambda_' do
-VCR.use_cassette('examples/where_now/4', record: :none) do
-envelope = @pubnub.where_now(uuid: 'ruby-test-uuid', http_sync: true, callback: @callback)
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
-
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
-
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:where_now)
-expect(envelope.result[:data]).to eq({"channels"=>[]})
-
-end
-end
+  it "__uuid___ruby-test-uuid____http_sync__true___callback__nil_" do
+    VCR.use_cassette("examples/where_now/5", record: :none) do
+      envelope = @pubnub.where_now(uuid: "ruby-test-uuid", http_sync: true)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
-it '__uuid___ruby-test-uuid____http_sync__false___callback__nil_' do
-VCR.use_cassette('examples/where_now/2', record: :none) do
-envelope = @pubnub.where_now(uuid: 'ruby-test-uuid', http_sync: false)
-envelope = envelope.value
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:where_now)
+      expect(envelope.result[:data]).to eq({"channels" => []})
+    end
+  end
 
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
+  it "__uuid___ruby-test-uuid____http_sync__true___callback___block_" do
+    VCR.use_cassette("examples/where_now/3", record: :none) do
+      envelope = @pubnub.where_now(uuid: "ruby-test-uuid", http_sync: true, &@callback)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:where_now)
-expect(envelope.result[:data]).to eq({"channels"=>[]})
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
-end
-end
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:where_now)
+      expect(envelope.result[:data]).to eq({"channels" => []})
+    end
+  end
 
+  it "__uuid___ruby-test-uuid____http_sync__true___callback___lambda_" do
+    VCR.use_cassette("examples/where_now/4", record: :none) do
+      envelope = @pubnub.where_now(uuid: "ruby-test-uuid", http_sync: true, callback: @callback)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
-it '__uuid___ruby-test-uuid____http_sync__false___callback___block_' do
-VCR.use_cassette('examples/where_now/0', record: :none) do
-envelope = @pubnub.where_now(uuid: 'ruby-test-uuid', http_sync: false, &@callback)
-envelope = envelope.value
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:where_now)
+      expect(envelope.result[:data]).to eq({"channels" => []})
+    end
+  end
 
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:where_now)
-expect(envelope.result[:data]).to eq({"channels"=>[]})
+  it "__uuid___ruby-test-uuid____http_sync__false___callback__nil_" do
+    VCR.use_cassette("examples/where_now/2", record: :none) do
+      envelope = @pubnub.where_now(uuid: "ruby-test-uuid", http_sync: false)
+      envelope = envelope.value
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
-end
-end
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:where_now)
+      expect(envelope.result[:data]).to eq({"channels" => []})
+    end
+  end
 
-it '__uuid___ruby-test-uuid____http_sync__false___callback___lambda_' do
-VCR.use_cassette('examples/where_now/1', record: :none) do
-envelope = @pubnub.where_now(uuid: 'ruby-test-uuid', http_sync: false, callback: @callback)
-envelope = envelope.value
-expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-expect(envelope.error?).to eq false
+  it "__uuid___ruby-test-uuid____http_sync__false___callback___block_" do
+    VCR.use_cassette("examples/where_now/0", record: :none) do
+      envelope = @pubnub.where_now(uuid: "ruby-test-uuid", http_sync: false, &@callback)
+      envelope = envelope.value
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
-expect(envelope.status[:code]).to eq(200)
-expect(envelope.status[:category]).to eq(:ack)
-expect(envelope.status[:config]).to eq({:tls=>false, :uuid=>"ruby-test-uuid-client-one", :auth_key=>"ruby-test-auth-client-one", :origin=>"ps.pndsn.com"})
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
-expect(envelope.result[:code]).to eq(200)
-expect(envelope.result[:operation]).to eq(:where_now)
-expect(envelope.result[:data]).to eq({"channels"=>[]})
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:where_now)
+      expect(envelope.result[:data]).to eq({"channels" => []})
+    end
+  end
 
-end
-end
+  it "__uuid___ruby-test-uuid____http_sync__false___callback___lambda_" do
+    VCR.use_cassette("examples/where_now/1", record: :none) do
+      envelope = @pubnub.where_now(uuid: "ruby-test-uuid", http_sync: false, callback: @callback)
+      envelope = envelope.value
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
 
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
 
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:where_now)
+      expect(envelope.result[:data]).to eq({"channels" => []})
+    end
+  end
 end

data/spec/lib/client_spec.rb

@@ -1,33 +1,30 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Pubnub::Client do
-
   around :each do |example|
-    Celluloid.boot
-    example.run
-    Celluloid.shutdown
+    example.run_with_retry retry: 10
   end
 
-  it 'has valid version constant' do
+  it "has valid version constant" do
     expect(Pubnub::Client::VERSION).to match(/\d+\.\d+\..+/)
   end
 
-  context '#initialize' do
-    it 'returns new Pubnub::Client' do
+  context "#initialize" do
+    it "returns new Pubnub::Client" do
       pubnub = Pubnub.new(subscribe_key: :key)
       expect(pubnub.is_a?(Pubnub::Client)).to eq true
     end
 
-    it 'requires arguments' do
+    it "requires arguments" do
       expect { Pubnub.new }.to raise_error(Pubnub::InitializationError)
     end
 
-    it 'by default sets Pubnub.logger that logs to pubnub.log' do
+    it "by default sets Pubnub.logger that logs to pubnub.log" do
       _pubnub = Pubnub.new(subscribe_key: :key)
-      expect(Pubnub.logger.instance_eval('@logdev').filename).to eq 'pubnub.log'
+      expect(Pubnub.logger.instance_eval("@logdev").filename).to eq "pubnub.log"
     end
 
-    it 'sets Pubnub.logger to new one if given' do
+    it "sets Pubnub.logger to new one if given" do
       _rd, wr = IO.pipe
 
       logger = Logger.new(wr)
@@ -35,8 +32,8 @@ describe Pubnub::Client do
       expect(Pubnub.logger).to eq(logger)
     end
 
-    it 'creates required pools' do
-      pubnub = Pubnub.new(subscribe_key: 'key')
+    it "creates required pools" do
+      pubnub = Pubnub.new(subscribe_key: "key")
 
       # Connections
       expect(pubnub.env[:single_event_conn_pool]).to eq({})
@@ -50,89 +47,79 @@ describe Pubnub::Client do
       expect(pubnub.env[:subscription_pool]).to eq({})
     end
 
-    context 'parameters' do
-
-      it 'changes string keys to sym keys' do
-        pubnub = Pubnub.new('subscribe_key' => 'key')
+    context "parameters" do
+      it "changes string keys to sym keys" do
+        pubnub = Pubnub.new("subscribe_key" => "key")
         pubnub.env.each_key do |key|
           expect(key.class).to eq Symbol
         end
       end
 
-      it 'removes empty parameters' do
-        pubnub = Pubnub.new(publish_key: '', subscribe_key: 'key')
+      it "removes empty parameters" do
+        pubnub = Pubnub.new(publish_key: "", subscribe_key: "key")
         expect(pubnub.env[:publish_key]).to eq(nil)
       end
 
-      it 'does not remove non-empty parameters' do
-        pubnub = Pubnub.new(publish_key: '', subscribe_key: 'key')
-        expect(pubnub.env[:subscribe_key]).to eq('key')
+      it "does not remove non-empty parameters" do
+        pubnub = Pubnub.new(publish_key: "", subscribe_key: "key")
+        expect(pubnub.env[:subscribe_key]).to eq("key")
       end
 
-      context 'validates' do
-        context 'parameter :origin' do
-          it 'must be valid' do
-            expect { Pubnub.new(origin: 123, subscribe_key: 'key') }
-            .to raise_error(Pubnub::InitializationError)
+      context "validates" do
+        context "parameter :origin" do
+          it "must be valid" do
+            expect { Pubnub.new(origin: 123, subscribe_key: "key") }.to raise_error(Pubnub::InitializationError)
 
-            expect { Pubnub.new(origin: { a: :b }, subscribe_key: 'key') }
-            .to raise_error(Pubnub::InitializationError)
+            expect { Pubnub.new(origin: {a: :b}, subscribe_key: "key") }.to raise_error(Pubnub::InitializationError)
 
-            expect { Pubnub.new(origin: nil, subscribe_key: 'key') }
-            .not_to raise_error
+            expect { Pubnub.new(origin: nil, subscribe_key: "key") }.not_to raise_error
 
-            expect { Pubnub.new(origin: '', subscribe_key: 'key') }
-            .not_to raise_error
+            expect { Pubnub.new(origin: "", subscribe_key: "key") }.not_to raise_error
 
-            expect { Pubnub.new(origin: 'http://a.com', subscribe_key: 'key') }
-            .not_to raise_error
+            expect { Pubnub.new(origin: "http://a.com", subscribe_key: "key") }.not_to raise_error
           end
         end
 
-        context 'parameter :subscribe_key' do
-          it 'is required' do
-            expect { Pubnub.new(http_sync: true) }
-            .to raise_error(Pubnub::InitializationError)
+        context "parameter :subscribe_key" do
+          it "is required" do
+            expect { Pubnub.new(http_sync: true) }.to raise_error(Pubnub::InitializationError)
           end
 
-          it 'must be valid' do
-            expect { Pubnub.new(subscribe_key: 123) }
-            .to raise_error(Pubnub::InitializationError)
+          it "must be valid" do
+            expect { Pubnub.new(subscribe_key: 123) }.to raise_error(Pubnub::InitializationError)
 
-            expect { Pubnub.new(subscribe_key: []) }
-            .to raise_error(Pubnub::InitializationError)
+            expect { Pubnub.new(subscribe_key: []) }.to raise_error(Pubnub::InitializationError)
 
-            expect { Pubnub.new(subscribe_key: {}) }
-            .to raise_error(Pubnub::InitializationError)
+            expect { Pubnub.new(subscribe_key: {}) }.to raise_error(Pubnub::InitializationError)
 
-            expect { Pubnub.new(subscribe_key: 'key') }.not_to raise_error
+            expect { Pubnub.new(subscribe_key: "key") }.not_to raise_error
             expect { Pubnub.new(subscribe_key: :key) }.not_to raise_error
           end
         end
 
-        context 'parameter :publish_key' do
-          it 'must be valid' do
+        context "parameter :publish_key" do
+          it "must be valid" do
             expect do
-              Pubnub.new(subscribe_key: 'valid', publish_key: ['invalid'])
+              Pubnub.new(subscribe_key: "valid", publish_key: ["invalid"])
             end.to raise_error(Pubnub::InitializationError)
 
             expect do
               Pubnub.new(
-                  subscribe_key: 'valid',
-                  publish_key: { invalid: 'yeah' }
+                subscribe_key: "valid",
+                publish_key: {invalid: "yeah"},
               )
             end.to raise_error(Pubnub::InitializationError)
 
             expect do
-              Pubnub.new(subscribe_key: 'valid', publish_key: ['invalid'])
+              Pubnub.new(subscribe_key: "valid", publish_key: ["invalid"])
             end.to raise_error(Pubnub::InitializationError)
 
             expect do
-              Pubnub.new(subscribe_key: 'valid', publish_key: 'key')
+              Pubnub.new(subscribe_key: "valid", publish_key: "key")
             end.not_to raise_error
 
             expect do
-              Pubnub.new(subscribe_key: 'valid', publish_key: :key)
+              Pubnub.new(subscribe_key: "valid", publish_key: :key)
             end.not_to raise_error
           end
         end
@@ -140,39 +127,39 @@ describe Pubnub::Client do
     end
   end
 
-  context 'timetoken manipulation' do
-    let(:pubnub_client) { Pubnub.new(subscribe_key: 'demo') }
+  context "timetoken manipulation" do
+    let(:pubnub_client) { Pubnub.new(subscribe_key: "demo") }
 
-    context '#timetoken' do
-      it 'returns timetoken hold in env' do
-        pubnub_client.env[:timetoken] = '0987654321'
-        expect(pubnub_client.timetoken).to eq '0987654321'
+    context "#timetoken" do
+      it "returns timetoken hold in env" do
+        pubnub_client.env[:timetoken] = "0987654321"
+        expect(pubnub_client.timetoken).to eq "0987654321"
       end
     end
 
-    context '#timetoken=' do
-      it 'sets given timetoken in env' do
-        pubnub_client.timetoken = '1234567890'
-        expect(pubnub_client.env[:timetoken]).to eq '1234567890'
+    context "#timetoken=" do
+      it "sets given timetoken in env" do
+        pubnub_client.timetoken = "1234567890"
+        expect(pubnub_client.env[:timetoken]).to eq "1234567890"
       end
     end
   end
 
-  context 'callback listeners' do
-    let(:pubnub_client) { Pubnub.new(subscribe_key: 'demo') }
+  context "callback listeners" do
+    let(:pubnub_client) { Pubnub.new(subscribe_key: "demo") }
 
-    it 'can be added' do
+    it "can be added" do
       callbacks = Pubnub::SubscribeCallback.new(
-          message:  ->(_envelope) {},
-          presence: ->(_envelope) {},
-          status:   ->(_envelope) {}
+        message: -> (_envelope) { },
+        presence: -> (_envelope) { },
+        status: -> (_envelope) { },
       )
 
       expect(pubnub_client.subscribed?).to eq false
 
       pubnub_client.add_listener(
-                       callback: callbacks,
-                       name: :callbacks
+        callback: callbacks,
+        name: :callbacks,
       )
 
       expect(pubnub_client.subscriber.listeners[:callbacks]).not_to be_nil
@@ -180,16 +167,16 @@ describe Pubnub::Client do
       expect(pubnub_client.subscribed?).to eq false # we have callbacks but we're not subscribed yet
     end
 
-    it 'can be removed' do
+    it "can be removed" do
       callbacks = Pubnub::SubscribeCallback.new(
-          message:  ->(_envelope) {},
-          presence: ->(_envelope) {},
-          status:   ->(_envelope) {}
+        message: -> (_envelope) { },
+        presence: -> (_envelope) { },
+        status: -> (_envelope) { },
       )
 
       pubnub_client.add_listener(
-          callback: callbacks,
-          name: :callbacks
+        callback: callbacks,
+        name: :callbacks,
       )
 
       expect(pubnub_client.subscriber.listeners[:callbacks]).not_to be_nil
@@ -199,7 +186,7 @@ describe Pubnub::Client do
       expect(pubnub_client.subscriber.listeners[:callbacks]).to be_nil
 
       pubnub_client.add_listener(
-          callback: callbacks
+        callback: callbacks,
       )
 
       expect(pubnub_client.subscriber.listeners).not_to be_empty
@@ -210,83 +197,78 @@ describe Pubnub::Client do
     end
   end
 
-  context 'helper methods' do
-    let(:pubnub_client) { Pubnub.new(subscribe_key: 'demo') }
+  context "helper methods" do
+    let(:pubnub_client) { Pubnub.new(subscribe_key: "demo") }
 
-    it 'can change uuid while not subscribed' do
-      expect(pubnub_client.change_uuid('whatever')).to eq 'whatever'
+    it "can change uuid while not subscribed" do
+      expect(pubnub_client.change_uuid("whatever")).to eq "whatever"
     end
 
-    it 'cannot change uuid when subscribed' do
+    it "cannot change uuid when subscribed" do
       pubnub_client.subscribe(channel: :demo)
 
-      expect { pubnub_client.change_uuid('whatever') }.to raise_error(RuntimeError)
+      expect { pubnub_client.change_uuid("whatever") }.to raise_error(RuntimeError)
     end
 
-    it 'can show what channels are subscribed' do
+    it "can show what channels are subscribed" do
       expect(pubnub_client.subscribed?).to eq(false)
-      pubnub_client.subscribe(channel: ['demo', 'demo.*'], presence: 'demo', group: 'demo')
+      pubnub_client.subscribe(channel: ["demo", "demo.*"], presence: "demo", group: "demo")
       expect(pubnub_client.subscribed?).to eq(true)
 
-      expect(pubnub_client.subscribed_to).to eq(channel: ['demo', 'demo-pnpres', 'demo.*'], group: ['demo'])
-      expect(pubnub_client.subscribed_to(true)).to eq(channel: ['demo', 'demo-pnpres'], wildcard_channel: ['demo.*'], group: ['demo'])
+      expect(pubnub_client.subscribed_to).to eq(channel: ["demo", "demo-pnpres", "demo.*"], group: ["demo"])
+      expect(pubnub_client.subscribed_to(true)).to eq(channel: ["demo", "demo-pnpres"], wildcard_channel: ["demo.*"], group: ["demo"])
     end
   end
 
-  context 'connections' do
-    it 'are keep_alive by default' do
+  context "connections" do
+    it "are keep_alive by default" do
       pubnub = Pubnub.new(subscribe_key: :demo, publish_key: :demo)
 
-      VCR.use_cassette('lib/client/keep_alive_default', record: :once) do
+      VCR.use_cassette("lib/client/keep_alive_default", record: :once) do
         pubnub.subscribe(channel: :demo)
-        
-        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]['ps.pndsn.com'][:subscribe_event].tcp_keepalive).to eq true }
+
+        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]["ps.pndsn.com"][:subscribe_event].tcp_keepalive).to eq true }
         pubnub.leave(channel: :demo)
-        
       end
     end
 
-    it 'respect :disable_keep_alive' do
+    it "respect :disable_keep_alive" do
       pubnub = Pubnub.new(subscribe_key: :demo, publish_key: :demo, disable_keepalive: true)
 
-      VCR.use_cassette('lib/client/keep_alive_disabled', record: :once) do
+      VCR.use_cassette("lib/client/keep_alive_disabled", record: :once) do
         pubnub.subscribe(channel: :demo)
-        
-        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]['ps.pndsn.com'][:subscribe_event].tcp_keepalive).to eq false }
+
+        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]["ps.pndsn.com"][:subscribe_event].tcp_keepalive).to eq false }
         pubnub.leave(channel: :demo)
-        
       end
     end
 
-    it 'respect :disable_subscribe_keep_alive init parameter' do
+    it "respect :disable_subscribe_keep_alive init parameter" do
       pubnub = Pubnub.new(subscribe_key: :demo, publish_key: :demo, disable_subscribe_keepalive: true)
 
-      VCR.use_cassette('lib/client/keep_alive_disable_subscribe_keep_alive', record: :once) do
+      VCR.use_cassette("lib/client/keep_alive_disable_subscribe_keep_alive", record: :once) do
         pubnub.subscribe(channel: :demo)
-        
-        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]['ps.pndsn.com'][:subscribe_event].tcp_keepalive).to eq false }
+
+        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]["ps.pndsn.com"][:subscribe_event].tcp_keepalive).to eq false }
         pubnub.leave(channel: :demo)
-        
+
         pubnub.publish(channel: :demo, message: :whatever)
-        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]['ps.pndsn.com'][:single_event].tcp_keepalive).to eq true }
-        
+        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]["ps.pndsn.com"][:single_event].tcp_keepalive).to eq true }
       end
     end
 
-    it 'respect :disable_non_subscribe_keep_alive init parameter' do
+    it "respect :disable_non_subscribe_keep_alive init parameter" do
       pubnub = Pubnub.new(subscribe_key: :demo, publish_key: :demo, disable_non_subscribe_keepalive: true)
 
-      VCR.use_cassette('lib/client/keep_alive_disable_non_subscribe_keep_alive', record: :once) do
+      VCR.use_cassette("lib/client/keep_alive_disable_non_subscribe_keep_alive", record: :once) do
         pubnub.subscribe(channel: :demo)
-        
-        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]['ps.pndsn.com'][:subscribe_event].tcp_keepalive).to eq true }
+
+        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]["ps.pndsn.com"][:subscribe_event].tcp_keepalive).to eq true }
         pubnub.leave(channel: :demo)
-        
+
         pubnub.publish(channel: :demo, message: :whatever)
-        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]['ps.pndsn.com'][:single_event].tcp_keepalive).to eq false }
-        
+        eventually { expect(pubnub.env[:req_dispatchers_pool][:async]["ps.pndsn.com"][:single_event].tcp_keepalive).to eq false }
       end
     end
   end
-
 end