pubnub 4.2.4 → 4.4.0

data/spec/examples/history_examples_spec.rb

@@ -18,6 +18,91 @@ describe Pubnub::History do
     example.run_with_retry retry: 10
   end
 
+  it "__channel___demo___count__10___start__nil___end__nil___reverse__false___http_sync__true___callback__nil___include_meta__true_" do
+    VCR.use_cassette("examples/history/100", :record => :none) do
+      envelope = @pubnub.history(channel: :rubytest, include_meta: true, http_sync: true)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
+
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
+
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:history)
+      expect(envelope.result[:data]).to eq({:messages => [{"message" => {"message"=>"text"}, "meta" => {"metaKey"=>"metaValue"}, "timetoken" => 15965666789169854}], :end => 15965666789169854, :start => 15965666789169854})
+    end
+  end
+
+  it "__channel___demo___count__10___start__nil___end__nil___reverse__false___http_sync__true___callback__nil___encrypted__true_" do
+    @pubnub = Pubnub.new(
+      publish_key: "pub-a-mock-key",
+      subscribe_key: "sub-a-mock-key",
+      uuid: "ruby-test-uuid-client-one",
+      auth_key: "ruby-test-auth-client-one",
+      cipher_key: "super-secret-cipher-key",
+    )
+    VCR.use_cassette("examples/history/no_includes__encrypted", :record => :none) do
+      envelope = @pubnub.history(channel: :rubytest, count: 10, http_sync: true)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
+
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
+
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:history)
+      expect(envelope.result[:data]).to eq({:messages => [100], :end => 15965666789169854, :start => 15965666789169854})
+    end
+  end
+
+  it "__channel___demo___count__10___start__nil___end__nil___reverse__false___http_sync__true___callback__nil___include_meta__true___encrypted__true_" do
+    @pubnub = Pubnub.new(
+      publish_key: "pub-a-mock-key",
+      subscribe_key: "sub-a-mock-key",
+      uuid: "ruby-test-uuid-client-one",
+      auth_key: "ruby-test-auth-client-one",
+      cipher_key: "super-secret-cipher-key",
+    )
+    VCR.use_cassette("examples/history/include_meta__encrypted", :record => :none) do
+      envelope = @pubnub.history(channel: :rubytest, count: 10, include_meta: true, http_sync: true)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
+
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
+
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:history)
+      expect(envelope.result[:data]).to eq({:messages => [{"message" => 100, "meta" => "", "timetoken" => 15965666789169854}], :end => 15965666789169854, :start => 15965666789169854})
+    end
+  end
+
+  it "__channel___demo___count__10___start__nil___end__nil___reverse__false___http_sync__true___callback__nil___include_token__true___encrypted__true_" do
+    @pubnub = Pubnub.new(
+      publish_key: "pub-a-mock-key",
+      subscribe_key: "sub-a-mock-key",
+      uuid: "ruby-test-uuid-client-one",
+      auth_key: "ruby-test-auth-client-one",
+      cipher_key: "super-secret-cipher-key",
+    )
+    VCR.use_cassette("examples/history/include_token__encrypted", :record => :none) do
+      envelope = @pubnub.history(channel: :rubytest, count: 10, include_token: true, http_sync: true)
+      expect(envelope.is_a?(Pubnub::Envelope)).to eq true
+      expect(envelope.error?).to eq false
+
+      expect(envelope.status[:code]).to eq(200)
+      expect(envelope.status[:category]).to eq(:ack)
+      expect(envelope.status[:config]).to eq({:tls => false, :uuid => "ruby-test-uuid-client-one", :auth_key => "ruby-test-auth-client-one", :origin => "ps.pndsn.com"})
+
+      expect(envelope.result[:code]).to eq(200)
+      expect(envelope.result[:operation]).to eq(:history)
+      expect(envelope.result[:data]).to eq({:messages => [{"message" => 100, "timetoken" => 15965666789169854}], :end => 15965666789169854, :start => 15965666789169854})
+    end
+  end
+
   it "__channel___demo___count__10___start__nil___end__nil___reverse__true___http_sync__true___callback__nil_" do
     VCR.use_cassette("examples/history/53", record: :none) do
       envelope = @pubnub.history(channel: :demo, count: 10, reverse: true, http_sync: true)

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,66 @@
 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" do
+      VCR.use_cassette("lib/events/get_memberships", 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 "set_memberships_works" do
+      VCR.use_cassette("lib/events/set_memberships", 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_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 "remove_memberships_works" do
+      VCR.use_cassette("lib/events/remove_memberships", record: :once) do
+        envelope = @pubnub.remove_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_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 "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_channel_members_works" do
+      VCR.use_cassette("lib/events/remove_channel_members", record: :once) do
+        envelope = @pubnub.remove_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

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
 
@@ -107,8 +117,8 @@ describe Pubnub::Subscribe do
         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 +128,21 @@ 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
+            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 'update'
-            expect(envelope.result[:data][:message]['type']).to eq 'user'
+            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'
           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 +152,21 @@ 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
+            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 'update'
-            expect(envelope.result[:data][:message]['type']).to eq 'space'
+            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'
           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 +176,21 @@ 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]['event']).to eq 'set'
             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_mg3'
           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 +200,15 @@ 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]['event']).to eq 'set'
             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_5'
           end
         end
       end
@@ -258,8 +270,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 +279,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 +300,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 +321,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 +342,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