pubnub 4.2.6 → 4.6.0

data/spec/lib/connection_callback_spec.rb

@@ -7,6 +7,7 @@ describe "Connect, disconnect and reconnect callbacks" do
 
   before(:each) do
     @connect_messages, @reconnect_messages, @disconnect_messages = [], [], []
+    @sleep_duration = ENV['JRUBY_TEST'] == 'true' ? 1.5 : 0.5
 
     callback = Pubnub::SubscribeCallback.new(
       message: -> (_envelope) { },
@@ -37,7 +38,7 @@ describe "Connect, disconnect and reconnect callbacks" do
   it "fire connect callback when connection is made" do
     VCR.use_cassette("client/connection_callbacks_0", :record => :once) do
       @pubnub.subscribe(channel: :demo)
-      sleep 0.5
+      sleep @sleep_duration
       expect(@connect_messages.size).to be > 0
     end
   end
@@ -47,7 +48,7 @@ describe "Connect, disconnect and reconnect callbacks" do
 
     VCR.use_cassette("client/connection_callbacks_1", :record => :once) do
       @pubnub.subscribe(channel: :demo)
-      sleep 0.5
+      sleep @sleep_duration
       expect(@disconnect_messages.size).to be > 0
     end
   end
@@ -57,7 +58,7 @@ describe "Connect, disconnect and reconnect callbacks" do
 
     VCR.use_cassette("client/connection_callbacks_2", :record => :once) do
       @pubnub.subscribe(channel: :demo)
-      sleep 0.5
+      sleep @sleep_duration
       expect(@reconnect_messages.size).to be > 0
     end
   end

data/spec/lib/event/formatter_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe "formatter" do
+  around :each do |example|
+    example.run_with_retry retry: 10
+  end
+
+  it "does not hide errors when formatting" do
+    class MockFormatter
+      include Pubnub::Event::EFormatter
+    end
+
+    class TestError < StandardError
+      def message
+        "This is a test"
+      end
+    end
+
+    # ensure the correct error is raised instead of -> NoMethodError: undefined method `body'
+    expect { MockFormatter.new.format_envelopes(TestError.new('error'), nil) }.to raise_error(TestError)
+  end
+end

data/spec/lib/events/channel_metadata_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe Pubnub::SetChannelMetadata do
+  it_behaves_like "an event"
+
+  context "given basic parameters" do
+    before :each do
+      @pubnub = Pubnub::Client.new(
+        subscribe_key: "sub-a-mock-key",
+        publish_key: "pub-a-mock-key",
+        auth_key: "ruby-test-auth",
+        uuid: "ruby-test-uuid"
+      )
+    end
+
+    it "set_channel_metadata_works" do
+      VCR.use_cassette("lib/events/set_channel_metadata", record: :once) do
+        envelope = @pubnub.set_channel_metadata(
+          channel: "rb_channel",
+          metadata: { name: "some_name", custom: { XXX: "YYYY" } },
+          include: { custom: true }
+        ).value
+
+        expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+      end
+    end
+
+    it "get_channel_metadata_works" do
+      VCR.use_cassette("lib/events/get_channel_metadata", record: :once) do
+        envelope = @pubnub.get_channel_metadata(channel: "rb_channel", include: { custom: true }).value
+
+        expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+      end
+    end
+
+    it "get_all_channels_metadata_works" do
+      VCR.use_cassette("lib/events/get_all_channels_metadata", record: :once) do
+        envelope = @pubnub.get_all_channels_metadata(limit: 5, include: { custom: true }).value
+
+        expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+      end
+    end
+
+    it "remove_channel_metadata_works" do
+      VCR.use_cassette("lib/events/remove_channel_metadata", record: :once) do
+        envelope = @pubnub.remove_channel_metadata(channel: "rb_channel").value
+
+        expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+      end
+    end
+
+  end
+
+end

data/spec/lib/events/grant_spec.rb

@@ -5,9 +5,10 @@ describe Pubnub::Grant do
 
   context "given basic parameters" do
     before :each do
-      allow_any_instance_of(Pubnub::Grant).to receive(:current_time).and_return 1463146850
-      allow_any_instance_of(Pubnub::Grant).to receive(:signature).and_return "udCXAk-z4VaU2JA2LgjVzED2LBZAKsjj86twYJoGPnY="
+      allow_any_instance_of(Pubnub::Grant).to receive(:current_time).and_return 1602537897
+      allow_any_instance_of(Pubnub::Grant).to receive(:signature).and_return "v2.OdCTZXne_jEBewh3yY8iNDWcMCHC6BXNrg1Er9JoSTQ"
     end
+
     let(:pubnub) do
       Pubnub::Client.new(
         subscribe_key: "sub-a-mock-key",

data/spec/lib/events/membership_spec.rb

@@ -1,63 +1,93 @@
 require "spec_helper"
 
-describe Pubnub::ManageMemberships do
+describe Pubnub::SetMemberships do
   it_behaves_like "an event"
 
   context "given basic parameters" do
     before :each do
       @pubnub = Pubnub::Client.new(
-        subscribe_key: "demo",
-        publish_key: "demo",
+        subscribe_key: "sub-a-mock-key",
+        publish_key: "pub-a-mock-key",
         auth_key: "ruby-test-auth",
         uuid: "ruby-test-uuid",
       )
     end
-    it "get_members_works" do
-      VCR.use_cassette("lib/events/get_members", record: :once) do
-        envelope = @pubnub.get_members(space_id: "space-1", include: "custom", count: true).value
+
+    it "get_channel_members_works" do
+      VCR.use_cassette("lib/events/get_channel_members", record: :once) do
+        envelope = @pubnub.get_channel_members(channel: "channel-1", include: { count: true, custom: true }).value
 
         expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
       end
     end
 
-    it "get_space_memberships_works" do
-      VCR.use_cassette("lib/events/get_space_memberships", record: :once) do
-        envelope = @pubnub.get_space_memberships(user_id: "mg3", include: "custom", count: true).value
+    it "get_memberships_works_1" do
+      VCR.use_cassette("lib/events/get_memberships1", record: :once) do
+        envelope = @pubnub.get_memberships(uuid: "mg3", include: { count: true, custom: true }).value
 
         expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
       end
     end
 
-    it "manage_memberships_add_works" do
-      VCR.use_cassette("lib/events/manage_memberships_add", record: :once) do
-        envelope = @pubnub.manage_memberships(user_id: "mg3", data: {'add': [{'id': 'space-1'}]}, include: "custom").value
+    it "get_memberships_works_2" do
+      VCR.use_cassette("lib/events/get_memberships2", record: :once) do
+        envelope = @pubnub.get_memberships(include: { count: true, custom: true }).value
 
         expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
       end
     end
-    it "manage_memberships_remove_works" do
-      VCR.use_cassette("lib/events/manage_memberships_remove", record: :once) do
-        envelope = @pubnub.manage_memberships(user_id: "mg3", data: {'remove': [{'id': 'space-1'}]}, include: "custom").value
+
+    it "set_memberships_works_1" do
+      VCR.use_cassette("lib/events/set_memberships1", record: :once) do
+        envelope = @pubnub.set_memberships(uuid: "mg3", channels: [{ channel: 'channel-1'}], include: { custom: true }).value
 
         expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
       end
     end
 
-    it "manage_members_add_works" do
-      VCR.use_cassette("lib/events/manage_members_add", record: :once) do
-        envelope = @pubnub.manage_members(space_id: "space-1", data: {'add': [{'id': 'mg2'}]}, include: "custom").value
+    it "set_memberships_works_2" do
+      VCR.use_cassette("lib/events/set_memberships2", record: :once) do
+        envelope = @pubnub.set_memberships(channels: [{ channel: 'channel-1'}], include: { custom: true }).value
 
         expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
       end
     end
-    it "manage_members_remove_works" do
-      VCR.use_cassette("lib/events/manage_members_remove", record: :once) do
-        envelope = @pubnub.manage_members(space_id: "space-1", data: {'remove': [{'id': 'mg2'}]}, include: "custom").value
+
+    it "remove_memberships_works_1" do
+      VCR.use_cassette("lib/events/remove_memberships1", record: :once) do
+        envelope = @pubnub.remove_memberships(uuid: "mg3", channels: ['channel-1'], include: { custom: true }).value
+
+        expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+      end
+    end
+
+    it "remove_memberships_works_2" do
+      VCR.use_cassette("lib/events/remove_memberships2", record: :once) do
+        envelope = @pubnub.remove_memberships(channels: ['channel-1'], include: { custom: true }).value
+
+        expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+      end
+    end
+
+    it "set_channel_members_works" do
+      VCR.use_cassette("lib/events/set_channel_members", record: :once) do
+        envelope = @pubnub.set_channel_members(channel: "channel-1", uuids: [{uuid: 'mg2'}], include: { custom: true }).value
+
+        expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+        expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+      end
+    end
+
+    it "remove_channel_members_works" do
+      VCR.use_cassette("lib/events/remove_channel_members", record: :once) do
+        envelope = @pubnub.remove_channel_members(channel: "channel-1", uuids: ['mg2'], include: { custom: true }).value
 
         expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
         expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new

data/spec/lib/events/presence_delta_spec.rb

@@ -8,12 +8,12 @@ describe Pubnub::Presence do
 
   context "with interval events and delta" do
     before :each do
-      @messages = []
+      @presences = []
       @statuses = []
 
       @callbacks = Pubnub::SubscribeCallback.new(
         message: -> (_envelope) { },
-        presence: -> (envelope) { @messages << envelope },
+        presence: -> (envelope) { @presences << envelope },
         status: -> (envelope) { @statuses << envelope },
       )
     end
@@ -26,10 +26,13 @@ describe Pubnub::Presence do
         pubnub.presence(channel: :demo)
 
         eventually do
-          expect(@messages[0].result[:data]).to eq({:message => {"action" => "interval", "timestamp" => 1490958575, "occupancy" => 3}, :subscribed_channel => "demo-pnpres", :actual_channel => "demo-pnpres", :publish_time_object => {:timetoken => "14909585750910131", :region_code => 1}, :message_meta_data => nil, :presence_event => "interval", :presence => {:uuid => nil, :timestamp => 1490958575, :state => nil, :occupancy => 3}})
-          expect(@messages[1].result[:data]).to eq({:message => {"action" => "interval", "timestamp" => 1490958585, "occupancy" => 4, "join" => ["Client-d39lr"]}, :subscribed_channel => "demo-pnpres", :actual_channel => "demo-pnpres", :publish_time_object => {:timetoken => "14909585850925693", :region_code => 1}, :message_meta_data => nil, :presence_event => "interval", :presence => {:uuid => nil, :timestamp => 1490958585, :state => nil, :occupancy => 4}})
-          expect(@messages[2].result[:data]).to eq({:message => {"action" => "interval", "timestamp" => 1490958595, "occupancy" => 3, "leave" => ["another-client"]}, :subscribed_channel => "demo-pnpres", :actual_channel => "demo-pnpres", :publish_time_object => {:timetoken => "14909585950916556", :region_code => 1}, :message_meta_data => nil, :presence_event => "interval", :presence => {:uuid => nil, :timestamp => 1490958595, :state => nil, :occupancy => 3}})
-          expect(@messages[3].result[:data]).to eq({:message => {"action" => "interval", "timestamp" => 1490958605, "occupancy" => 2, "join" => ["another-client"], "leave" => ["Client-d39lr", "client0"]}, :subscribed_channel => "demo-pnpres", :actual_channel => "demo-pnpres", :publish_time_object => {:timetoken => "14909586050915528", :region_code => 1}, :message_meta_data => nil, :presence_event => "interval", :presence => {:uuid => nil, :timestamp => 1490958605, :state => nil, :occupancy => 2}})
+          if @presences.length >= 4
+            expect(@presences[0].result[:data]).to eq({:message => {"action" => "interval", "timestamp" => 1490958575, "occupancy" => 3}, :subscribed_channel => "demo-pnpres", :actual_channel => "demo-pnpres", :publish_time_object => {:timetoken => "14909585750910131", :region_code => 1}, :message_meta_data => nil, :presence_event => "interval", :presence => {:uuid => nil, :timestamp => 1490958575, :state => nil, :occupancy => 3}})
+            expect(@presences[1].result[:data]).to eq({:message => {"action" => "interval", "timestamp" => 1490958585, "occupancy" => 4, "join" => ["Client-d39lr"]}, :subscribed_channel => "demo-pnpres", :actual_channel => "demo-pnpres", :publish_time_object => {:timetoken => "14909585850925693", :region_code => 1}, :message_meta_data => nil, :presence_event => "interval", :presence => {:uuid => nil, :timestamp => 1490958585, :state => nil, :occupancy => 4}})
+            expect(@presences[2].result[:data]).to eq({:message => {"action" => "interval", "timestamp" => 1490958595, "occupancy" => 3, "leave" => ["another-client"]}, :subscribed_channel => "demo-pnpres", :actual_channel => "demo-pnpres", :publish_time_object => {:timetoken => "14909585950916556", :region_code => 1}, :message_meta_data => nil, :presence_event => "interval", :presence => {:uuid => nil, :timestamp => 1490958595, :state => nil, :occupancy => 3}})
+            expect(@presences[3].result[:data]).to eq({:message => {"action" => "interval", "timestamp" => 1490958605, "occupancy" => 2, "join" => ["another-client"], "leave" => ["Client-d39lr", "client0"]}, :subscribed_channel => "demo-pnpres", :actual_channel => "demo-pnpres", :publish_time_object => {:timetoken => "14909586050915528", :region_code => 1}, :message_meta_data => nil, :presence_event => "interval", :presence => {:uuid => nil, :timestamp => 1490958605, :state => nil, :occupancy => 2}})
+            true
+          end
         end
       end
     end

data/spec/lib/events/presence_spec.rb

@@ -4,7 +4,7 @@ describe Pubnub::Presence do
   around :each do |example|
     example.run_with_retry retry: 10
   end
-  
+
   it_behaves_like "an event"
 
   context "given basic parameters" do
@@ -34,9 +34,12 @@ describe Pubnub::Presence do
           @pubnub.presence(channel: :demo)
 
           eventually do
-            envelope = @messages.first
-            expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
-            expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+            if @messages.length > 0
+              envelope = @messages.first
+              expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+              expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+              true
+            end
           end
         end
       end
@@ -56,9 +59,12 @@ describe Pubnub::Presence do
           sleep 0.1
 
           eventually do
-            envelope = @statuses.first
-            expect(envelope).to be_a_kind_of Pubnub::ErrorEnvelope
-            # expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
+            if @statuses.length > 0
+              envelope = @statuses.first
+              expect(envelope).to be_a_kind_of Pubnub::ErrorEnvelope
+              # expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema
+              true
+            end
           end
         end
       end

data/spec/lib/events/subscribe_spec.rb

@@ -13,8 +13,8 @@ describe Pubnub::Subscribe do
       @messages = []
       @statuses = []
       @signals = []
-      @user_events = []
-      @space_events = []
+      @uuid_metadata_events = []
+      @channel_metadata_events = []
       @membership_events = []
 
       @callbacks = Pubnub::SubscribeCallback.new(
@@ -22,9 +22,19 @@ describe Pubnub::Subscribe do
         presence: -> (_envelope) { },
         status: -> (envelope) { @statuses << envelope },
         signal: -> (envelope) { @signals << envelope },
-        user: -> (envelope) { @user_events << envelope },
-        space: -> (envelope) { @space_events << envelope },
-        membership: -> (envelope) { @membership_events << envelope }
+        object: -> (envelope) {
+          case envelope.result[:operation]
+          when Pubnub::Constants::OPERATION_SET_UUID_METADATA, Pubnub::Constants::OPERATION_REMOVE_UUID_METADATA
+            @uuid_metadata_events << envelope
+          when Pubnub::Constants::OPERATION_SET_CHANNEL_METADATA, Pubnub::Constants::OPERATION_REMOVE_CHANNEL_METADATA
+            @channel_metadata_events << envelope
+          when Pubnub::Constants::OPERATION_SET_CHANNEL_MEMBERS, Pubnub::Constants::OPERATION_REMOVE_CHANNEL_MEMBERS,
+               Pubnub::Constants::OPERATION_SET_MEMBERSHIPS, Pubnub::Constants::OPERATION_REMOVE_MEMBERSHIPS
+            @membership_events << envelope
+          else
+            puts "Unexpected operation"
+          end
+        }
       )
     end
 
@@ -43,9 +53,12 @@ describe Pubnub::Subscribe do
           @pubnub.subscribe(channel: :demo)
 
           eventually do
-            envelope = @messages.first
-            expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
-            expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+            if @messages.length > 0
+              envelope = @messages.first
+              expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+              expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+              true
+            end
           end
         end
       end
@@ -56,6 +69,7 @@ describe Pubnub::Subscribe do
           publish_key: "demo",
           uuid: "ruby-test-uuid",
           cipher_key: "demo",
+          random_iv: false
         )
 
         @pubnub.add_listener(callback: @callbacks)
@@ -64,7 +78,10 @@ describe Pubnub::Subscribe do
           @pubnub.subscribe(channel: :whatever)
 
           eventually do
-            expect(@messages.first.result[:data][:message]).to eq("text" => "hey")
+            if @messages.length > 0
+              expect(@messages.first.result[:data][:message]).to eq("text" => "hey")
+              true
+            end
           end
         end
       end
@@ -100,15 +117,18 @@ describe Pubnub::Subscribe do
           sleep 0.1
 
           eventually do
-            envelope = @statuses.first
-            expect(envelope).to be_a_kind_of Pubnub::ErrorEnvelope
-            expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+            if @statuses.length > 0
+              envelope = @statuses.first
+              expect(envelope).to be_a_kind_of Pubnub::ErrorEnvelope
+              expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+              true
+            end
           end
         end
       end
 
-      it "user update works" do
-        VCR.use_cassette("lib/events/subscribe-user-update-async", record: :once) do
+      it "uuid metadata update works" do
+        VCR.use_cassette("lib/events/subscribe-uuid-metadata-set-async", record: :once) do
           @pubnub = Pubnub::Client.new(
             subscribe_key: "sub-a-mock-key",
             publish_key: "pub-a-mock-key",
@@ -118,20 +138,24 @@ describe Pubnub::Subscribe do
 
           @pubnub.add_listener(callback: @callbacks)
 
-          @pubnub.subscribe(channel: :user_mg3)
+          @pubnub.subscribe(channel: :uuid_mg3)
 
           eventually do
-            envelope = @user_events.first
-            expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
-            expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
-            expect(envelope.result[:data][:message]['event']).to eq 'update'
-            expect(envelope.result[:data][:message]['type']).to eq 'user'
+            if @uuid_metadata_events.length > 0
+              envelope = @uuid_metadata_events.first
+              expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+              expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+              expect(envelope.result[:data][:message]['event']).to eq 'set'
+              expect(envelope.result[:data][:message]['type']).to eq 'uuid'
+              expect(envelope.result[:data][:message]['data']['id']).to eq 'uuid_mg3'
+              true
+            end
           end
         end
       end
 
-      it "space update works" do
-        VCR.use_cassette("lib/events/subscribe-space-update-async", record: :once) do
+      it "channel metadata update works" do
+        VCR.use_cassette("lib/events/subscribe-channel-metadata-set-async", record: :once) do
           @pubnub = Pubnub::Client.new(
             subscribe_key: "sub-a-mock-key",
             publish_key: "pub-a-mock-key",
@@ -141,20 +165,24 @@ describe Pubnub::Subscribe do
 
           @pubnub.add_listener(callback: @callbacks)
 
-          @pubnub.subscribe(channel: :rb_space_3)
+          @pubnub.subscribe(channel: :rb_channel_3)
 
           eventually do
-            envelope = @space_events.first
-            expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
-            expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
-            expect(envelope.result[:data][:message]['event']).to eq 'update'
-            expect(envelope.result[:data][:message]['type']).to eq 'space'
+            if @channel_metadata_events.length > 0
+              envelope = @channel_metadata_events.first
+              expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+              expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+              expect(envelope.result[:data][:message]['event']).to eq 'set'
+              expect(envelope.result[:data][:message]['type']).to eq 'channel'
+              # expect(envelope.result[:data][:message]['data']['id']).to eq 'rb_channel_3'
+              true
+            end
           end
         end
       end
 
-      it "member add works" do
-        VCR.use_cassette("lib/events/subscribe-member-add-async", record: :once) do
+      it "member set works" do
+        VCR.use_cassette("lib/events/subscribe-member-set-async", record: :once) do
           @pubnub = Pubnub::Client.new(
             subscribe_key: "sub-a-mock-key",
             publish_key: "pub-a-mock-key",
@@ -164,21 +192,24 @@ describe Pubnub::Subscribe do
 
           @pubnub.add_listener(callback: @callbacks)
 
-          @pubnub.subscribe(channel: :rb_space_4)
+          @pubnub.subscribe(channel: :rb_channel_3)
 
           eventually do
-            envelope = @membership_events.first
-            expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
-            expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
-            expect(envelope.result[:data][:message]['event']).to eq 'create'
-            expect(envelope.result[:data][:message]['type']).to eq 'membership'
-            expect(envelope.result[:data][:message]['data']['userId']).to eq 'user_mg4'
+            if @membership_events.length > 0
+              envelope = @membership_events.first
+              expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+              expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+              expect(envelope.result[:data][:message]['event']).to eq 'set'
+              expect(envelope.result[:data][:message]['type']).to eq 'membership'
+              expect(envelope.result[:data][:message]['data']['uuid']['id']).to eq 'uuid_mg3'
+              true
+            end
           end
         end
       end
 
-      it "membership add works" do
-        VCR.use_cassette("lib/events/subscribe-membership-add-async", record: :once) do
+      it "membership set works" do
+        VCR.use_cassette("lib/events/subscribe-membership-set-async", record: :once) do
           @pubnub = Pubnub::Client.new(
               subscribe_key: "sub-a-mock-key",
               publish_key: "pub-a-mock-key",
@@ -188,15 +219,18 @@ describe Pubnub::Subscribe do
 
           @pubnub.add_listener(callback: @callbacks)
 
-          @pubnub.subscribe(channel: :user_mg4)
+          @pubnub.subscribe(channel: :uuid_mg5)
 
           eventually do
-            envelope = @membership_events.first
-            expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
-            expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
-            expect(envelope.result[:data][:message]['event']).to eq 'create'
-            expect(envelope.result[:data][:message]['type']).to eq 'membership'
-            expect(envelope.result[:data][:message]['data']['spaceId']).to eq 'rb_space_4'
+            if @membership_events.length > 0
+              envelope = @membership_events.first
+              expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
+              expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
+              expect(envelope.result[:data][:message]['event']).to eq 'set'
+              expect(envelope.result[:data][:message]['type']).to eq 'membership'
+              expect(envelope.result[:data][:message]['data']['channel']['id']).to eq 'rb_channel_5'
+              true
+            end
           end
         end
       end
@@ -211,13 +245,17 @@ describe Pubnub::Subscribe do
           publish_key: "demo",
           uuid: "ruby-test-uuid",
           cipher_key: "demo",
+          random_iv: false
         )
 
         VCR.use_cassette("lib/events/subscribe-cipher-async", record: :once) do
           @pubnub.subscribe(channel: :whatever, http_sync: true)
           @messages = @pubnub.subscribe(channel: :whatever, http_sync: true)
           eventually do
-            expect(@messages.first.result[:data][:message]).to eq("text" => "hey")
+            if @messages.length > 0
+              expect(@messages.first.result[:data][:message]).to eq("text" => "hey")
+              true
+            end
           end
         end
       end
@@ -258,8 +296,8 @@ describe Pubnub::Subscribe do
         end
       end
 
-      it "user delete works" do
-        VCR.use_cassette("lib/events/subscribe-user-delete-async", record: :once) do
+      it "uuid metadata remove works" do
+        VCR.use_cassette("lib/events/subscribe-uuid-metadata-remove-sync", record: :once) do
           @pubnub = Pubnub::Client.new(
               subscribe_key: "sub-a-mock-key",
               publish_key: "pub-a-mock-key",
@@ -267,19 +305,20 @@ describe Pubnub::Subscribe do
               uuid: "ruby-test-uuid"
           )
 
-          @pubnub.subscribe(channel: :user_mg3, http_sync: true)
-          envelopes = @pubnub.subscribe(channel: :user_mg3, http_sync: true)
+          @pubnub.subscribe(channel: :uuid_mg3, http_sync: true)
+          envelopes = @pubnub.subscribe(channel: :uuid_mg3, http_sync: true)
 
           envelope = envelopes.first
           expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
           expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
           expect(envelope.result[:data][:message]['event']).to eq 'delete'
-          expect(envelope.result[:data][:message]['type']).to eq 'user'
+          expect(envelope.result[:data][:message]['type']).to eq 'uuid'
+          expect(envelope.result[:data][:message]['data']['id']).to eq 'uuid_mg3'
         end
       end
 
-      it "space delete works" do
-        VCR.use_cassette("lib/events/subscribe-space-delete-async", record: :once) do
+      it "channel metadata remove works" do
+        VCR.use_cassette("lib/events/subscribe-channel-metadata-remove-sync", record: :once) do
           @pubnub = Pubnub::Client.new(
               subscribe_key: "sub-a-mock-key",
               publish_key: "pub-a-mock-key",
@@ -287,20 +326,20 @@ describe Pubnub::Subscribe do
               uuid: "ruby-test-uuid"
           )
 
-          @pubnub.subscribe(channel: :rb_space_3, http_sync: true)
-          envelopes = @pubnub.subscribe(channel: :rb_space_3, http_sync: true)
+          @pubnub.subscribe(channel: :rb_channel_1, http_sync: true)
+          envelopes = @pubnub.subscribe(channel: :rb_channel_1, http_sync: true)
 
           envelope = envelopes.first
           expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
           expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
           expect(envelope.result[:data][:message]['event']).to eq 'delete'
-          expect(envelope.result[:data][:message]['type']).to eq 'space'
-          expect(envelope.result[:data][:message]['data']['id']).to eq 'rb_space_3'
+          expect(envelope.result[:data][:message]['type']).to eq 'channel'
+          expect(envelope.result[:data][:message]['data']['id']).to eq 'rb_channel_1'
         end
       end
 
       it "member remove works" do
-        VCR.use_cassette("lib/events/subscribe-member-remove-async", record: :once) do
+        VCR.use_cassette("lib/events/subscribe-member-remove-sync", record: :once) do
           @pubnub = Pubnub::Client.new(
               subscribe_key: "sub-a-mock-key",
               publish_key: "pub-a-mock-key",
@@ -308,15 +347,15 @@ describe Pubnub::Subscribe do
               uuid: "ruby-test-uuid"
           )
 
-          @pubnub.subscribe(channel: :rb_space_4, http_sync: true)
-          envelopes = @pubnub.subscribe(channel: :rb_space_4, http_sync: true)
+          @pubnub.subscribe(channel: :rb_channel_1, http_sync: true)
+          envelopes = @pubnub.subscribe(channel: :rb_channel_1, http_sync: true)
 
           envelope = envelopes.first
           expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
           expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
           expect(envelope.result[:data][:message]['event']).to eq 'delete'
           expect(envelope.result[:data][:message]['type']).to eq 'membership'
-          expect(envelope.result[:data][:message]['data']['userId']).to eq 'user_mg4'
+          expect(envelope.result[:data][:message]['data']['uuid']['id']).to eq 'uuid_mg1'
         end
       end
 
@@ -329,15 +368,15 @@ describe Pubnub::Subscribe do
               uuid: "ruby-test-uuid"
           )
 
-          @pubnub.subscribe(channel: :user_mg4, http_sync: true)
-          envelopes = @pubnub.subscribe(channel: :user_mg4, http_sync: true)
+          @pubnub.subscribe(channel: :uuid_mg1, http_sync: true)
+          envelopes = @pubnub.subscribe(channel: :uuid_mg1, http_sync: true)
 
           envelope = envelopes.first
           expect(envelope.status).to satisfies_schema Pubnub::Schemas::Envelope::StatusSchema.new
           expect(envelope.result).to satisfies_schema Pubnub::Schemas::Envelope::ResultSchema.new
           expect(envelope.result[:data][:message]['event']).to eq 'delete'
           expect(envelope.result[:data][:message]['type']).to eq 'membership'
-          expect(envelope.result[:data][:message]['data']['spaceId']).to eq 'rb_space_4'
+          expect(envelope.result[:data][:message]['data']['channel']['id']).to eq 'rb_channel_1'
         end
 
     end