qonfig 0.25.0 → 0.26.0

data/spec/features/expose_self/format_option_dynamic_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+describe '#expose_self => format: :dynamic' do
+  specify ':dynamic-format - automatically resolves the data format' do
+    class ExposeEndDataFormatDynamicallyConfig < Qonfig::DataSet
+      setting(:staging_env) { expose_self env: :staging }
+      setting(:prod_env) { expose_self env: :production }
+      setting(:test_env) { expose_self env: :test }
+    end
+
+    config = ExposeEndDataFormatDynamicallyConfig.new
+
+    # NOTE: production env
+    expect(config.settings.prod_env.credentials.user).to eq('admin')
+    expect(config.settings.prod_env.credentials.password).to eq('123')
+    expect(config.settings.prod_env.credentials.enabled).to eq(true)
+    expect(config.settings.prod_env.api).to eq('google.com')
+    expect(config.settings.prod_env.ports).to eq([10001, 10002, 10003])
+
+    # NOTE: test env
+    expect(config.settings.test_env.credentials.user).to eq('megaman')
+    expect(config.settings.test_env.credentials.password).to eq('atata123')
+    expect(config.settings.test_env.credentials.enabled).to eq(false)
+    expect(config.settings.test_env.api).to eq('yandex.ru')
+    expect(config.settings.test_env.ports).to eq([1, 2, 3])
+
+    # NOTE: staging env
+    expect(config.settings.staging_env.credentials.user).to eq('diablo')
+    expect(config.settings.staging_env.credentials.password).to eq('testornot')
+    expect(config.settings.staging_env.credentials.enabled).to eq(true)
+    expect(config.settings.staging_env.api).to eq('battle.net')
+    expect(config.settings.staging_env.ports).to eq([111, 222, 333])
+  end
+end
+
+__END__
+
+production:
+  credentials:
+    user: admin
+    password: '123'
+    enabled: true
+  api: google.com
+  ports:
+    - 10001
+    - 10002
+    - 10003
+
+test:
+  credentials:
+    user: megaman
+    password: atata123
+    enabled: false
+  api: yandex.ru
+  ports:
+    - 1
+    - 2
+    - 3
+
+staging:
+  credentials:
+    user: diablo
+    password: testornot
+    enabled: true
+  api: battle.net
+  ports:
+    - 111
+    - 222
+    - 333

data/spec/features/expose_self/format_option_json_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+describe '#expose_self => format: :json' do
+  specify ':json-format support' do
+    class ExposeJsonEndDataConfig < Qonfig::DataSet
+      setting :staging_env do
+        expose_self format: :json, env: :staging
+      end
+
+      setting :prod_env do
+        expose_self format: :json, env: :production
+      end
+
+      setting :test_env do
+        expose_self format: :json, env: :test
+      end
+    end
+
+    config = ExposeJsonEndDataConfig.new
+
+    # NOTE: production env
+    expect(config.settings.prod_env.credentials.user).to eq('admin')
+    expect(config.settings.prod_env.credentials.password).to eq('123')
+    expect(config.settings.prod_env.credentials.enabled).to eq(true)
+    expect(config.settings.prod_env.api).to eq('google.com')
+    expect(config.settings.prod_env.ports).to eq([10001, 10002, 10003])
+
+    # NOTE: test env
+    expect(config.settings.test_env.credentials.user).to eq('megaman')
+    expect(config.settings.test_env.credentials.password).to eq('atata123')
+    expect(config.settings.test_env.credentials.enabled).to eq(false)
+    expect(config.settings.test_env.api).to eq('yandex.ru')
+    expect(config.settings.test_env.ports).to eq([1, 2, 3])
+
+    # NOTE: staging env
+    expect(config.settings.staging_env.credentials.user).to eq('diablo')
+    expect(config.settings.staging_env.credentials.password).to eq('testornot')
+    expect(config.settings.staging_env.credentials.enabled).to eq(true)
+    expect(config.settings.staging_env.api).to eq('battle.net')
+    expect(config.settings.staging_env.ports).to eq([111, 222, 333])
+  end
+end
+
+__END__
+
+{
+  "production": {
+    "credentials": {
+      "user": "admin",
+      "password": "123",
+      "enabled": true
+    },
+    "api": "google.com",
+    "ports": [10001, 10002, 10003]
+  },
+  "test": {
+    "credentials": {
+      "user": "megaman",
+      "password": "atata123",
+      "enabled": false
+    },
+    "api": "yandex.ru",
+    "ports": [1, 2, 3]
+  },
+  "staging": {
+    "credentials": {
+      "user": "diablo",
+      "password": "testornot",
+      "enabled": true
+    },
+    "api": "battle.net",
+    "ports": [111, 222, 333]
+  }
+}

data/spec/features/expose_self/format_option_unsupported_spec.rb

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

data/spec/features/expose_self/format_option_yaml_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+describe '#expose_self => format: :yaml' do
+  specify ':yaml-format support' do
+    class ExposeYamlEndDataConfig < Qonfig::DataSet
+      setting :staging_env do
+        expose_self format: :yaml, env: :staging
+      end
+
+      setting :prod_env do
+        expose_self format: :yml, env: :production # NOTE: yml is the same as yaml
+      end
+
+      setting :test_env do
+        expose_self format: :yaml, env: :test
+      end
+    end
+
+    config = ExposeYamlEndDataConfig.new
+
+    # NOTE: production env
+    expect(config.settings.prod_env.credentials.user).to eq('admin')
+    expect(config.settings.prod_env.credentials.password).to eq('123')
+    expect(config.settings.prod_env.credentials.enabled).to eq(true)
+    expect(config.settings.prod_env.api).to eq('google.com')
+    expect(config.settings.prod_env.ports).to eq([10001, 10002, 10003])
+
+    # NOTE: test env
+    expect(config.settings.test_env.credentials.user).to eq('megaman')
+    expect(config.settings.test_env.credentials.password).to eq('atata123')
+    expect(config.settings.test_env.credentials.enabled).to eq(false)
+    expect(config.settings.test_env.api).to eq('yandex.ru')
+    expect(config.settings.test_env.ports).to eq([1, 2, 3])
+
+    # NOTE: staging env
+    expect(config.settings.staging_env.credentials.user).to eq('diablo')
+    expect(config.settings.staging_env.credentials.password).to eq('testornot')
+    expect(config.settings.staging_env.credentials.enabled).to eq(true)
+    expect(config.settings.staging_env.api).to eq('battle.net')
+    expect(config.settings.staging_env.ports).to eq([111, 222, 333])
+  end
+end
+
+__END__
+
+production:
+  credentials:
+    user: admin
+    password: '123'
+    enabled: true
+  api: google.com
+  ports:
+    - 10001
+    - 10002
+    - 10003
+
+test:
+  credentials:
+    user: megaman
+    password: atata123
+    enabled: false
+  api: yandex.ru
+  ports:
+    - 1
+    - 2
+    - 3
+
+staging:
+  credentials:
+    user: diablo
+    password: testornot
+    enabled: true
+  api: battle.net
+  ports:
+    - 111
+    - 222
+    - 333

data/spec/features/expose_self_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+describe 'Expose self (expose __END__)' do
+  specify 'defines config object by __END__ instructions and specific environment settings' do
+    class ExposeSelfConfig < Qonfig::DataSet
+      setting :test_env do
+        expose_self env: :test # NOTE: format: :yaml by default
+      end
+
+      setting :dev_env do
+        expose_self env: :development # NOTE: format: :yaml by default
+      end
+
+      setting :stage_env do
+        expose_self env: :staging # NOTE: format: :yaml by default
+      end
+
+      setting :prod_env do
+        expose_self env: :production # NOTE: format: :yaml by default
+      end
+    end
+
+    settings = ExposeSelfConfig.new.settings
+
+    # :test env key
+    expect(settings.test_env.api_mode_enabled).to eq(true)
+    expect(settings.test_env.db_driver).to eq('in_memory')
+    expect(settings.test_env.logging).to eq(false)
+    expect(settings.test_env.credentials).to eq({})
+
+    # :production env key
+    expect(settings.prod_env.api_mode_enabled).to eq(true)
+    expect(settings.prod_env.db_driver).to eq('rom')
+    expect(settings.prod_env.logging).to eq(true)
+    expect(settings.prod_env.credentials).to eq({})
+
+    # :development env key
+    expect(settings.dev_env.api_mode_enabled).to eq(true)
+    expect(settings.dev_env.db_driver).to eq('sequel')
+    expect(settings.dev_env.logging).to eq(false)
+    expect(settings.dev_env.credentials).to eq({})
+
+    # :staging env key
+    expect(settings.stage_env.api_mode_enabled).to eq(true)
+    expect(settings.stage_env.db_driver).to eq('active_record')
+    expect(settings.stage_env.logging).to eq(true)
+    expect(settings.stage_env.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_self 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_self env: ''
+          end
+        end.to raise_error(Qonfig::ArgumentError)
+      end
+    end
+  end
+end
+
+__END__
+
+default: &default
+  api_mode_enabled: true
+  logging: true
+  db_driver: in_memory
+  throttle_requests: false
+  credentials: {}
+
+development:
+  <<: *default
+  db_driver: sequel
+  logging: false
+
+test:
+  <<: *default
+  logging: false
+
+staging:
+  <<: *default
+  db_driver: active_record
+  throttle_requests: true
+
+production:
+  <<: *default
+  db_driver: rom
+  throttle_requests: true

data/spec/features/expose_yaml_spec.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+describe 'Expose YAML file' do
+  specify 'defines config object by yaml instructions and specific environment settings' do
+    class ExposeYAMLConfig < Qonfig::DataSet
+      yaml_file_path = SpecSupport.fixture_path('expose_yaml', 'project.yml')
+
+      setting :file_name_based do
+        setting :test_env do
+          # spec/fixtures/expose_yaml/project.test.yml
+          expose_yaml yaml_file_path, via: :file_name, env: :test
+        end
+
+        setting :prod_env do
+          # spec/fixtures/expose_yaml/project.production.yml
+          expose_yaml yaml_file_path, via: :file_name, env: :production
+        end
+
+        setting :stage_env do
+          # spec/fixtures/expose_yaml/project.staging.yml
+          expose_yaml yaml_file_path, via: :file_name, env: :staging
+        end
+
+        setting :dev_env do
+          # spec/fixtures/expose_yaml/project.development.yml
+          expose_yaml yaml_file_path, via: :file_name, env: :development
+        end
+      end
+
+      setting :env_based do
+        setting :test_env do
+          # spec/fixtures/expose_yaml/project.yml
+          expose_yaml yaml_file_path, via: :env_key, env: :test
+        end
+
+        setting :prod_env do
+          # spec/fixtures/expose_yaml/project.yml
+          expose_yaml yaml_file_path, via: :env_key, env: :production
+        end
+
+        setting :stage_env do
+          # spec/fixtures/expose_yaml/project.yml
+          expose_yaml yaml_file_path, via: :env_key, env: :staging
+        end
+
+        setting :dev_env do
+          # spec/fixtures/expose_yaml/project.yml
+          expose_yaml yaml_file_path, via: :env_key, env: :development
+        end
+      end
+    end
+
+    settings = ExposeYAMLConfig.new.settings
+
+    # NOTE: file-name based expose
+    # spec/fixtures/expose_yaml/project.test.yml
+    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_yaml/project.production.yml
+    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_yaml/project.development.yml
+    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_yaml/project.staging.yml
+    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_yaml/project.yml (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_yaml/project.yml (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_yaml/project.yml (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_yaml/project.yml (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 PathnameExposeYamlCheck < Qonfig::DataSet
+      expose_yaml(
+        Pathname.new(SpecSupport.fixture_path('expose_yaml', 'project.yml')),
+        via: :env_key, env: :development
+      )
+    end
+
+    config = PathnameExposeYamlCheck.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_yaml SpecSupport.fixture_path(
+              'expose_yaml', 'project.yml'
+            ), 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_yaml SpecSupport.fixture_path(
+              'expose_yaml', 'project.yml'
+            ), 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_yaml SpecSupport.fixture_path(
+              'expose_yaml', 'project.yml'
+            ), 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_yaml/incompatible_structure.yml
+        #   - :staging environment key has incorrect value (scalar)
+        #   - :test environment key has correct value (hash)
+
+        class IncompatibleEnvBasedYAMLConfig < Qonfig::DataSet
+          expose_yaml SpecSupport.fixture_path(
+            'expose_yaml', 'incompatible_structure.yml'
+          ), via: :env_key, env: :staging
+        end
+
+        expect do
+          IncompatibleEnvBasedYAMLConfig.new
+        end.to raise_error(Qonfig::IncompatibleYAMLStructureError)
+
+        class CompatibleEnvBasedYAMLConfig < Qonfig::DataSet
+          expose_yaml SpecSupport.fixture_path(
+            'expose_yaml', 'incompatible_structure.yml'
+          ), via: :env_key, env: :test
+        end
+
+        expect { CompatibleEnvBasedYAMLConfig.new }.not_to raise_error
+      end
+
+      describe 'strict mode' do
+        specify(
+          'disabled (non-strict): ' \
+          'file existence requirement + yaml-env-key existence requirement'
+        ) do
+          # NOTE: file does not exist + env key does not exist in yml file
+          class NoFileNonStrictExposeYAMLConfig < Qonfig::DataSet
+            setting :non_strict_by_file do
+              expose_yaml SpecSupport.fixture_path(
+                'expose_yaml', 'nonexistent.yml'
+              ), strict: false, via: :file_name, env: :development
+            end
+
+            setting :non_strict_by_env do
+              expose_yaml SpecSupport.fixture_path(
+                'expose_yaml', 'nonexistent.yml'
+              ), strict: false, via: :env_key, env: :development
+            end
+          end
+
+          expect(NoFileNonStrictExposeYAMLConfig.new.to_h).to match(
+            'non_strict_by_file' => {},
+            'non_strict_by_env'  => {}
+          )
+
+          # NOTE: file is exist + env key does not exist in yml file
+          class NoEnvKeyNonStrictExposeYAMLConfig < Qonfig::DataSet
+            setting :non_strict_by_file do
+              expose_yaml SpecSupport.fixture_path(
+                'expose_yaml', 'project.yml'
+              ), strict: false, via: :file_name, env: :nonexistent
+            end
+
+            setting :non_strict_by_env do
+              expose_yaml SpecSupport.fixture_path(
+                'expose_yaml', 'project.yml'
+              ), strict: false, via: :env_key, env: :nonexistent
+            end
+          end
+
+          expect(NoEnvKeyNonStrictExposeYAMLConfig.new.to_h).to match(
+            'non_strict_by_file' => {},
+            'non_strict_by_env'  => {}
+          )
+        end
+
+        specify(
+          'enabled (strict, by default): ' \
+          'file existence requirement + yaml-env-key existence requirement'
+        ) do
+          # NOTE: file does not exist
+          class StrictFileViaFileNameYAMLConfig < Qonfig::DataSet
+            expose_yaml SpecSupport.fixture_path(
+              'expose_yaml', 'nonexistent.yml'
+            ), via: :file_name, env: :production
+          end
+
+          # NOTE: file does not exist
+          class StrictFileViaEnvKeyYAMLConfig < Qonfig::DataSet
+            expose_yaml SpecSupport.fixture_path(
+              'expose_yaml', 'nonexistent.yml'
+            ), via: :env_key, env: :production
+          end
+
+          # NOTE: file does not exist
+          expect { StrictFileViaFileNameYAMLConfig.new }.to raise_error(Qonfig::FileNotFoundError)
+          expect { StrictFileViaEnvKeyYAMLConfig.new }.to   raise_error(Qonfig::FileNotFoundError)
+
+          # NOTE:
+          #   - file exists but env key does not exist
+          #   - file: spec/fixtures/expose_yaml/project.yml
+          class NonExistentEnvKeyYAMLConfig < Qonfig::DataSet
+            expose_yaml SpecSupport.fixture_path(
+              'expose_yaml', 'project.yml'
+            ), via: :env_key, env: :nonexistent
+          end
+
+          # NOTE: env key does not exist
+          expect { NonExistentEnvKeyYAMLConfig.new }.to raise_error(Qonfig::ExposeError)
+        end
+      end
+    end
+  end
+end