fail_fast 0.1.0

data/lib/fail_fast/main.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+require 'erb'
+
+class FailFast
+  ERB_TEMPLATE = File.dirname(__FILE__) + '/report.txt.erb'
+
+  class Error < StandardError ; end
+  class ErrorDetails < Struct.new(:key, :kind, :value) ;
+    def has_key_and_kind?(akey, akind)
+      (key.to_s == akey.to_s) && kind.to_sym == akind.to_sym
+    end
+    def has_value_and_kind?(avalue, akind)
+      (value.to_s == avalue.to_s) && kind.to_sym == akind.to_sym
+    end
+  end
+  class Params < Struct.new(:key, :value, :regexp, :options) ; end
+
+  def initialize(path, prefix=nil)
+    @path   = path
+    @prefix = prefix
+    @@errors = []
+  end
+
+  def self.errors
+    @@errors
+  end
+
+  def check(&block)
+    if missing_file?(@path)
+      FailFast.errors << ErrorDetails.new(nil, :config_file_not_found, @path)
+    else
+      @hash = YAML.load(ERB.new(File.read(@path)).result) || {}
+      self.instance_eval(&block)
+    end
+    raise_and_print_errors if errors?
+  end
+
+
+private
+
+  def blank?( value)        value.nil? || value.is_a?(String) && ''==value.strip  end
+  def range?( value)        value.is_a?(Range )                                   end
+  def regexp?(value)        value.is_a?(Regexp)                                   end
+  def array?( value)        value.is_a?(Array )                                   end
+  def hash?(  value)        value.is_a?(Hash)                                     end
+  def missing_file?(path)  !File.exist?(path)                                     end
+
+  # Usage
+  #   value_for_deep_key('one/two/three')
+  # returns
+  #   @hash[:one][:two][:three]
+  #
+  def value_for_deep_key(key)
+    key.to_s.split('/').inject(@hash) { |h, k| h[k] } rescue nil
+  end
+
+
+  def key_value_regexp_options(key, params)
+    last = params.pop
+    if last.is_a?(Hash)
+      options = last
+    else
+      params << last
+      options = {}
+    end
+
+    last = params.pop
+    if last.is_a?(Regexp)
+      regexp = last
+    else
+      params << last
+    end
+
+    key = "#{@prefix}/#{key}" if @prefix
+    value = value_for_deep_key(key)
+
+    Params.new(key, value, regexp, options)
+  end
+
+  def errors?
+    !FailFast.errors.empty?
+  end
+
+
+  def raise_and_print_errors
+    @errors = @@errors 
+    raise "\n\n\n" + ERB.new(File.read(ERB_TEMPLATE)).result(binding) + "\n\n"
+  end
+end

data/lib/fail_fast/report.txt.erb

@@ -0,0 +1,8 @@
++------------------------------------------------------------------------------------------
+|   FAIL_FAST error : <%= @path.inspect  %>
+|   key prefix  = <%= @prefix.inspect   %>
++------------------------------------------------------------------------------------------
+|      error                                   key                                value
++------------------------------------------------------------------------------------------<% @errors.each do |e| %>
+|  * <%= "%-38s %-35s %-30s " % [ e.kind, e.key, e.value] %><% end %>
++------------------------------------------------------------------------------------------

data/lib/fail_fast.rb

@@ -0,0 +1,14 @@
+require 'fail_fast/main'
+
+require 'fail_fast/check_value'
+require 'fail_fast/check_file_system'
+require 'fail_fast/check_mongo_db'
+require 'fail_fast/check_active_record_db'
+require 'fail_fast/check_url'
+require 'fail_fast/check_email'
+
+
+def FailFast(path, prefix=nil)
+  FailFast.new(path, prefix)
+end
+

data/show_all_errors.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'mongo'
+
+def fake_http_server
+  require 'fakeweb'
+  FakeWeb.register_uri(:get, "http://example.com/index.html", :body => "I'm reachable!")
+  FakeWeb.register_uri(:get, "http://localhost/index.html", :body => "I'm reachable!")
+  FakeWeb.register_uri(:get, "http://example.com", :body => "I'm reachable!")
+end
+def fake_mongo_server_absent
+  require 'mocha'
+  Mongo::Connection.stubs(:new).raises(Mongo::ConnectionFailure)
+end
+def fake_mongo_db_absent
+  require 'mocha'
+  Mocha::Mockery.instance.stubba.unstub_all
+  
+  conn = Mongo::Connection.new
+  conn.stubs(:database_names).returns []
+  Mongo::Connection.stubs(:new).returns(conn)
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__)+'/lib')
+SPEC_DIR = File.dirname(__FILE__)+'/spec'
+
+require 'fail_fast'
+FailFast(SPEC_DIR + '/fixtures/simple.yml').check do
+
+#test values :
+  has_value_for   :first_keyNOT                   # single absent key
+  has_values_for  :last_keyNOT, 'number_sixNOT'   # multiple absent keys
+  has_value_for 'testNOT/mongoDB/database'        # invalid yaml path
+
+  has_value_for :last_key, /(will_never_match)/   # value does not match regexp
+
+  has_email_for 'test/host'                       # value is not an email address
+
+  fake_http_server
+  has_url_for 'test/host'                         # value is not a url
+
+#test http server :
+  has_url_for 'test/url_not_reachable', :reachable => true #server is not reachable
+
+#test file system :
+  directory_exists  '/foobarbaz'                  # not a directory
+  directory_exists_for  'test/a_file'             # not a directory
+
+  file_exists         '/tmp/foo/bar/??nOTaFile'   # not a file
+  file_exists_for     'test/a_directory'          # not a file
+
+#test mondoDB
+  fake_mongo_server_absent
+  has_mongoDB      '10.0.0.123', :timeout => 1    # no mongo server at this address
+  has_mongoDB_for  'test/mongoDB'                 #    "   "   "   "   "   "   ""
+
+  fake_mongo_db_absent
+  has_mongoDB      'localhost', 'not_a_known_db'
+  has_mongoDB_for 'test/unknown_mongoDB_db'       # a mongoDB, but the DB is unknown
+
+#test ActiveRecord
+  has_active_record_db      :host => 'localhost', :adapter => 'mysql', :database=> 'some-db'
+  has_active_record_db_for  'db_connection'
+end

data/spec/file_is_empty_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "ConfigCheck on an empty file" do
+  it_should_not_raise_an_error("when there are no checks") { }
+  it_should_raise_an_error('anykey', :missing_value, 'when there is a has_value_for check') {
+    has_value_for :anykey
+  }
+end

data/spec/file_is_missing_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "ConfigCheck on an unknown file" do
+
+  it "should not raise an error in new()" do
+    FailFast(UNKNOWN_FILE_PATH)
+    fail unless FailFast.errors.empty?
+  end
+
+  it "should raise an error in fail_fast()" do
+    lambda {
+      FailFast(UNKNOWN_FILE_PATH).check do end
+    }.should raise_error
+    fail unless FailFast.errors.collect(&:kind) == [:config_file_not_found]
+  end
+
+end

data/spec/file_system_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+a_dir   = SPEC_DIR + '/fixtures'
+a_file  = SPEC_DIR + '/fixtures/simple.yml'
+
+
+describe 'directory_exists' do
+  context '' do
+    it_should_not_raise_an_error('when the directory exists'                                            ) { directory_exists a_dir }
+
+    it_should_raise_a_direct_error('XYZ',     :directory_not_found, 'when the directory does not exist' ) { directory_exists 'XYZ' }
+    it_should_raise_a_direct_error(a_file,    :directory_not_found, 'when the path points to a File'    ) { directory_exists a_file}
+  end
+
+  context '_for' do
+    it_should_not_raise_an_error('when the directory exists'                                            ) { directory_exists_for 'test/a_directory' }
+
+    it_should_raise_an_error('test/a_file',   :directory_not_found, 'when the path points to a File'    ) { directory_exists_for 'test/a_file'      }
+    it_should_raise_an_error('test/email',    :directory_not_found, 'when the directory does not exist' ) { directory_exists_for 'test/email'       }
+    it_should_raise_an_error('not_a_valid_key',:missing_value,      'when the key is invalid'           ) { directory_exists_for 'not_a_valid_key'  }
+  end
+end
+
+
+describe 'file_exists' do
+  context '' do
+    it_should_not_raise_an_error('when the file exists'                                                 ) { file_exists a_file}
+
+    it_should_raise_a_direct_error('XYZ',     :file_not_found, 'when the file does not exist'           ) { file_exists 'XYZ' }
+    it_should_raise_a_direct_error(a_dir,     :file_not_found, 'when the path points to a dir'          ) { file_exists a_dir }
+  end
+
+  context '_for' do
+    it_should_not_raise_an_error('when the file exists'                                                 ) { file_exists_for 'test/a_file' }
+
+    it_should_raise_an_error('test/a_directory', :file_not_found,    'when the path points to a dir'    ) { file_exists_for 'test/a_directory'  }
+    it_should_raise_an_error('test/email',       :file_not_found,    'when the file does not exist'     ) { file_exists_for 'test/email'        }
+    it_should_raise_an_error('not_a_valid_key',  :missing_value,     'when the key is invalid'          ) { file_exists_for 'not_a_valid_key'   }
+  end
+end

data/spec/fixtures/simple.yml

@@ -0,0 +1,32 @@
+first_key: premier
+key_with_blank_value: <%= '' %>
+last_key: dernier
+test:
+  host: localhost
+  url: http://example.com/index.html
+  url_localhost: http://localhost/index.html
+  email: test@example.com
+  url_reachable: http://example.com
+  url_not_reachable: http://xxx.zzz
+  mongoDB:
+    host: localhost
+    database: sample_mongoDB
+
+  unreachable_mongoDB_server:
+    host: unreachable_host
+    database: "vasco-dpplus-auditlog-dev"
+
+  unknown_mongoDB_db:
+    host: localhost
+    database: unknown_mongoDB_db
+
+  a_directory:  <%= SPEC_DIR + '/fixtures' %>
+
+  a_file: <%= SPEC_DIR + '/fixtures/simple.yml' %>
+
+db_connection:
+  adapter: mysql
+  database: a_db
+
+number_six: 6
+letter_x: x

data/spec/has_active_record_db_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'has_ar_db' do
+  context '' do
+    it_should_not_raise_an_error('when the connections succeeds' ) {
+      conn = Object.new ; conn.should_receive(:active?).and_return(true)
+      ActiveRecord::Base.should_receive(:connection).and_return(conn)
+
+      has_active_record_db :host => 'localhost', :adapter => 'mysql', :database=> 'a-db', :username => 'root'
+    }
+
+    it_should_raise_a_direct_error('ze-error-message', :active_record_db_connection_error, 'when the connection fails' ) {
+      exception = StandardError.new('ze-error-message')
+      ActiveRecord::Base.should_receive(:establish_connection).and_raise(exception)
+
+      has_active_record_db valid_connection_options = {}
+    }
+  end
+
+  context '_for' do
+    it_should_not_raise_an_error('when the connections succeeds' ) {
+      conn = Object.new ; conn.should_receive(:active?).and_return(true)
+      ActiveRecord::Base.should_receive(:connection).and_return(conn)
+
+      has_active_record_db_for 'db_connection'
+    }
+
+    it_should_raise_an_error('db_connection', :active_record_db_connection_error, 'when the connection fails' ) {
+      exception = StandardError.new('an-error-message')
+      ActiveRecord::Base.should_receive(:establish_connection).and_raise(exception)
+
+      has_active_record_db_for 'db_connection'
+    }
+
+    it_should_raise_an_error('invalid_key', :missing_value, 'when the key is invalid' ) {
+      has_active_record_db_for 'invalid_key'
+    }
+  end
+end

data/spec/has_email_for_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'has_email_for()' do
+  it_should_not_raise_an_error('when the value is an email') {
+    has_email_for 'test/email'
+  }
+  it_should_raise_an_error('test/url', :not_an_email, 'when the value is not an email') {
+    has_email_for 'test/url'
+  }
+  it_should_raise_an_error('invalid_key', :missing_value, 'when the key is invalid') {
+    has_email_for 'invalid_key'
+  }
+end

data/spec/has_mongoDB_for_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'has_mongoDB' do
+
+  context '' do
+    context 'when the mongo server cannot be reached' do
+      before(:each) { Mongo::Connection.should_receive(:new).any_number_of_times.and_raise(Mongo::ConnectionFailure) }
+
+      it_should_raise_a_direct_error('localhost', :mongoDB_server_not_found, 'when the mongoDB server connection failed') {
+        has_mongoDB 'localhost'
+      }
+    end
+
+    context 'when the mongo server can be reached' do
+      before(:each) do
+        conn = Mongo::Connection.new
+        conn.should_receive(:database_names).any_number_of_times.and_return %w(sample_mongoDB)
+        Mongo::Connection.should_receive(:new).and_return(conn)
+      end
+
+      it_should_not_raise_an_error('when the mongoDB server responds'                         ) { has_mongoDB 'localhost'                   }
+      it_should_not_raise_an_error('when the mongoDB server responds and the db can be found' ) { has_mongoDB 'localhost', 'sample_mongoDB' }
+
+      it_should_raise_a_direct_error('not_a_known_db', :mongoDB_db_not_found, 'when the database cannot be found on the mongoDB') {
+        has_mongoDB 'localhost', 'not_a_known_db'
+      }
+    end
+  end
+
+  context '_for' do
+    context 'when the mongo server cannot be reached' do
+      before(:each) { Mongo::Connection.should_receive(:new).any_number_of_times.and_raise(Mongo::ConnectionFailure) }
+
+      it_should_raise_an_error('test/unreachable_mongoDB_server', :mongoDB_server_not_found, 'when the mongoDB server connection failed') {
+        has_mongoDB_for 'test/unreachable_mongoDB_server'
+      }
+      it_should_raise_an_error('not_a_valid_key', :missing_value, 'when the key is invalid') { has_mongoDB_for 'not_a_valid_key' }
+    end
+
+    context 'when the mongo server can be reached' do
+      before(:each) do
+        conn = Mongo::Connection.new
+        conn.should_receive(:database_names).any_number_of_times.and_return %w(sample_mongoDB)
+        Mongo::Connection.should_receive(:new).and_return(conn)
+      end
+
+      it_should_not_raise_an_error('when the mongoDB server responds and the database can be found') {
+        has_mongoDB_for 'test/mongoDB'
+      }
+
+      it_should_raise_an_error('test/unknown_mongoDB_db', :mongoDB_db_not_found,'when the database cannot be found on the mongoDB') {
+        has_mongoDB_for 'test/unknown_mongoDB_db'
+      }
+
+      it_should_not_raise_an_error('when :ignore_database => false desactivate the db check') {
+        has_mongoDB_for 'test/unknown_mongoDB_db', :check_database => false
+      }
+    end
+  end
+end

data/spec/has_url_for_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'has_url_for()' do
+before(:all) do
+    FakeWeb.register_uri(:get, "http://example.com/index.html", :body => "I'm reachable!")
+    FakeWeb.register_uri(:get, "http://localhost/index.html"  , :body => "I'm reachable!")
+    FakeWeb.register_uri(:get, "http://example.com"           , :body => "I'm reachable!")
+  end
+
+  it_should_not_raise_an_error('when the value is an url') { has_url_for 'test/url' }
+  it_should_not_raise_an_error("when the domain is 'localhost'") { has_url_for 'test/url_localhost' }
+  it_should_raise_an_error('test/email', :not_a_url, 'when the value is not an url') { has_url_for 'test/email' }
+
+  it_should_raise_an_error('not_a_valid_key', :missing_value ,'when the value is blank or absent') { has_url_for 'not_a_valid_key' }
+
+  it_should_not_raise_an_error('when the url is reachable') {
+    has_url_for 'test/url_reachable'    , :reachable => true, :may_add_trailing_slash => true
+  }
+  it_should_raise_an_error('test/url_not_reachable', :url_not_reachable ,'when the url is not reachable') {
+    has_url_for 'test/url_not_reachable', :reachable => true
+  }
+end

data/spec/has_value_for_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'has_value_for()' do
+
+  context 'when the value is present' do
+    it_should_not_raise_an_error('when the (string) key has a value') { has_value_for 'first_key' }
+    it_should_not_raise_an_error('when the (symbol) key has a value') { has_value_for :last_key   }
+    it_should_not_raise_an_error('when all the keys have a value'   ) { has_values_for 'first_key', :last_key   }
+    it_should_not_raise_an_error('when the key is composed'         ) { has_value_for 'test/mongoDB/host',    /localhost/ }
+  end
+
+  context 'when the key is blank or absent' do
+    it_should_raise_an_error('key_not_present', :missing_value, 'when the key is absent') {
+      has_value_for :key_not_present
+    }
+    it_should_raise_an_error('key_with_blank_value', :missing_value, 'when the key has a blank value') {
+      has_values_for 'first_key', :key_with_blank_value
+    }
+    it_should_raise_an_error('key_with_blank_value', :missing_value, 'when one of the keys is absent') {
+      has_values_for :first_key, :key_with_blank_value
+    }
+    context 'because the key path is invalid' do
+      it_should_raise_an_error('INVALID/mongoDB/host', :missing_value, 'when the key path is invalid') {
+        has_value_for 'INVALID/mongoDB/host'
+      }
+    end
+  end
+
+  context 'when the value should match a regexp' do
+    it_should_not_raise_an_error('when the value matches a regexp') { has_value_for 'test/host', /localhost/ }
+    it_should_raise_an_error('letter_x', :value_does_not_match, 'when the value matches a regexp') {
+      has_value_for :letter_x, /localhost/
+    }
+  end
+
+  context 'when the value must be in a range' do
+    it_should_not_raise_an_error("when the value is in range ('a'..'z')") { has_value_for :letter_x,   :in => ('a'..'z') }
+    it_should_raise_an_error('letter_x', :value_not_in_range, 'when the value is not in range (5..6)') {
+      has_value_for :letter_x, :in => (5..6)
+    }
+    it_should_raise_an_error('letter_x', :value_not_in_range, 'when the value is not in range (5..6)') {
+      has_value_for :letter_x, :in => (5..6)
+    }
+    it_should_not_raise_an_error('when the value is in range (5..6)'    ) { has_value_for :number_six, :in => (5..6) }
+    it_should_raise_an_error('number_six', :value_not_in_range, 'when the value is not in range (5..6)') {
+      has_value_for :number_six, :in => ('a'..'z')
+    }
+  end
+
+  context 'when the value must be in an array' do
+    it_should_not_raise_an_error('when the value is in array [6, "x"]') {
+      has_value_for :letter_x,   :in => [6, "x"]
+      has_value_for :number_six, :in => [6, "x"]
+    }
+    it_should_raise_an_error('letter_x', :value_not_in_array, 'when the value is not in array [0, 1]') {
+      has_value_for :letter_x, :in => [0, 1]
+    }
+  end
+
+  context 'when a prefix is specified' do
+    it "should not raise an error when a prefix is used" do
+      lambda {
+        FailFast(SIMPLE_FILE_PATH, 'test').check do
+          has_value_for 'mongoDB/host',    /localhost/
+        end
+      }.should_not raise_error
+    end
+  end
+end

data/spec/how_to_use_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "typical usage" do
+
+  example 'simple usage (short notation)' do
+    FailFast(SIMPLE_FILE_PATH).check do
+      has_value_for :first_key
+      has_values_for :last_key, 'number_six', :letter_x
+      has_value_for 'test/mongoDB/database'             # composed key
+
+
+      has_value_for :last_key, /(premier|dernier)/      # regexp match
+
+      has_url_for 'test/url'
+      has_url_for 'test/url_reachable', :reachable => true, :may_add_trailing_slash => true
+
+      has_email_for 'test/email'
+
+      has_mongoDB_for 'test/mongoDB'
+      has_mongoDB_for 'test/unknown_mongoDB_db', :check_database  => false
+
+      directory_exists_for  'test/a_directory'
+      file_exists_for       'test/a_file'
+    end
+  end
+
+  example 'with a keys yaml prefix' do
+    rails_env_prefix = 'test' # == Rails.env
+    FailFast(SIMPLE_FILE_PATH, rails_env_prefix).check do
+      has_value_for 'mongoDB/database'             # composed key
+    end
+  end
+
+  before(:each) { fake_the_remote_services() }
+end
+
+def fake_the_remote_services
+  FakeWeb.register_uri(:get, "http://example.com/index.html", :body => "I'm reachable!")
+  FakeWeb.register_uri(:get, "http://localhost/index.html", :body => "I'm reachable!")
+  FakeWeb.register_uri(:get, "http://example.com", :body => "I'm reachable!")
+
+  conn = Mongo::Connection.new
+  conn.should_receive(:database_names).any_number_of_times.and_return %w(sample_mongoDB)
+  Mongo::Connection.should_receive(:new).any_number_of_times.and_return(conn)
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,86 @@
+require 'fail_fast'
+require 'spec'
+require 'spec/autorun'
+require 'fakeweb'
+require 'mongo'
+
+SPEC_DIR = File.dirname(File.expand_path(__FILE__))
+UNKNOWN_FILE_PATH =   'an_unknown_file_path'
+EMPTY_FILE_PATH   =   File.expand_path(File.dirname(__FILE__) + '/fixtures/empty.yml')
+SIMPLE_FILE_PATH  =   File.expand_path(File.dirname(__FILE__) + '/fixtures/simple.yml')
+
+
+module DSLMacros
+  module ClassMethods
+    def it_should_not_raise_an_error(msg, &block)
+      it "should not raise an error #{msg}" do
+        begin
+          FailFast(SIMPLE_FILE_PATH).check do
+            raise "BUG : @@errorz should be empty \n#{FailFast.errors.inspect}"  unless FailFast.errors.empty?
+            self.instance_eval(&block)
+          end
+        rescue => e
+          raise e
+        ensure
+          if 1 <= FailFast.errors.length
+            fail "ZZshould not have raised an error, but it raised\n#{FailFast.errors.join("\n")}"
+          end
+        end
+
+      end
+    end
+
+    def it_should_raise_an_error(key, kind, msg, &block)
+      it "should raise an error #{kind}-#{key}-#{msg}" do
+        begin
+          FailFast(SIMPLE_FILE_PATH).check do
+            raise "BUG : @@errorz should be empty \n#{FailFast.errors.inspect}"  unless FailFast.errors.empty?
+            self.instance_eval(&block)
+          end
+        rescue => e
+          # uncomment the next line after the refactoring/once error are no longer raise
+          #  raise e
+        ensure
+          if FailFast.errors.empty?
+            fail "\ne2d\nshould have raised a #{kind} error for #{key} \n==#{e}"
+          elsif FailFast.errors.length == 1 && !FailFast.errors.first.has_key_and_kind?(key, kind)
+            fail "\ne2e\nshould have raised a #{kind.inspect} error for #{key.inspect}, but raised instead #{FailFast.errors.inspect}"
+          elsif 2 <= FailFast.errors.length
+            fail "\ne2f\nshould have raised only a #{kind} error for #{key}\n#{FailFast.errors.join("\n")}"
+          end
+        end
+
+      end
+    end
+    def it_should_raise_a_direct_error(value, kind, msg, &block)
+      it "should raise an error #{kind}-#{value}-#{msg}" do
+        begin
+          FailFast(SIMPLE_FILE_PATH).check do
+            raise "BUG : @@errorz should be empty \n#{FailFast.errors.inspect}"  unless FailFast.errors.empty?
+            self.instance_eval(&block)
+          end
+        rescue => e
+          # uncomment the next line after the refactoring/once error are no longer raise
+          #  raise e
+        ensure
+          if FailFast.errors.empty?
+            fail "\ne2d\nshould have raised a #{kind} error for #{value} \n==#{e}"
+          elsif FailFast.errors.length == 1 && !FailFast.errors.first.has_value_and_kind?(value, kind)
+            fail "\ne2e\nshould have raised a #{kind.inspect} error for #{value.inspect}\n, but raised instead\n#{FailFast.errors.inspect}"
+          elsif 2 <= FailFast.errors.length
+            fail "\ne2f\nshould have raised only 1 #{kind} error for #{value}\nbut raised instead\n#{FailFast.errors.join("\n")}"
+          end
+        end
+
+      end
+    end
+
+  end
+
+  def self.included(receiver)
+    receiver.extend(ClassMethods)
+  end
+end
+Spec::Runner.configure do |config|
+  config.include(DSLMacros)
+end