right_support 2.11.3 → 2.12.1

data/spec/net/s3_helper_spec.rb

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

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

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

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

data/spec/rack/request_logger_spec.rb

@@ -1,225 +0,0 @@
-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}
-    @options = {}
-  end
-
-  subject { described_class.new(@app, @options) }
-
-  context :initialize do
-    context 'without :logger option' do
-      it 'uses rack.logger' do
-        @logger.should_receive(:info).at_least.once
-        subject.call(@env).should == [200, {}, 'body']
-      end
-    end
-
-    context 'with :logger option' do
-      it 'uses given logger' do
-        @env = {'rack.logger' => flexmock('overridden')}
-        @options[:logger] = @logger
-        @logger.should_receive(:info).at_least.once
-        subject.call(@env).should == [200, {}, 'body']
-      end
-    end
-
-    context 'with :normalize_40x option' do
-      it 'omits some 40x details and disables global session Set-Cookie fields' do
-        @options[:normalize_40x] = true
-        @app = flexmock('Rack app')
-        body = 'insecure information'
-        headers = { 'TooMuch' => 'info', 'Content-Type' => 'text/plain', 'Content-Length' => body.bytesize.to_s }
-        iterative = [nil, headers, body]
-        @app.should_receive(:call).and_return(iterative)
-
-        # note that sending 'X-Debug' header should have no effect on a
-        # normalized 40x response
-        @env.merge!(described_class::DEBUG_MODE_HTTP_HEADER => 'true')
-        (400..499).each do |code|
-          iterative[0] = code
-          if described_class::NORMALIZE_40X.include?(code)
-            env = @env.dup
-            subject.call(env).should == [code, { 'Content-Length' => '0'}, []]
-            env.should == @env.merge(
-              'global_session.req.renew' => false,
-              'global_session.req.update' => false,
-              described_class::DEBUG_MODE_ENV_KEY => false)
-          else
-            subject.call(@env).should == iterative
-          end
-        end
-      end
-    end
-
-    context 'with :normalize_40x_set_cookie option' do
-      it 'disables global session Set-Cookie fields' do
-        @options[:normalize_40x_set_cookie] = true
-        @app = flexmock('Rack app')
-        body = 'whatever'
-        headers = { 'Content-Type' => 'text/plain', 'Content-Length' => body.bytesize.to_s }
-        iterative = [nil, headers, body]
-        @app.should_receive(:call).and_return(iterative)
-
-        (400..499).each do |code|
-          iterative[0] = code
-          if described_class::NORMALIZE_40X.include?(code)
-            env = @env.dup
-            subject.call(env).should == iterative
-            env.should == @env.merge(
-              'global_session.req.renew' => false,
-              'global_session.req.update' => false)
-          else
-            subject.call(@env).should == iterative
-          end
-        end
-      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).at_least.once
-        lambda {
-          subject.call(@env)
-        }.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).at_least.once
-        subject.call(@env)
-      end
-
-      it 'skips logging the exception when already handled' do
-        @logger.should_receive(:info)
-        @logger.should_receive(:error).never
-        @env['sinatra.error.handled'] = true
-        subject.call(@env)
-      end
-    end
-
-    context 'given limiting options' do
-      before(:each) do
-        @options = {:except => [/bar/]}
-        @env.merge!('PATH_INFO' => '/foo/bar')
-        subject = described_class.new(@app, @options)
-        @logger.should_receive(:level).and_return(Logger::INFO).by_default
-      end
-
-      it 'limits if logger in debug mode' do
-        @logger.should_receive(:level).and_return(Logger::DEBUG)
-        @logger.should_receive(:info).never
-        subject.call(@env)
-      end
-
-      it 'does not limit if HTTP_X_DEBUG set' do
-        @logger.should_receive(:info).at_least.once
-        subject.call(@env.merge('HTTP_X_DEBUG' => true))
-      end
-
-      it 'does not log for paths matching :except option' do
-        @logger.should_receive(:info).never
-        subject.call(@env)
-      end
-
-      it 'does log for paths matching :only option' do
-        @options = {:only => [/bar/]}
-        subject = described_class.new(@app, @options)
-        @logger.should_receive(:info)
-        subject.call(@env)
-      end
-
-      it 'sets rack.logging.enabled in Rack environment' do
-        @logger.should_receive(:info).at_least.once
-        @env.merge!('PATH_INFO' => '/my/app')
-        subject.call(@env)
-        @env['rack.logging.enabled'].should be_true
-      end
-    end
-
-    context 'when logging the query string' do
-      before(:each) do
-        @options = {}
-        @env.merge!('PATH_INFO' => '/my/app', 'QUERY_STRING' => 'foo=bar')
-        subject = described_class.new(@app, @options)
-      end
-
-      it 'does not log the query string by default' do
-        @logger.should_receive(:info).with(FlexMock.on { |arg| arg.should =~ /\/my\/app\?\.{3}/ } )
-        subject.send(:log_request_begin, @logger, @env)
-      end
-
-      context 'when the include_query_string option is true' do
-        it 'logs the query string' do
-          @options[:include_query_string] = true
-          subject = described_class.new(@app, @options)
-          @logger.should_receive(:info).with(FlexMock.on { |arg| arg.should =~ /\/my\/app\?foo%3Dbar/ } )
-          subject.send(:log_request_begin, @logger, @env)
-        end
-      end
-
-      context 'when the include_query_string option is false' do
-        it 'does not log the query string' do
-          @options[:include_query_string] = false
-          subject = described_class.new(@app, @options)
-          @logger.should_receive(:info).with(FlexMock.on { |arg| arg.should =~ /\/my\/app\?\.{3}/ } )
-          subject.send(:log_request_begin, @logger, @env)
-        end
-      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$/ } )
-        subject.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$/ } )
-        subject.send(:log_request_begin, @logger, @env)
-      end
-    end
-
-    context 'request ID logging' do
-      before(:each) do
-        @logger = mock_logger
-        @env['rack.request_uuid'] = 'some-uuid'
-      end
-
-      it 'tags the Started line' do
-        @logger.should_receive(:info).with(FlexMock.on { |arg| arg.should =~ /^\[some\-uuid\] Started / } )
-        subject.send(:log_request_begin, @logger, @env)
-      end
-
-      it 'tags the Completed line' do
-        @logger.should_receive(:info).with(FlexMock.on { |arg| arg.should =~ /^\[some\-uuid\] Completed / } )
-        subject.send(:log_request_end, @logger, @env, 200, {}, '', Time.now)
-      end
-    end
-
-  end
-end

data/spec/rack/request_tracker_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::Rack::RequestTracker do
-
-  let(:app) { flexmock('next middleware or rack app') }
-
-  let(:generator)              { described_class::Generator }
-  let(:generated_request_uuid) { 'generated-uuid' }
-  let(:request_uuid)           { 'given-uuid' }
-
-  subject { described_class.new(app) }
-
-  context :call do
-    context 'when ID is missing from request headers' do
-      it 'generates a new request ID and responds as UUID for legacy reasons' do
-        flexmock(generator).
-          should_receive(:generate).
-          and_return(generated_request_uuid).
-          once
-        original_env = {}
-        expected_env = original_env.merge(described_class::REQUEST_UUID_ENV_NAME => generated_request_uuid)
-        app.should_receive(:call).with(expected_env).and_return([200, {}, 'body']).once
-
-        actual = subject.call(original_env)
-
-        expected_headers = { described_class::REQUEST_UUID_HEADER => generated_request_uuid }
-        actual[1].should == expected_headers
-      end
-    end
-
-    context 'when ID sent with request' do
-      it 'passes incoming request ID and responds as ID' do
-        flexmock(generator).should_receive(:generate).never
-        original_env = { described_class::HTTP_REQUEST_ID_HEADER => request_uuid }
-        expected_env = original_env.merge(described_class::REQUEST_UUID_ENV_NAME => request_uuid)
-        app.should_receive(:call).with(expected_env).and_return([200, {}, 'body']).once
-
-        actual = subject.call(original_env)
-
-        expected_headers = { described_class::REQUEST_ID_HEADER => request_uuid }
-        actual[1].should == expected_headers
-      end
-    end
-
-    context 'when UUID sent with request' do
-      it 'passes incoming request UUID and responds as UUID' do
-        flexmock(generator).should_receive(:generate).never
-        original_env = { described_class::HTTP_REQUEST_UUID_HEADER => request_uuid }
-        expected_env = original_env.merge(described_class::REQUEST_UUID_ENV_NAME => request_uuid)
-        app.should_receive(:call).with(expected_env).and_return([200, {}, 'body']).once
-
-        actual = subject.call(original_env)
-
-        expected_headers = { described_class::REQUEST_UUID_HEADER => request_uuid }
-        actual[1].should == expected_headers
-      end
-    end
-
-    context 'when lineage sent with request' do
-      it 'passes all UUIDs in header under length limit' do
-        uuids = []
-        3.times do
-          uuids << ::RightSupport::Data::UUID.generate
-        end
-        lineage_uuid = uuids.join(described_class::UUID_SEPARATOR)
-        flexmock(generator).should_receive(:generate).never
-        original_env = { described_class::REQUEST_LINEAGE_UUID_HEADER => lineage_uuid }
-        expected_env = original_env.merge(described_class::REQUEST_UUID_ENV_NAME => lineage_uuid)
-        app.should_receive(:call).with(expected_env).and_return([200, {}, 'body']).once
-
-        actual = subject.call(original_env)
-
-        expected_headers = { described_class::REQUEST_UUID_HEADER => lineage_uuid }
-        actual[1].should == expected_headers
-      end
-    end
-
-    context 'when sent ID exceeds length limit' do
-      it 'passes truncated request ID' do
-        flexmock(generator).should_receive(:generate).never
-        too_long_id = 'x' * 1024
-        truncated_id = 'x' * described_class::MAX_REQUEST_UUID_LENGTH
-        original_env = { described_class::HTTP_REQUEST_ID_HEADER => too_long_id }
-        expected_env = original_env.merge(described_class::REQUEST_UUID_ENV_NAME => truncated_id)
-        app.should_receive(:call).with(expected_env).and_return([200, {}, 'body']).once
-
-        actual = subject.call(original_env)
-
-        expected_headers = { described_class::REQUEST_ID_HEADER => truncated_id }
-        actual[1].should == expected_headers
-      end
-    end
-
-  end
-
-  context :copy_request_uuid do
-    it 'does nothing when request UUID is missing' do
-      described_class.copy_request_uuid(nil, nil).should be_empty
-    end
-
-    it 'copies request UUID to target hash when present' do
-      env = {
-        described_class::REQUEST_UUID_ENV_NAME => request_uuid,
-        'other' => 'stuff'
-      }
-      other_headers = { 'Foo' => 'bar' }
-      expected = {
-        described_class::REQUEST_ID_HEADER => request_uuid
-      }.merge(other_headers)
-      actual = described_class.copy_request_uuid(env, other_headers)
-      actual.should == expected
-    end
-  end
-
-end

data/spec/rack/runtime_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-class FasterApp
-  def self.call(env)
-    sleep 0.05; [200, {}, "50ms"]
-  end
-end
-
-class SlowerApp
-  def self.call(env)
-    sleep 0.2; [200, {}, "200ms"]
-  end
-end
-
-describe RightSupport::Rack::Runtime do
-  before(:each) do
-    @app = flexmock('Rack app')
-    @app.should_receive(:call).and_return([200, {}, 'body']).by_default
-    @env = {'rack.logger' => @logger}
-    @middleware = RightSupport::Rack::Runtime.new(@app)
-  end
-
-  context :call do
-    it 'sets an X-Runtime header in response' do
-      @middleware.call(@env).should == [200, {"X-Runtime"=>"0"}, 'body']
-    end
-
-    it 'sets a correct X-Runtime value for 50 ms app' do
-      faster = RightSupport::Rack::Runtime.new(FasterApp)
-      result = faster.call(@env)
-      result[1].keys.should == ['X-Runtime']
-      result[1]['X-Runtime'].to_i.should >= 50
-      result[1]['X-Runtime'].to_i.should < 70
-    end
-
-    it 'sets a correct X-Runtime value for 200 ms app' do
-      slower = RightSupport::Rack::Runtime.new(SlowerApp)
-      result = slower.call(@env)
-      result[1].keys.should == ['X-Runtime']
-      result[1]['X-Runtime'].to_i.should >= 200
-      result[1]['X-Runtime'].to_i.should < 270
-    end
-
-    it 'allows appending custom name to X-Runtime header' do
-      customized = RightSupport::Rack::Runtime.new(@app, "Test")
-      customized.call(@env).should == [200, {"X-Runtime-Test"=>"0"}, 'body']
-    end
-  end
-end