kumo_keisei 4.0.7 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dfd14b479ecbe73bb45fa4bb9c619a7dadef1d73
-  data.tar.gz: 7cddfcea3bef69d106eff3e2555e2af49b50cf24
+  metadata.gz: 98d31fb2d5e7dea5e297475a4580f02038ec74ce
+  data.tar.gz: f5d7e8d9ab455adab43ae717ebbd4343056b4db6
 SHA512:
-  metadata.gz: dbcbf96422f8e16ea0b668d6fb79621ee74b8ff9f59c00d0f5b8ad784a122a4417dce1817dc48b1ea42d0afbb472840deff2d98eeb70cfbb1daa8477c7919dec
-  data.tar.gz: adf2aece481994982d14972f1563ebf985054e4f53af4abc995ad6c502d8aaaea3f8e5f85f9efbea3764d83e9fcba51a9a7a9301785c407a5a6075b43d9b4625
+  metadata.gz: 288aedeb13b80df6a1728c5729ca9cefc02524b8507ece03669fd6e2115eb113e3d1ab3c168e775cd35164aae03e0240ec75f0efb5112a1807f0f2ecc311f03c
+  data.tar.gz: 89848dab939d87145bce5f9cae4997752edc57ff954338cba24faa2922b6f90a876745c2da50da1b3399eca29319f04a577f511d9c7a078fbf41d7e1ea9eecbb

data/README.md

@@ -118,9 +118,9 @@ end
 
 ## Upgrading from `KumoKeisei::CloudFormationStack` to `KumoKeisei::Stack`
 
-`KumoKeisei::CloudFormationStack` is deprecated and should be replaced with a `KumoKeisei::Stack` which encompasses an environment object (`KumoKeisei::EnvironmentConfig`).
+`KumoKeisei::CloudFormationStack` is deprecated and should be replaced with a `KumoKeisei::Stack` which encompasses an environment object (`KumoConfig::EnvironmentConfig`).
 
-Previously you would have to construct your own `EnvironmentConfig` which would marshal it's configuration, then instantiate a `CloudFormationStack` and conduct operations on it.
+Previously you would have to construct your own `EnvironmentConfig` which would marshal its configuration, then instantiate a `CloudFormationStack` and conduct operations on it.
 
 E.g. `apply-env`:
 ```ruby
@@ -131,7 +131,7 @@ environment_name = ARGV.fetch(0) rescue raise("Error! No environment name given!
 stack = CloudFormationStack.new(environment_name)
 stack.apply
 ```
-and `environment_config.rb`:
+and `cloudformation_stack.rb`:
 ```ruby
 require 'kumo_keisei'
 
@@ -216,14 +216,3 @@ You can test the Cloudformation responsibilities of this gem by extending the in
 To run these tests you need a properly configured AWS environment (with AWS_DEFAULT_REGION, AWS_ACCESS_KEY and AWS_SECRET_ACCESS_KEY set) and then run `./script/integration_test.sh`.
 
 If you run this within a Buildkite job then you will have a stack named "kumokeisei-test-$buildnumber" created and torn down for each integration test context. If you run this outside of a Buildkite job then the stack will be named "kumokeisei-test-$username".
-
-### Manual testing with Kumo Tools container
-
-Changes to the gem can be manually tested end to end in a project that uses the gem (i.e. http-wala).
-
-1. First start the dev-tools container: `kumo tools debug non-production`
-1. gem install specific_install
-1. Re-install the gem: `gem specific_install https://github.com/redbubble/kumo_keisei_gem.git -b <your_branch>`
-1. Fire up a console: `irb`
-1. Require the gem: `require "kumo_keisei"`
-1. Interact with the gem's classes. `KumoKeisei::Stack.new(...).apply!`

data/VERSION

@@ -1 +1 @@
-4.0.7
+5.0.0

data/kumo_keisei.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency 'aws-sdk', "~> 2.2"
-  spec.add_runtime_dependency 'kumo_ki'
+  spec.add_runtime_dependency 'kumo_config'
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.4"

data/lib/kumo_keisei.rb

@@ -1,5 +1,4 @@
 require_relative "kumo_keisei/cloud_formation_stack"
 require_relative "kumo_keisei/stack"
-require_relative "kumo_keisei/environment_config"
 require_relative "kumo_keisei/errors"
 require_relative "kumo_keisei/get_stack_output"

data/lib/kumo_keisei/stack.rb

@@ -1,4 +1,5 @@
 require 'aws-sdk'
+require 'kumo_config'
 
 module KumoKeisei
   class Stack
@@ -93,6 +94,21 @@ module KumoKeisei
 
     private
 
+    def cf_params(stack_config, environment_config)
+      erb = params_template_erb(stack_config)
+      return [] unless erb
+
+      stack_params = YAML.load(erb.result(environment_config.get_binding))
+      KumoKeisei::ParameterBuilder.new(stack_params).params
+    end
+
+    def params_template_erb(stack_config)
+      template_path = params_template_path(stack_config)
+
+      return nil unless template_path && File.exist?(template_path)
+      ERB.new(File.read(template_path))
+    end
+
     def transform_logical_resource_id(id)
       id.to_s.split('_').map {|w| w.capitalize }.join
     end
@@ -141,7 +157,7 @@ module KumoKeisei
       cloudformation.create_stack(
         stack_name: @stack_name,
         template_body: File.read(stack_config[:template_path]),
-        parameters: environment_config(stack_config).cf_params,
+        parameters: cf_params(stack_config, environment_config(stack_config)),
         capabilities: ["CAPABILITY_IAM"],
         on_failure: "DELETE"
       )
@@ -159,7 +175,7 @@ module KumoKeisei
       cloudformation.update_stack(
         stack_name: @stack_name,
         template_body: File.read(stack_config[:template_path]),
-        parameters: environment_config(stack_config).cf_params,
+        parameters: cf_params(stack_config, environment_config(stack_config)),
         capabilities: ["CAPABILITY_IAM"]
       )
 
@@ -174,7 +190,7 @@ module KumoKeisei
     end
 
     def environment_config(stack_config)
-      EnvironmentConfig.new(stack_config.merge(params_template_file_path: params_template_path(stack_config)))
+      KumoConfig::EnvironmentConfig.new(stack_config)
     end
 
     def stack_events_url

data/spec/lib/kumo_keisei/stack_spec.rb

@@ -23,7 +23,7 @@ describe KumoKeisei::Stack do
     {
       stack_name: stack_name,
       template_body: stack_template_body,
-      parameters: {},
+      parameters: [],
       capabilities: ["CAPABILITY_IAM"]
     }
   end
@@ -48,7 +48,7 @@ describe KumoKeisei::Stack do
     allow(cloudformation).to receive(:describe_stacks).with({stack_name: stack_name}).and_return(cf_stack)
     allow(KumoKeisei::ParameterBuilder).to receive(:new).and_return(parameter_builder)
     allow(File).to receive(:read).with(stack_cfntemplate_filename).and_return(stack_template_body)
-    allow(KumoKeisei::EnvironmentConfig).to receive(:new).with(stack_config.merge(params_template_file_path: "/#{stack_cfnparams_filename}")).and_return(double(:environment_config, cf_params: {}))
+    allow(KumoConfig::EnvironmentConfig).to receive(:new).with(stack_config).and_return(double(:environment_config))
     Dir.chdir('/')
   end
 
@@ -278,8 +278,8 @@ describe KumoKeisei::Stack do
 
   describe "#config" do
     context "when passed a config_path and params_template_file_path" do
-      it "will return the results of the nested KumoKeisei::EnvironmentConfig.config" do
-        expect(KumoKeisei::EnvironmentConfig).to receive(:new).with(stack_config.merge(params_template_file_path: "/#{stack_template_name}.yml.erb")).and_return(double(:environment_config, cf_params: {}, config: { :foo=> 'bar', :baz=> 'qux' }))
+      it "will return the results of the nested KumoConfig::EnvironmentConfig.config" do
+        expect(KumoConfig::EnvironmentConfig).to receive(:new).with(stack_config).and_return(double(:environment_config, cf_params: {}, config: { :foo=> 'bar', :baz=> 'qux' }))
         expect(subject.config(stack_config)).to eq({:foo=> 'bar', :baz=>'qux'})
       end
     end
@@ -292,8 +292,8 @@ describe KumoKeisei::Stack do
         }
       }
 
-      it "will return the results of the nested KumoKeisei::EnvironmentConfig.config" do
-        expect(KumoKeisei::EnvironmentConfig).to receive(:new).with(stack_config.merge(params_template_file_path: nil)).and_return(double(:environment_config, cf_params: {}, config: { :foo=> 'bar', :baz=> 'qux' }))
+      it "will return the results of the nested KumoConfig::EnvironmentConfig.config" do
+        expect(KumoConfig::EnvironmentConfig).to receive(:new).with(stack_config).and_return(double(:environment_config, cf_params: {}, config: { :foo=> 'bar', :baz=> 'qux' }))
         expect(subject.config(stack_config)).to eq({:foo=> 'bar', :baz=>'qux'})
       end
     end
@@ -344,8 +344,8 @@ describe KumoKeisei::Stack do
 
   describe "#plain_text_secrets" do
     context "when passed a config_path and params_template_file_path" do
-      it "will return the results of the nested KumoKeisei::EnvironmentConfig.plain_text_secrets" do
-        expect(KumoKeisei::EnvironmentConfig).to receive(:new).with(stack_config.merge(params_template_file_path: "/#{stack_template_name}.yml.erb")).and_return(double(:environment_config, cf_params: {}, plain_text_secrets: { :foo=> 'bar', :baz=> 'qux' }))
+      it "will return the results of the nested KumoConfig::EnvironmentConfig.plain_text_secrets" do
+        expect(KumoConfig::EnvironmentConfig).to receive(:new).with(stack_config).and_return(double(:environment_config, cf_params: {}, plain_text_secrets: { :foo=> 'bar', :baz=> 'qux' }))
         expect(subject.plain_text_secrets(stack_config)).to eq({:foo=> 'bar', :baz=>'qux'})
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kumo_keisei
 version: !ruby/object:Gem::Version
-  version: 4.0.7
+  version: 5.0.0
 platform: ruby
 authors:
 - Redbubble
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-27 00:00:00.000000000 Z
+date: 2016-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: kumo_ki
+  name: kumo_config
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -115,9 +115,7 @@ files:
 - lib/kumo_keisei.rb
 - lib/kumo_keisei/cloud_formation_stack.rb
 - lib/kumo_keisei/console_jockey.rb
-- lib/kumo_keisei/environment_config.rb
 - lib/kumo_keisei/errors.rb
-- lib/kumo_keisei/file_loader.rb
 - lib/kumo_keisei/get_stack_output.rb
 - lib/kumo_keisei/parameter_builder.rb
 - lib/kumo_keisei/stack.rb
@@ -133,8 +131,6 @@ files:
 - spec/integration/stack_spec.rb
 - spec/lib/kumo_keisei/cloud_formation_stack_spec.rb
 - spec/lib/kumo_keisei/console_jockey_spec.rb
-- spec/lib/kumo_keisei/environment_config_spec.rb
-- spec/lib/kumo_keisei/file_loader_spec.rb
 - spec/lib/kumo_keisei/get_stack_output_spec.rb
 - spec/lib/kumo_keisei/parameter_builder_spec.rb
 - spec/lib/kumo_keisei/stack_spec.rb
@@ -172,8 +168,6 @@ test_files:
 - spec/integration/stack_spec.rb
 - spec/lib/kumo_keisei/cloud_formation_stack_spec.rb
 - spec/lib/kumo_keisei/console_jockey_spec.rb
-- spec/lib/kumo_keisei/environment_config_spec.rb
-- spec/lib/kumo_keisei/file_loader_spec.rb
 - spec/lib/kumo_keisei/get_stack_output_spec.rb
 - spec/lib/kumo_keisei/parameter_builder_spec.rb
 - spec/lib/kumo_keisei/stack_spec.rb

data/lib/kumo_keisei/environment_config.rb

@@ -1,136 +0,0 @@
-require 'kumo_ki'
-require 'logger'
-require 'yaml'
-
-require_relative 'file_loader'
-require_relative 'parameter_builder'
-
-module KumoKeisei
-  # Environment Configuration for a cloud formation stack
-  class EnvironmentConfig
-    class ConfigurationError < StandardError; end
-
-    LOGGER = Logger.new(STDOUT)
-
-    attr_reader :app_name, :env_name
-
-    def initialize(options, logger = LOGGER)
-      @env_name = options[:env_name]
-      @params_template_file_path = options[:params_template_file_path]
-      @injected_config = options[:injected_config] || {}
-      @log = logger
-
-      if options[:config_path]
-          @config_file_loader = KumoKeisei::FileLoader.new(config_dir_path: options[:config_path])
-      elsif options[:config_dir_path]
-          @log.warn "[DEPRECATION] `:config_dir_path` is deprecated, please pass in `:config_path` instead"
-          @config_file_loader = KumoKeisei::FileLoader.new(config_dir_path: options[:config_dir_path])
-      end
-
-    end
-
-    def production?
-      env_name == 'production'
-    end
-
-    def development?
-      !%w(production staging).include? env_name
-    end
-
-    def plain_text_secrets
-      @plain_text_secrets ||= decrypt_secrets(encrypted_secrets)
-    end
-
-    def config
-      # a hash of all settings that apply to this environment
-      @config ||= common_config.merge(env_config).merge(@injected_config)
-    end
-
-    def cf_params
-      # returns a list of Cfn friendly paramater_value, paramater_key pairs for
-      # consumption by cloudformation.
-      return [] unless params_template_erb
-      config
-
-      stack_params = YAML.load(params_template_erb.result(binding))
-      KumoKeisei::ParameterBuilder.new(stack_params).params
-    end
-
-    def get_binding
-      binding
-    end
-
-    private
-
-    def kms
-      @kms ||= KumoKi::KMS.new
-    end
-
-    def params_template_erb
-      return nil unless @params_template_file_path && File.exist?(@params_template_file_path)
-      template_file_loader = KumoKeisei::FileLoader.new(config_dir_path: File.dirname(@params_template_file_path))
-      template_file_loader.load_erb(File.basename(@params_template_file_path))
-    end
-
-    def decrypt_secrets(secrets)
-      Hash[
-        secrets.map do |name, cipher_text|
-          @log.debug "Decrypting '#{name}'"
-          decrypt_cipher name, cipher_text
-        end
-      ]
-    end
-
-    def decrypt_cipher(name, cipher_text)
-      if cipher_text.start_with? '[ENC,'
-        begin
-          [name, kms.decrypt(cipher_text[5, cipher_text.size]).to_s]
-        rescue
-          @log.error "Error decrypting secret '#{name}'"
-          raise
-        end
-      else
-        [name, cipher_text]
-      end
-    end
-
-    def env_config_file_name
-      "#{env_name}.yml"
-    end
-
-    def env_secrets_file_name
-      "#{env_name}_secrets.yml"
-    end
-
-    def encrypted_secrets
-      encrypted_common_secrets.merge(encrypted_env_secrets)
-    end
-
-    def encrypted_common_secrets
-      @config_file_loader.load_hash('common_secrets.yml')
-    end
-
-    def encrypted_env_secrets
-      secrets = @config_file_loader.load_hash(env_secrets_file_name)
-
-      if !secrets.empty?
-        secrets
-      else
-        @config_file_loader.load_hash('development_secrets.yml')
-      end
-    end
-
-    def common_config
-      @config_file_loader.load_hash('common.yml')
-    end
-
-    def env_config
-      config = @config_file_loader.load_hash(env_config_file_name)
-      if !config.empty?
-        config
-      else
-        @config_file_loader.load_hash('development.yml')
-      end
-    end
-  end
-end

data/lib/kumo_keisei/file_loader.rb

@@ -1,38 +0,0 @@
-require 'erb'
-
-module KumoKeisei
-  class FileLoader
-    def initialize(options)
-      @config_dir_path = options[:config_dir_path]
-    end
-
-    def load_hash(file_name, optional = true)
-      # reads a file presuming it's a yml in form of key: value, returning it as a hash
-      path = file_path(file_name)
-
-      begin
-        YAML::load(File.read(path))
-      rescue Errno::ENOENT => ex
-        # file not found, return empty dictionary if that is ok
-        return {} if optional
-        raise ex
-      rescue StandardError => ex
-        # this is an error we weren't expecting
-        raise ex
-      end
-    end
-
-    def load_erb(file_name)
-      # loads a file, constructs an ERB object from it and returns the ERB object
-      # DOES NOT RENDER A RESULT!!
-      path = file_path(file_name)
-      ERB.new(File.read(path))
-    end
-
-    private
-
-    def file_path(file_name)
-      File.join(@config_dir_path, file_name)
-    end
-  end
-end

data/spec/lib/kumo_keisei/environment_config_spec.rb

@@ -1,282 +0,0 @@
-describe KumoKeisei::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(KumoKeisei::FileLoader) }
-  let(:file_loader_cloudformation) { instance_double(KumoKeisei::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(KumoKeisei::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(KumoKeisei::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
-    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(KumoKeisei::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 '#cf_params' do
-      subject { environment_config.cf_params }
-
-      context 'params template file path is not provided' do
-        let(:options) do
-          {
-            env_name: env_name,
-            config_path: config_dir_path
-          }
-        end
-
-        it 'creates an empty array' do
-          expect(subject).to eq([])
-        end
-      end
-
-      context 'params is empty' do
-        let(:parameters_erb) { nil }
-
-        it 'creates an empty array' do
-          expect(subject).to eq([])
-        end
-      end
-
-      context 'no config_path' do
-        let(:options) { { params_template_file_path: "not-a-real-file.yml.erb" } }
-
-        it { is_expected.to eq([]) }
-      end
-
-      context 'a hard-coded param' do
-        let(:parameters_erb) { ERB.new("foo: \"bar\"") }
-
-        before do
-          allow(File).to receive(:exist?).with(params_template_file_path).and_return(true)
-          allow(file_loader).to receive(:load_hash).with('common.yml').and_return({})
-          allow(file_loader).to receive(:load_hash).with('the_jungle.yml').and_return({})
-          allow(file_loader).to receive(:load_hash).with('development.yml').and_return({})
-        end
-
-        it 'creates a array containing an aws formatted parameter hash' do
-          expect(subject).to eq([{parameter_key: "foo", parameter_value: "bar"}])
-        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
-
-    context 'integration tests' do
-      describe '#cf_params' do
-        subject { environment_config.cf_params }
-
-        context 'templated params' do
-          before { allow(File).to receive(:exist?).with(params_template_file_path).and_return(true) }
-
-          let(:parameters_erb) { ERB.new("stack_name: \"<%= config['stack_name'] %>\"" ) }
-          let(:common_config) { { "stack_name" => "common"} }
-          let(:staging_config) { { "stack_name" => "staging" } }
-          let(:development_config) { { "stack_name" => "development" } }
-
-          context 'hiearchy of parameters' do
-            it 'will load values from the common paramater file' do
-              expect(file_loader).to receive(:load_hash).with('common.yml').and_return(common_config)
-              expect(file_loader).to receive(:load_hash).with("development.yml").and_return({})
-              expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return({})
-              expect(subject).to eq([{parameter_key: "stack_name", parameter_value: "common"}])
-            end
-
-            it 'will load values from the environment specific file' do
-              expect(file_loader).to receive(:load_hash).with('common.yml').and_return({})
-              expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return(staging_config)
-              expect(subject).to eq([{parameter_key: "stack_name", parameter_value: "staging"}])
-            end
-
-            it 'will load values from the shared development file if an environment specific file has no values' do
-              expect(file_loader).to receive(:load_hash).with('common.yml').and_return({})
-              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(development_config)
-              expect(subject).to eq([{parameter_key: "stack_name", parameter_value: "development"}])
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/kumo_keisei/file_loader_spec.rb

@@ -1,64 +0,0 @@
-describe KumoKeisei::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 { KumoKeisei::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 { KumoKeisei::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 { KumoKeisei::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