ably-rest 0.7.1 → 0.7.3

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

@@ -0,0 +1,32 @@
+module RSpec
+  module ProtocolHelper
+    PROTOCOLS = if ENV['TEST_LIMIT_PROTOCOLS']
+      JSON.parse(ENV['TEST_LIMIT_PROTOCOLS'])
+    else
+      {
+        json:    'JSON',
+        msgpack: 'MsgPack'
+      }
+    end
+
+    def vary_by_protocol(&block)
+      RSpec::ProtocolHelper::PROTOCOLS.each do |protocol, description|
+        context("using #{description} protocol", protocol: protocol, &block)
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.extend RSpec::ProtocolHelper
+
+  config.before(:context, protocol: :json) do |context|
+    context.class.let(:protocol) { :json }
+  end
+
+  config.before(:context, protocol: :msgpack) do |context|
+    context.class.let(:protocol) { :msgpack }
+  end
+end
+
+

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

@@ -0,0 +1,15 @@
+require 'securerandom'
+
+module RandomHelper
+  def random_str(length = 16)
+    SecureRandom.hex(length).encode(Encoding::UTF_8)
+  end
+
+  def random_int_str(size = 1_000_000_000)
+    SecureRandom.random_number(size).to_s.encode(Encoding::UTF_8)
+  end
+
+  RSpec.configure do |config|
+    config.include self
+  end
+end

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

@@ -0,0 +1,15 @@
+# If a test fails and RSPEC_RETRY is set to true, create a new
+# application before retrying the RSpec test again
+#
+RSpec.configure do |config|
+  config.around(:example) do |example|
+    example.run
+
+    next if example.metadata[:webmock] # new app is not needed for a mocked test
+
+    if example.exception && ENV['RSPEC_RETRY']
+      reload_test_app
+      puts "** Test app reloaded before next retry **"
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+require 'singleton'
+
+class TestApp
+  APP_SPEC = {
+    'keys' => [
+      {},
+      {
+        'capability' => '{ "cansubscribe:*":["subscribe"], "canpublish:*":["publish"], "canpublish:andpresence":["presence","publish"] }'
+      }
+    ],
+    'namespaces' => [
+      { 'id' => 'persisted', 'persisted' => true }
+    ],
+    'channels' => [
+      {
+        'name' => 'persisted:presence_fixtures',
+        'presence' => [
+          { 'clientId' => 'client_bool',    'clientData' => 'true' },
+          { 'clientId' => 'client_int',     'clientData' => '24' },
+          { 'clientId' => 'client_string',  'clientData' => 'This is a string clientData payload' },
+          { 'clientId' => 'client_json',    'clientData' => '{ "test" => \'This is a JSONObject clientData payload\'}' }
+        ]
+      }
+    ]
+  }
+
+  # If an app has already been created and we need a new app, create a new test app
+  # This is sometimes needed when a test needs to be isolated from any other tests
+  def self.reload
+    if instance_variable_get('@singleton__instance__')
+      instance.delete
+      instance.create_test_app
+    end
+  end
+
+  include Singleton
+
+  def initialize
+    create_test_app
+  end
+
+  def app_id
+    @attributes["appId"]
+  end
+
+  def key
+    @attributes["keys"].first
+  end
+
+  def restricted_key
+    @attributes["keys"][1]
+  end
+
+  def key_id
+    "#{app_id}.#{key['id']}"
+  end
+
+  def key_value
+    key['value']
+  end
+
+  def api_key
+    "#{key_id}:#{key_value}"
+  end
+
+  def restricted_api_key
+    "#{app_id}.#{restricted_key['id']}:#{restricted_key['value']}"
+  end
+
+  def delete
+    return unless TestApp.instance_variable_get('@singleton__instance__')
+
+    url = "#{sandbox_client.endpoint}/apps/#{app_id}"
+
+    basic_auth = Base64.encode64(api_key).chomp
+    headers    = { "Authorization" => "Basic #{basic_auth}" }
+
+    Faraday.delete(url, nil, headers)
+  end
+
+  def environment
+    'sandbox'
+  end
+
+  def create_test_app
+    url = "#{sandbox_client.endpoint}/apps"
+
+    headers = {
+      'Accept'       => 'application/json',
+      'Content-Type' => 'application/json'
+    }
+
+    @attributes = JSON.parse(Faraday.post(url, APP_SPEC.to_json, headers).body)
+  end
+
+  def host
+    sandbox_client.endpoint.host
+  end
+
+  def realtime_host
+    host.gsub(/rest/, 'realtime')
+  end
+
+  def create_test_stats(stats)
+    client = Ably::Rest::Client.new(api_key: api_key, environment: environment)
+    client.post('/stats', stats)
+  end
+
+  private
+  def sandbox_client
+    @sandbox_client ||= Ably::Rest::Client.new(api_key: 'app.key:secret', tls: true, environment: environment)
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'shared/protocol_msgbus_behaviour'
+
+describe Ably::Auth do
+  let(:client)    { double('client').as_null_object }
+  let(:client_id) { nil }
+  let(:options)   { { api_key: 'appid.keyuid:keysecret', client_id: client_id } }
+
+  subject do
+    Ably::Auth.new(client, options)
+  end
+
+  describe 'client_id option' do
+    let(:client_id) { random_str.encode(encoding) }
+
+    context 'with nil value' do
+      let(:client_id) { nil }
+
+      it 'is permitted' do
+        expect(subject.client_id).to be_nil
+      end
+    end
+
+    context 'as UTF_8 string' do
+      let(:encoding) { Encoding::UTF_8 }
+
+      it 'is permitted' do
+        expect(subject.client_id).to eql(client_id)
+      end
+
+      it 'remains as UTF-8' do
+        expect(subject.client_id.encoding).to eql(encoding)
+      end
+    end
+
+    context 'as SHIFT_JIS string' do
+      let(:encoding) { Encoding::SHIFT_JIS }
+
+      it 'gets converted to UTF-8' do
+        expect(subject.client_id.encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'is compatible with original encoding' do
+        expect(subject.client_id.encode(encoding)).to eql(client_id)
+      end
+    end
+
+    context 'as ASCII_8BIT string' do
+      let(:encoding) { Encoding::ASCII_8BIT }
+
+      it 'gets converted to UTF-8' do
+        expect(subject.client_id.encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'is compatible with original encoding' do
+        expect(subject.client_id.encode(encoding)).to eql(client_id)
+      end
+    end
+
+    context 'as Integer' do
+      let(:client_id) { 1 }
+
+      it 'raises an argument error' do
+        expect { subject.client_id }.to raise_error ArgumentError, /must be a String/
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Ably::Logger do
+  let(:rest_client) do
+    instance_double('Ably::Rest::Client')
+  end
+
+  subject { Ably::Logger.new(rest_client, Logger::INFO) }
+
+  def uncolorize(string)
+    regex_pattern = /\033\[[0-9]+m(.+?)\033\[0m/m
+    string.gsub(regex_pattern, '\1')
+  end
+
+  it 'uses the language provided Logger by default' do
+    expect(subject.logger).to be_a(Logger)
+  end
+
+  context 'internals', :api_private do
+    it 'delegates to the logger object' do
+      expect(subject.logger).to receive(:warn).with('message')
+      subject.warn 'message'
+    end
+
+    context 'formatter' do
+      context 'when debugging' do
+        it 'uses short time format' do
+          formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to match(/^\d+:\d+:\d+.\d{3} DEBUG/)
+        end
+      end
+
+      context 'when info -> fatal' do
+        it 'uses long time format' do
+          formatted = subject.logger.formatter.call(Logger::INFO, Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+        end
+      end
+
+      if defined?(Ably::Realtime)
+        context 'with Realtime client' do
+          let(:new_realtime_client) do
+            instance_double('Ably::Realtime::Client', connection: instance_double('Ably::Realtime::Connection', id: nil))
+          end
+          let(:connected_realtime_client) do
+            instance_double('Ably::Realtime::Client', connection: instance_double('Ably::Realtime::Connection', id: '0000'))
+          end
+          before do
+            allow(new_realtime_client).to receive(:kind_of?).with(Ably::Realtime::Client).and_return(true)
+            allow(connected_realtime_client).to receive(:kind_of?).with(Ably::Realtime::Client).and_return(true)
+          end
+
+          context 'with Realtime disconnected client' do
+            subject { Ably::Logger.new(new_realtime_client, Logger::INFO) }
+
+            it 'formats logs with an empty client ID' do
+              formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+              formatted = uncolorize(formatted)
+              expect(formatted).to match(/\[ \-\- \]/)
+              expect(formatted).to match(%r{unique_message$})
+              expect(formatted).to match(%r{DEBUG})
+            end
+          end
+
+          context 'with Realtime connected client' do
+            subject { Ably::Logger.new(connected_realtime_client, Logger::INFO) }
+
+            it 'formats logs with a client ID' do
+              formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+              formatted = uncolorize(formatted)
+              expect(formatted).to match(/\[0000\]/)
+              expect(formatted).to match(%r{unique_message$})
+              expect(formatted).to match(%r{DEBUG})
+            end
+          end
+        end
+      end
+
+      context 'with REST client' do
+        subject { Ably::Logger.new(rest_client, Logger::INFO) }
+
+        it 'formats logs without a client ID' do
+          formatted = subject.logger.formatter.call(Logger::FATAL, Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to_not match(/\[.*\]/)
+          expect(formatted).to match(%r{unique_message$})
+          expect(formatted).to match(%r{FATAL})
+        end
+      end
+
+      context 'severity argument' do
+        it 'can be an Integer' do
+          formatted = subject.logger.formatter.call(Logger::INFO, Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+        end
+
+        it 'can be a string' do
+          formatted = subject.logger.formatter.call('INFO', Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+        end
+      end
+    end
+  end
+
+  context 'with a custom Logger' do
+    context 'with an invalid interface' do
+      let(:custom_logger_with_bad_interface) do
+        Class.new.new
+      end
+      subject { Ably::Logger.new(rest_client, Logger::INFO, custom_logger_with_bad_interface) }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error ArgumentError, /The custom Logger's interface does not provide the method/
+      end
+    end
+
+    context 'with a valid interface' do
+      let(:custom_logger) do
+        Class.new do
+          extend Forwardable
+          def initialize
+            @logger = Logger.new(STDOUT)
+          end
+          def_delegators :@logger, :fatal, :error, :warn, :info, :debug, :level, :level=
+        end
+      end
+      let(:custom_logger_object) { custom_logger.new }
+
+      subject { Ably::Logger.new(rest_client, Logger::INFO, custom_logger_object) }
+
+      it 'is used' do
+        expect { subject }.to_not raise_error
+        expect(subject.logger.class).to eql(custom_logger)
+      end
+
+      it 'delegates log messages to logger', :api_private do
+        expect(custom_logger_object).to receive(:fatal).with('message')
+        subject.fatal 'message'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ErrorInfo do
+  subject { Ably::Models::ErrorInfo }
+
+  it_behaves_like 'a model', with_simple_attributes: %w(code status_code message) do
+    let(:model_args) { [] }
+  end
+
+  context '#status' do
+    subject { Ably::Models::ErrorInfo.new('statusCode' => 401) }
+    it 'is an alias for #status_code' do
+      expect(subject.status).to eql(subject.status_code)
+      expect(subject.status).to eql(401)
+    end
+  end
+end

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

@@ -0,0 +1,349 @@
+require 'spec_helper'
+
+describe Ably::Models::IdiomaticRubyWrapper, :api_private do
+  include Ably::Modules::Conversions
+
+  let(:mixed_case_data) do
+    {
+      'mixedCase' => 'true',
+      'simple' => 'without case',
+      'hashObject' => {
+        'mixedCaseChild' => 'exists'
+      },
+      'arrayObject' => [
+        {
+          'mixedCaseChild' => 'exists'
+        }
+      ]
+    }
+  end
+  subject { Ably::Models::IdiomaticRubyWrapper.new(mixed_case_data) }
+
+  context 'Kernel.Array like method to create a IdiomaticRubyWrapper' do
+    it 'will return the same IdiomaticRubyWrapper if passed in' do
+      expect(IdiomaticRubyWrapper(subject)).to eql(subject)
+    end
+
+    it 'will return the same IdiomaticRubyWrapper if passed in' do
+      expect(IdiomaticRubyWrapper(mixed_case_data)).to be_a(Ably::Models::IdiomaticRubyWrapper)
+    end
+  end
+
+  it 'provides accessor method to values using snake_case' do
+    expect(subject[:mixed_case]).to eql('true')
+    expect(subject[:simple]).to eql('without case')
+  end
+
+  it 'provides methods to read values using snake_case' do
+    expect(subject.mixed_case).to eql('true')
+    expect(subject.simple).to eql('without case')
+  end
+
+  it 'provides accessor set method to values using snake_case' do
+    subject[:mixed_case] = 'mixedCase'
+    subject[:simple] = 'simple'
+    expect(subject[:mixed_case]).to eql('mixedCase')
+    expect(subject[:simple]).to eql('simple')
+  end
+
+  it 'provides methods to write values using snake_case' do
+    subject.mixed_case = 'mixedCase'
+    subject.simple = 'simple'
+    expect(subject.mixed_case).to eql('mixedCase')
+    expect(subject.simple).to eql('simple')
+  end
+
+  it 'does not provide methods for keys that are missing' do
+    expect { subject.no_key_exists_for_this }.to raise_error NoMethodError
+  end
+
+  specify '#hash returns raw Hash object' do
+    expect(subject.hash).to eql(mixed_case_data)
+  end
+
+  context 'recursively wrapping child objects' do
+    it 'wraps Hashes' do
+      expect(subject.hash_object.mixed_case_child).to eql('exists')
+    end
+
+    it 'ignores arrays' do
+      expect(subject.array_object.first).to include('mixedCaseChild' => 'exists')
+    end
+
+    context ':stop_at option' do
+      subject { Ably::Models::IdiomaticRubyWrapper.new(mixed_case_data, stop_at: stop_at) }
+
+      context 'with symbol' do
+        let(:stop_at) { :hash_object }
+
+        it 'does not wrap the matching key' do
+          expect(subject.hash_object).to include('mixedCaseChild' => 'exists')
+        end
+      end
+
+      context 'with string' do
+        let(:stop_at) { ['hashObject'] }
+
+        it 'does not wrap the matching key' do
+          expect(subject.hash_object).to include('mixedCaseChild' => 'exists')
+        end
+      end
+    end
+  end
+
+  context 'non standard mixedCaseData' do
+    let(:data) do
+      {
+        :symbol             => 'aSymbolValue',
+        :snake_case_symbol  => 'snake_case_symbolValue',
+        :mixedCaseSymbol    => 'mixedCaseSymbolValue',
+        'snake_case_string' => 'snake_case_stringValue',
+        'mixedCaseString'   => 'mixedCaseStringFirstChoiceValue',
+        :mixedCaseString    => 'mixedCaseStringFallbackValue',
+        :CamelCaseSymbol    => 'CamelCaseSymbolValue',
+        'CamelCaseString'   => 'camel_case_stringValue',
+        :lowercasesymbol    => 'lowercasesymbolValue',
+        'lowercasestring'   => 'lowercasestringValue'
+      }
+    end
+    let(:unique_value) { random_str }
+
+    subject { Ably::Models::IdiomaticRubyWrapper.new(data) }
+
+    {
+      :symbol => 'aSymbolValue',
+      :snake_case_symbol    => 'snake_case_symbolValue',
+      :mixed_case_symbol    => 'mixedCaseSymbolValue',
+      :snake_case_string    => 'snake_case_stringValue',
+      :mixed_case_string    => 'mixedCaseStringFirstChoiceValue',
+      :camel_case_symbol    => 'CamelCaseSymbolValue',
+      :camel_case_string    => 'camel_case_stringValue',
+      :lower_case_symbol      => 'lowercasesymbolValue',
+      :lower_case_string      => 'lowercasestringValue'
+    }.each do |symbol_accessor, expected_value|
+      context symbol_accessor do
+        it 'allows access to non conformant keys but prefers correct mixedCaseSyntax' do
+          expect(subject[symbol_accessor]).to eql(expected_value)
+        end
+
+        context 'updates' do
+          before do
+            subject[symbol_accessor] = unique_value
+          end
+
+          it 'returns the new value' do
+            expect(subject[symbol_accessor]).to eql(unique_value)
+          end
+
+          it 'returns the new value in the JSON' do
+            expect(subject.to_json).to include(unique_value)
+            expect(subject.to_json).to_not include(expected_value)
+          end
+        end
+      end
+    end
+
+    it 'returns nil for non existent keys' do
+      expect(subject[:non_existent_key]).to eql(nil)
+    end
+
+    context 'new keys' do
+      before do
+        subject[:new_key] = 'new_value'
+      end
+
+      it 'uses mixedCase' do
+        expect(subject.hash['newKey']).to eql('new_value')
+        expect(subject.new_key).to eql('new_value')
+      end
+    end
+  end
+
+  context 'acts like a duck' do
+    let(:parsed_json) { JSON.parse(subject.to_json) }
+    specify '#to_json returns JSON stringified' do
+      expect(subject.to_json).to eql(mixed_case_data.to_json)
+    end
+
+    specify '#to_json returns child JSON objects in the JSON stringified' do
+      expect(parsed_json['arrayObject']).to eql(mixed_case_data['arrayObject'])
+    end
+
+    context 'with snake case JSON' do
+      let(:subject) { Ably::Models::IdiomaticRubyWrapper.new('wrong_case' => 'will_be_corrected')}
+      specify '#to_json uses mixedCase for any non mixedCase keys' do
+        expect(parsed_json['wrongCase']).to eql('will_be_corrected')
+      end
+    end
+
+    context '#to_json with changes' do
+      before do
+        @original_mixed_case_data = mixed_case_data.to_json
+        subject[:mixed_case] = 'new_value'
+      end
+
+      it 'returns stringified JSON with changes' do
+        expect(subject.to_json).to_not eql(@original_mixed_case_data)
+        expect(subject.to_json).to match('new_value')
+      end
+    end
+
+    it 'returns correct size' do
+      expect(subject.size).to eql(mixed_case_data.size)
+    end
+
+    it 'supports Hash-like #keys' do
+      expect(subject.keys.length).to eql(mixed_case_data.keys.length)
+    end
+
+    it 'supports Hash-like #values' do
+      expect(subject.values.length).to eql(mixed_case_data.values.length)
+    end
+
+    it 'is Enumerable' do
+      expect(subject).to be_kind_of(Enumerable)
+    end
+
+    context 'iterable' do
+      subject { Ably::Models::IdiomaticRubyWrapper.new(mixed_case_data, stop_at: [:hash_object, :array_object]) }
+
+      let(:expected_keys) { [:mixed_case, :simple, :hash_object, :array_object] }
+      let(:expected_vals) { mixed_case_data.map { |k,v| v } }
+
+      it 'yields key value pairs' do
+        expect(subject.map { |k,v| k }).to eql(expected_keys)
+        expect(subject.map { |k,v| v }).to eql(expected_vals)
+      end
+
+      context '#each' do
+        it 'returns an enumerator' do
+          expect(subject.each).to be_a(Enumerator)
+        end
+
+        it 'yields key value pairs' do
+          emitted = {}
+          subject.each do |key, val|
+            emitted[key] = val
+          end
+          expect(emitted.keys).to eql(expected_keys)
+          expect(emitted.values).to eql(expected_vals)
+        end
+      end
+    end
+
+    context '#fetch' do
+      it 'fetches the key' do
+        expect(subject.fetch(:mixed_case)).to eql('true')
+      end
+
+      it 'raise an exception if key does not exist' do
+        expect { subject.fetch(:non_existent) }.to raise_error KeyError, /key not found: non_existent/
+      end
+
+      it 'allows a default value argument' do
+        expect(subject.fetch(:non_existent, 'default')).to eql('default')
+      end
+
+      it 'calls the block if key does not exist' do
+        expect(subject.fetch(:non_existent) { 'block_default' } ).to eql('block_default')
+      end
+    end
+
+    context '#==' do
+      let(:mixed_case_data) do
+        {
+          'key' => 'value'
+        }
+      end
+      let(:presented_as_data) do
+        {
+          :key => 'value'
+        }
+      end
+      let(:invalid_match) do
+        {
+          :key => 'other value'
+        }
+      end
+      let(:other) { Ably::Models::IdiomaticRubyWrapper.new(mixed_case_data) }
+      let(:other_invalid) { Ably::Models::IdiomaticRubyWrapper.new(invalid_match) }
+
+      it 'presents itself as a symbolized version of the object' do
+        expect(subject).to eq(presented_as_data)
+      end
+
+      it 'returns false if different values to another Hash' do
+        expect(subject).to_not eq(invalid_match)
+      end
+
+      it 'compares with itself' do
+        expect(subject).to eq(other)
+      end
+
+      it 'returns false if different values to another IdiomaticRubyWrapper' do
+        expect(subject).to_not eq(other_invalid)
+      end
+
+      it 'returns false if comparing with a non Hash/IdiomaticRubyWrapper object' do
+        expect(subject).to_not eq(Object)
+      end
+    end
+
+    context '#to_hash' do
+      let(:mixed_case_data) do
+        {
+          'key' => 'value',
+          'childObject' => {
+            'child' => true
+          }
+        }
+      end
+
+      it 'returns a hash' do
+        expect(subject.to_hash).to include(key: 'value')
+      end
+
+      it 'converts hashes within hashes' do
+        expect(subject.to_hash[:child_object]).to include(child: true)
+      end
+    end
+
+    context '#to_msgpack' do
+      let(:mixed_case_data) do
+        {
+          'key' => 'value',
+          'child' => {
+            'with_attributes' => true
+          }
+        }
+      end
+      let(:msg_packed) { subject.to_msgpack }
+      let(:unpacked)   { MessagePack.unpack(msg_packed) }
+
+      it 'returns a msgpack object' do
+        expect(unpacked).to include('key' => 'value')
+        expect(unpacked).to include('child' => { 'withAttributes' => true })
+      end
+    end
+
+    context '#dup' do
+      let(:mixed_case_data) do
+        {
+          'key' => 'value'
+        }.freeze
+      end
+      let(:dupe) { subject.dup }
+
+      it 'returns a new object with the underlying JSON duped' do
+        expect(subject.hash).to be_frozen
+        expect(dupe.hash).to_not be_frozen
+      end
+
+      it 'returns a new IdiomaticRubyWrapper with the same underlying Hash object' do
+        expect(dupe).to be_a(Ably::Models::IdiomaticRubyWrapper)
+        expect(dupe.hash).to be_a(Hash)
+        expect(dupe.hash).to eql(mixed_case_data)
+      end
+    end
+  end
+end