a9n 0.6.2 → 0.7.0

data/spec/unit/loader_spec.rb

@@ -1,89 +1,89 @@
 RSpec.describe A9n::Loader do
-  let(:scope) { A9n::Scope.new("configuration") }
-  let(:env) { "test" }
-  let(:root) { File.expand_path("../../../test_app", __FILE__) }
-  let(:file_path) { File.join(root, "config/configuration.yml") }
+  let(:scope) { A9n::Scope.new('configuration') }
+  let(:env) { 'test' }
+  let(:root) { File.expand_path('../../test_app', __dir__) }
+  let(:file_path) { File.join(root, 'config/configuration.yml') }
   subject { described_class.new(file_path, scope, env) }
 
-  describe "#intialize" do
+  describe '#intialize' do
     it { expect(subject.scope).to eq(scope) }
     it { expect(subject.env).to eq(env) }
     it { expect(subject.local_file).to eq(file_path) }
     it { expect(subject.example_file).to eq("#{file_path}.example") }
   end
 
-  describe "#load" do
+  describe '#load' do
     let(:example_config) do
-      { app_url: "http://127.0.0.1:3000", api_key: "example1234" }
+      { app_url: 'http://127.0.0.1:3000', api_key: 'example1234' }
     end
 
     let(:local_config) do
-      { app_host: "127.0.0.1:3000", api_key: "local1234" }
+      { app_host: '127.0.0.1:3000', api_key: 'local1234' }
     end
 
-    let(:env) { "tropical" }
+    let(:env) { 'tropical' }
     let(:config) { subject.get }
 
-    context "when no configuration file exists" do
+    context 'when no configuration file exists' do
       before do
         expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(nil)
         expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(nil)
       end
 
-      it "raises expection"  do
+      it 'raises expection' do
         expect {
           subject.load
         }.to raise_error(A9n::MissingConfigurationDataError)
       end
     end
 
-    context "when only example configuration file exists" do
+    context 'when only example configuration file exists' do
       before do
         expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(example_config)
         expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(nil)
         subject.load
       end
 
-      it { expect(config.app_url).to eq("http://127.0.0.1:3000") }
-      it { expect(config.api_key).to eq("example1234") }
+      it { expect(config.app_url).to eq('http://127.0.0.1:3000') }
+      it { expect(config.api_key).to eq('example1234') }
 
       it do
         expect { config.app_host }.to raise_error(A9n::NoSuchConfigurationVariableError)
       end
     end
 
-    context "when only local configuration file exists" do
+    context 'when only local configuration file exists' do
       before do
         expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(nil)
         expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(local_config)
         subject.load
       end
 
-      it { expect(config.app_host).to eq("127.0.0.1:3000") }
-      it { expect(config.api_key).to eq("local1234") }
+      it { expect(config.app_host).to eq('127.0.0.1:3000') }
+      it { expect(config.api_key).to eq('local1234') }
 
       it do
         expect { config.app_url }.to raise_error(A9n::NoSuchConfigurationVariableError)
       end
     end
 
-    context "when both local and base configuration file exists without defaults" do
-      context "with same data" do
+    context 'when both local and base configuration file exists without defaults' do
+      context 'with same data' do
         before do
           expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(example_config)
           expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(example_config)
           subject.load
         end
 
-        it { expect(config.app_url).to eq("http://127.0.0.1:3000") }
-        it { expect(config.api_key).to eq("example1234") }
+        it { expect(config.app_url).to eq('http://127.0.0.1:3000') }
+        it { expect(config.api_key).to eq('example1234') }
 
         it do
           expect { config.app_host }.to raise_error(A9n::NoSuchConfigurationVariableError)
         end
       end
 
-      context "with different data" do
+      context 'with different data' do
         before do
           expect(described_class).to receive(:load_yml).with(subject.example_file, scope, env).and_return(example_config)
           expect(described_class).to receive(:load_yml).with(subject.local_file, scope, env).and_return(local_config)
@@ -91,106 +91,106 @@ RSpec.describe A9n::Loader do
 
         let(:missing_variables_names) { example_config.keys - local_config.keys }
 
-        it "raises expection with missing variables names"  do
+        it 'raises expection with missing variables names'  do
           expect {
             subject.load
-          }.to raise_error(A9n::MissingConfigurationVariablesError, /#{missing_variables_names.join(", ")}/)
+          }.to raise_error(A9n::MissingConfigurationVariablesError, /#{missing_variables_names.join(', ')}/)
         end
       end
     end
   end
 
-  describe ".load_yml" do
-    let(:env) { "test" }
-    subject {  described_class.load_yml(file_path, scope, env) }
+  describe '.load_yml' do
+    let(:env) { 'test' }
+    subject { described_class.load_yml(file_path, scope, env) }
 
-    context "when file not exists" do
-      let(:file_path) { "file_not_existing_in_the_universe.yml" }
+    context 'when file not exists' do
+      let(:file_path) { 'file_not_existing_in_the_universe.yml' }
 
-      it{ expect(subject).to be_nil }
+      it { expect(subject).to be_nil }
     end
 
-    context "when file exists" do
-      shared_examples "non-empty config file" do
-        it "returns non-empty hash" do
+    context 'when file exists' do
+      shared_examples 'non-empty config file' do
+        it 'returns non-empty hash' do
           expect(subject).to be_kind_of(Hash)
           expect(subject.keys).to_not be_empty
         end
       end
 
       before do
-        ENV["ERB_DWARF"] = "erbized dwarf"
-        ENV["DWARF_PASSWORD"] = "dwarf123"
+        ENV['ERB_DWARF'] = 'erbized dwarf'
+        ENV['DWARF_PASSWORD'] = 'dwarf123'
       end
 
       after do
-        ENV.delete("ERB_DWARF")
-        ENV.delete("DWARF_PASSWORD")
+        ENV.delete('ERB_DWARF')
+        ENV.delete('DWARF_PASSWORD')
       end
 
-      context "when file has erb extension" do
-        let(:file_path) { File.join(root, "config/a9n/cloud.yml.erb") }
+      context 'when file has erb extension' do
+        let(:file_path) { File.join(root, 'config/a9n/cloud.yml.erb') }
 
-        it_behaves_like "non-empty config file"
+        it_behaves_like 'non-empty config file'
       end
 
-      context "having env and defaults data" do
-        let(:file_path) { File.join(root, "config/configuration.yml") }
+      context 'having env and defaults data' do
+        let(:file_path) { File.join(root, 'config/configuration.yml') }
 
-        it_behaves_like "non-empty config file"
+        it_behaves_like 'non-empty config file'
 
-        it "contains keys from defaults scope" do
-          expect(subject[:default_dwarf]).to eq("default dwarf")
-          expect(subject[:overriden_dwarf]).to eq("already overriden dwarf")
+        it 'contains keys from defaults scope' do
+          expect(subject[:default_dwarf]).to eq('default dwarf')
+          expect(subject[:overriden_dwarf]).to eq('already overriden dwarf')
         end
 
-        it "has symbolized keys" do
+        it 'has symbolized keys' do
           expect(subject.keys.first).to be_kind_of(Symbol)
           expect(subject[:hash_dwarf]).to be_kind_of(Hash)
           expect(subject[:hash_dwarf].keys.first).to be_kind_of(Symbol)
         end
 
-        it "parses erb" do
-          expect(subject[:erb_dwarf]).to eq("erbized dwarf")
+        it 'parses erb' do
+          expect(subject[:erb_dwarf]).to eq('erbized dwarf')
         end
 
-        it "gets valus from ENV" do
-          expect(subject[:dwarf_password]).to eq("dwarf123")
+        it 'gets valus from ENV' do
+          expect(subject[:dwarf_password]).to eq('dwarf123')
         end
 
-        it "raises exception when ENV var is not set" do
-          ENV.delete("DWARF_PASSWORD")
-          expect{ subject[:dwarf_password] }.to raise_error(A9n::MissingEnvVariableError)
+        it 'raises exception when ENV var is not set' do
+          ENV.delete('DWARF_PASSWORD')
+          expect { subject[:dwarf_password] }.to raise_error(A9n::MissingEnvVariableError)
         end
 
-        it "raises exception when ENV var is set to nil" do
-          ENV["DWARF_PASSWORD"] = nil
-          expect{ subject[:dwarf_password] }.to raise_error(A9n::MissingEnvVariableError)
+        it 'raises exception when ENV var is set to nil' do
+          ENV['DWARF_PASSWORD'] = nil
+          expect { subject[:dwarf_password] }.to raise_error(A9n::MissingEnvVariableError)
         end
       end
 
-      context "having no env and only defaults data" do
-        let(:file_path) { File.join(root, "config/configuration.yml") }
-        let(:env) { "production" }
+      context 'having no env and only defaults data' do
+        let(:file_path) { File.join(root, 'config/configuration.yml') }
+        let(:env) { 'production' }
 
-        it_behaves_like "non-empty config file"
+        it_behaves_like 'non-empty config file'
 
-        it "contains keys from defaults scope" do
-          expect(subject[:default_dwarf]).to eq("default dwarf")
-          expect(subject[:overriden_dwarf]).to eq("not yet overriden dwarf")
+        it 'contains keys from defaults scope' do
+          expect(subject[:default_dwarf]).to eq('default dwarf')
+          expect(subject[:overriden_dwarf]).to eq('not yet overriden dwarf')
         end
       end
 
-      context "having only env and no default data" do
-        let(:file_path) { File.join(root, "config/no_defaults.yml") }
+      context 'having only env and no default data' do
+        let(:file_path) { File.join(root, 'config/no_defaults.yml') }
 
-        context "valid env" do
-          let(:env) { "production" }
-          it_behaves_like "non-empty config file"
+        context 'valid env' do
+          let(:env) { 'production' }
+          it_behaves_like 'non-empty config file'
         end
 
-        context "invalid env" do
-          let(:env) { "tropical" }
+        context 'invalid env' do
+          let(:env) { 'tropical' }
           it { expect(subject).to be_nil }
         end
       end

data/spec/unit/scope_spec.rb

@@ -1,25 +1,25 @@
 RSpec.describe A9n::Scope do
   subject { described_class.new(name) }
 
-  describe "#name" do
-    let(:name) { "configuration" }
+  describe '#name' do
+    let(:name) { 'configuration' }
     it { expect(subject.name).to eq(:configuration) }
   end
 
-  describe "#main?" do
-    context "when name is configuration" do
-      let(:name) { "configuration" }
+  describe '#main?' do
+    context 'when name is configuration' do
+      let(:name) { 'configuration' }
       it { expect(subject).to be_root }
     end
 
-    context "when name is other than configuration" do
-      let(:name) { "mandrill" }
+    context 'when name is other than configuration' do
+      let(:name) { 'mandrill' }
       it { expect(subject).not_to be_root }
     end
   end
 
-  describe ".form_file_path" do
-    let(:path) { "config/a9n/mandrill.yml.example" }
+  describe '.form_file_path' do
+    let(:path) { 'config/a9n/mandrill.yml.example' }
     subject { described_class.form_file_path(path) }
 
     it { expect(subject.name).to eq(:mandrill) }

data/spec/unit/struct_spec.rb

@@ -1,151 +1,164 @@
 RSpec.describe A9n::Struct do
-  context "without any values" do
+  context 'without any values' do
     subject { described_class.new }
 
-    describe "#empty?" do
+    describe '#empty?' do
       it { expect(subject).to be_empty }
     end
 
-    describe "#keys" do
+    describe '#keys' do
       it { expect(subject.keys).to eq([]) }
     end
 
-    describe "#key?" do
+    describe '#key?' do
       it { expect(subject.key?(:dwarf)).to eq(false) }
     end
 
-    describe "#[]" do
+    describe '#[]' do
       it { expect(subject[:dwarf]).to eq(nil) }
     end
 
-    describe "#fetch" do
+    describe '#fetch' do
       it do
-        expect {
-          subject.fetch(:dwarf)
-        }.to raise_error(KeyError)
+        expect { subject.fetch(:dwarf) }.to raise_error(KeyError)
       end
 
       it do
-        expect(subject.fetch(:dwarf, "hello")).to eq("hello")
+        expect(subject.fetch(:dwarf, 'hello')).to eq('hello')
       end
     end
 
-    it "raises error on accessin invalid attribute" do
+    it 'raises error on accessin invalid attribute' do
       expect {
         subject.dwarf
-      }.to raise_error(A9n::NoSuchConfigurationVariableError, "dwarf")
+      }.to raise_error(A9n::NoSuchConfigurationVariableError, 'dwarf')
     end
   end
 
-  context "with values" do
-    subject {
-      described_class.new({
-          non_empty_dwarf: "dwarf",
-          nil_dwarf:   nil,
-          false_dwarf: false,
-          true_dwarf:  true,
-          hash_dwarf:  { dwarf: "hello" }
-        })
-    }
-
-    describe "#keys" do
+  context 'with values' do
+    let(:data) do
+      {
+        non_empty_dwarf: 'dwarf',
+        nil_dwarf: nil,
+        false_dwarf: false,
+        true_dwarf: true,
+        hash_dwarf: { dwarf: 'hello' }
+      }
+    end
+
+    subject { described_class.new(data) }
+
+    describe '#keys' do
       it do
         expect(subject.keys).to eq [:non_empty_dwarf, :nil_dwarf, :false_dwarf, :true_dwarf, :hash_dwarf]
       end
     end
 
-    describe "#key?" do
+    describe '#to_h' do
+      it do
+        expect(subject.to_h).to be_kind_of(Hash)
+        expect(subject.to_h).to eq(data)
+      end
+    end
+
+    describe '#to_hash' do
+      it do
+        expect(subject.to_hash).to be_kind_of(Hash)
+        expect(subject.to_hash).to eq(data)
+      end
+    end
+
+    describe '#key?' do
       it { expect(subject.key?(:nil_dwarf)).to eq(true) }
       it { expect(subject.key?(:unknown)).to eq(false) }
     end
 
-    describe "#merge" do
+    describe '#merge' do
       before { subject.merge(argument) }
 
-      context "hash" do
-        let(:argument) { { non_empty_dwarf: "hello dwarf" } }
+      context 'hash' do
+        let(:argument) { { non_empty_dwarf: 'hello dwarf' } }
 
         it do
-          expect(subject.non_empty_dwarf).to eq("hello dwarf")
+          expect(subject.non_empty_dwarf).to eq('hello dwarf')
         end
       end
 
-      context "struct" do
-        let(:argument) { described_class.new(non_empty_dwarf: "hello dwarf") }
+      context 'struct' do
+        let(:argument) { described_class.new(non_empty_dwarf: 'hello dwarf') }
 
         it do
-          expect(subject.non_empty_dwarf).to eq("hello dwarf")
+          expect(subject.non_empty_dwarf).to eq('hello dwarf')
         end
       end
     end
 
-    it "is not empty" do
+    it 'is not empty' do
       expect(subject).not_to be_empty
     end
 
-    it "gets non-empty value" do
-      expect(subject.non_empty_dwarf).to eq("dwarf")
+    it 'gets non-empty value' do
+      expect(subject.non_empty_dwarf).to eq('dwarf')
     end
 
-    it "gets nil value" do
+    it 'gets nil value' do
       expect(subject.nil_dwarf).to eq(nil)
     end
 
-    it "gets true value" do
+    it 'gets true value' do
       expect(subject.true_dwarf).to eq(true)
     end
 
-    it "gets false value" do
+    it 'gets false value' do
       expect(subject.false_dwarf).to eq(false)
     end
 
-    it "gets hash value" do
+    it 'gets hash value' do
       expect(subject.hash_dwarf).to be_kind_of(Hash)
     end
 
-    it "raises exception when value not exists" do
+    it 'raises exception when value not exists' do
       expect {
         subject.non_existing_dwarf
       }.to raise_error(A9n::NoSuchConfigurationVariableError)
     end
 
-    describe "#[]" do
-      it "returns non empty value" do
-        expect(subject[:non_empty_dwarf]).to eq("dwarf")
+    describe '#[]' do
+      it 'returns non empty value' do
+        expect(subject[:non_empty_dwarf]).to eq('dwarf')
       end
 
-      it "returns false value" do
+      it 'returns false value' do
         expect(subject[:false_dwarf]).to eq(false)
       end
 
-      it "returns nil value" do
+      it 'returns nil value' do
         expect(subject[:nil_dwarf]).to eq(nil)
       end
 
-      it "returns nil for non existing key" do
+      it 'returns nil for non existing key' do
         expect(subject[:non_existing_dwarf]).to eq(nil)
       end
     end
 
-
-    describe "#fetch" do
-      it "returns non empty value" do
-        expect(subject.fetch(:non_empty_dwarf)).to eq("dwarf")
+    describe '#fetch' do
+      it 'returns non empty value' do
+        expect(subject.fetch(:non_empty_dwarf)).to eq('dwarf')
       end
 
-      it "returns false value" do
+      it 'returns false value' do
         expect(subject.fetch(:false_dwarf)).to eq(false)
       end
 
-      it "returns nil value" do
+      it 'returns nil value' do
         expect(subject.fetch(:nil_dwarf)).to eq(nil)
       end
 
-      it "returns default for non existing value" do
-        expect(subject.fetch(:non_existing_dwarf, "hello")).to eq("hello")
+      it 'returns default for non existing value' do
+        expect(subject.fetch(:non_existing_dwarf, 'hello')).to eq('hello')
       end
 
-      it "raises error for non existing key" do
+      it 'raises error for non existing key' do
         expect {
           subject.fetch(:non_existing_dwarf)
         }.to raise_error(KeyError)