envied 0.9.1 → 0.9.2

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

data/spec/gemspec_spec.rb

@@ -0,0 +1,17 @@
+require "open3"
+
+RSpec.describe 'envied.gemspec' do
+  let!(:build) { Open3.capture3("gem build envied.gemspec") }
+
+  after do
+    Dir.glob("envied-*.gem").each { |f| File.delete(f) }
+  end
+
+  it 'builds without warnings' do
+    expect(build[1]).to_not match(/WARNING/)
+  end
+
+  it 'builds successfully' do
+    expect(build[2].success?).to eq true
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,74 @@
-require 'rubygems'
-require 'bundler'
-Bundler.setup
+require "bundler/setup"
+require "envied"
 
-$:.unshift File.expand_path("../../lib", __FILE__)
-require 'envied'
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  #   config.filter_run :focus
+  #   config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+end

data/spec/variable_spec.rb

@@ -1,15 +1,25 @@
-require 'spec_helper'
-
-describe ENVied::Variable do
+RSpec.describe ENVied::Variable do
   def variable(*args)
     described_class.new(*args)
   end
 
-  def set_env(env)
-    stub_const("ENV", env)
-  end
-
   describe 'an instance' do
     subject { variable(:A, :string) }
+    it { is_expected.to respond_to :name }
+    it { is_expected.to respond_to :type }
+    it { is_expected.to respond_to :group }
+    it { is_expected.to respond_to :default }
+    it { is_expected.to respond_to :== }
+    it { is_expected.to respond_to :default_value }
+  end
+
+  describe 'defaults' do
+    it 'returns the default value as it is' do
+      expect(variable(:A, :string, default: 'A').default_value).to eq 'A'
+    end
+
+    it 'returns the default value from calling the proc provided' do
+      expect(variable(:A, :string, default: ->{ 'A' * 2 }).default_value).to eq 'AA'
+    end
   end
 end