is2-aws-ssm-env 0.1.1

data/lib/aws-ssm-env/naming_strategies/snakecase.rb

@@ -0,0 +1,58 @@
+require 'aws-ssm-env/naming_strategy'
+
+module AwsSsmEnv
+  # パラメータ名の階層表現をスネークケースに変換した値を環境変数名とする。
+  # 例えば、`removed_prefix`が`/path`で`/path/to/environment_name`というパラメータ名なら
+  # ENV['TO_ENVIRONMENT_NAME']にパラメータ値がインジェクションされる。
+  #
+  # @author Ryohei Sonoda
+  # @since 0.1.0
+  class SnakeCaseNamingStrategy < NamingStrategy
+    # ここの引数は AwsSsmEnv#load の呼び出し時に渡された引数がそのまま渡される。
+    #
+    # @param [Hash] args AwsSsmEnv#load の呼び出し時に渡された引数。
+    # @option args [String] :removed_prefix
+    #   パラメータ名から除去するプレフィクス。この文字列は導出される環境変数名に含まない。
+    #   :removed_prefixが指定されておらず、:begins_with または :path が指定されていた場合はそれを利用する。 TODO: AwsSsmEnv#loadとREADMEに反映
+    # @option args [String, Regexp] :delimiter
+    #   アンダースコアに変換する区切り文字。デフォルトはスラッシュ('/')。 TODO: AwsSsmEnv#loadとREADMEに反映
+    def initialize(**args)
+      @logger = args[:logger]
+      @delimiter = detect_delimiter(args)
+      removed_prefix = detect_prefix(args).sub(%r{/\z}, '')
+      @removed_prefix = /\A#{Regexp.escape(removed_prefix)}/
+      @logger.debug("#{self.class.name} removed_prefix is #{@removed_prefix}") if @logger
+    end
+
+    # @see AwsSsmEnv::NamingStrategy#parse_name
+    #
+    # パラメータ名からプレフィクスを除去してパス区切りをアンダースコアに変換後、大文字にして返す。
+    # @return [String] 環境変数名
+    def parse_name(parameter)
+      name_without_prefix = parameter.name.gsub(@removed_prefix, '')
+      name_without_prefix.gsub(@delimiter, '_').upcase
+    end
+
+    private
+
+    def detect_delimiter(**args)
+      if args[:delimiter].nil?
+        '/'
+      else
+        args[:delimiter]
+      end
+    end
+
+    def detect_prefix(**args)
+      if args[:removed_prefix]
+        args[:removed_prefix]
+      elsif args[:begins_with]
+        args[:begins_with]
+      elsif args[:path]
+        args[:path]
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/aws-ssm-env/naming_strategy.rb

@@ -0,0 +1,23 @@
+module AwsSsmEnv
+  # パラメータの値を設定する環境変数名を決定するためのStrategyクラス。
+  # 実装クラスを AwsSsmEnv#load の引数で`naming`パラメータとして渡すことにより
+  # インジェクションされる環境変数名の命名ルールを切り替えられるようにする。
+  #
+  # @abstract
+  # @author Ryohei Sonoda
+  # @since 0.1.0
+  class NamingStrategy
+    # ここの引数は AwsSsmEnv#load の呼び出し時に渡された引数がそのまま渡される。
+    # サブクラスでは必要に応じて使う引数をインスタンス変数に保持しておく。
+    #
+    # @param [Hash] ** AwsSsmEnv#load の呼び出し時に渡された引数。
+    def initialize(**); end
+
+    # パラメータから環境変数名を導出するメソッド。
+    # @abstract
+    # @return [String] 環境変数名
+    def parse_name(_parameter)
+      raise NotImplementedError, 'parse_name'
+    end
+  end
+end

data/lib/aws-ssm-env/version.rb

@@ -0,0 +1,3 @@
+module AwsSsmEnv
+  VERSION = '0.1.1'.freeze
+end

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

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe AwsSsmEnv::Fetcher do
+  let(:fetcher) { described_class.new(args) }
+  let(:args) { {} }
+  let(:client) { fetcher.send(:client) }
+  let(:ssm_client_args) {
+    {
+      access_key_id: 'access_key_id',
+      secret_access_key: 'secret_access_key'
+    }
+  }
+
+  describe '#initialize' do
+    context 'when decryption was not set' do
+      it 'with_decryption is true' do
+        expect(fetcher.send(:with_decryption)).to be_truthy
+      end
+    end
+
+    context 'when decryption is nil' do
+      let(:args) { { decryption: nil } }
+
+      it 'with_decryption is true' do
+        expect(fetcher.send(:with_decryption)).to be_truthy
+      end
+    end
+
+    context 'when decryption is truthy string' do
+      let(:args) { { decryption: 'TrUe' } }
+
+      it 'with_decryption is true' do
+        expect(fetcher.send(:with_decryption)).to be_truthy
+      end
+    end
+
+    context 'when decryption is not truthy string' do
+      let(:args) { { decryption: 'foo' } }
+
+      it 'with_decryption is false' do
+        expect(fetcher.send(:with_decryption)).to be_falsey
+      end
+    end
+
+    context 'when client was not set' do
+      context 'when ssm_client_args was set' do
+        let(:args) { { ssm_client_args: ssm_client_args } }
+
+        it 'client is initialized by ssm_client_args' do
+          expect(client.config[:access_key_id]).to eq('access_key_id')
+          expect(client.config[:secret_access_key]).to eq('secret_access_key')
+        end
+      end
+
+      context 'when ssm_client_args was not set' do
+        it 'client is default construction' do
+          expect(client.config[:access_key_id]).to be_nil
+        end
+      end
+    end
+
+    context 'when client was set' do
+      context 'when client is instance of Aws::SSM::Client' do
+        let(:ssm_client) { Aws::SSM::Client.new }
+        let(:args) { { client: ssm_client } }
+
+        it 'client is equals to args[:client]' do
+          expect(client).to eq(ssm_client)
+        end
+      end
+
+      context 'when client is not instance of Aws::SSM::Client' do
+        let(:ssm_client) { 'foo' }
+        let(:args) { { client: ssm_client, ssm_client_args: ssm_client_args } }
+
+        it 'client is not equals to args[:client] and client is initialized by ssm_client_args' do
+          expect(client).not_to eq(ssm_client)
+          expect(client.config[:access_key_id]).to eq('access_key_id')
+          expect(client.config[:secret_access_key]).to eq('secret_access_key')
+        end
+      end
+    end
+  end
+
+  describe '#each' do
+    let(:parameters) { [ Parameter.new('foo', 'foo'), Parameter.new('bar', 'bar') ] }
+    let(:fetcher) {
+      mock_class = Class.new(described_class) do
+        def initialize(response); @response = response; end
+        protected def fetch(_); @response; end
+      end
+      mock_class.new(dummy_response)
+    }
+
+    context 'when fetch returns empty parameters at first' do
+      let(:dummy_response) { AwsSsmEnv::FetchResult::EMPTY }
+
+      it 'consumer is not called' do
+        called = false
+        fetcher.each do |_|
+          called = true
+        end
+        expect(called).to be_falsey
+      end
+    end
+
+    context 'when fetch returns two parameters at first and empty next_token' do
+      let(:dummy_response) { AwsSsmEnv::FetchResult.new(parameters, nil) }
+
+      it 'consumer is called twice' do
+        called = 0
+        fetcher.each do |_|
+          called += 1
+        end
+        expect(called).to eq(2)
+      end
+    end
+
+    context 'when fetch returns two parameters and next_token at first, fetch returns two parameters and empty next_token at second' do
+      let(:fetcher) {
+        mock_class = Class.new(described_class) do
+          def initialize(parameters); @parameters = parameters; @count = 0; end
+          protected def fetch(_)
+            if @count == 0
+              @count = 1
+              AwsSsmEnv::FetchResult.new(@parameters, 'next_token')
+            else
+              AwsSsmEnv::FetchResult.new(@parameters, nil)
+            end
+          end
+        end
+        mock_class.new(parameters)
+      }
+
+      it 'consumer is called four times' do
+        called = 0
+        fetcher.each do |_|
+          called += 1
+        end
+        expect(called).to eq(4)
+      end
+    end
+  end
+
+  describe '#fetch' do
+    it 'raise error' do
+      expect { fetcher.send(:fetch, 'next_token') }.to raise_error(NotImplementedError)
+    end
+  end
+end
+
+describe AwsSsmEnv::FetchResult do
+  describe '#initialize' do
+    subject { described_class.new([], 'next_token') }
+
+    it { is_expected.to have_attributes(parameters: [], next_token: 'next_token') }
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'aws-ssm-env/fetchers/begins_with'
+
+describe AwsSsmEnv::BeginsWithFetcher do
+  let(:fetcher) { described_class.new(args) }
+  let(:args) { { begins_with: [ '/foo', '/bar' ] } }
+  let(:base_params) { fetcher.instance_variable_get(:'@base_params') }
+  let(:parameter_filter) { base_params[:parameter_filters][0] }
+
+  describe '#initialize' do
+    context 'when :begins_with was not set' do
+      it 'raise error' do
+        expect { described_class.new(begins_with: nil) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when :begins_with is Array' do
+      it 'parameter_filter[:values] is begins_with value' do
+        expect(parameter_filter[:values]).to eq(args[:begins_with])
+      end
+    end
+
+    context 'when :begins_with is not Array' do
+      let(:args) { { begins_with: '/foo' } }
+
+      it 'parameter_filter[:values] is [ begins_with value ]' do
+        expect(parameter_filter[:values]).to eq([ args[:begins_with] ])
+      end
+    end
+
+    context 'when :fetch_size was set and less than 50' do
+      let(:args) { { begins_with: '/foo', fetch_size: 49 } }
+
+      it '@base_params[:max_results] is fetch_size value' do
+        expect(base_params[:max_results]).to eq(49)
+      end
+    end
+
+    context 'when :fetch_size was not set' do
+      let(:args) { { begins_with: '/foo', fetch_size: nil } }
+
+      it '@base_params[:max_results] is 50' do
+        expect(base_params[:max_results]).to eq(50)
+      end
+    end
+
+    context 'when :fetch_size > 50' do
+      let(:args) { { begins_with: '/foo', fetch_size: 51 } }
+
+      it '@base_params[:max_results] is 50' do
+        expect(base_params[:max_results]).to eq(50)
+      end
+    end
+  end
+
+  describe '#fetch' do
+    let(:client) { fetcher.send(:client) }
+
+    context 'when describe_parameters return empty parameters' do
+      before do
+        allow_any_instance_of(Aws::SSM::Client).to \
+          receive(:describe_parameters).and_return(AwsSsmEnv::FetchResult::EMPTY)
+      end
+
+      it 'return AwsSsmEnv::FetchResult::EMPTY' do
+        expect(fetcher.send(:fetch, nil)).to eq(AwsSsmEnv::FetchResult::EMPTY)
+      end
+
+      context 'when next_token is nil' do
+        it 'called describe_parameters without next_token' do
+          expect(fetcher.send(:fetch, nil)).to eq(AwsSsmEnv::FetchResult::EMPTY)
+          expect(client).to \
+            have_received(:describe_parameters).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 eq(AwsSsmEnv::FetchResult::EMPTY)
+          expect(client).to have_received(:describe_parameters)
+            .with(base_params.merge(next_token: 'next_token')).once
+        end
+      end
+    end
+
+    context 'when describe_parameters return not empty parameters' do
+      let!(:dummy_parameters) { [ Parameter.new('foo'), Parameter.new('bar') ] }
+      let!(:dummy_response) { AwsSsmEnv::FetchResult.new(dummy_parameters, 'next_token') }
+
+      before do
+        allow_any_instance_of(Aws::SSM::Client).to \
+          receive(:describe_parameters).and_return(dummy_response)
+        allow_any_instance_of(Aws::SSM::Client).to \
+          receive(:get_parameters).and_return(dummy_response)
+      end
+
+      it 'return parameters' do
+        response = fetcher.send(:fetch, 'next_token')
+        expect(response.parameters).to eq(dummy_response.parameters)
+        expect(response.next_token).to eq(dummy_response.next_token)
+        expect(client).to have_received(:get_parameters)
+          .with(names: dummy_parameters.map(&:name), with_decryption: true).once
+      end
+    end
+  end
+end

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