kumo_config 0.0.1

data/spec/lib/environment_config_spec.rb

@@ -0,0 +1,202 @@
+describe KumoConfig::EnvironmentConfig do
+  let(:env_name) { 'the_jungle' }
+  let(:config_dir_path) { '/var/config' }
+  let(:options) do
+    {
+      env_name: env_name,
+      config_path: config_dir_path,
+      params_template_file_path: params_template_file_path
+    }
+  end
+  let(:file_loader) { instance_double(KumoConfig::FileLoader) }
+  let(:file_loader_cloudformation) { instance_double(KumoConfig::FileLoader) }
+  let(:parameters_erb) { ERB.new("") }
+  let(:params_template_file_path) { 'junk.txt' }
+  let(:environment_config_file_name) { "#{env_name}.yml" }
+  let(:kms) { instance_double(KumoKi::KMS) }
+  let(:logger) { double(:test_logger, debug: nil) }
+  let(:environment_config) { described_class.new(options, logger) }
+
+  before do
+    allow(KumoConfig::FileLoader).to receive(:new).and_return(file_loader)
+    allow(KumoKi::KMS).to receive(:new).and_return(kms)
+    allow(file_loader).to receive(:load_erb).with(params_template_file_path).and_return(parameters_erb)
+    allow(File).to receive(:dirname).and_return('/tmp')
+  end
+
+  context 'backward compatibility' do
+    context 'config_path' do
+      let(:options) do
+        {
+          env_name: env_name,
+          config_path: config_dir_path
+        }
+      end
+
+      it 'will be used without complaint' do
+          expect(KumoConfig::FileLoader).to receive(:new).with(config_dir_path: config_dir_path).and_return(nil)
+          expect(logger).to receive(:warn).at_most(0).times
+          expect(logger).to receive(:fatal).at_most(0).times
+          described_class.new(options, logger)
+      end
+
+      it 'complains if config_path is not present'
+    end
+
+    context 'config_dir_path' do
+      let(:options) do
+        {
+          env_name: env_name,
+          config_dir_path: config_dir_path
+        }
+      end
+
+      it 'will be used if given and raise a deprecation warning' do
+        expect(KumoConfig::FileLoader).to receive(:new).with(config_dir_path: config_dir_path).and_return(nil)
+          expect(logger).to receive(:warn).with("[DEPRECATION] `:config_dir_path` is deprecated, please pass in `:config_path` instead")
+          described_class.new(options, logger)
+      end
+    end
+  end
+
+  context 'unit tests' do
+    describe '#get_binding' do
+      subject { environment_config.get_binding }
+
+      it 'returns a binding' do
+        expect(subject).to be_a(Binding)
+      end
+    end
+
+    describe "#config" do
+      subject { described_class.new(options, logger).config }
+
+      context 'injected config' do
+
+        let(:options) do
+          {
+            env_name: env_name,
+            config_path: config_dir_path,
+            params_template_file_path: params_template_file_path,
+            injected_config: { "injected" => "yes" }
+          }
+        end
+
+        let(:common_parameters) { { "stack_name" => "okonomiyaki" } }
+        it 'adds injected config to the config hash' do
+          expect(file_loader).to receive(:load_hash).with('common.yml').and_return(common_parameters)
+          expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return({})
+          expect(file_loader).to receive(:load_hash).with("development.yml").and_return({})
+
+          expect(subject).to eq({ "stack_name" => "okonomiyaki", "injected" => "yes" })
+        end
+      end
+
+      context 'common config' do
+        let(:common_parameters) { { "stack_name" => "okonomiyaki" } }
+
+        it 'creates a array containing an aws formatted parameter hash' do
+          expect(file_loader).to receive(:load_hash).with('common.yml').and_return(common_parameters)
+          expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return({})
+          expect(file_loader).to receive(:load_hash).with("development.yml").and_return({})
+
+          expect(subject).to eq('stack_name' => 'okonomiyaki')
+        end
+      end
+
+      context 'merging common and environment specific configurations' do
+        let(:environment_config) { {'image' => 'ami-5678'} }
+        let(:development_config) { {'image' => 'ami-9999'} }
+
+        context 'with environmental overrides' do
+          let(:parameter_template) { "image: <%= config['image'] %>" }
+          let(:common_config) { {'image' => 'ami-1234'} }
+          let(:env_name) { 'development' }
+
+          it 'replaces the common value with the env value' do
+            expect(file_loader).to receive(:load_hash).with('common.yml').and_return(common_config)
+            expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return(environment_config)
+            expect(subject).to eq('image' => 'ami-5678')
+          end
+        end
+
+        it 'falls back to a default environment if the requested one does not exist' do
+          expect(file_loader).to receive(:load_hash).with('common.yml').and_return({})
+          expect(file_loader).to receive(:load_hash).with("#{env_name}.yml").and_return({})
+          expect(file_loader).to receive(:load_hash).with("development.yml").and_return(development_config)
+
+          expect(subject).to eq('image' => 'ami-9999')
+        end
+      end
+    end
+
+    describe "#plain_text_secrets" do
+      subject { described_class.new(options, logger).plain_text_secrets }
+
+      let(:crypted_password) { 'lookatmyencryptedpasswords' }
+      let(:plain_text_password) { 'plain_text_password' }
+      let(:secrets) { { 'secret_password' => "[ENC,#{crypted_password}" } }
+
+      let(:crypted_env_password) { 'cryptedenvpassword' }
+      let(:plain_text_env_password) { 'plain_text_env_password' }
+      let(:env_secrets) { { 'secret_password' => "[ENC,#{crypted_env_password}"}}
+
+      before do
+        allow(kms).to receive(:decrypt).with(crypted_password).and_return(plain_text_password)
+      end
+
+      it 'decrypts common secrets' do
+        allow(file_loader).to receive(:load_hash).with('common_secrets.yml').and_return(secrets)
+        allow(file_loader).to receive(:load_hash).with("#{env_name}_secrets.yml").and_return({})
+        allow(file_loader).to receive(:load_hash).with("development_secrets.yml").and_return({})
+
+        expect(subject).to eq('secret_password' => plain_text_password)
+      end
+
+      it 'decrypts environment secrets' do
+        allow(file_loader).to receive(:load_hash).with('common_secrets.yml').and_return({})
+        allow(file_loader).to receive(:load_hash).with("#{env_name}_secrets.yml").and_return(secrets)
+
+        expect(subject).to eq('secret_password' => plain_text_password)
+      end
+
+      it 'gives preference to environment secrets' do
+        allow(file_loader).to receive(:load_hash).with('common_secrets.yml').and_return(secrets)
+        allow(file_loader).to receive(:load_hash).with("#{env_name}_secrets.yml").and_return(env_secrets)
+        allow(kms).to receive(:decrypt).with(crypted_env_password).and_return(plain_text_env_password)
+
+        expect(subject).to eq('secret_password' => plain_text_env_password)
+      end
+
+      it 'falls back to a default environment if the requested one does not exist' do
+        allow(file_loader).to receive(:load_hash).with('common_secrets.yml').and_return({})
+        allow(file_loader).to receive(:load_hash).with("#{env_name}_secrets.yml").and_return({})
+        expect(file_loader).to receive(:load_hash).with("development_secrets.yml").and_return(secrets)
+
+        expect(subject).to eq('secret_password' => plain_text_password)
+      end
+    end
+
+    describe '#development?' do
+      %w(production staging).each do |environment|
+        it "returns false for #{environment}" do
+          expect(
+            described_class.new({
+              env_name: environment,
+              config_path: '',
+              params_template_file_path: ''}
+            ).development?).to eq false
+        end
+      end
+
+      it 'returns true for anything other than production or staging' do
+        expect(
+          described_class.new({
+            env_name: 'fred',
+            config_path: '',
+            params_template_file_path: ''}
+          ).development?).to eq true
+      end
+    end
+  end
+end

data/spec/lib/file_loader_spec.rb

@@ -0,0 +1,64 @@
+describe KumoConfig::FileLoader do
+  let(:config_dir_path) { '/the/garden/path' }
+  let(:options) { { config_dir_path: config_dir_path } }
+  let(:file_name) { 'environment.yml' }
+  let(:full_file_path) { config_dir_path + '/' + file_name }
+
+  describe "#load_erb" do
+    subject { KumoConfig::FileLoader.new(options).load_erb(file_name) }
+
+    context "when the requested erb file exits" do
+      let(:fake_erb_object) { double() }
+      let(:fake_file_handle) { double() }
+
+      it "loads the file and returns an ERB object" do
+        expect(File).to receive(:read).with("#{config_dir_path}/#{file_name}").and_return(fake_file_handle)
+        expect(ERB).to receive(:new).with(fake_file_handle).and_return(fake_erb_object)
+        expect(subject).to eq(fake_erb_object)
+      end
+    end
+  end
+
+  describe "#load_hash" do
+    subject { KumoConfig::FileLoader.new(options).load_hash(file_name) }
+
+    context "when the file does not exist" do
+      it "returns an empty hash" do
+        expect(subject).to eq({})
+      end
+    end
+
+    context "when the file does exist" do
+      let(:file_contents) { 'key: value' }
+
+      it "populates a hash" do
+        expect(File).to receive(:read).with(full_file_path).and_return(file_contents)
+        expect(subject).to eq({ 'key' => 'value' })
+      end
+    end
+  end
+
+  describe "#load_hash when you set optional flag to false" do
+    let(:config_dir_path) { '/the/garden/path' }
+    let(:options) { { config_dir_path: config_dir_path } }
+    let(:file_name) { 'environment.yml' }
+    let(:full_file_path) { config_dir_path + '/' + file_name }
+
+    subject { KumoConfig::FileLoader.new(options).load_hash(file_name, false) }
+
+    context 'when the file does not exist' do
+      it 'raises an error' do
+        expect { subject }.to raise_error(Errno::ENOENT)
+      end
+    end
+
+    context 'when the file exists' do
+      let(:file_contents) { 'key: value' }
+
+      it 'populates a hash' do
+        expect(File).to receive(:read).with(full_file_path).and_return(file_contents)
+        expect(subject).to eq({ 'key' => 'value' })
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+ENV['RUBY_ENV'] ||= 'test'
+require File.expand_path("../../lib/kumo_config.rb", __FILE__)
+Dir[File.expand_path("../support/*.rb", __FILE__)].each {|file| require file }
+
+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
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: kumo_config
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Redbubble
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kumo_ki
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: 
+email:
+- delivery-engineering@redbubble.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".buildkite/pipeline.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- kumo_config.gemspec
+- lib/kumo_config.rb
+- lib/kumo_config/environment_config.rb
+- lib/kumo_config/file_loader.rb
+- script/build.sh
+- script/integration_test.sh
+- script/unit_test.sh
+- spec/integration/.gitkeep
+- spec/integration/config_spec.rb
+- spec/integration/fixtures/.gitkeep
+- spec/integration/fixtures/common.yml
+- spec/integration/fixtures/common_secrets.yml
+- spec/integration/fixtures/development.yml
+- spec/integration/fixtures/development_secrets.yml
+- spec/integration/fixtures/production.yml
+- spec/integration/fixtures/production_secrets.yml
+- spec/lib/environment_config_spec.rb
+- spec/lib/file_loader_spec.rb
+- spec/spec_helper.rb
+homepage: http://redbubble.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A utility for reading Kumo configuration
+test_files:
+- spec/integration/.gitkeep
+- spec/integration/config_spec.rb
+- spec/integration/fixtures/.gitkeep
+- spec/integration/fixtures/common.yml
+- spec/integration/fixtures/common_secrets.yml
+- spec/integration/fixtures/development.yml
+- spec/integration/fixtures/development_secrets.yml
+- spec/integration/fixtures/production.yml
+- spec/integration/fixtures/production_secrets.yml
+- spec/lib/environment_config_spec.rb
+- spec/lib/file_loader_spec.rb
+- spec/spec_helper.rb