pubnub 3.3.0.7 → 3.4

data/lib/pubnub/subscription.rb

@@ -0,0 +1,24 @@
+module Pubnub
+  class Subscription
+    attr_accessor :channel, :callback
+
+    def initialize(options)
+      @channel = options[:channel]
+      @callback = options[:callback]
+    end
+
+    def fire_callback_for(envelope)
+      $log.debug "CALLING SUBSCRIPTION CALLBACK FOR CHANNEL #{@channel}" if envelope.channel == @channel
+      @callback.call envelope if envelope.channel == @channel
+      $log.debug "AFTER CALLING SUBSCRIPTION CALLBACK FOR CHANNEL #{@channel}"
+    end
+
+    def ==(other)
+      (@channel == other.get_channel && @callback == other.callback && @error_callback == other.error_callback)
+    end
+
+    def get_channel
+      @channel
+    end
+  end
+end

data/lib/tasks/examples.rake

@@ -0,0 +1,39 @@
+require 'pubnub'
+
+namespace :examples do
+
+  desc "PubNub Subscribe (Receive Messages)"
+  task :subscribe, :channel do |task, args|
+
+    pn = Pubnub.new(:publish_key => "demo", :subscribe_key => "demo")
+
+    # if my_callback returns false, return immediately, otherwise, keep going...
+    my_callback = lambda{ |message| puts(message.inspect); return false; }
+
+
+    pn.subscribe(:channel => args.channel, :callback => my_callback)
+  end
+
+  task :re_subscribe, :channel do |task, args|
+
+    pn = Pubnub.new(:publish_key => "demo", :subscribe_key => "demo")
+
+    time_callback = lambda{ |timetoken| @timetoken = timetoken }
+    my_callback = lambda{ |message| puts(message.inspect); }
+
+    pn.time(:callback => time_callback)
+    pn.subscribe(:channel => args.channel, :callback => my_callback, :override_timetoken => @timetoken)
+  end
+
+  desc "Realtime see who channel events, such as joins, leaves, and occupancy"
+  task :presence, :channel do |task, args|
+
+    pn = Pubnub.new(:publish_key => "demo", :subscribe_key => "demo")
+
+    # if my_callback returns false, return immediately, otherwise, keep going...
+    my_callback = lambda{ |message| puts(message.inspect); return false; }
+
+    pn.presence(:channel => args.channel, :callback => my_callback)
+  end
+
+end

data/lib/version.rb

@@ -0,0 +1 @@
+PUBNUB_VERSION = '3.4'

data/pubnub.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = 'pubnub'
+  s.version = '3.4'
+
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['PubNub']
+  s.date = '2013-10-19'
+  s.description = 'Ruby anywhere in the world in 250ms with PubNub!'
+  s.email = 'support@pubnub.com'
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'http://github.com/pubnub/ruby'
+  s.licenses = ['MIT']
+  s.require_paths = ['lib']
+  s.rubygems_version = '1.7.2'
+  s.summary = 'PubNub Official Ruby gem'
+
+  s.add_dependency 'eventmachine'
+  s.add_dependency 'httparty'
+  s.add_dependency 'persistent_httparty'
+  s.add_dependency 'em-http-request'
+  s.add_dependency 'uuid', '~> 2.3.5'
+  s.add_dependency 'json'
+
+end

data/spec/lib/client_spec.rb

@@ -0,0 +1,346 @@
+require 'spec_helper'
+require 'rr'
+require 'vcr'
+
+describe Pubnub::Client do
+
+  describe '#uuid' do
+    it 'should return a UUID' do
+    end
+  end
+
+  describe '.initialize' do
+
+    before do
+      @publish_key   = 'demo_pub_key'
+      @subscribe_key = 'demo_sub_key'
+      @secret_key    = 'demo_md5_key'
+      @cipher_key    = 'demo_cipher_key'
+      @ssl           = false
+      @channel       = 'pn_test'
+    end
+
+    shared_examples_for 'successful initialization' do
+
+      it 'should initialize' do
+        @pn.publish_key.should   == @publish_key
+        @pn.subscribe_key.should == @subscribe_key
+        @pn.secret_key.should    == @secret_key
+        @pn.cipher_key.should    == @cipher_key
+        @pn.ssl.should           == @ssl_enabled
+      end
+    end
+
+    context 'when initialized' do
+      it 'should set a sessionUUID' do
+        Pubnub.new(:subscribe_key => :demo).session_uuid.should_not == nil
+      end
+    end
+
+    context 'when named' do
+      context 'and there are more than one arguments' do
+        it 'should throw an error' do
+          lambda { Pubnub::Client.new('arg1', 'arg2', 'arg3') }.should raise_error
+        end
+      end
+    end
+
+    context 'when passed with optional parameters in a hash' do
+      context 'when the hash key is a symbol' do
+        before do
+          @pn = Pubnub::Client.new(:publish_key   => @publish_key,
+                                   :subscribe_key => @subscribe_key,
+                                   :secret_key    => @secret_key,
+                                   :cipher_key    => @cipher_key,
+                                   :ssl           => @ssl_enabled)
+        end
+        it_behaves_like 'successful initialization'
+      end
+    end
+
+    describe '.verify_config' do
+      context 'subscribe_key' do
+        it 'should not throw an exception if present' do
+          lambda {  pn = Pubnub::Client.new(:subscribe_key => 'demo') }.should_not raise_error
+        end
+
+        it 'should not throw an exception if present' do
+          lambda { pn = Pubnub::Client.new(:subscribe_key => :bar) }.should_not raise_error
+        end
+      end
+    end
+  end
+
+  describe 'public methods' do
+    describe '.time' do
+      before do
+
+        @my_callback = lambda { |message| Rails.logger.debug(message) }
+        @my_pub_key = 'demo'
+        @my_sub_key = 'demo'
+        @my_message = 'hello_world!'
+        @my_channel = 'hello_world'
+
+        @my_cipher_key = 'my_cipher_key'
+        @my_sec_key = 'my_sec_key'
+        @alt_sec_key = 'alt_sec_key'
+      end
+
+      context 'required parameters' do
+
+        before do
+          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
+        end
+
+        it 'should raise when callback or block is missing' do
+          lambda { @pn.time }.
+              should raise_error(ArgumentError, 'time() require, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is invalid' do
+          lambda { @pn.time(:callback => :blah) }.
+              should raise_error('callback is invalid.')
+        end
+
+      end
+    end
+
+    describe '.publish' do
+      before do
+
+        @my_callback = lambda { |message| Rails.logger.debug(message) }
+        @my_pub_key = 'demo'
+        @my_sub_key = 'demo'
+        @my_message = 'hello_world!'
+        @my_channel = 'hello_world'
+
+        @my_cipher_key = 'my_cipher_key'
+        @my_sec_key = 'my_sec_key'
+        @alt_sec_key = 'alt_sec_key'
+      end
+
+      context 'required parameters' do
+
+        before do
+          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
+        end
+
+        it 'should raise when channel is missing' do
+          lambda { @pn.publish(:callback => @my_callback, :message => @my_message) }.
+              should raise_error(ArgumentError, 'publish() requires :channel, :message parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is missing' do
+          lambda { @pn.publish(:message => @my_message, :channel => @my_channel) }.
+              should raise_error(ArgumentError, 'publish() requires :channel, :message parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when message is missing' do
+          lambda { @pn.publish(:channel => @my_channel, :callback => @my_callback) }.
+              should raise_error(ArgumentError, 'publish() requires :channel, :message parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is invalid' do
+          lambda { @pn.presence(:channel => @my_channel, :callback => :blah) }.
+              should raise_error('callback is invalid.')
+        end
+
+      end
+    end
+
+    describe '.subscribe' do
+      before do
+
+        @my_callback = lambda { |message| Rails.logger.debug(message) }
+        @my_pub_key = 'demo'
+        @my_sub_key = 'demo'
+        @my_message = 'hello_world!'
+        @my_channel = 'hello_world'
+
+        @my_cipher_key = 'my_cipher_key'
+        @my_sec_key = 'my_sec_key'
+        @alt_sec_key = 'alt_sec_key'
+      end
+
+      context 'required parameters' do
+
+        before do
+          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
+        end
+
+        it 'should raise when channel is missing' do
+          lambda { @pn.subscribe(:foo => :bar, :callback => @my_callback) }.
+              should raise_error(ArgumentError, 'subscribe() requires :channel parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is missing' do
+          lambda { @pn.subscribe(:channel => @my_channel) }.
+              should raise_error(ArgumentError, 'subscribe() requires :channel parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is invalid' do
+          lambda { @pn.subscribe(:channel => @my_channel, :callback => :blah) }.
+              should raise_error('callback is invalid.')
+        end
+
+      end
+    end
+
+    describe '.here_now' do
+      before do
+
+        @my_callback = lambda { |message| Rails.logger.debug(message) }
+        @my_pub_key = 'demo'
+        @my_sub_key = 'demo'
+        @my_message = 'hello_world!'
+        @my_channel = 'hello_world'
+
+        @my_cipher_key = 'my_cipher_key'
+        @my_sec_key = 'my_sec_key'
+        @alt_sec_key = 'alt_sec_key'
+      end
+
+      context 'required parameters' do
+
+        before do
+          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
+        end
+
+        it 'should raise when channel is missing' do
+          lambda { @pn.here_now(:foo => :bar) }.
+              should raise_error(ArgumentError, 'here_now() requires :channel parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is missing' do
+          lambda { @pn.here_now(:channel => @my_channel) }.
+              should raise_error(ArgumentError, 'here_now() requires :channel parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is invalid' do
+          lambda { @pn.here_now(:channel => @my_channel, :callback => :blah) }.
+              should raise_error('callback is invalid.')
+        end
+
+      end
+    end
+
+    describe '.presence' do
+      before do
+
+        @my_callback = lambda { |message| Rails.logger.debug(message) }
+        @my_pub_key = 'demo'
+        @my_sub_key = 'demo'
+        @my_message = 'hello_world!'
+        @my_channel = 'hello_world'
+
+        @my_cipher_key = 'my_cipher_key'
+        @my_sec_key = 'my_sec_key'
+        @alt_sec_key = 'alt_sec_key'
+      end
+
+      context 'required parameters' do
+
+        before do
+          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
+        end
+
+        it 'should raise when channel is missing' do
+          lambda { @pn.presence(:foo => :bar) }.
+              should raise_error(ArgumentError, 'presence() requires :channel parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is missing' do
+          lambda { @pn.presence(:channel => @my_channel) }.
+              should raise_error(ArgumentError, 'presence() requires :channel parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is invalid' do
+          lambda { @pn.presence(:channel => @my_channel, :callback => :blah) }.
+              should raise_error('callback is invalid.')
+        end
+
+      end
+    end
+
+    describe '.hisotry' do
+      before do
+
+        @my_callback = lambda { |message| Rails.logger.debug(message) }
+        @my_pub_key = 'demo'
+        @my_sub_key = 'demo'
+        @my_message = 'hello_world!'
+        @my_channel = 'hello_world'
+
+        @my_cipher_key = 'my_cipher_key'
+        @my_sec_key = 'my_sec_key'
+        @alt_sec_key = 'alt_sec_key'
+      end
+
+      context 'required parameters' do
+
+        before do
+          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
+        end
+
+        it 'should raise when channel is missing' do
+          lambda { @pn.history(:count => 10, :callback => @my_callback) }.
+              should raise_error(ArgumentError, 'history() requires :channel, :count parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is missing' do
+          lambda { @pn.history(:channel => @my_channel, :count => 10) }.
+              should raise_error(ArgumentError, 'history() requires :channel, :count parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when count is missing' do
+          lambda { @pn.history(:channel => @my_channel, :callback => @my_callback) }.
+              should raise_error(ArgumentError, 'history() requires :channel, :count parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is invalid' do
+          lambda { @pn.history(:channel => @my_channel, :count => 10, :callback => :blah) }.
+              should raise_error('callback is invalid.')
+        end
+
+      end
+    end
+
+    describe '.leave' do
+      before do
+
+        @my_callback = lambda { |message| Rails.logger.debug(message) }
+        @my_pub_key = 'demo'
+        @my_sub_key = 'demo'
+        @my_message = 'hello_world!'
+        @my_channel = 'hello_world'
+
+        @my_cipher_key = 'my_cipher_key'
+        @my_sec_key = 'my_sec_key'
+        @alt_sec_key = 'alt_sec_key'
+      end
+
+      context 'required parameters' do
+
+        before do
+          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
+        end
+
+        it 'should raise when channel is missing' do
+          lambda { @pn.leave(:callback => @my_callback) }.
+              should raise_error(ArgumentError, 'leave() requires :channel parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is missing' do
+          lambda { @pn.leave(:channel => @my_channel) }.
+              should raise_error(ArgumentError, 'leave() requires :channel parameters and, if async, callback parameter or block given.')
+        end
+
+        it 'should raise when callback is invalid' do
+          lambda { @pn.leave(:channel => @my_channel, :callback => :blah) }.
+              should raise_error('callback is invalid.')
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/crypto_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'rr'
+require 'vcr'
+
+describe Pubnub::Crypto do
+
+  before do
+    @cipher_key = "enigma"
+
+    @plain_string = %^Pubnub Messaging API 1^
+    @cipher_string = "f42pIQcWZ9zbTbH8cyLwByD/GsviOE0vcREIEVPARR0="
+
+    @plain_hash = {"foo" => {"bar" => "foobar"}}
+    @encrypted_hash = "GsvkCYZoYylL5a7/DKhysDjNbwn+BtBtHj2CvzC4Y4g="
+
+    @cipher_empty_hash = "IDjZE9BHSjcX67RddfCYYg=="
+
+    @cipher_object = %^yLUdgdHs2Fsd5MUYXO7cJH2ciXPC8S3zVrmQHV00sxU=^
+
+    @cipher_empty_object = "IDjZE9BHSjcX67RddfCYYg=="
+
+    @cipher_empty_array = "Ns4TB41JjT2NCXaGLWSPAQ=="
+    @cipher_array = "bz1jaOW3wT/MBPMN8SI0GvWPKT2PUfj2TD/Rg746jSc="
+
+  end
+
+  describe "#when there is a message encrypted on PHP AES256" do
+
+    context "pubnub standard tests" do
+      it "should encrypt" do
+        crypto = Pubnub::Crypto.new(@cipher_key)
+        crypto.encrypt(@plain_string).should == @cipher_string
+      end
+
+      it "should decrypt" do
+        crypto = Pubnub::Crypto.new(@cipher_key)
+        crypto.decrypt(@cipher_string).should == @plain_string
+      end
+    end
+
+  end
+
+  describe "encrypt array" do
+    it "should not blow up on an empty array" do
+      Pubnub::Crypto.new(@cipher_key).encrypt([]).should == @cipher_empty_array
+    end
+
+    it "should encrypt an array with a single message" do
+      Pubnub::Crypto.new(@cipher_key).encrypt([@plain_string]).should == @cipher_array
+    end
+
+  end
+
+  describe "decrypt array" do
+    it "should not blow up on an empty array" do
+      Pubnub::Crypto.new(@cipher_key).decrypt(@cipher_empty_array).should == []
+    end
+
+    it "should decrypt an array with a single message" do
+      Pubnub::Crypto.new(@cipher_key).decrypt(@cipher_array).should == [@plain_string]
+    end
+
+  end
+
+
+  describe "encrypt Hash" do
+    it "should not blow up on an empty hash" do
+      Pubnub::Crypto.new(@cipher_key).encrypt({}).should == @cipher_empty_hash
+    end
+
+    it "should encrypt a hash with a single message" do
+      Pubnub::Crypto.new(@cipher_key).encrypt(@plain_hash).should == @encrypted_hash
+    end
+  end
+
+  describe "decrypt Hash" do
+    it "should not blow up on an empty hash" do
+      Pubnub::Crypto.new(@cipher_key).decrypt(@cipher_empty_hash).should == {}
+    end
+
+    it "should decrypt an hash with a single message" do
+      Pubnub::Crypto.new(@cipher_key).decrypt(@encrypted_hash).should == @plain_hash
+    end
+  end
+
+
+end
+
+