qonfig 0.25.0 → 0.26.0

data/spec/features/composition_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+describe 'Composition' do
+  specify 'config composition (multiple inheritance)' do
+    class WebAPIConfig < Qonfig::DataSet
+      setting :version, '0.1.0'
+      setting :header, 'app.vendor'
+      setting :strategy do
+        setting :format, :json
+      end
+    end
+
+    class ServerConfig < Qonfig::DataSet
+      setting :port, 8080
+      setting :host, '0.0.0.0'
+      setting :enable_middlewares, true
+    end
+
+    class DatabaseConfig < Qonfig::DataSet
+      setting :username, 'kek'
+      setting :password, 'pek'
+      setting :connection do
+        setting :address, 'google.com'
+        setting :port, 12_345
+      end
+    end
+
+    class ProjectConfig < Qonfig::DataSet
+      compose ServerConfig
+
+      setting :api do
+        compose WebAPIConfig
+      end
+
+      setting :db do
+        compose DatabaseConfig
+      end
+
+      setting :limits do
+        setting :withdraw, 1_000_000
+        setting :deposit, 3_000_000
+      end
+    end
+
+    config = ProjectConfig.new
+
+    config.settings.tap do |conf|
+      expect(conf.api.version).to eq('0.1.0')
+      expect(conf.api.header).to eq('app.vendor')
+      expect(conf.api.strategy.format).to eq(:json)
+      expect(conf.db.username).to eq('kek')
+      expect(conf.db.password).to eq('pek')
+      expect(conf.db.connection.address).to eq('google.com')
+      expect(conf.db.connection.port).to eq(12_345)
+      expect(conf.port).to eq(8080)
+      expect(conf.host).to eq('0.0.0.0')
+      expect(conf.enable_middlewares).to eq(true)
+      expect(conf.limits.withdraw).to eq(1_000_000)
+      expect(conf.limits.deposit).to eq(3_000_000)
+
+      expect(conf[:api][:version]).to eq('0.1.0')
+      expect(conf[:api][:header]).to eq('app.vendor')
+      expect(conf[:api][:strategy][:format]).to eq(:json)
+      expect(conf[:db][:username]).to eq('kek')
+      expect(conf[:db][:password]).to eq('pek')
+      expect(conf[:db][:connection][:address]).to eq('google.com')
+      expect(conf[:db][:connection][:port]).to eq(12_345)
+      expect(conf[:port]).to eq(8080)
+      expect(conf[:host]).to eq('0.0.0.0')
+      expect(conf[:enable_middlewares]).to eq(true)
+      expect(conf[:limits][:withdraw]).to eq(1_000_000)
+      expect(conf[:limits][:deposit]).to eq(3_000_000)
+    end
+
+    # hash representation
+    expect(config.to_h).to match(
+      'db' => {
+        'username' => 'kek',
+        'password' => 'pek',
+        'connection' => {
+          'address' => 'google.com',
+          'port' => 12_345
+        }
+      },
+      'port' => 8080,
+      'host' => '0.0.0.0',
+      'enable_middlewares' => true,
+      'limits' => {
+        'withdraw' => 1_000_000,
+        'deposit' => 3_000_000
+      },
+      'api' => {
+        'version' => '0.1.0',
+        'header' => 'app.vendor',
+        'strategy' => {
+          'format' => :json
+        }
+      }
+    )
+
+    # reconfgure
+    config.configure do |conf|
+      conf.api.version = '0.2.0'
+      conf.api.header = 'app.super.vendor'
+      conf.api.strategy.format = :xml
+      conf.db.username = 'che'
+      conf.db.password = 'burek'
+      conf.db.connection.address = 'db.google.com'
+      conf.db.connection.port = 666
+      conf.port = 8081
+      conf.host = 'app.google.com'
+      conf.enable_middlewares = false
+      conf.limits.withdraw = 0
+      conf.limits.deposit = 1_000
+    end
+
+    config.settings.tap do |conf|
+      expect(conf.api.version).to eq('0.2.0')
+      expect(conf.api.header).to eq('app.super.vendor')
+      expect(conf.api.strategy.format).to eq(:xml)
+      expect(conf.db.username).to eq('che')
+      expect(conf.db.password).to eq('burek')
+      expect(conf.db.connection.address).to eq('db.google.com')
+      expect(conf.db.connection.port).to eq(666)
+      expect(conf.port).to eq(8081)
+      expect(conf.host).to eq('app.google.com')
+      expect(conf.enable_middlewares).to eq(false)
+      expect(conf.limits.withdraw).to eq(0)
+      expect(conf.limits.deposit).to eq(1_000)
+
+      expect(conf[:api][:version]).to eq('0.2.0')
+      expect(conf[:api][:header]).to eq('app.super.vendor')
+      expect(conf[:api][:strategy][:format]).to eq(:xml)
+      expect(conf[:db][:username]).to eq('che')
+      expect(conf[:db][:password]).to eq('burek')
+      expect(conf[:db][:connection][:address]).to eq('db.google.com')
+      expect(conf[:db][:connection][:port]).to eq(666)
+      expect(conf[:port]).to eq(8081)
+      expect(conf[:host]).to eq('app.google.com')
+      expect(conf[:enable_middlewares]).to eq(false)
+      expect(conf[:limits][:withdraw]).to eq(0)
+      expect(conf[:limits][:deposit]).to eq(1_000)
+    end
+
+    expect(config.to_h).to match(
+      'db' => {
+        'username' => 'che',
+        'password' => 'burek',
+        'connection' => {
+          'address' => 'db.google.com',
+          'port' => 666
+        }
+      },
+      'port' => 8081,
+      'host' => 'app.google.com',
+      'enable_middlewares' => false,
+      'limits' => {
+        'withdraw' => 0,
+        'deposit' => 1_000
+      },
+      'api' => {
+        'version' => '0.2.0',
+        'header' => 'app.super.vendor',
+        'strategy' => {
+          'format' => :xml
+        }
+      }
+    )
+  end
+
+  specify 'composed config class should be a subtype of Qonfig::DataSet' do
+    InappropriateConfig = Class.new
+    AppropriateConfig = Class.new(Qonfig::DataSet)
+
+    expect do
+      # (with incompatible config class) on the root
+      Class.new(Qonfig::DataSet) do
+        compose InappropriateConfig
+      end
+    end.to raise_error(Qonfig::ArgumentError)
+
+    expect do
+      # (with compatible config class) on the root
+      Class.new(Qonfig::DataSet) do
+        compose AppropriateConfig
+      end
+    end.not_to raise_error
+
+    expect do
+      # (with incompatible config class) nested
+      Class.new(Qonfig::DataSet) do
+        setting :nested do
+          compose InappropriateConfig
+        end
+      end
+    end.to raise_error(Qonfig::ArgumentError)
+
+    expect do
+      # (with compatible config class) nested
+      Class.new(Qonfig::DataSet) do
+        setting :nested do
+          compose AppropriateConfig
+        end
+      end
+    end.not_to raise_error
+  end
+end

data/spec/features/config_definition_and_representation_spec.rb

@@ -0,0 +1,535 @@
+# frozen_string_literal: true
+
+describe 'Config definition and representation' do
+  specify 'config object definition, instantiation, settings access and mutation' do
+    class SimpleConfig < Qonfig::DataSet
+      # setting with nested options
+      setting :serializers do
+        # :native by default
+        setting :json, :native
+      end
+
+      # another setting with nested options
+      setting :mutations do
+        # subsetting
+        setting :action do
+          # nil by default
+          setting :query
+        end
+      end
+
+      # nested option reopening
+      setting :serializers do
+        # :native by default
+        setting :xml, :native
+      end
+
+      setting :defaults do
+        setting :test, false
+      end
+      # existing nested config redifinition (nested => value)
+      setting :defaults, nil
+
+      setting :shared, true
+      # existind setting redifinition (value => nested)
+      setting :shared do
+        setting :convert, false
+      end
+
+      # setting without nested options
+      setting :steps, 22
+    end
+
+    # instantiation
+    config = SimpleConfig.new
+
+    # access via method named as a setting key
+    expect(config.settings.serializers.json).to eq(:native)
+    expect(config.settings.serializers.xml).to eq(:native)
+    expect(config.settings.mutations.action.query).to eq(nil)
+    expect(config.settings.steps).to eq(22)
+    expect(config.settings.defaults).to eq(nil)
+    expect(config.settings.shared.convert).to eq(false)
+
+    # access via index named as a setting key
+    expect(config.settings[:serializers][:json]).to eq(:native)
+    expect(config.settings[:serializers][:xml]).to eq(:native)
+    expect(config.settings[:mutations][:action][:query]).to eq(nil)
+    expect(config.settings[:steps]).to eq(22)
+
+    # hash representation
+    expect(config.to_h).to match(
+      'serializers' => {
+        'json' => :native,
+        'xml' => :native
+      },
+      'defaults' => nil,
+      'shared' => {
+        'convert' => false
+      },
+      'mutations' => {
+        'action' => {
+          'query' => nil
+        }
+      },
+      'steps' => 22
+    )
+
+    # hash representation (with key transformation)
+    expect(config.to_h(key_transformer: proc { |value| value.to_sym })).to match(
+      serializers: {
+        json: :native,
+        xml: :native
+      },
+      defaults: nil,
+      shared: {
+        convert: false
+      },
+      mutations: {
+        action: {
+          query: nil
+        }
+      },
+      steps: 22
+    )
+
+    # hash representation (with value transformation)
+    expect(config.to_h(value_transformer: proc { |value| value.to_s })).to match(
+      'serializers' => {
+        'json' => 'native',
+        'xml' => 'native'
+      },
+      'defaults' => '',
+      'shared' => {
+        'convert' => 'false'
+      },
+      'mutations' => {
+        'action' => {
+          'query' => ''
+        }
+      },
+      'steps' => '22'
+    )
+
+    # hash representation (with key and value transformations)
+    expect(
+      config.to_h(
+        key_transformer: proc { |value| value.to_sym },
+        value_transformer: proc { |value| value.to_s }
+      )
+    ).to match(
+      serializers: {
+        json: 'native',
+        xml: 'native'
+      },
+      defaults: '',
+      shared: {
+        convert: 'false'
+      },
+      mutations: {
+        action: {
+          query: ''
+        }
+      },
+      steps: '22'
+    )
+
+    # configuration via block (classic style)
+    config.configure do |conf|
+      conf.serializers.json = :oj
+      conf.serializers.xml = :ox
+      conf.mutations.action.query = 'select'
+      conf.steps = 31
+    end
+
+    # access via method named as a setting key
+    expect(config.settings.serializers.json).to eq(:oj)
+    expect(config.settings.serializers.xml).to eq(:ox)
+    expect(config.settings.mutations.action.query).to eq('select')
+    expect(config.settings.steps).to eq(31)
+
+    # access via option index named as a setting key
+    expect(config.settings[:serializers][:json]).to eq(:oj)
+    expect(config.settings[:serializers][:xml]).to eq(:ox)
+    expect(config.settings[:mutations][:action][:query]).to eq('select')
+    expect(config.settings[:steps]).to eq(31)
+
+    # configuration via settings method
+    config.settings.serializers.json = 'circular'
+    config.settings.serializers.xml = 'angular'
+    config.settings.mutations.action.query = :update
+    config.settings.steps = nil
+
+    # access via method named as a setting key
+    expect(config.settings.serializers.json).to eq('circular')
+    expect(config.settings.serializers.xml).to eq('angular')
+    expect(config.settings.mutations.action.query).to eq(:update)
+    expect(config.settings.steps).to eq(nil)
+
+    # access via option index named as a setting key
+    expect(config.settings[:serializers][:json]).to eq('circular')
+    expect(config.settings[:serializers][:xml]).to eq('angular')
+    expect(config.settings[:mutations][:action][:query]).to eq(:update)
+    expect(config.settings[:steps]).to eq(nil)
+
+    # configuration via index accessing
+    config.settings[:serializers][:json] = 'pararam'
+    config.settings[:serializers][:xml] = 'tratata'
+    config.settings[:mutations][:action][:query] = :upsert
+    config.settings[:steps] = 1234
+
+    # access via method named as a setting key
+    expect(config.settings.serializers.json).to eq('pararam')
+    expect(config.settings.serializers.xml).to eq('tratata')
+    expect(config.settings.mutations.action.query).to eq(:upsert)
+    expect(config.settings.steps).to eq(1234)
+
+    # access via option index named as a setting key
+    expect(config.settings[:serializers][:json]).to eq('pararam')
+    expect(config.settings[:serializers][:xml]).to eq('tratata')
+    expect(config.settings[:mutations][:action][:query]).to eq(:upsert)
+    expect(config.settings[:steps]).to eq(1234)
+
+    # instant configuration via proc
+    config = SimpleConfig.new do |conf|
+      conf.serializers.json = :native
+      conf.serializers.xml = :native
+      conf.mutations.action.query = 'delete'
+      conf.steps = 0
+    end
+
+    # access via method named as a setting key
+    expect(config.settings.serializers.json).to eq(:native)
+    expect(config.settings.serializers.xml).to eq(:native)
+    expect(config.settings.mutations.action.query).to eq('delete')
+    expect(config.settings.steps).to eq(0)
+
+    # access via option index named as a setting key
+    expect(config.settings[:serializers][:json]).to eq(:native)
+    expect(config.settings[:serializers][:xml]).to eq(:native)
+    expect(config.settings[:mutations][:action][:query]).to eq('delete')
+    expect(config.settings[:steps]).to eq(0)
+
+    # attempt to get an access to the unexistent setting
+    expect { config.settings.deserialization }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.settings.mutations.global }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.settings[:deserialization] }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.settings.mutations[:global] }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.settings.mutations[:global] = 1 }.to raise_error(Qonfig::UnknownSettingError)
+
+    # access via []-method with indifferent access and dot-notation
+    expect(config[:serializers]['json']).to eq(:native)
+    expect(config['serializers'][:xml]).to eq(:native)
+    expect(config[:mutations][:action][:query]).to eq('delete')
+    expect(config['steps']).to eq(0)
+    expect(config['serializers.json']).to eq(:native)
+    expect(config['serializers.xml']).to eq(:native)
+    expect(config['mutations.action.query']).to eq('delete')
+
+    # configuration via []=-method with/and/without dot-notation
+    config['serializers.json'] = :non_native
+    config['serializers.xml'] = :non_native
+    expect(config['serializers.json']).to eq(:non_native)
+    expect(config['serializers.xml']).to eq(:non_native)
+
+    # mutation of non-existent keys via []=-method fails with error
+    expect { config['serializers.toml'] = :native }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config['mutations.operation'] = :upgrade }.to raise_error(Qonfig::UnknownSettingError)
+
+    # ambigous mutation via []=-method fails with corresponding error
+    expect do
+      config['mutations.action'] = :select
+    end.to raise_error(Qonfig::AmbiguousSettingValueError)
+
+    # hash representation
+    expect(config.to_h).to match(
+      'serializers' => {
+        'json' => :non_native,
+        'xml' => :non_native
+      },
+      'defaults' => nil,
+      'shared' => {
+        'convert' => false
+      },
+      'mutations' => {
+        'action' => {
+          'query' => 'delete'
+        }
+      },
+      'steps' => 0
+    )
+  end
+
+  specify 'configuration via hash / hash + proc (instant and not)' do
+    class HashConfigurableConfig < Qonfig::DataSet
+      setting :a do
+        setting :b
+        setting :c
+      end
+
+      setting :d
+      setting :e
+    end
+
+    # configure by hash (via .new)
+    config = HashConfigurableConfig.new(
+      a: {
+        b: { g: 33 },
+        c: 2
+      },
+      d: 33,
+      e: { f: 49 }
+    )
+    expect(config.to_h).to match(
+      'a' => {
+        'b' => { g: 33 },
+        'c' => 2
+      },
+      'd' => 33,
+      'e' => { f: 49 }
+    )
+
+    # configure by hash (via #configure)
+    config = HashConfigurableConfig.new
+    config.configure(
+      a: {
+        b: 'test',
+        c: 'no_test'
+      },
+      d: 100_500,
+      e: false
+    )
+    expect(config.to_h).to match(
+      'a' => {
+        'b' => 'test',
+        'c' => 'no_test'
+      },
+      'd' => 100_500,
+      'e' => false
+    )
+
+    # mixed: configure by hash + proc (via .new)
+    config = HashConfigurableConfig.new(d: false, e: true) do |conf|
+      conf.a.b = 123
+      conf.a.c = 456
+    end
+    expect(config.to_h).to match(
+      'a' => {
+        'b' => 123,
+        'c' => 456
+      },
+      'd' => false,
+      'e' => true
+    )
+
+    # mixed: configure by hash + proc (via #configure)
+    config = HashConfigurableConfig.new
+    config.configure(a: { b: { c: 49 }, c: 55 }) do |conf|
+      conf.d = 0.55
+      conf.e = false
+    end
+    expect(config.to_h).to match(
+      'a' => {
+        'b' => { c: 49 },
+        'c' => 55
+      },
+      'd' => 0.55,
+      'e' => false
+    )
+
+    # proc has higher priority
+    config = HashConfigurableConfig.new(a: { b: 1, c: 2 }, d: 3, e: 4) do |conf|
+      conf.a.b = 5
+      conf.a.c = 6
+      conf.d = 7
+      conf.e = 8
+    end
+    expect(config.to_h).to match(
+      'a' => {
+        'b' => 5,
+        'c' => 6
+      },
+      'd' => 7,
+      'e' => 8
+    )
+
+    expect do
+      # nonexistent nested key
+      HashConfigurableConfig.new(a: { e: 55 })
+    end.to raise_error(Qonfig::UnknownSettingError)
+    expect do
+      # nonexistend nested key + proc
+      HashConfigurableConfig.new(a: { e: 55 }) { |conf| conf.d = 'test' }
+    end.to raise_error(Qonfig::UnknownSettingError)
+
+    expect do
+      # nonexistent root key
+      HashConfigurableConfig.new(g: 'test')
+    end.to raise_error(Qonfig::UnknownSettingError)
+    expect do
+      # nonexistent root key + proc
+      HashConfigurableConfig.new(g: 'test') { |conf| conf.e = false }
+    end.to raise_error(Qonfig::UnknownSettingError)
+
+    expect do
+      # attempt to override nested settings
+      HashConfigurableConfig.new(a: 100)
+    end.to raise_error(Qonfig::AmbiguousSettingValueError)
+    expect do
+      # attempt to override nested settings (+ proc)
+      HashConfigurableConfig.new(a: 100) { |conf| conf.a.b = :none }
+    end.to raise_error(Qonfig::AmbiguousSettingValueError)
+
+    # attempt to use non-hash object
+    [1, 1.0, Object.new, true, false, Class.new, Module.new, (proc {}), (-> {})].each do |non_hash|
+      expect do
+        # without proc
+        HashConfigurableConfig.new(non_hash)
+      end.to raise_error(Qonfig::ArgumentError)
+
+      expect do
+        # with valid proc
+        HashConfigurableConfig.new(non_hash) { |conf| conf.d = 55 }
+      end.to raise_error(Qonfig::ArgumentError)
+    end
+  end
+
+  specify '(#to_h): key (and value) transformer should be a type of Proc' do
+    empty_config = Class.new(Qonfig::DataSet).new
+
+    expect do
+      empty_config.to_h(key_transformer: 123)
+    end.to raise_error(Qonfig::IncorrectKeyTransformerError)
+
+    expect do
+      empty_config.to_h(value_transformer: 123)
+    end.to raise_error(Qonfig::IncorrectValueTransformerError)
+
+    expect do
+      empty_config.to_h(key_transformer: proc {}, value_transformer: 123)
+    end.to raise_error(Qonfig::IncorrectValueTransformerError)
+
+    expect do
+      empty_config.to_h(key_transformer: 123, value_transformer: proc {})
+    end.to raise_error(Qonfig::IncorrectKeyTransformerError)
+
+    expect do
+      empty_config.to_h(key_transformer: 123, value_transformer: 123)
+    end.to raise_error(Qonfig::IncorrectHashTransformationError)
+
+    expect do
+      empty_config.to_h(key_transformer: proc {}, value_transformer: proc {})
+    end.not_to raise_error
+
+    expect do
+      empty_config.to_h(key_transformer: proc {})
+    end.not_to raise_error
+
+    expect do
+      empty_config.to_h(value_transformer: proc {})
+    end.not_to raise_error
+
+    expect do
+      empty_config.to_h
+    end.not_to raise_error
+  end
+
+  specify 'only string and symbol keys are supported' do
+    [1, 1.0, Object.new, true, false, Class.new, Module.new, (proc {}), (-> {})].each do |key|
+      expect do
+        Class.new(Qonfig::DataSet) { setting(key) }
+      end.to raise_error(Qonfig::ArgumentError)
+    end
+
+    expect do
+      Class.new(Qonfig::DataSet) do
+        setting :a
+        setting 'b'
+      end
+    end.not_to raise_error
+  end
+
+  specify 'causes an error when tries to assign a setting value to an option ' \
+          'which already have another nested options' do
+    class WithNestedOptionsConfig < Qonfig::DataSet
+      setting :database do
+        setting :hostname, 'localhost'
+      end
+    end
+
+    config = WithNestedOptionsConfig.new
+
+    expect do
+      config.configure { |conf| conf.database = double }
+    end.to raise_error(Qonfig::AmbiguousSettingValueError)
+
+    expect do
+      config.configure { |conf| conf[:database] = double }
+    end.to raise_error(Qonfig::AmbiguousSettingValueError)
+
+    expect do
+      config.configure { |conf| conf[:database][:hostname] = double }
+    end.not_to raise_error
+
+    expect do
+      config.configure { |conf| conf.database.hostname = double }
+    end.not_to raise_error
+  end
+
+  specify 'fails when tries to use a non-string/non-symbol value as a setting key' do
+    incorrect_key_values = [123, Object.new, 15.1, (proc {}), Class.new, true, false]
+    correct_key_values   = ['test', :test]
+
+    incorrect_key_values.each do |incorrect_key|
+      # check root
+      expect do
+        Class.new(Qonfig::DataSet) { setting incorrect_key }
+      end.to raise_error(Qonfig::ArgumentError)
+
+      # check nested
+      expect do
+        Class.new(Qonfig::DataSet) do
+          setting incorrect_key do
+            setting :any
+          end
+        end
+      end.to raise_error(Qonfig::ArgumentError)
+
+      # check nested
+      expect do
+        Class.new(Qonfig::DataSet) do
+          setting :any do
+            setting incorrect_key
+          end
+        end
+      end.to raise_error(Qonfig::ArgumentError)
+    end
+
+    correct_key_values.each do |correct_key|
+      # check root
+      expect do
+        Class.new(Qonfig::DataSet) do
+          setting correct_key
+        end
+      end.not_to raise_error
+
+      # check nested
+      expect do
+        Class.new(Qonfig::DataSet) do
+          setting correct_key do
+            setting :any
+          end
+        end
+      end.not_to raise_error
+
+      # check nested do
+      expect do
+        Class.new(Qonfig::DataSet) do
+          setting :any do
+            setting correct_key
+          end
+        end
+      end.not_to raise_error
+    end
+  end
+end