qonfig 0.25.0 → 0.26.0

data/spec/features/plugins/vault/expose_vault_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+describe 'Plugins(vault): expose vault', plugin: :vault do
+  before { stub_const('VaultConfig', vault_class) }
+
+  before { allow(Vault).to receive(:logical).and_return(logical_double) }
+
+  let(:logical_double) { instance_double(Vault::Logical) }
+
+  let(:returned_data) do
+    instance_double(Vault::Secret).tap do |instance|
+      allow(instance).to receive(:data).and_return(secret_data)
+    end
+  end
+  let(:secret_data) do
+    { data: { production: { kek: 'pek', cheburek: true }, other_key: '<%= 1 + 1 %>' } }
+  end
+
+  let(:vault_class) do
+    Class.new(Qonfig::DataSet) do
+      setting :based_on_path do
+        expose_vault 'kv/data/path_based', via: :path, env: :production
+      end
+
+      setting :based_on_env_key do
+        expose_vault 'kv/data/env_key', via: :env_key, env: 'production'
+      end
+    end
+  end
+
+  specify 'defines config object by vault instructions and specific environment settings' do
+    expect(Vault.logical).to(
+      receive(:read).with('kv/data/production/path_based').and_return(returned_data)
+    )
+    expect(Vault.logical).to receive(:read).with('kv/data/env_key').and_return(returned_data)
+
+    VaultConfig.new.settings.tap do |conf|
+      expect(conf.based_on_path.other_key).to eq(2)
+      expect(conf.based_on_path.production).to be_a(Qonfig::Settings)
+      expect(conf.based_on_env_key).to have_attributes(kek: 'pek', cheburek: true)
+    end
+  end
+
+  context 'when provided env argument is an Object' do
+    specify 'raises an error' do
+      expect do
+        Class.new(Qonfig::DataSet) do
+          expose_vault 'kv/data/path_based', via: Object.new, env: :production
+        end
+      end.to raise_error(Qonfig::ArgumentError)
+    end
+  end
+
+  context 'when provided via argument is an Object' do
+    specify 'raises an error' do
+      expect do
+        Class.new(Qonfig::DataSet) do
+          expose_vault 'kv/data/path_based', via: :path, env: Object.new
+        end
+      end.to raise_error(Qonfig::ArgumentError)
+    end
+  end
+
+  context 'when provided via is not supported' do
+    specify 'raises an error' do
+      expect do
+        Class.new(Qonfig::DataSet) do
+          expose_vault 'kv/data/path_based', via: :kek, env: :production
+        end
+      end.to raise_error(Qonfig::ArgumentError)
+    end
+  end
+
+  context 'when provided env is empty' do
+    specify 'raises an error' do
+      expect do
+        Class.new(Qonfig::DataSet) do
+          expose_vault 'kv/data/path_based', via: :path, env: ''
+        end
+      end.to raise_error(Qonfig::ArgumentError)
+    end
+  end
+
+  context "when provided key doesn't exist" do
+    let(:vault_class) do
+      Class.new(Qonfig::DataSet) do
+        expose_vault 'kv/data/env_key', via: :env_key, env: 'kekduction'
+      end
+    end
+
+    specify 'raises an error' do
+      expect(Vault.logical).to receive(:read).with('kv/data/env_key').and_return(returned_data)
+
+      expect { VaultConfig.new }.to raise_error(/does not contain settings with <kekduction>/)
+    end
+  end
+
+  context 'with not strict mode' do
+    let(:vault_class) do
+      Class.new(Qonfig::DataSet) do
+        setting :based_on_env_key do
+          expose_vault 'kv/data/env_key', via: :env_key, env: 'production', strict: false
+        end
+      end
+    end
+
+    let(:secret_data) { Hash[] }
+
+    specify "doesn't fail and uses empty config" do
+      expect(Vault.logical).to receive(:read).with('kv/data/env_key').and_return(returned_data)
+
+      conf = nil
+      expect { conf = VaultConfig.new }.not_to raise_error
+      expect(conf.to_h['based_on_env_key']).to be_empty
+    end
+  end
+end

data/spec/features/plugins/vault/load_from_vault_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+describe 'Plugins(vault): Load from vault kv store', plugin: :vault do
+  before { stub_const('VaultConfig', vault_class) }
+
+  before { allow(Vault).to receive(:logical).and_return(logical_double) }
+
+  let(:returned_data) do
+    instance_double(Vault::Secret).tap do |instance|
+      allow(instance).to receive(:data).and_return(secret_data)
+    end
+  end
+  let(:logical_double) { instance_double(Vault::Logical) }
+  let(:secret_data) { Hash[data: { kek: true, pek: 'cheburek', nested: Hash[key: 123] }] }
+
+  let(:vault_class) do
+    Class.new(Qonfig::DataSet) do
+      load_from_vault 'kv/data/development'
+    end
+  end
+
+  specify 'defines config object by vault instructions' do
+    expect(Vault.logical).to receive(:read).with('kv/data/development').and_return(returned_data)
+
+    VaultConfig.new.settings.tap do |conf|
+      expect(conf).to have_attributes(kek: true, pek: 'cheburek')
+      expect(conf.nested.key).to eq(123)
+    end
+  end
+
+  context 'with not exist path' do
+    let(:expected_error_args) do
+      [Qonfig::FileNotFoundError, 'No such file or directory - Path kv/data/development not exist']
+    end
+
+    specify 'raises error' do
+      expect(Vault.logical).to receive(:read).with('kv/data/development').and_return(nil)
+      expect { VaultConfig.new }.to raise_error(*expected_error_args)
+    end
+  end
+
+  context 'with Pathname at path argument' do
+    let(:vault_class) do
+      Class.new(Qonfig::DataSet) do
+        load_from_vault Pathname('kv/data/development')
+      end
+    end
+
+    specify 'converts it to string' do
+      expect(Vault.logical).to receive(:read).with('kv/data/development').and_return(returned_data)
+
+      VaultConfig.new
+    end
+  end
+
+  context 'when strict set to false' do
+    let(:vault_class) do
+      Class.new(Qonfig::DataSet) do
+        load_from_vault 'kv/data/development', strict: false
+      end
+    end
+
+    specify "doesn't fail and uses empty config" do
+      expect(Vault.logical).to receive(:read).with('kv/data/development').and_return(nil).twice
+
+      expect { VaultConfig.new }.not_to raise_error
+      expect(VaultConfig.new.to_h).to eq({})
+    end
+  end
+
+  context 'when VaultError is raised' do
+    let(:raised_error) { Vault::VaultError.new('Cool error') }
+
+    specify 'raises VaultLoaderError' do
+      expect(Vault.logical).to receive(:read).with('kv/data/development').and_raise(raised_error)
+
+      expect { VaultConfig.new }.to raise_error(Qonfig::VaultLoaderError, 'Cool error')
+    end
+  end
+end

data/spec/features/plugins_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+describe 'Plugins' do
+  specify 'plguin regsitration, load and resolving' do
+    # plugins are not registered
+    expect(Qonfig::Plugins.names).not_to include('internal_test_plugin', 'external_test_plugin')
+    expect(Qonfig.plugins).not_to        include('internal_test_plugin', 'external_test_plugin')
+
+    InternalTestPluginInterceptor = Class.new { def self.invoke; end }
+    ExternalTestPluginInterceptor = Class.new { def self.call; end }
+
+    module Qonfig::Plugins
+      class InternalTestPlugin < Abstract
+        def self.install!
+          InternalTestPluginInterceptor.invoke
+        end
+      end
+
+      class ExternalTestPlugin < Abstract
+        def self.install!
+          ExternalTestPluginInterceptor.call
+        end
+      end
+
+      # register new plugins
+      register_plugin(:internal_test_plugin, InternalTestPlugin)
+      register_plugin(:external_test_plugin, ExternalTestPlugin)
+    end
+
+    # plugins are registered
+    expect(Qonfig::Plugins.names).to include('internal_test_plugin', 'external_test_plugin')
+    expect(Qonfig.plugins).to        include('internal_test_plugin', 'external_test_plugin')
+
+    # new plugins is not included in #loaded_plugins list
+    expect(Qonfig.loaded_plugins).not_to include('internal_test_plugin')
+    expect(Qonfig.loaded_plugins).not_to include('external_test_plugin')
+    expect(Qonfig.enabled_plugins).not_to include('internal_test_plugin')
+    expect(Qonfig.enabled_plugins).not_to include('external_test_plugin')
+    expect(Qonfig.loaded_plugins).to eq(Qonfig.enabled_plugins)
+
+    # plugin can be loaded
+    expect(InternalTestPluginInterceptor).to receive(:invoke).exactly(4).times
+    Qonfig::Plugins.load(:internal_test_plugin)
+    Qonfig::Plugins.load('internal_test_plugin')
+    Qonfig.plugin(:internal_test_plugin)
+    Qonfig.plugin('internal_test_plugin')
+    expect(Qonfig.loaded_plugins).to include('internal_test_plugin')
+    expect(Qonfig.loaded_plugins).not_to include('external_test_plugin')
+    expect(Qonfig.enabled_plugins).to include('internal_test_plugin')
+    expect(Qonfig.enabled_plugins).not_to include('external_test_plugin')
+    expect(Qonfig.loaded_plugins).to eq(Qonfig.enabled_plugins)
+
+    # plugin can be loaded
+    expect(ExternalTestPluginInterceptor).to receive(:call).exactly(4).times
+    Qonfig::Plugins.load(:external_test_plugin)
+    Qonfig::Plugins.load('external_test_plugin')
+    Qonfig.enable(:external_test_plugin)
+    Qonfig.enable('external_test_plugin')
+    expect(Qonfig.loaded_plugins).to include('external_test_plugin')
+    expect(Qonfig.loaded_plugins).to include('internal_test_plugin')
+    expect(Qonfig.enabled_plugins).to include('external_test_plugin')
+    expect(Qonfig.enabled_plugins).to include('internal_test_plugin')
+    expect(Qonfig.loaded_plugins).to eq(Qonfig.enabled_plugins)
+
+    # fails when there is an attempt to register a plugin with already used name
+    expect do
+      module Qonfig::Plugins
+        register_plugin(:internal_test_plugin, Object)
+      end
+    end.to raise_error(Qonfig::AlreadyRegisteredPluginError)
+
+    # fails when there is an attempt to register a plugin with already used name
+    expect do
+      module Qonfig::Plugins
+        register_plugin(:external_test_plugin, Object)
+      end
+    end.to raise_error(Qonfig::AlreadyRegisteredPluginError)
+
+    # fails when there is an attempt to load an unregistered plugin
+    expect do
+      Qonfig::Plugins.load(:kek_test_plugin)
+    end.to raise_error(Qonfig::UnregisteredPluginError)
+
+    # fails when there is an attempt to load an unregistered plugin
+    expect do
+      Qonfig.plugin(:kek_test_plugin)
+    end.to raise_error(Qonfig::UnregisteredPluginError)
+  end
+end

data/spec/features/reload_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+describe 'Config reloading' do
+  specify 'config reloading works correctly' do
+    class ReloadableConfig < Qonfig::DataSet
+      setting :db do
+        setting :adapter, 'postgresql'
+      end
+
+      setting :logging, false
+    end
+
+    config = ReloadableConfig.new
+
+    expect(config.to_h).to match(
+      'db' => { 'adapter' => 'postgresql' },
+      'logging' => false
+    )
+
+    config.configure { |conf| conf.logging = true } # change internal state
+
+    # re-define and append settings and validations
+    class ReloadableConfig
+      setting :db do
+        setting :adapter, 'mongoid' # re-define defaults
+      end
+
+      setting :enable_api, false # append new setting
+
+      validate :logging, :boolean, strict: true
+    end
+
+    expect(config.to_h).to match(
+      'db' => { 'adapter' => 'postgresql' },
+      'logging' => true # internal state has initial value (not a changed previously)
+    )
+
+    # new validator is not invoked (logging should be a boolean)
+    expect { config.settings.logging = nil }.not_to raise_error
+
+    # reload config settings
+    config.reload!
+
+    expect(config.to_h).to match(
+      'db' => { 'adapter' => 'mongoid' },
+      'logging' => false,
+      'enable_api' => false
+    )
+
+    # reload with instant configuration
+    config.reload! do |conf|
+      conf.enable_api = true # changed instantly
+    end
+
+    expect(config.to_h).to match(
+      'db' => { 'adapter' => 'mongoid' },
+      'logging' => false,
+      'enable_api' => true # value from isntant change
+    )
+
+    # reload with hash && proc configuration
+    config.reload!(db: { adapter: 'oracloid' }) do |conf|
+      conf.enable_api = true
+    end
+
+    expect(config.to_h).to match(
+      'db' => { 'adapter' => 'oracloid' },
+      'logging' => false,
+      'enable_api' => true
+    )
+
+    # reload and set invalid options (logging cant be nil)
+    expect { config.reload!(logging: nil) }.to raise_error(Qonfig::ValidationError)
+  end
+end

data/spec/features/run_code_with_temporary_settings_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+describe 'Run code with temporary settings' do
+  specify 'temporary settings works as expected :)' do
+    config = Qonfig::DataSet.build do
+      setting :api do
+        setting :token, 'test123'
+        setting :login, 'D@iVeR'
+      end
+    end
+
+    config.with(api: { token: '123test' }) do
+      config.settings.api.login = '555'
+
+      # NOTE: settings was changed
+      expect(config.settings.api.token).to eq('123test')
+      expect(config.settings.api.login).to eq('555')
+    end
+
+    # NOTE: original settings are still original :)
+    expect(config.settings.api.token).to eq('test123')
+    expect(config.settings.api.login).to eq('D@iVeR')
+  end
+
+  specify 'thread-safety' do
+    config = Qonfig::DataSet.build do
+      setting :api do
+        setting :token, 'test123'
+        setting :login, 'D@iVeR'
+      end
+
+      setting :credentials do
+        setting :user, 'admin'
+        setting :password, '1234asdf'
+      end
+    end
+
+    ThreadGroup.new.tap do |thread_group|
+      10.times do
+        thread_group.add(Thread.new do
+          # NOTE: change settings temporary
+          config.with(api: { token: '777555' }, credentials: { password: 'test123' }) do
+            config.settings.credentials.user = 'nimda'
+          end
+        end)
+
+        thread_group.add(Thread.new do
+          # NOTE: settings are not changed :)
+          expect(config.settings.credentials.user).to eq('admin')
+          expect(config.settings.credentials.password).to eq('1234asdf')
+          expect(config.settings.api.token).to eq('test123')
+          expect(config.settings.api.login).to eq('D@iVeR')
+        end)
+
+        thread_group.add(Thread.new do
+          # NOTE: change settings temporary
+          config.with do
+            config.settings.api.login = 'provider'
+            config.settings.api.token = 'super_puper_123'
+          end
+        end)
+
+        thread_group.add(Thread.new do
+          # NOTE: settings are not changed :)
+          expect(config.settings.credentials.user).to eq('admin')
+          expect(config.settings.credentials.password).to eq('1234asdf')
+          expect(config.settings.api.token).to eq('test123')
+          expect(config.settings.api.login).to eq('D@iVeR')
+        end)
+
+        thread_group.add(Thread.new do
+          config.with(api: { login: '0exp' }, credentials: { user: 'D@iVeR' }) do
+            config.settings.api.token = 'kekpek123'
+            config.settings.credentials.password = 'admin'
+          end
+        end)
+
+        thread_group.add(Thread.new do
+          # NOTE: settings are not changed :)
+          expect(config.settings.credentials.user).to eq('admin')
+          expect(config.settings.credentials.password).to eq('1234asdf')
+          expect(config.settings.api.token).to eq('test123')
+          expect(config.settings.api.login).to eq('D@iVeR')
+        end)
+
+        thread_group.add(Thread.new do
+          # NOTE: change settings temporary
+          config.with(api: { login: 'mobile_legends' }, credentials: { user: 'dota2' }) do
+            config.settings.api.token = 'league_of_legends'
+            config.settings.credentials.password = 'overwatch'
+          end
+        end)
+
+        thread_group.add(Thread.new do
+          # NOTE: settings are not changed :)
+          expect(config.settings.credentials.user).to eq('admin')
+          expect(config.settings.credentials.password).to eq('1234asdf')
+          expect(config.settings.api.token).to eq('test123')
+          expect(config.settings.api.login).to eq('D@iVeR')
+        end)
+      end
+    end.list.map(&:join)
+  end
+end