1109 lines
35 KiB
Ruby
1109 lines
35 KiB
Ruby
require 'spec_helper'
|
|
|
|
describe Hashie::Mash do
|
|
subject { Hashie::Mash.new }
|
|
|
|
include_context 'with a logger'
|
|
|
|
it 'inherits from Hash' do
|
|
expect(subject.is_a?(Hash)).to be_truthy
|
|
end
|
|
|
|
it 'sets hash values through method= calls' do
|
|
subject.test = 'abc'
|
|
expect(subject['test']).to eq 'abc'
|
|
end
|
|
|
|
it 'retrieves set values through method calls' do
|
|
subject['test'] = 'abc'
|
|
expect(subject.test).to eq 'abc'
|
|
end
|
|
|
|
it 'retrieves set values through blocks' do
|
|
subject['test'] = 'abc'
|
|
value = nil
|
|
subject.[]('test') { |v| value = v }
|
|
expect(value).to eq 'abc'
|
|
end
|
|
|
|
it 'retrieves set values through blocks with method calls' do
|
|
subject['test'] = 'abc'
|
|
value = nil
|
|
subject.test { |v| value = v }
|
|
expect(value).to eq 'abc'
|
|
end
|
|
|
|
it 'tests for already set values when passed a ? method' do
|
|
expect(subject.test?).to be_falsy
|
|
subject.test = 'abc'
|
|
expect(subject.test?).to be_truthy
|
|
end
|
|
|
|
it 'returns false on a ? method if a value has been set to nil or false' do
|
|
subject.test = nil
|
|
expect(subject).not_to be_test
|
|
subject.test = false
|
|
expect(subject).not_to be_test
|
|
end
|
|
|
|
it 'makes all [] and []= into strings for consistency' do
|
|
subject['abc'] = 123
|
|
expect(subject.key?('abc')).to be_truthy
|
|
expect(subject['abc']).to eq 123
|
|
end
|
|
|
|
it 'has a to_s that is identical to its inspect' do
|
|
subject.abc = 123
|
|
expect(subject.to_s).to eq subject.inspect
|
|
end
|
|
|
|
it 'returns nil instead of raising an error for attribute-esque method calls' do
|
|
expect(subject.abc).to be_nil
|
|
end
|
|
|
|
it 'returns the default value if set like Hash' do
|
|
subject.default = 123
|
|
expect(subject.abc).to eq 123
|
|
end
|
|
|
|
it 'gracefully handles being accessed with arguments' do
|
|
expect(subject.abc('foobar')).to eq nil
|
|
subject.abc = 123
|
|
expect(subject.abc('foobar')).to eq 123
|
|
end
|
|
|
|
# Added due to downstream gems assuming indifferent access to be true for Mash
|
|
# When this is not, bump major version so that downstream gems can target
|
|
# correct version and fix accordingly.
|
|
# See https://github.com/hashie/hashie/pull/197
|
|
it 'maintains indifferent access when nested' do
|
|
subject[:a] = { b: 'c' }
|
|
expect(subject[:a][:b]).to eq 'c'
|
|
expect(subject[:a]['b']).to eq 'c'
|
|
end
|
|
|
|
it 'returns a Hashie::Mash when passed a bang method to a non-existenct key' do
|
|
expect(subject.abc!.is_a?(Hashie::Mash)).to be_truthy
|
|
end
|
|
|
|
it 'returns the existing value when passed a bang method for an existing key' do
|
|
subject.name = 'Bob'
|
|
expect(subject.name!).to eq 'Bob'
|
|
end
|
|
|
|
it 'returns a Hashie::Mash when passed an under bang method to a non-existenct key' do
|
|
expect(subject.abc_.is_a?(Hashie::Mash)).to be_truthy
|
|
end
|
|
|
|
it 'returns the existing value when passed an under bang method for an existing key' do
|
|
subject.name = 'Bob'
|
|
expect(subject.name_).to eq 'Bob'
|
|
end
|
|
|
|
it '#initializing_reader returns a Hashie::Mash when passed a non-existent key' do
|
|
expect(subject.initializing_reader(:abc).is_a?(Hashie::Mash)).to be_truthy
|
|
end
|
|
|
|
it 'allows for multi-level assignment through bang methods' do
|
|
subject.author!.name = 'Michael Bleigh'
|
|
expect(subject.author).to eq Hashie::Mash.new(name: 'Michael Bleigh')
|
|
subject.author!.website!.url = 'http://www.mbleigh.com/'
|
|
expect(subject.author.website).to eq Hashie::Mash.new(url: 'http://www.mbleigh.com/')
|
|
end
|
|
|
|
it 'allows for multi-level under bang testing' do
|
|
expect(subject.author_.website_.url).to be_nil
|
|
expect(subject.author_.website_.url?).to eq false
|
|
expect(subject.author).to be_nil
|
|
end
|
|
|
|
it 'does not call super if id is not a key' do
|
|
expect(subject.id).to eq nil
|
|
end
|
|
|
|
it 'returns the value if id is a key' do
|
|
subject.id = 'Steve'
|
|
expect(subject.id).to eq 'Steve'
|
|
end
|
|
|
|
it 'does not call super if type is not a key' do
|
|
expect(subject.type).to eq nil
|
|
end
|
|
|
|
it 'returns the value if type is a key' do
|
|
subject.type = 'Steve'
|
|
expect(subject.type).to eq 'Steve'
|
|
end
|
|
|
|
include_context 'with a logger' do
|
|
it 'logs a warning when overriding built-in methods' do
|
|
Hashie::Mash.new('trust' => { 'two' => 2 })
|
|
|
|
expect(logger_output).to match('Hashie::Mash#trust')
|
|
end
|
|
|
|
it 'can set keys more than once and does not warn when doing so' do
|
|
mash = Hashie::Mash.new
|
|
mash[:test_key] = 'Test value'
|
|
|
|
expect { mash[:test_key] = 'A new value' }.not_to raise_error
|
|
expect(logger_output).to be_empty
|
|
end
|
|
|
|
it 'does not write to the logger when warnings are disabled' do
|
|
mash_class = Class.new(Hashie::Mash) do
|
|
disable_warnings
|
|
end
|
|
mash_class.new('trust' => { 'two' => 2 })
|
|
|
|
expect(logger_output).to be_empty
|
|
end
|
|
|
|
it 'does not write to the logger when setting most affixed keys' do
|
|
underbang = Hashie::Mash.new('foo_' => 'foo')
|
|
bang = Hashie::Mash.new('foo!' => 'foo')
|
|
query = Hashie::Mash.new('foo?' => 'foo')
|
|
|
|
expect(logger_output).to be_empty
|
|
expect(underbang.foo_).to eq 'foo'
|
|
expect(bang.foo!).to eq 'foo'
|
|
expect(query.foo?).to eq 'foo'
|
|
end
|
|
|
|
it 'warns when setting a key that looks like a setter' do
|
|
setter = Hashie::Mash.new('foo=' => 'foo')
|
|
|
|
expect(logger_output).to match 'Hashie::Mash#foo='
|
|
expect('setter.foo=').not_to parse_as_valid_ruby
|
|
|
|
setter.foo = 'bar'
|
|
|
|
expect(setter.to_h).to eq 'foo=' => 'foo'
|
|
end
|
|
|
|
it 'cannot disable logging on the base Mash' do
|
|
expected_error = Hashie::Extensions::KeyConflictWarning::CannotDisableMashWarnings
|
|
|
|
expect { Hashie::Mash.disable_warnings }.to raise_error(expected_error)
|
|
end
|
|
|
|
it 'carries over the disable for warnings on grandchild classes' do
|
|
child_class = Class.new(Hashie::Mash) do
|
|
disable_warnings
|
|
end
|
|
grandchild_class = Class.new(child_class)
|
|
|
|
grandchild_class.new('trust' => { 'two' => 2 })
|
|
|
|
expect(logger_output).to be_empty
|
|
end
|
|
|
|
it 'writes to logger when a key is overridden that is not ignored' do
|
|
mash_class = Class.new(Hashie::Mash) do
|
|
disable_warnings :merge
|
|
end
|
|
|
|
mash_class.new('address' => { 'zip' => '90210' })
|
|
expect(logger_output).not_to be_empty
|
|
end
|
|
|
|
it 'does not write to logger when a key is overridden that is ignored' do
|
|
mash_class = Class.new(Hashie::Mash) do
|
|
disable_warnings :zip
|
|
end
|
|
|
|
mash_class.new('address' => { 'zip' => '90210' })
|
|
expect(logger_output).to be_empty
|
|
end
|
|
|
|
it 'carries over the ignored warnings list for warnings on grandchild classes' do
|
|
child_class = Class.new(Hashie::Mash) do
|
|
disable_warnings :zip, :merge
|
|
end
|
|
grandchild_class = Class.new(child_class)
|
|
|
|
grandchild_class.new('address' => { 'zip' => '90210' }, 'merge' => true)
|
|
|
|
expect(grandchild_class.disabled_warnings).to eq(%i[zip merge])
|
|
expect(logger_output).to be_empty
|
|
end
|
|
|
|
context 'multiple disable_warnings calls' do
|
|
context 'calling disable_warnings multiple times with parameters' do
|
|
it 'appends each new parameter to the ignore list' do
|
|
child_class = Class.new(Hashie::Mash) do
|
|
disable_warnings :zip
|
|
disable_warnings :merge
|
|
disable_warnings :cycle
|
|
end
|
|
|
|
expect(child_class.disabled_warnings).to eq(%i[zip merge cycle])
|
|
end
|
|
end
|
|
|
|
context 'calling disable_warnings without keys after calling with keys' do
|
|
it 'uses the last call to determine the ignore list' do
|
|
child_class = Class.new(Hashie::Mash) do
|
|
disable_warnings :zip
|
|
disable_warnings
|
|
end
|
|
|
|
child_class.new('address' => { 'zip' => '90210' }, 'merge' => true, 'cycle' => 'bi')
|
|
|
|
expect(child_class.disabled_warnings).to eq([])
|
|
expect(logger_output).to be_empty
|
|
end
|
|
end
|
|
|
|
context 'calling disable_parameters with keys after calling without keys' do
|
|
it 'only ignores logging for ignored methods' do
|
|
child_class = Class.new(Hashie::Mash) do
|
|
disable_warnings
|
|
disable_warnings :zip
|
|
end
|
|
|
|
child_class.new('address' => { 'zip' => '90210' }, 'merge' => true)
|
|
|
|
expect(logger_output).to match(/#{child_class}#merge/)
|
|
expect(logger_output).not_to match(/#{child_class}#zip/)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'updating' do
|
|
subject do
|
|
described_class.new(
|
|
first_name: 'Michael',
|
|
last_name: 'Bleigh',
|
|
details: {
|
|
email: 'michael@asf.com',
|
|
address: 'Nowhere road'
|
|
}
|
|
)
|
|
end
|
|
|
|
describe '#deep_update' do
|
|
it 'recursively Hashie::Mash Hashie::Mashes and hashes together' do
|
|
subject.deep_update(details: { email: 'michael@intridea.com', city: 'Imagineton' })
|
|
expect(subject.first_name).to eq 'Michael'
|
|
expect(subject.details.email).to eq 'michael@intridea.com'
|
|
expect(subject.details.address).to eq 'Nowhere road'
|
|
expect(subject.details.city).to eq 'Imagineton'
|
|
end
|
|
|
|
it 'converts values only once' do
|
|
class ConvertedMash < Hashie::Mash
|
|
end
|
|
|
|
rhs = ConvertedMash.new(email: 'foo@bar.com')
|
|
expect(subject).to receive(:convert_value).exactly(1).times
|
|
subject.deep_update(rhs)
|
|
end
|
|
|
|
it 'makes #update deep by default' do
|
|
expect(subject.update(details: { address: 'Fake street' })).to eql(subject)
|
|
expect(subject.details.address).to eq 'Fake street'
|
|
expect(subject.details.email).to eq 'michael@asf.com'
|
|
end
|
|
|
|
it 'clones before a #deep_merge' do
|
|
duped = subject.deep_merge(details: { address: 'Fake street' })
|
|
expect(duped).not_to eql(subject)
|
|
expect(duped.details.address).to eq 'Fake street'
|
|
expect(subject.details.address).to eq 'Nowhere road'
|
|
expect(duped.details.email).to eq 'michael@asf.com'
|
|
end
|
|
|
|
it 'default #merge is deep' do
|
|
duped = subject.merge(details: { email: 'michael@intridea.com' })
|
|
expect(duped).not_to eql(subject)
|
|
expect(duped.details.email).to eq 'michael@intridea.com'
|
|
expect(duped.details.address).to eq 'Nowhere road'
|
|
end
|
|
|
|
# http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-update
|
|
it 'accepts a block' do
|
|
duped = subject.merge(details: { address: 'Pasadena CA' }) do |_, oldv, newv|
|
|
[oldv, newv].join(', ')
|
|
end
|
|
|
|
expect(duped.details.address).to eq 'Nowhere road, Pasadena CA'
|
|
end
|
|
|
|
it 'copies values for non-duplicate keys when a block is supplied' do
|
|
m_hash = { details: { address: 'Pasadena CA', state: 'West Thoughtleby' } }
|
|
duped = subject.merge(m_hash) { |_, oldv, _| oldv }
|
|
|
|
expect(duped.details.address).to eq 'Nowhere road'
|
|
expect(duped.details.state).to eq 'West Thoughtleby'
|
|
end
|
|
|
|
it 'does not raise an exception when default_proc raises an error' do
|
|
hash = described_class.new(a: 1) { |_k, _v| raise('Should not be raise I') }
|
|
other_has = described_class.new(a: 2, b: 2) { |_k, _v| raise('Should not be raise II') }
|
|
expected_hash = described_class.new(a: 2, b: 2)
|
|
|
|
res = hash.merge(other_has)
|
|
expect(res).to eq(expected_hash)
|
|
end
|
|
end
|
|
|
|
describe 'shallow update' do
|
|
it 'shallowly Hashie::Mash Hashie::Mashes and hashes together' do
|
|
expect(subject.shallow_update(details: { email: 'michael@intridea.com',
|
|
city: 'Imagineton' })).to eql(subject)
|
|
|
|
expect(subject.first_name).to eq 'Michael'
|
|
expect(subject.details.email).to eq 'michael@intridea.com'
|
|
expect(subject.details.address).to be_nil
|
|
expect(subject.details.city).to eq 'Imagineton'
|
|
end
|
|
|
|
it 'clones before a #regular_merge' do
|
|
duped = subject.shallow_merge(details: { address: 'Fake street' })
|
|
expect(duped).not_to eql(subject)
|
|
end
|
|
|
|
it 'default #merge is shallow' do
|
|
duped = subject.shallow_merge(details: { address: 'Fake street' })
|
|
expect(duped.details.address).to eq 'Fake street'
|
|
expect(subject.details.address).to eq 'Nowhere road'
|
|
expect(duped.details.email).to be_nil
|
|
end
|
|
end
|
|
|
|
describe '#replace' do
|
|
before do
|
|
subject.replace(
|
|
middle_name: 'Cain',
|
|
details: { city: 'Imagination' }
|
|
)
|
|
end
|
|
|
|
it 'returns self' do
|
|
expect(subject.replace(foo: 'bar').to_hash).to eq('foo' => 'bar')
|
|
end
|
|
|
|
it 'sets all specified keys to their corresponding values' do
|
|
expect(subject.middle_name?).to be_truthy
|
|
expect(subject.details?).to be_truthy
|
|
expect(subject.middle_name).to eq 'Cain'
|
|
expect(subject.details.city?).to be_truthy
|
|
expect(subject.details.city).to eq 'Imagination'
|
|
end
|
|
|
|
it 'leaves only specified keys' do
|
|
expect(subject.keys.sort).to eq %w[details middle_name]
|
|
expect(subject.first_name?).to be_falsy
|
|
expect(subject).not_to respond_to(:first_name)
|
|
expect(subject.last_name?).to be_falsy
|
|
expect(subject).not_to respond_to(:last_name)
|
|
end
|
|
end
|
|
|
|
describe 'delete' do
|
|
it 'deletes with String key' do
|
|
subject.delete('details')
|
|
expect(subject.details).to be_nil
|
|
expect(subject).not_to be_respond_to :details
|
|
end
|
|
|
|
it 'deletes with Symbol key' do
|
|
subject.delete(:details)
|
|
expect(subject.details).to be_nil
|
|
expect(subject).not_to be_respond_to :details
|
|
end
|
|
end
|
|
end
|
|
|
|
it 'converts hash assignments into Hashie::Mashes' do
|
|
subject.details = { email: 'randy@asf.com', address: { state: 'TX' } }
|
|
expect(subject.details.email).to eq 'randy@asf.com'
|
|
expect(subject.details.address.state).to eq 'TX'
|
|
end
|
|
|
|
it 'does not convert the type of Hashie::Mashes childs to Hashie::Mash' do
|
|
class MyMash < Hashie::Mash
|
|
end
|
|
|
|
record = MyMash.new
|
|
record.son = MyMash.new
|
|
expect(record.son.class).to eq MyMash
|
|
end
|
|
|
|
it 'does not change the class of Mashes when converted' do
|
|
class SubMash < Hashie::Mash
|
|
end
|
|
|
|
record = Hashie::Mash.new
|
|
son = SubMash.new
|
|
record['submash'] = son
|
|
expect(record['submash']).to be_kind_of(SubMash)
|
|
end
|
|
|
|
it 'respects the class when passed a bang method for a non-existent key' do
|
|
record = Hashie::Mash.new
|
|
expect(record.non_existent!).to be_kind_of(Hashie::Mash)
|
|
|
|
class SubMash < Hashie::Mash
|
|
end
|
|
|
|
son = SubMash.new
|
|
expect(son.non_existent!).to be_kind_of(SubMash)
|
|
end
|
|
|
|
it 'respects the class when passed an under bang method for a non-existent key' do
|
|
record = Hashie::Mash.new
|
|
expect(record.non_existent_).to be_kind_of(Hashie::Mash)
|
|
|
|
class SubMash < Hashie::Mash
|
|
end
|
|
|
|
son = SubMash.new
|
|
expect(son.non_existent_).to be_kind_of(SubMash)
|
|
end
|
|
|
|
it 'respects the class when converting the value' do
|
|
record = Hashie::Mash.new
|
|
record.details = Hashie::Mash.new(email: 'randy@asf.com')
|
|
expect(record.details).to be_kind_of(Hashie::Mash)
|
|
end
|
|
|
|
it 'respects another subclass when converting the value' do
|
|
record = Hashie::Mash.new
|
|
|
|
class SubMash < Hashie::Mash
|
|
end
|
|
|
|
son = SubMash.new(email: 'foo@bar.com')
|
|
record.details = son
|
|
expect(record.details).to be_kind_of(SubMash)
|
|
end
|
|
|
|
describe '#respond_to?' do
|
|
subject do
|
|
Hashie::Mash.new(abc: 'def')
|
|
end
|
|
|
|
it 'responds to a normal method' do
|
|
expect(subject).to be_respond_to(:key?)
|
|
end
|
|
|
|
it 'responds to a set key' do
|
|
expect(subject).to be_respond_to(:abc)
|
|
expect(subject.method(:abc)).to_not be_nil
|
|
end
|
|
|
|
it 'responds to a set key with a suffix' do
|
|
%w[= ? ! _].each do |suffix|
|
|
expect(subject).to be_respond_to(:"abc#{suffix}")
|
|
end
|
|
end
|
|
|
|
it 'is able to access the suffixed key as a method' do
|
|
%w[= ? ! _].each do |suffix|
|
|
expect(subject.method(:"abc#{suffix}")).to_not be_nil
|
|
end
|
|
end
|
|
|
|
it 'responds to an unknown key with a suffix' do
|
|
%w[= ? ! _].each do |suffix|
|
|
expect(subject).to be_respond_to(:"xyz#{suffix}")
|
|
end
|
|
end
|
|
|
|
it 'is able to access an unknown suffixed key as a method' do
|
|
# See https://github.com/intridea/hashie/pull/285 for more information
|
|
pending_for(engine: 'ruby', versions: %w[2.2.0 2.2.1 2.2.2])
|
|
|
|
%w[= ? ! _].each do |suffix|
|
|
expect(subject.method(:"xyz#{suffix}")).to_not be_nil
|
|
end
|
|
end
|
|
|
|
it 'does not respond to an unknown key without a suffix' do
|
|
expect(subject).not_to be_respond_to(:xyz)
|
|
expect { subject.method(:xyz) }.to raise_error(NameError)
|
|
end
|
|
end
|
|
|
|
context '#initialize' do
|
|
it 'converts an existing hash to a Hashie::Mash' do
|
|
converted = Hashie::Mash.new(abc: 123, name: 'Bob')
|
|
expect(converted.abc).to eq 123
|
|
expect(converted.name).to eq 'Bob'
|
|
end
|
|
|
|
it 'converts hashes recursively into Hashie::Mashes' do
|
|
converted = Hashie::Mash.new(a: { b: 1, c: { d: 23 } })
|
|
expect(converted.a.is_a?(Hashie::Mash)).to be_truthy
|
|
expect(converted.a.b).to eq 1
|
|
expect(converted.a.c.d).to eq 23
|
|
end
|
|
|
|
it 'converts hashes in arrays into Hashie::Mashes' do
|
|
converted = Hashie::Mash.new(a: [{ b: 12 }, 23])
|
|
expect(converted.a.first.b).to eq 12
|
|
expect(converted.a.last).to eq 23
|
|
end
|
|
|
|
it 'converts an existing Hashie::Mash into a Hashie::Mash' do
|
|
initial = Hashie::Mash.new(name: 'randy', address: { state: 'TX' })
|
|
copy = Hashie::Mash.new(initial)
|
|
expect(initial.name).to eq copy.name
|
|
expect(initial.__id__).not_to eq copy.__id__
|
|
expect(copy.address.state).to eq 'TX'
|
|
copy.address.state = 'MI'
|
|
expect(initial.address.state).to eq 'TX'
|
|
expect(copy.address.__id__).not_to eq initial.address.__id__
|
|
end
|
|
|
|
it 'accepts a default block' do
|
|
initial = Hashie::Mash.new { |h, i| h[i] = [] }
|
|
expect(initial.default_proc).not_to be_nil
|
|
expect(initial.default).to be_nil
|
|
expect(initial.test).to eq []
|
|
expect(initial.test?).to be_truthy
|
|
end
|
|
|
|
it 'allows propagation of a default block' do
|
|
h = Hashie::Mash.new { |mash, key| mash[key] = mash.class.new(&mash.default_proc) }
|
|
expect { h[:x][:y][:z] = :xyz }.not_to raise_error
|
|
expect(h.x.y.z).to eq(:xyz)
|
|
expect(h[:x][:y][:z]).to eq(:xyz)
|
|
end
|
|
|
|
it 'allows assignment of an empty array in a default block' do
|
|
initial = Hashie::Mash.new { |h, k| h[k] = [] }
|
|
initial.hello << 100
|
|
expect(initial.hello).to eq [100]
|
|
initial['hi'] << 100
|
|
expect(initial['hi']).to eq [100]
|
|
end
|
|
|
|
it 'allows assignment of a non-empty array in a default block' do
|
|
initial = Hashie::Mash.new { |h, k| h[k] = [100] }
|
|
initial.hello << 200
|
|
expect(initial.hello).to eq [100, 200]
|
|
initial['hi'] << 200
|
|
expect(initial['hi']).to eq [100, 200]
|
|
end
|
|
|
|
it 'allows assignment of an empty hash in a default block' do
|
|
initial = Hashie::Mash.new { |h, k| h[k] = {} }
|
|
initial.hello[:a] = 100
|
|
expect(initial.hello).to eq Hashie::Mash.new(a: 100)
|
|
initial[:hi][:a] = 100
|
|
expect(initial[:hi]).to eq Hashie::Mash.new(a: 100)
|
|
end
|
|
|
|
it 'allows assignment of a non-empty hash in a default block' do
|
|
initial = Hashie::Mash.new { |h, k| h[k] = { a: 100 } }
|
|
initial.hello[:b] = 200
|
|
expect(initial.hello).to eq Hashie::Mash.new(a: 100, b: 200)
|
|
initial[:hi][:b] = 200
|
|
expect(initial[:hi]).to eq Hashie::Mash.new(a: 100, b: 200)
|
|
end
|
|
|
|
it 'converts Hashie::Mashes within Arrays back to Hashes' do
|
|
initial_hash = { 'a' => [{ 'b' => 12, 'c' => ['d' => 50, 'e' => 51] }, 23] }
|
|
converted = Hashie::Mash.new(initial_hash)
|
|
expect(converted.to_hash['a'].first.is_a?(Hashie::Mash)).to be_falsy
|
|
expect(converted.to_hash['a'].first.is_a?(Hash)).to be_truthy
|
|
expect(converted.to_hash['a'].first['c'].first.is_a?(Hashie::Mash)).to be_falsy
|
|
end
|
|
|
|
it 'only stringifies keys which can be converted to symbols' do
|
|
initial_hash = { 1 => 'a', ['b'] => 2, 'c' => 3, d: 4 }
|
|
converted = Hashie::Mash.new(initial_hash)
|
|
expect(converted).to eq(1 => 'a', ['b'] => 2, 'c' => 3, 'd' => 4)
|
|
end
|
|
|
|
it 'preserves keys which cannot be converted to symbols' do
|
|
initial_hash = { 1 => 'a', '1' => 'b', :'1' => 'c' }
|
|
converted = Hashie::Mash.new(initial_hash)
|
|
expect(converted).to eq(1 => 'a', '1' => 'c')
|
|
end
|
|
end
|
|
|
|
describe '#fetch' do
|
|
let(:hash) { { one: 1, other: false } }
|
|
let(:mash) { Hashie::Mash.new(hash) }
|
|
|
|
context 'when key exists' do
|
|
it 'returns the value' do
|
|
expect(mash.fetch(:one)).to eql(1)
|
|
end
|
|
|
|
it 'returns the value even if the value is falsy' do
|
|
expect(mash.fetch(:other)).to eql(false)
|
|
end
|
|
|
|
context 'when key has other than original but acceptable type' do
|
|
it 'returns the value' do
|
|
expect(mash.fetch('one')).to eql(1)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when key does not exist' do
|
|
it 'raises KeyError' do
|
|
expect { mash.fetch(:two) }.to raise_error(KeyError)
|
|
end
|
|
|
|
context 'with default value given' do
|
|
it 'returns default value' do
|
|
expect(mash.fetch(:two, 8)).to eql(8)
|
|
end
|
|
|
|
it 'returns default value even if it is falsy' do
|
|
expect(mash.fetch(:two, false)).to eql(false)
|
|
end
|
|
end
|
|
|
|
context 'with block given' do
|
|
it 'returns default value' do
|
|
expect(mash.fetch(:two) do
|
|
'block default value'
|
|
end).to eql('block default value')
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#to_hash' do
|
|
let(:hash) { { 'outer' => { 'inner' => 42 }, 'testing' => [1, 2, 3] } }
|
|
let(:mash) { Hashie::Mash.new(hash) }
|
|
|
|
it 'returns a standard Hash' do
|
|
expect(mash.to_hash).to be_a(::Hash)
|
|
end
|
|
|
|
it 'includes all keys' do
|
|
expect(mash.to_hash.keys).to eql(%w[outer testing])
|
|
end
|
|
|
|
it 'converts keys to symbols when symbolize_keys option is true' do
|
|
expect(mash.to_hash(symbolize_keys: true).keys).to include(:outer)
|
|
expect(mash.to_hash(symbolize_keys: true).keys).not_to include('outer')
|
|
end
|
|
|
|
it 'leaves keys as strings when symbolize_keys option is false' do
|
|
expect(mash.to_hash(symbolize_keys: false).keys).to include('outer')
|
|
expect(mash.to_hash(symbolize_keys: false).keys).not_to include(:outer)
|
|
end
|
|
|
|
it 'symbolizes keys recursively' do
|
|
expect(mash.to_hash(symbolize_keys: true)[:outer].keys).to include(:inner)
|
|
expect(mash.to_hash(symbolize_keys: true)[:outer].keys).not_to include('inner')
|
|
end
|
|
end
|
|
|
|
describe '#stringify_keys' do
|
|
it 'turns all keys into strings recursively' do
|
|
hash = Hashie::Mash[:a => 'hey', 123 => { 345 => 'hey' }]
|
|
hash.stringify_keys!
|
|
expect(hash).to eq Hashie::Hash['a' => 'hey', '123' => { '345' => 'hey' }]
|
|
end
|
|
end
|
|
|
|
describe '#values_at' do
|
|
let(:hash) { { 'key_one' => 1, :key_two => 2 } }
|
|
let(:mash) { Hashie::Mash.new(hash) }
|
|
|
|
context 'when the original type is given' do
|
|
it 'returns the values' do
|
|
expect(mash.values_at('key_one', :key_two)).to eq([1, 2])
|
|
end
|
|
end
|
|
|
|
context 'when a different, but acceptable type is given' do
|
|
it 'returns the values' do
|
|
expect(mash.values_at(:key_one, 'key_two')).to eq([1, 2])
|
|
end
|
|
end
|
|
|
|
context 'when a key is given that is not in the Mash' do
|
|
it 'returns nil for that value' do
|
|
expect(mash.values_at('key_one', :key_three)).to eq([1, nil])
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '.load(filename, options = {})' do
|
|
let(:config) do
|
|
{
|
|
'production' => {
|
|
'foo' => 'production_foo'
|
|
}
|
|
}
|
|
end
|
|
let(:path) { 'database.yml' }
|
|
let(:parser) { double(:parser) }
|
|
|
|
subject { described_class.load(path, parser: parser) }
|
|
|
|
before do |ex|
|
|
unless ex.metadata == :test_cache
|
|
described_class.instance_variable_set('@_mashes', nil) # clean the cached mashes
|
|
end
|
|
end
|
|
|
|
context 'if the file exists' do
|
|
before do
|
|
expect(File).to receive(:file?).with(path).and_return(true)
|
|
expect(parser).to receive(:perform).with(path, {}).and_return(config)
|
|
end
|
|
|
|
it { is_expected.to be_a(Hashie::Mash) }
|
|
|
|
it 'return a Mash from a file' do
|
|
expect(subject.production).not_to be_nil
|
|
expect(subject.production.keys).to eq config['production'].keys
|
|
expect(subject.production.foo).to eq config['production']['foo']
|
|
end
|
|
|
|
it 'freeze the attribtues' do
|
|
expect { subject.production = {} }.to raise_exception(RuntimeError, /can't modify frozen/)
|
|
end
|
|
end
|
|
|
|
context 'if the fils does not exists' do
|
|
before do
|
|
expect(File).to receive(:file?).with(path).and_return(false)
|
|
end
|
|
|
|
it 'raise an ArgumentError' do
|
|
expect { subject }.to raise_exception(ArgumentError)
|
|
end
|
|
end
|
|
|
|
context 'if the file is passed as Pathname' do
|
|
require 'pathname'
|
|
let(:path) { Pathname.new('database.yml') }
|
|
|
|
before do
|
|
expect(File).to receive(:file?).with(path).and_return(true)
|
|
expect(parser).to receive(:perform).with(path, {}).and_return(config)
|
|
end
|
|
|
|
it 'return a Mash from a file' do
|
|
expect(subject.production.foo).to eq config['production']['foo']
|
|
end
|
|
end
|
|
|
|
describe 'results are cached' do
|
|
let(:parser) { double(:parser) }
|
|
|
|
subject { described_class.load(path, parser: parser) }
|
|
|
|
before do
|
|
expect(File).to receive(:file?).with(path).and_return(true)
|
|
expect(File).to receive(:file?).with("#{path}+1").and_return(true)
|
|
expect(parser).to receive(:perform).once.with(path, {}).and_return(config)
|
|
expect(parser).to receive(:perform).once.with("#{path}+1", {}).and_return(config)
|
|
end
|
|
|
|
it 'cache the loaded yml file', :test_cache do
|
|
2.times do
|
|
expect(subject).to be_a(described_class)
|
|
expect(described_class.load("#{path}+1", parser: parser)).to be_a(described_class)
|
|
end
|
|
|
|
expect(subject.object_id).to eq subject.object_id
|
|
end
|
|
end
|
|
|
|
context 'when the file has aliases in it' do
|
|
it 'can use the aliases and does not raise an error' do
|
|
mash = Hashie::Mash.load('spec/fixtures/yaml_with_aliases.yml')
|
|
expect(mash.company_a.accounts.admin.password).to eq('secret')
|
|
end
|
|
it 'can override the value of aliases' do
|
|
expect do
|
|
Hashie::Mash.load('spec/fixtures/yaml_with_aliases.yml', aliases: false)
|
|
end.to raise_error Psych::BadAlias, /base_accounts/
|
|
end
|
|
end
|
|
|
|
context 'when the file has symbols' do
|
|
it 'can override the value of permitted_classes' do
|
|
mash = Hashie::Mash.load('spec/fixtures/yaml_with_symbols.yml', permitted_classes: [Symbol])
|
|
expect(mash.user_icon.width).to eq(200)
|
|
end
|
|
it 'uses defaults for permitted_classes' do
|
|
expect do
|
|
Hashie::Mash.load('spec/fixtures/yaml_with_symbols.yml')
|
|
end.to raise_error Psych::DisallowedClass, /Symbol/
|
|
end
|
|
it 'can override the value of permitted_symbols' do
|
|
mash = Hashie::Mash.load('spec/fixtures/yaml_with_symbols.yml',
|
|
permitted_classes: [Symbol],
|
|
permitted_symbols: %i[
|
|
user_icon
|
|
width
|
|
height
|
|
])
|
|
expect(mash.user_icon.width).to eq(200)
|
|
end
|
|
it 'raises an error on insufficient permitted_symbols' do
|
|
expect do
|
|
Hashie::Mash.load('spec/fixtures/yaml_with_symbols.yml',
|
|
permitted_classes: [Symbol],
|
|
permitted_symbols: %i[
|
|
user_icon
|
|
width
|
|
])
|
|
end.to raise_error Psych::DisallowedClass, /Symbol/
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#to_module(mash_method_name)' do
|
|
let(:mash) { described_class.new }
|
|
subject { Class.new.extend mash.to_module }
|
|
|
|
it 'defines a settings method on the klass class that extends the module' do
|
|
expect(subject).to respond_to(:settings)
|
|
expect(subject.settings).to eq mash
|
|
end
|
|
|
|
context 'when a settings_method_name is set' do
|
|
let(:mash_method_name) { 'config' }
|
|
|
|
subject { Class.new.extend mash.to_module(mash_method_name) }
|
|
|
|
it 'defines a settings method on the klass class that extends the module' do
|
|
expect(subject).to respond_to(mash_method_name.to_sym)
|
|
expect(subject.send(mash_method_name.to_sym)).to eq mash
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#reverse_merge' do
|
|
subject { described_class.new(a: 1, b: 2) }
|
|
|
|
it 'unifies strings and symbols' do
|
|
expect(subject.reverse_merge(a: 2).length).to eq 2
|
|
expect(subject.reverse_merge('a' => 2).length).to eq 2
|
|
end
|
|
|
|
it 'does not overwrite values' do
|
|
expect(subject.reverse_merge(a: 5).a).to eq subject.a
|
|
end
|
|
|
|
context 'when using with subclass' do
|
|
let(:subclass) { Class.new(Hashie::Mash) }
|
|
subject { subclass.new(a: 1) }
|
|
|
|
it 'creates an instance of subclass' do
|
|
expect(subject.reverse_merge(a: 5)).to be_kind_of(subclass)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#invert' do
|
|
subject(:mash) { described_class.new(a: 'apple', b: 4) }
|
|
|
|
it 'returns a Hashie::Mash' do
|
|
expect(mash.invert).to be_kind_of(described_class)
|
|
end
|
|
|
|
it 'returns a mash with the keys and values inverted' do
|
|
expect(mash.invert).to eq('apple' => 'a', 4 => 'b')
|
|
end
|
|
|
|
context 'when using with subclass' do
|
|
let(:subclass) { Class.new(Hashie::Mash) }
|
|
subject(:sub_mash) { subclass.new(a: 1, b: nil) }
|
|
|
|
it 'creates an instance of subclass' do
|
|
expect(sub_mash.invert).to be_kind_of(subclass)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#reject' do
|
|
subject(:mash) { described_class.new(a: 1, b: nil) }
|
|
|
|
it 'returns a Hashie::Mash' do
|
|
expect(mash.reject { |_k, v| v.nil? }).to be_kind_of(described_class)
|
|
end
|
|
|
|
it 'rejects keys for which the block returns true' do
|
|
expect(mash.reject { |_k, v| v.nil? }).to eq('a' => 1)
|
|
end
|
|
|
|
context 'when using with subclass' do
|
|
let(:subclass) { Class.new(Hashie::Mash) }
|
|
subject(:sub_mash) { subclass.new(a: 1, b: nil) }
|
|
|
|
it 'creates an instance of subclass' do
|
|
expect(sub_mash.reject { |_k, v| v.nil? }).to be_kind_of(subclass)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#select' do
|
|
subject(:mash) { described_class.new(a: 'apple', b: 4) }
|
|
|
|
it 'returns a Hashie::Mash' do
|
|
expect(mash.select { |_k, v| v.is_a? String }).to be_kind_of(described_class)
|
|
end
|
|
|
|
it 'selects keys for which the block returns true' do
|
|
expect(mash.select { |_k, v| v.is_a? String }).to eq('a' => 'apple')
|
|
end
|
|
|
|
context 'when using with subclass' do
|
|
let(:subclass) { Class.new(Hashie::Mash) }
|
|
subject(:sub_mash) { subclass.new(a: 1, b: nil) }
|
|
|
|
it 'creates an instance of subclass' do
|
|
expect(sub_mash.select { |_k, v| v.is_a? String }).to be_kind_of(subclass)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '.quiet' do
|
|
it 'returns a subclass of the calling class' do
|
|
expect(Hashie::Mash.quiet.new).to be_a(Hashie::Mash)
|
|
end
|
|
|
|
it 'memoizes and returns classes' do
|
|
call_one = Hashie::Mash.quiet
|
|
call_two = Hashie::Mash.quiet
|
|
expect(Hashie::Mash.instance_variable_get('@memoized_classes').count).to eq(1)
|
|
expect(call_one).to eq(call_two)
|
|
end
|
|
end
|
|
|
|
describe '#dig' do
|
|
subject { described_class.new(a: { b: 1 }) }
|
|
|
|
it 'accepts both string and symbol as key' do
|
|
expect(subject.dig(:a, :b)).to eq(1)
|
|
expect(subject.dig('a', 'b')).to eq(1)
|
|
end
|
|
|
|
context 'when the Mash wraps a Hashie::Array' do
|
|
it 'handles digging into an array' do
|
|
mash = described_class.new(alphabet: { first_three: Hashie::Array['a', 'b', 'c'] })
|
|
|
|
expect(mash.dig(:alphabet, :first_three, 0)).to eq 'a'
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#transform_values' do
|
|
subject(:mash) { described_class.new(a: 1) }
|
|
|
|
it 'returns a Hashie::Mash' do
|
|
expect(mash.transform_values(&:to_s)).to be_kind_of(described_class)
|
|
end
|
|
|
|
it 'transforms the value' do
|
|
expect(mash.transform_values(&:to_s).a).to eql('1')
|
|
end
|
|
|
|
context 'when using with subclass' do
|
|
let(:subclass) { Class.new(Hashie::Mash) }
|
|
subject(:sub_mash) { subclass.new(a: 1).transform_values { |a| a + 2 } }
|
|
|
|
it 'creates an instance of subclass' do
|
|
expect(sub_mash).to be_kind_of(subclass)
|
|
end
|
|
end
|
|
|
|
describe '#compact' do
|
|
subject(:mash) { described_class.new(a: 1, b: nil) }
|
|
|
|
it 'returns a Hashie::Mash' do
|
|
expect(mash.compact).to be_kind_of(described_class)
|
|
end
|
|
|
|
it 'removes keys with nil values' do
|
|
expect(mash.compact).to eq('a' => 1)
|
|
end
|
|
|
|
context 'when using with subclass' do
|
|
let(:subclass) { Class.new(Hashie::Mash) }
|
|
subject(:sub_mash) { subclass.new(a: 1, b: nil) }
|
|
|
|
it 'creates an instance of subclass' do
|
|
expect(sub_mash.compact).to be_kind_of(subclass)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
with_minimum_ruby('2.5.0') do
|
|
describe '#slice' do
|
|
subject(:mash) { described_class.new(a: 1, b: 2) }
|
|
|
|
it 'returns a Hashie::Mash' do
|
|
expect(mash.slice(:a)).to be_kind_of(described_class)
|
|
end
|
|
|
|
it 'returns a Mash with only the keys passed' do
|
|
expect(mash.slice(:a).to_hash).to eq('a' => 1)
|
|
end
|
|
|
|
context 'when using with subclass' do
|
|
let(:subclass) { Class.new(Hashie::Mash) }
|
|
subject(:sub_mash) { subclass.new(a: 1, b: 2) }
|
|
|
|
it 'creates an instance of subclass' do
|
|
expect(sub_mash.slice(:a)).to be_kind_of(subclass)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#transform_keys' do
|
|
subject(:mash) { described_class.new(a: 1, b: 2) }
|
|
|
|
it 'returns a Hashie::Mash' do
|
|
expect(mash.transform_keys { |k| k + k }).to be_kind_of(described_class)
|
|
end
|
|
|
|
it 'returns a Mash with transformed keys' do
|
|
expect(mash.transform_keys { |k| k + k }).to eq('aa' => 1, 'bb' => 2)
|
|
end
|
|
|
|
context 'when using with subclass' do
|
|
let(:subclass) { Class.new(Hashie::Mash) }
|
|
subject(:sub_mash) { subclass.new(a: 1, b: 2) }
|
|
|
|
it 'creates an instance of subclass' do
|
|
expect(sub_mash.transform_keys { |k| k + k }).to be_kind_of(subclass)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
with_minimum_ruby('2.6.0') do
|
|
context 'ruby 2.6 merging' do
|
|
subject(:mash) { Hashie::Mash.new(model: 'Honda') }
|
|
it 'merges multiple hashes and mashes passeed to #merge' do
|
|
first_hash = { model: 'Ford' }
|
|
second_hash = { model: 'DeLorean' }
|
|
expect(mash.merge(first_hash, second_hash)).to eq('model' => 'DeLorean')
|
|
end
|
|
end
|
|
end
|
|
|
|
with_minimum_ruby('3.0.0') do
|
|
context '#except' do
|
|
subject(:mash) { described_class.new(a: 'A', b: 'B') }
|
|
it 'return a Hashie::Mash' do
|
|
expect(mash.except(:b)).to be_kind_of(described_class)
|
|
end
|
|
|
|
it 'excludes keys' do
|
|
expect(mash.except(:b)).to eq('a' => 'A')
|
|
end
|
|
end
|
|
end
|
|
end
|