qonfig 0.25.0 → 0.26.0

data/spec/features/load_setting_values_from_file/by_instance_method_examples.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LineLength, Style/Semicolon
+shared_examples 'load setting values from file by instance methods' do |file_name:, file_with_env_name:, file_format:, load_by:|
+  specify "load values from #{file_format} file over existing (strict, explicit format, no env)" do
+    config = Class.new(Qonfig::DataSet) do
+      setting :enabled, true
+      setting :adapter, 'undefined'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    config.public_send(load_by, file_name)
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify "load values from #{file_format} file (strict, dynamic format, no env)" do
+    config = Class.new(Qonfig::DataSet) do
+      setting :enabled, nil
+      setting :adapter, 'no-adapter'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    config.load_from_file(file_name)
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify 'support for Pathname in file path' do
+    config = Class.new(Qonfig::DataSet) do
+      setting :enabled, true
+      setting :adapter, 'undefined'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    config.public_send(load_by, Pathname.new(file_name))
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify 'provides "do |config|" ability' do
+    config = Class.new(Qonfig::DataSet) do
+      setting :enabled, nil
+      setting :adapter, 'no-adapter'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    config.public_send(load_by, file_name) do |conf|
+      conf.enabled = true
+      conf.credentials.user = 'do_config'
+      conf.credentials.timeout = 0
+    end
+
+    expect(config.settings.enabled).to eq(true) # from do-config
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('do_config') # from do-config
+    expect(config.settings.credentials.timeout).to eq(0) # from do-config
+
+    config.public_send(load_by, file_with_env_name, expose: :test) do |conf|
+      conf.credentials.user = 'super_expose_test'
+    end
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('super_expose_test') # from do-config
+    expect(config.settings.credentials.timeout).to eq(321)
+
+    config.public_send(load_by, file_with_env_name, expose: :production) do |conf|
+      conf.adapter = 'overwatch'
+    end
+
+    expect(config.settings.enabled).to eq(true)
+    expect(config.settings.adapter).to eq('overwatch') # from do-config
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify 'can expose environment-based settings defined by key' do
+    config = Class.new(Qonfig::DataSet) do
+      setting :enabled, true
+      setting :adapter, 'resque'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    config.public_send(load_by, file_with_env_name, expose: :test)
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('D@iVeR')
+    expect(config.settings.credentials.timeout).to eq(321)
+
+    config.public_send(load_by, file_with_env_name, expose: :production)
+
+    expect(config.settings.enabled).to eq(true)
+    expect(config.settings.adapter).to eq('que')
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify 'fails when file does not exist (default strict behavior (strict: true))' do
+    config = nil
+    nonexistent_file = SpecSupport.fixture_path('values_file', "atata.#{file_format}")
+
+    expect do
+      config = Class.new(Qonfig::DataSet) do
+        setting :enabled, true
+        setting :adapter, 'undefined'
+        setting(:credentials) { setting :user; setting :timeout }
+      end.new
+
+      config.public_send(load_by, nonexistent_file)
+    end.to raise_error(Qonfig::FileNotFoundError)
+
+    # NOTE: check that original settings has original values
+    expect(config.settings.enabled).to eq(true)
+    expect(config.settings.adapter).to eq('undefined')
+    expect(config.settings.credentials.user).to eq(nil)
+    expect(config.settings.credentials.timeout).to eq(nil)
+  end
+
+  specify 'does not fail when file does not exist and strict behaviour is disabled (strict: false)' do
+    nonexistent_file = SpecSupport.fixture_path('values_file', "atata.#{file_format}")
+
+    config = Class.new(Qonfig::DataSet) do
+      setting :enabled, true
+      setting :adapter, 'undefined'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    expect { config.public_send(load_by, nonexistent_file, strict: false) }.not_to raise_error
+
+    # NOTE: check that original settings has original values
+    expect(config.settings.enabled).to eq(true)
+    expect(config.settings.adapter).to eq('undefined')
+    expect(config.settings.credentials.user).to eq(nil)
+    expect(config.settings.credentials.timeout).to eq(nil)
+  end
+
+  specify 'fails when method attributes are incorrect' do
+    config = Class.new(Qonfig::DataSet) do
+      setting :enabled, true
+      setting :adapter, 'undefined'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    # incorrect file path
+    expect do
+      config.public_send(load_by, 123)
+    end.to raise_error(Qonfig::ArgumentError)
+
+    # incorrect :expose
+    expect do
+      config.public_send(load_by, file_name, expose: 123)
+    end.to raise_error(Qonfig::ArgumentError)
+
+    # incorrect :strict
+    expect do
+      config.public_send(load_by, file_name, strict: 123)
+    end.to raise_error(Qonfig::ArgumentError)
+  end
+end
+# rubocop:enable Layout/LineLength, Style/Semicolon

data/spec/features/load_setting_values_from_file/by_macros_examples.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LineLength, Style/Semicolon
+shared_examples 'load setting values from file by macros' do |file_name:, file_with_env_name:, file_format:|
+  specify "load values from #{file_format} file over existing (non-strict, explicit format, no env)" do
+    config = Class.new(Qonfig::DataSet) do
+      values_file file_name, format: file_format
+
+      setting :enabled, true
+      setting :adapter, 'undefined'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify 'support for Pathname in file path' do
+    config = Class.new(Qonfig::DataSet) do
+      values_file Pathname.new(file_name), format: file_format
+
+      setting :enabled, true
+      setting :adapter, 'undefined'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify 'works with inheritance and composition' do
+    base_config_klass = Class.new(Qonfig::DataSet) do
+      values_file file_name, format: file_format
+
+      setting :enabled, true
+      setting :adapter, 'undefined'
+      setting(:credentials) { setting :user; setting :timeout }
+    end
+
+    child_config_klass = Class.new(base_config_klass) do
+      compose base_config_klass
+      setting(:nested) { compose base_config_klass }
+    end
+
+    config = child_config_klass.new
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+    expect(config.settings.nested.enabled).to eq(false)
+    expect(config.settings.nested.adapter).to eq('sidekiq')
+    expect(config.settings.nested.credentials.user).to eq('0exp')
+    expect(config.settings.nested.credentials.timeout).to eq(123)
+  end
+
+  specify "load values from #{file_format} file (non-strict, dynamic format, no env)" do
+    config = Class.new(Qonfig::DataSet) do
+      values_file file_name
+
+      setting :enabled, nil
+      setting :adapter, 'no-adapter'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    expect(config.settings.enabled).to eq(false)
+    expect(config.settings.adapter).to eq('sidekiq')
+    expect(config.settings.credentials.user).to eq('0exp')
+    expect(config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify 'can expose environment-based settings defined by key' do
+    test_config = Class.new(Qonfig::DataSet) do
+      values_file file_with_env_name, expose: :test
+
+      setting :enabled, true
+      setting :adapter, 'resque'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    expect(test_config.settings.enabled).to eq(false)
+    expect(test_config.settings.adapter).to eq('sidekiq')
+    expect(test_config.settings.credentials.user).to eq('D@iVeR')
+    expect(test_config.settings.credentials.timeout).to eq(321)
+
+    production_config = Class.new(Qonfig::DataSet) do
+      values_file file_with_env_name, expose: :production
+
+      setting :enabled, true
+      setting :adapter, 'resque'
+      setting(:credentials) { setting :user; setting :timeout }
+    end.new
+
+    expect(production_config.settings.enabled).to eq(true)
+    expect(production_config.settings.adapter).to eq('que')
+    expect(production_config.settings.credentials.user).to eq('0exp')
+    expect(production_config.settings.credentials.timeout).to eq(123)
+  end
+
+  specify 'does not fails when file does not exist (default non-strict behavior)' do
+    config = nil
+
+    expect do
+      config = Class.new(Qonfig::DataSet) do
+        values_file SpecSupport.fixture_path('values_file', "atata.#{file_format}")
+
+        setting :enabled, true
+        setting :adapter, 'undefined'
+        setting(:credentials) { setting :user; setting :timeout }
+      end.new
+    end.not_to raise_error
+
+    expect do
+      # NOTE: (quietly :)) check that we can use expose param too :)
+      Class.new(Qonfig::DataSet) do
+        values_file SpecSupport.fixture_path('values_file', "atata.#{file_format}"), expose: :test
+      end.new
+    end.not_to raise_error
+
+    # NOTE: check that original settings has original values
+    expect(config.settings.enabled).to eq(true)
+    expect(config.settings.adapter).to eq('undefined')
+    expect(config.settings.credentials.user).to eq(nil)
+    expect(config.settings.credentials.timeout).to eq(nil)
+  end
+
+  specify 'fails when file does not exist (with configured strict behavior)' do
+    config_klass = Class.new(Qonfig::DataSet) do
+      values_file SpecSupport.fixture_path('values_file', "atata.#{file_format}"), strict: true
+
+      setting :enabled, true
+      setting :adapter, 'undefined'
+      setting(:credentials) { setting :user; setting :timeout }
+    end
+
+    expect { config_klass.new }.to raise_error(Qonfig::FileNotFoundError)
+  end
+
+  specify 'fails when method attributes are incorrect' do
+    # incorrect file path
+    expect do
+      Class.new(Qonfig::DataSet) { values_file 123 }
+    end.to raise_error(Qonfig::ArgumentError)
+
+    # incorrect :format
+    expect do
+      Class.new(Qonfig::DataSet) { values_file file_name, format: 123 }
+    end.to raise_error(Qonfig::ArgumentError)
+
+    # incorrect :expose
+    expect do
+      Class.new(Qonfig::DataSet) { values_file file_name, expose: 123 }
+    end.to raise_error(Qonfig::ArgumentError)
+
+    # incorrect :strict
+    expect do
+      Class.new(Qonfig::DataSet) { values_file file_name, strict: 123 }
+    end.to raise_error(Qonfig::ArgumentError)
+  end
+end
+# rubocop:enable Layout/LineLength, Style/Semicolon

data/spec/features/load_setting_values_from_file/load_from_json_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'by_macros_examples'
+require_relative 'by_instance_method_examples'
+
+describe 'Load setting values from JSON file' do
+  describe 'DSL macros (Qonfig::DataSet.values_file)' do
+    it_behaves_like 'load setting values from file by macros',
+                    file_name: SpecSupport.fixture_path('values_file', 'without_env.json'),
+                    file_with_env_name: SpecSupport.fixture_path('values_file', 'with_env.json'),
+                    file_format: :json
+  end
+
+  describe 'Instance methods (Qonfig::DataSet#load_from_file/.load_from_json' do
+    it_behaves_like 'load setting values from file by instance methods',
+                    file_name: SpecSupport.fixture_path('values_file', 'without_env.json'),
+                    file_with_env_name: SpecSupport.fixture_path('values_file', 'with_env.json'),
+                    load_by: :load_from_json,
+                    file_format: :json
+  end
+end

data/spec/features/load_setting_values_from_file/load_from_self/json_format/end_data_with_env_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+describe '.values_file / #load_from_self (__END__ data with env) (JSON format)' do
+  describe 'DSL macros' do
+    context '__END__ data has corresponding env key' do
+      let(:config_klass) do
+        Class.new(Qonfig::DataSet) do
+          values_file :self, format: :json, expose: :production
+
+          setting :user, 'D@iVeR'
+          setting :queue do
+            setting :adapter, 'que'
+            setting :concurrency, 2
+          end
+        end
+      end
+
+      specify 'loads setting values of corresponding environment' do
+        config = config_klass.new
+
+        expect(config.settings.user).to eq('iAmDaiveR')
+        expect(config.settings.queue.adapter).to eq('in_memory')
+        expect(config.settings.queue.concurrency).to eq(50)
+      end
+    end
+
+    context '__END__ data does not have correspodning env key' do
+      let(:config_klass) do
+        Class.new(Qonfig::DataSet) do
+          values_file :self, format: :json, expose: :staging
+
+          setting :user, 'D@iVeR'
+          setting :queue do
+            setting :adapter, 'que'
+            setting :concurrency, 2
+          end
+        end
+      end
+
+      specify 'ignrores values from __END__ data' do
+        config = config_klass.new
+
+        expect(config.settings.user).to eq('D@iVeR')
+        expect(config.settings.queue.adapter).to eq('que')
+        expect(config.settings.queue.concurrency).to eq(2)
+      end
+    end
+  end
+
+  describe 'Instance method' do
+    let(:config) do
+      Qonfig::DataSet.build do
+        setting :user, 'D@iVeR'
+        setting :queue do
+          setting :adapter, 'que'
+          setting :concurrency, 2
+        end
+      end
+    end
+
+    context '__END__ data has corresponding env key' do
+      specify 'loads setting values of corresponding environment' do
+        config.load_from_self(format: :json, expose: :production)
+
+        expect(config.settings.user).to eq('iAmDaiveR')
+        expect(config.settings.queue.adapter).to eq('in_memory')
+        expect(config.settings.queue.concurrency).to eq(50)
+      end
+    end
+
+    context '__END__ data does not have correspodning env key' do
+      specify 'ignrores values from __END__ data' do
+        config.load_from_self(format: :json, expose: :staging)
+
+        expect(config.settings.user).to eq('D@iVeR')
+        expect(config.settings.queue.adapter).to eq('que')
+        expect(config.settings.queue.concurrency).to eq(2)
+      end
+    end
+  end
+end
+
+__END__
+
+{
+  "test": {
+    "user": "0exp",
+    "queue": {
+      "adapter": "sidekiq",
+      "concurrency": 25
+    }
+  },
+  "production": {
+    "user": "iAmDaiveR",
+    "queue": {
+      "adapter": "in_memory",
+      "concurrency": 50
+    }
+  }
+}