chamber 1.0.3 → 2.0.0

data/spec/lib/chamber/commands/files_spec.rb

@@ -0,0 +1,19 @@
+require 'rspectacular'
+require 'chamber/commands/files'
+
+module    Chamber
+module    Commands
+describe  Files do
+  let(:rootpath) { ::File.expand_path('./spec/fixtures') }
+  let(:options)  { {  basepath: rootpath,
+                      rootpath: rootpath } }
+
+  it 'can return values formatted as environment variables' do
+    files = Files.call(options)
+
+    expect(files.size).to   eql     1
+    expect(files.first).to  include 'spec/fixtures/settings.yml'
+  end
+end
+end
+end

data/spec/lib/chamber/commands/heroku/clear_spec.rb

@@ -0,0 +1,11 @@
+require 'rspectacular'
+require 'chamber/commands/heroku/clear'
+
+module    Chamber
+module    Commands
+module    Heroku
+describe  Clear do
+end
+end
+end
+end

data/spec/lib/chamber/commands/heroku/compare_spec.rb

@@ -0,0 +1,11 @@
+require 'rspectacular'
+require 'chamber/commands/heroku/compare'
+
+module    Chamber
+module    Commands
+module    Heroku
+describe  Compare do
+end
+end
+end
+end

data/spec/lib/chamber/commands/heroku/pull_spec.rb

@@ -0,0 +1,11 @@
+require 'rspectacular'
+require 'chamber/commands/heroku/pull'
+
+module    Chamber
+module    Commands
+module    Heroku
+describe  Pull do
+end
+end
+end
+end

data/spec/lib/chamber/commands/heroku/push_spec.rb

@@ -0,0 +1,11 @@
+require 'rspectacular'
+require 'chamber/commands/heroku/push'
+
+module    Chamber
+module    Commands
+module    Heroku
+describe  Push do
+end
+end
+end
+end

data/spec/lib/chamber/commands/secure_spec.rb

@@ -0,0 +1,29 @@
+require 'rspectacular'
+require 'chamber/commands/secure'
+
+module    Chamber
+module    Commands
+describe  Secure do
+  let(:rootpath)          { Pathname.new(::File.expand_path('./spec/fixtures')) }
+  let(:settings_filename) { rootpath + 'settings' + 'unencrypted.yml' }
+  let(:options)           { {  basepath:       rootpath,
+                               rootpath:       rootpath,
+                               encryption_key: rootpath + '../spec_key'} }
+
+  it 'can return values formatted as environment variables' do
+    ::File.open(settings_filename, 'w') do |file|
+      file.write <<-HEREDOC
+test:
+  _secure_my_unencrpyted_setting: hello
+HEREDOC
+    end
+
+    files = Secure.call(options)
+
+    expect(::File.read(settings_filename)).to match %r{_secure_my_unencrpyted_setting: [A-Za-z0-9\+\/]{342}==}
+
+    ::File.delete(settings_filename)
+  end
+end
+end
+end

data/spec/lib/chamber/commands/show_spec.rb

@@ -0,0 +1,43 @@
+require 'rspectacular'
+require 'chamber/commands/show'
+
+module    Chamber
+module    Commands
+describe  Show do
+  let(:rootpath) { ::File.expand_path('./spec/fixtures') }
+  let(:options)  { {  basepath:   rootpath,
+                      rootpath:   rootpath,
+                      namespaces: 'test' } }
+
+  it 'can return values formatted as environment variables' do
+    expect(Show.call(options.merge(as_env: true))).to eql(
+<<-HEREDOC.chomp
+ANOTHER_LEVEL_LEVEL_THREE_AN_ARRAY="["item 1", "item 2", "item 3"]"
+ANOTHER_LEVEL_LEVEL_THREE_A_SCALAR="hello"
+ANOTHER_LEVEL_SETTING_ONE="1"
+ANOTHER_LEVEL_SETTING_TWO="2"
+MY_BOOLEAN="false"
+MY_DYNAMIC_SETTING="2"
+MY_SETTING="my_value"
+HEREDOC
+    )
+  end
+
+  it 'can return values formatted as a hash' do
+    expect(Show.call(options)).to eql(
+<<-HEREDOC.chomp
+{"my_setting"=>"my_value",
+ "my_boolean"=>false,
+ "my_dynamic_setting"=>2,
+ "another_level"=>
+  {"setting_one"=>1,
+   "setting_two"=>2,
+   "level_three"=>
+    {"an_array"=>["item 1", "item 2", "item 3"],
+     "a_scalar"=>"hello"}}}
+HEREDOC
+    )
+  end
+end
+end
+end

data/spec/lib/chamber/file_set_spec.rb

@@ -3,7 +3,7 @@ require 'chamber/file_set'
 require 'fileutils'
 
 
-class     Chamber
+module    Chamber
 describe  FileSet do
   before(:each) { FileUtils.mkdir '/tmp/settings' unless ::File.exist? '/tmp/settings' }
   after(:each)  { FileUtils.rm_rf '/tmp/settings' if     ::File.exist? '/tmp/settings' }

data/spec/lib/chamber/file_spec.rb

@@ -1,6 +1,7 @@
 require 'rspectacular'
 require 'chamber/file'
 require 'chamber/settings'
+require 'chamber/filters/encryption_filter'
 require 'tempfile'
 
 def create_tempfile_with_content(content)
@@ -10,7 +11,7 @@ def create_tempfile_with_content(content)
   tempfile
 end
 
-class     Chamber
+module    Chamber
 describe  File do
   it 'can convert file contents to settings' do
     tempfile      = create_tempfile_with_content %Q({ test: settings })
@@ -23,8 +24,10 @@ describe  File do
 
     expect(file_settings).to  eql :settings
     expect(Settings).to       have_received(:new).
-                              with(settings:    {'test' => 'settings'},
-                                   namespaces:  {})
+                              with(settings:       {'test' => 'settings'},
+                                   namespaces:     {},
+                                   decryption_key: nil,
+                                   encryption_key: nil)
   end
 
   it 'can convert a file whose contents are empty' do
@@ -38,8 +41,10 @@ describe  File do
 
     expect(file_settings).to  eql :settings
     expect(Settings).to       have_received(:new).
-                              with(settings:    {},
-                                   namespaces:  {})
+                              with(settings:       {},
+                                   namespaces:     {},
+                                   decryption_key: nil,
+                                   encryption_key: nil)
   end
 
   it 'throws an error when the file contents are malformed' do
@@ -62,7 +67,9 @@ describe  File do
     expect(Settings).to have_received(:new).
                         with( settings:    {'test' => 'settings'},
                               namespaces: {
-                                environment:  :development })
+                                environment:  :development },
+                              decryption_key: nil,
+                              encryption_key: nil)
   end
 
   it 'can handle files which contain ERB markup' do
@@ -74,7 +81,9 @@ describe  File do
     settings_file.to_settings
     expect(Settings).to have_received(:new).
                         with( settings:   {'test' => 2},
-                              namespaces: {} )
+                              namespaces: {},
+                              decryption_key: nil,
+                              encryption_key: nil)
   end
 
   it 'does not throw an error when attempting to convert a file which does not exist' do
@@ -87,8 +96,22 @@ describe  File do
 
     expect(file_settings).to  eql :settings
     expect(Settings).to       have_received(:new).
-                              with(settings:    {},
-                                   namespaces:  {})
+                              with(settings:       {},
+                                   namespaces:     {},
+                                   decryption_key: nil,
+                                   encryption_key: nil)
+  end
+
+  it 'can securely encrypt the settings contained in a file' do
+    tempfile      = create_tempfile_with_content %Q({ _secure_setting: hello })
+    settings_file = File.new  path:           tempfile.path,
+                              encryption_key: './spec/spec_key.pub'
+
+    settings_file.secure
+
+    settings_file = File.new  path:           tempfile.path
+
+    expect(settings_file.to_settings.send(:raw_data)['_secure_setting']).to match Filters::EncryptionFilter::BASE64_STRING_PATTERN
   end
 end
 end

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

@@ -0,0 +1,44 @@
+require 'rspectacular'
+require 'chamber/filters/boolean_conversion_filter'
+
+module    Chamber
+module    Filters
+describe  BooleanConversionFilter do
+  it 'can convert string boolean values into TrueClass and FalseClass even if they are deeply nested' do
+    filtered_data = BooleanConversionFilter.execute(
+                                              data: {
+                                                true_boolean:   'true',
+                                                boolean_group:  {
+                                                  yes_boolean:        'yes',
+                                                  t_boolean:          't',
+                                                  non_boolean:        'hello',
+                                                  sub_boolean_group:  {
+                                                    false_boolean:      'false',
+                                                    no_boolean:         'no',
+                                                    nilly:              nil,
+                                                    non_boolean:        3, },
+                                                  f_boolean:          'f',
+                                                  non_boolean:        Time.utc(2012, 8, 1),
+                                                  nilly:              nil, },
+                                                false_boolean:        'false',
+                                                non_boolean:          [1, 2, 3] })
+
+    expect(filtered_data).to eql( true_boolean:       true,
+                                  boolean_group:      {
+                                    yes_boolean:        true,
+                                    t_boolean:          true,
+                                    non_boolean:        'hello',
+                                    sub_boolean_group:  {
+                                      false_boolean:      false,
+                                      no_boolean:         false,
+                                      nilly:              nil,
+                                      non_boolean:        3, },
+                                    f_boolean:          false,
+                                    non_boolean:        Time.utc(2012, 8, 1),
+                                    nilly:              nil, },
+                                  false_boolean:        false,
+                                  non_boolean:          [1, 2, 3] )
+  end
+end
+end
+end

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

@@ -0,0 +1,55 @@
+require 'rspectacular'
+require 'chamber/filters/decryption_filter'
+
+module    Chamber
+module    Filters
+describe  DecryptionFilter do
+  it 'will attempt to decrypt values which are marked as "secure"' do
+    filtered_settings = DecryptionFilter.execute( data: {
+                                                    _secure_my_secure_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==' },
+                                                  decryption_key: './spec/spec_key' )
+
+    expect(filtered_settings.my_secure_setting).to eql 'hello'
+  end
+
+  it 'will not attempt to decrypt values which are not marked as "secure"' do
+    filtered_settings = DecryptionFilter.execute( data: {
+                                                    my_secure_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==' },
+                                                  decryption_key: './spec/spec_key' )
+
+    expect(filtered_settings.my_secure_setting).to eql 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ=='
+  end
+
+  it 'will not attempt to decrypt values even if they are prefixed with "secure"' do
+    filtered_settings = DecryptionFilter.execute( data: {
+                                                    secure_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==' },
+                                                  decryption_key: './spec/spec_key' )
+
+    expect(filtered_settings.secure_setting).to eql 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ=='
+  end
+
+  it 'will not attempt to decrypt values even if they are not properly encoded' do
+    filtered_settings = DecryptionFilter.execute( data: {
+                                                    _secure_my_secure_setting: 'cJbFe0NI5\wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==' },
+                                                  decryption_key: './spec/spec_key' )
+
+    expect(filtered_settings.my_secure_setting).to eql 'cJbFe0NI5\wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ=='
+  end
+
+  it 'will not attempt to decrypt values if it guesses that they are not encrpyted' do
+    filtered_settings = DecryptionFilter.execute( data: {
+                                                    _secure_my_secure_setting: 'hello' },
+                                                  decryption_key: './spec/spec_key' )
+
+    expect(filtered_settings.my_secure_setting).to eql 'hello'
+  end
+
+  it 'will raise an exception if there is an encrypted value that it cannot decrypt' do
+    expect { DecryptionFilter.execute(data: {
+                                        _secure_my_secure_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4mpsspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ57m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXznf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZDwS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXWS7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ=='
+                                      }) }.to \
+      raise_error(Chamber::Errors::UndecryptableValueError, 'my_secure_setting appears to need decrypting but the decryption key is not available.')
+  end
+end
+end
+end

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

@@ -0,0 +1,48 @@
+require 'rspectacular'
+require 'chamber/filters/encryption_filter'
+
+module    Chamber
+module    Filters
+describe  EncryptionFilter do
+  it 'will attempt to encrypt values which are marked as "secure"' do
+    filtered_settings = EncryptionFilter.execute( data: {
+                                                    _secure_my_secure_setting: 'hello' },
+                                                  encryption_key: './spec/spec_key.pub' )
+
+    expect(filtered_settings._secure_my_secure_setting).to match EncryptionFilter::BASE64_STRING_PATTERN
+  end
+
+  it 'will not attempt to encrypt values which are not marked as "secure"' do
+    filtered_settings = EncryptionFilter.execute( data: {
+                                                    my_secure_setting: 'hello' },
+                                                  encryption_key: './spec/spec_key.pub' )
+
+    expect(filtered_settings.my_secure_setting).to eql 'hello'
+  end
+
+  it 'will not attempt to encrypt values even if they are prefixed with "secure"' do
+    filtered_settings = EncryptionFilter.execute( data: {
+                                                    secure_setting: 'hello' },
+                                                  encryption_key: './spec/spec_key.pub' )
+
+    expect(filtered_settings.secure_setting).to eql 'hello'
+  end
+
+  it 'will attempt to encrypt values if they are not properly encoded' do
+    filtered_settings = EncryptionFilter.execute( data: {
+                                                    _secure_my_secure_setting: 'fNI5\jwlBn' },
+                                                  encryption_key: './spec/spec_key.pub' )
+
+    expect(filtered_settings._secure_my_secure_setting).to match EncryptionFilter::BASE64_STRING_PATTERN
+  end
+
+  it 'will not attempt to encrypt values if it guesses that they are already encrpyted' do
+    filtered_settings = EncryptionFilter.execute( data: {
+                                                    _secure_my_secure_setting: 'fNI5wlBniNhEU4396pmhWwx+A09bRAMJOUASuP7PzprewBX8CXYqL+v/uXOJpIRCLDjwe8quuC+j9iLcPU7HBRMr054gGxeqZexbLevXcPk7SrMis3qeEKmnAuarQGXe7ZAntidMY9Lx4pqSkhYXwQnI48d2Dh44qfaS9w2OrehSkpdFRnuxQeOpCKO/bleB0J88WGkytCohyHCRIpbaEjEC3UD52pnqMeu/ClNm+PBgE6Ci94pu5UUnZuIE/y+P4A3wgD6G/u8hgvAW51JwVryg/im1rayGAwWYNgupQ/5LDmjffwx7Q3fyMH2uF3CDIKRIC6U+mnM5SRMO4Dzysw==' },
+                                                  encryption_key: './spec/spec_key.pub' )
+
+    expect(filtered_settings._secure_my_secure_setting).to eql 'fNI5wlBniNhEU4396pmhWwx+A09bRAMJOUASuP7PzprewBX8CXYqL+v/uXOJpIRCLDjwe8quuC+j9iLcPU7HBRMr054gGxeqZexbLevXcPk7SrMis3qeEKmnAuarQGXe7ZAntidMY9Lx4pqSkhYXwQnI48d2Dh44qfaS9w2OrehSkpdFRnuxQeOpCKO/bleB0J88WGkytCohyHCRIpbaEjEC3UD52pnqMeu/ClNm+PBgE6Ci94pu5UUnZuIE/y+P4A3wgD6G/u8hgvAW51JwVryg/im1rayGAwWYNgupQ/5LDmjffwx7Q3fyMH2uF3CDIKRIC6U+mnM5SRMO4Dzysw=='
+  end
+end
+end
+end

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

@@ -0,0 +1,35 @@
+require 'rspectacular'
+require 'chamber/filters/environment_filter'
+
+module    Chamber
+module    Filters
+describe  EnvironmentFilter do
+  it 'can extract data from the environment if an existing variable matches the composite key' do
+    ENV['TEST_SETTING_GROUP_TEST_SETTING_LEVEL_TEST_SETTING'] = 'value 2'
+
+    filtered_data = EnvironmentFilter.execute(data: {
+                                                test_setting_group: {
+                                                  test_setting_level: {
+                                                    test_setting:   'value 1' }}})
+
+    expect(filtered_data.test_setting_group.test_setting_level.test_setting).to eql 'value 2'
+
+    ENV.delete('TEST_SETTING_GROUP_TEST_SETTING_LEVEL_TEST_SETTING')
+  end
+
+  it 'does not affect items which are not stored in the environment' do
+    ENV['TEST_SETTING_GROUP_TEST_SETTING_LEVEL_TEST_SETTING'] = 'value 2'
+
+    filtered_data = EnvironmentFilter.execute(data: {
+                                                test_setting_group: {
+                                                  test_setting_level: {
+                                                    test_setting:     'value 1',
+                                                    another_setting:  'value 3', }}})
+
+    expect(filtered_data.test_setting_group.test_setting_level.another_setting).to eql 'value 3'
+
+    ENV.delete('TEST_SETTING_GROUP_TEST_SETTING_LEVEL_TEST_SETTING')
+  end
+end
+end
+end

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

@@ -0,0 +1,73 @@
+require 'rspectacular'
+require 'chamber/filters/namespace_filter'
+require 'chamber/namespace_set'
+
+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' ])
+
+    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' ])
+
+    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' ])
+
+    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: [])
+
+    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']) )
+
+    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
+end