right_support 2.11.3 → 2.12.1

data/spec/ruby/easy_singleton_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-class Alice
-  include Singleton
-  include RightSupport::Ruby::EasySingleton
-
-  def alice?
-    true
-  end
-end
-
-class Bob
-  include RightSupport::Ruby::EasySingleton
-
-  def bob?
-    true
-  end
-end
-
-class Charlie
-  include RightSupport::Ruby::EasySingleton
-
-  def charlie?(&block)
-    block.call("this is charlie") if block
-    true
-  end
-
-  def horse(x,y,z)
-    yield("this is horse") if block_given?
-    x+y+z
-  end
-end
-
-describe RightSupport::Ruby::EasySingleton do
-  context 'when mixed into a base class' do
-    it 'ensures the base is already a Singleton' do
-      Alice.ancestors.should include(Singleton)
-      Bob.ancestors.should include(Singleton)
-    end
-
-    it 'adds a class-level method_missing' do
-      Alice.alice?.should be_true
-      Bob.bob?.should be_true
-
-      lambda { Alice.bob? }.should raise_error(NoMethodError)
-    end
-
-    it 'modifies class-level respond_to? to be truthful' do
-      Alice.respond_to?(:alice?).should be_true
-      Bob.respond_to?(:bob?).should be_true
-      Alice.respond_to?(:bob?).should be_false
-      Bob.respond_to?(:alice?).should be_false
-    end
-  end
-
-  context 'when proxying class-level method_missing to instance' do
-    it 'preserves parameters as passed' do
-      Charlie.horse(1,2,3).should == 6
-    end
-
-    it 'preserves block semantics' do
-      charlie = nil
-      horse   = nil
-
-      Charlie.charlie? { |x| charlie = x }
-      charlie.should == 'this is charlie'
-
-      Charlie.horse(1,2,3) { |x| horse = x }
-      horse.should == 'this is horse'
-    end
-  end
-end

data/spec/ruby/object_extensions_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::Ruby::ObjectExtensions do
-  context :require_succeeds? do
-    it 'yields to its block when the require succeeds' do
-      @canary = false
-
-      # The 'set' source file ships with Ruby standard library and should
-      # always be available
-      if require_succeeds?('set')
-        @canary = true
-      end
-
-      @canary.should == true
-    end
-
-    it 'does not yield when require fails for any reason' do
-      @canary = false
-
-      if require_succeeds?('a_source_file_with_a_wholly_improbable_name')
-        @canary = true
-      end
-
-      @canary.should == false
-    end
-  end
-end

data/spec/ruby/string_extensions_spec.rb

@@ -1,98 +0,0 @@
-#
-# Copyright (c) 2012 RightScale Inc
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'spec_helper'
-
-describe RightSupport::Ruby::StringExtensions do
-
-  context ":snake_case" do
-
-    it "downcases single word" do
-      ["FOO", "Foo", "foo"].each do |w|
-        w.snake_case.should == "foo"
-      end
-    end
-
-    it "doesn't separate numbers from end of word" do
-      ["Foo1234", "foo1234"].each do |w|
-        w.snake_case.should == "foo1234"
-      end
-    end
-
-    it "doesn't separate numbers from word that starts with uppercase letter" do
-      "1234Foo".snake_case.should == "1234foo"
-    end
-
-    it "doesn't' separate numbers from word that starts with lowercase letter" do
-      "1234foo".snake_case.should == "1234foo"
-    end
-
-    it "downcases camel-cased words and connect with underscore" do
-      ["FooBar", "fooBar"].each do |w|
-        w.snake_case.should == "foo_bar"
-      end
-    end
-
-    it "starts new word with uppercase letter before lower case letter" do
-      ["FooBARBaz", "fooBARBaz"].each do |w|
-        w.snake_case.should == "foo_bar_baz"
-      end
-    end
-
-  end
-
-  context ":to_const_path" do
-
-    it "snakes-case the string" do
-      "Hello::World".to_const_path.should == "hello/world"
-    end
-
-    it "leaves (snake-cased) string without '::' unchanged" do
-      "hello".to_const_path.should == "hello"
-    end
-
-    it "replaces single '::' with '/'" do
-      "hello::world".to_const_path.should == "hello/world"
-    end
-    
-    it "replaces multiple '::' with '/'" do
-      "hello::rightscale::world".to_const_path.should == "hello/rightscale/world"
-    end
-
-  end
-
-  context ':camelize' do
-
-    it 'camelizes the string' do
-      'hello/world_hello'.camelize.should == 'Hello::WorldHello'
-    end
-
-    it 'camelizes strings with integers' do
-      '1hel2lo3/4wor5ld6_7hel8lo9'.camelize.should == '1hel2lo3::4wor5ld67hel8lo9'
-    end
-
-    it 'leaves camelized strings alone' do
-      '1Hel2lo3::4Wor5ld67Hel8lo9'.camelize.should == '1Hel2lo3::4Wor5ld67Hel8lo9'
-    end
-    
-  end
-end

data/spec/spec_helper.rb

@@ -1,188 +0,0 @@
-# Copyright (c) 2012- RightScale Inc
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'rubygems'
-require 'bundler/setup'
-require 'flexmock'
-
-require 'simplecov'
-
-$:.unshift(File.expand_path('../../../lib', __FILE__)) #ensure we load THIS project's code, not an installed gem
-require 'right_support'
-
-['pry', 'ruby-debug'].each do |debugger|
-  begin
-    require debugger
-  rescue LoadError
-    # ignore
-  end
-end
-
-RSpec.configure do |config|
-  config.mock_with :flexmock
-end
-
-def read_fixture(fn)
-  basedir = File.expand_path('../..', __FILE__)
-  fixtures_dir = File.join(basedir, 'spec', 'fixtures')
-  File.read(File.join(fixtures_dir, fn))
-end
-
-def corrupt(key, factor=4)
-  d = key.size / 2
-
-  key[0..(d-factor)] + key[d+factor..-1]
-end
-
-RSpec::Matchers.define :have_green_endpoint do |endpoint|
-  match do |balancer|
-    stack = balancer.instance_variable_get(:@stack)
-    state = stack.instance_variable_get(:@endpoints)
-    state = state[endpoint] if state.respond_to?(:[])
-    unless stack && state && state.key?(:n_level)
-      raise ArgumentError, "Custom matcher is incompatible with new HealthCheck implementation!"
-    end
-    state[:n_level] == 0
-  end
-end
-
-RSpec::Matchers.define :have_yellow_endpoint do |endpoint, n|
-  match do |balancer|
-    stack = balancer.instance_variable_get(:@stack)
-    max_n = stack.instance_variable_get(:@yellow_states)
-    state = stack.instance_variable_get(:@endpoints)
-    state = state[endpoint] if state.respond_to?(:[])
-    unless max_n && stack && state && state.key?(:n_level)
-      raise ArgumentError, "Custom matcher is incompatible with new HealthCheck implementation!"
-    end
-
-    if n
-      state[:n_level].should == n
-    else
-      (1...max_n).should include(state[:n_level])
-    end
-  end
-end
-
-RSpec::Matchers.define :have_red_endpoint do |endpoint|
-  match do |balancer|
-    stack = balancer.instance_variable_get(:@stack)
-    max_n = stack.instance_variable_get(:@yellow_states)
-    state = stack.instance_variable_get(:@endpoints)
-    state = state[endpoint] if state.respond_to?(:[])
-    unless max_n && stack && state && state.key?(:n_level)
-      raise ArgumentError, "Custom matcher is incompatible with new HealthCheck implementation!"
-    end
-    min = 1
-    state[:n_level].should == max_n
-  end
-end
-
-def find_empirical_distribution(trials=2500, list=[1,2,3,4,5])
-  seen = {}
-
-  trials.times do
-    value = yield
-    seen[value] ||= 0
-    seen[value] += 1
-  end
-
-  seen
-end
-
-def test_random_distribution(trials=25000, list=[1,2,3,4,5], &block)
-  seen = find_empirical_distribution(trials, &block)
-  should_be_chosen_fairly(seen,trials,list.size)
-end
-
-def should_be_chosen_fairly(seen, trials, size)
-  #Load should be evenly distributed
-  chance = 1.0 / size
-  seen.each_pair do |_, count|
-    (Float(count) / Float(trials)).should be_within(0.025).of(chance) #allow 5% margin of error
-  end
-end
-
-RANDOM_KEY_CLASSES   = [String, Integer, Float, TrueClass, FalseClass]
-RANDOM_VALUE_CLASSES = RANDOM_KEY_CLASSES + [Array, Hash]
-
-def random_value(klass=nil, depth=0)
-  if klass.nil?
-    if depth < 5
-      klasses = RANDOM_VALUE_CLASSES
-    else
-      klasses = RANDOM_KEY_CLASSES
-    end
-
-    klass = klasses[rand(klasses.size)]
-  end
-
-  if klass == String
-    result = ''
-    io = StringIO.new(result, 'w')
-    rand(40).times { io.write(0x61 + rand(26)) }
-    io.close
-  elsif klass == Integer
-    result = rand(0xffffff)
-  elsif klass == Float
-    result = rand(0xffffff) * rand
-  elsif klass == TrueClass
-    result = true
-  elsif klass == FalseClass
-    result = false
-  elsif klass == Array
-    result = []
-    rand(10).times { result << random_value(nil, depth+1) }
-  elsif klass == Hash
-    result = {}
-    key_type = RANDOM_KEY_CLASSES[rand(RANDOM_KEY_CLASSES.size)]
-    rand(10).times { result[random_value(key_type, depth+1)] = random_value(nil, depth+1) }
-  else
-    raise ArgumentError, "Unknown random value type #{klass}"
-  end
-
-  result
-end
-
-def mock_logger
-  logger = flexmock(Logger.new(StringIO.new))
-end
-
-module SpecHelper
-  module SocketMocking
-    def mock_getaddrinfo(hostname, result, times=1)
-      boring_args = [nil, Socket::AF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP]
-
-      if result.is_a?(Class) && result.ancestors.include?(Exception)
-        e = result.new("Mock exception raised by getaddrinfo")
-        flexmock(Socket).should_receive(:getaddrinfo).with(hostname, *boring_args).times(times).ordered.and_raise(e)
-      else
-        infos = []
-
-        result.each do |addr|
-          infos << [0,0,0,addr]
-        end
-
-        flexmock(Socket).should_receive(:getaddrinfo).with(hostname, *boring_args).times(times).ordered.and_return(infos)
-      end
-    end
-  end
-end