qonfig 0.24.0 → 0.27.0

data/spec/features/plugins/toml/load_setting_values_from_file/load_toml_from_self/without_end_data_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+describe 'Plugins(toml): .values_file / #load_from_self (without __END__ data)', plugin: :toml do
+  describe 'DSL macros' do
+    context 'strict behavior' do
+      let(:config_klass) do
+        Class.new(Qonfig::DataSet) do
+          values_file :self, format: :toml, strict: true
+          setting :user, 'D@iVeR'
+        end
+      end
+
+      specify 'fails with Qonfig::SelfDataNotFoundError' do
+        expect { config_klass.new }.to raise_error(Qonfig::SelfDataNotFoundError)
+      end
+    end
+
+    context 'non-strict behavior (default)' do
+      let(:config_klass) do
+        Class.new(Qonfig::DataSet) do
+          values_file :self, format: :toml
+          setting :user, 'D@iVeR'
+        end
+      end
+
+      specify 'config instantiation works well :)' do
+        config = nil
+        expect { config = config_klass.new }.not_to raise_error
+        expect(config.settings.user).to eq('D@iVeR')
+      end
+    end
+  end
+
+  describe 'Instance method' do
+    context 'strict behavior (default)' do
+      let(:config_klass) do
+        Class.new(Qonfig::DataSet) { setting :user, 'D@iVeR' }
+      end
+
+      specify 'fails with Qonfig::SelfDataNotFoundError' do
+        config = config_klass.new
+
+        expect do
+          config.load_from_self(format: :toml, strict: true)
+        end.to raise_error(Qonfig::SelfDataNotFoundError)
+      end
+    end
+
+    context 'non-strict behavior' do
+      let(:config_klass) do
+        Class.new(Qonfig::DataSet) { setting :user, 'D@iVeR' }
+      end
+
+      specify 'no errors :)' do
+        config = config_klass.new
+
+        expect do
+          config.load_from_self(format: :toml, strict: false)
+        end.not_to raise_error
+
+        expect(config.settings.user).to eq('D@iVeR')
+      end
+    end
+  end
+end

data/spec/features/plugins/toml/load_setting_values_from_file/shared_behavior_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+describe 'Plugin(:toml) .values_file / #load_from_file (shared behavior)', plugin: :toml do
+  describe 'unsupported format failures' do
+    describe 'DSL macros' do
+      specify 'fails on unsupported format' do
+        expect do
+          Qonfig::DataSet.build do
+            values_file :self
+          end
+        end.to raise_error(Qonfig::DynamicLoaderParseError)
+      end
+    end
+
+    describe 'Instance method' do
+      specify 'fails on unsupported format' do
+        expect do
+          Qonfig::DataSet.build.load_from_self
+        end.to raise_error(Qonfig::DynamicLoaderParseError)
+      end
+    end
+  end
+end
+
+__END__
+
+user: 0exp
+ASDF|"asSDF"
+[test]
+<xml>
+  <data>
+    <key>123</key>
+  </data>
+</xml>

data/spec/features/plugins/toml/save_to_toml_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+describe 'Plugins(toml): Save to .toml (TOML)', plugin: :toml do
+  describe 'saving' do
+    let(:config_file_name) { "#{SecureRandom.uuid}.yml" }
+    let(:config_file_path) { SpecSupport.artifact_path(config_file_name) }
+    let(:config_klass) do
+      Class.new(Qonfig::DataSet) do
+        setting :sentry do
+          setting :user, 'D@iVeR'
+          setting :callback, -> { 'loaded' }
+        end
+
+        setting :server_port, 123
+        setting :cost, 123.456
+        setting :enabled, true
+
+        setting :sub_configurations, [
+          { 'server' => 'google',   'ping' => false },
+          { 'server' => 'shoklude', 'ping' => true  }
+        ]
+      end
+    end
+    let(:config) { config_klass.new }
+
+    before do
+      config.save_to_toml(path: config_file_path) do |value|
+        value.is_a?(Proc) ? value.call : value
+      end
+    end
+
+    specify 'correctly represents config as YAML' do
+      file_data = File.read(config_file_path)
+
+      expect(file_data).to eq(<<~TOML.strip << "\n")
+        cost = 123.456
+        enabled = true
+        server_port = 123
+        [sentry]
+        callback = "loaded"
+        user = "D@iVeR"
+        [[sub_configurations]]
+        ping = false
+        server = "google"
+        [[sub_configurations]]
+        ping = true
+        server = "shoklude"
+      TOML
+    end
+
+    specify 'rewrites existing file' do
+      config_a = Class.new(Qonfig::DataSet) do
+        setting :kek, 'kek'
+      end.new
+
+      config_b = Class.new(Qonfig::DataSet) do
+        setting :pek, 'pek'
+      end.new
+
+      # first save (initial write)
+      config_a.save_to_toml(path: config_file_path)
+      file_data = File.read(config_file_path) # NOTE: initial path
+      expect(file_data).to eq(<<~TOML.strip << "\n")
+        kek = "kek"
+      TOML
+
+      # subsequent save (rewrite)
+      config_b.save_to_toml(path: config_file_path)
+      file_data = File.read(config_file_path) # NOTE: same path
+      expect(file_data).to eq(<<~TOML.strip << "\n")
+        pek = "pek"
+      TOML
+    end
+  end
+
+  describe 'data representation' do
+    let(:config_file_name) { "#{SecureRandom.uuid}.yml" }
+    let(:config_file_path) { SpecSupport.artifact_path(config_file_name) }
+
+    context 'config with supported toml types' do
+      let(:config) do
+        Class.new(Qonfig::DataSet) do
+          setting :true_boolean, true
+          setting :false_boolean, false
+          setting :empty_object, {}
+          setting :filled_object, { a: 1, b: nil, 'c' => true, d: '1', e: false }
+          setting :null_data, nil
+          setting :float_value, 123.456
+          setting :collection, [%w[1 2], [3, 4], [true, false], []]
+          setting :time, Time.utc(2031, 0o5, 27, 0o7, 32, 0)
+        end.new
+      end
+
+      specify 'correctly represents YAML data types' do
+        # NOTE: step 1) save config
+        config.save_to_toml(path: config_file_path)
+
+        # NOTE: step 2) read saved file
+        file_data = File.read(config_file_path)
+
+        expect(file_data).to eq(<<~TOML.strip << "\n")
+          collection = [["1", "2"], [3, 4], [true, false], []]
+          false_boolean = false
+          float_value = 123.456
+          time = 2031-05-27T07:32:00Z
+          true_boolean = true
+          [empty_object]
+          [filled_object]
+          a = 1
+          c = true
+          d = "1"
+          e = false
+        TOML
+      end
+
+      specify 'support for Pathname in filepath' do
+        config.save_to_toml(path: Pathname.new(config_file_path))
+
+        file_data = File.read(config_file_path)
+
+        expect(file_data).to eq(<<~TOML.strip << "\n")
+          collection = [["1", "2"], [3, 4], [true, false], []]
+          false_boolean = false
+          float_value = 123.456
+          time = 2031-05-27T07:32:00Z
+          true_boolean = true
+          [empty_object]
+          [filled_object]
+          a = 1
+          c = true
+          d = "1"
+          e = false
+        TOML
+      end
+    end
+
+    context 'config with unsupported toml types' do
+      let(:config) do
+        Class.new(Qonfig::DataSet) do
+          setting :collection, [[3, 4], %w[6 4], nil]
+        end.new
+      end
+
+      specify 'fails with parser error' do
+        expect { config.save_to_toml(path: config_file_path) }.to raise_error(::TomlRB::ParseError)
+      end
+    end
+  end
+end

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