ably-rest 1.1.2 → 1.2.2

data/lib/submodules/ably-ruby/spec/acceptance/rest/push_admin_spec.rb

@@ -89,31 +89,15 @@ describe Ably::Rest::Push::Admin do
           end
         end
 
-        def request_body(request, protocol)
-          if protocol == :msgpack
-            MessagePack.unpack(request.body)
-          else
-            JSON.parse(request.body)
-          end
-        end
-
-        def serialize(object, protocol)
-          if protocol == :msgpack
-            MessagePack.pack(object)
-          else
-            JSON.dump(object)
-          end
-        end
-
         let!(:publish_stub) do
           stub_request(:post, "#{client.endpoint}/push/publish").
             with do |request|
-              expect(request_body(request, protocol)['recipient']['camelCase']['secondLevelCamelCase']).to eql('val')
-              expect(request_body(request, protocol)['recipient']).to_not have_key('camel_case')
+              expect(deserialize_body(request.body, protocol)['recipient']['camelCase']['secondLevelCamelCase']).to eql('val')
+              expect(deserialize_body(request.body, protocol)['recipient']).to_not have_key('camel_case')
               true
             end.to_return(
               :status => 201,
-              :body => serialize({}, protocol),
+              :body => serialize_body({}, protocol),
               :headers => { 'Content-Type' => content_type }
             )
         end

data/lib/submodules/ably-ruby/spec/lib/unit/models/channel_options_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Ably::Models::ChannelOptions do
+  let(:modes) { nil }
+  let(:params) { {} }
+  let(:options) { described_class.new(modes: modes, params: params) }
+
+  describe '#modes_to_flags' do
+    let(:modes) { %w[publish subscribe presence_subscribe] }
+
+    subject(:protocol_message) do
+      Ably::Models::ProtocolMessage.new(action: Ably::Models::ProtocolMessage::ACTION.Attach, flags: options.modes_to_flags)
+    end
+
+    it 'converts modes to ProtocolMessage#flags correctly' do
+      expect(protocol_message.has_attach_publish_flag?).to eq(true)
+      expect(protocol_message.has_attach_subscribe_flag?).to eq(true)
+      expect(protocol_message.has_attach_presence_subscribe_flag?).to eq(true)
+
+      expect(protocol_message.has_attach_resume_flag?).to eq(false)
+      expect(protocol_message.has_attach_presence_flag?).to eq(false)
+    end
+  end
+
+  describe '#set_modes_from_flags' do
+    let(:subscribe_flag) { 262144 }
+
+    it 'converts flags to ChannelOptions#modes correctly' do
+      result = options.set_modes_from_flags(subscribe_flag)
+
+      expect(result).to eq(options.modes)
+      expect(options.modes.map(&:to_sym)).to eq(%i[subscribe])
+    end
+  end
+
+    describe '#set_params' do
+      let(:previous_params) { { example_attribute: 1 } }
+      let(:new_params) { { new_attribute: 1 } }
+      let(:params) { previous_params }
+
+      it 'should be able to overwrite attributes' do
+        expect { options.set_params(new_params) }.to \
+          change { options.params }.from(previous_params).to(new_params)
+      end
+
+      it 'should be able to make params empty' do # (1)
+        expect { options.set_params({}) }.to change { options.params }.from(previous_params).to({})
+      end
+    end
+end

data/lib/submodules/ably-ruby/spec/run_parallel_tests

@@ -11,13 +11,8 @@ DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
 bundle exec rspec "${DIR}/unit"
 unit_status=$?
 
-if ruby -v | grep -e "1.9"; then
-  # Output with test ID is not supported with this old version of RSpec
-  # So it will be jumbled sadly for 1.9.*
-  bundle exec parallel_rspec "${DIR}/acceptance"
-else
-  bundle exec parallel_rspec "${DIR}/acceptance" --prefix-output-with-test-env-number
-fi
+bundle exec parallel_rspec "${DIR}/acceptance" --prefix-output-with-test-env-number
+
 acceptance_status=$?
 
 if [ $unit_status -ne 0 ]; then

data/lib/submodules/ably-ruby/spec/shared/client_initializer_behaviour.rb

@@ -69,14 +69,6 @@ shared_examples 'a client initializer' do
         expect { subject }.to raise_error(ArgumentError, /key and key_name or key_secret are mutually exclusive/)
       end
     end
-
-    context 'client_id as only option' do
-      let(:client_options) { { client_id: 'valid' } }
-
-      it 'requires a valid key' do
-        expect { subject }.to raise_error(ArgumentError, /client_id cannot be provided without a complete API key or means to authenticate/)
-      end
-    end
   end
 
   context 'with valid arguments' do
@@ -273,6 +265,137 @@ shared_examples 'a client initializer' do
         end
       end
     end
+
+    context 'environment' do
+      context 'when set without custom fallback hosts configured' do
+        let(:environment) { 'foo' }
+        let(:client_options) { default_options.merge(environment: environment) }
+        let(:default_fallbacks) { %w(a b c d e).map { |id| "#{environment}-#{id}-fallback.ably-realtime.com" } }
+
+        it 'sets the environment attribute' do
+          expect(subject.environment).to eql(environment)
+        end
+
+        it 'uses the default fallback hosts (#TBC, see https://github.com/ably/wiki/issues/361)' do
+          expect(subject.fallback_hosts.sort).to eql(default_fallbacks)
+        end
+      end
+
+      context 'when set with custom fallback hosts configured' do
+        let(:environment) { 'foo' }
+        let(:custom_fallbacks) { %w(a b c).map { |id| "#{environment}-#{id}.foo.com" } }
+        let(:client_options) { default_options.merge(environment: environment, fallback_hosts: custom_fallbacks) }
+
+        it 'sets the environment attribute' do
+          expect(subject.environment).to eql(environment)
+        end
+
+        it 'uses the custom provided fallback hosts (#RSC15a)' do
+          expect(subject.fallback_hosts.sort).to eql(custom_fallbacks)
+        end
+      end
+
+      context 'when set with fallback_hosts_use_default' do
+        let(:environment) { 'foo' }
+        let(:custom_fallbacks) { %w(a b c).map { |id| "#{environment}-#{id}.foo.com" } }
+        let(:default_production_fallbacks) { %w(a b c d e).map { |id| "#{id}.ably-realtime.com" } }
+        let(:client_options) { default_options.merge(environment: environment, fallback_hosts_use_default: true) }
+
+        it 'sets the environment attribute' do
+          expect(subject.environment).to eql(environment)
+        end
+
+        it 'uses the production default fallback hosts (#RTN17b)' do
+          expect(subject.fallback_hosts.sort).to eql(default_production_fallbacks)
+        end
+      end
+    end
+
+    context 'rest_host' do
+      context 'when set without custom fallback hosts configured' do
+        let(:custom_rest_host) { 'foo.com' }
+        let(:client_options) { default_options.merge(rest_host: custom_rest_host) }
+
+        it 'sets the custom_host attribute' do
+          expect(subject.custom_host).to eql(custom_rest_host)
+        end
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+
+      context 'when set with environment and without custom fallback hosts configured' do
+        let(:environment) { 'foobar' }
+        let(:custom_rest_host) { 'foo.com' }
+        let(:client_options) { default_options.merge(environment: environment, rest_host: custom_rest_host) }
+
+        it 'sets the environment attribute' do
+          expect(subject.environment).to eql(environment)
+        end
+
+        it 'sets the custom_host attribute' do
+          expect(subject.custom_host).to eql(custom_rest_host)
+        end
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+
+      context 'when set with custom fallback hosts configured' do
+        let(:custom_rest_host) { 'foo.com' }
+        let(:custom_fallbacks) { %w(a b c).map { |id| "#{environment}-#{id}.foo.com" } }
+        let(:client_options) { default_options.merge(rest_host: custom_rest_host, fallback_hosts: custom_fallbacks) }
+
+        it 'sets the custom_host attribute' do
+          expect(subject.custom_host).to eql(custom_rest_host)
+        end
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts.sort).to eql(custom_fallbacks)
+        end
+      end
+    end
+
+    context 'realtime_host' do
+      context 'when set without custom fallback hosts configured' do
+        let(:custom_realtime_host) { 'realtime.foo.com' }
+        let(:client_options) { default_options.merge(realtime_host: custom_realtime_host) }
+
+        # These tests are shared between realtime & rest clients
+        # So don't test for the attribute, instead test the options
+        it 'sets the realtime_host option' do
+          expect(subject.options[:realtime_host]).to eql(custom_realtime_host)
+        end
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+    end
+
+    context 'custom port' do
+      context 'when set without custom fallback hosts configured' do
+        let(:custom_port) { 555 }
+        let(:client_options) { default_options.merge(port: custom_port) }
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+    end
+
+    context 'custom TLS port' do
+      context 'when set without custom fallback hosts configured' do
+        let(:custom_port) { 555 }
+        let(:client_options) { default_options.merge(tls_port: custom_port) }
+
+        it 'has no default fallback hosts' do
+          expect(subject.fallback_hosts).to be_empty
+        end
+      end
+    end
   end
 
   context 'delegators' do

data/lib/submodules/ably-ruby/spec/shared/model_behaviour.rb

@@ -19,7 +19,7 @@ shared_examples 'a model' do |shared_options = {}|
     end
 
     context '#attributes', :api_private do
-      let(:model_options) { { action: 5 } }
+      let(:model_options) { { action: 5, max_message_size: 65536, max_frame_size: 524288 } }
 
       it 'provides access to #attributes' do
         expect(model.attributes).to eq(model_options)

data/lib/submodules/ably-ruby/spec/spec_helper.rb

@@ -5,8 +5,17 @@ def console(message)
 end
 
 unless RUBY_VERSION.match(/^1\./)
-  require 'coveralls'
-  Coveralls.wear!
+  require 'simplecov'
+
+  SimpleCov.start do
+    require 'simplecov-lcov'
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      c.single_report_path = 'coverage/lcov.info'
+    end
+    formatter SimpleCov::Formatter::LcovFormatter
+    add_filter %w[vendor spec]
+  end
 end
 
 require 'webmock/rspec'
@@ -19,6 +28,7 @@ require 'support/event_emitter_helper'
 require 'support/private_api_formatter'
 require 'support/protocol_helper'
 require 'support/random_helper'
+require 'support/serialization_helper'
 require 'support/test_logger_helper'
 
 require 'rspec_config'

data/lib/submodules/ably-ruby/spec/support/serialization_helper.rb

@@ -0,0 +1,21 @@
+module SerializationHelper
+  def serialize_body(object, protocol)
+    if protocol == :msgpack
+      MessagePack.pack(object)
+    else
+      JSON.dump(object)
+    end
+  end
+
+  def deserialize_body(object, protocol)
+    if protocol == :msgpack
+      MessagePack.unpack(object)
+    else
+      JSON.parse(object)
+    end
+  end
+
+  RSpec.configure do |config|
+    config.include self
+  end
+end

data/lib/submodules/ably-ruby/spec/support/test_app.rb

@@ -4,11 +4,11 @@ class TestApp
   TEST_RESOURCES_PATH = File.expand_path('../../../lib/submodules/ably-common/test-resources', __FILE__)
 
   # App configuration for test app
-  # See https://github.com/ably/ably-common/blob/master/test-resources/test-app-setup.json
+  # See https://github.com/ably/ably-common/blob/main/test-resources/test-app-setup.json
   APP_SPEC = JSON.parse(File.read(File.join(TEST_RESOURCES_PATH, 'test-app-setup.json')))['post_apps']
 
   # Cipher details used for client_encoded presence data in test app
-  # See https://github.com/ably/ably-common/blob/master/test-resources/test-app-setup.json
+  # See https://github.com/ably/ably-common/blob/main/test-resources/test-app-setup.json
   APP_SPEC_CIPHER = JSON.parse(File.read(File.join(TEST_RESOURCES_PATH, 'test-app-setup.json')))['cipher']
 
   # If an app has already been created and we need a new app, create a new test app
@@ -59,7 +59,7 @@ class TestApp
 
     url = "#{sandbox_client.endpoint}/apps/#{app_id}"
 
-    basic_auth = Base64.encode64(api_key).chomp
+    basic_auth = Base64.urlsafe_encode64(api_key).chomp
     headers    = { "Authorization" => "Basic #{basic_auth}" }
 
     Faraday.delete(url, nil, headers)

data/lib/submodules/ably-ruby/spec/unit/logger_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Ably::Logger do
+describe Ably::Logger, :prevent_log_stubbing do
   let(:rest_client) do
     instance_double('Ably::Rest::Client')
   end
@@ -18,14 +18,10 @@ describe Ably::Logger do
 
   context 'internals', :api_private do
     it 'delegates to the default Logger object' do
-      received = false
       expect(subject.logger).to be_a(::Logger)
-      allow_any_instance_of(::Logger).to receive(:warn) do |*args, &block|
-        expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
-        received = true
-      end
+      expect(subject.logger).to receive(:warn).with('message')
+
       subject.warn 'message'
-      expect(received).to be_truthy
     end
 
     context 'formatter' do
@@ -136,18 +132,14 @@ describe Ably::Logger do
       end
 
       it 'delegates log messages to logger', :api_private do
-        received = false
-        allow(custom_logger_object).to receive(:fatal) do |*args, &block|
-          expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
-          received = true
-        end
+        expect(custom_logger_object).to receive(:fatal).with('message')
+
         subject.fatal 'message'
-        expect(received).to be_truthy
       end
     end
   end
 
-  context 'with blocks', :prevent_log_stubbing do
+  context 'with blocks' do
     it 'does not call the block unless the log level is met' do
       log_level_blocks = []
       subject.warn { log_level_blocks << :warn }

data/lib/submodules/ably-ruby/spec/unit/models/channel_details_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ChannelDetails do
+  subject { Ably::Models::ChannelDetails(channel_id: 'channel-id-123-xyz', name: 'name', status: { isActive: 'true', occupancy: { metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } } }) }
+
+  describe '#channel_id' do
+    it 'should return channel id' do
+      expect(subject.channel_id).to eq('channel-id-123-xyz')
+    end
+  end
+
+  describe '#name' do
+    it 'should return name' do
+      expect(subject.name).to eq('name')
+    end
+  end
+
+  describe '#status' do
+    it 'should return status' do
+      expect(subject.status).to be_a(Ably::Models::ChannelStatus)
+      expect(subject.status.occupancy.metrics.connections).to eq(1)
+      expect(subject.status.occupancy.metrics.presence_connections).to eq(2)
+      expect(subject.status.occupancy.metrics.presence_members).to eq(2)
+      expect(subject.status.occupancy.metrics.presence_subscribers).to eq(5)
+      expect(subject.status.occupancy.metrics.publishers).to eq(7)
+      expect(subject.status.occupancy.metrics.subscribers).to eq(9)
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/models/channel_metrics_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ChannelMetrics do
+  subject { Ably::Models::ChannelMetrics(connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9) }
+
+  describe '#connections' do
+    it 'should return integer' do
+      expect(subject.connections).to eq(1)
+    end
+  end
+
+  describe '#presence_connections' do
+    it 'should return integer' do
+      expect(subject.presence_connections).to eq(2)
+    end
+  end
+
+  describe '#presence_members' do
+    it 'should return integer' do
+      expect(subject.presence_members).to eq(2)
+    end
+  end
+
+  describe '#presence_subscribers' do
+    it 'should return integer' do
+      expect(subject.presence_subscribers).to eq(5)
+    end
+  end
+
+  describe '#publishers' do
+    it 'should return integer' do
+      expect(subject.publishers).to eq(7)
+    end
+  end
+
+  describe '#subscribers' do
+    it 'should return integer' do
+      expect(subject.subscribers).to eq(9)
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/models/channel_occupancy_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ChannelOccupancy do
+  subject { Ably::Models::ChannelOccupancy({ metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } }) }
+
+  describe '#metrics' do
+    it 'should return attributes' do
+      expect(subject.metrics.connections).to eq(1)
+      expect(subject.metrics.presence_connections).to eq(2)
+      expect(subject.metrics.presence_members).to eq(2)
+      expect(subject.metrics.presence_subscribers).to eq(5)
+      expect(subject.metrics.publishers).to eq(7)
+      expect(subject.metrics.subscribers).to eq(9)
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/models/channel_status_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ChannelStatus do
+  subject { Ably::Models::ChannelStatus({ isActive: 'true', occupancy: { metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } } }) }
+
+  describe '#is_active' do
+    context 'when occupancy is active' do
+      subject { Ably::Models::ChannelStatus({ isActive: true, occupancy: { metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } } }) }
+
+      it 'should return true' do
+        expect(subject.is_active).to eq(true)
+      end
+    end
+
+    context 'when occupancy is not active' do
+      subject { Ably::Models::ChannelStatus({ isActive: false, occupancy: { metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } } }) }
+
+      it 'should return false' do
+        expect(subject.is_active).to eq(false)
+      end
+    end
+  end
+
+  describe '#occupancy' do
+    it 'should return occupancy object' do
+      expect(subject.occupancy).to be_a(Ably::Models::ChannelOccupancy)
+      expect(subject.occupancy.metrics.connections).to eq(1)
+      expect(subject.occupancy.metrics.presence_connections).to eq(2)
+      expect(subject.occupancy.metrics.presence_members).to eq(2)
+      expect(subject.occupancy.metrics.presence_subscribers).to eq(5)
+      expect(subject.occupancy.metrics.publishers).to eq(7)
+      expect(subject.occupancy.metrics.subscribers).to eq(9)
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/models/delta_extras_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Models::DeltaExtras do
+  subject { described_class.new({ format: 'vcdiff', from: '1234-4567-8910-1001-1111'}) }
+
+  it 'should have `from` attribute' do
+    expect(subject.from).to eq('1234-4567-8910-1001-1111')
+  end
+
+  it 'should have `format` attribute' do
+    expect(subject.format).to eq('vcdiff')
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/models/error_info_spec.rb

@@ -5,7 +5,7 @@ describe Ably::Models::ErrorInfo do
   subject { Ably::Models::ErrorInfo }
 
   context '#TI1, #TI4' do
-    it_behaves_like 'a model', with_simple_attributes: %w(code status_code href message) do
+    it_behaves_like 'a model', with_simple_attributes: %w(code status_code href message request_id cause) do
       let(:model_args) { [] }
     end
   end
@@ -18,6 +18,22 @@ describe Ably::Models::ErrorInfo do
     end
   end
 
+  context '#request_id #RSC7c' do
+    subject { Ably::Models::ErrorInfo.new('request_id' => '123-456-789-001') }
+
+    it 'should return request ID' do
+      expect(subject.request_id).to eql('123-456-789-001')
+    end
+  end
+
+  context '#cause #TI1' do
+    subject { Ably::Models::ErrorInfo.new('cause' => Ably::Models::ErrorInfo.new({})) }
+
+    it 'should return cause attribute' do
+      expect(subject.cause).to be_kind_of(Ably::Models::ErrorInfo)
+    end
+  end
+
   context 'log entries container help link #TI5' do
     context 'without an error code' do
       subject { Ably::Models::ErrorInfo.new('statusCode' => 401) }

data/lib/submodules/ably-ruby/spec/unit/models/message_spec.rb

@@ -211,6 +211,79 @@ describe Ably::Models::Message do
     end
   end
 
+  describe '#size' do
+    let(:model) { subject.new({ name: name, data: data, client_id: client_id, extras: extras }, protocol_message: protocol_message) }
+
+    context 'String (#TO3l8a)' do
+      let(:data) { 'example string data' }
+      let(:client_id) { '1' }
+      let(:name) { 'My Name' }
+      let(:extras) { 'extras' }
+
+      it 'should return 33 bytes' do
+        expect(model.size).to eq(33)
+      end
+    end
+
+    context 'Object (#TO3l8b)' do
+      let(:data) { Object.new }
+      let(:client_id) { String('10') }
+      let(:name) { 'John' }
+      let(:extras) { Hash.new }
+
+      it 'should return 38 bytes' do
+        expect(model.size).to eq(38)
+      end
+    end
+
+    context 'Array (#TO3l8b)' do
+      let(:data) { [1, 'two', :three] }
+      let(:client_id) { '2' }
+      let(:name) { 'Kate' }
+      let(:extras) { [] }
+
+      it 'should return 24 bytes' do
+        expect(model.size).to eq(24)
+      end
+    end
+
+    context 'extras (#TO3l8d)' do
+      let(:data) { { example: 'value', score: 1, hash: { test: true } } }
+      let(:client_id) { '3' }
+      let(:name) { 'John' }
+      let(:extras) { {} }
+
+      it 'should return 57 bytes' do
+        expect(model.size).to eq(57)
+      end
+    end
+
+    context 'nil (#TO3l8e)' do
+      let(:data) { nil }
+      let(:client_id) { '' }
+      let(:name) { '' }
+      let(:extras) { nil}
+
+      it 'should return 19 bytes' do
+        expect(model.size).to eq(0)
+      end
+    end
+  end
+
+  describe '#protocol_message_index (#RTL21)' do
+    let(:messages) { [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }] }
+
+    let(:protocol_message) do
+      Ably::Models::ProtocolMessage.new({ action: 1 }.merge(messages: messages))
+    end
+
+    it 'should return correct protocol_message_index' do
+      expect(protocol_message.messages[0].protocol_message_index).to eq(0)
+      expect(protocol_message.messages[1].protocol_message_index).to eq(1)
+      expect(protocol_message.messages[2].protocol_message_index).to eq(2)
+    end
+  end
+
   context 'from REST request with embedded fields', :api_private do
     let(:id)                  { random_str }
     let(:protocol_message_id) { random_str }
@@ -547,4 +620,28 @@ describe Ably::Models::Message do
       end
     end
   end
+
+  context '#delta_extras (TM2i)' do
+    let(:delta_extras) { message.delta_extras }
+
+    context 'when delta' do
+      let(:message) { subject.new({ extras: { delta: { from: '1234-1234-5678-9009', format: 'vcdiff' } } }) }
+
+      it 'should return vcdiff format' do
+        expect(delta_extras.format).to eq('vcdiff')
+      end
+
+      it 'should return 1234-1234-5678-9009 message id' do
+        expect(delta_extras.from).to eq('1234-1234-5678-9009')
+      end
+    end
+
+    context 'when no delta' do
+      let(:message) { subject.new({ extras: {} }) }
+
+      it 'should return nil' do
+        expect(delta_extras).to eq(nil)
+      end
+    end
+  end
 end