right_support 2.6.17 → 2.7.0

data/spec/net/s3_helper_spec.rb

@@ -0,0 +1,160 @@
+require "spec_helper"
+
+describe RightSupport::Net::S3Helper do
+
+  def digest
+    OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, passphrase, @valid_params[:data])
+  end
+
+  def ciphertext
+    "\203\346\271\273\323\377r\246\002\204\231\374h\327!\323"
+  end
+
+  def passphrase
+    "#{@valid_params[:key]}:key"
+  end
+
+  before(:each) do
+    @valid_params = { :key => "foo", :data => "bar" }
+
+    # Mock right_aws config & objects with reasonable default behavior
+    @s3_config = {'creds' =>
+                      {'aws_access_key_id' => 'knock_knock',
+                       'aws_secret_access_key' => 'open_sesame'},
+                  'bucket_name' => 'my_own_personal_bucket',
+                  'master_secret' => 'if i told you i would have to kill you'}
+    @s3_class  = flexmock("s3")
+    @s3_object = flexmock("s3_object")
+    @s3_bucket = flexmock("s3_bucket")
+    @s3_class.should_receive(:new).with(String, String, Hash).and_return(@s3_object)
+    @s3_object.should_receive(:bucket).with('my_own_personal_bucket').and_return(@s3_bucket).by_default
+    @s3_bucket.should_receive(:key).and_return(@s3_object).by_default
+    @s3_bucket.should_receive(:put).with(String, String, Hash).and_return(true).by_default
+
+    @s3_object.should_receive(:meta_headers).and_return({"digest" => digest})
+    @s3_object.should_receive(:data).and_return(ciphertext)
+
+    flexmock(RightSupport::Net::S3Helper).should_receive(:s3_enabled?).and_return(:true)
+    flexmock(RightSupport::Net::S3Helper).should_receive(:master_secret).and_return('key')
+
+    @encrypt = flexmock("encrypt")
+    @encrypt.should_receive(:encrypt).with(String, String, Hash).and_return(ciphertext)
+    @encrypt.should_receive(:encrypt).with(Hash).and_return(ciphertext)
+    @encrypt.should_receive(:decrypt).with(Hash).and_return(@valid_params[:data])
+  end
+
+  context :init do
+    context "when all params are valid" do
+      it "succeeds" do
+        RightSupport::Net::S3Helper.init(@s3_config, @s3_class, @encrypt).should be_true
+      end
+    end
+
+    context "when bucket does not exist" do
+      before(:each) do
+        @bad_s3_config = @s3_config.clone
+        @bad_s3_config['bucket_name'] = "supercallifragilisticexpialidocious"
+        @s3_object.should_receive(:bucket).with("supercallifragilisticexpialidocious").and_return(nil)
+      end
+
+      it "raises BucketNotFound" do
+        lambda {
+          RightSupport::Net::S3Helper.init(@bad_s3_config, @s3_class, @encrypt)
+        }.should raise_error(RightSupport::Net::S3Helper::BucketNotFound)
+      end
+    end
+  end
+
+  context :get do
+    before(:each) do
+      RightSupport::Net::S3Helper.init(@s3_config, @s3_class, @encrypt)
+    end
+
+    context "with valid params" do
+      it 'returns plaintext' do
+        RightSupport::Net::S3Helper.get(@valid_params[:key]).should be_eql(@valid_params[:data])
+      end
+    end
+  end
+
+  context :post do
+    before(:each) do
+      RightSupport::Net::S3Helper.init(@s3_config, @s3_class, @encrypt)
+    end
+
+    context "with valid params" do
+      it 'encrypts and saves data' do
+        @s3_bucket.should_receive(:put).with(@valid_params[:key], ciphertext, {"digest" => digest}).and_return(true)
+        RightSupport::Net::S3Helper.post(@valid_params[:key], @valid_params[:data]).should be_true
+      end
+    end
+  end
+
+  context :health_check do
+    before(:each) do
+      RightSupport::Net::S3Helper.init(@s3_config, @s3_class, @encrypt)
+    end
+
+    context 'with invalid configuration' do
+      before :each do
+        flexmock(RightSupport::Net::S3Helper).should_receive(:config).and_return({'creds' => {'aws_access_key_id' => '@@AWS_ACCESS_KEY_ID@@', 'aws_secret_access_key' => '@@AWS_SECRET_ACCESS_KEY@@'}, 'bucket_name' => '@@s3_bucket_NAME@@', 'master_secret' => '@@MASTER_SECRET@@'})
+      end
+
+      it 'return error' do
+        RightSupport::Net::S3Helper.health_check.class.should == String
+      end
+    end
+
+    context 'with valid configuration but invalid s3 connection credentials' do
+      before :each do
+        flexmock(RightSupport::Net::S3Helper).should_receive(:config).and_return({'creds' => {'aws_access_key_id' => 'AWS_ACCESS_KEY_ID', 'aws_secret_access_key' => 'AWS_SECRET_ACCESS_KEY'}, 'bucket_name' => 'BUCKET_NAME', 'master_secret' => 'MASTER_SECRET'})
+      end
+
+      it 'returns error ' do
+        RightSupport::Net::S3Helper.health_check.class.should == String
+      end
+    end
+
+    context 'with valid configuration and s3 connection' do
+      before :each do
+        flexmock(RightSupport::Net::S3Helper).should_receive(:config).and_return({'creds' => {'aws_access_key_id' => 'dsfgdsfgdsfgdsfg', 'aws_secret_access_key' => 'sdghdhsdg'}, 'bucket_name' => 'dshdshdfgh', 'master_secret' => 'dshdshg'})
+        flexmock(RightSupport::Net::S3Helper).should_receive(:post).with('ping', 'heath check').and_return(true)
+        flexmock(RightSupport::Net::S3Helper).should_receive(:get).with('ping').and_return('heath check')
+      end
+
+      it 'returns ok' do
+        RightSupport::Net::S3Helper.health_check.should == true
+      end
+    end
+  end
+
+  context 'test/development environment' do
+
+    before :each do
+      @key1 = 'aws_access_key_id'
+      @key2 = 'aws_secret_access_key'
+      @opt_with_no_subdomains = {:no_subdomains => true}
+      @opt_without_subdoamins = {}
+      @config = {}
+      @config["creds"] = {}
+      @config["creds"]["aws_access_key_id"] = @key1
+      @config["creds"]["aws_secret_access_key"] = @key2
+      @s3_class = flexmock('Rightscale::S3')
+      flexmock(RightSupport::Net::S3Helper).should_receive(:bucket).and_return(true)
+    end
+
+    it 'works ok with :no_subdomains' do
+      @s3_class.should_receive(:new).with(@key1, @key2, @opt_with_no_subdomains)
+      RightSupport::Net::S3Helper.init(@config, @s3_class, @s3_class, :no_subdomains => true)
+      RightSupport::Net::S3Helper.s3
+    end
+
+    it 'works ok without subdomains' do
+      @s3_class.should_receive(:new).with(@key1, @key2, @opt_without_subdoamins)
+      RightSupport::Net::S3Helper.init(@config, @s3_class, @s3_class)
+      RightSupport::Net::S3Helper.s3
+    end
+
+  end
+
+end

data/spec/net/ssl_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe RightSupport::Net::SSL do
+  PATCH = RightSupport::Net::SSL::OpenSSLPatch
+
+  context :with_expected_hostname do
+    before(:all) do
+      PATCH.enable!
+    end
+
+    it 'works' do
+      OpenSSL::SSL.should respond_to(:verify_certificate_identity_without_hack)
+      PATCH.enabled?.should be_true
+
+      cert = flexmock('SSL certificate')
+
+      flexmock(OpenSSL::SSL).
+          should_receive(:verify_certificate_identity_without_hack).
+          with(cert, 'reposeX.rightscale.com').and_return(true)
+      RightSupport::Net::SSL.with_expected_hostname('reposeX.rightscale.com') do
+        OpenSSL::SSL.verify_certificate_identity(cert, '1.2.3.4').should be_true
+      end
+    end
+
+    context 'with disabled monkey-patch' do
+      before(:all) do
+        PATCH.disable!
+      end
+      it 'does not work' do
+        PATCH.enabled?.should be_false
+        cert = flexmock('SSL certificate')
+        flexmock(OpenSSL::SSL).
+            should_receive(:verify_certificate_identity_without_hack).
+            with(cert, '1.2.3.4').and_return(false)
+
+        RightSupport::Net::SSL.with_expected_hostname('reposeX.rightscale.com') do
+          OpenSSL::SSL.verify_certificate_identity(cert, '1.2.3.4').should be_false
+        end
+      end
+    end
+  end
+end

data/spec/net/string_encoder_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'cgi'
+
+describe RightSupport::Net::StringEncoder do
+  #Alias for brevity's sake
+  ENCODINGS = RightSupport::Net::StringEncoder::ENCODINGS
+
+  before(:all) do
+    #Generate some random binary test vectors with varying
+    #lengths, 2-1024 bytes
+    @strings = []
+    (1..10).each do |i|
+      s = ''
+      i.times { s << rand(256) }
+
+      if RUBY_VERSION >= '1.9'
+        @strings << s.force_encoding(Encoding::ASCII_8BIT)
+      else
+        @strings << s
+      end
+    end
+  end
+
+  context :initialize do
+    it 'accepts a glob of encodings' do
+      obj = RightSupport::Net::StringEncoder.new(:base64, :url)
+      obj.decode(obj.encode('moo')).should == 'moo'
+    end
+
+    it 'accepts an Array of encodings' do
+      obj = RightSupport::Net::StringEncoder.new([:base64, :url])
+      obj.decode(obj.encode('moo')).should == 'moo'
+    end
+
+    context 'when unknown encodings are specified' do
+      it 'raises ArgumentError' do
+        lambda do
+          RightSupport::Net::StringEncoder.new(:xyzzy, :foobar)
+        end.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  #Ensure that encodings are symmetrical and commutative by testing round-trip
+  #for all combinations.
+  (1..ENCODINGS.length).each do |n|
+    context "when using any #{n} encoding#{n > 1 ? 's' : ''}" do
+      ENCODINGS.combination(n).each do |list|
+        it "round-trips #{list.join(', ')}" do
+          obj = RightSupport::Net::StringEncoder.new(*list)
+          @strings.each do |str|
+            obj.decode(obj.encode(str)).should == str
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rack/log_setter_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe RightSupport::Rack::LogSetter do
+  it 'has test coverage'
+end

data/spec/rack/request_logger_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe RightSupport::Rack::RequestLogger do
+  class OhNoes < Exception; end
+
+  before(:each) do
+    @app = flexmock('Rack app')
+    @app.should_receive(:call).and_return([200, {}, 'body']).by_default
+    @logger = mock_logger
+    @env = {'rack.logger' => @logger}
+    @middleware = RightSupport::Rack::RequestLogger.new(@app)
+  end
+
+  context :initialize do
+    context 'without :logger option' do
+      it 'uses rack.logger' do
+        @logger.should_receive(:info)
+        @middleware.call(@env).should == [200, {}, 'body']
+      end
+    end
+  end
+
+  context :call do
+    context 'when the app raises an exception' do
+      before(:each) do
+        @app.should_receive(:call).and_raise(OhNoes)
+      end
+
+      it 'logs the exception' do
+        @logger.should_receive(:error)
+        lambda {
+          @middleware.call({})
+        }.should raise_error
+      end
+    end
+
+    context 'when Sinatra stores an exception' do
+      before(:each) do
+        @app.should_receive(:call).and_return([500, {}, 'body'])
+        @env['sinatra.error'] = OhNoes.new
+      end
+
+      it 'logs the exception' do
+        @logger.should_receive(:info)
+        @logger.should_receive(:error)
+        @middleware.call(@env)
+      end
+    end
+
+    context 'Shard ID logging' do
+      before(:each) do
+        @logger = mock_logger
+      end
+
+      it 'logs X-Shard header if it is present' do
+        @env['HTTP_X_SHARD'] = '9'
+        @logger.should_receive(:info).with(FlexMock.on { |arg| arg.should =~ /Shard: 9;/ } )
+        @middleware.send(:log_request_begin, @logger, @env)
+      end
+
+      it 'logs "default" if X-Shard header is absent' do
+        @logger.should_receive(:info).with(FlexMock.on { |arg| arg.should =~ /Shard: default;/ } )
+        @middleware.send(:log_request_begin, @logger, @env)
+      end
+    end
+
+  end
+end

data/spec/rack/request_tracker_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe RightSupport::Rack::RequestTracker do
+  it 'has test coverage'
+end

data/spec/ruby/easy_singleton_spec.rb

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,98 @@
+#
+# 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