chamber 2.10.1 → 2.10.2

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-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',
-                                                  },
-                                                },
-                                              })
-
-    test_setting  = filtered_data.test_setting_group.test_setting_level.test_setting
-
-    expect(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',
-                                                  },
-                                                },
-                                              })
-
-    another_setting = filtered_data.test_setting_group.test_setting_level.another_setting
-
-    expect(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/failed_decryption_filter_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-require 'rspectacular'
-require 'chamber/filters/failed_decryption_filter'
-
-module    Chamber
-module    Filters
-describe  FailedDecryptionFilter do
-  it 'raises an exception if any of the settings are not decrypted' do
-    expect {
-      FailedDecryptionFilter.execute(
-        data: {
-          _secure_my_secure_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4m' \
-                                     'psspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ5' \
-                                     '7m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXz' \
-                                     'nf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZD' \
-                                     'wS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXW' \
-                                     'S7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kK' \
-                                     'TcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
-        },
-      )
-    }.
-    to raise_error Chamber::Errors::DecryptionFailure
-  end
-
-  it 'does not raise an exception if it is not a secure key' do
-    expect {
-      FailedDecryptionFilter.execute(
-        data: {
-          my_secure_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4m' \
-                             'psspg/ZTBtmjx7kMwcF6cjXFLDVw3FxptTHwzJUd4akun6EZ5' \
-                             '7m+QzCMJYnfY95gB2/emEAQLSz4/YwsE4LDGydkEjY1ZprfXz' \
-                             'nf+rU31YGDJUTf34ESz7fsQGSc9DjkBb9ao8Mv4cI7pCXkQZD' \
-                             'wS5kLAZDf6agy1GzeL71Z8lrmQzk8QQuf/1kQzxsWVlzpKNXW' \
-                             'S7u2CJ0sN5eINMngJBfv5ZFrZgfXc86wdgUKc8aaoX8OQA1kK' \
-                             'TcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
-        },
-      )
-    }.
-    not_to raise_error
-  end
-
-  it 'does not raise an exception if it is not a secure value' do
-    expect {
-      FailedDecryptionFilter.execute(
-        data: {
-          _secure_my_secure_setting: 'hello',
-        },
-      )
-    }.
-    not_to raise_error
-  end
-end
-end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-require 'rspectacular'
-require 'chamber/filters/insecure_filter'
-
-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',
-                                               })
-
-    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',
-                                               })
-
-    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',
-                                                 },
-                                               })
-
-    expect(filtered_settings._secure_setting).to                      eql 'hello'
-    expect(filtered_settings.secure_setting).to                       be_nil
-    expect(filtered_settings.secure_group._secure_nested_setting).to  eql 'movie'
-    expect(filtered_settings.secure_group.insecure_nested_setting).to be_nil
-  end
-
-  it 'will not return values which are encrypted' do
-    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
-    expect(filtered_settings._secure_other_setting).to                     eql 'hello'
-    expect(filtered_settings.secure_group._secure_nested_setting?).to      eql false
-    expect(filtered_settings.secure_group._secure_other_nested_setting).to eql 'goodbye'
-    expect(filtered_settings.secure_group.insecure_nested_setting?).to     eql false
-  end
-end
-end
-end

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

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-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: %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',
-                  ],
-    )
-
-    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: %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: [],
-    )
-
-    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(%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')
-  end
-end
-end
-end

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

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

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require 'rspectacular'
-require 'chamber/filters/translate_secure_keys_filter'
-
-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',
-      },
-    )
-
-    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',
-      },
-    )
-
-    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',
-      },
-    )
-
-    expect(filtered_settings.secure_setting).to eql 'hello'
-  end
-end
-end
-end

data/spec/lib/chamber/namespace_set_spec.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-require 'rspectacular'
-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')
-
-    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 create itself using square-bracket notation' do
-    namespace_set = NamespaceSet[:development, 'my host']
-
-    expect(namespace_set).to eq ['development', 'my host']
-  end
-
-  it 'can create itself from another NamespaceSet' do
-    original_set  = NamespaceSet[:development, 'my host']
-    namespace_set = NamespaceSet.new(original_set)
-
-    expect(namespace_set).to eq ['development', 'my host']
-  end
-
-  it 'can create itself from a single value' do
-    namespace_set = NamespaceSet.new(:development)
-
-    expect(namespace_set).to eq ['development']
-  end
-
-  it 'when creating itself from another NamespaceSet, it creates a new NamespaceSet' do
-    original_set  = NamespaceSet[:development, 'my host']
-    namespace_set = NamespaceSet.new(original_set)
-
-    expect(namespace_set.object_id).not_to eq original_set.object_id
-  end
-
-  it 'when creating itself from another NamespaceSet, it does not nest the ' \
-     'NamespaceSets' do
-
-    original_set  = NamespaceSet[:development, 'my host']
-    namespace_set = NamespaceSet.new(original_set)
-
-    expect(namespace_set.__send__(:raw_namespaces)).not_to be_a NamespaceSet
-  end
-
-  it 'can turn itself into an array' do
-    namespace_set = NamespaceSet[: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[:development, 'my host']
-    other_set     = Set['other value', 3]
-
-    combined_set  = namespace_set + other_set
-
-    expect(combined_set).to eq ['development', 'my host', 'other value', '3']
-  end
-
-  it 'can combine itself with another NamespaceSet' do
-    namespace_set = NamespaceSet[:development, 'my host']
-    other_set     = NamespaceSet['other value', 3]
-
-    combined_set  = namespace_set + other_set
-
-    expect(combined_set).to eq ['development', 'my host', 'other value', '3']
-  end
-
-  it 'does not modify the set in place if combining with another array' do
-    namespace_set = NamespaceSet[: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[: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[: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[-> { '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[:development, :development]
-    other_namespace_set = NamespaceSet[:development, :development]
-
-    expect(namespace_set).to eql other_namespace_set
-  end
-end
-end