qonfig 0.25.0 → 0.26.0

data/spec/features/load_from_json_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+describe 'Load from JSON' do
+  specify 'defines config object by json instructions' do
+    class JSONBasedConfig < Qonfig::DataSet
+      load_from_json SpecSupport.fixture_path('json_object_sample.json')
+
+      setting :nested do
+        load_from_json SpecSupport.fixture_path('json_object_sample.json')
+      end
+
+      setting :with_empty_objects do
+        load_from_json SpecSupport.fixture_path('json_with_empty_object.json')
+      end
+
+      setting :with_erb do
+        load_from_json SpecSupport.fixture_path('json_with_erb.json')
+      end
+    end
+
+    JSONBasedConfig.new.settings.tap do |conf|
+      expect(conf.user).to eq('D@iVeR')
+      expect(conf.maxAuthCount).to eq(55)
+      expect(conf.rubySettings.allowedVersions).to eq(['2.3', '2.4.2', '1.9.8'])
+      expect(conf.rubySettings.gitLink).to eq(nil)
+      expect(conf.rubySettings.withAdditionals).to eq(false)
+
+      expect(conf.nested.user).to eq('D@iVeR')
+      expect(conf.nested.maxAuthCount).to eq(55)
+      expect(conf.nested.rubySettings.allowedVersions).to eq(['2.3', '2.4.2', '1.9.8'])
+      expect(conf.nested.rubySettings.gitLink).to eq(nil)
+      expect(conf.nested.rubySettings.withAdditionals).to eq(false)
+
+      expect(conf.with_empty_objects.requirements).to eq({})
+      expect(conf.with_empty_objects.credentials.excluded).to eq({})
+
+      expect(conf.with_erb.count).to eq(10_000)
+      expect(conf.with_erb.credentials.excluded).to eq("some string here")
+    end
+  end
+
+  specify 'fails when json object has non-hash-like structure' do
+    class IncompatibleJSONConfig < Qonfig::DataSet
+      load_from_json SpecSupport.fixture_path('json_array_sample.json')
+    end
+
+    expect { IncompatibleJSONConfig.new }.to raise_error(Qonfig::IncompatibleJSONStructureError)
+  end
+
+  specify 'support for Pathname in file path' do
+    class PathanmeJSONLoadCheckConfig < Qonfig::DataSet
+      load_from_json Pathname.new(SpecSupport.fixture_path('json_object_sample.json'))
+    end
+
+    config = PathanmeJSONLoadCheckConfig.new
+
+    expect(config.settings.user).to eq('D@iVeR')
+    expect(config.settings.maxAuthCount).to eq(55)
+    expect(config.settings.rubySettings.allowedVersions).to eq(['2.3', '2.4.2', '1.9.8'])
+    expect(config.settings.rubySettings.gitLink).to eq(nil)
+    expect(config.settings.rubySettings.withAdditionals).to eq(false)
+  end
+
+  describe ':strict mode option (when file doesnt exist)' do
+    context 'when :strict => true (by default)' do
+      specify 'fails with corresponding error' do
+        # check default behaviour (strict: true)
+        class FailingJSONConfig < Qonfig::DataSet
+          load_from_json 'no_file.json'
+        end
+
+        expect { FailingJSONConfig.new }.to raise_error(Qonfig::FileNotFoundError)
+
+        class ExplicitlyStrictedJSONCOnfig < Qonfig::DataSet
+          load_from_json 'no_file.json', strict: true
+        end
+
+        expect { ExplicitlyStrictedJSONCOnfig.new }.to raise_error(Qonfig::FileNotFoundError)
+      end
+    end
+
+    context 'when :strict => false' do
+      specify 'does not fail - empty config' do
+        class NonFailingJSONConfig < Qonfig::DataSet
+          load_from_json 'no_file.json', strict: false
+
+          setting :nested do
+            load_from_json 'no_file.json', strict: false
+          end
+        end
+
+        expect { NonFailingJSONConfig.new }.not_to raise_error
+        expect(NonFailingJSONConfig.new.to_h).to eq('nested' => {})
+      end
+    end
+  end
+end

data/spec/features/load_from_self/format_option_json_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+describe '#load_from_self => format: :json' do
+  specify ':json-format support' do
+    class JsonEndDataConfig < Qonfig::DataSet
+      load_from_self format: :json
+    end
+
+    config = JsonEndDataConfig.new
+
+    expect(config.settings.credentials.user).to eq('admin')
+    expect(config.settings.credentials.password).to eq('123')
+    expect(config.settings.credentials.enabled).to eq(true)
+    expect(config.settings.amount).to eq(123.456)
+    expect(config.settings.data).to eq(nil)
+    expect(config.settings.methods).to eq([1, 'test', nil, true, false, ['data']])
+  end
+end
+
+__END__
+
+{
+  "credentials": {
+    "user": "admin",
+    "password": "123",
+    "enabled": true
+  },
+  "amount": 123.456,
+  "data": null,
+  "methods": [1, "test", null, true, false, ["data"]]
+}

data/spec/features/load_from_self/format_option_unsupported_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+describe '#load_from_self => format: <unsupported>' do
+  specify 'fails on unsupported formats' do
+    expect do
+      Class.new(Qonfig::DataSet) do
+        load_from_self format: :atata
+      end
+    end.to raise_error(Qonfig::UnsupportedLoaderFormatError)
+  end
+
+  specify 'fails on empty format parameter' do
+    expect do
+      Class.new(Qonfig::DataSet) do
+        load_from_self format: ''
+      end
+    end.to raise_error(Qonfig::UnsupportedLoaderFormatError)
+  end
+
+  specify 'fails on incorrect format parameter' do
+    expect do
+      Class.new(Qonfig::DataSet) do
+        load_from_self format: Object.new
+      end
+    end.to raise_error(Qonfig::ArgumentError)
+  end
+end

data/spec/features/load_from_self/format_option_yaml_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+describe '#load_from_self => format: :yaml' do
+  specify ':yaml/:yml-format support' do
+    class YamlEndDataConfig < Qonfig::DataSet
+      setting :by_yml do
+        load_from_self format: :yml # the same as :yaml
+      end
+
+      setting :by_yaml do
+        load_from_self format: :yaml # the same as :yml
+      end
+    end
+
+    config = YamlEndDataConfig.new
+
+    # NOTE: format: :yml
+    expect(config.settings.by_yml.credentials.user).to eq('admin')
+    expect(config.settings.by_yml.credentials.password).to eq('123')
+    expect(config.settings.by_yml.credentials.enabled).to eq(true)
+    expect(config.settings.by_yml.amount).to eq(123.456)
+    expect(config.settings.by_yml.data).to eq(nil)
+    expect(config.settings.by_yml.methods).to eq([1, 'test', nil, true, false, ['data']])
+
+    # NOTE: format: :yaml
+    expect(config.settings.by_yaml.credentials.user).to eq('admin')
+    expect(config.settings.by_yaml.credentials.password).to eq('123')
+    expect(config.settings.by_yaml.credentials.enabled).to eq(true)
+    expect(config.settings.by_yaml.amount).to eq(123.456)
+    expect(config.settings.by_yaml.data).to eq(nil)
+    expect(config.settings.by_yaml.methods).to eq([1, 'test', nil, true, false, ['data']])
+  end
+end
+
+__END__
+
+credentials:
+  user: 'admin'
+  password: '123'
+  enabled: true
+amount: 123.456
+data: ~
+methods:
+  - 1
+  - 'test'
+  - ~
+  - true
+  - false
+  - ['data']

data/spec/features/load_from_self/with_erb_instructions_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+describe 'Load from self (hash-like __END__ data representation with ERB inserts)' do
+  specify 'defines config object by self-contained __END__ yaml data with ERB inserts' do
+    class SelfDefinedWithErbConfig < Qonfig::DataSet
+      load_from_self
+    end
+
+    SelfDefinedWithErbConfig.new.settings.tap do |conf|
+      expect(conf.defaults.host).to eq('localhost')
+      expect(conf.defaults.user).to eq('0exp')
+      expect(conf.defaults.password).to eq('password4')
+      expect(conf.defaults.credentials).to eq({})
+
+      expect(conf.staging.host).to eq('yandex.ru')
+      expect(conf.staging.user).to eq('0exp')
+      expect(conf.staging.password).to eq('password4')
+      expect(conf.staging.credentials).to eq({})
+    end
+  end
+end
+
+__END__
+
+defaults: &defaults
+  host: localhost
+  user: <%= '0exp' %>
+  password: <%= "password#{(2 * 2)}" %>
+  credentials: <%= {} %>
+
+staging:
+  <<: *defaults
+  host: yandex.ru

data/spec/features/load_from_self/with_hash_like_data_representation_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+describe 'Load from self (hash-like __END__ data representation)' do
+  specify 'defines config object by self-contained __END__ yaml data' do
+    class SelfDefinedConfig < Qonfig::DataSet
+      load_from_self # yaml format will be automatically resolved
+
+      setting :with_nesting do
+        load_from_self
+      end
+    end
+
+    SelfDefinedConfig.new.settings.tap do |conf|
+      # access via method
+      expect(conf.secret_key).to eq('top-mega-secret')
+      expect(conf.api_host).to eq('super.puper-google.com')
+      expect(conf.requirements).to eq({})
+      expect(conf.connection_timeout.seconds).to eq(10)
+      expect(conf.connection_timeout.enabled).to eq(false)
+      expect(conf.defaults.port).to eq(12_345)
+      expect(conf.defaults.host).to eq('localhost')
+      expect(conf.staging.port).to eq(12_345)
+      expect(conf.staging.host).to eq('google.kek')
+
+      # access via index
+      expect(conf['secret_key']).to eq('top-mega-secret')
+      expect(conf['api_host']).to eq('super.puper-google.com')
+      expect(conf['requirements']).to eq({})
+      expect(conf[:connection_timeout]['seconds']).to eq(10)
+      expect(conf[:connection_timeout]['enabled']).to eq(false)
+      expect(conf['defaults']['port']).to eq(12_345)
+      expect(conf['defaults']['host']).to eq('localhost')
+      expect(conf['staging']['port']).to eq(12_345)
+      expect(conf['staging']['host']).to eq('google.kek')
+
+      expect(conf.with_nesting.secret_key).to eq('top-mega-secret')
+      expect(conf.with_nesting.api_host).to eq('super.puper-google.com')
+      expect(conf.with_nesting.connection_timeout.seconds).to eq(10)
+      expect(conf.with_nesting.connection_timeout.enabled).to eq(false)
+      expect(conf.with_nesting.requirements).to eq({})
+
+      expect(conf[:with_nesting]['secret_key']).to eq('top-mega-secret')
+      expect(conf[:with_nesting]['api_host']).to eq('super.puper-google.com')
+      expect(conf[:with_nesting][:requirements]).to eq({})
+      expect(conf[:with_nesting][:connection_timeout]['seconds']).to eq(10)
+      expect(conf[:with_nesting][:connection_timeout]['enabled']).to eq(false)
+    end
+  end
+end
+
+__END__
+
+defaults: &defaults
+  port: 12345
+  host: 'localhost'
+
+staging:
+  <<: *defaults
+  host: 'google.kek'
+
+secret_key: top-mega-secret
+api_host: super.puper-google.com
+requirements: {}
+:connection_timeout:
+   seconds: 10
+   enabled: false

data/spec/features/load_from_self/with_non_hash_like_data_representation_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+describe 'Load from self (non-hash-like __END__ data representation)' do
+  specify 'fails when yaml data is not represented as a hash' do
+    class IncompatibleSelfDataConfig < Qonfig::DataSet
+      load_from_self
+    end
+
+    expect { IncompatibleSelfDataConfig.new }.to raise_error(
+      Qonfig::IncompatibleEndDataStructureError
+    )
+  end
+end
+
+__END__
+
+- user
+- password
+- 123

data/spec/features/load_from_self/without_end_data_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+describe 'Load from self (without __END__ data)' do
+  specify 'fails when yaml data is not represented as a hash' do
+    class MissingSelfDataConfig < Qonfig::DataSet
+      load_from_self
+    end
+
+    expect { MissingSelfDataConfig.new }.to raise_error(Qonfig::SelfDataNotFoundError)
+  end
+end

data/spec/features/load_from_yaml_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+describe 'Load from YAML' do
+  specify 'defines config object by yaml instructions' do
+    class CISettings < Qonfig::DataSet
+      load_from_yaml SpecSupport.fixture_path('shared_settings_with_aliases.yml')
+
+      setting :travis do
+        load_from_yaml SpecSupport.fixture_path('travis_settings.yml')
+      end
+
+      setting :rubocop do
+        load_from_yaml SpecSupport.fixture_path('rubocop_settings.yml')
+      end
+
+      setting :with_erb do
+        load_from_yaml SpecSupport.fixture_path('with_erb_instructions.yml')
+      end
+
+      setting :with_empty_hash do
+        load_from_yaml SpecSupport.fixture_path('with_empty_hash.yml')
+      end
+    end
+
+    CISettings.new.settings.tap do |conf|
+      # shared_settings_with_aliases.yml
+      expect(conf.enable_api).to eq(false)
+      expect(conf.run_sidekiq).to eq(true)
+      expect(conf.default.test).to eq(true)
+      expect(conf.default.engine).to eq('rspec')
+      expect(conf.staging.test).to eq(true)
+      expect(conf.staging.engine).to eq('minitest')
+
+      # travis_settings.yml
+      expect(conf.travis.language).to eq('ruby')
+      expect(conf.travis.rvm).to contain_exactly('2.5.1', 'ruby-head', 'jruby-head')
+      expect(conf.travis.sudo).to eq(false)
+
+      # rubocop_settings.yml
+      expect(conf['rubocop']['require']).to eq('rubocop-rspec')
+      expect(conf['rubocop']['AllCops']['Include']).to contain_exactly('lib/**/*', 'spec/**/*')
+      expect(conf['rubocop']['AllCops']['Exclude']).to contain_exactly('bin/**/*', 'Gemfile')
+      expect(conf['rubocop']['Metrics/LineLength']['Max']).to eq(100)
+
+      # with_erb_instructions.yml
+      expect(conf['with_erb']['user']).to eq('D@iVeR')
+      expect(conf['with_erb']['max_auth_count']).to eq(2)
+      expect(conf['with_erb']['ruby_version']).to eq(RUBY_VERSION)
+
+      # with_empty_hash.yml
+      expect(conf['with_empty_hash']['settings']).to eq({})
+      expect(conf['with_empty_hash']['another_settings']['option_a']).to eq({})
+      expect(conf['with_empty_hash']['another_settings']['option_b']).to eq(1)
+    end
+  end
+
+  specify 'fails when yaml settings is not represented as a hash' do
+    class IncompatibleYAMLConfig < Qonfig::DataSet
+      load_from_yaml SpecSupport.fixture_path('array_settings.yml')
+    end
+
+    expect { IncompatibleYAMLConfig.new }.to raise_error(Qonfig::IncompatibleYAMLStructureError)
+  end
+
+  specify 'support for Pathname in file path' do
+    class PathnameYAMLLoadCheck < Qonfig::DataSet
+      load_from_yaml Pathname.new(SpecSupport.fixture_path('travis_settings.yml'))
+    end
+
+    config = PathnameYAMLLoadCheck.new
+
+    expect(config.settings.sudo).to eq(false)
+    expect(config.settings.language).to eq('ruby')
+    expect(config.settings.rvm).to contain_exactly('2.5.1', 'ruby-head', 'jruby-head')
+  end
+
+  describe ':strict mode option (when file does not exist)' do
+    context 'when :strict => true (by default)' do
+      specify 'fails with corresponding error' do
+        # check default behaviour (strict: true)
+        class FailingYAMLConfig < Qonfig::DataSet
+          load_from_yaml 'no_file.yml'
+        end
+
+        expect { FailingYAMLConfig.new }.to raise_error(Qonfig::FileNotFoundError)
+
+        class ExplicitlyStrictedYAMLConfig < Qonfig::DataSet
+          load_from_yaml 'no_file.yml', strict: true
+        end
+
+        expect { ExplicitlyStrictedYAMLConfig.new }.to raise_error(Qonfig::FileNotFoundError)
+      end
+    end
+
+    context 'when :strict => false' do
+      specify 'does not fail - empty config' do
+        class NonFailingYAMLConfig < Qonfig::DataSet
+          load_from_yaml 'no_file.yml', strict: false
+
+          setting :nested do
+            load_from_yaml 'no_file.yml', strict: false
+          end
+        end
+
+        expect { NonFailingYAMLConfig.new }.not_to raise_error
+        expect(NonFailingYAMLConfig.new.to_h).to eq('nested' => {})
+      end
+    end
+  end
+end