pubnub 4.1.2 → 4.1.6

data/lib/pubnub/schemas/envelope_schema.rb

@@ -1,57 +1,84 @@
+# frozen_string_literal: true
+
 module Pubnub
   module Schemas
     module Envelope
-      DataSchema = Dry::Validation.Schema do
+      DataSchema = Dry::Schema.Params do
         required(:message)
         required(:subscribed_channel).filled(:str?)
         required(:actual_channel).filled(:str?)
         optional(:publish_time_object).maybe(:hash?)
         optional(:message_meta_data).maybe(:hash?)
         optional(:presence_event).maybe(:str?)
-        optional(:presence).maybe.schema do
-          optional(:uuid).filled(:str?)
-          optional(:timestamp).filled(:int?)
-          optional(:state).maybe(:hash?)
-          optional(:occupancy).filled(:int?)
+        optional(:presence).maybe do
+          hash do
+            optional(:uuid).filled(:str?)
+            optional(:timestamp).filled(:int?)
+            optional(:state).maybe(:hash?)
+            optional(:occupancy).filled(:int?)
+          end
         end
       end
 
-      ConfigSchema = Dry::Validation.Schema do
+      PresenceSchema = Dry::Schema.Params do
+        required(:channels).maybe(:array?)
+      end
+
+      ConfigSchema = Dry::Schema.Params do
         required(:tls).filled(:bool?)
         required(:uuid).filled(:str?)
         optional(:auth_key).maybe(:str?)
         required(:origin).filled(:str?)
       end
 
-      StatusSchema = Dry::Validation.Schema do
-        required(:code).filled(:int?)
-        required(:client_request).filled
-        required(:server_response).filled
-        optional(:data).maybe
+      CategorySchema = Dry::Schema.Params do
         required(:category).filled
         required(:error).filled(:bool?)
-        required(:auto_retried).filled(:bool?)
+      end
 
-        optional(:current_timetoken).maybe(:int?)
-        optional(:last_timetoken).maybe(:int?)
-        optional(:subscribed_channels).maybe(:array?)
-        optional(:subscribed_channel_groups).maybe(:array?)
+      # The schema for status response on subscribe listener
+      class StatusSchema < Dry::Validation::Contract
+        params do
+          required(:code).filled(:int?)
+          required(:category).filled
+          required(:error).filled(:bool?)
+          required(:client_request).filled
+          required(:server_response).filled
+          required(:auto_retried).filled(:bool?)
 
-        required(:config).schema(ConfigSchema)
+          optional(:data).maybe(:hash?)
+          optional(:current_timetoken).maybe(:int?)
+          optional(:last_timetoken).maybe(:int?)
+          optional(:subscribed_channels).maybe(:array?)
+          optional(:subscribed_channel_groups).maybe(:array?)
 
-        rule(category_value: %i[error category]) do |error, category|
-          error.true?.then(category.included_in?(Pubnub::Constants::STATUS_CATEGORY_ERRORS))
-          error.false?.then(category.included_in?(Pubnub::Constants::STATUS_CATEGORY_SUCCESSES))
+          required(:config).hash(ConfigSchema)
+        end
+
+        rule(:category, :error) do
+          key.failure('Invalid error category') if values[:error] && Pubnub::Constants::STATUS_CATEGORY_ERRORS.include?(values[:category].to_s)
+          key.failure('Invalid success category') if !values[:error] && Pubnub::Constants::STATUS_CATEGORY_SUCCESSES.include?(values[:category].to_s)
         end
       end
 
-      ResultSchema = Dry::Validation.Schema do
-        required(:code).filled(:int?)
-        required(:operation) { included_in?(Pubnub::Constants::OPERATIONS) }
-        required(:client_request).filled
-        required(:server_response).filled
+      # The schema for the publish result on a subscribe listener
+      class ResultSchema < Dry::Validation::Contract
+        params do
+          required(:code).filled(:int?)
+          required(:operation) { included_in?(Pubnub::Constants::OPERATIONS) }
+          required(:client_request).filled
+          required(:server_response).filled
+
+          optional(:data).maybe(:hash?)
+        end
 
-        required(:data).maybe.schema(DataSchema)
+        rule(:operation, :data) do
+          if values[:operation] == Pubnub::Constants::OPERATION_PRESENCE
+            PresenceSchema.call(values[:data])
+          else
+            DataSchema.call(values[:data])
+          end
+        end
       end
     end
   end

data/lib/pubnub/subscribe_callback.rb

@@ -8,7 +8,8 @@ module Pubnub
       @callbacks = {
         message: options[:message],
         status: options[:status],
-        presence: options[:presence]
+        presence: options[:presence],
+        signal: options[:signal]
       }
       validate!
     end

data/lib/pubnub/subscribe_event/formatter.rb

@@ -134,11 +134,11 @@ module Pubnub
         # return if envelopes.size == 1 && envelopes.first.timetoken_update?
 
         results_validation = envelopes.map(&:result).map do |result|
-          Pubnub::Schemas::Envelope::ResultSchema.call result
+          Pubnub::Schemas::Envelope::ResultSchema.new.call result
         end
 
         statuses_validation = envelopes.map(&:status).map do |status|
-          Pubnub::Schemas::Envelope::StatusSchema.call status
+          Pubnub::Schemas::Envelope::StatusSchema.new.call status
         end
 
         if (results_validation + statuses_validation).map(&:failure?).index(true)
@@ -164,6 +164,8 @@ module Pubnub
           Pubnub::Constants::OPERATION_TIME
         elsif message[:channel].to_s.index(/pnpres\z/)
           Pubnub::Constants::OPERATION_PRESENCE
+        elsif message[:type] == 1
+          Pubnub::Constants::OPERATION_SIGNAL
         else
           Pubnub::Constants::OPERATION_SUBSCRIBE
         end
@@ -193,6 +195,7 @@ module Pubnub
             channel: m['c'],
             subscription_match: m['b'],
             payload: m['d'],
+            type: m['e'],
             flags: m['f'],
             issuing_client_id: m['i'],
             subscribe_key: m['k'],

data/lib/pubnub/subscriber.rb

@@ -71,6 +71,8 @@ module Pubnub
             case envelope.result[:operation]
             when Pubnub::Constants::OPERATION_SUBSCRIBE
               secure_call callbacks.callbacks[:message], envelope
+            when Pubnub::Constants::OPERATION_SIGNAL
+              secure_call callbacks.callbacks[:signal], envelope
             when Pubnub::Constants::OPERATION_PRESENCE
               secure_call callbacks.callbacks[:presence], envelope
             else

data/lib/pubnub/validators/push.rb

@@ -6,12 +6,12 @@ module Pubnub
     # Push related events validator
     module Push
       include CommonValidator
-      BASIC_PARAMS = %i[push_token type uuid].freeze
+      BASIC_PARAMS = %i[push_token type].freeze
       PARAMS_MAP = {
-        Pubnub::Constants::OPERATION_ADD_CHANNELS_TO_PUSH => BASIC_PARAMS + %i[add auth],
+        Pubnub::Constants::OPERATION_ADD_CHANNELS_TO_PUSH => BASIC_PARAMS + %i[add],
         Pubnub::Constants::OPERATION_LIST_PUSH_PROVISIONS => BASIC_PARAMS,
-        Pubnub::Constants::OPERATION_REMOVE_CHANNELS_FROM_PUSH => BASIC_PARAMS + %i[remove auth],
-        Pubnub::Constants::OPERATION_REMOVE_DEVICE_FROM_PUSH => BASIC_PARAMS - [:uuid]
+        Pubnub::Constants::OPERATION_REMOVE_CHANNELS_FROM_PUSH => BASIC_PARAMS + %i[remove],
+        Pubnub::Constants::OPERATION_REMOVE_DEVICE_FROM_PUSH => BASIC_PARAMS
       }.freeze
 
       def validate!
@@ -23,7 +23,7 @@ module Pubnub
       private
 
       def validate_channel!
-        missing_params = required_params - @params.keys
+        missing_params = required_params - @given_options.keys
         return if missing_params.empty?
 
         raise(

data/lib/pubnub/validators/signal.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Toplevel Pubnub module.
+module Pubnub
+  # Validator module that holds all validators modules
+  module Validator
+    # Validator for Signal event
+    module Signal
+      include CommonValidator
+
+      def validate!
+        return if @skip_validate
+
+        validate_publish_key!
+        validate_channel!
+        validate_message!
+      end
+
+      private
+
+      def validate_publish_key!
+        return unless @publish_key.nil?
+
+        raise(
+          ArgumentError.new,
+          ':publish_key is required for publish event.'
+        )
+      end
+
+      def validate_channel!
+        return unless @channel.nil? || @channel.empty?
+
+        raise(
+          ArgumentError.new,
+          ':channel is required for publish event.'
+        )
+      end
+
+      def validate_message!
+        return unless @message.nil?
+
+        raise(
+          ArgumentError.new,
+          ':message is required for publish event.'
+        )
+      end
+    end
+  end
+end

data/lib/pubnub/version.rb

@@ -1,4 +1,4 @@
 # Toplevel Pubnub module.
 module Pubnub
-  VERSION = '4.1.2'.freeze
+  VERSION = '4.1.6'.freeze
 end

data/pubnub.gemspec

@@ -16,12 +16,13 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^bin\/}) { |f| File.basename(f) }
   spec.test_files = spec.files.grep(%r{^(test|spec|features)\/})
   spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.4'
 
-  spec.add_dependency 'concurrent-ruby', '~> 1.0.5'
-  spec.add_dependency 'concurrent-ruby-edge', '~> 0.3.1'
-  spec.add_dependency 'dry-validation', '~> 0.10'
+  spec.add_dependency 'concurrent-ruby', '~> 1.1.5'
+  spec.add_dependency 'concurrent-ruby-edge', '~> 0.5.0'
+  spec.add_dependency 'dry-validation', '~> 1.0'
   spec.add_dependency 'httpclient', '~> 2.8', '>= 2.8.3'
-  spec.add_dependency 'json', '>= 1.8', '< 3'
-  spec.add_dependency 'timers', '>= 4.1.1'
+  spec.add_dependency 'json', '>= 2.2.0', '< 3'
+  spec.add_dependency 'timers', '>= 4.3.0'
   spec.add_development_dependency 'bundler', '~> 1.7'
 end

data/spec/examples/audit_examples_spec.rb

@@ -11,7 +11,7 @@ describe Pubnub::Audit do
     @pubnub = Pubnub.new(
       publish_key: "pub-a-mock-key",
       subscribe_key: "sub-a-mock-key",
-      secret_key: "sec-c-OWIyYmVlYWYtYWMxMS00OTcxLTlhZDAtZDBlYTM4ODE1MWUy",
+      secret_key: "sec-a-mock-key",
       uuid: "ruby-test-uuid-client-one",
       auth_key: "ruby-test-auth-client-one",
     )

data/spec/examples/grant_examples_spec.rb

@@ -11,7 +11,7 @@ describe Pubnub::Grant do
     @pubnub = Pubnub.new(
       publish_key: "pub-a-mock-key",
       subscribe_key: "sub-a-mock-key",
-      secret_key: "sec-c-OWIyYmVlYWYtYWMxMS00OTcxLTlhZDAtZDBlYTM4ODE1MWUy",
+      secret_key: "sec-a-mock-key",
       uuid: "ruby-test-uuid-client-one",
       auth_key: "ruby-test-auth-client-one",
     )

data/spec/examples/presence_examples_spec.rb

@@ -29,7 +29,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403696, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654036961172863", :region_code => 1}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403696, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654036961172863", :region_code => 1}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654036961931472)
@@ -54,7 +54,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "leave", "timestamp" => 1465403696, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654036965065315", :region_code => 2}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "leave", "timestamp" => 1465403696, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654036965065315", :region_code => 2}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654036965469160)
@@ -79,7 +79,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403698, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654036986516448", :region_code => 2}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403698, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654036986516448", :region_code => 2}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654036986900265)
@@ -203,7 +203,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo.*-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403699, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654036996668692", :region_code => 1}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo.*-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403699, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654036996668692", :region_code => 1}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654036997432530)
@@ -228,7 +228,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo.*-pnpres", :subscription_match => nil, :payload => {"action" => "leave", "timestamp" => 1465403700, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654037002398263", :region_code => 1}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo.*-pnpres", :subscription_match => nil, :payload => {"action" => "leave", "timestamp" => 1465403700, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654037002398263", :region_code => 1}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654037003110327)
@@ -253,7 +253,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo.*-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403702, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654037023404890", :region_code => 1}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo.*-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403702, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654037023404890", :region_code => 1}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654037024165554)
@@ -377,7 +377,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "leave", "timestamp" => 1465403703, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654037039766378", :region_code => 2}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "leave", "timestamp" => 1465403703, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654037039766378", :region_code => 2}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654037040157428)
@@ -402,7 +402,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465405069, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654050693824272", :region_code => 1}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465405069, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654050693824272", :region_code => 1}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654050694555754)
@@ -427,7 +427,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403890, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654038904558577", :region_code => 2}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => nil, :payload => {"action" => "join", "timestamp" => 1465403890, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654038904558577", :region_code => 2}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654038904954461)
@@ -551,7 +551,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => "demo-pnpres", :payload => {"action" => "leave", "timestamp" => 1465403891, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654038913084722", :region_code => 1}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => "demo-pnpres", :payload => {"action" => "leave", "timestamp" => 1465403891, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654038913084722", :region_code => 1}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654038913920232)
@@ -576,7 +576,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo.*-pnpres", :subscription_match => "demo.*-pnpres", :payload => {"action" => "leave", "timestamp" => 1465403892, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654038929920942", :region_code => 1}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo.*-pnpres", :subscription_match => "demo.*-pnpres", :payload => {"action" => "leave", "timestamp" => 1465403892, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 0}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654038929920942", :region_code => 1}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654038931856126)
@@ -601,7 +601,7 @@ describe Pubnub::Presence do
       end
 
       expect(envelopes[0].status[:code]).to eq(200)
-      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => "demo-pnpres", :payload => {"action" => "join", "timestamp" => 1465403893, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654038934962157", :region_code => 2}})
+      expect(envelopes[0].status[:data]).to eq({:shard => "5", :channel => "demo-pnpres", :subscription_match => "demo-pnpres", :payload => {"action" => "join", "timestamp" => 1465403893, "uuid" => "ruby-test-uuid-client-two", "occupancy" => 1}, :flags => 0, :issuing_client_id => nil, :subscribe_key => "sub-a-mock-key", :sequence_number => nil, :user_meta_data => nil, :replication_map => nil, :eat_after_reading => nil, :type => nil, :waypoint_list => nil, :origination_time_token => nil, :publish_timetoken => {:timetoken => "14654038934962157", :region_code => 2}})
       expect(envelopes[0].status[:category]).to eq(:ack)
       expect(envelopes[0].status[:auto_retried]).to eq(true)
       expect(envelopes[0].status[:current_timetoken]).to eq(14654038935342617)

data/spec/examples/publish_with_ttl_spec.rb

@@ -18,7 +18,7 @@ describe Pubnub::Publish do
         envelope = @pubnub.publish(channel: :demo, message: :whatever, ttl: 10, http_sync: true)
 
         expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
       end
     end
 
@@ -27,7 +27,7 @@ describe Pubnub::Publish do
         envelope = @pubnub.publish(channel: :demo, message: :whatever, ttl: 10, store: false, http_sync: true)
 
         expect(envelope.is_a?(Pubnub::Envelope)).to eq true
-        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
       end
     end
   end

data/spec/examples/revoke_examples_spec.rb

@@ -11,7 +11,7 @@ describe Pubnub::Revoke do
     @pubnub = Pubnub.new(
       publish_key: "pub-a-mock-key",
       subscribe_key: "sub-a-mock-key",
-      secret_key: "sec-c-OWIyYmVlYWYtYWMxMS00OTcxLTlhZDAtZDBlYTM4ODE1MWUy",
+      secret_key: "sec-a-mock-key",
       uuid: "ruby-test-uuid-client-one",
       auth_key: "ruby-test-auth-client-one",
     )