envied 0.9.1 → 0.9.2.rc1

data/spec/env_var_extractor_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe ENVied::EnvVarExtractor do
+RSpec.describe ENVied::EnvVarExtractor do
 
   describe "#capture_variables" do
     def capture_variables(text)

data/spec/envied_spec.rb

@@ -1,112 +1,93 @@
-require 'spec_helper'
-
-describe ENVied do
+RSpec.describe ENVied do
   describe 'class' do
     subject { described_class }
-
     it { is_expected.to respond_to :require }
   end
 
-  describe 'responding to methods that are variables' do
-  end
-
-  before do
-    reset_env
-    reset_envied_config
-    reset_configuration
-  end
-
-  def reset_configuration
-    @config = ENVied::Configuration.new
-  end
-
-  def reset_env
-    ENVied.instance_eval { @env = nil }
-  end
-
-  def reset_envied_config
-    ENVied.instance_eval { @config = nil }
+  def reset_envied
+    ENVied.instance_eval do
+      @env = nil
+      @config = nil
+    end
   end
 
   context 'configured' do
 
-    def unconfigured
-      configured_with
-      self
+    before do
+      reset_envied
     end
 
-    def config
-      @config
+    def set_ENV(env = {})
+      stub_const("ENV", env)
     end
 
-    def configure(options = {}, &block)
+    def configure(**options, &block)
       @config = ENVied::Configuration.new(options, &block)
-      self
     end
 
-    def configured_with(hash = {})
-      @config = ENVied::Configuration.new.tap do |c|
+    def configured_with(**hash)
+      @config = ENVied::Configuration.new.tap do |config|
         hash.each do |name, type|
-          c.variable(name, *type)
+          config.variable(name, type)
         end
       end
-      self
-    end
-
-    def and_ENV(env = {})
-      stub_const("ENV", env)
-      described_class
     end
 
-    def and_no_ENV
-      and_ENV
+    def envied_require(*args, **options)
+      options[:config] = @config || ENVied::Configuration.new # Prevent `Configuration.load` from being called
+      ENVied.require(*args, **options)
     end
 
-    def envied_require(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      options[:config] = options[:config] || config
-
-      ENVied.require(*args, options)
-    end
-
-    it 'responds to configured variables' do
-      configured_with(a: :integer).and_ENV({'a' => '1'})
+    it 'does respond to configured variables' do
+      set_ENV('A' => '1')
+      configured_with(A: :integer)
       envied_require
 
-      expect(described_class).to respond_to :a
+      expect(described_class).to respond_to :A
     end
 
-    it 'responds not to unconfigured variables' do
-      unconfigured.and_ENV({'A' => '1'})
+    it 'does not respond to unconfigured variables' do
+      set_ENV('A' => '1')
+      configured_with
       envied_require
 
       expect(described_class).to_not respond_to :B
     end
 
     it 'sets ENVied.config' do
-      configured_with(a: :integer).and_ENV({'a' => '1'})
+      set_ENV('A' => '1')
+      configured_with(A: :integer)
       envied_require
 
-      expect(ENVied.config).to_not be(nil)
+      expect(ENVied.config).to be_instance_of(ENVied::Configuration)
     end
 
     context 'ENV contains not all configured variables' do
-      before { configured_with(a: :integer).and_no_ENV }
+      before do
+        set_ENV
+        configured_with(A: :integer)
+      end
 
       specify do
         expect {
           envied_require
-        }.to raise_error(RuntimeError, 'The following environment variables should be set: a.')
+        }.to raise_error(RuntimeError, 'The following environment variables should be set: A.')
       end
     end
 
     context 'ENV variables are not coercible' do
-      before { configured_with(A: :integer).and_ENV('A' => 'NaN') }
+      before do
+        set_ENV('A' => 'NaN', 'B' => 'invalid')
+        configured_with(A: :integer, B: :boolean)
+      end
 
       specify do
         expect {
           envied_require
-        }.to raise_error(/A \('NaN' can't be coerced to integer/)
+        }.to raise_error(
+          RuntimeError,
+          'The following environment variables are not coercible: A with "NaN" (integer), B with "invalid" (boolean).'
+        )
       end
     end
 
@@ -114,16 +95,17 @@ describe ENVied do
       it 'raises error when configuring variable of unknown type' do
         expect {
           configured_with(A: :fixnum)
-        }.to raise_error(ArgumentError, /Variable type \(of A\) should be one of \[/)
+        }.to raise_error(ArgumentError, ":fixnum is not a supported type. Should be one of #{ENVied::Coercer.supported_types}")
       end
     end
 
+    # TODO: review needed, doesn't make sense?
     context 'bug: default value "false" is not coercible' do
-      before {
+      before do
         configure(enable_defaults: true) do
           variable :FORCE_SSL, :boolean, default: true
         end
-      }
+      end
 
       specify do
         expect {
@@ -133,41 +115,8 @@ describe ENVied do
     end
 
     describe 'defaults' do
-      describe 'setting' do
-        subject { config }
-
-        it 'is disabled by default' do
-          expect(subject.defaults_enabled?).to_not be
-        end
-
-        it 'yields ENV["ENVIED_ENABLE_DEFAULTS"] if not set otherwise' do
-          stub_const("ENV", {'ENVIED_ENABLE_DEFAULTS' => '1'})
-          configure
-
-          expect(subject.defaults_enabled?).to be
-        end
-
-        it 'can be enabled via #configure' do
-          configure(enable_defaults: true){ }
-
-          expect(subject.defaults_enabled?).to be
-        end
-
-        it 'can be enabled via a configure-block' do
-          configure { self.enable_defaults! }
-
-          expect(subject.defaults_enabled?).to be
-        end
-
-        it 'can be assigned a Proc' do
-          configure { self.enable_defaults! { true } }
-
-          expect(subject.defaults_enabled?).to be
-        end
-      end
-
       describe 'assigning' do
-        it 'can be a value' do
+        it 'sets a default value for ENV variable' do
           configure(enable_defaults: true) do
             variable :A, :integer, default: '1'
           end
@@ -176,7 +125,7 @@ describe ENVied do
           expect(described_class.A).to eq 1
         end
 
-        it 'can be a Proc' do
+        it 'sets a default value from calling a proc for ENV variable' do
           configure(enable_defaults: true) do
             variable :A, :integer, default: proc { "1" }
           end
@@ -185,30 +134,34 @@ describe ENVied do
           expect(described_class.A).to eq 1
         end
 
-        it 'is ignored if defaults are disabled' do
+        it 'ignores setting defaults if they are disabled' do
+          set_ENV
           configure(enable_defaults: false) do
             variable :A, :integer, default: "1"
-          end.and_no_ENV
+            variable :B, :integer, default: "1"
+          end
 
           expect {
             envied_require
-          }.to raise_error(RuntimeError, 'The following environment variables should be set: A.')
+          }.to raise_error(RuntimeError, 'The following environment variables should be set: A, B.')
         end
 
-        it 'is ignored if ENV is provided' do
+        it 'ignores a default value if ENV variable is already provided' do
+          set_ENV('A' => '2')
           configure(enable_defaults: true) do
             variable :A, :integer, default: "1"
-          end.and_ENV('A' => '2')
+          end
           envied_require
 
           expect(described_class.A).to eq 2
         end
 
-        it 'can be defined in terms of other variables' do
+        it 'can set a default value via a proc that references another ENV variable' do
+          set_ENV('A' => '1')
           configure(enable_defaults: true) do
             variable :A, :integer
             variable :B, :integer, default: proc {|env| env.A * 2 }
-          end.and_ENV('A' => '1')
+          end
           envied_require
 
           expect(described_class.B).to eq 2
@@ -216,8 +169,9 @@ describe ENVied do
       end
     end
 
-    describe "::required?" do
-      it 'yields true-ish when ::require is called' do
+    describe ".required?" do
+      # TODO: change to always return boolean
+      it 'returns true-ish if `ENVied.require` was called' do
         expect {
           envied_require
         }.to change { ENVied.required? }.from(nil).to(anything)
@@ -225,154 +179,159 @@ describe ENVied do
     end
 
     describe "groups" do
-      describe 'requiring' do
-
-        it 'yields :default when nothing passed to require' do
-          envied_require
-          expect(ENVied.env.groups).to eq [:default]
-        end
-
-        it 'takes ENV["ENVIED_GROUPS"] into account when nothing passed to require' do
-          and_ENV('ENVIED_GROUPS' => 'baz')
-          envied_require
-          expect(ENVied.env.groups).to eq [:baz]
-        end
-
-        it 'yields groupnames passed to it as string' do
-          envied_require('bar')
-          expect(ENVied.env.groups).to eq [:bar]
-        end
-
-        it 'yields groupnames passed to it as symbols' do
-          envied_require(:foo)
-          expect(ENVied.env.groups).to eq [:foo]
-        end
-
-        it 'yields the groups passed via a string with groupnames' do
-          envied_require('foo,bar')
-          expect(ENVied.env.groups).to eq [:foo, :bar]
-        end
-      end
-
       context 'a variable in a group' do
         before do
+          set_ENV
           configure do
-            variable :moar
+            variable :MORE
 
             group :foo do
-              variable :bar
+              variable :BAR
             end
-          end.and_no_ENV
+            group :moo do
+              variable :BAT
+            end
+          end
         end
 
-        it 'is required when requiring the group' do
+        it 'is required when requiring the groups passed as a delimited string' do
           expect {
-            envied_require(:foo)
-          }.to raise_error(/bar/)
+            envied_require('foo,moo')
+          }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR, BAT.')
+        end
+
+        it 'is required when requiring the group' do
+          [:foo, 'foo'].each do |group|
+            expect {
+              envied_require(group)
+            }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR.')
+          end
         end
 
         it 'is not required when requiring another group' do
-          expect {
-            envied_require(:bat)
-          }.to_not raise_error
+          [:bat, 'bat'].each do |group|
+            expect {
+              envied_require(group)
+            }.to_not raise_error
+          end
         end
 
-        it 'wont define non-required variables on ENVied' do
-          stub_const("ENV", {'moar' => 'yes'})
+        it 'will not define variables not part of the default group' do
+          set_ENV('MORE' => 'yes')
           envied_require(:default)
 
           expect {
-            described_class.bar
+            described_class.BAR
           }.to raise_error(NoMethodError)
         end
 
+        it 'takes ENV["ENVIED_GROUPS"] into account when nothing is passed to require' do
+          set_ENV('ENVIED_GROUPS' => 'foo')
+          expect {
+            envied_require
+          }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR.')
+        end
+
+        it 'will define variables in the default group when nothing is passed to require' do
+          set_ENV('MORE' => 'yes')
+          envied_require
+
+          expect(described_class.MORE).to eq 'yes'
+        end
+
         it 'requires variables without a group when requiring the default group' do
-          [:default, 'default'].each do |groups|
+          [:default, 'default'].each do |group|
             expect {
-              envied_require(*groups)
-            }.to raise_error(/moar/)
+              envied_require(group)
+            }.to raise_error(RuntimeError, 'The following environment variables should be set: MORE.')
           end
         end
       end
 
       context 'a variable in multiple groups' do
         before do
+          set_ENV
           configure do
-            variable :moar
+            variable :MORE
 
             group :foo, :moo do
-              variable :bar
+              variable :BAR
             end
-          end.and_no_ENV
+          end
         end
 
         it 'is required when requiring any of the groups' do
           expect {
             envied_require(:foo)
-          }.to raise_error(/bar/)
+          }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR.')
 
           expect {
             envied_require(:moo)
-          }.to raise_error(/bar/)
+          }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR.')
         end
       end
 
       describe 'Hashable' do
         before do
+          set_ENV('FOO' => 'a=1&b=&c', 'BAR' => '')
           configure do
-            variable :foo, :hash
-            variable :bar, :hash
-          end.and_ENV('foo' => 'a=1&b=&c', 'bar' => '')
+            variable :FOO, :hash
+            variable :BAR, :hash
+          end
           envied_require
         end
 
         it 'yields hash from string' do
-          expect(ENVied.foo).to eq Hash['a'=> '1', 'b' => '', 'c' => nil]
+          expect(ENVied.FOO).to eq({ 'a' => '1', 'b' => '', 'c' => nil })
         end
 
         it 'yields hash from an empty string' do
-          expect(ENVied.bar).to eq Hash.new
+          expect(ENVied.BAR).to eq({})
         end
 
         context 'with defaults enabled' do
           before do
+            set_ENV
             configure(enable_defaults: true) do
-              variable :baz, :hash
-            end.and_no_ENV
+              variable :BAZ, :hash
+            end
           end
 
           it 'has no default by default' do
             # fixes a bug where variables of type :Hash had a default even
             # when none was configured.
-            expect { envied_require }.to raise_error(RuntimeError, 'The following environment variables should be set: baz.')
+            expect { envied_require }.to raise_error(RuntimeError, 'The following environment variables should be set: BAZ.')
           end
         end
       end
 
       describe 'Arrayable' do
         before do
+          set_ENV('MORE' => 'a, b, and\, c')
           configure do
-            variable :moar, :array
-          end.and_ENV('moar' => 'a, b, and\, c')
+            variable :MORE, :array
+          end
           envied_require
         end
 
         it 'yields array from string' do
-          expect(ENVied.moar).to eq ['a',' b',' and, c']
+          expect(ENVied.MORE).to eq ['a',' b',' and, c']
         end
       end
 
       describe 'URIable' do
         before do
+          set_ENV('SITE_URL' => 'https://www.google.com')
           configure do
-            variable :site_url, :uri
-          end.and_ENV('site_url' => 'https://www.google.com')
+            variable :SITE_URL, :uri
+          end
           envied_require
         end
 
         it 'yields a URI from string' do
-          expect(ENVied.site_url).to be_a URI
-          expect(ENVied.site_url.host).to eq 'www.google.com'
+          expect(ENVied.SITE_URL).to be_a URI
+          expect(ENVied.SITE_URL.scheme).to eq 'https'
+          expect(ENVied.SITE_URL.host).to eq 'www.google.com'
         end
       end
     end