chamber 2.4.0 → 2.7.1

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

@@ -5,26 +5,26 @@ module    Chamber
 module    Filters
 describe  InsecureFilter do
   it 'will return values which are marked as "secure" if they are unencrypted' do
-    filtered_settings = InsecureFilter.execute( data: {
-                                                  _secure_my_secure_setting: 'hello' })
+    filtered_settings = InsecureFilter.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 = InsecureFilter.execute( data: {
-                                                  my_secure_setting: 'hello' })
+    filtered_settings = InsecureFilter.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 = InsecureFilter.execute( data: {
-                                                  _secure_setting: 'hello',
-                                                  secure_setting:  'goodbye',
-                                                  secure_group: {
-                                                    _secure_nested_setting:  'movie',
-                                                    insecure_nested_setting: 'dinner' }})
+    filtered_settings = InsecureFilter.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
@@ -33,14 +33,34 @@ describe  InsecureFilter do
   end
 
   it 'will not return values which are encrypted' do
-    filtered_settings = InsecureFilter.execute( data: {
-                                                  _secure_setting:       'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
-                                                  secure_setting:        'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
-                                                  _secure_other_setting: 'hello',
-                                                  secure_group: {
-                                                    _secure_nested_setting:       'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
-                                                    _secure_other_nested_setting: 'goodbye',
-                                                    insecure_nested_setting:      'dinner' }})
+    filtered_settings = InsecureFilter.execute(
+      data: {
+        _secure_setting:       'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpss' \
+                               'pg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzC' \
+                               'MJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YG' \
+                               'DJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6ag' \
+                               'y1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMn' \
+                               'gJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfN' \
+                               'xMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
+        secure_setting:        'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpss' \
+                               'pg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzC' \
+                               'MJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YG' \
+                               'DJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6ag' \
+                               'y1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMn' \
+                               'gJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfN' \
+                               'xMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
+        _secure_other_setting: 'hello',
+        secure_group:          {
+          _secure_nested_setting:       'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYTh' \
+                                        'aV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4' \
+                                        'akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGy' \
+                                        'dkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9' \
+                                        'ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8' \
+                                        'QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZ' \
+                                        'gfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMn' \
+                                        'z84XzmUp2Y0H1jPgGkBKQJKArfQ==',
+          _secure_other_nested_setting: 'goodbye',
+          insecure_nested_setting:      'dinner' } })
 
     expect(filtered_settings._secure_setting?).to                          eql false
     expect(filtered_settings.secure_setting?).to                           eql false

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

@@ -6,67 +6,67 @@ module    Chamber
 module    Filters
 describe  NamespaceFilter do
   it 'can filter settings data based on the settings namespaces' do
-    filtered_settings = NamespaceFilter.execute(data: {
-                                                  namespace_value: {
-                                                    namespace_setting: 'value 1' },
-                                                  other_namespace_value: {
-                                                    other_namespace_setting: 'value 2' }},
-                                                namespaces: [
-                                                  'namespace_value',
-                                                  'other_namespace_value' ])
+    filtered_settings = NamespaceFilter.execute(
+      data:       {
+        namespace_value:       {
+          namespace_setting: 'value 1' },
+        other_namespace_value: {
+          other_namespace_setting: 'value 2' } },
+      namespaces: %w{namespace_value other_namespace_value})
 
     expect(filtered_settings.namespace_setting).to eql 'value 1'
     expect(filtered_settings.other_namespace_setting).to eql 'value 2'
   end
 
   it 'ignores data which is not part of a namespace' do
-    filtered_settings = NamespaceFilter.execute(data: {
-                                                  namespace_value: {
-                                                    namespace_setting: 'value 1' },
-                                                  non_namespaced_value: {
-                                                    non_namespaced_setting: 'value 2' }},
-                                                namespaces: [
-                                                  'namespace_value' ])
+    filtered_settings = NamespaceFilter.execute(
+      data:       {
+        namespace_value:      {
+          namespace_setting: 'value 1' },
+        non_namespaced_value: {
+          non_namespaced_setting: 'value 2' } },
+      namespaces: [
+        'namespace_value'])
 
     expect(filtered_settings.namespace_setting).to eql 'value 1'
     expect(filtered_settings.non_namespaced_setting).to be_nil
   end
 
   it 'ignores namespaces which do not exist in the data' do
-    filtered_settings = NamespaceFilter.execute(data: {
-                                                  namespace_value: {
-                                                    namespace_setting: 'value 1' }},
-                                                namespaces: [
-                                                  'namespace_value',
-                                                  'other_namespace_value' ])
+    filtered_settings = NamespaceFilter.execute(
+      data:       {
+        namespace_value: {
+          namespace_setting: 'value 1' } },
+      namespaces: %w{namespace_value other_namespace_value})
 
     expect(filtered_settings.namespace_setting).to eql 'value 1'
   end
 
   it 'does not filter data if it does not include any namespaces' do
-    filtered_settings = NamespaceFilter.execute(data: {
-                                                  non_namespaced_setting: 'value 1' },
-                                                namespaces: [])
+    filtered_settings = NamespaceFilter.execute(
+      data:       {
+        non_namespaced_setting: 'value 1' },
+      namespaces: [])
 
     expect(filtered_settings.non_namespaced_setting).to eql 'value 1'
   end
 
   it 'can filter if it is given NamespaceSets' do
-    filtered_settings = NamespaceFilter.execute(data: {
-                                                  namespace_value: {
-                                                    namespace_setting:            'value 1',
-                                                    another_namespace_setting:    'value 2' },
-                                                  other_namespace_value: {
-                                                    namespace_setting_1:          'value 1',
-                                                    another_namespace_setting_2:  'value 2' },
-                                                  non_namespaced_value:           'value 3' },
-                                                namespaces:
-                                                  NamespaceSet.new(['namespace_value', 'other_namespace_value']) )
+    filtered_settings = NamespaceFilter.execute(
+      data:       {
+        namespace_value:       {
+          namespace_setting:         'value 1',
+          another_namespace_setting: 'value 2' },
+        other_namespace_value: {
+          namespace_setting_1:         'value 1',
+          another_namespace_setting_2: 'value 2' },
+        non_namespaced_value:  'value 3' },
+      namespaces: NamespaceSet.new(%w{namespace_value other_namespace_value}))
 
-    expect(filtered_settings.to_hash).to eql( 'namespace_setting'           => 'value 1',
-                                              'another_namespace_setting'   => 'value 2',
-                                              'namespace_setting_1'         => 'value 1',
-                                              'another_namespace_setting_2' => 'value 2')
+    expect(filtered_settings.to_hash).to eql('namespace_setting'           => 'value 1',
+                                             'another_namespace_setting'   => 'value 2',
+                                             'namespace_setting_1'         => 'value 1',
+                                             'another_namespace_setting_2' => 'value 2')
   end
 end
 end

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

@@ -5,26 +5,26 @@ 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' })
+    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' })
+    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' }})
+    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

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

@@ -5,22 +5,25 @@ module    Chamber
 module    Filters
 describe  TranslateSecureKeysFilter do
   it 'will translate keys if they start with "_secure_"' do
-    filtered_settings = TranslateSecureKeysFilter.execute( data: {
-                                                    _secure_my_secure_setting: 'hello' })
+    filtered_settings = TranslateSecureKeysFilter.execute(
+      data: {
+        _secure_my_secure_setting: 'hello' })
 
     expect(filtered_settings.my_secure_setting).to eql 'hello'
   end
 
   it 'will not translate keys if they do not start with "_secure_"' do
-    filtered_settings = TranslateSecureKeysFilter.execute( data: {
-                                                    my_secure_setting: 'hello' })
+    filtered_settings = TranslateSecureKeysFilter.execute(
+      data: {
+        my_secure_setting: 'hello' })
 
     expect(filtered_settings.my_secure_setting).to eql 'hello'
   end
 
   it 'will not translate the key if it starts with "secure"' do
-    filtered_settings = TranslateSecureKeysFilter.execute( data: {
-                                                    secure_setting: 'hello' })
+    filtered_settings = TranslateSecureKeysFilter.execute(
+      data: {
+        secure_setting: 'hello' })
 
     expect(filtered_settings.secure_setting).to eql 'hello'
   end

data/spec/lib/chamber/namespace_set_spec.rb

@@ -4,8 +4,8 @@ require 'chamber/namespace_set'
 module    Chamber
 describe  NamespaceSet do
   it 'can create a set from from a hash' do
-    namespace_set = NamespaceSet.new( environment:  :development,
-                                      hostname:     'my host')
+    namespace_set = NamespaceSet.new(environment: :development,
+                                     hostname:    'my host')
 
     expect(namespace_set).to eq ['development', 'my host']
   end
@@ -50,7 +50,9 @@ describe  NamespaceSet do
     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
+  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)
 
@@ -105,11 +107,11 @@ describe  NamespaceSet do
   end
 
   it 'will process a value by executing it if it is a callable' do
-    namespace_set = NamespaceSet[ -> { '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

data/spec/lib/chamber/settings_spec.rb

@@ -4,28 +4,28 @@ require 'chamber/settings'
 module    Chamber
 describe  Settings do
   it 'can verify that it is equal to another Settings object' do
-    settings        = Settings.new( settings:   {setting: 'value'},
-                                    namespaces: ['good'])
-    other_settings  = Settings.new( settings:   {setting: 'value'},
-                                    namespaces: ['good'])
+    settings        = Settings.new(settings:   { setting: 'value' },
+                                   namespaces: ['good'])
+    other_settings  = Settings.new(settings:   { setting: 'value' },
+                                   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: ['good'])
-    other_settings  = Settings.new( settings:   {setting: 'value'},
-                                    namespaces: ['bad'])
+    settings        = Settings.new(settings:   { setting: 'value' },
+                                   namespaces: ['good'])
+    other_settings  = Settings.new(settings:   { setting: 'value' },
+                                   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: ['good'])
-    other_settings  = Settings.new( settings:   {setting: 'value 1'},
-                                    namespaces: ['good'])
+    settings        = Settings.new(settings:   { setting: 'value' },
+                                   namespaces: ['good'])
+    other_settings  = Settings.new(settings:   { setting: 'value 1' },
+                                   namespaces: ['good'])
 
     expect(settings).not_to eql other_settings
   end
@@ -34,11 +34,11 @@ describe  Settings do
     settings = Settings.new(settings: {
                               my_setting: 'value',
                               level_1:    {
-                                level_2:    {
+                                level_2: {
                                   some_setting: 'hello',
                                   another:      'goodbye',
                                 },
-                                body:       'gracias',
+                                body:    'gracias',
                               },
                               there:      'was not that easy?',
                             })
@@ -52,45 +52,53 @@ describe  Settings do
     )
   end
 
-  it 'sorts environment variables by name when converted to an environment hash so that they are easier to parse for humans' do
+  it 'sorts environment variables by name when converted to an environment hash so ' \
+     'that they are easier to parse for humans' do
+
     settings = Settings.new(settings: { 'C' => 'value',
                                         'D' => 'value',
                                         'A' => 'value',
                                         'E' => 'value',
                                         'B' => 'value' })
 
-    expect(settings.to_environment.to_a).to eql([['A', 'value'],
-                                                 ['B', 'value'],
-                                                 ['C', 'value'],
-                                                 ['D', 'value'],
-                                                 ['E', 'value']])
+    expect(settings.to_environment.to_a).to eql([%w{A value},
+                                                 %w{B value},
+                                                 %w{C value},
+                                                 %w{D value},
+                                                 %w{E value}])
   end
 
   it 'can convert itself into a string' do
     settings = Settings.new(settings: {
                               my_setting: 'value',
                               level_1:    {
-                                level_2:    {
+                                level_2: {
                                   some_setting: 'hello',
                                   another:      'goodbye',
                                 },
-                                body:       'gracias',
+                                body:    'gracias',
                               },
                               there:      'was not that easy?',
                             })
 
-    expect(settings.to_s).to eql %Q{LEVEL_1_BODY="gracias" LEVEL_1_LEVEL_2_ANOTHER="goodbye" LEVEL_1_LEVEL_2_SOME_SETTING="hello" MY_SETTING="value" THERE="was not that easy?"}
+    expect(settings.to_s).to eql %w{
+      LEVEL_1_BODY="gracias"
+      LEVEL_1_LEVEL_2_ANOTHER="goodbye"
+      LEVEL_1_LEVEL_2_SOME_SETTING="hello"
+      MY_SETTING="value"
+      THERE="was not that easy?"
+    }.join(' ')
   end
 
   it 'can convert itself into a string with custom options' do
     settings = Settings.new(settings: {
                               my_setting: 'value',
                               level_1:    {
-                                level_2:    {
+                                level_2: {
                                   some_setting: 'hello',
                                   another:      'goodbye',
                                 },
-                                body:       'gracias',
+                                body:    'gracias',
                               },
                               there:      'was not that easy?',
                             })
@@ -110,32 +118,32 @@ HEREDOC
   end
 
   it 'can merge itself with a hash' do
-    settings        = Settings.new(settings: {setting: 'value'})
+    settings        = Settings.new(settings: { setting: 'value' })
     other_settings  = { other_setting: 'another value' }
 
     merged_settings = settings.merge(other_settings)
 
     expect(merged_settings).to eq('setting'       => 'value',
-                                   'other_setting' => 'another value')
+                                  'other_setting' => 'another value')
   end
 
   it 'can merge itself with Settings' do
-    settings       = Settings.new(settings:   {setting:       'value'},
+    settings       = Settings.new(settings:   { setting:       'value' },
                                   namespaces: ['good'])
-    other_settings = Settings.new(settings:   {other_setting: 'another value'},
+    other_settings = Settings.new(settings:   { other_setting: 'another value' },
                                   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'])
+                                                  setting:       'value',
+                                                  other_setting: 'another value' },
+                                                namespaces: %w{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       = Settings.new(settings:   { setting:       'value' })
+    other_settings = Settings.new(settings:   { other_setting: 'another value' })
 
     merged_settings = settings.merge(other_settings)
 
@@ -144,7 +152,7 @@ HEREDOC
   end
 
   it 'can convert itself into a hash' do
-    settings = Settings.new(settings: {setting: 'value'})
+    settings = Settings.new(settings: { setting: 'value' })
 
     expect(settings.to_hash).to     eql('setting' => 'value')
     expect(settings.to_hash).to     be_a Hash
@@ -155,28 +163,30 @@ HEREDOC
     settings = Settings.new(settings: {
                               my_setting: 'value',
                               level_1:    {
-                                level_2:    {
+                                level_2: {
                                   some_setting: 'hello',
                                   another:      'goodbye',
                                 },
-                                body:       'gracias',
+                                body:    'gracias',
                               },
                               there:      'was not that easy?',
                             })
 
     expect(settings.to_flattened_name_hash).to     eql(
-      ['my_setting']                         => 'value',
-      ['level_1', 'level_2', 'some_setting'] => 'hello',
-      ['level_1', 'level_2', 'another']      => 'goodbye',
-      ['level_1', 'body']                    => 'gracias',
-      ['there']                              => 'was not that easy?',
+      %w{my_setting}                   => 'value',
+      %w{level_1 level_2 some_setting} => 'hello',
+      %w{level_1 level_2 another}      => 'goodbye',
+      %w{level_1 body}                 => 'gracias',
+      %w{there}                        => 'was not that easy?',
     )
     expect(settings.to_flattened_name_hash).to     be_a Hash
     expect(settings.to_flattened_name_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'})
+  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'
@@ -186,60 +196,69 @@ HEREDOC
   end
 
   it 'allows messages to be passed through to the underlying data' do
-    settings = Settings.new(settings: {setting: 'value'})
+    settings = Settings.new(settings: { setting: 'value' })
 
     expect(settings.setting).to eql 'value'
   end
 
   it 'will still raise an error if the underlying data does not respond to it' do
-    settings = Settings.new(settings: {setting: 'value'})
+    settings = Settings.new(settings: { setting: 'value' })
 
     expect { settings.unknown }.to raise_error NoMethodError
   end
 
   it 'can notify properly whether it responds to messages if the underlying data does' do
-    settings = Settings.new(settings: {setting: 'value'})
+    settings = Settings.new(settings: { setting: 'value' })
 
     expect(settings.respond_to?(:setting)).to be_a TrueClass
   end
 
   it 'only includes namespaced data if any exists' do
     settings = Settings.new(settings:   {
-                              namespace_value:        {
-                                namespace_setting:        'value' },
-                              other_namespace_value:  {
-                                other_namespace_setting:  'value' },
-                              non_namespace_setting:  'other value'
+                              namespace_value:       {
+                                namespace_setting: 'value' },
+                              other_namespace_value: {
+                                other_namespace_setting: 'value' },
+                              non_namespace_setting: 'other value',
                             },
-                            namespaces: ['namespace_value', 'other_namespace_value'])
+                            namespaces: %w{namespace_value other_namespace_value})
 
-    expect(settings).to eq('namespace_setting' => 'value',
-                             'other_namespace_setting' => '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')
+    settings = Settings.new(
+      settings:       {
+        _secure_my_encrypted_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYTha' \
+                                      'V4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4ak' \
+                                      'un6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkE' \
+                                      'jY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8M' \
+                                      'v4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/' \
+                                      '1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86' \
+                                      'wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmU' \
+                                      'p2Y0H1jPgGkBKQJKArfQ==',
+      },
+      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'
+    settings = Settings.new(settings:       {
+                              _secure_my_encrypted_setting: 'hello',
                             },
                             encryption_key: './spec/spec_key.pub',
                             pre_filters:    [],
-                            post_filters:   [ Filters::EncryptionFilter ])
+                            post_filters:   [Filters::EncryptionFilter])
 
-    expect(settings._secure_my_encrypted_setting).to match Filters::EncryptionFilter::BASE64_STRING_PATTERN
+    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'
+    settings = Settings.new(settings:       {
+                              _secure_my_encrypted_setting: 'hello',
                             },
                             decryption_key: './spec/spec_key',
                             encryption_key: './spec/spec_key.pub')
@@ -248,22 +267,31 @@ HEREDOC
 
     secure_settings = settings.secure
 
-    expect(secure_settings.my_encrypted_setting).to match Filters::EncryptionFilter::BASE64_STRING_PATTERN
+    expect(secure_settings.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'})
+    settings = Settings.new(settings: { setting: 'value' })
 
     expect(settings).to eq('setting' => 'value')
   end
 
   it 'can filter securable settings' do
-    settings = Settings.new(settings: {
-                              _secure_my_encrypted_setting:   'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
-                              _secure_my_unencrypted_setting: 'nifty',
-                              my_insecure_setting:            'goodbye',
-                            },
-                            decryption_key: './spec/spec_key')
+    settings = Settings.new(
+      settings:       {
+        _secure_my_encrypted_setting:   'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYTha' \
+                                        'V4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4ak' \
+                                        'un6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkE' \
+                                        'jY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8M' \
+                                        'v4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/' \
+                                        '1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86' \
+                                        'wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmU' \
+                                        'p2Y0H1jPgGkBKQJKArfQ==',
+        _secure_my_unencrypted_setting: 'nifty',
+        my_insecure_setting:            'goodbye',
+      },
+      decryption_key: './spec/spec_key')
 
     secured_settings = settings.securable
 
@@ -273,12 +301,20 @@ HEREDOC
   end
 
   it 'can filter unencrypted settings' do
-    settings = Settings.new(settings: {
-                              _secure_my_encrypted_setting:   'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
-                              _secure_my_unencrypted_setting: 'nifty',
-                              my_insecure_setting:            'goodbye',
-                            },
-                            decryption_key: './spec/spec_key')
+    settings = Settings.new(
+      settings:       {
+        _secure_my_encrypted_setting:   'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYTha' \
+                                        'V4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4ak' \
+                                        'un6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkE' \
+                                        'jY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8M' \
+                                        'v4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/' \
+                                        '1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86' \
+                                        'wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmU' \
+                                        'p2Y0H1jPgGkBKQJKArfQ==',
+        _secure_my_unencrypted_setting: 'nifty',
+        my_insecure_setting:            'goodbye',
+      },
+      decryption_key: './spec/spec_key')
 
     secured_settings = settings.insecure
 
@@ -286,5 +322,58 @@ HEREDOC
     expect(secured_settings.my_unencrypted_setting).to  eql 'nifty'
     expect(secured_settings.my_insecure_setting?).to    eql false
   end
+
+  it 'raises an exception when it accesses a value which cannot be decrypted' do
+    settings = Settings.new(
+      settings: {
+        _secure_my_encrypted_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYTha' \
+                                      'V4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4ak' \
+                                      'un6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkE' \
+                                      'jY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8M' \
+                                      'v4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/' \
+                                      '1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86' \
+                                      'wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmU' \
+                                      'p2Y0H1jPgGkBKQJKArfQ==',
+      },
+    )
+
+    expect { settings.my_encrypted_setting }.
+    to raise_error Chamber::Errors::DecryptionFailure
+  end
+
+  it 'prefers environment variable values over encrypted values' do
+    ENV['MY_ENCRYPTED_SETTING']                       = 'my env setting'
+    ENV['ENCRYPTED_GROUP_MY_ENCRYPTED_GROUP_SETTING'] = 'my env group'
+
+    settings = Settings.new(
+      settings: {
+        _secure_my_encrypted_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYTha' \
+                                      'V4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4ak' \
+                                      'un6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkE' \
+                                      'jY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8M' \
+                                      'v4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/' \
+                                      '1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86' \
+                                      'wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmU' \
+                                      'p2Y0H1jPgGkBKQJKArfQ==',
+        encrypted_group:              {
+          _secure_my_encrypted_group_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdn' \
+                                              'MoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3Fx' \
+                                              'ptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEA' \
+                                              'QLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUT' \
+                                              'f34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5k' \
+                                              'LAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlz' \
+                                              'pKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgU' \
+                                              'Kc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84Xz' \
+                                              'mUp2Y0H1jPgGkBKQJKArfQ==',
+        },
+      },
+    )
+
+    expect(settings.my_encrypted_setting).to                       eql 'my env setting'
+    expect(settings.encrypted_group.my_encrypted_group_setting).to eql 'my env group'
+
+    ENV['MY_ENCRYPTED_SETTING']                       = nil
+    ENV['ENCRYPTED_GROUP_MY_ENCRYPTED_GROUP_SETTING'] = nil
+  end
 end
 end