qonfig 0.25.0 → 0.26.0

data/spec/features/freeze_state_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+describe 'Freeze state' do
+  context 'instance' do
+    specify 'freezing' do
+      class FrozenableConfig < Qonfig::DataSet
+        setting :api_mode_enabled, true
+
+        setting :api do
+          setting :format, :json
+        end
+      end
+
+      frozen_config = FrozenableConfig.new
+
+      # can modify config values
+      frozen_config.configure do |conf|
+        expect { conf.api_mode_enabled = nil }.not_to raise_error
+        expect { conf.api.format = :plain_text }.not_to raise_error
+      end
+
+      # can reload config object
+      class FrozenableConfig
+        setting :additionals, false
+      end
+
+      expect { frozen_config.clear! }.not_to raise_error
+      expect { frozen_config.reload! }.not_to raise_error
+
+      frozen_config.freeze!
+
+      # cannot modify config values
+      frozen_config.configure do |conf|
+        expect { conf.api_mode_enabled = false }.to raise_error(Qonfig::FrozenSettingsError)
+        expect { conf.api.format = :xml }.to        raise_error(Qonfig::FrozenSettingsError)
+        expect { conf.additionals = true }.to       raise_error(Qonfig::FrozenSettingsError)
+
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+          expect { conf.api_mode_enabled = false }.to raise_error(::FrozenError)
+          expect { conf.api.format = :xml }.to        raise_error(::FrozenError)
+          expect { conf.additionals = true }.to       raise_error(::FrozenError)
+        else
+          expect { conf.api_mode_enabled = false }.to raise_error(::RuntimeError)
+          expect { conf.api.format = :xml }.to        raise_error(::RuntimeError)
+          expect { conf.additionals = true }.to       raise_error(::RuntimeError)
+        end
+      end
+
+      # cannot reload config object
+      class FrozenableConfig
+        setting :customizable, false
+      end
+
+      expect { frozen_config.reload! }.to raise_error(Qonfig::FrozenSettingsError)
+      expect { frozen_config.clear! }.to raise_error(Qonfig::FrozenSettingsError)
+
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+        expect { frozen_config.reload! }.to raise_error(::FrozenError)
+        expect { frozen_config.clear! }.to raise_error(::FrozenError)
+      else
+        expect { frozen_config.reload! }.to raise_error(::RuntimeError)
+        expect { frozen_config.clear! }.to raise_error(::RuntimeError)
+      end
+
+      expect(frozen_config.to_h).to match(
+        'api_mode_enabled' => true,
+        'api' => {
+          'format' => :json
+        },
+        'additionals' => false
+      )
+    end
+  end
+
+  context 'definition' do
+    specify 'created instance should be frozen' do
+      config = Qonfig::DataSet.build do
+        setting :test, true
+        freeze_state!
+      end
+
+      expect(config.frozen?).to eq(true)
+    end
+
+    specify 'inherited classes should not be frozen' do
+      base_config_klass = Class.new(Qonfig::DataSet) do
+        setting :test, true
+        freeze_state!
+      end
+
+      children_config_klass = Class.new(base_config_klass)
+      children_config = children_config_klass.new
+
+      expect(children_config.frozen?).to eq(false)
+    end
+
+    specify 'composed configurations should not be frozen' do
+      class BaseWithFreezeConfig < Qonfig::DataSet
+        setting :test, true
+        freeze_state!
+      end
+
+      class CompositionOfFreezedConfigs < Qonfig::DataSet
+        setting :nested do
+          compose BaseWithFreezeConfig
+        end
+        compose BaseWithFreezeConfig
+      end
+
+      config = CompositionOfFreezedConfigs.new
+      expect(config.frozen?).to eq(false)
+
+      expect do
+        config.settings.test = false
+        config.settings.nested.test = false
+      end.not_to raise_error
+
+      expect(config.settings.test).to eq(false)
+      expect(config.settings.nested.test).to eq(false)
+    end
+  end
+end

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