global 0.2.2 → 2.1.0

data/spec/files/aws.test.yml

@@ -0,0 +1,3 @@
+---
+:api_key: 'some api key'
+:api_secret: 'some secret'

data/spec/files/aws.yml

@@ -0,0 +1,6 @@
+:default:
+  activated: false
+
+test:
+  activated: true
+  api_key: 'nothing'

data/spec/global/backend/aws_parameter_store_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'aws-sdk-ssm'
+require 'global/backend/aws_parameter_store'
+
+RSpec.describe Global::Backend::AwsParameterStore do
+  let(:client) do
+    Aws::SSM::Client.new(stub_responses: true)
+  end
+  subject do
+    described_class.new(prefix: '/testapp/', client: client)
+  end
+
+  it 'reads parameters from the parameter store' do
+    client.stub_responses(
+      :get_parameters_by_path,
+      [
+        lambda { |req_context|
+          expect(req_context.params[:next_token]).to be_nil
+          {
+            parameters: [
+              { name: '/testapp/foo', value: 'foo-value' },
+              { name: '/testapp/bar/baz', value: 'baz-value' }
+            ],
+            next_token: 'next-token'
+          }
+        },
+        lambda { |req_context|
+          expect(req_context.params[:next_token]).to eq('next-token')
+          {
+            parameters: [
+              { name: '/testapp/bar/qux', value: 'qux-value' }
+            ],
+            next_token: nil
+          }
+        }
+      ]
+    )
+    expect(subject.load).to eq(
+      foo: 'foo-value',
+      bar: {
+        baz: 'baz-value',
+        qux: 'qux-value'
+      }
+    )
+  end
+end

data/spec/global/backend/gcp_secret_manager_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'google/cloud/secret_manager'
+require 'global/backend/gcp_secret_manager'
+
+RSpec.describe Global::Backend::GcpSecretManager do
+  let(:client) { double }
+
+  subject do
+    described_class.new(prefix: 'prod-myapp-', client: client, project_id: 'example')
+  end
+
+  before do
+    @match_item = double
+    allow(@match_item).to receive(:name).and_return('prod-myapp-example-test_key')
+
+    @secret_data = double
+    allow(@secret_data).to receive_message_chain(:payload, :data).and_return('secret value')
+
+    @not_match_item = double
+    allow(@not_match_item).to receive(:name).and_return('different_key')
+
+    @list = double
+    allow(@list).to receive(:next_page_token).and_return('')
+    allow(@list).to receive(:each).and_yield(@match_item).and_yield(@not_match_item)
+
+    allow(client).to receive(:project_path).and_return('projects/example')
+    allow(client).to receive(:secret_version_path)
+      .with(project: 'example', secret: 'prod-myapp-example-test_key', secret_version: 'latest')
+      .and_return('some_key_path')
+    allow(client).to receive(:access_secret_version).with(name: 'some_key_path').and_return(@secret_data)
+    allow(client).to receive(:list_secrets).and_return(@list)
+  end
+
+  it 'reads parameters from the secret manager' do
+    expect(subject.load).to eq({ example: { test_key: 'secret value' }})
+  end
+end

data/spec/global/configuration_spec.rb

@@ -1,149 +1,163 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe Global::Configuration do
-  let(:hash){ { "key" => "value", "nested" => { "key" => "value" } } }
-  let(:configuration){ described_class.new hash }
+  let(:hash) { { 'key' => 'value', 'boolean_key' => true, 'nested' => { 'key' => 'value' }} }
+  let(:configuration) { described_class.new hash }
 
-  describe "#hash" do
-    subject{ configuration.hash }
+  describe '#hash' do
+    subject { configuration.hash }
 
-    it{ is_expected.to eq(hash) }
+    it { is_expected.to eq(hash) }
   end
 
-  describe "#to_hash" do
-    subject{ configuration.to_hash }
+  describe '#to_hash' do
+    subject { configuration.to_hash }
 
-    it{ is_expected.to eq(hash) }
+    it { is_expected.to eq(hash) }
   end
 
-  describe "key?" do
-    subject{ configuration.key?(:key) }
+  describe 'key?' do
+    subject { configuration.key?(:key) }
 
-    it{ is_expected.to be_truthy }
+    it { is_expected.to be_truthy }
   end
 
-  describe "has_key?" do
-    subject{ configuration.has_key?(:key) }
+  describe 'has_key?' do
+    subject { configuration.key?(:key) }
 
-    it{ is_expected.to be_truthy }
+    it { is_expected.to be_truthy }
   end
 
-  describe "include?" do
-    subject{ configuration.include?(:key) }
+  describe 'include?' do
+    subject { configuration.include?(:key) }
 
-    it{ is_expected.to be_truthy }
+    it { is_expected.to be_truthy }
   end
 
-  describe "member?" do
-    subject{ configuration.member?(:key) }
+  describe 'member?' do
+    subject { configuration.member?(:key) }
 
-    it{ is_expected.to be_truthy }
+    it { is_expected.to be_truthy }
   end
 
-  describe "#[]" do
-    subject{ configuration[:key] }
+  describe '#[]' do
+    subject { configuration[:key] }
 
-    it{ is_expected.to eq("value") }
+    it { is_expected.to eq('value') }
   end
 
-  describe "#[]=" do
-    subject{ configuration[:new_key] }
+  describe '#[]=' do
+    subject { configuration[:new_key] }
 
-    before{ configuration[:new_key] = "new_value" }
+    before { configuration[:new_key] = 'new_value' }
 
-    it{ is_expected.to eq("new_value") }
+    it { is_expected.to eq('new_value') }
   end
 
-  describe "#inspect" do
-    subject{ configuration.inspect }
+  describe '#inspect' do
+    subject { configuration.inspect }
 
-    it{ is_expected.to eq(hash.inspect) }
+    it { is_expected.to eq(hash.inspect) }
   end
 
-  describe "#filter" do
-    subject{ configuration.filter(filter_options) }
+  describe '#filter' do
+    subject { configuration.filter(filter_options) }
 
-    context "when include all" do
-      let(:filter_options){ { only: :all } }
+    context 'when include all' do
+      let(:filter_options) { { only: :all } }
 
-      it{ should == {"key"=>"value", "nested"=>{"key"=>"value"}} }
+      it { should == { 'key' => 'value', 'boolean_key' => true, 'nested' => { 'key' => 'value' }} }
     end
 
-    context "when except all" do
-      let(:filter_options){ { except: :all } }
+    context 'when except all' do
+      let(:filter_options) { { except: :all } }
 
-      it{ should == {} }
+      it { should == {} }
     end
 
-    context "when except present" do
-      let(:filter_options){ { except: %w(key) } }
+    context 'when except present' do
+      let(:filter_options) { { except: %w[key] } }
 
-      it{ should == {"nested"=>{"key"=>"value"}} }
+      it { should == { 'boolean_key' => true, 'nested' => { 'key' => 'value' }} }
     end
 
-    context "when include present" do
-      let(:filter_options){ { only: %w(key) } }
+    context 'when include present' do
+      let(:filter_options) { { only: %w[key] } }
 
-      it{ should == {"key"=>"value"} }
+      it { should == { 'key' => 'value' } }
     end
 
-    context "when empty options" do
-      let(:filter_options){ {} }
+    context 'when empty options' do
+      let(:filter_options) { {} }
 
-      it{ should == {} }
+      it { should == {} }
     end
   end
 
-  describe "#method_missing" do
-    context "when key exist" do
-      subject{ configuration.key }
+  describe '#method_missing' do
+    context 'when key exists' do
+      subject { configuration.key }
+
+      it { is_expected.to eq('value') }
+    end
+
+    context 'when boolean key exists' do
+      subject { configuration.boolean_key? }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'when key does not exist' do
+      subject { configuration.some_key }
 
-      it{ is_expected.to eq("value") }
+      it { expect { subject }.to raise_error(NoMethodError) }
     end
 
-    context "when key does not exist" do
-      subject{ configuration.some_key }
+    context 'when boolean key does not exist' do
+      subject { configuration.some_boolean_key? }
 
-      it{ expect { subject }.to raise_error(NoMethodError) }
+      it { expect { subject }.to raise_error(NoMethodError) }
     end
 
-    context "with nested hash" do
-      subject{ configuration.nested.key }
+    context 'with nested hash' do
+      subject { configuration.nested.key }
 
-      it{ is_expected.to eq("value") }
+      it { is_expected.to eq('value') }
     end
   end
 
-  describe "#respond_to_missing?" do
-    context "when key exist" do
-      subject{ configuration.respond_to?(:key) }
+  describe '#respond_to_missing?' do
+    context 'when key exist' do
+      subject { configuration.respond_to?(:key) }
 
-      it{ is_expected.to eq(true) }
+      it { is_expected.to eq(true) }
     end
 
-    context "when key does not exist" do
-      subject{ configuration.respond_to?(:some_key) }
+    context 'when key does not exist' do
+      subject { configuration.respond_to?(:some_key) }
 
-      it{ is_expected.to eq(false) }
+      it { is_expected.to eq(false) }
     end
 
-    context "with nested hash" do
-      subject{ configuration.nested.respond_to?(:key) }
+    context 'with nested hash' do
+      subject { configuration.nested.respond_to?(:key) }
 
-      it{ is_expected.to eq(true) }
+      it { is_expected.to eq(true) }
     end
 
-    context "when call it by method" do
-      subject{ configuration.method(:key).call }
+    context 'when call it by method' do
+      subject { configuration.method(:key).call }
 
-      it{ is_expected.to eq("value") }
+      it { is_expected.to eq('value') }
     end
 
-    context "when call it by method, which not exist" do
+    context 'when call it by method, which not exist' do
       it 'raise error' do
-        expect{ configuration.method(:some_key) }.to raise_error(NameError)
+        expect { configuration.method(:some_key) }.to raise_error(NameError)
       end
     end
   end
 
-end
+end

data/spec/global_spec.rb

@@ -1,132 +1,115 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe Global do
 
+  let(:config_path) { File.join(Dir.pwd, 'spec/files') }
   before(:each) do
     described_class.configure do |config|
-      config.environment = "test"
-      config.config_directory = File.join(Dir.pwd, "spec/files")
-    end
-  end
-
-  describe ".environment" do
-    subject{ described_class.environment }
-
-    it{ is_expected.to eq("test") }
-
-    context "when undefined" do
-      before{ described_class.environment = nil }
-
-      it{ expect{ subject }.to raise_error("environment should be defined") }
-    end
-  end
-
-  describe ".config_directory" do
-    subject{ described_class.config_directory }
-
-    it{ is_expected.to eq(File.join(Dir.pwd, "spec/files"))}
-
-    context "when undefined" do
-      before{ described_class.config_directory = nil }
-
-      it{ expect{ subject }.to raise_error("config_directory should be defined") }
+      config.backend :filesystem, path: config_path, environment: 'test'
     end
   end
 
-  describe ".configuration" do
-    subject{ described_class.configuration }
+  describe '.configuration' do
+    subject { described_class.configuration }
 
-    it{ is_expected.to be_instance_of(Global::Configuration) }
+    it { is_expected.to be_instance_of(Global::Configuration) }
 
-    context "when load from directory" do
+    context 'when load from directory' do
       describe '#rspec_config' do
         subject { super().rspec_config }
         describe '#to_hash' do
           subject { super().to_hash }
-          it { is_expected.to eq({"default_value"=>"default value", "test_value"=>"test value"}) }
+          it { is_expected.to eq('default_value' => 'default value', 'test_value' => 'test value') }
         end
       end
     end
 
-    context "when load from file" do
-      before{ described_class.config_directory = File.join(Dir.pwd, "spec/files/rspec_config") }
+    context 'when load from file' do
+      let(:config_path) { File.join(Dir.pwd, 'spec/files/rspec_config') }
 
       describe '#rspec_config' do
-        subject { super().rspec_config }
         describe '#to_hash' do
           subject { super().to_hash }
-          it { is_expected.to eq({"default_value"=>"default value", "test_value"=>"test value"}) }
+          it { is_expected.to eq('default_value' => 'default value', 'test_value' => 'test value') }
         end
       end
     end
 
-    context "when nested directories" do
-      it{ expect(subject.rspec["config"].to_hash).to eq({"default_value"=>"default nested value", "test_value"=>"test nested value"}) }
+    context 'when nested directories' do
+      it { expect(subject.rspec['config'].to_hash).to eq('default_value' => 'default nested value', 'test_value' => 'test nested value') }
     end
 
-    context "when boolean" do
-      it{ expect(subject.bool_config.works).to eq(true) }
-      it{ expect(subject.bool_config.works?).to eq(true) }
+    context 'when boolean' do
+      it { expect(subject.bool_config.works).to eq(true) }
+      it { expect(subject.bool_config.works?).to eq(true) }
+    end
+
+    context 'environment file' do
+      it { expect(subject.aws.activated).to eq(true) }
+      it { expect(subject.aws.api_key).to eq('some api key') }
+      it { expect(subject.aws.api_secret).to eq('some secret') }
+    end
+
+    context 'skip files with dots in name' do
+      it { expect(subject['aws.test']).to eq(nil) }
+      it { expect { subject.fetch('aws.test') }.to raise_error(KeyError, /key not found/) }
     end
   end
 
-  context ".reload!" do
-    subject{ described_class.reload! }
+  context '.reload!' do
+    subject { described_class.reload! }
 
     before do
       described_class.configuration
-      described_class.environment = "development"
-    end
-
-    after do
-      described_class.environment = "test"
-      described_class.reload!
+      described_class.instance_variable_set('@backends', [])
+      described_class.backend :filesystem, path: config_path, environment: 'development'
     end
 
-    it{ is_expected.to be_instance_of(Global::Configuration) }
+    it { is_expected.to be_instance_of(Global::Configuration) }
 
     describe '#rspec_config' do
       subject { super().rspec_config }
       describe '#to_hash' do
         subject { super().to_hash }
-        it { is_expected.to eq({"default_value"=>"default value", "test_value"=>"development value"}) }
+        it { is_expected.to eq('default_value' => 'default value', 'test_value' => 'development value') }
       end
     end
   end
-  
-  describe ".respond_to_missing?" do
-    context "when file exists" do
-      subject{ described_class.respond_to?(:rspec_config) }
 
-      it{ is_expected.to be_truthy }
+  describe '.respond_to_missing?' do
+    context 'when file exists' do
+      subject { described_class.respond_to?(:rspec_config) }
+
+      it { is_expected.to be_truthy }
     end
 
-    context "when file does not exist" do
-      subject{ described_class.respond_to?(:some_file) }
+    context 'when file does not exist' do
+      subject { described_class.respond_to?(:some_file) }
 
-      it{ is_expected.to be_falsey }
+      it { is_expected.to be_falsey }
     end
   end
 
-  describe ".method_missing" do
-    context "when file exists" do
-      subject{ described_class.rspec_config }
+  describe '.method_missing' do
+    context 'when file exists' do
+      subject { described_class.rspec_config }
 
-      it{ is_expected.to  be_kind_of(Global::Configuration) }
+      it { is_expected.to be_kind_of(Global::Configuration) }
     end
 
-    context "when file does not exist" do
-      subject{ described_class.some_file }
+    context 'when file does not exist' do
+      subject { described_class.some_file }
 
-      it{ expect{ subject }.to raise_error(NoMethodError) }
+      it { expect { subject }.to raise_error(NoMethodError) }
     end
 
-    context "when file with nested hash" do
-      subject{ described_class.nested_config }
+    context 'when file with nested hash' do
+      subject { described_class.nested_config }
 
-      it{ is_expected.to be_kind_of(Global::Configuration) }
+      it { is_expected.to be_kind_of(Global::Configuration) }
     end
 
   end
-
 end

data/spec/merge_backends_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Global do
+  describe 'merging backends' do
+    it 'merges data from two backends together' do
+      backend_alpha = double('backend_alpha')
+      allow(backend_alpha).to receive(:load).and_return(foo: 'foo', bar: 'bar-alpha')
+      described_class.backend backend_alpha
+
+      backend_beta = double('backend_beta')
+      allow(backend_beta).to receive(:load).and_return('bar' => 'bar-beta', 'baz' => 'baz')
+      described_class.backend backend_beta
+
+      expect(described_class.configuration.to_hash).to eq(
+        'foo' => 'foo',
+        'bar' => 'bar-beta',
+        'baz' => 'baz'
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$:.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
 require 'global'
 require 'simplecov'
-require 'support/javascript_helper'
 
 SimpleCov.start do
   add_filter '/spec/'
@@ -39,5 +38,9 @@ RSpec.configure do |config|
   config.filter_run :focus
 
   config.order = 'random'
-  config.include JavascriptHelper
-end
+
+  config.before do
+    Global.remove_instance_variable(:@backends) if Global.instance_variable_defined?(:@backends)
+    Global.remove_instance_variable(:@configuration) if Global.instance_variable_defined?(:@configuration)
+  end
+end