chamber 0.0.4 → 1.0.0

data/spec/lib/chamber/namespace_set_spec.rb

@@ -0,0 +1,81 @@
+require 'rspectacular'
+require 'chamber/namespace_set'
+
+class     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']
+  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']
+  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']
+  end
+
+  it 'can turn itself into an array' do
+    namespace_set = NamespaceSet.new([: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'])
+    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 'does not modify the set in place if combining with another array' do
+    namespace_set = NamespaceSet.new([:development, 'my host'])
+    other_set     = Set['other value', 3]
+    combined_set  = namespace_set + other_set
+
+    expect(combined_set.object_id).not_to eq namespace_set.object_id
+  end
+
+  it 'can combine itself with something that can be converted to an array' do
+    namespace_set = NamespaceSet.new([:development, 'my host'])
+    other_set     = (1..3)
+    combined_set  = namespace_set + other_set
+
+    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])
+
+    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' } ])
+
+    expect(namespace_set).to eq ['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])
+
+    expect(namespace_set).to eql other_namespace_set
+  end
+end
+end

data/spec/lib/chamber/settings_spec.rb

@@ -0,0 +1,135 @@
+require 'rspectacular'
+require 'chamber/settings'
+
+class     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']))
+    other_settings  = Settings.new( settings:   {setting: 'value'},
+                                    namespaces: NamespaceSet.new(['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']))
+    other_settings  = Settings.new( settings:   {setting: 'value'},
+                                    namespaces: NamespaceSet.new(['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']))
+    other_settings  = Settings.new( settings:   {setting: 'value 1'},
+                                    namespaces: NamespaceSet.new(['good']))
+
+    expect(settings).not_to eql other_settings
+  end
+
+  it 'knows how to convert itself into an environment hash' do
+    allow(SystemEnvironment).to receive(:extract_from).
+                                and_return(:environment => :development)
+
+    settings = Settings.new(settings: {setting: 'value'})
+
+    expect(settings.to_environment).to  eql(:environment => :development)
+    expect(SystemEnvironment).to        have_received(:extract_from).
+                                        with(Hashie::Mash.new setting: 'value')
+  end
+
+  it 'sorts environment variables by name when converted to an environment hash so that they are easier to parse for humans' do
+    allow(SystemEnvironment).to receive(:extract_from).
+                                and_return('C' => 'value',
+                                           'D' => 'value',
+                                           'A' => 'value',
+                                           'E' => 'value',
+                                           'B' => 'value',)
+
+    settings = Settings.new(settings: { setting: 'value' })
+
+    expect(settings.to_environment.to_a).to eql([['A', 'value'],
+                                                 ['B', 'value'],
+                                                 ['C', 'value'],
+                                                 ['D', 'value'],
+                                                 ['E', 'value']])
+  end
+
+  it 'can convert itself into a string' do
+    allow(SystemEnvironment).to receive(:extract_from).
+                                and_return('C' => 'cv',
+                                           'D' => 'dv',
+                                           'A' => 'av',
+                                           'E' => 'ev',
+                                           'B' => 'bv',)
+
+    settings = Settings.new(settings: { setting: 'value' })
+
+    expect(settings.to_s).to eql %Q{A="av" B="bv" C="cv" D="dv" E="ev"}
+  end
+
+  it 'can merge itself with a hash' do
+    settings = Settings.new(settings: {setting: 'value'})
+    settings.merge!(other_setting: 'another value')
+
+    expect(settings.to_hash).to eql Hashie::Mash.new( setting:        'value',
+                                                      other_setting:  'another value')
+  end
+
+  it 'can merge itself with Settings' do
+    settings       = Settings.new(settings:   {setting:       'value'},
+                                  namespaces: NamespaceSet.new(['good']))
+
+    other_settings = Settings.new(settings:   {other_setting: 'another value'},
+                                  namespaces: NamespaceSet.new(['bad']))
+
+    settings.merge!(other_settings)
+
+    expect(settings).to eql Settings.new( settings:   {
+                                            setting:        'value',
+                                            other_setting:  'another value' },
+                                          namespaces: NamespaceSet.new(['good', 'bad']))
+  end
+
+  it 'can convert itself into a hash' do
+    settings = Settings.new(settings: {setting: 'value'})
+
+    expect(settings.to_hash).to eql('setting' => 'value')
+  end
+
+  it 'allows messages to be passed through to the underlying data' do
+    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'})
+
+    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'})
+
+    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'
+                            },
+                            namespaces: NamespaceSet.new(['namespace_value', 'other_namespace_value']))
+
+    expect(settings.to_hash).to eql('namespace_setting'       => 'value',
+                                    'other_namespace_setting' => 'value')
+  end
+end
+end

data/spec/lib/chamber/system_environment_spec.rb

@@ -0,0 +1,121 @@
+require 'rspectacular'
+require 'chamber/system_environment'
+
+class     Chamber
+describe  SystemEnvironment do
+  it 'can extract environment variables based on a hash that is passed in' do
+    source_hash = {
+      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' }
+    }
+
+    expect(SystemEnvironment.extract_from(source_hash)).to eql({
+      'LEVEL_ONE_1_LEVEL_TWO_1'               => 'value 1',
+      'LEVEL_ONE_1_LEVEL_TWO_2_LEVEL_THREE_1' => 'value 2',
+      'LEVEL_ONE_1_LEVEL_TWO_2_LEVEL_THREE_2' => 'value 3',
+      'LEVEL_ONE_1_LEVEL_TWO_3'               => 'value 4',
+      'LEVEL_ONE_1_LEVEL_ONE_2'               => 'value 5',
+    })
+  end
+
+  it 'converts all items to strings so that they are usable as an environment variable' do
+    source_hash = {
+      value_one: Time.utc(2013, 10, 8, 18, 0, 1),
+      value_two: 3,
+    }
+
+    expect(SystemEnvironment.extract_from(source_hash)).to eql({
+      'VALUE_ONE' => '2013-10-08 18:00:01 UTC',
+      'VALUE_TWO' => '3',
+    })
+  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',
+    }
+
+    environment_hash = SystemEnvironment.extract_from(source_hash, [:prefix])
+
+    expect(environment_hash).to eql({
+      '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

@@ -1,250 +1,286 @@
-require 'spec_helper'
+require 'rspectacular'
+require 'chamber'
+require 'fileutils'
 
-require 'tempfile'
+FileUtils.mkdir_p '/tmp/chamber/settings' unless File.exist? '/tmp/chamber/settings'
 
-class Settings
-  extend Chamber
+File.open('/tmp/chamber/settings.yml', 'w+') do |file|
+  file.puts <<-HEREDOC
+test:
+  my_setting: my_value
+  my_boolean: "false"
+  my_dynamic_setting: <%= 1 + 1 %>
+  my_ftp_url: ftp://<%= Chamber[:test][:my_username] %>:<%= Chamber[:test][:my_password] %>@127.0.0.1
+  another_level:
+    setting_one: 1
+    setting_two: 2
+    level_three:
+      an_array:
+        - item 1
+        - item 2
+        - item 3
+      a_scalar: 'hello'
+  HEREDOC
+end
+
+File.open('/tmp/chamber/credentials.yml', 'w+') do |file|
+  file.puts <<-HEREDOC
+test:
+  my_username: username
+  my_password: password
+  HEREDOC
 end
 
-describe Chamber do
-  before do
-    Settings.clear!
-  end
-
-  describe '.source' do
-    context 'when an invalid option is specified' do
-      let(:options) do
-        { foo: 'bar' }
-      end
-
-      it 'raises ChamberInvalidOptionError' do
-        expect { Settings.source('filename', options) }.to raise_error(Chamber::ChamberInvalidOptionError)
-      end
-    end
-
-    context 'when no options are specified' do
-      it 'does not raise an error' do
-        expect { Settings.source('filename') }.not_to raise_error
-      end
-    end
-
-    context 'when valid options are specified' do
-      context 'and options only contains :namespace' do
-        let(:options) do
-          { namespace: 'bar' }
-        end
-
-        it 'does not raise an error' do
-          expect { Settings.source('filename', options) }.not_to raise_error
-        end
-      end
-
-      context 'and options only contains :override_from_environment' do
-        let(:options) do
-          { override_from_environment: 'bar' }
-        end
-
-        it 'does not raise an error' do
-          expect { Settings.source('filename', options) }.not_to raise_error
-        end
-      end
-
-      context 'and options contains both :namespace and :override_from_environment' do
-        let(:options) do
-          {
-            namespace: 'bar',
-            override_from_environment: 'bar'
-          }
-        end
-
-        it 'does not raise an error' do
-          expect { Settings.source('filename', options) }.not_to raise_error
-        end
-      end
-    end
-  end
-
-  describe '.load!' do
-    context 'when a non-existent file is specified' do
-      let(:file) { Tempfile.new('test') }
-      let!(:filename) { file.path }
-
-      before do
-        file.close
-        file.unlink
-        expect(File.exists?(filename)).to be_false
-        Settings.source filename
-      end
-
-      it 'does not raise an error' do
-        expect { Settings.load! }.not_to raise_error
-      end
-
-      it 'leaves the instance empty' do
-        Settings.load!
-        expect(Settings.instance).to be_empty
-      end
-    end
-
-    context 'when an existing file is specified' do
-      let(:file) { Tempfile.new('test') }
-      let(:filename) { file.path }
-      let(:content) do
-        <<-CONTENT
-secret:
-  environment: CHAMBER_TEST
-development:
-  foo: bar dev
+File.open('/tmp/chamber/settings-blue.yml', 'w+') do |file|
+  file.puts <<-HEREDOC
 test:
-  foo: bar test
-CONTENT
-      end
-
-      before do
-        file.write(content)
-        file.close
-      end
-
-      after do
-        file.unlink
-      end
-
-      context 'and no options are specified' do
-        before { Settings.source(filename) }
-
-        let(:expected) do
-          {
-            'secret' => {
-              'environment' => 'CHAMBER_TEST'
-            },
-            'development' => {
-              'foo' => 'bar dev'
-            },
-            'test' => {
-              'foo' => 'bar test'
-            }
-          }
-        end
-
-        it 'loads all settings' do
-          Settings.load!
-          expect(Settings.instance.to_hash).to eq expected
-        end
-
-        it 'provides access to all settings without the instance root' do
-          Settings.load!
-          expect(Settings.to_hash).to eq expected
-        end
-      end
-
-      context 'and the :namespace option is specified' do
-        before { Settings.source(filename, namespace: namespace) }
-
-        context 'and it is valid' do
-          let(:namespace) { 'development' }
-          let(:expected) do
-            {
-              'foo' => 'bar dev'
-            }
-          end
-
-          it 'loads settings for the specified namespace' do
-            Settings.load!
-            expect(Settings.instance.to_hash).to eq expected
-          end
-
-          it 'provides access to all settings without the instance root' do
-            Settings.load!
-            expect(Settings.to_hash).to eq expected
-          end
-        end
-
-        context 'and it is not valid' do
-          let(:namespace) { 'staging' }
-
-          it 'raises a KeyError' do
-            expect { Settings.load! }.to raise_error(KeyError)
-          end
-        end
-      end
-
-      context 'and the :override_from_environment option is specified' do
-        before { Settings.source(filename, override_from_environment: true) }
-
-        context 'and the environment variable is present' do
-          before { ENV['CHAMBER_TEST'] = 'value' }
-
-          it 'overrides the settings from the environment' do
-            Settings.load!
-            expect(Settings.instance.secret).to eq 'value'
-          end
-
-          it 'provides access to all settings without the instance root' do
-            Settings.load!
-            expect(Settings.secret).to eq 'value'
-          end
-        end
-
-        context 'and the environment variable is not present' do
-          before { ENV.delete('CHAMBER_TEST') }
-
-          it 'sets the value to nil' do
-            Settings.load!
-            expect(Settings.instance.secret).to be_nil
-          end
-
-          it 'provides acccess to all settings without the instance root' do
-            Settings.load!
-            expect(Settings.secret).to be_nil
-          end
-        end
-      end
-    end
-  end
-
-  describe '.reload!' do
-    context 'when a filename is changed after it is sourced and loaded' do
-      let(:file) { Tempfile.new('test') }
-      let!(:filename) { file.path }
-      let(:content) do
-        <<-CONTENT
-initial: value
-CONTENT
-      end
-      let(:modified) do
-        <<-MODIFIED
-modified: changed
-MODIFIED
-      end
-
-      before do
-        file.write(content)
-        file.close
-        Settings.source(filename)
-        Settings.load!
-      end
-
-      after do
-        file.unlink
-      end
-
-      it 'reloads the settings' do
-        File.open(filename, 'w') { |writer| writer.write(modified) }
-
-        expect { Settings.reload! }.to change { Settings.instance.to_hash }.from({ 'initial' => 'value' }).to({ 'modified' => 'changed' })
-      end
-    end
-  end
-
-  describe '.instance' do
-    it 'is a Hashie::Mash' do
-      expect(Settings.instance).to be_a(Hashie::Mash)
-    end
-  end
-
-  describe '.env' do
-    it 'is aliased to :instance' do
-      expect(Settings.method(:env)).to eq Settings.method(:instance)
-    end
+  my_other_setting: my_other_value
+  another_level:
+    setting_one: 3
+other:
+  everything: works
+  HEREDOC
+end
+
+File.open('/tmp/chamber/settings/some_settings_file.yml', 'w+') do |file|
+  file.puts <<-HEREDOC
+blue:
+  my_settings_for_inline_namespace: my_value_for_inline_namespace
+my_non_inline_namespaced_setting: my_value_for_non_inline_namespace
+  HEREDOC
+end
+
+File.open('/tmp/chamber/settings/sub_settings.yml', 'w+') do |file|
+  file.puts <<-HEREDOC
+sub_settings:
+  my_sub_setting: my_sub_setting_value
+  HEREDOC
+end
+
+File.open('/tmp/chamber/settings/sub_settings-blue.yml', 'w+') do |file|
+  file.puts <<-HEREDOC
+sub_settings:
+  my_namespaced_sub_setting: my_namespaced_sub_setting_value
+  HEREDOC
+end
+
+File.open('/tmp/chamber/settings/only_namespaced_settings-blue.yml', 'w+') do |file|
+  file.puts <<-HEREDOC
+only_namespaced_sub_settings:
+  another_sub_setting: namespaced
+  HEREDOC
+end
+
+describe Chamber, :singletons => [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'
+  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'
+  end
+
+  it 'processes settings files through ERB before YAML' do
+    expect(Chamber[:test][:my_dynamic_setting]).to eql 2
+  end
+
+  it 'can access settings through a hash-like syntax' do
+    expect(Chamber[:test][:my_setting]).to eql 'my_value'
+  end
+
+  it 'can access the settings through method-based access' do
+    expect(Chamber.instance.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'
+  end
+
+  it 'prefers values stored in environment variables over those in the YAML files' do
+    ENV['TEST_MY_SETTING'] = 'some_other_value'
+    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
+
+    ENV.delete 'TEST_MY_SETTING'
+    ENV.delete 'TEST_ANOTHER_LEVEL_LEVEL_THREE_AN_ARRAY'
+  end
+
+  it 'can load files based on the namespace passed in' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :my_namespace => -> { 'blue' } } )
+
+    expect(Chamber.instance.other.everything).to eql 'works'
+    expect(Chamber.instance.test.my_dynamic_setting).to eql 2
+  end
+
+  it 'loads multiple namespaces if it is called twice' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :first_namespace_call  => -> { :first },
+                    :second_namespace_call => -> { :second }, } )
+
+    expect(Chamber.instance.namespaces.to_a).to eql [:first, :second]
+  end
+
+  it 'does not load the same namespace twice' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :first_namespace_call => -> { :first },
+                    :first_namespace_call => -> { :first }, } )
+
+    expect(Chamber.instance.namespaces.to_a).to eql [:first]
+  end
+
+  it 'will load settings files which are only namespaced' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :my_namespace => -> { 'blue' } } )
+
+    expect(Chamber[:only_namespaced_sub_settings][:another_sub_setting]).to eql 'namespaced'
+  end
+
+  it 'clears all settings each time the settings are loaded' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :my_namespace => -> { 'blue' } } )
+
+    expect(Chamber[:only_namespaced_sub_settings][:another_sub_setting]).to eql 'namespaced'
+
+    Chamber.load(:basepath => '/tmp/chamber')
+
+    expect(Chamber[:only_namespaced_sub_settings]).to be_nil
+  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
+  end
+
+  it 'does not raise an exception if a namespaced file does not exist' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :non_existant_namespace => -> { false } } )
+
+    expect { Chamber.load(:basepath => '/tmp/chamber') }.not_to raise_error
+  end
+
+  it 'merges (not overrides) subsequent settings' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :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
+  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'
+  end
+
+  it 'does not load YAML files from the "settings" directory if it is namespaced' do
+    expect(Chamber['sub_settings-namespaced']).to be_nil
+  end
+
+  it 'loads namespaced YAML files in the "settings" directory if they correspond to a value namespace' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :my_namespace => -> { 'blue' } } )
+
+    expect(Chamber['sub_settings']['my_namespaced_sub_setting']).to eql 'my_namespaced_sub_setting_value'
+  end
+
+  it 'loads namespaced settings if they are inline in a non-namespaced filename' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :my_namespace => -> { 'blue' } } )
+
+    expect(Chamber['my_settings_for_inline_namespace']).to eql 'my_value_for_inline_namespace'
+  end
+
+  it 'does not load non-namespaced data from a file if inline namespaces are found' do
+    Chamber.load( :basepath   => '/tmp/chamber',
+                  :namespaces => {
+                    :my_namespace => -> { 'blue' } } )
+
+    expect(Chamber['my_non_inline_namespaced_setting']).not_to eql 'my_value_for_non_inline_namespace'
+  end
+
+  it 'loads the entire inline namespaced file if no namespaces are passed in since it does not know they are namespaced' do
+    Chamber.load(:basepath => '/tmp/chamber')
+
+    expect(Chamber['blue']['my_settings_for_inline_namespace']).to eql 'my_value_for_inline_namespace'
+    expect(Chamber['my_non_inline_namespaced_setting']).to         eql 'my_value_for_non_inline_namespace'
+  end
+
+  it 'can convert the settings to their environment variable versions' do
+    Chamber.load(:basepath => '/tmp/chamber')
+
+    expect(Chamber.to_environment).to eql(
+      'SUB_SETTINGS_MY_SUB_SETTING'             => 'my_sub_setting_value',
+      'TEST_ANOTHER_LEVEL_LEVEL_THREE_AN_ARRAY' => '["item 1", "item 2", "item 3"]',
+      'TEST_ANOTHER_LEVEL_LEVEL_THREE_A_SCALAR' => 'hello',
+      'TEST_ANOTHER_LEVEL_SETTING_ONE'          => '1',
+      'TEST_ANOTHER_LEVEL_SETTING_TWO'          => '2',
+      'TEST_MY_DYNAMIC_SETTING'                 => '2',
+      'TEST_MY_SETTING'                         => 'my_value',
+      'TEST_MY_FTP_URL'                         => 'ftp://username:password@127.0.0.1',
+      'TEST_MY_PASSWORD'                        => 'password',
+      'TEST_MY_SETTING'                         => 'my_value',
+      'TEST_MY_USERNAME'                        => 'username',
+      'TEST_MY_BOOLEAN'                         => 'false',
+      'BLUE_MY_SETTINGS_FOR_INLINE_NAMESPACE'   => 'my_value_for_inline_namespace',
+      'MY_NON_INLINE_NAMESPACED_SETTING'        => 'my_value_for_non_inline_namespace',
+    )
+  end
+
+  it 'can convert boolean-like strings to actual booleans' do
+    expect(Chamber[:test][:my_boolean]).to be_a FalseClass
+  end
+
+  it 'can use data from credentials in subsequently loaded files' do
+    expect(Chamber[:test][:my_ftp_url]).to eql 'ftp://username:password@127.0.0.1'
+  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
+  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', } )
+  end
+
+  it 'ignores the basepath if file patterns are explicitly passed in' do
+    Chamber.load basepath:  '/tmp/chamber',
+                 files:     'credentials.yml'
+
+    expect(Chamber.filenames).to be_empty
+  end
+
+  it 'can render itself as a string even if it has not been loaded' do
+    Singleton.__init__(Chamber)
+
+    expect(Chamber.to_s).to eql ''
+  end
+
+  it 'can determine settings even if it has not been loaded' do
+    Singleton.__init__(Chamber)
+
+    expect(Chamber.settings.to_hash).to eql({})
   end
 end