qonfig 0.24.0 → 0.27.0

data/spec/features/get_config_keys_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+describe 'Get config keys' do
+  let(:config) do
+    Qonfig::DataSet.build do
+      setting :credentials do
+        setting :social do
+          setting :service, 'instagram'
+          setting :login, '0exp'
+        end
+
+        setting :admin do
+          setting :enabled, true
+        end
+      end
+
+      setting :server do
+        setting :type, 'cloud'
+        setting :options do
+          setting :os, 'CentOS'
+        end
+      end
+    end
+  end
+
+  specify '(#keys) existing keys' do
+    expect(config.keys).to contain_exactly(
+      'credentials.social.service',
+      'credentials.social.login',
+      'credentials.admin.enabled',
+      'server.type',
+      'server.options.os'
+    )
+  end
+
+  specify '(#keys) all key variants' do
+    expect(config.keys(all_variants: true)).to contain_exactly(
+      'credentials',
+      'credentials.social',
+      'credentials.social.service',
+      'credentials.social.login',
+      'credentials.admin',
+      'credentials.admin.enabled',
+      'server',
+      'server.type',
+      'server.options',
+      'server.options.os'
+    )
+  end
+
+  specify '(#root_keys) only root keys' do
+    expect(config.keys(only_root: true)).to contain_exactly(
+      'credentials',
+      'server'
+    )
+
+    expect(config.root_keys).to contain_exactly(
+      'credentials',
+      'server'
+    )
+  end
+end

data/spec/features/get_config_values_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+describe 'Get config values' do
+  subject(:config) do
+    Qonfig::DataSet.build do
+      setting :some_nested_setting do
+        setting :username, 'your_cool_name_here'
+        setting :password, 'secure_password'
+      end
+
+      setting :role, 'cool guy'
+    end.settings
+  end
+
+  describe '#[]' do
+    it 'properly gets value by value' do
+      expect(config[:some_nested_setting][:username]).to eq('your_cool_name_here')
+      expect(config[:some_nested_setting][:password]).to eq('secure_password')
+      expect(config[:role]).to eq('cool guy')
+    end
+
+    context 'with key path' do
+      it 'properly gets value' do
+        expect(config[:some_nested_setting, :username]).to eq('your_cool_name_here')
+        expect(config[:some_nested_setting, :password]).to eq('secure_password')
+      end
+    end
+
+    context "when setting doesn't exist" do
+      it 'raises error' do
+        expect { config[:some_nested_setting, :kek] }.to raise_error(Qonfig::UnknownSettingError)
+      end
+    end
+
+    context 'when zero arguments passed' do
+      it 'raises error' do
+        expect { config[] }.to raise_error(Qonfig::ArgumentError)
+      end
+    end
+  end
+end

data/spec/features/has_a_key_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+describe 'Has a key? (option? / setting?)' do
+  specify 'setting key existence checker' do
+    config = Qonfig::DataSet.build do
+      setting :credentials do
+        setting :user, 'D@iVeR'
+        setting :password, 'test123'
+      end
+    end
+
+    # root key
+    expect(config.key?('credentials')).to eq(true)
+    expect(config.key?(:credentials)).to eq(true)
+
+    expect(config.option?('credentials')).to eq(true)
+    expect(config.option?(:credentials)).to eq(true)
+
+    expect(config.setting?('credentials')).to eq(true)
+    expect(config.setting?(:credentials)).to eq(true)
+
+    # deeply nested key (with mixed types of params)
+    expect(config.key?('credentials', :user)).to eq(true)
+    expect(config.key?(:credentials, 'user')).to eq(true)
+    expect(config.key?(:credentials, :user)).to eq(true)
+
+    expect(config.option?('credentials', :user)).to eq(true)
+    expect(config.option?(:credentials, 'user')).to eq(true)
+    expect(config.option?(:credentials, :user)).to eq(true)
+
+    expect(config.setting?('credentials', :user)).to eq(true)
+    expect(config.setting?(:credentials, 'user')).to eq(true)
+    expect(config.setting?(:credentials, :user)).to eq(true)
+
+    # nonexited key
+    expect(config.key?(:user, :password)).to eq(false)
+    expect(config.key?('options')).to eq(false)
+
+    expect(config.option?(:user, :password)).to eq(false)
+    expect(config.option?('options')).to eq(false)
+
+    expect(config.setting?(:user, :password)).to eq(false)
+    expect(config.setting?('options')).to eq(false)
+
+    # incorrect key type
+    expect { config.setting?(Object.new) }.to raise_error(Qonfig::ArgumentError)
+  end
+end

data/spec/features/import_settings_spec.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+describe 'Import settings as access methods to a class' do
+  let(:config) do
+    Qonfig::DataSet.build do
+      setting :credentials do
+        setting :admin, true
+        setting :login, 'D@iVeR'
+        setting :password, 'test123'
+      end
+
+      setting :job_que do
+        setting :adapter, :sidekiq
+        setting :options do
+          setting :server, 'cloud'
+          setting :auto_run, true
+        end
+      end
+    end
+  end
+
+  before { stub_const('AppConfig', config) }
+
+  specify 'empty import does nothing' do
+    expect do
+      Class.new do
+        include Qonfig::Imports
+        import_settings(AppConfig, '#')
+      end
+    end.not_to raise_error
+
+    expect do
+      Class.new do
+        include Qonfig::Imports
+        import_settings(AppConfig, '*')
+      end
+    end.not_to raise_error
+  end
+
+  specify 'each required setting is imported as an instance method with access to sliced value' do
+    class SimpleImportCheckApp
+      include Qonfig::Imports
+
+      import_settings(AppConfig, 'credentials.login', 'job_que.options')
+    end
+
+    app_with_configs = SimpleImportCheckApp.new
+
+    # NOTE: new methods
+    expect(app_with_configs).to respond_to(:login)
+    expect(app_with_configs).to respond_to(:options)
+
+    # NOTE: get config values
+    expect(app_with_configs.login).to eq('D@iVeR')
+    expect(app_with_configs.options).to match('server' => 'cloud', 'auto_run' => true)
+
+    # NOTE: change config options and try to get them from app_with_config again
+    AppConfig.configure do |config|
+      config.credentials.login = '0exp'
+      config.job_que.options.server = 'localhost'
+      config.job_que.options.auto_run = false
+    end
+
+    # NOTE: check cahnged configs
+    expect(app_with_configs.login).to eq('0exp')
+    expect(app_with_configs.options).to match('server' => 'localhost', 'auto_run' => false)
+
+    # NOTE: only att_readers are generated by default
+    expect { app_with_configs.login = 'test123' }.to raise_error(NoMethodError)
+    expect { app_with_configs.options = 'test123' }.to raise_error(NoMethodError)
+
+    # NOTE: check that original values isnt changed after NoMethodError exception
+    expect(app_with_configs.login).to eq('0exp')
+    expect(app_with_configs.options).to match('server' => 'localhost', 'auto_run' => false)
+  end
+
+  specify 'support for predicates' do
+    class ImportPredicatesCheck
+      include Qonfig::Imports
+
+      # NOTE: without prefix
+      import_settings(AppConfig, 'credentials.*', accessor: true)
+
+      # NOTE: with prefix
+      import_settings(AppConfig, 'job_que.options.*', prefix: 'config_', accessor: true)
+
+      # NOTE: and mappings
+      import_settings(AppConfig, mappings: { queue_engine: 'job_que.adapter' }, accessor: true)
+    end
+
+    app_with_predicates = ImportPredicatesCheck.new
+
+    expect(app_with_predicates.admin?).to eq(true)
+    expect(app_with_predicates.login?).to eq(true)
+    expect(app_with_predicates.password?).to eq(true)
+    expect(app_with_predicates.config_server?).to eq(true)
+    expect(app_with_predicates.config_auto_run?).to eq(true)
+    expect(app_with_predicates.queue_engine?).to eq(true)
+
+    app_with_predicates.config_server = nil
+    app_with_predicates.admin = false
+    app_with_predicates.queue_engine = nil
+
+    expect(app_with_predicates.config_server?).to eq(false)
+    expect(app_with_predicates.admin?).to eq(false)
+    expect(app_with_predicates.queue_engine?).to eq(false)
+
+    app_with_predicates.config_server = 'yandex'
+    app_with_predicates.admin = true
+    app_with_predicates.queue_engine = :delayed_job
+
+    expect(app_with_predicates.config_server?).to eq(true)
+    expect(app_with_predicates.admin?).to eq(true)
+    expect(app_with_predicates.queue_engine?).to eq(true)
+  end
+
+  specify 'attr_writers (config muatators)' do
+    class AttrAccessorImportCheckApp
+      include Qonfig::Imports
+
+      import_settings(
+        AppConfig,
+        'credentials.login',
+        mappings: { job_opts: 'job_que.options' },
+        accessor: true
+      )
+    end
+
+    app_with_configs = AttrAccessorImportCheckApp.new
+
+    # NOTE: you can mutate config settings via imported attr_writers
+    app_with_configs.login = 'D@iVeR'
+
+    # NOTE: check that original config was changed
+    expect(AppConfig.settings.credentials.login).to eq('D@iVeR')
+
+    # NOTE: check that reader returns new value
+    expect(app_with_configs.login).to eq('D@iVeR')
+
+    # NOTE: some mutators can be ambiguous - be careful :thinking:
+    expect { app_with_configs.job_opts = 'test' }.to raise_error(Qonfig::AmbiguousSettingValueError)
+  end
+
+  specify 'you can prefix imported methods' do
+    class PrefixImportCheckApp
+      include Qonfig::Imports
+
+      import_settings(AppConfig, 'credentials.password', 'credentials.login', prefix: 'config_')
+    end
+
+    app_with_configs = PrefixImportCheckApp.new
+
+    expect(app_with_configs).to respond_to(:config_login)
+    expect(app_with_configs).to respond_to(:config_password)
+
+    expect(app_with_configs.config_login).to eq('D@iVeR')
+    expect(app_with_configs.config_password).to eq('test123')
+  end
+
+  specify 'you can define your own method name for each imported setting' do
+    class ImportWithMappingsApp
+      include Qonfig::Imports
+
+      # NOTE: without prefix
+      import_settings(AppConfig, mappings: {
+        user_password: 'credentials.password',
+        user_login: 'credentials.login',
+        job_adapter: 'job_que.adapter'
+      })
+
+      # NOTE: with prefix
+      import_settings(
+        AppConfig,
+        mappings: { job_server: 'job_que.options.server' },
+        prefix: 'config_'
+      )
+    end
+
+    app_with_configs = ImportWithMappingsApp.new
+
+    expect(app_with_configs).to respond_to(:user_password)
+    expect(app_with_configs).to respond_to(:user_login)
+    expect(app_with_configs).to respond_to(:job_adapter)
+    expect(app_with_configs).to respond_to(:config_job_server)
+
+    expect(app_with_configs.user_password).to eq('test123')
+    expect(app_with_configs.user_login).to eq('D@iVeR')
+    expect(app_with_configs.job_adapter).to eq(:sidekiq)
+    expect(app_with_configs.config_job_server).to eq('cloud')
+
+    # NOTE: change cofnigs and check that each new method returns the real config value
+    AppConfig.configure do |config|
+      config.credentials.password = 'tratata123'
+      config.credentials.login = '0exp'
+      config.job_que.adapter = :resque
+      config.job_que.options.server = 'aws'
+    end
+
+    expect(app_with_configs.user_password).to eq('tratata123')
+    expect(app_with_configs.user_login).to eq('0exp')
+    expect(app_with_configs.job_adapter).to eq(:resque)
+    expect(app_with_configs.config_job_server).to eq('aws')
+  end
+
+  specify 'you can mix explicit keys, mappings and prefix' do
+    class MixedImportCheckApp
+      include Qonfig::Imports
+
+      import_settings(
+        AppConfig,
+        'credentials', 'job_que.options', # simple keys
+        mappings: { passwd: 'credentials.password', admn: 'credentials.admin' }, # mappings
+        prefix: 'config_' # and prefix
+      )
+    end
+
+    app_with_configs = MixedImportCheckApp.new
+
+    expect(app_with_configs).to respond_to(:config_passwd)
+    expect(app_with_configs).to respond_to(:config_admn)
+    expect(app_with_configs).to respond_to(:config_credentials)
+    expect(app_with_configs).to respond_to(:config_options)
+
+    expect(app_with_configs.config_passwd).to eq('test123')
+    expect(app_with_configs.config_admn).to eq(true)
+    expect(app_with_configs.config_credentials).to match(
+      'admin'    => true,
+      'login'    => 'D@iVeR',
+      'password' => 'test123'
+    )
+    expect(app_with_configs.config_options).to eq(
+      'server'   => 'cloud',
+      'auto_run' => true
+    )
+  end
+
+  specify 'raw setting import (Qonfig::Settings object - or <value>)' do
+    # NOTE: default non-raw import (import nested settings as hashes)
+    class NonRawImportCheckApp
+      include Qonfig::Imports
+      import_settings(AppConfig, 'job_que', mappings: { creds: 'credentials' }, raw: false)
+    end
+
+    app_with_configs = NonRawImportCheckApp.new
+
+    expect(app_with_configs).to respond_to(:job_que)
+    expect(app_with_configs).to respond_to(:creds)
+    expect(app_with_configs.creds).to be_a(Hash)
+    expect(app_with_configs.job_que).to be_a(Hash)
+    expect(app_with_configs.creds).to match(
+      'admin' => true,
+      'login' => 'D@iVeR',
+      'password' => 'test123'
+    )
+    expect(app_with_configs.job_que).to match(
+      'adapter' => :sidekiq,
+      'options' => {
+        'server' => 'cloud',
+        'auto_run' => true
+      }
+    )
+
+    # NOTE: raw import (import nested settings as Qonfig::Settings objects)
+    class RawImportCheckApp
+      include Qonfig::Imports
+      import_settings(AppConfig, 'job_que', mappings: { creds: 'credentials' }, raw: true)
+    end
+
+    app_with_configs = RawImportCheckApp.new
+
+    expect(app_with_configs).to respond_to(:job_que)
+    expect(app_with_configs).to respond_to(:creds)
+    expect(app_with_configs.job_que).to be_a(Qonfig::Settings)
+    expect(app_with_configs.creds).to be_a(Qonfig::Settings)
+    expect(app_with_configs.job_que.adapter).to eq(:sidekiq)
+    expect(app_with_configs.job_que.options.server).to eq('cloud')
+    expect(app_with_configs.job_que.options.auto_run).to eq(true)
+    expect(app_with_configs.creds.admin).to eq(true)
+    expect(app_with_configs.creds.login).to eq('D@iVeR')
+    expect(app_with_configs.creds.password).to eq('test123')
+  end
+
+  specify 'incorrect attributes' do
+    expect do
+      Class.new do
+        include Qonfig::Imports
+        import_settings(123)
+      end
+    end.to raise_error(Qonfig::IncompatibleImportedConfigError)
+
+    expect do
+      Class.new do
+        include Qonfig::Imports
+        import_settings(AppConfig, 'kek.pek', prefix: Object.new)
+      end
+    end.to raise_error(Qonfig::IncorrectImportPrefixError)
+
+    expect do
+      Class.new do
+        include Qonfig::Imports
+        import_settings(AppConfig, 'pek.kek', 'kek.pek', Object.new)
+      end
+    end.to raise_error(Qonfig::IncorrectImportKeyError)
+
+    expect do
+      Class.new do
+        include Qonfig::Imports
+        import_settings(AppConfig, 'kek.pek', mappings: {
+          Object.new => 'kek.pek'
+        })
+      end
+    end.to raise_error(Qonfig::IncorrectImportMappingsError)
+
+    expect do
+      Class.new do
+        include Qonfig::Imports
+        import_settings(AppConfig, 'kek.pek', mappings: {
+          some_method: Object.new
+        })
+      end
+    end.to raise_error(Qonfig::IncorrectImportMappingsError)
+  end
+end

data/spec/features/indifferent_access_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+describe 'Indifferent Access' do
+  specify 'indifferently accessable options (directly via index; via string / via symbol)' do
+    class IndifferentlyAccessableConfig < Qonfig::DataSet
+      setting :project_id, 10
+    end
+
+    class AnotherIndifferentlyAccessableConfig < Qonfig::DataSet
+      compose IndifferentlyAccessableConfig
+
+      setting 'database' do
+        setting :hostname, 'localhost'
+      end
+    end
+
+    config = AnotherIndifferentlyAccessableConfig.new
+
+    # indifferent access via string / via symbol
+    expect(config.settings[:project_id]).to eq(10)
+    expect(config.settings['project_id']).to eq(10)
+    expect(config.settings[:database][:hostname]).to eq('localhost')
+    expect(config.settings['database']['hostname']).to eq('localhost')
+    expect(config.settings['database'][:hostname]).to eq('localhost')
+    expect(config.settings[:database]['hostname']).to eq('localhost')
+
+    # direct access via [] on the config object
+    expect(config[:project_id]).to eq(10)
+    expect(config['project_id']).to eq(10)
+    expect(config[:database][:hostname]).to eq('localhost')
+    expect(config['database']['hostname']).to eq('localhost')
+    expect(config['database'][:hostname]).to eq('localhost')
+    expect(config[:database]['hostname']).to eq('localhost')
+
+    # instant configuration with indifferently accessable options
+    config.configure do |conf|
+      conf['project_id'] = 1
+      conf[:database]['hostname'] = 'google.com'
+    end
+
+    # indifferent access via string / via symbol
+    expect(config.settings[:project_id]).to eq(1)
+    expect(config.settings['project_id']).to eq(1)
+    expect(config.settings[:database][:hostname]).to eq('google.com')
+    expect(config.settings['database']['hostname']).to eq('google.com')
+    expect(config.settings['database'][:hostname]).to eq('google.com')
+    expect(config.settings[:database]['hostname']).to eq('google.com')
+
+    # direct access via [] on the config object
+    expect(config[:project_id]).to eq(1)
+    expect(config['project_id']).to eq(1)
+    expect(config[:database][:hostname]).to eq('google.com')
+    expect(config['database']['hostname']).to eq('google.com')
+    expect(config['database'][:hostname]).to eq('google.com')
+    expect(config[:database]['hostname']).to eq('google.com')
+  end
+end

data/spec/features/inheritance_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+describe 'Inheritance' do
+  specify 'config inheritance works correclty' do
+    class FrameworkConfig < Qonfig::DataSet
+      setting :version, '0.1.0'
+
+      setting :defaults do
+        setting :path, '/a/b/c'
+      end
+    end
+
+    class UnknownConfig < Qonfig::DataSet
+      setting :unkown_data, true
+    end
+
+    class SharedConfig < Qonfig::DataSet
+      setting :google_api do
+        setting :token, 'test-google-api'
+      end
+
+      setting :admin_access_required, false
+
+      compose FrameworkConfig
+    end
+
+    class ClientConfig < SharedConfig
+      compose UnknownConfig
+
+      setting :google_api do
+        setting :client_token, 'client-test-google-api'
+      end
+
+      setting :defaults, nil
+    end
+
+    client_config = ClientConfig.new
+
+    client_config.settings.tap do |config|
+      # own settings
+      expect(config.google_api.client_token).to eq('client-test-google-api')
+      expect(config.defaults).to eq(nil)
+      expect(config[:google_api][:client_token]).to eq('client-test-google-api')
+      expect(config[:defaults]).to eq(nil)
+
+      # inherited settings
+      expect(config.google_api.token).to eq('test-google-api')
+      expect(config.admin_access_required).to eq(false)
+      expect(config[:google_api][:token]).to eq('test-google-api')
+      expect(config[:admin_access_required]).to eq(false)
+
+      # inherited composition
+      expect(config.version).to eq('0.1.0')
+      expect(config[:version]).to eq('0.1.0')
+
+      # own composition
+      expect(config.unkown_data).to eq(true)
+      expect(config[:unkown_data]).to eq(true)
+    end
+
+    # hash representation
+    expect(client_config.to_h).to match(
+      'google_api' => {
+        'client_token' => 'client-test-google-api',
+        'token' => 'test-google-api'
+      },
+      'defaults' => nil,
+      'admin_access_required' => false,
+      'version' => '0.1.0',
+      'unkown_data' => true
+    )
+
+    # reconfigure
+    client_config.configure do |config|
+      config.google_api.client_token = 'none'
+      config.defaults = { a: 1 }
+      config.google_api.token = 'anti-hype'
+      config.admin_access_required = true
+      config.version = '0.2.0'
+      config.unkown_data = nil
+    end
+
+    client_config.settings.tap do |config|
+      expect(config.google_api.client_token).to eq('none')
+      expect(config.defaults).to match(a: 1)
+      expect(config.google_api.token).to eq('anti-hype')
+      expect(config.admin_access_required).to eq(true)
+      expect(config.version).to eq('0.2.0')
+      expect(config.unkown_data).to eq(nil)
+
+      expect(config[:google_api][:client_token]).to eq('none')
+      expect(config[:defaults]).to match(a: 1)
+      expect(config[:google_api][:token]).to eq('anti-hype')
+      expect(config[:admin_access_required]).to eq(true)
+      expect(config[:version]).to eq('0.2.0')
+      expect(config[:unkown_data]).to eq(nil)
+    end
+
+    expect(client_config.to_h).to match(
+      'google_api' => {
+        'client_token' => 'none',
+        'token' => 'anti-hype'
+      },
+      'defaults' => { a: 1 },
+      'admin_access_required' => true,
+      'version' => '0.2.0',
+      'unkown_data' => nil
+    )
+  end
+end

data/spec/features/instantiation_without_class_definition_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+describe 'Instantiation without class definition' do
+  specify '#build builds a config instance without a class' do
+    config = Qonfig::DataSet.build do
+      setting :credentials do
+        setting :user, 'D@iVeR'
+        setting :password, 'test123'
+      end
+
+      def custom_method(custom_param)
+        custom_param
+      end
+    end
+
+    expect(config).to be_a(Qonfig::DataSet)
+    expect(config.settings.credentials.user).to eq('D@iVeR')
+    expect(config.settings.credentials.password).to eq('test123')
+
+    custom_param = rand(1..1000).to_s
+    expect(config.custom_method(custom_param)).to eq(custom_param)
+  end
+
+  specify 'custom Qonfig::DataSet inheritance' do
+    simple_config_klass = Class.new(Qonfig::DataSet) do
+      setting :adapter do
+        setting :engine, :sidekiq
+        setting :options, {}
+      end
+    end
+
+    config = Qonfig::DataSet.build(simple_config_klass) do
+      setting :credentials do
+        setting :user, '0exp'
+        setting :password, '123test123'
+      end
+
+      setting :adapter do
+        setting :enabled, false
+      end
+    end
+
+    # NOTE: inherited configs
+    expect(config.settings.adapter.engine).to eq(:sidekiq)
+    expect(config.settings.adapter.options).to eq({})
+
+    # NOTE: extended base config
+    expect(config.settings.adapter.enabled).to eq(false)
+
+    # NOTE: own configs
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.password).to eq('123test123')
+  end
+
+  specify 'custom inheritance fails on non-Qonfig::DataSet base classes' do
+    expect { Qonfig::DataSet.build(Object) }.to raise_error(Qonfig::ArgumentError)
+    expect { Qonfig::DataSet.build(Qonfig::DataSet) }.not_to raise_error
+  end
+end