aws2-ssm-env 0.1.1

data/spec/aws-ssm-env/fetchers/factory_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe AwsSsmEnv::FetcherFactory do
+  describe '#create_fetcher' do
+    let(:fetcher) { described_class.create_fetcher(args) }
+
+    context 'when fetch was not set' do
+      context 'when begins_with was not set' do
+        let(:args) { { path: '/path' } }
+
+        it 'return AwsSsmEnv::PathFetcher' do
+          expect(fetcher).to be_a(AwsSsmEnv::PathFetcher)
+        end
+      end
+
+      context 'when begins_with was set' do
+        let(:args) { { begins_with: '/path' } }
+
+        it 'return AwsSsmEnv::BeginsWithFetcher' do
+          expect(fetcher).to be_a(AwsSsmEnv::BeginsWithFetcher)
+        end
+      end
+    end
+
+    context 'when fetch is :path' do
+      let(:args) { { fetch: :path, path: '/path' } }
+
+      it 'return AwsSsmEnv::PathFetcher' do
+        expect(fetcher).to be_a(AwsSsmEnv::PathFetcher)
+      end
+    end
+
+    context 'when fetch is :begins_with' do
+      let(:args) { { fetch: :begins_with, begins_with: '/path' } }
+
+      it 'return AwsSsmEnv::BeginsWithFetcher' do
+        expect(fetcher).to be_a(AwsSsmEnv::BeginsWithFetcher)
+      end
+    end
+
+    context 'when fetch is AwsSsmEnv::Fetcher implementation instance' do
+      let(:fetcher_class) { Class.new(AwsSsmEnv::Fetcher) { def fetch(_); end } }
+      let(:fetcher_instance) { fetcher_class.new }
+      let(:args) { { fetch: fetcher_instance } }
+
+      it 'return it as is' do
+        expect(fetcher).to eq(fetcher_instance)
+      end
+    end
+
+    context 'when fetch has each method' do
+      let(:args) { { fetch: [] } }
+
+      it 'return it as is' do
+        expect(fetcher).to eq([])
+      end
+    end
+
+    context 'in other cases' do
+      it 'raise error' do
+        expect { described_class.create_fetcher(fetch: 'foo') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/aws-ssm-env/fetchers/path_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'aws-ssm-env/fetchers/path'
+
+describe AwsSsmEnv::PathFetcher do
+  let(:fetcher) { described_class.new(args) }
+  let(:args) { { path: '/path' } }
+  let(:base_params) { fetcher.instance_variable_get(:'@base_params') }
+
+  describe '#initialize' do
+    context 'when path was not set' do
+      it 'raise error' do
+        expect { described_class.new(path: nil) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when :path was set' do
+      it '@base_params[:path] is argument value' do
+        expect(base_params[:path]).to eq('/path')
+      end
+    end
+
+    context 'when recursive was not set' do
+      it '@base_params[:recursive] is false' do
+        expect(base_params[:recursive]).to be_falsey
+      end
+    end
+
+    context 'when recursive is truthy string' do
+      let(:args) { { path: '/path', recursive: 'TruE' } }
+
+      it '@base_params[:recursive] is true' do
+        expect(base_params[:recursive]).to be_truthy
+      end
+    end
+
+    context 'when recursive is not truthy string' do
+      let(:args) { { path: '/path', recursive: 'foo' } }
+
+      it '@base_params[:recursive] is false' do
+        expect(base_params[:recursive]).to be_falsey
+      end
+    end
+
+    context 'when :fetch_size was set and less than 10' do
+      let(:args) { { path: '/path', fetch_size: 5 } }
+
+      it '@base_params[:max_results] is fetch_size value' do
+        expect(base_params[:max_results]).to eq(5)
+      end
+    end
+
+    context 'when :fetch_size was not set' do
+      it '@base_params[:max_results] is 10' do
+        expect(base_params[:max_results]).to eq(10)
+      end
+    end
+
+    context 'when :fetch_size is nil' do
+      let(:args) { { path: '/path', fetch_size: nil } }
+
+      it '@base_params[:max_results] is 10' do
+        expect(base_params[:max_results]).to eq(10)
+      end
+    end
+
+    context 'when :fetch_size > 10' do
+      let(:args) { { path: '/path', fetch_size: 11 } }
+
+      it '@base_params[:max_results] is 10' do
+        expect(base_params[:max_results]).to eq(10)
+      end
+    end
+  end
+
+  describe '#fetch' do
+    before do
+      allow_any_instance_of(Aws::SSM::Client).to \
+        receive(:get_parameters_by_path).and_return(nil)
+    end
+
+    let(:client) { fetcher.send(:client) }
+
+    context 'when next_token is nil' do
+      it 'called get_parameters_by_path without next_token' do
+        expect(fetcher.send(:fetch, nil)).to be_nil
+        expect(client).to \
+          have_received(:get_parameters_by_path).with(base_params).once
+      end
+    end
+
+    context 'when next_token is not nil' do
+      it 'called get_parameters_by_path with next_token' do
+        expect(fetcher.send(:fetch, 'next_token')).to be_nil
+        expect(client).to \
+          have_received(:get_parameters_by_path)
+          .with(base_params.merge(next_token: 'next_token')).once
+      end
+    end
+  end
+end

data/spec/aws-ssm-env/loader_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe AwsSsmEnv::Loader do
+  let(:args) { { path: '/foo' } }
+
+  describe '#initialize' do
+    let(:loader) { described_class.new(args) }
+
+    it 'has fetcher and naming_strategy' do
+      expect(loader.instance_variable_get(:@fetcher)).to be_a(AwsSsmEnv::PathFetcher)
+      expect(loader.instance_variable_get(:@naming_strategy)).to be_a(AwsSsmEnv::BasenameNamingStrategy)
+    end
+
+    describe 'overwrite option' do
+      let(:applier) { loader.instance_variable_get(:@applier) }
+
+      context 'when overwrite was not set' do
+        it '@applier is not overwrite method' do
+          expect(applier).to eq(:apply)
+        end
+      end
+
+      context 'when overwrite is nil' do
+        let(:args) { { path: '/foo', overwrite: nil } }
+
+        it '@applier is not overwrite method' do
+          expect(applier).to eq(:apply)
+        end
+      end
+
+      context 'when overwrite is truthy string' do
+        let(:args) { { path: '/foo', overwrite: 'truE' } }
+
+        it '@applier is overwrite method' do
+          expect(applier).to eq(:apply!)
+        end
+      end
+
+      context 'when overwrite is not truthy string' do
+        let(:args) { { path: '/foo', overwrite: 'foo' } }
+
+        it '@applier is not overwrite method' do
+          expect(applier).to eq(:apply)
+        end
+      end
+    end
+  end
+
+  describe '#load' do
+    context 'when overwrite is false' do
+      it 'environment variables were not overwritten' do
+        ENV['foo'] = nil
+        ENV['fizz'] = 'fizz'
+
+        loader = described_class.new(args)
+        loader.instance_variable_set(:@fetcher,
+          [ Parameter.new('foo', 'bar'), Parameter.new('fizz', 'buzz') ])
+
+        loader.load
+
+        expect(ENV['foo']).to eq('bar')
+        expect(ENV['fizz']).to eq('fizz')
+      end
+    end
+
+    context 'when overwrite is true' do
+      let(:args) { { path: '/foo', overwrite: true } }
+
+      it 'environment variables were overwritten' do
+        ENV['foo'] = nil
+        ENV['fizz'] = 'fizz'
+
+        loader = described_class.new(args)
+        loader.instance_variable_set(:@fetcher,
+          [ Parameter.new('foo', 'bar'), Parameter.new('fizz', 'buzz') ])
+
+        loader.load
+
+        expect(ENV['foo']).to eq('bar')
+        expect(ENV['fizz']).to eq('buzz')
+      end
+    end
+  end
+end

data/spec/aws-ssm-env/naming_strategies/basename_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'aws-ssm-env/naming_strategies/basename'
+
+describe AwsSsmEnv::BasenameNamingStrategy do
+  describe '#parse_name' do
+    let(:naming_strategy) { described_class.new }
+
+    it 'return the last element name of the path hierarchy' do
+      expect(naming_strategy.parse_name(Parameter.new('/path/to/ENV_NAME'))).to eq('ENV_NAME')
+      expect(naming_strategy.parse_name(Parameter.new('env_name'))).to eq('env_name')
+      expect(naming_strategy.parse_name(Parameter.new('env/name'))).to eq('name')
+    end
+  end
+end

data/spec/aws-ssm-env/naming_strategies/factory_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe AwsSsmEnv::NamingStrategyFactory do
+  describe '#create_naming_strategy' do
+    let(:naming_strategy) { described_class.create_naming_strategy(args) }
+
+    context 'when naming was not set' do
+      let(:args) { { naming: nil } }
+
+      it 'return AwsSsmEnv::BasenameNamingStrategy' do
+        expect(naming_strategy).to be_a(AwsSsmEnv::BasenameNamingStrategy)
+      end
+    end
+
+    context 'when naming is :basename' do
+      let(:args) { { naming: :basename } }
+
+      it 'return AwsSsmEnv::BasenameNamingStrategy' do
+        expect(naming_strategy).to be_a(AwsSsmEnv::BasenameNamingStrategy)
+      end
+    end
+
+    context 'when naming is :snakecase' do
+      let(:args) { { naming: :snakecase } }
+
+      it 'return AwsSsmEnv::SnakeCaseNamingStrategy' do
+        expect(naming_strategy).to be_a(AwsSsmEnv::SnakeCaseNamingStrategy)
+      end
+    end
+
+    context 'when naming is AwsSsmEnv::NamingStrategy implementation instance' do
+      let(:naming_class) { Class.new(AwsSsmEnv::NamingStrategy) { def parse_name(_); end } }
+      let(:naming_instance) { naming_class.new }
+      let(:args) { { naming: naming_instance } }
+
+      it 'return it as is' do
+        expect(naming_strategy).to eq(naming_instance)
+      end
+    end
+
+    context 'when naming has parse_name method' do
+      let(:naming_class) { Class.new { def parse_name(_); end } }
+      let(:naming_instance) { naming_class.new }
+      let(:args) { { naming: naming_instance } }
+
+      it 'return it as is' do
+        expect(naming_strategy).to eq(naming_instance)
+      end
+    end
+
+    context 'in other cases' do
+      it 'raise error' do
+        expect { described_class.create_naming_strategy(naming: 'foo') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/aws-ssm-env/naming_strategies/snakecase_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'aws-ssm-env/naming_strategies/snakecase'
+
+describe AwsSsmEnv::SnakeCaseNamingStrategy do
+  let(:strategy) { described_class.new(args) }
+  let(:name) { 'path.to.db/password' }
+  let(:env_name) { strategy.parse_name(Parameter.new(name)) }
+
+  describe '#parse_name' do
+    context 'when :removed_prefix was not set' do
+      context 'when :begins_with was not set' do
+        let(:args) { {} }
+
+        it 'return converted path hierarchy into snake case' do
+          expect(env_name).to eq('PATH.TO.DB_PASSWORD')
+        end
+      end
+
+      context 'when :begins_with was set' do
+        let(:args) { { begins_with: 'path.to.' } }
+
+        it 'return converted path hierarchy without begins_with into snake case' do
+          expect(env_name).to eq('DB_PASSWORD')
+        end
+      end
+
+      context 'when :path was set' do
+        let(:args) { { path: 'path.to.' } }
+
+        it 'return converted path hierarchy without begins_with into snake case' do
+          expect(env_name).to eq('DB_PASSWORD')
+        end
+      end
+    end
+
+    context 'when :removed_prefix was set' do
+      context 'when :begins_with was not set' do
+        let(:args) { { removed_prefix: 'path.' } }
+
+        it 'return converted path hierarchy without removed_prefix into snake case' do
+          expect(env_name).to eq('TO.DB_PASSWORD')
+        end
+      end
+
+      context 'when :begins_with was set' do
+        let(:args) { { removed_prefix: 'path.', begins_with: 'path.to.' } }
+
+        it 'return converted path hierarchy without removed_prefix into snake case' do
+          expect(env_name).to eq('TO.DB_PASSWORD')
+        end
+      end
+
+      context 'when :path was set' do
+        let(:args) { { removed_prefix: 'path.', path: 'path.to.' } }
+
+        it 'return converted path hierarchy without removed_prefix into snake case' do
+          expect(env_name).to eq('TO.DB_PASSWORD')
+        end
+      end
+    end
+
+    context 'when :delimiter was not set' do
+      let(:args) { { removed_prefix: 'path.' } }
+
+      it 'return converted path hierarchy with replace "/" to "_"' do
+        expect(env_name).to eq('TO.DB_PASSWORD')
+      end
+    end
+
+    context 'when :delimiter was set' do
+      let(:args) { { removed_prefix: 'path.', delimiter: %r{[./]} } }
+
+      it 'return converted path hierarchy with replace "/" or "." to "_"' do
+        expect(env_name).to eq('TO_DB_PASSWORD')
+      end
+    end
+  end
+end

data/spec/aws-ssm-env/naming_strategy_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe AwsSsmEnv::NamingStrategy do
+  describe '#parse_name' do
+    let!(:strategy) { described_class.new }
+
+    it 'raise error' do
+      expect { strategy.parse_name(Parameter.new('foo')) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/aws-ssm-env/parameter.rb

@@ -0,0 +1,7 @@
+class Parameter
+  attr_reader :name, :value
+  def initialize(*args)
+    @name = args[0]
+    @value = args[1]
+  end
+end

data/spec/aws-ssm-env_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'logger'
+
+describe AwsSsmEnv do
+  let(:ssm_client) {
+    stub_responses = {
+      get_parameters_by_path: {
+        parameters: [
+          { name: 'foo', value: 'bar', type: 'String', version: 1 },
+          { name: 'fizz', value: 'buzz', type: 'String', version: 1 }
+        ],
+        next_token: nil
+      }
+    }
+    Aws::SSM::Client.new(stub_responses: stub_responses)
+  }
+  let(:logger) { Logger.new('/dev/null') }
+
+  describe '#load' do
+    context 'when overwrite is false' do
+      it 'environment variables were not overwritten' do
+        ENV['foo'] = nil
+        ENV['fizz'] = 'fizz'
+
+        described_class.load(client: ssm_client, path: '/path')
+
+        expect(ENV['foo']).to eq('bar')
+        expect(ENV['fizz']).to eq('fizz')
+      end
+    end
+
+    context 'when overwrite is true' do
+      it 'environment variables were overwritten' do
+        ENV['foo'] = nil
+        ENV['fizz'] = 'fizz'
+
+        described_class.load!(client: ssm_client, path: '/path', logger: logger)
+
+        expect(ENV['foo']).to eq('bar')
+        expect(ENV['fizz']).to eq('buzz')
+      end
+    end
+  end
+
+  # @example Request syntax with placeholder values
+  #
+  #   resp = client.put_parameter({
+  #     name: "PSParameterName", # required
+  #     description: "ParameterDescription",
+  #     value: "PSParameterValue", # required
+  #     type: "String", # required, accepts String, StringList, SecureString
+  #     key_id: "ParameterKeyId",
+  #     overwrite: false,
+  #     allowed_pattern: "AllowedPattern",
+  #   })
+  #
+  describe 'Integration test', integration: true do
+    PARAMETERS = [
+      { name: "/test/#{RUBY_VERSION}/aws-ssm-env/db_password", value: 'db_password', type: :SecureString },
+      { name: "/test/#{RUBY_VERSION}/aws-ssm-env/db/username", value: 'db_username', type: :String },
+      { name: "/test/#{RUBY_VERSION}/aws-ssm-env/roles", value: 'admin,guest', type: :StringList },
+      { name: "test.#{RUBY_VERSION}.aws-ssm-env.db_password", value: 'db_password', type: :SecureString },
+      { name: "test.#{RUBY_VERSION}.aws-ssm-env.username", value: 'db_username', type: :String },
+      { name: "test.#{RUBY_VERSION}.aws-ssm-env.roles", value: 'admin,guest', type: :StringList },
+    ].freeze
+    ENV_NAMES = %w[db_password username roles].freeze
+
+    def remove_env_all
+      ENV_NAMES.each do |name|
+        ENV[name] = nil
+        ENV[name.upcase] = nil
+      end
+    end
+
+    before :all do
+      @client = Aws::SSM::Client.new
+      PARAMETERS.each do |parameter|
+        @client.put_parameter(
+          name: parameter[:name],
+          value: parameter[:value],
+          type: parameter[:type].to_s,
+          overwrite: true
+        )
+      end
+    end
+
+    before do
+      remove_env_all
+    end
+
+    after :all do
+      @client.delete_parameters(names: PARAMETERS.map { |p| p[:name] })
+    end
+
+    after do
+      remove_env_all
+    end
+
+    describe 'path fetcher' do
+      context 'when recursive is true' do
+        it 'set environment variables from EC2 Parameter Store parameters' do
+          described_class.load(path: "/test/#{RUBY_VERSION}/aws-ssm-env", recursive: true, logger: logger)
+          expect(ENV['db_password']).to eq('db_password')
+          expect(ENV['username']).to eq('db_username')
+          expect(ENV['roles']).to eq('admin,guest')
+        end
+      end
+
+      context 'when recursive is false' do
+        it 'set environment variables from EC2 Parameter Store parameters' do
+          described_class.load(path: "/test/#{RUBY_VERSION}/aws-ssm-env", recursive: false, logger: logger)
+          expect(ENV['db_password']).to eq('db_password')
+          expect(ENV['username']).to be_nil
+          expect(ENV['roles']).to eq('admin,guest')
+        end
+      end
+    end
+
+    describe 'begins_with fetcher' do
+      it 'set environment variables from EC2 Parameter Store parameters' do
+        described_class.load(begins_with: "test.#{RUBY_VERSION}.aws-ssm-env.", naming: :snakecase, delimiter: '.', logger: logger)
+        expect(ENV['DB_PASSWORD']).to eq('db_password')
+        expect(ENV['USERNAME']).to eq('db_username')
+        expect(ENV['ROLES']).to eq('admin,guest')
+      end
+    end
+  end
+end