qonfig 0.25.0 → 0.26.0

data/spec/features/definition_order_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+describe 'Definition order' do
+  specify 'config definitions dependes on the order' do
+    class FirstConfig < Qonfig::DataSet
+      setting :default, 100_500
+      setting :default do
+        setting :options, defined: true
+      end
+    end
+
+    FirstConfig.new.settings.tap do |config|
+      # { default: { options: { defined: true } } } is the last
+      expect(config.default.options).to match(defined: true)
+    end
+
+    class SecondConfig < Qonfig::DataSet
+      setting :default do
+        setting :options, defined: true
+      end
+      setting :default, 100_500
+    end
+
+    SecondConfig.new.settings.tap do |config|
+      # { default: 100_500 } is the last
+      expect(config.default).to eq(100_500)
+    end
+
+    class FirstComposedConfig < Qonfig::DataSet
+      compose FirstConfig
+      compose SecondConfig
+    end
+
+    FirstComposedConfig.new.settings.tap do |config|
+      # setting from SecondConfig (SecondConfig is the last)
+      expect(config.default).to eq(100_500)
+    end
+
+    class SecondComposedConfig < Qonfig::DataSet
+      compose SecondConfig
+      compose FirstConfig
+    end
+
+    SecondComposedConfig.new.settings.tap do |config|
+      # setting from FirstConfig (FirstConfig is the last)
+      expect(config.default.options).to match(defined: true)
+    end
+
+    class FirstAllInConfig < Qonfig::DataSet
+      setting :default, 123
+      compose FirstConfig
+    end
+
+    FirstAllInConfig.new.settings.tap do |config|
+      # setting from FirstConfig (FirstConfig is the last)
+      expect(config.default.options).to match(defined: true)
+    end
+
+    class SecondAllInConfig < Qonfig::DataSet
+      compose FirstConfig
+      setting :default, 123
+    end
+
+    SecondAllInConfig.new.settings.tap do |config|
+      # own setting (own setting is the last)
+      expect(config.default).to eq(123)
+    end
+  end
+end

data/spec/features/dig_functionality_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/SingleArgumentDig
+describe '#dig-functionality (Hash#dig-like behaviour)' do
+  specify '#dig functionality works as expected :)' do
+    class DiggingConfig < Qonfig::DataSet
+      setting :db do
+        setting :creds do
+          setting :user, 'D@iVeR'
+          setting :password, 'test123'
+          setting :data, test: false
+        end
+      end
+    end
+
+    config = DiggingConfig.new
+
+    # acces to a value
+    expect(config.dig(:db, :creds, :user)).to eq('D@iVeR')
+    expect(config.dig('db', :creds, 'password')).to eq('test123')
+    expect(config.dig('db', 'creds', 'data')).to match(test: false)
+
+    # access to the settings
+    expect(config.dig(:db, :creds)).to be_a(Qonfig::Settings)
+    expect(config.dig(:db)).to be_a(Qonfig::Settings)
+
+    # try to dig into the hash value (setting with a hash value)
+    expect { config.dig(:db, :creds, :user, :test) }.to raise_error(Qonfig::UnknownSettingError)
+
+    # rubocop:disable Lint/RedundantSplatExpansion
+    # dig with empty key lists
+    expect { config.dig(*[]) }.to raise_error(Qonfig::ArgumentError)
+    expect { config.dig }.to raise_error(Qonfig::ArgumentError)
+    # rubocop:enable Lint/RedundantSplatExpansion
+
+    # dig into unexistent option
+    expect do
+      config.dig(:db, :creds, :session)
+    end.to raise_error(Qonfig::UnknownSettingError)
+
+    # dig into unexistent option
+    expect do
+      config.dig(:a, :b, :c, :d)
+    end.to raise_error(Qonfig::UnknownSettingError)
+  end
+end
+# rubocop:enable Style/SingleArgumentDig

data/spec/features/dot_notation_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/SingleArgumentDig
+describe 'Dot-notation' do
+  let(:config) do
+    Qonfig::DataSet.build do
+      setting :kek do
+        setting :pek do
+          setting :cheburek, 'test'
+        end
+
+        setting 'foo.bar', 100_500
+
+        setting :frek do
+          setting :jek do
+            setting :bek, 123_456
+          end
+        end
+      end
+    end
+  end
+
+  specify '#key? / #option? / #setting?' do
+    expect(config.key?('kek.pek.cheburek')).to eq(true)
+    expect(config.key?('kek.pek')).to eq(true)
+    expect(config.key?('kek')).to eq(true)
+    expect(config.key?('kek.foo.bar')).to eq(true)
+    expect(config.key?('kek.cheburek.pek')).to eq(false)
+    expect(config.key?('kek.cheburek')).to eq(false)
+
+    expect(config.option?('kek.pek.cheburek')).to eq(true)
+    expect(config.option?('kek.pek')).to eq(true)
+    expect(config.option?('kek')).to eq(true)
+    expect(config.option?('kek.foo.bar')).to eq(true)
+    expect(config.option?('kek.cheburek.pek')).to eq(false)
+    expect(config.option?('kek.cheburek')).to eq(false)
+
+    expect(config.setting?('kek.pek.cheburek')).to eq(true)
+    expect(config.setting?('kek.pek')).to eq(true)
+    expect(config.setting?('kek')).to eq(true)
+    expect(config.setting?('kek.foo.bar')).to eq(true)
+    expect(config.setting?('kek.cheburek.pek')).to eq(false)
+    expect(config.setting?('kek.cheburek')).to eq(false)
+  end
+
+  specify '#dig' do
+    expect(config.dig('kek.pek.cheburek')).to eq('test')
+    expect(config.dig('kek.pek')).to be_a(Qonfig::Settings)
+    expect(config.dig('kek')).to be_a(Qonfig::Settings)
+    expect(config.dig('kek.foo.bar')).to eq(100_500)
+
+    expect { config.dig('kek.pek.ululek') }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.dig('kek.ululek') }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.dig('ululek') }.to raise_error(Qonfig::UnknownSettingError)
+  end
+
+  specify '#subset' do
+    expect(config.subset('kek', 'kek.frek')).to match(
+      'kek' => {
+        'frek' => { 'jek' => { 'bek' => 123456 } },
+        'pek' => { 'cheburek'=>'test' },
+        'foo.bar' => 100_500
+      },
+      'frek' => {
+        'jek' => { 'bek' => 123_456 }
+      }
+    )
+
+    expect do
+      config.subset('kek', 'kek.frek', 'kek.lel', 'kek.foo')
+    end.to raise_error(Qonfig::UnknownSettingError)
+  end
+
+  specify '#slice' do
+    expect(config.slice('kek.pek')).to match('pek' => { 'cheburek' => 'test' })
+    expect(config.slice('kek.frek')).to match('frek' => { 'jek' => { 'bek' => 123_456 } })
+
+    # TODO: fix this
+    # expect(config.slice('kek.foo.bar')).to match('foo.bar' => 100_500)
+
+    expect { config.slice('lel') }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.slice('kek.lek') }.to raise_error(Qonfig::UnknownSettingError)
+  end
+
+  specify '#slice_value' do
+    expect(config.slice_value('kek.pek.cheburek')).to eq('test')
+    expect(config.slice_value('kek.pek')).to match('cheburek' => 'test')
+    expect(config.slice_value('kek.frek')).to match('jek' => { 'bek' => 123_456 })
+    expect(config.slice_value('kek.foo.bar')).to eq(100_500)
+
+    expect { config.slice_value('kek.pek.lelek') }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.slice_value('kek.frek.bek') }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.slice_value('lel') }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config.slice_value('kek.foo') }.to raise_error(Qonfig::UnknownSettingError)
+  end
+
+  specify '#[]' do
+    expect(config['kek.pek.cheburek']).to eq('test')
+    expect(config['kek.pek']).to be_a(Qonfig::Settings)
+    expect(config['kek.pek']['cheburek']).to eq('test')
+    expect(config['kek']['frek.jek']['bek']).to eq(123_456)
+    expect(config['kek']['foo.bar']).to eq(100_500)
+    expect(config['kek.foo.bar']).to eq(100_500)
+
+    expect { config['kek.foo'] }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config['kek.pek.lelek'] }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config['kek.frek']['bek'] }.to raise_error(Qonfig::UnknownSettingError)
+    expect { config['lel'] }.to raise_error(Qonfig::UnknownSettingError)
+  end
+
+  describe '#to_h' do
+    specify 'default behavior' do
+      expect(config.to_h(dot_style: true)).to match(
+        'kek.pek.cheburek' => 'test',
+        'kek.foo.bar' => 100_500,
+        'kek.frek.jek.bek' => 123_456
+      )
+    end
+
+    specify 'with key and value transformations' do
+      transformer = -> (value) { "#{value}!!" }
+
+      # transformations: key ONLY
+      hash = config.to_h(
+        dot_style: true,
+        key_transformer: transformer
+      )
+      expect(hash).to match(
+        'kek.pek.cheburek!!' => 'test',
+        'kek.foo.bar!!' => 100_500,
+        'kek.frek.jek.bek!!' => 123_456
+      )
+
+      # transformations: value ONLY
+      hash = config.to_h(
+        dot_style: true,
+        value_transformer: transformer
+      )
+      expect(hash).to match(
+        'kek.pek.cheburek' => 'test!!',
+        'kek.foo.bar' => '100500!!',
+        'kek.frek.jek.bek' => '123456!!'
+      )
+
+      # transformations: key AND value
+      hash = config.to_h(
+        dot_style: true,
+        key_transformer: transformer,
+        value_transformer: transformer
+      )
+      expect(hash).to match(
+        'kek.pek.cheburek!!' => 'test!!',
+        'kek.foo.bar!!' => '100500!!',
+        'kek.frek.jek.bek!!' => '123456!!'
+      )
+    end
+  end
+end
+# rubocop:enable Style/SingleArgumentDig

data/spec/features/export_settings_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+describe 'Export settings as instance-level access methods' do
+  let(:config) do
+    Qonfig::DataSet.build do
+      setting :credentials do
+        setting :login, '0exp'
+        setting :password, 'test123'
+      end
+
+      setting :queue do
+        setting :adapter, :sidekiq
+        setting :threads, 10
+      end
+    end
+  end
+
+  let(:empty_config) { Qonfig::DataSet.build }
+
+  specify 'empty export does nothing' do
+    my_simple_object = Object.new
+
+    expect { empty_config.export_settings(my_simple_object, '*') }.not_to raise_error
+    expect { empty_config.export_settings(my_simple_object, '#') }.not_to raise_error
+  end
+
+  specify 'default values => do nothing' do
+    my_simple_object = Object.new
+    config.export_settings(my_simple_object) # do nothing :D
+
+    expect(my_simple_object).not_to respond_to(:credentials)
+    expect(my_simple_object).not_to respond_to(:login)
+    expect(my_simple_object).not_to respond_to(:queue)
+    expect(my_simple_object).not_to respond_to(:adaper)
+    expect(my_simple_object).not_to respond_to(:threads)
+  end
+
+  specify '<non-raw export> (concrete keys as values and keys with nestings as a hash)' do
+    my_simple_object = Object.new
+
+    config.export_settings(
+      my_simple_object,
+      'credentials',
+      mappings: { adapter: 'queue.adapter' },
+      prefix: 'config_'
+    )
+
+    expect(my_simple_object).to respond_to(:config_credentials) # NOTE: hash
+    expect(my_simple_object).to respond_to(:config_adapter) # NOTE: value
+    expect(my_simple_object.config_credentials).to be_a(Hash)
+
+    expect(my_simple_object.config_credentials).to match('login' => '0exp', 'password' => 'test123')
+    expect(my_simple_object.config_adapter).to eq(:sidekiq)
+  end
+
+  specify 'support for predicates' do
+    my_simple_object = Object.new
+
+    # NOTE: without prefix
+    config.export_settings(my_simple_object, 'credentials.*', accessor: true)
+
+    # NOTE: with prefix
+    config.export_settings(my_simple_object, 'queue.*', prefix: 'config_', accessor: true)
+
+    # NOTE: and mappings
+    config.export_settings(
+      my_simple_object,
+      mappings: { creds_pass: 'credentials.password' },
+      accessor: true
+    )
+
+    expect(my_simple_object.login?).to eq(true)
+    expect(my_simple_object.password?).to eq(true)
+    expect(my_simple_object.config_adapter?).to eq(true)
+    expect(my_simple_object.config_threads?).to eq(true)
+    expect(my_simple_object.creds_pass?).to eq(true)
+
+    my_simple_object.config_adapter = nil
+    my_simple_object.password = false
+
+    expect(my_simple_object.config_adapter?).to eq(false)
+    expect(my_simple_object.password?).to eq(false)
+    expect(my_simple_object.creds_pass?).to eq(false)
+
+    my_simple_object.config_adapter = :delayed_job
+    my_simple_object.creds_pass = 'test'
+
+    expect(my_simple_object.config_adapter?).to eq(true)
+    expect(my_simple_object.password?).to eq(true)
+    expect(my_simple_object.creds_pass?).to eq(true)
+  end
+
+  specify '<raw export> (concrete keys as values and keys with nestings as Qonfig::Settings)' do
+    my_simple_object = Object.new
+
+    config.export_settings(
+      my_simple_object,
+      'credentials',
+      mappings: { adapter: 'queue.adapter' },
+      prefix: 'kek_',
+      raw: true
+    )
+
+    expect(my_simple_object).to respond_to(:kek_credentials) # NOTE: Qonfig::Settings
+    expect(my_simple_object).to respond_to(:kek_adapter) # NOTE: value
+    expect(my_simple_object.kek_credentials).to be_a(Qonfig::Settings)
+
+    expect(my_simple_object.kek_credentials.login).to eq('0exp')
+    expect(my_simple_object.kek_credentials.password).to eq('test123')
+    expect(my_simple_object.kek_adapter).to eq(:sidekiq)
+  end
+
+  specify 'attr_writers (config muatators)' do
+    my_simple_object = Object.new
+
+    config.export_settings(
+      my_simple_object,
+      'credentials.login', 'credentials',
+      mappings: { driver: 'queue.adapter' },
+      accessor: true
+    )
+
+    # NOTE: you can mutate config settings via exported attr_writers
+    my_simple_object.login = 'D@iVeR'
+    my_simple_object.driver = :delayed_job
+
+    # NOTE: check taht original config was changed
+    expect(config.settings.credentials.login).to eq('D@iVeR')
+    expect(config.settings.queue.adapter).to eq(:delayed_job)
+
+    # NOTE: check that reder returns new value
+    expect(my_simple_object.login).to eq('D@iVeR')
+    expect(my_simple_object.driver).to eq(:delayed_job)
+
+    # NOTE: some mutators can be ambiguous - be careful :thinking:
+    expect { my_simple_object.credentials = 123 }.to raise_error(Qonfig::AmbiguousSettingValueError)
+  end
+end

data/spec/features/expose_json_spec.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+describe 'Expose JSON file' do
+  specify 'defines config object by json instructions and specific environment settings' do
+    class ExposeJSONConfig < Qonfig::DataSet
+      json_file_path = SpecSupport.fixture_path('expose_json', 'project.json')
+
+      setting :file_name_based do
+        setting :test_env do
+          # spec/fixtures/expose_json/project.test.json
+          expose_json json_file_path, via: :file_name, env: :test
+        end
+
+        setting :prod_env do
+          # spec/fixtures/expose_json/project.production.json
+          expose_json json_file_path, via: :file_name, env: :production
+        end
+
+        setting :stage_env do
+          # spec/fixtures/expose_json/project.staging.json
+          expose_json json_file_path, via: :file_name, env: :staging
+        end
+
+        setting :dev_env do
+          # spec/fixtures/expose_json/project.development.json
+          expose_json json_file_path, via: :file_name, env: :development
+        end
+      end
+
+      setting :env_based do
+        setting :test_env do
+          # spec/fixtures/expose_json/project.json
+          expose_json json_file_path, via: :env_key, env: :test
+        end
+
+        setting :prod_env do
+          # spec/fixtures/expose_json/project.json
+          expose_json json_file_path, via: :env_key, env: :production
+        end
+
+        setting :stage_env do
+          # spec/fixtures/expose_json/project.json
+          expose_json json_file_path, via: :env_key, env: :staging
+        end
+
+        setting :dev_env do
+          # spec/fixtures/expose_json/project.json
+          expose_json json_file_path, via: :env_key, env: :development
+        end
+      end
+    end
+
+    settings = ExposeJSONConfig.new.settings
+
+    # NOTE: file-name based expose
+    # spec/fixtures/expose_json/project.test.json
+    expect(settings.file_name_based.test_env.api_mode_enabled).to eq(false)
+    expect(settings.file_name_based.test_env.db_driver).to eq('in_memory')
+    expect(settings.file_name_based.test_env.logging).to eq(false)
+    expect(settings.file_name_based.test_env.credentials).to eq({})
+    # spec/fixtures/expose_json/project.production.json
+    expect(settings.file_name_based.prod_env.api_mode_enabled).to eq(true)
+    expect(settings.file_name_based.prod_env.db_driver).to eq('rom')
+    expect(settings.file_name_based.prod_env.logging).to eq(true)
+    expect(settings.file_name_based.prod_env.credentials).to eq({})
+    # spec/fixtures/expose_json/project.development.json
+    expect(settings.file_name_based.dev_env.api_mode_enabled).to eq(true)
+    expect(settings.file_name_based.dev_env.db_driver).to eq('sequel')
+    expect(settings.file_name_based.dev_env.logging).to eq(false)
+    expect(settings.file_name_based.dev_env.credentials).to eq({})
+    # spec/fixtures/expose_json/project.staging.json
+    expect(settings.file_name_based.stage_env.api_mode_enabled).to eq(true)
+    expect(settings.file_name_based.stage_env.db_driver).to eq('active_record')
+    expect(settings.file_name_based.stage_env.logging).to eq(true)
+    expect(settings.file_name_based.stage_env.credentials).to eq({})
+
+    # NOTE: environment based expose
+    # spec/fixtures/expose_json/project.json (key: 'test')
+    expect(settings.env_based.test_env.api_mode_enabled).to eq(true)
+    expect(settings.env_based.test_env.db_driver).to eq('in_memory')
+    expect(settings.env_based.test_env.logging).to eq(false)
+    expect(settings.env_based.test_env.throttle_requests).to eq(false)
+    expect(settings.env_based.test_env.credentials).to eq({})
+    # spec/fixtures/expose_json/project.json (key: 'production')
+    expect(settings.env_based.prod_env.api_mode_enabled).to eq(true)
+    expect(settings.env_based.prod_env.db_driver).to eq('rom')
+    expect(settings.env_based.prod_env.logging).to eq(true)
+    expect(settings.env_based.prod_env.throttle_requests).to eq(true)
+    expect(settings.env_based.prod_env.credentials).to eq({})
+    # spec/fixtures/expose_json/project.json (key: 'development')
+    expect(settings.env_based.dev_env.api_mode_enabled).to eq(true)
+    expect(settings.env_based.dev_env.db_driver).to eq('sequel')
+    expect(settings.env_based.dev_env.logging).to eq(false)
+    expect(settings.env_based.dev_env.throttle_requests).to eq(false)
+    expect(settings.env_based.dev_env.credentials).to eq({})
+    # spec/fixtures/expose_json/project.json (key: 'staging')
+    expect(settings.env_based.stage_env.api_mode_enabled).to eq(true)
+    expect(settings.env_based.stage_env.db_driver).to eq('active_record')
+    expect(settings.env_based.stage_env.logging).to eq(true)
+    expect(settings.env_based.stage_env.throttle_requests).to eq(true)
+    expect(settings.env_based.stage_env.credentials).to eq({})
+  end
+
+  specify 'support for Pathname in file path' do
+    class PathnameExposeJSONCheck < Qonfig::DataSet
+      expose_json(
+        Pathname.new(SpecSupport.fixture_path('expose_json', 'project.json')),
+        via: :env_key, env: :development
+      )
+    end
+
+    config = PathnameExposeJSONCheck.new
+
+    expect(config.settings.api_mode_enabled).to eq(true)
+    expect(config.settings.logging).to eq(false)
+    expect(config.settings.db_driver).to eq('sequel')
+    expect(config.settings.throttle_requests).to eq(false)
+    expect(config.settings.credentials).to eq({})
+  end
+
+  describe 'failures and inconsistent situations' do
+    describe 'definition level errors' do
+      specify 'fails when :env attribute has non-string / non-symbol / non-numeric value' do
+        expect do
+          Class.new(Qonfig::DataSet) do
+            expose_json SpecSupport.fixture_path(
+              'expose_json', 'project.json'
+            ), via: :env_key, env: Object.new
+          end
+        end.to raise_error(Qonfig::ArgumentError)
+      end
+
+      specify 'fails when :env is empty' do
+        expect do
+          Class.new(Qonfig::DataSet) do
+            expose_json SpecSupport.fixture_path(
+              'expose_json', 'project.json'
+            ), via: :env_key, env: ''
+          end
+        end.to raise_error(Qonfig::ArgumentError)
+      end
+
+      specify 'fails when provided :via is not supported' do
+        expect do
+          Class.new(Qonfig::DataSet) do
+            expose_json SpecSupport.fixture_path(
+              'expose_json', 'project.json'
+            ), via: :auto, env: :production
+          end
+        end.to raise_error(Qonfig::ArgumentError)
+      end
+    end
+
+    describe 'initialization level errors' do
+      specify 'fails when env-based settings is represented as a non-hash-like data' do
+        # NOTE:
+        #   - file: spec/fixtures/expose_json/incompatible_structure.json
+        #   - :staging environment key has incorrect value (scalar)
+        #   - :test environment key has correct value (hash)
+
+        class IncompatibleEnvBasedJSONConfig < Qonfig::DataSet
+          expose_json SpecSupport.fixture_path(
+            'expose_json', 'incompatible_structure.json'
+          ), via: :env_key, env: :staging
+        end
+
+        expect do
+          IncompatibleEnvBasedJSONConfig.new
+        end.to raise_error(Qonfig::IncompatibleJSONStructureError)
+
+        class CompatibleEnvBasedJSONConfig < Qonfig::DataSet
+          expose_json SpecSupport.fixture_path(
+            'expose_json', 'incompatible_structure.json'
+          ), via: :env_key, env: :test
+        end
+
+        expect { CompatibleEnvBasedJSONConfig.new }.not_to raise_error
+      end
+
+      specify 'fails when json structure is represented as a non-hash-like data in the root' do
+        # NOTE:
+        #  - file: spec/fixtures/expose_json/incompatible_root_structure.json
+        #  - in the root: array
+        #  - inside array: correct json object with "staging" and "test" environments"
+        #  - expected behaviour: exception (because of the root is an array)
+
+        class IncompatibleEnvBasedRootStructureJSONConfig < Qonfig::DataSet
+          expose_json SpecSupport.fixture_path(
+            'expose_json', 'incompatible_root_structure.json'
+          ), via: :env_key, env: :test
+        end
+
+        expect do
+          IncompatibleEnvBasedRootStructureJSONConfig.new
+        end.to raise_error(Qonfig::IncompatibleJSONStructureError)
+      end
+
+      describe 'strict mode' do
+        specify(
+          'disabled (non-strict): ' \
+          'file existence requirement + json-env-key existence requirement'
+        ) do
+          # NOTE: file does not exist + env key does not exist in json file
+          class NoFileNonStrictExposeJSONConfig < Qonfig::DataSet
+            setting :non_strict_by_file do
+              expose_json SpecSupport.fixture_path(
+                'expose_json', 'nonexistent.json'
+              ), strict: false, via: :file_name, env: :development
+            end
+
+            setting :non_strict_by_env do
+              expose_json SpecSupport.fixture_path(
+                'expose_json', 'nonexistent.json'
+              ), strict: false, via: :env_key, env: :development
+            end
+          end
+
+          expect(NoFileNonStrictExposeJSONConfig.new.to_h).to match(
+            'non_strict_by_file' => {},
+            'non_strict_by_env'  => {}
+          )
+
+          # NOTE: file is exist + env key does not exist in json file
+          class NoEnvKeyNonStrictExposeJSONConfig < Qonfig::DataSet
+            setting :non_strict_by_file do
+              expose_json SpecSupport.fixture_path(
+                'expose_json', 'project.json'
+              ), strict: false, via: :file_name, env: :nonexistent
+            end
+
+            setting :non_strict_by_env do
+              expose_json SpecSupport.fixture_path(
+                'expose_json', 'project.json'
+              ), strict: false, via: :env_key, env: :nonexistent
+            end
+          end
+
+          expect(NoEnvKeyNonStrictExposeJSONConfig.new.to_h).to match(
+            'non_strict_by_file' => {},
+            'non_strict_by_env'  => {}
+          )
+        end
+
+        specify(
+          'enabled (strict, by default): ' \
+          'file existence requirement + json-env-key existence requirement'
+        ) do
+          # NOTE: file does not exist
+          class StrictFileViaFileNameJSONConfig < Qonfig::DataSet
+            expose_json SpecSupport.fixture_path(
+              'expose_json', 'nonexistent.json'
+            ), via: :file_name, env: :production
+          end
+
+          # NOTE: file does not exist
+          class StrictFileViaEnvKeyJSONConfig < Qonfig::DataSet
+            expose_json SpecSupport.fixture_path(
+              'expose_json', 'nonexistent.json'
+            ), via: :env_key, env: :production
+          end
+
+          # NOTE: file does not exist
+          expect { StrictFileViaFileNameJSONConfig.new }.to raise_error(Qonfig::FileNotFoundError)
+          expect { StrictFileViaEnvKeyJSONConfig.new }.to   raise_error(Qonfig::FileNotFoundError)
+
+          # NOTE:
+          #   - file exists but env key does not exist
+          #   - file: spec/fixtures/expose_json/project.json
+          class NonExistentEnvKeyJSONConfig < Qonfig::DataSet
+            expose_json SpecSupport.fixture_path(
+              'expose_json', 'project.json'
+            ), via: :env_key, env: :nonexistent
+          end
+
+          # NOTE: env key does not exist
+          expect { NonExistentEnvKeyJSONConfig.new }.to raise_error(Qonfig::ExposeError)
+        end
+      end
+    end
+  end
+end