chamber 1.0.3 → 2.0.0

data/spec/lib/chamber/filters/secure_filter_spec.rb

@@ -0,0 +1,36 @@
+require 'rspectacular'
+require 'chamber/filters/secure_filter'
+
+module    Chamber
+module    Filters
+describe  SecureFilter do
+  it 'will return values which are marked as "secure"' do
+    filtered_settings = SecureFilter.execute( data: {
+                                                _secure_my_secure_setting: 'hello' })
+
+    expect(filtered_settings._secure_my_secure_setting).to match 'hello'
+  end
+
+  it 'will not return values which are not marked as "secure"' do
+    filtered_settings = SecureFilter.execute( data: {
+                                                my_secure_setting: 'hello' })
+
+    expect(filtered_settings.my_secure_setting).to be_nil
+  end
+
+  it 'will properly return values even if they are mixed and deeply nested' do
+    filtered_settings = SecureFilter.execute( data: {
+                                                _secure_setting: 'hello',
+                                                secure_setting:  'goodbye',
+                                                secure_group: {
+                                                  _secure_nested_setting:  'movie',
+                                                  insecure_nested_setting: 'dinner' }})
+
+    expect(filtered_settings._secure_setting).to                      eql 'hello'
+    expect(filtered_settings.secure_setting).to                       be_nil
+    expect(filtered_settings.secure_group._secure_nested_setting).to  eql 'movie'
+    expect(filtered_settings.secure_group.insecure_nested_setting).to be_nil
+  end
+end
+end
+end

data/spec/lib/chamber/namespace_set_spec.rb

@@ -1,46 +1,89 @@
 require 'rspectacular'
 require 'chamber/namespace_set'
 
-class     Chamber
+module    Chamber
 describe  NamespaceSet do
   it 'can create a set from from a hash' do
     namespace_set = NamespaceSet.new( environment:  :development,
                                       hostname:     'my host')
 
-    expect(namespace_set).to eq [:development, 'my host']
+    expect(namespace_set).to eq ['development', 'my host']
   end
 
   it 'can create a set from an array' do
     namespace_set = NamespaceSet.new([:development,
                                       'my host'])
 
-    expect(namespace_set).to eq [:development, 'my host']
+    expect(namespace_set).to eq ['development', 'my host']
   end
 
   it 'can create a set from a set' do
     original_set  = Set[:development, 'my host']
     namespace_set = NamespaceSet.new(original_set)
 
-    expect(namespace_set).to eq [:development, 'my host']
+    expect(namespace_set).to eq ['development', 'my host']
+  end
+
+  it 'can create itself using square-bracket notation' do
+    namespace_set = NamespaceSet[:development, 'my host']
+
+    expect(namespace_set).to eq ['development', 'my host']
+  end
+
+  it 'can create itself from another NamespaceSet' do
+    original_set  = NamespaceSet[:development, 'my host']
+    namespace_set = NamespaceSet.new(original_set)
+
+    expect(namespace_set).to eq ['development', 'my host']
+  end
+
+  it 'can create itself from a single value' do
+    namespace_set = NamespaceSet.new(:development)
+
+    expect(namespace_set).to eq ['development']
+  end
+
+  it 'when creating itself from another NamespaceSet, it creates a new NamespaceSet' do
+    original_set  = NamespaceSet[:development, 'my host']
+    namespace_set = NamespaceSet.new(original_set)
+
+    expect(namespace_set.object_id).not_to eq original_set.object_id
+  end
+
+  it 'when creating itself from another NamespaceSet, it does not nest the NamespaceSets' do
+    original_set  = NamespaceSet[:development, 'my host']
+    namespace_set = NamespaceSet.new(original_set)
+
+    expect(namespace_set.send(:raw_namespaces)).not_to be_a NamespaceSet
   end
 
   it 'can turn itself into an array' do
-    namespace_set = NamespaceSet.new([:development, 'my host'])
+    namespace_set = NamespaceSet[:development, 'my host']
 
-    expect(namespace_set.to_ary).to eq [:development, 'my host']
-    expect(namespace_set.to_a).to   eq [:development, 'my host']
+    expect(namespace_set.to_ary).to eq ['development', 'my host']
+    expect(namespace_set.to_a).to   eq ['development', 'my host']
   end
 
   it 'can combine itself with an array' do
-    namespace_set = NamespaceSet.new([:development, 'my host'])
+    namespace_set = NamespaceSet[:development, 'my host']
     other_set     = Set['other value', 3]
+
+    combined_set  = namespace_set + other_set
+
+    expect(combined_set).to eq ['development', 'my host', 'other value', '3']
+  end
+
+  it 'can combine itself with another NamespaceSet' do
+    namespace_set = NamespaceSet[:development, 'my host']
+    other_set     = NamespaceSet['other value', 3]
+
     combined_set  = namespace_set + other_set
 
-    expect(combined_set).to eq [:development, 'my host', 'other value', 3]
+    expect(combined_set).to eq ['development', 'my host', 'other value', '3']
   end
 
   it 'does not modify the set in place if combining with another array' do
-    namespace_set = NamespaceSet.new([:development, 'my host'])
+    namespace_set = NamespaceSet[:development, 'my host']
     other_set     = Set['other value', 3]
     combined_set  = namespace_set + other_set
 
@@ -48,32 +91,32 @@ describe  NamespaceSet do
   end
 
   it 'can combine itself with something that can be converted to an array' do
-    namespace_set = NamespaceSet.new([:development, 'my host'])
+    namespace_set = NamespaceSet[:development, 'my host']
     other_set     = (1..3)
     combined_set  = namespace_set + other_set
 
-    expect(combined_set).to eq [:development, 'my host', 1, 2, 3]
+    expect(combined_set).to eq ['development', 'my host', '1', '2', '3']
   end
 
   it 'does not allow duplicate items' do
-    namespace_set = NamespaceSet.new([:development, :development])
+    namespace_set = NamespaceSet[:development, :development]
 
-    expect(namespace_set).to eq [:development]
+    expect(namespace_set).to eq ['development']
   end
 
   it 'will process a value by executing it if it is a callable' do
-    namespace_set = NamespaceSet.new([ -> { 'callable' } ])
+    namespace_set = NamespaceSet[ -> { 'callable' } ]
 
     expect(namespace_set).to eq ['callable']
 
-    namespace_set = NamespaceSet.new({ :my_namespace => -> { 'callable' } })
+    namespace_set = NamespaceSet.new( :my_namespace => -> { 'callable' } )
 
     expect(namespace_set).to eq ['callable']
   end
 
   it 'can compare itself to another NamespaceSet' do
-    namespace_set       = NamespaceSet.new([:development, :development])
-    other_namespace_set = NamespaceSet.new([:development, :development])
+    namespace_set       = NamespaceSet[:development, :development]
+    other_namespace_set = NamespaceSet[:development, :development]
 
     expect(namespace_set).to eql other_namespace_set
   end

data/spec/lib/chamber/settings_spec.rb

@@ -1,31 +1,31 @@
 require 'rspectacular'
 require 'chamber/settings'
 
-class     Chamber
+module    Chamber
 describe  Settings do
   it 'can verify that it is equal to another Settings object' do
     settings        = Settings.new( settings:   {setting: 'value'},
-                                    namespaces: NamespaceSet.new(['good']))
+                                    namespaces: ['good'])
     other_settings  = Settings.new( settings:   {setting: 'value'},
-                                    namespaces: NamespaceSet.new(['good']))
+                                    namespaces: ['good'])
 
     expect(settings).to eql other_settings
   end
 
   it 'does not consider itself equal if the namespaces are not equal' do
     settings        = Settings.new( settings:   {setting: 'value'},
-                                    namespaces: NamespaceSet.new(['good']))
+                                    namespaces: ['good'])
     other_settings  = Settings.new( settings:   {setting: 'value'},
-                                    namespaces: NamespaceSet.new(['bad']))
+                                    namespaces: ['bad'])
 
     expect(settings).not_to eql other_settings
   end
 
   it 'does not consider itself equal if the settings are not equal' do
     settings        = Settings.new( settings:   {setting: 'value'},
-                                    namespaces: NamespaceSet.new(['good']))
+                                    namespaces: ['good'])
     other_settings  = Settings.new( settings:   {setting: 'value 1'},
-                                    namespaces: NamespaceSet.new(['good']))
+                                    namespaces: ['good'])
 
     expect(settings).not_to eql other_settings
   end
@@ -72,32 +72,55 @@ describe  Settings do
   end
 
   it 'can merge itself with a hash' do
-    settings = Settings.new(settings: {setting: 'value'})
-    settings.merge!(other_setting: 'another value')
+    settings        = Settings.new(settings: {setting: 'value'})
+    other_settings  = { other_setting: 'another value' }
+
+    merged_settings = settings.merge(other_settings)
 
-    expect(settings.to_hash).to eql Hashie::Mash.new( setting:        'value',
-                                                      other_setting:  'another value')
+    expect(merged_settings).to eq('setting'       => 'value',
+                                   'other_setting' => 'another value')
   end
 
   it 'can merge itself with Settings' do
     settings       = Settings.new(settings:   {setting:       'value'},
-                                  namespaces: NamespaceSet.new(['good']))
-
+                                  namespaces: ['good'])
     other_settings = Settings.new(settings:   {other_setting: 'another value'},
-                                  namespaces: NamespaceSet.new(['bad']))
+                                  namespaces: ['bad'])
+
+    merged_settings = settings.merge(other_settings)
+
+    expect(merged_settings).to eql Settings.new(settings:   {
+                                                  setting:        'value',
+                                                  other_setting:  'another value' },
+                                                namespaces: ['good', 'bad'])
+  end
+
+  it 'does not manipulate the existing Settings but instead returns a new one' do
+    settings       = Settings.new(settings:   {setting:       'value'})
+    other_settings = Settings.new(settings:   {other_setting: 'another value'})
 
-    settings.merge!(other_settings)
+    merged_settings = settings.merge(other_settings)
 
-    expect(settings).to eql Settings.new( settings:   {
-                                            setting:        'value',
-                                            other_setting:  'another value' },
-                                          namespaces: NamespaceSet.new(['good', 'bad']))
+    expect(merged_settings.object_id).not_to eql settings.object_id
+    expect(merged_settings.object_id).not_to eql other_settings.object_id
   end
 
   it 'can convert itself into a hash' do
     settings = Settings.new(settings: {setting: 'value'})
 
-    expect(settings.to_hash).to eql('setting' => 'value')
+    expect(settings.to_hash).to     eql('setting' => 'value')
+    expect(settings.to_hash).to     be_a Hash
+    expect(settings.to_hash).not_to be_a Hashie::Mash
+  end
+
+  it 'does not allow manipulation of the internal setting hash when converted to a Hash' do
+    settings = Settings.new(settings: {setting: 'value'})
+
+    settings_hash = settings.to_hash
+    settings_hash['setting'] = 'foo'
+
+    expect(settings.send(:data).object_id).not_to eql settings_hash.object_id
+    expect(settings.setting).to eql 'value'
   end
 
   it 'allows messages to be passed through to the underlying data' do
@@ -126,10 +149,63 @@ describe  Settings do
                                 other_namespace_setting:  'value' },
                               non_namespace_setting:  'other value'
                             },
-                            namespaces: NamespaceSet.new(['namespace_value', 'other_namespace_value']))
+                            namespaces: ['namespace_value', 'other_namespace_value'])
+
+    expect(settings).to eq('namespace_setting' => 'value',
+                             'other_namespace_setting' => 'value')
+  end
+
+  it 'can decrypt a setting if it finds a secure key' do
+    settings = Settings.new(settings:   {
+                              _secure_my_encrypted_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ=='
+                            },
+                            decryption_key: './spec/spec_key')
+
+    expect(settings).to eq('my_encrypted_setting' => 'hello')
+  end
+
+  it 'can encrypt a setting if it finds a secure key' do
+    settings = Settings.new(settings:   {
+                              _secure_my_encrypted_setting: 'hello'
+                            },
+                            encryption_key: './spec/spec_key.pub',
+                            pre_filters:    [],
+                            post_filters:   [ Filters::EncryptionFilter ])
+
+    expect(settings._secure_my_encrypted_setting).to match Filters::EncryptionFilter::BASE64_STRING_PATTERN
+  end
+
+  it 'can encrypt a settings without explicitly having to have a filter passed' do
+    settings = Settings.new(settings:   {
+                              _secure_my_encrypted_setting: 'hello'
+                            },
+                            decryption_key: './spec/spec_key',
+                            encryption_key: './spec/spec_key.pub')
+
+    expect(settings).to eq('my_encrypted_setting' => 'hello')
+
+    secure_settings = settings.secure
+
+    expect(secure_settings._secure_my_encrypted_setting).to match Filters::EncryptionFilter::BASE64_STRING_PATTERN
+  end
+
+  it 'can check if it is equal to other items which can be converted into hashes' do
+    settings = Settings.new(settings: {setting: 'value'})
+
+    expect(settings).to eq('setting' => 'value')
+  end
+
+  it 'can filter secured settings' do
+    settings = Settings.new(settings:   {
+                              _secure_my_encrypted_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
+                              my_insecure_setting:          'goodbye',
+                            },
+                            decryption_key: './spec/spec_key')
+
+    secured_settings = settings.secured
 
-    expect(settings.to_hash).to eql('namespace_setting'       => 'value',
-                                    'other_namespace_setting' => 'value')
+    expect(secured_settings.my_encrypted_setting).to  eql 'hello'
+    expect(secured_settings.my_insecure_setting?).to  be_false
   end
 end
 end

data/spec/lib/chamber/system_environment_spec.rb

@@ -1,7 +1,7 @@
 require 'rspectacular'
 require 'chamber/system_environment'
 
-class     Chamber
+module    Chamber
 describe  SystemEnvironment do
   it 'can extract environment variables based on a hash that is passed in' do
     source_hash = {
@@ -36,20 +36,6 @@ describe  SystemEnvironment do
     })
   end
 
-  it 'allows injected environment variables to be prefixed for compatibility' do
-    ENV['PREFIX_VALUE_ONE'] = 'value 1'
-
-    source_hash = {
-      value_one: 'value',
-    }
-
-    environment_hash = SystemEnvironment.inject_into(source_hash, [:prefix])
-
-    expect(environment_hash).to eql({
-      'value_one' => 'value 1',
-    })
-  end
-
   it 'allows extracted environment variables to be prefixed for compatibility' do
     source_hash = {
       value_one: 'value',
@@ -61,61 +47,5 @@ describe  SystemEnvironment do
       'PREFIX_VALUE_ONE' => 'value',
     })
   end
-
-  it 'can inject existing environment variable values into a hash' do
-    ENV['LEVEL_ONE_1_LEVEL_TWO_1']               = 'value 1'
-    ENV['LEVEL_ONE_1_LEVEL_TWO_2_LEVEL_THREE_1'] = 'value 2'
-    ENV['LEVEL_ONE_1_LEVEL_TWO_2_LEVEL_THREE_2'] = 'value 3'
-    ENV['LEVEL_ONE_1_LEVEL_TWO_3']               = 'value 4'
-    ENV['LEVEL_ONE_1_LEVEL_ONE_2']               = 'value 5'
-
-    source_hash = {
-      level_one_1: {
-        level_two_1: nil,
-        level_two_2: {
-          level_three_1: nil,
-          level_three_2: '',
-        },
-        level_two_3: '',
-      level_one_2: '' }
-    }
-
-    expect(SystemEnvironment.inject_into(source_hash)).to eql({
-      'level_one_1' => {
-        'level_two_1' => 'value 1',
-        'level_two_2' => {
-          'level_three_1' => 'value 2',
-          'level_three_2' => 'value 3',
-        },
-        'level_two_3' => 'value 4',
-      'level_one_2' => 'value 5' }
-    })
-
-    ENV.delete('LEVEL_ONE_1_LEVEL_TWO_1')
-    ENV.delete('LEVEL_ONE_1_LEVEL_TWO_2_LEVEL_THREE_1')
-    ENV.delete('LEVEL_ONE_1_LEVEL_TWO_2_LEVEL_THREE_2')
-    ENV.delete('LEVEL_ONE_1_LEVEL_TWO_3')
-    ENV.delete('LEVEL_ONE_1_LEVEL_ONE_2')
-  end
-
-  it 'can convert simple boolean text values to their Boolean equivalents' do
-    source_hash = {
-      true_text:    'true',
-      true_single:  't',
-      true_yes:     'yes',
-      false_text:   'false',
-      false_single: 'f',
-      false_no:     'no',
-    }
-
-    environment_hash = SystemEnvironment.inject_into(source_hash)
-
-    expect(environment_hash['true_text']).to    be_a TrueClass
-    expect(environment_hash['true_single']).to  be_a TrueClass
-    expect(environment_hash['true_yes']).to     be_a TrueClass
-    expect(environment_hash['false_text']).to   be_a FalseClass
-    expect(environment_hash['false_single']).to be_a FalseClass
-    expect(environment_hash['false_no']).to     be_a FalseClass
-  end
 end
 end

data/spec/lib/chamber_spec.rb

@@ -23,6 +23,13 @@ test:
   HEREDOC
 end
 
+File.open('/tmp/chamber/secure.yml', 'w+') do |file|
+  file.puts <<-HEREDOC
+test:
+  _secure_my_encrpyted_setting: cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==
+  HEREDOC
+end
+
 File.open('/tmp/chamber/credentials.yml', 'w+') do |file|
   file.puts <<-HEREDOC
 test:
@@ -71,19 +78,19 @@ only_namespaced_sub_settings:
   HEREDOC
 end
 
-describe Chamber, :singletons => [Chamber] do
+describe Chamber do
   before(:each) { Chamber.load(:basepath => '/tmp/chamber') }
 
   it 'knows how to load itself with a path string' do
     Chamber.load(:basepath => '/tmp/chamber')
 
-    expect(Chamber.basepath.to_s).to eql '/tmp/chamber'
+    expect(Chamber.configuration.basepath.to_s).to eql '/tmp/chamber'
   end
 
   it 'knows how to load itself with a path object' do
     Chamber.load(:basepath => Pathname.new('/tmp/chamber'))
 
-    expect(Chamber.basepath.to_s).to eql '/tmp/chamber'
+    expect(Chamber.configuration.basepath.to_s).to eql '/tmp/chamber'
   end
 
   it 'processes settings files through ERB before YAML' do
@@ -95,11 +102,11 @@ describe Chamber, :singletons => [Chamber] do
   end
 
   it 'can access the settings through method-based access' do
-    expect(Chamber.instance.test.my_setting).to eql 'my_value'
+    expect(Chamber.test.my_setting).to eql 'my_value'
   end
 
-  it 'can access the instance via "env"' do
-    expect(Chamber.instance.test.my_setting).to eql 'my_value'
+  it 'can access the settings via "env"' do
+    expect(Chamber.env.test.my_setting).to eql 'my_value'
   end
 
   it 'prefers values stored in environment variables over those in the YAML files' do
@@ -107,9 +114,9 @@ describe Chamber, :singletons => [Chamber] do
     ENV['TEST_ANOTHER_LEVEL_LEVEL_THREE_AN_ARRAY'] = 'something'
 
     Chamber.load(:basepath => '/tmp/chamber')
-    expect(Chamber.instance.test.my_setting).to eql 'some_other_value'
-    expect(Chamber.instance.test.another_level.level_three.an_array).to eql 'something'
-    expect(Chamber.instance.test.my_dynamic_setting).to eql 2
+    expect(Chamber.test.my_setting).to eql 'some_other_value'
+    expect(Chamber.test.another_level.level_three.an_array).to eql 'something'
+    expect(Chamber.test.my_dynamic_setting).to eql 2
 
     ENV.delete 'TEST_MY_SETTING'
     ENV.delete 'TEST_ANOTHER_LEVEL_LEVEL_THREE_AN_ARRAY'
@@ -120,8 +127,8 @@ describe Chamber, :singletons => [Chamber] do
                   :namespaces => {
                     :my_namespace => -> { 'blue' } } )
 
-    expect(Chamber.instance.other.everything).to eql 'works'
-    expect(Chamber.instance.test.my_dynamic_setting).to eql 2
+    expect(Chamber.other.everything).to        eql 'works'
+    expect(Chamber.test.my_dynamic_setting).to eql 2
   end
 
   it 'loads multiple namespaces if it is called twice' do
@@ -130,7 +137,7 @@ describe Chamber, :singletons => [Chamber] do
                     :first_namespace_call  => -> { :first },
                     :second_namespace_call => -> { :second }, } )
 
-    expect(Chamber.instance.namespaces.to_a).to eql [:first, :second]
+    expect(Chamber.namespaces.to_a).to eql ['first', 'second']
   end
 
   it 'does not load the same namespace twice' do
@@ -139,7 +146,7 @@ describe Chamber, :singletons => [Chamber] do
                     :first_namespace_call => -> { :first },
                     :first_namespace_call => -> { :first }, } )
 
-    expect(Chamber.instance.namespaces.to_a).to eql [:first]
+    expect(Chamber.namespaces.to_a).to eql ['first']
   end
 
   it 'will load settings files which are only namespaced' do
@@ -163,7 +170,7 @@ describe Chamber, :singletons => [Chamber] do
   end
 
   it 'still raises an error if you try to send a message which the settings hash does not understand' do
-    expect{ Chamber.instance.i_do_not_know }.to raise_error NoMethodError
+    expect{ Chamber.env.i_do_not_know }.to raise_error NoMethodError
   end
 
   it 'does not raise an exception if a namespaced file does not exist' do
@@ -179,13 +186,13 @@ describe Chamber, :singletons => [Chamber] do
                   :namespaces => {
                     :my_namespace => -> { 'blue' } } )
 
-    expect(Chamber.instance.test.my_setting).to                eql 'my_value'
-    expect(Chamber.instance.test.my_other_setting).to          eql 'my_other_value'
-    expect(Chamber.instance.test.another_level.setting_one).to eql 3
+    expect(Chamber.test.my_setting).to                eql 'my_value'
+    expect(Chamber.test.my_other_setting).to          eql 'my_other_value'
+    expect(Chamber.test.another_level.setting_one).to eql 3
   end
 
   it 'loads YAML files from the "settings" directory under the base directory if any exist' do
-    expect(Chamber.instance.sub_settings.my_sub_setting).to eql 'my_sub_setting_value'
+    expect(Chamber.sub_settings.my_sub_setting).to eql 'my_sub_setting_value'
   end
 
   it 'does not load YAML files from the "settings" directory if it is namespaced' do
@@ -253,16 +260,16 @@ describe Chamber, :singletons => [Chamber] do
   end
 
   it 'can notify properly whether it responds to messages if the underlying settings does' do
-    expect(Chamber.env.respond_to?(:sub_settings)).to be_a TrueClass
+    expect(Chamber.respond_to?(:sub_settings)).to be_a TrueClass
   end
 
   it 'can explicitly specify files without specifying a basepath' do
     Chamber.load files: ['/tmp/chamber/credentials.yml']
 
-    expect(Chamber.filenames).to eql  ['/tmp/chamber/credentials.yml']
-    expect(Chamber.settings.to_hash).to eql('test' => {
-                                              'my_username' => 'username',
-                                              'my_password' => 'password', } )
+    expect(Chamber.filenames).to    eql ['/tmp/chamber/credentials.yml']
+    expect(Chamber.to_hash).to  eql('test' => {
+                                      'my_username' => 'username',
+                                      'my_password' => 'password', } )
   end
 
   it 'ignores the basepath if file patterns are explicitly passed in' do
@@ -273,14 +280,21 @@ describe Chamber, :singletons => [Chamber] do
   end
 
   it 'can render itself as a string even if it has not been loaded' do
-    Singleton.__init__(Chamber)
+    Chamber.load
 
     expect(Chamber.to_s).to eql ''
   end
 
   it 'can determine settings even if it has not been loaded' do
-    Singleton.__init__(Chamber)
+    Chamber.load
+
+    expect(Chamber.to_hash).to eql({})
+  end
+
+  it 'can unencrpyt an already encrpyted value if it has access to the private key' do
+    Chamber.load(files:           '/tmp/chamber/secure.yml',
+                 decryption_key:  './spec/spec_key')
 
-    expect(Chamber.settings.to_hash).to eql({})
+    expect(Chamber.test.my_encrpyted_setting).to eql 'hello'
   end
 end