pubnub 3.5.1 → 3.5.3

data/lib/pubnub/events/heartbeat.rb

@@ -0,0 +1,59 @@
+module Pubnub
+  class Heartbeat
+    include Pubnub::Event
+    include Pubnub::SingleEvent
+    include Pubnub::Formatter
+    include Pubnub::Validator
+
+    def initialize(options, app)
+      super
+      @event = 'heartbeat'
+      @allow_multiple_channels = true
+      @doesnt_require_callback = true
+    end
+
+    def fire(app)
+      super
+    end
+
+    private
+
+    def path(app)
+      '/' + [
+          'v2',
+          'presence',
+          'sub-key',
+          @subscribe_key,
+          'channel',
+          @channel.join(','),
+          'heartbeat'
+      ].join('/')
+    end
+
+    def parameters(app)
+      params = super(app)
+      params.merge!({ :state => URI.encode_www_form_component({}) })
+      params
+    end
+
+    def format_envelopes(response, app, error)
+
+      parsed_response = Parser.parse_json(response.body) if Parser.valid_json?(response.body)
+
+      envelopes = Array.new
+      envelopes << Envelope.new(
+          {
+              :message           => parsed_response,
+              :response_message  => parsed_response
+          },
+          app
+      )
+
+      envelopes = add_common_data_to_envelopes(envelopes, response, app, error)
+
+      envelopes
+
+    end
+
+  end
+end

data/lib/pubnub/events/here_now.rb

@@ -16,22 +16,31 @@ module Pubnub
       super
 
       # check channel
-      raise ArgumentError.new(:object => self, :message => 'History requires :channel argument') unless @channel
-      raise ArgumentError.new(:object => self, :message => 'Invalid channel format! Should be type of: String, Symbol') unless [String, Symbol].include?(@channel.class)
+      raise ArgumentError.new(:object => self, :message => 'Invalid channel format! Should be type of: String, Symbol') unless [String, Symbol, NilClass].include?(@channel.class)
 
     end
 
     private
 
     def path(app)
-      '/' + [
-          'v2',
-          'presence',
-          'sub-key',
-          @subscribe_key,
-          'channel',
-          @channel
-      ].join('/')
+      unless @channel.blank?
+        '/' + [
+            'v2',
+            'presence',
+            'sub-key',
+            @subscribe_key,
+            'channel',
+            @channel
+        ].join('/')
+      else
+        $logger.debug('Pubnub'){'Global here_now'}
+        '/' + [
+            'v2',
+            'presence',
+            'sub-key',
+            @subscribe_key
+        ].join('/')
+      end
     end
 
     def format_envelopes(response, app, error)

data/lib/pubnub/events/leave.rb

@@ -24,15 +24,23 @@ module Pubnub
     end
 
     def fire(app)
-      app.update_timetoken(0)
-      if app.env[:subscriptions][@origin].nil?
-        raise ArgumentError.new(:object => self, :message => 'You cannot leave channel that is not subscribed')
-      elsif app.env[:subscriptions][@origin].get_channels.include?(@channel)
-        raise ArgumentError.new(:object => self, :message => 'You cannot leave channel that is not subscribed')
-      end unless @force
-      @channel.each do |channel|
-        app.env[:subscriptions][@origin].remove_channel(channel, app) if app.env[:subscriptions][@origin]
-      end unless @skip_remove
+      $logger.debug('Pubnub'){"Pubnub::Leave#fire"}
+      unless @left
+        app.update_timetoken(0)
+        if app.env[:subscriptions][@origin].nil?
+          $logger.error('Pubnub'){'There\'s no subscription for that origin'}
+          raise ArgumentError.new(:object => self, :message => 'You cannot leave channel that is not subscribed')
+        else
+          @channel.each do |channel|
+            $logger.debug('Pubnub'){"#{app.env[:subscriptions][@origin].get_channels.to_s}.include? #{channel}"}
+            raise ArgumentError.new(:object => self, :message => 'You cannot leave channel that is not subscribed') unless app.env[:subscriptions][@origin].get_channels.include?(channel)
+          end
+        end unless @force
+        @channel.each do |channel|
+          app.env[:subscriptions][@origin].remove_channel(channel, app) if app.env[:subscriptions][@origin]
+          @left = true
+        end unless @skip_remove
+      end
       super
     end
 

data/lib/pubnub/exceptions.rb

@@ -35,7 +35,7 @@ module Pubnub
       if $logger.blank?
         puts error_message
       else
-        $logger.error(error_message)
+        $logger.error('Pubnub'){error_message}
       end
     end
 

data/lib/pubnub/formatter.rb

@@ -38,6 +38,7 @@ module Pubnub
       hash.each do |key, value|
         params << "#{key}=#{value}&"
       end
+      params.chop! if params[-1] == '&'
       params
     end
 

data/lib/pubnub/pam.rb

@@ -1,5 +1,10 @@
 module Pubnub
   module PAM
+    def initialize(options, app)
+      super
+      @auth_key = options[:auth_key]
+    end
+
     def signature(app)
       channel = @original_channel.first
       message = "#{@subscribe_key}\n#{@publish_key}\n#{@event}\n#{variables_for_signature(app)}"

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Pubnub
-  VERSION = '3.5.1'
+  VERSION = '3.5.3'
 end

data/pubnub.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = 'pubnub'
-  s.version = '3.5.1'
+  s.version = '3.5.3'
 
   s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
   s.authors = ['PubNub']
-  s.date = '2014-01-15'
+  s.date = '2014-04-14'
   s.description = 'Ruby anywhere in the world in 250ms with PubNub!'
   s.email = 'support@pubnub.com'
   s.files = `git ls-files`.split("\n")

data/spec/lib/auth_key_flow_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+# If VCR would fail, that means auth_key isn't set as desired in params
+describe 'auth_key flow' do
+
+  before(:each) do
+    origin = 'pubsub.pubnub.com'
+    sub_key = 'sub-c-a478dd2a-c33d-11e2-883f-02ee2ddab7fe'
+    pub_key = 'pub-c-a2650a22-deb1-44f5-aa87-1517049411d5'
+    sec_key = 'sec-c-YjFmNzYzMGMtYmI3NC00NzJkLTlkYzYtY2MwMzI4YTJhNDVh'
+    @pn = Pubnub.new(:subscribe_key => sub_key, :publish_key => pub_key, :secret_key => sec_key, :error_callback => lambda {|e|})
+
+    Pubnub::Audit.any_instance.stub(:current_time).and_return 1234567890
+    Pubnub::Audit.any_instance.stub(:signature).and_return 'kdDh/sFC3rSR%2Bt5AEymIc57d1velIr562V7usa5M4k0='
+  end
+
+  context 'non-pam' do
+    it 'isn\'t appened to params if isn\'t set' do
+      VCR.use_cassette("auth_key_flow_no_auth_publish", :record => :none) do
+        enve = @pn.publish(:channel => :ruby_test, :http_sync => true, :message => :whatever)
+        enve.size.should eq 1
+      end
+    end
+
+    it 'appears in params if set' do
+      VCR.use_cassette("auth_key_flow_auth_publish", :record => :none) do
+        @pn.auth_key = 'ruby_client_123'
+        enve = @pn.publish(:channel => :ruby_test, :http_sync => true, :message => :whatever)
+        enve.size.should eq 1
+      end
+    end
+  end
+  
+  context 'PAM' do
+    it 'doesn\'t care if it\'s set in client' do
+      VCR.use_cassette("auth_key_flow_non_auth_audit", :record => :none) do
+        @pn.auth_key = 'ruby_client_123'
+        enve = @pn.audit(:channel => :ruby_test, :http_sync => true)
+        enve.size.should eq 1
+      end
+    end
+
+    it 'uses passed auth_key insted of client auth_key' do
+      VCR.use_cassette("auth_key_flow_instead_auth_audit", :record => :none) do
+        @pn.auth_key = 'ruby_client_123'
+        enve = @pn.audit(:channel => :ruby_test, :http_sync => true, :auth_key => 'omg_so_key')
+        enve.size.should eq 1
+      end
+    end
+
+    it 'uses passed auth_key when client auth_key is blank' do
+      VCR.use_cassette("auth_key_flow_empty_auth_audit", :record => :none) do
+        enve = @pn.audit(:channel => :ruby_test, :http_sync => true, :auth_key => 'omg_so_key')
+        enve.size.should eq 1
+      end
+    end
+  end
+
+end
+

data/spec/lib/heartbeat_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe 'hearbeat' do
+
+  it 'default should be nil' do
+    @pn = Pubnub.new(:subscribe_key => :test)
+    @pn.env[:heartbeat].should eq nil
+  end
+
+  it 'is present in subscribe request when set, also fires leave after sync subscribe' do
+    @pn = Pubnub.new(:subscribe_key => 'demo-36', :heartbeat => 100)
+
+    VCR.use_cassette("heartbeated-subscribe", :record => :none) do
+      enve = @pn.subscribe(:channel => :ruby_test, :http_sync => true) # request would file if heartbeat would not be present
+      enve.size.should eq 1
+    end
+
+  end
+
+  it 'isn\'t present in subscribe request when not set' do
+    @pn = Pubnub.new(:subscribe_key => 'demo-36')
+
+    VCR.use_cassette("non-heartbeated-subscribe", :record => :none) do
+      enve = @pn.subscribe(:channel => :ruby_test, :http_sync => true) # request would file if heartbeat would be present
+      enve.size.should eq 1
+    end
+
+  end
+
+  it 'is called every heartbeat/2 - 1 seconds' do
+    @pn = Pubnub.new(:subscribe_key => 'demo-36', :heartbeat => '12')
+
+    VCR.use_cassette("heartbeat-test", :record => :all) do
+      @pn.subscribe(:channel => 'rubyheartbeatdemo'){|e| }
+      eventually do
+        @pn.env[:heartbeat].to_i.should      eq 12
+        @pn.env[:respirator].interval.should eq 5
+      end
+    end
+  end
+
+  it 'calls error_callback if get\'s non-200 response' do
+    @error = false
+    error_callback = lambda do |error|
+      @error = true
+      EM.stop
+    end
+
+    @pn = Pubnub.new(:subscribe_key => 'demo-36', :heartbeat => '4', :error_callback => error_callback)
+    VCR.use_cassette("heartbeat-non200", :record => :new_episodes) do
+      @pn.subscribe(:channel => 'rubyheartbeatdemo'){|e| }
+      eventually do
+        @error.should eq true
+      end
+    end
+  end
+
+  context 'is settable' do
+    before(:each) do
+      @pn = Pubnub.new(:subscribe_key => :test)
+    end
+
+    it 'at init time' do
+      @pn = Pubnub.new(:subscribe_key => :test, :heartbeat => 100)
+      @pn.env[:heartbeat].should eq 100
+    end
+
+    it 'via heartbeat=' do
+      @pn.heartbeat = 100
+      @pn.env[:heartbeat].should eq 100
+    end
+
+    it 'via set_heartbeat(value)' do
+      @pn.set_heartbeat 100
+      @pn.env[:heartbeat].should eq 100
+    end
+  end
+
+  context 'is updateable' do
+    before(:each) do
+      @pn = Pubnub.new(:subscribe_key => :test)
+      @pn.heartbeat = 100
+    end
+
+    it 'via heartbeat=' do
+      @pn.heartbeat = 200
+      @pn.env[:heartbeat].should eq 200
+    end
+
+    it 'via set_heartbeat(value)' do
+      @pn.set_heartbeat 200
+      @pn.env[:heartbeat].should eq 200
+    end
+  end
+
+  context 'is gettable' do
+    before(:each) do
+      @pn = Pubnub.new(:subscribe_key => :test)
+      @pn.heartbeat = 100
+    end
+
+    it 'via get_heartbeat' do
+      @pn.get_heartbeat.should eq 100
+    end
+
+    it 'via .env' do
+      @pn.env[:heartbeat].should eq 100
+    end
+  end
+end

data/spec/lib/integration/global_here_now_spec.rb

@@ -0,0 +1,541 @@
+require 'spec_helper'
+
+describe "#here_now" do
+  before(:each) do
+
+    EM.stop if EM.reactor_running?
+    while EM.reactor_running? do end
+    sleep(0.1)
+
+    @response_output = StringIO.new
+    @message_output = StringIO.new
+
+    @callback = lambda { |envelope|
+      $logger.debug 'FIRING CALLBACK FROM TEST'
+      @response_output.write envelope.response
+      @message_output.write envelope.msg
+      @after_callback = true
+    }
+
+    @error_callback = lambda { |envelope|
+      $logger.debug 'FIRING ERROR CALLBACK FROM TEST'
+      @response_output.write envelope.response
+      @message_output.write envelope.msg
+      @after_error_callback = true
+    }
+
+    @pn = Pubnub.new(:max_retries => 0, :subscribe_key => 'demo-36', :publish_key => 'demo-36', :auth_key => :demoish_authkey, :secret_key => 'some_secret_key', :error_callback => @error_callback)
+    @pn.uuid = 'rubytests'
+
+  end
+  context "uses ssl" do
+    before(:each) { @ssl = true }
+    context "passess callback as block" do
+      context "gets valid json in response" do
+        context "gets status 200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-valid-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                @message_output.seek 0
+                @message_output.read.should eq '{"status"=>200, "message"=>"OK", "service"=>"Presence", "uuids"=>[], "occupancy"=>0}'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-valid-200-async", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                  @message_output.seek 0
+                  @message_output.read.should eq '{"status"=>200, "message"=>"OK", "service"=>"Presence", "uuids"=>[], "occupancy"=>0}'
+                end
+              end
+            end
+          end
+        end
+        context "gets status non-200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-valid-non-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Non 2xx server response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-valid-non-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Non 2xx server response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+      context "gets invalid json in response" do
+        context "gets status 200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-invalid-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Invalid JSON in response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-invalid-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+        context "gets status non-200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Invalid JSON in response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    context "passess callback as parameter" do
+      context "gets valid json in response" do
+        context "gets status 200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-valid-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                @message_output.seek 0
+                @message_output.read.should eq '{"status"=>200, "message"=>"OK", "service"=>"Presence", "uuids"=>[], "occupancy"=>0}'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-valid-200-async", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                  @message_output.seek 0
+                  @message_output.read.should eq '{"status"=>200, "message"=>"OK", "service"=>"Presence", "uuids"=>[], "occupancy"=>0}'
+                end
+              end
+            end
+          end
+        end
+        context "gets status non-200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-valid-non-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Non 2xx server response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-valid-non-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Non 2xx server response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+      context "gets invalid json in response" do
+        context "gets status 200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-invalid-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Invalid JSON in response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-invalid-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+        context "gets status non-200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Invalid JSON in response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-ssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.here_now(:ssl => true, :http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  context "uses non-ssl" do
+    before(:each) { @ssl = false }
+    context "passess callback as block" do
+      context "gets valid json in response" do
+        context "gets status 200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-valid-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                @message_output.seek 0
+                @message_output.read.should eq '{"status"=>200, "message"=>"OK", "service"=>"Presence", "uuids"=>[], "occupancy"=>0}'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-valid-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                  @message_output.seek 0
+                  @message_output.read.should eq '{"status"=>200, "message"=>"OK", "service"=>"Presence", "uuids"=>[], "occupancy"=>0}'
+                end
+              end
+            end
+          end
+        end
+        context "gets status non-200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-valid-non-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Non 2xx server response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-valid-non-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Non 2xx server response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+      context "gets invalid json in response" do
+        context "gets status 200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-invalid-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Invalid JSON in response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-invalid-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+        context "gets status non-200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Invalid JSON in response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    context "passess callback as parameter" do
+      context "gets valid json in response" do
+        context "gets status 200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-valid-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                @message_output.seek 0
+                @message_output.read.should eq '{"status"=>200, "message"=>"OK", "service"=>"Presence", "uuids"=>[], "occupancy"=>0}'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-valid-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                  @message_output.seek 0
+                  @message_output.read.should eq '{"status"=>200, "message"=>"OK", "service"=>"Presence", "uuids"=>[], "occupancy"=>0}'
+                end
+              end
+            end
+          end
+        end
+        context "gets status non-200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-valid-non-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Non 2xx server response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-valid-non-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0}'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Non 2xx server response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+      context "gets invalid json in response" do
+        context "gets status 200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-invalid-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Invalid JSON in response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-invalid-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+        context "gets status non-200 in response" do
+          context "uses sync connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => true, :channel => "demo", :callback => @callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                @message_output.seek 0
+                @message_output.read.should eq '[0,"Invalid JSON in response."]'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("here_now_global-nonssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.here_now(:http_sync => false, :channel => "demo", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status": 200, "message": "OK", "service": "Presence", "uuids": [], "occupancy": 0'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end