a9n 0.10.0 → 1.0.0

data/spec/spec_helper.rb

@@ -1,96 +0,0 @@
-require 'simplecov'
-SimpleCov.start
-
-require 'rubygems'
-require 'bundler/setup'
-
-require 'a9n'
-require 'pry'
-
-RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
-  config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => 'be bigger than 2 and smaller than 4'
-    # ...rather than:
-    #     # => 'be bigger than 2'
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
-  end
-
-  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
-  # have no way to turn it off -- the option exists only for backwards
-  # compatibility in RSpec 3). It causes shared context metadata to be
-  # inherited by the metadata hash of host groups and examples, rather than
-  # triggering implicit auto-inclusion in groups with matching metadata.
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  # This allows you to limit a spec run to individual examples or groups
-  # you care about by tagging them with `:focus` metadata. When nothing
-  # is tagged with `:focus`, all examples get run. RSpec also provides
-  # aliases for `it`, `describe`, and `context` that include `:focus`
-  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
-  config.filter_run_when_matching :focus
-
-  # Allows RSpec to persist some state between runs in order to support
-  # the `--only-failures` and `--next-failure` CLI options. We recommend
-  # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = 'spec/examples.txt'
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
-  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  # if config.files_to_run.one?
-  #   # Use the documentation formatter for detailed output,
-  #   # unless a formatter has already been configured
-  #   # (e.g. via a command-line flag).
-  #   config.default_formatter = 'doc'
-  # end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-end
-
-def clean_singleton(klass)
-  [:@storage, :@env, :@app, :@root].each do |var|
-    klass.instance_variable_defined?(var) && klass.remove_instance_variable(var)
-  end
-end

data/spec/unit/a9n_spec.rb

@@ -1,268 +0,0 @@
-RSpec.describe A9n do
-  subject { described_class }
-  before { clean_singleton(subject) }
-  after { clean_singleton(subject) }
-
-  describe '.env' do
-    before do
-      subject.instance_variable_set(:@env, nil)
-    end
-
-    context 'app_env is set' do
-      let(:app) { OpenStruct.new(env: ::A9n::StringInquirer.new('foo_env')) }
-
-      before do
-        allow(subject).to receive(:app).and_return(app)
-        expect(subject).to receive(:env_var).never
-      end
-
-      it do
-        expect(subject.env).to eq('foo_env')
-        expect(subject.env.foo_env?).to eq(true)
-        expect(subject.env.production?).to eq(false)
-      end
-    end
-
-    context 'when APP_ENV is set' do
-      before do
-        expect(subject).to receive(:app_env).and_return(nil)
-        expect(subject).to receive(:env_var).with('RAILS_ENV').and_return(nil)
-        expect(subject).to receive(:env_var).with('RACK_ENV').and_return(nil)
-        expect(subject).to receive(:env_var).with('APP_ENV').and_return('foo_env')
-      end
-
-      it do
-        expect(subject.env).to eq('foo_env')
-        expect(subject.env.foo_env?).to eq(true)
-        expect(subject.env.production?).to eq(false)
-      end
-    end
-
-    context 'unknown env' do
-      before do
-        expect(subject).to receive(:app_env).and_return(nil)
-        expect(subject).to receive(:env_var).with('RAILS_ENV').and_return(nil)
-        expect(subject).to receive(:env_var).with('RACK_ENV').and_return(nil)
-        expect(subject).to receive(:env_var).with('APP_ENV').and_return(nil)
-      end
-
-      it do
-        expect { subject.env }.to raise_error(A9n::UnknownEnvError)
-      end
-    end
-  end
-
-  describe '.groups' do
-    before do
-      subject.env = 'development'
-    end
-
-    it do
-      expect(subject.groups).to eq(%w[default development])
-      expect(subject.groups).to be_frozen
-    end
-  end
-
-  describe '.app' do
-    context 'when rails not found' do
-      before do
-        expect(subject).to receive(:rails_app).and_return(nil)
-      end
-
-      it do
-        expect(subject.app).to be_nil
-      end
-    end
-
-    context 'when rails app is being used' do
-      let(:app) { double(env: 'test', root: '/apps/a9n') }
-
-      before do
-        expect(subject).to receive(:rails_app).and_return(app)
-      end
-
-      it do
-        expect(subject.app).to eq(app)
-      end
-    end
-
-    context 'when custom non-rails app is being used' do
-      let(:app) { double(env: 'test', root: '/apps/a9n') }
-
-      before do
-        subject.app = app
-      end
-
-      it do
-        expect(subject.app).to eq(app)
-      end
-    end
-  end
-
-  describe '.root' do
-    context 'when app is set' do
-      let(:app) { OpenStruct.new(env: 'test', root: '/apps/a9n') }
-
-      before do
-        subject.app = app
-      end
-
-      context 'with custom path' do
-        before do
-          subject.root = '/home/knapo/workspace/a9n'
-        end
-
-        it do
-          expect(subject.root).to eq(Pathname.new('/home/knapo/workspace/a9n'))
-          expect(subject.root).to be_frozen
-        end
-      end
-
-      context 'with local app path' do
-        it do
-          expect(subject.root).to eq('/apps/a9n')
-        end
-      end
-    end
-
-    context 'when app is not set' do
-      it do
-        expect(subject.root).to eq(A9n.root_from_bundle_env)
-      end
-
-      context 'when setting a custom path' do
-        before do
-          subject.root = '/home/knapo/workspace/a9n'
-        end
-
-        it do
-          expect(subject.root).to eq(Pathname.new('/home/knapo/workspace/a9n'))
-        end
-      end
-    end
-  end
-
-  describe '.rails_app' do
-    context 'when defined' do
-      before do
-        Object.const_set(:Rails, Module.new)
-      end
-
-      after do
-        Object.send(:remove_const, :Rails)
-      end
-
-      it do
-        expect(subject.rails_app).to be_kind_of(Module)
-      end
-    end
-
-    context 'when not defined' do
-      it do
-        expect(subject.rails_app).to be_nil
-      end
-    end
-  end
-
-  describe '.env_var' do
-    before do
-      ENV['FOO'] = 'little foo'
-    end
-
-    it do
-      expect(subject.env_var('FOO')).to eq('little foo')
-      expect(subject.env_var('FOO')).to be_frozen
-    end
-
-    it do
-      expect(subject.env_var('IS_FOO')).to be_nil
-    end
-  end
-
-  describe '.default_files' do
-    before do
-      subject.root = File.expand_path('../../test_app', __dir__)
-    end
-
-    it do
-      expect(subject.default_files[0]).to include('a9n.yml')
-      expect(Pathname.new(subject.default_files[0])).to be_absolute
-      expect(subject.default_files[1]).to include('a9n/aws.yml')
-      expect(Pathname.new(subject.default_files[1])).to be_absolute
-    end
-  end
-
-  describe '.load' do
-    before do
-      expect(described_class).to receive(:env).exactly(2).times.and_return('dev')
-      subject.root = '/apps/test_app'
-      files.each do |f, cfg|
-        expect(A9n::Loader).to receive(:new).with(f, kind_of(A9n::Scope), 'dev').and_return(double(get: cfg))
-      end
-    end
-
-    context 'when no files given' do
-      let(:files) do
-        {
-          '/apps/test_app/config/file1.yml' => { host: 'host1.com' },
-          '/apps/test_app/config/dir/file2.yml' => { host: 'host2.com' }
-        }
-      end
-
-      before do
-        expect(subject).to receive(:default_files).and_return(files.keys)
-        expect(subject).to receive(:absolute_paths_for).never
-      end
-
-      it do
-        expect(subject.load).to eq(files.values)
-      end
-    end
-
-    context 'when custom files given' do
-      let(:given_files) do
-        ['file3.yml', '/apps/test_app/config/dir/file4.yml']
-      end
-
-      let(:files) do
-        {
-          '/apps/test_app/config/file3.yml' => { host: 'host3.com' },
-          '/apps/test_app/config/dir/file4.yml' => { host: 'host4.com' }
-        }
-      end
-
-      before do
-        expect(subject).to receive(:default_files).never
-        expect(subject).to receive(:absolute_paths_for).with(given_files).and_call_original
-      end
-
-      it do
-        expect(subject.load(*given_files)).to eq(files.values)
-      end
-    end
-  end
-
-  describe '.method_missing' do
-    context 'when storage is empty' do
-      before do
-        expect(subject).to receive(:load).once
-      end
-
-      it do
-        expect(subject.storage).to be_empty
-        expect { subject.whatever }.to raise_error(A9n::NoSuchConfigurationVariableError)
-      end
-    end
-
-    context 'when storage is not empty' do
-      before do
-        subject.storage[:whenever] = 'whenever'
-        expect(subject).not_to receive(:load)
-      end
-
-      it do
-        expect { subject.whatever }.to raise_error(A9n::NoSuchConfigurationVariableError)
-      end
-    end
-  end
-end

data/spec/unit/loader_spec.rb

@@ -1,207 +0,0 @@
-RSpec.describe A9n::Loader do
-  let(:scope) { A9n::Scope.new('a9n') }
-  let(:env) { 'test' }
-  let(:root) { File.expand_path('../../test_app', __dir__) }
-  let(:file_path) { File.join(root, 'config/a9n.yml') }
-  subject { described_class.new(file_path, scope, env) }
-
-  describe '#intialize' do
-    it { expect(subject.scope).to eq(scope) }
-    it { expect(subject.env).to eq(env) }
-    it { expect(subject.local_file).to eq(file_path) }
-    it { expect(subject.example_file).to eq("#{file_path}.example") }
-  end
-
-  describe '#load' do
-    let(:example_config) do
-      { app_url: 'http://127.0.0.1:3000', api_key: 'example1234' }
-    end
-
-    let(:local_config) do
-      { app_host: '127.0.0.1:3000', api_key: 'local1234' }
-    end
-
-    let(:env) { 'tropical' }
-    let(:config) { subject.get }
-
-    context 'when no configuration file exists' do
-      before do
-        expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(nil)
-        expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(nil)
-      end
-
-      it 'raises expection' do
-        expect {
-          subject.load
-        }.to raise_error(A9n::MissingConfigurationDataError)
-      end
-    end
-
-    context 'when only example configuration file exists' do
-      before do
-        expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(example_config)
-        expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(nil)
-        subject.load
-      end
-
-      it { expect(config.app_url).to eq('http://127.0.0.1:3000') }
-      it { expect(config.api_key).to eq('example1234') }
-
-      it do
-        expect { config.app_host }.to raise_error(A9n::NoSuchConfigurationVariableError)
-      end
-    end
-
-    context 'when only local configuration file exists' do
-      before do
-        expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(nil)
-        expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(local_config)
-        subject.load
-      end
-
-      it { expect(config.app_host).to eq('127.0.0.1:3000') }
-      it { expect(config.api_key).to eq('local1234') }
-
-      it do
-        expect { config.app_url }.to raise_error(A9n::NoSuchConfigurationVariableError)
-      end
-    end
-
-    context 'when both local and base configuration file exists without defaults' do
-      context 'with same data' do
-        before do
-          expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(example_config)
-          expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(example_config)
-          subject.load
-        end
-
-        it { expect(config.app_url).to eq('http://127.0.0.1:3000') }
-        it { expect(config.api_key).to eq('example1234') }
-
-        it do
-          expect { config.app_host }.to raise_error(A9n::NoSuchConfigurationVariableError)
-        end
-      end
-
-      context 'with different data' do
-        before do
-          expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(example_config)
-          expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(local_config)
-        end
-
-        let(:missing_variables_names) { example_config.keys - local_config.keys }
-
-        it 'raises expection with missing variables names'  do
-          expect {
-            subject.load
-          }.to raise_error(A9n::MissingConfigurationVariablesError, /#{missing_variables_names.join(', ')}/)
-        end
-      end
-    end
-  end
-
-  describe '.load_yml' do
-    let(:env) { 'test' }
-    subject { described_class.load_yml(file_path, scope, env) }
-
-    context 'when file not exists' do
-      let(:file_path) { 'file_not_existing_in_the_universe.yml' }
-
-      it { expect(subject).to be_nil }
-    end
-
-    context 'when file exists' do
-      shared_examples 'non-empty config file' do
-        it 'returns non-empty hash' do
-          expect(subject).to be_kind_of(Hash)
-          expect(subject).to be_frozen
-          expect(subject.keys).to_not be_empty
-        end
-      end
-
-      before do
-        ENV['ERB_FOO'] = 'erbized foo'
-        ENV['FOO_PASSWORD'] = 'foo123'
-        ENV['FOO_KEY'] = 'key123'
-      end
-
-      after do
-        ENV.delete('ERB_FOO')
-        ENV.delete('FOO_PASSWORD')
-        ENV.delete('FOO_KEY')
-      end
-
-      context 'when file has erb extension' do
-        let(:file_path) { File.join(root, 'config/a9n/cloud.yml.erb') }
-
-        it_behaves_like 'non-empty config file'
-      end
-
-      context 'having env and defaults data' do
-        let(:file_path) { File.join(root, 'config/a9n.yml') }
-
-        it_behaves_like 'non-empty config file'
-
-        it 'contains only frozen values' do
-          expect(subject.values.reject(&:frozen?)).to eq([])
-        end
-
-        it 'contains keys from defaults scope' do
-          expect(subject[:default_foo]).to eq('default foo')
-          expect(subject[:overriden_foo]).to eq('already overriden foo')
-        end
-
-        it 'has symbolized keys' do
-          expect(subject.keys.first).to be_kind_of(Symbol)
-          expect(subject[:hash_foo]).to be_kind_of(Hash)
-          expect(subject[:hash_foo].keys.first).to be_kind_of(Symbol)
-          expect(subject[:hash_foo]).to eq(foo_1: 'hello 1', foo_2: 'hello 2', foo_key: 'key123')
-        end
-
-        it 'parses erb' do
-          expect(subject[:erb_foo]).to eq('erbized foo')
-        end
-
-        it 'gets valus from ENV' do
-          expect(subject[:foo_password]).to eq('foo123')
-        end
-
-        it 'raises exception when ENV var is not set' do
-          ENV.delete('FOO_PASSWORD')
-          expect { subject[:foo_password] }.to raise_error(A9n::MissingEnvVariableError)
-        end
-
-        it 'raises exception when ENV var is set to nil' do
-          ENV['FOO_PASSWORD'] = nil
-          expect { subject[:foo_password] }.to raise_error(A9n::MissingEnvVariableError)
-        end
-      end
-
-      context 'having no env and only defaults data' do
-        let(:file_path) { File.join(root, 'config/a9n.yml') }
-        let(:env) { 'production' }
-
-        it_behaves_like 'non-empty config file'
-
-        it 'contains keys from defaults scope' do
-          expect(subject[:default_foo]).to eq('default foo')
-          expect(subject[:overriden_foo]).to eq('not yet overriden foo')
-        end
-      end
-
-      context 'having only env and no default data' do
-        let(:file_path) { File.join(root, 'config/no_defaults.yml') }
-
-        context 'valid env' do
-          let(:env) { 'production' }
-          it_behaves_like 'non-empty config file'
-        end
-
-        context 'invalid env' do
-          let(:env) { 'tropical' }
-          it { expect(subject).to be_nil }
-        end
-      end
-    end
-  end
-end