aws-ssm-env 0.1.0 → 0.1.1

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

@@ -1,3 +1,3 @@
 module AwsSsmEnv
-  VERSION = '0.1.0'.freeze
+  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

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