pubnub 3.4.1 → 3.5.1

data/spec/lib/encoder_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'Pubnub::Formatter' do
+  before(:each) do
+    @formater = (Class.new { include Pubnub::Formatter }).new
+  end
+
+  context '#format_channels' do
+    context 'should encode' do
+      it 'encodes properly string into array of channels' do
+        encoded = @formater.format_channels('Some Channel with+special+chars=[];!@#$%^&*()')
+        encoded.should eq ['Some%20Channel%20with%2Bspecial%2Bchars%3D%5B%5D%3B%21%40%23%24%25%5E%26*%28%29']
+      end
+
+      it 'encodes properly array of strings into array of channels' do
+        encoded = @formater.format_channels(['Some Channel with+special+chars=[];!@#$%^&*()', ' +++ ', '123'])
+        encoded.should eq ['Some%20Channel%20with%2Bspecial%2Bchars%3D%5B%5D%3B%21%40%23%24%25%5E%26*%28%29', '%20%2B%2B%2B%20', '123']
+      end
+
+      it 'encodes properly csv into array of channels' do
+        encoded = @formater.format_channels('Some Channel with+special+chars=[];!@#$%^&*(), +++ ,123')
+        encoded.should eq ['Some%20Channel%20with%2Bspecial%2Bchars%3D%5B%5D%3B%21%40%23%24%25%5E%26*%28%29', '%20%2B%2B%2B%20', '123']
+      end
+    end
+
+    context 'should not encode' do
+      it 'formats properly string into array of channels' do
+        encoded = @formater.format_channels('Some Channel with+special+chars=[];!@#$%^&*()', false)
+        encoded.should eq ['Some Channel with+special+chars=[];!@#$%^&*()']
+      end
+
+      it 'formats properly array of strings into array of channels' do
+        encoded = @formater.format_channels(['Some Channel with+special+chars=[];!@#$%^&*()', ' +++ ', '123'], false)
+        encoded.should eq ['Some Channel with+special+chars=[];!@#$%^&*()', ' +++ ', '123']
+      end
+
+      it 'formats properly csv into array of channels' do
+        encoded = @formater.format_channels('Some Channel with+special+chars=[];!@#$%^&*(), +++ ,123', false)
+        encoded.should eq ['Some Channel with+special+chars=[];!@#$%^&*()', ' +++ ', '123']
+      end
+    end
+  end
+
+  context '#encode_channel' do
+    it 'encodes channel' do
+      encoded = @formater.encode_channel('Some Channel with+special+chars=[];!@#$%^&*()')
+      encoded.should eq 'Some%20Channel%20with%2Bspecial%2Bchars%3D%5B%5D%3B%21%40%23%24%25%5E%26*%28%29'
+    end
+  end
+
+end

data/spec/lib/formatting_envelope_spec.rb

@@ -0,0 +1,304 @@
+require 'spec_helper'
+
+describe "Pubnub::Envelope" do
+  context 'after subscribe' do
+    context 'without cipher key' do
+
+      before(:each) do
+        sleep(0.1)
+        @pn = Pubnub.new(:subscribe_key => :demo, :publish_key => :demo)
+      end
+
+      context 'on one channel' do
+        context 'after getting string' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-one-channel-string", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+
+              envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting integer' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-one-channel-integer", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+
+              envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting array' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-one-channel-array", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+
+              envelopes.size.should eq 1
+            end
+          end
+        end
+
+
+        context 'after getting hash' do
+          it 'formats envelopes hash' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-one-channel-hash", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+
+              envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting mix of everything' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-one-channel-mix", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+
+              envelopes.size.should eq 4
+            end
+          end
+
+        end
+      end
+
+      context 'on many channels' do
+        context 'after getting string' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-many-channels-string", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting integer' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-many-channels-integer", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting array' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-many-channels-array", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+        end
+
+
+        context 'after getting hash' do
+          it 'formats envelopes hash' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-many-channels-hash", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting mix of everything' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-many-channels-mix", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+          end
+
+        context 'after getting mix of everything from both channels' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-without-cipherkey-many-channels-multi-mix", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+      end
+    end
+
+    context 'with cipher key' do
+
+      before(:each) do
+        @pn = Pubnub.new(:subscribe_key => :demo, :publish_key => :demo, :cipher_key => 'secret')
+      end
+
+      context 'on one channel' do
+        context 'after getting string' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-one-channel-string", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting integer' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-one-channel-integer", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting array' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-one-channel-array", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              
+
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+        end
+
+
+        context 'after getting hash' do
+          it 'formats envelopes hash' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-one-channel-hash", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting mix of everything' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-one-channel-mix", :record => :none) do
+              @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+
+              
+              envelopes = @pn.subscribe(:channel => :test_channel_one, :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+      end
+
+      context 'on many channels' do
+        context 'after getting string' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-many-channels-string", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting integer' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-many-channels-integer", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting array' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-many-channels-array", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+        end
+
+
+        context 'after getting hash' do
+          it 'formats envelopes hash' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-many-channels-hash", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting mix of everything' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-many-channels-mix", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+
+        context 'after getting mix of everything from both channels' do
+          it 'formats envelopes properly' do
+            VCR.use_cassette("formatting-envelope-subscribe-cipherkey-many-channels-multi-mix", :record => :none) do
+              @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              
+              envelopes = @pn.subscribe(:channel => [:test_channel_one, :test_channel_two], :http_sync => true)
+              #envelopes.size.should eq 1
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/integration/audit_spec.rb

@@ -0,0 +1,544 @@
+require 'spec_helper'
+
+describe "#audit" 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 => 'sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe', :publish_key => 'pub-c-15d6fd3c-05de-4abc-8eba-6595a441959d', :secret_key => 'sec-c-ZWYwMGJiZTYtMTQwMC00NDQ5LWI0NmEtMzZiM2M5NThlOTJh', :error_callback => @error_callback)
+    @pn.uuid = 'f0ac67ef-912f-4797-be67-a59745107306'
+
+    Pubnub::Audit.any_instance.stub(:current_time).and_return 1234567890
+    Pubnub::Audit.any_instance.stub(:signature).and_return 'kdDh/sFC3rSR%2Bt5AEymIc57d1velIr562V7usa5M4k0='
+
+  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("audit-ssl-block-valid-200-sync", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => true, :channel => "demo", :auth_key => "authkey", &@callback)
+                
+                @after_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                @message_output.seek 0
+                @message_output.read.should eq 'Success'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("audit-ssl-block-valid-200-async", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => false, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                eventually do
+                  @after_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                  @message_output.seek 0
+                  @message_output.read.should eq 'Success'
+                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("audit-ssl-block-valid-non-200-sync", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => true, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                @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("audit-ssl-block-valid-non-200-async", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => false, :channel => "demo", :auth_key => "authkey", &@callback)
+                
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                  @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("audit-ssl-block-invalid-200-sync", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => true, :channel => "demo", :auth_key => "authkey", &@callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,'
+                @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("audit-ssl-block-invalid-200-async", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => false, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,'
+                  @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("audit-ssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => true, :channel => "demo", :auth_key => "authkey", &@callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,'
+                @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("audit-ssl-block-invalid-non-200-async", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => false, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,'
+                  @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("audit-ssl-parameter-valid-200-sync", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => true, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                @after_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                @message_output.seek 0
+                @message_output.read.should eq 'Success'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("audit-ssl-parameter-valid-200-async", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => false, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+
+                eventually do
+                  @after_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                  @message_output.seek 0
+                  @message_output.read.should eq 'Success'
+                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("audit-ssl-parameter-valid-non-200-sync", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => true, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                @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("audit-ssl-parameter-valid-non-200-async", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => false, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                  @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("audit-ssl-parameter-invalid-200-sync", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => true, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,'
+                @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("audit-ssl-parameter-invalid-200-async", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => false, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,'
+                  @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("audit-ssl-parameter-invalid-non-200-sync", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => true, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,'
+                @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("audit-ssl-parameter-invalid-non-200-async", :record => :none) do
+                @pn.audit(:ssl => true, :http_sync => false, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,'
+                  @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("audit-nonssl-block-valid-200-sync", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => true, :channel => "demo", :auth_key => "authkey", &@callback)
+                
+                @after_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                @message_output.seek 0
+                @message_output.read.should eq 'Success'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("audit-nonssl-block-valid-200-async", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => false, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                eventually do
+                  @after_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                  @message_output.seek 0
+                  @message_output.read.should eq 'Success'
+                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("audit-nonssl-block-valid-non-200-sync", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => true, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                @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("audit-nonssl-block-valid-non-200-async", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => false, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                  @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("audit-nonssl-block-invalid-200-sync", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => true, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,'
+                @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("audit-nonssl-block-invalid-200-async", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => false, :channel => "demo", :auth_key => "authkey", &@callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,'
+                  @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("audit-nonssl-block-invalid-non-200-sync", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => true, :channel => "demo", :auth_key => "authkey", &@callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,'
+                @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("audit-nonssl-block-invalid-non-200-async", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => false, :channel => "demo", :auth_key => "authkey", &@callback)
+                
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,'
+                  @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("audit-nonssl-parameter-valid-200-sync", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => true, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                @after_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                @message_output.seek 0
+                @message_output.read.should eq 'Success'
+              end
+            end
+          end
+          context "uses async connection" do
+            it 'works fine' do
+              VCR.use_cassette("audit-nonssl-parameter-valid-200-async", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => false, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                eventually do
+                  @after_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                  @message_output.seek 0
+                  @message_output.read.should eq 'Success'
+                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("audit-nonssl-parameter-valid-non-200-sync", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => true, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                @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("audit-nonssl-parameter-valid-non-200-async", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => false, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,"message":"Success","payload":{"auths":{},"subscribe_key":"sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe","channel":"demo","level":"user"},"service":"Access Manager"}'
+                  @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("audit-nonssl-parameter-invalid-200-sync", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => true, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,'
+                @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("audit-nonssl-parameter-invalid-200-async", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => false, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,'
+                  @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("audit-nonssl-parameter-invalid-non-200-sync", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => true, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+                
+                @after_error_callback.should eq true
+                @response_output.seek 0
+                @response_output.read.should eq '{"status":200,'
+                @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("audit-nonssl-parameter-invalid-non-200-async", :record => :none) do
+                @pn.audit(:ssl => false, :http_sync => false, :channel => "demo", :auth_key => "authkey", :callback => @callback)
+
+                eventually do
+                  @after_error_callback.should eq true
+                  @response_output.seek 0
+                  @response_output.read.should eq '{"status":200,'
+                  @message_output.seek 0
+                  @message_output.read.should eq '[0,"Invalid JSON in response."]'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end