qonfig 0.25.0 → 0.26.0

data/spec/features/save_to_file/save_to_json_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+describe 'Save to .json (JSON)' do
+  describe 'saving' do
+    let(:config_file_name) { "#{SecureRandom.uuid}.json" }
+    let(:config_file_path) { SpecSupport.artifact_path(config_file_name) }
+    let(:config_klass) do
+      Class.new(Qonfig::DataSet) do
+        setting :sentry do
+          setting :user, 'D@iVeR'
+          setting :callback, -> { 'loaded' }
+        end
+
+        setting :server_port, 123
+        setting :enabled, true
+      end
+    end
+    let(:config) { config_klass.new }
+
+    specify 'correctly represents config as JSON' do
+      # NOTE: step 1) save config (each config's value can be pre-processed via block)
+      config.save_to_json(path: config_file_path) do |value|
+        value.is_a?(Proc) ? value.call : value
+      end
+
+      # NOTE: step 2) read saved file
+      file_data = File.read(config_file_path)
+
+      expect(file_data).to eq(<<~JSON.strip)
+        {
+         "sentry": {
+          "user": "D@iVeR",
+          "callback": "loaded"
+         },
+         "server_port": 123,
+         "enabled": true
+        }
+      JSON
+    end
+
+    specify 'support for Pathname in file path' do
+      config.save_to_json(path: Pathname.new(config_file_path)) do |value|
+        value.is_a?(Proc) ? value.call : value
+      end
+
+      file_data = File.read(config_file_path)
+
+      expect(file_data).to eq(<<~JSON.strip)
+        {
+         "sentry": {
+          "user": "D@iVeR",
+          "callback": "loaded"
+         },
+         "server_port": 123,
+         "enabled": true
+        }
+      JSON
+    end
+
+    specify 'rewrites existing file' do
+      config_a = Class.new(Qonfig::DataSet) do
+        setting :kek, 'kek'
+      end.new
+
+      config_b = Class.new(Qonfig::DataSet) do
+        setting :pek, 'pek'
+      end.new
+
+      # first save (initial write)
+      config_a.save_to_json(path: config_file_path)
+      file_data = File.read(config_file_path) # NOTE: initial path
+      expect(file_data).to eq(<<~JSON.strip)
+        {
+         "kek": "kek"
+        }
+      JSON
+
+      # subsequent save (rewrite)
+      config_b.save_to_json(path: config_file_path)
+      file_data = File.read(config_file_path) # NOTE: same path
+      expect(file_data).to eq(<<~JSON.strip)
+        {
+         "pek": "pek"
+        }
+      JSON
+    end
+  end
+
+  describe 'data representation' do
+    let(:config_file_name) { "#{SecureRandom.uuid}.json" }
+    let(:config_file_path) { SpecSupport.artifact_path(config_file_name) }
+    let(:config_klass) do
+      Class.new(Qonfig::DataSet) do
+        setting :true_bollean, true
+        setting :false_boolean, false
+        setting :empty_object, {}
+        setting :filled_object, { a: 1, b: nil, 'c' => true, d: '1', e: false }
+        setting :null_data, nil
+        setting :collection, ['1', 2, true, false, nil, [], {}]
+      end
+    end
+    let(:config) { config_klass.new }
+
+    specify 'correctly represents JSON data types' do
+      # NOTE: step 1) save config
+      config.save_to_json(path: config_file_path)
+
+      # NOTE: step 2) read saved file
+      file_data = File.read(config_file_path)
+
+      expect(file_data).to eq(<<~JSON.strip)
+        {
+         "true_bollean": true,
+         "false_boolean": false,
+         "empty_object": {
+         },
+         "filled_object": {
+          "a": 1,
+          "b": null,
+          "c": true,
+          "d": "1",
+          "e": false
+         },
+         "null_data": null,
+         "collection": [  "1",  2,  true,  false,  null,  [],  {
+          }]
+        }
+      JSON
+    end
+  end
+
+  describe 'saving with native JSON settings' do
+    let(:config_file_name) { "#{SecureRandom.uuid}.json" }
+    let(:config_file_path) { SpecSupport.artifact_path(config_file_name) }
+    let(:config_klass) do
+      Class.new(Qonfig::DataSet) do
+        setting :server do
+          setting :address, 'localhost'
+          setting :port, 12_345
+        end
+
+        setting :enabled, true
+      end
+    end
+    let(:config) { config_klass.new }
+
+    specify '(SMOKE TEST) uses native JSON.generate(...) attributes (:options kwarg)' do
+      config = config_klass.new
+      config.save_to_json(path: config_file_path, options: {
+        # NOTE: our options (save json representation in one line without spaces)
+        indent: '', space: '', object_nl: ''
+      })
+      file_data = File.read(config_file_path)
+      expect(file_data).to eq('{"server":{"address":"localhost","port":12345},"enabled":true}')
+    end
+  end
+end

data/spec/features/save_to_file/save_to_yaml_spec.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+describe 'Save to .yml (YAML)' do
+  describe 'saving' do
+    let(:config_file_name) { "#{SecureRandom.uuid}.yml" }
+    let(:config_file_path) { SpecSupport.artifact_path(config_file_name) }
+    let(:config_klass) do
+      Class.new(Qonfig::DataSet) do
+        setting :sentry do
+          setting :user, 'D@iVeR'
+          setting :callback, -> { 'loaded' }
+        end
+
+        setting :server_port, 123
+        setting :enabled, true
+      end
+    end
+    let(:config) { config_klass.new }
+
+    context 'with key symbolization' do
+      before do
+        # NOTE: step 1) save config (each config's value can be pre-processed via block)
+        config.save_to_yaml(path: config_file_path, symbolize_keys: true) do |value|
+          value.is_a?(Proc) ? value.call : value
+        end
+      end
+
+      specify 'correctly represents config as YAML' do
+        # NOTE: step 2) read saved file
+        file_data = File.read(config_file_path)
+
+        expect(file_data).to eq(<<~YAML.strip << "\n")
+          ---
+          :sentry:
+            :user: D@iVeR
+            :callback: loaded
+          :server_port: 123
+          :enabled: true
+        YAML
+      end
+    end
+
+    context 'without key symbolization' do
+      before do
+        # NOTE: step 1) save config (each config's value can be pre-processed via block)
+        config.save_to_yaml(path: config_file_path, symbolize_keys: false) do |value|
+          value.is_a?(Proc) ? value.call : value
+        end
+      end
+
+      specify 'correctly represents config as YAML' do
+        # NOTE: step 2) read saved file
+        file_data = File.read(config_file_path)
+
+        expect(file_data).to eq(<<~YAML.strip << "\n")
+          ---
+          sentry:
+            user: D@iVeR
+            callback: loaded
+          server_port: 123
+          enabled: true
+        YAML
+      end
+    end
+
+    specify 'support for Pathname in file path' do
+      config.save_to_yaml(path: Pathname.new(config_file_path), symbolize_keys: false) do |value|
+        value.is_a?(Proc) ? value.call : value
+      end
+
+      file_data = File.read(config_file_path)
+
+      expect(file_data).to eq(<<~YAML.strip << "\n")
+        ---
+        sentry:
+          user: D@iVeR
+          callback: loaded
+        server_port: 123
+        enabled: true
+      YAML
+    end
+
+    specify 'rewrites existing file' do
+      config_a = Class.new(Qonfig::DataSet) do
+        setting :kek, 'kek'
+      end.new
+
+      config_b = Class.new(Qonfig::DataSet) do
+        setting :pek, 'pek'
+      end.new
+
+      # first save (initial write)
+      config_a.save_to_yaml(path: config_file_path)
+      file_data = File.read(config_file_path) # NOTE: initial path
+      expect(file_data).to eq(<<~YAML.strip << "\n")
+        ---
+        kek: kek
+      YAML
+
+      # subsequent save (rewrite)
+      config_b.save_to_yaml(path: config_file_path)
+      file_data = File.read(config_file_path) # NOTE: same path
+      expect(file_data).to eq(<<~YAML.strip << "\n")
+        ---
+        pek: pek
+      YAML
+    end
+  end
+
+  describe 'data representation' do
+    let(:config_file_name) { "#{SecureRandom.uuid}.yml" }
+    let(:config_file_path) { SpecSupport.artifact_path(config_file_name) }
+    let(:config_klass) do
+      Class.new(Qonfig::DataSet) do
+        setting :true_bollean, true
+        setting :false_boolean, false
+        setting :empty_object, {}
+        setting :filled_object, { a: 1, b: nil, 'c' => true, d: '1', e: false }
+        setting :null_data, nil
+        setting :collection, ['1', 2, true, false, nil, [], {}]
+      end
+    end
+    let(:config) { config_klass.new }
+
+    specify 'correctly represents YAML data types' do
+      # NOTE: step 1) save config
+      config.save_to_yaml(path: config_file_path)
+
+      # NOTE: step 2) read saved file
+      file_data = File.read(config_file_path)
+
+      expect(file_data).to eq(<<~YAML.strip << "\n")
+        ---
+        true_bollean: true
+        false_boolean: false
+        empty_object: {}
+        filled_object:
+          :a: 1
+          :b: ~
+          c: true
+          :d: '1'
+          :e: false
+        null_data: ~
+        collection:
+        - '1'
+        - 2
+        - true
+        - false
+        - ~
+        - []
+        - {}
+      YAML
+    end
+  end
+
+  describe 'saving with native YAML settings' do
+    let(:config_file_name) { "#{SecureRandom.uuid}.yml" }
+    let(:config_file_path) { SpecSupport.artifact_path(config_file_name) }
+    let(:config_klass) do
+      Class.new(Qonfig::DataSet) do
+        setting :server do
+          setting :address, 'localhost'
+          setting :port, 12_345
+        end
+
+        setting :enabled, true
+      end
+    end
+    let(:config) { config_klass.new }
+
+    specify '(SMOKE TEST) uses native YAML.dump(...) attributes (:options kwarg)' do
+      config = config_klass.new
+      config.save_to_yaml(path: config_file_path, options: {
+        # NOTE: put current YAML version in start of file (in first line)
+        indentation: 2, header: true
+      })
+      file_data = File.read(config_file_path)
+
+      expect(file_data).to eq(<<~YAML.strip << "\n")
+        %YAML 1.1
+        ---
+        server:
+          address: localhost
+          port: 12345
+        enabled: true
+      YAML
+    end
+  end
+end

data/spec/features/settings_as_predicates_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+describe 'Settings as Predicates' do
+  specify 'boolean nature of the option value' do
+    class BooleanCheckConfig < Qonfig::DataSet
+      setting :database do
+        setting :user
+        setting :host, 'google.com'
+      end
+
+      setting :enable_mocks, true
+    end
+
+    config = BooleanCheckConfig.new
+
+    # predicats
+    expect(config.settings.database.user?).to eq(false)
+    expect(config.settings.database.host?).to eq(true)
+    expect(config.settings.enable_mocks?).to eq(true)
+    # setting roots always returns true
+    expect(config.settings.database?).to eq(true)
+
+    # reconfigure and check again
+    config.configure do |conf|
+      conf.database.user = 'D@iVeR'
+      conf.database.host = nil
+      conf.enable_mocks = false
+    end
+
+    # predicates
+    expect(config.settings.database.user?).to eq(true)
+    expect(config.settings.database.host?).to eq(false)
+    expect(config.settings.enable_mocks?).to eq(false)
+    # setting roots always returns true
+    expect(config.settings.database?).to eq(true)
+
+    # clear all options
+    config.configure do |conf|
+      conf.database.user = nil
+      conf.database.host = nil
+      conf.enable_mocks = nil
+    end
+
+    # setting roots always returns true
+    expect(config.settings.database?).to eq(true)
+  end
+end

data/spec/features/settings_redefinition_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+describe 'Settings redefinition' do
+  specify '.re_setting DSL command redefines previously defined setting keys' do
+    class BaseRedefinableConfig < Qonfig::DataSet
+      setting :nested do
+        setting :some_key, 100_500
+      end
+    end
+
+    class ChildRedefinitionConfig < BaseRedefinableConfig
+      re_setting :nested, :some_value
+    end
+
+    class AnotherChildRedefinitionConfig < BaseRedefinableConfig
+      re_setting :nested do
+        setting :another_key, 'test'
+      end
+    end
+
+    redefinable_config = BaseRedefinableConfig.new
+    expect(redefinable_config[:nested][:some_key]).to eq(100_500)
+
+    child_redefinition_config = ChildRedefinitionConfig.new
+    expect(child_redefinition_config[:nested]).to eq(:some_value)
+
+    another_child_redefinition_config = AnotherChildRedefinitionConfig.new
+    expect(another_child_redefinition_config[:nested][:another_key]).to eq('test')
+  end
+end

data/spec/features/slice_functionality_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LineLength
+describe '(#slice/#slice_value)-functionality' do
+  specify '#slice/#slice_value functionality works as expected :)' do
+    class SlicingConfig < Qonfig::DataSet
+      setting :db do
+        setting :creds do
+          setting :user, 'D@iVeR'
+          setting :data, test: false
+        end
+      end
+    end
+
+    config = SlicingConfig.new
+
+    db_slice    = { 'db' => { 'creds' => { 'user' => 'D@iVeR', 'data' => { test: false } } } }
+    creds_slice = { 'creds' => { 'user' => 'D@iVeR', 'data' => { test: false } } }
+    user_slice  = { 'user' => 'D@iVeR' }
+    data_slice  = { 'data' => { test: false } }
+
+    # access to the slice (with indifferent keys type)
+    expect(config.slice(:db)).to match(db_slice)
+    expect(config.slice('db', :creds)).to match(creds_slice)
+    expect(config.slice(:db, 'creds', :user)).to match(user_slice)
+    expect(config.slice(:db, :creds, 'data')).to match(data_slice)
+
+    # try to slice with with unexistent keys
+    expect { config.slice(:db, :creds, :megazavr) }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.slice(:db, :test) }.to raise_error(Qonfig::UnknownSettingError)
+
+    # you cant slice over setting values - you can do it only over the setting keys!
+    expect { config.slice(:db, :creds, :data, :test) }.to raise_error(Qonfig::UnknownSettingError)
+
+    # slice with empty key list
+    # rubocop:disable Lint/RedundantSplatExpansion
+    expect { config.slice(*[]) }.to raise_error(Qonfig::ArgumentError)
+    expect { config.slice }.to raise_error(Qonfig::ArgumentError)
+    # rubocop:enable Lint/RedundantSplatExpansion
+
+    # slice over unexistent option
+    expect { config.slice(:db, :creds, :session) }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.slice(:a, :b, :c, :d) }.to raise_error(Qonfig::UnknownSettingError)
+
+    # access to the sliced value (with indifferent keys type)
+    expect(config.slice_value(:db)).to match(db_slice['db'])
+    expect(config.slice_value('db', :creds)).to match(creds_slice['creds'])
+    expect(config.slice_value(:db, 'creds', :user)).to eq(user_slice['user'])
+    expect(config.slice_value(:db, :creds, 'data')).to match(data_slice['data'])
+
+    # try to slice value over with unexistent keys
+    expect { config.slice_value(:db, :creds, :megazavr) }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.slice_value(:db, :test) }.to raise_error(Qonfig::UnknownSettingError)
+
+    # you cant slice over setting values - you can do it only over the setting keys!
+    expect { config.slice_value(:db, :creds, :data, :test) }.to raise_error(Qonfig::UnknownSettingError)
+
+    # slice with empty key list
+    # rubocop:disable Lint/RedundantSplatExpansion
+    expect { config.slice_value(*[]) }.to raise_error(Qonfig::ArgumentError)
+    expect { config.slice_value }.to raise_error(Qonfig::ArgumentError)
+    # rubocop:enable Lint/RedundantSplatExpansion
+
+    # slice over unexistent option
+    expect { config.slice_value(:db, :creds, :session) }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.slice_value(:a, :b, :c, :d) }.to raise_error(Qonfig::UnknownSettingError)
+  end
+end
+# rubocop:enable Layout/LineLength