right_support 2.6.17 → 2.7.0

data/spec/db/cassandra_model_spec.rb

@@ -0,0 +1,359 @@
+require 'spec_helper'
+
+describe RightSupport::DB::CassandraModel do
+
+  class Cassandra
+    class OrderedHash < Hash
+      def keys
+        super.sort
+      end
+    end
+  end
+
+  def init_app_state(column_family,keyspace,server,env)
+    ENV["RACK_ENV"] = env
+    RightSupport::DB::CassandraModel.column_family = column_family
+    RightSupport::DB::CassandraModel.keyspace = keyspace
+    RightSupport::DB::CassandraModel.config = {"#{env}" => {"server" => server}}
+  end
+
+  context "initialization" do
+    # This method determines the current keyspace based on the return value of the CassandraModel.keyspace method
+    # which looks at the value of @@current_keyspace or @@default_keyspace to determine the keyspace it is operating
+    # under. If a connection already exists for the keyspace it will re-use it.  If a connection does not exist,
+    # it will create a new persistent connection for that keyspace that can be re-used with future requests
+    context :conn do
+      let(:column_family) { 'column_family' }
+      let(:env) { 'test' }
+      let(:server) { 'localhost:9160' }
+      let(:keyspace) { 'SatelliteService_1' }
+      let(:default_keyspace) { 'SatelliteService' }
+      let(:current_keyspace_connection) { flexmock('cassandra') }
+      let(:default_keyspace_connection) { flexmock('cassandra') }
+
+      before(:each) do
+        ENV["RACK_ENV"] = env
+        RightSupport::DB::CassandraModel.column_family = column_family
+        RightSupport::DB::CassandraModel.keyspace = default_keyspace
+        RightSupport::DB::CassandraModel.config = {env => {"server" => server}}
+
+        current_keyspace_connection.should_receive(:disable_node_auto_discovery!).and_return(true)
+        current_keyspace_connection.should_receive(:name).and_return('connection1')
+
+        default_keyspace_connection.should_receive(:disable_node_auto_discovery!).and_return(true)
+        default_keyspace_connection.should_receive(:name).and_return('connection2')
+
+        flexmock(Cassandra).should_receive(:new).with(keyspace + '_' + (ENV['RACK_ENV'] || 'development'), "localhost:9160", {:timeout=>10}).and_return(current_keyspace_connection)
+        flexmock(Cassandra).should_receive(:new).with(default_keyspace + '_' + (ENV['RACK_ENV'] || 'development'), "localhost:9160", {:timeout=>10}).and_return(default_keyspace_connection)
+      end
+
+      it 'raises a meaningful exception when a config stanza is missing' do
+        old_rack_env = ENV['RACK_ENV']
+
+        begin
+          ENV['RACK_ENV'] = 'foobar_12345'
+          bad_proc = lambda { RightSupport::DB::CassandraModel.reconnect }
+          bad_proc.should raise_error(RightSupport::DB::MissingConfiguration)
+          # This must be the very first attempt to call #conn during the execution of this spec
+          bad_proc = lambda { RightSupport::DB::CassandraModel.conn }
+          bad_proc.should raise_error(RightSupport::DB::MissingConfiguration)
+        ensure
+          ENV['RACK_ENV'] = old_rack_env
+        end
+      end
+
+      # This method assumes that keyspaces being requested to connect to already exist.
+      # If they do not exist, it should NOT create them.  If the connection is able
+      # to be successfully established then it should be stored in a pool of connections
+      it 'creates a new connection if no connection exists for provided keyspace' do
+        RightSupport::DB::CassandraModel.conn.name.should == default_keyspace_connection.name
+      end
+
+      # If a connection has already been opened for a keyspace it should be re-used
+      it 're-uses an existing connection if it exists for provided keyspace' do
+        RightSupport::DB::CassandraModel.conn.name.should == RightSupport::DB::CassandraModel.conn.name
+      end
+
+      # The keyspace being used for the connection should be either the current keyspace or the default keyspace
+      it 'uses the connection that corresponds to the provided keyspace' do
+        RightSupport::DB::CassandraModel.with_keyspace(keyspace) do
+          RightSupport::DB::CassandraModel.conn.name.should == current_keyspace_connection.name
+        end
+      end
+    end
+  end
+
+  context "use" do
+
+    before(:each) do
+      @column_family  = "TestApp"
+      @keyspace       = "TestAppService"
+      @server         = "localhost:9160"
+      @env            = "test"
+      @timeout        = {:timeout => RightSupport::DB::CassandraModel::DEFAULT_TIMEOUT}
+
+      init_app_state(@column_family, @keyspace, @server, @env)
+
+      @key            = 'key'
+      @value          = 'foo'
+      @offset         = 'bar'
+      @attrs          = {@offset => @value}
+      @opt            = {}
+      @get_opt        = {:count => RightSupport::DB::CassandraModel::DEFAULT_COUNT}
+
+      @instance = RightSupport::DB::CassandraModel.new(@key, @attrs)
+
+      @conn = flexmock(:connection)
+      flexmock(RightSupport::DB::CassandraModel).should_receive(:conn).and_return(@conn)
+      @conn.should_receive(:insert).with(@column_family, @key, @attrs,@opt).and_return(true)
+      @conn.should_receive(:remove).with(@column_family, @key).and_return(true)
+      @conn.should_receive(:get).with(@column_family, @key, @get_opt).and_return(@attrs).by_default
+      @conn.should_receive(:multi_get).with(@column_family, [1,2], @opt).and_return(Hash.new)
+    end
+
+    describe "instance methods" do
+      context :save do
+        it 'saves the row' do
+          @instance.save.should be_true
+        end
+      end
+
+      context :destroy do
+        it 'destroys the row' do
+          @instance.destroy.should be_true
+        end
+      end
+
+      context :reload do
+        it 'returns a new object for the row' do
+          @instance.reload.should be_a_kind_of(RightSupport::DB::CassandraModel)
+          @instance.reload!.should be_a_kind_of(RightSupport::DB::CassandraModel)
+        end
+      end
+    end
+
+    describe "class methods" do
+      # We want to remain backward-compatible for existing services so we expect this call to be made
+      # as such: RightSupport::DB::CassandraModel.keyspace = "SatelliteService" and CassandraModel
+      # will append the RACK_ENV to the end of it.  Ex: "SatelliteService_development"
+      context :keyspace= do
+        let(:keyspace) { 'SatelliteService' }
+
+        it 'appends the environment to the keyspace provided' do
+          RightSupport::DB::CassandraModel.keyspace = keyspace
+          RightSupport::DB::CassandraModel.send(:class_variable_get, :@@default_keyspace).should == (keyspace + "_" + (ENV['RACK_ENV'] || 'development'))
+        end
+      end
+
+      # If a current keyspace is provided it takes precedence over the default keyspace.  If none is
+      # provided, the default keyspace should be returned.
+      context :keyspace do
+        let(:keyspace) { 'SatelliteService_' + ENV['RACK_ENV'] }
+
+        it 'returns the default keyspace if no current keyspace is set' do
+          RightSupport::DB::CassandraModel.send(:class_variable_set, :@@current_keyspace, nil)
+          RightSupport::DB::CassandraModel.send(:class_variable_set, :@@default_keyspace, keyspace)
+          RightSupport::DB::CassandraModel.keyspace.should == keyspace
+        end
+
+        it 'returns the current keyspace if a current keyspace is set' do
+          RightSupport::DB::CassandraModel.send(:class_variable_set, :@@current_keyspace, keyspace)
+          RightSupport::DB::CassandraModel.send(:class_variable_set, :@@default_keyspace, nil)
+          RightSupport::DB::CassandraModel.keyspace.should == keyspace
+        end
+      end
+
+      # This method assumes that a valid keyspace is passed in.  If the keyspace does not exist we do NOT
+      # want to create it.  CassandraModel should use the keyspace provided for the duration of the code
+      # executed within the block.  Any requests processed outside of the block should execute using the
+      # default keyspace.
+      context :with_keyspace do
+        let(:keyspace) { 'SatelliteService_1' }
+        let(:default_keyspace) { 'SatelliteService' }
+
+        before(:each) do
+          RightSupport::DB::CassandraModel.keyspace = default_keyspace
+        end
+
+        it 'sets the current keyspace to the keyspace provided for execution within the block' do
+          RightSupport::DB::CassandraModel.with_keyspace(keyspace) do
+            RightSupport::DB::CassandraModel.keyspace.should == keyspace + "_" + 'test'
+          end
+        end
+
+        it 'resets back to the default keyspace for execution outside of the block' do
+          RightSupport::DB::CassandraModel.with_keyspace(keyspace) {}
+          RightSupport::DB::CassandraModel.keyspace.should == default_keyspace + "_" + 'test'
+        end
+        context 'append_env parameter' do
+          it 'appends the environment by default' do
+            RightSupport::DB::CassandraModel.with_keyspace('Monkey') do
+              RightSupport::DB::CassandraModel.keyspace.should == 'Monkey_test'
+            end
+          end
+
+          it 'appends the environment when append_env == true' do
+            RightSupport::DB::CassandraModel.with_keyspace('Monkey', true) do
+              RightSupport::DB::CassandraModel.keyspace.should == 'Monkey_test'
+            end
+          end
+
+          it 'does NOT append the environment when append_env == false' do
+            RightSupport::DB::CassandraModel.with_keyspace('Monkey_notatest', false) do
+              RightSupport::DB::CassandraModel.keyspace.should == 'Monkey_notatest'
+            end
+          end
+
+          it 'avoids double-appending the environment' do
+            RightSupport::DB::CassandraModel.with_keyspace('Monkey_test') do
+              RightSupport::DB::CassandraModel.keyspace.should == 'Monkey_test'
+            end
+          end
+        end
+      end
+
+      context :insert do
+        it 'inserts a row by using the class method' do
+          RightSupport::DB::CassandraModel.insert(@key, @attrs, @opt).should be_true
+        end
+      end
+
+      context :remove do
+        it 'removes a row by using the class method' do
+          RightSupport::DB::CassandraModel.remove(@key).should be_true
+        end
+      end
+
+      context :all do
+        it 'returns all existing rows for the specified array of keys' do
+          RightSupport::DB::CassandraModel.all([1, 2]).should be_a_kind_of(Hash)
+        end
+      end
+
+      context :get do
+        it 'returns row for the specified key' do
+          RightSupport::DB::CassandraModel.get(@key).should be_a_kind_of(RightSupport::DB::CassandraModel)
+        end
+
+        it 'returns only number of columns requested' do
+          attrs = {@offset + '1' => @value, @offset + '2' => @value}
+          get_opt = {:count => 2}
+          @conn.should_receive(:get).with(@column_family, @key, get_opt).and_return(attrs).once
+          RightSupport::DB::CassandraModel.get(@key, get_opt).attributes.should == attrs
+        end
+
+        it 'returns all columns for the specified key if no count specified' do
+          pending "Unpredictable behavior on ruby < 1.9" unless RUBY_VERSION >= "1.9"
+          default_count = RightSupport::DB::CassandraModel::DEFAULT_COUNT
+
+          RightSupport::DB::CassandraModel.instance_eval { remove_const :DEFAULT_COUNT }
+          RightSupport::DB::CassandraModel.const_set(:DEFAULT_COUNT, 2)
+          begin
+
+            attrs1 = {@offset + '1' => @value, @offset + '2' => @value}
+            attrs2 = {@offset + '3' => @value}
+            attrs = attrs1.merge(attrs2)
+            get_opt1 = {:count => 2}
+            get_opt2 = {:count => 2, :start => @offset + '2'}
+            @conn.should_receive(:get).with(@column_family, @key, get_opt1).and_return(attrs1).once
+            @conn.should_receive(:get).with(@column_family, @key, get_opt2).and_return(attrs2).once
+            RightSupport::DB::CassandraModel.get(@key).attributes.should == attrs
+          ensure
+            RightSupport::DB::CassandraModel.instance_eval { remove_const :DEFAULT_COUNT }
+            RightSupport::DB::CassandraModel.const_set(:DEFAULT_COUNT, default_count)
+          end
+        end
+
+        it 'returns nil if key not found' do
+          @conn.should_receive(:get).with(@column_family, @key, @get_opt).and_return({})
+          RightSupport::DB::CassandraModel.get(@key).should be_nil
+        end
+      end
+
+      def real_get_indexed(index, key, columns = nil, opt = {})
+        rows = {}
+        start = ""
+        count = DEFAULT_COUNT
+        expr = do_op(:create_idx_expr, index, key, "EQ")
+        opt = opt[:consistency] ? {:consistency => opt[:consistency]} : {}
+        while true
+          clause = do_op(:create_idx_clause, [expr], start, count)
+          chunk = do_op(:get_indexed_slices, column_family, clause, columns, opt)
+          rows.merge!(chunk)
+          if chunk.size == count
+            # Assume there are more chunks, use last key as start of next get
+            start = chunk.keys.last
+          else
+            # This must be the last chunk
+            break
+          end
+        end
+        rows
+      end
+
+      context :get_indexed do
+
+        before(:each) do
+          @column = flexmock(:column, :name => 'foo', :value => 'bar')
+          @column_or_super = flexmock(:column_or_super, :column => @column)
+          @rows = {@key => [@column_or_super]}
+          @index = 'index'
+          @index_key = 'index_key'
+          @start = ""
+          @count = RightSupport::DB::CassandraModel::DEFAULT_COUNT
+          @expr = flexmock(:expr)
+          @conn.should_receive(:create_idx_expr).and_return(@expr)
+          @clause = flexmock(:clause)
+          @conn.should_receive(:create_idx_clause).with([@expr], @start, @count).and_return(@clause).by_default
+          @conn.should_receive(:get_indexed_slices).with(@column_family, @clause, nil, {}).and_return(@rows).by_default
+        end
+
+        it 'returns row for the specified key' do
+          rows = RightSupport::DB::CassandraModel.get_indexed(@index, @index_key)
+          rows.should be_a_kind_of(Array)
+          rows.size.should == 1
+          rows.first.should be_a_kind_of(RightSupport::DB::CassandraModel)
+        end
+
+        it 'returns all rows for the specified key if no count specified' do
+          pending "Unpredictable behavior on ruby < 1.9" unless RUBY_VERSION >= "1.9"
+
+          default_count = RightSupport::DB::CassandraModel::DEFAULT_COUNT
+
+          RightSupport::DB::CassandraModel.instance_eval { remove_const :DEFAULT_COUNT }
+          RightSupport::DB::CassandraModel.const_set(:DEFAULT_COUNT, 2)
+          begin
+            key1 = @key + '8'
+            key2 = @key + '12'
+            key3 = @key + '13'
+            cols = {'foo' => 'bar'}
+            rows1 = {key1 => [@column_or_super], key2 => [@column_or_super]}
+            rows2 = {key3 => [@column_or_super]}
+            @conn.should_receive(:create_idx_clause).with([@expr], @start, 2).and_return(@clause).once
+            @conn.should_receive(:get_indexed_slices).with(@column_family, @clause, nil, {}).and_return(rows1).once
+            @conn.should_receive(:create_idx_clause).with([@expr], key2, 2).and_return(@clause).once
+            @conn.should_receive(:get_indexed_slices).with(@column_family, @clause, nil, {}).and_return(rows2).once
+            rows = RightSupport::DB::CassandraModel.get_indexed(@index, @index_key)
+            rows.size.should == 3
+            rows.inject({}) { |s, r| s[r.key] = r.attributes; s }.should == {key1 => cols, key2 => cols, key3 => cols}
+          ensure
+            RightSupport::DB::CassandraModel.instance_eval { remove_const :DEFAULT_COUNT }
+            RightSupport::DB::CassandraModel.const_set(:DEFAULT_COUNT, default_count)
+          end
+        end
+
+        it 'returns empty array if no rows found for key' do
+          @conn.should_receive(:get_indexed_slices).with(@column_family, @clause, nil, {}).and_return({}).once
+          RightSupport::DB::CassandraModel.get_indexed(@index, @index_key).should == []
+        end
+      end
+    end
+  end
+
+  context '.calculate_random_partitioner_token' do
+    it 'works' do
+      expected = 73001115008341200964825964898370608784
+      described_class.calculate_random_partitioner_token('71:foomonkeys').should == expected
+    end
+  end
+end

data/spec/fixtures/encrypted_priv_rsa.pem

@@ -0,0 +1,30 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,61C0BBB816A708D4
+
+SQ/Y+U7z51OL/hx4YnfVPl6uqsOjpSjU2w4NFqB6EyBtMFgOoqW6ryuIi6ycHgWJ
+YabUlMPdnexU+1BGqu9P2M9kQejfVddBFmbE09s54dwamk7q6RjaARN0UvHq6Ms9
+r5/nqRBrinWtOeU/+7cV5qGp2/HbWC2bHAUCCwBcq+ymEpLOw/dpHpxjuiB5ZOLt
+QzcEJ8ePlNDYvPxw4Wjvb5IDjS4MSoJfA5Y2ZXwVSI1d7mhx4Cekx3CkTMWKYIU8
+FS6hO39tfPTcxb4os3FYl8D8TlRHv5atrsptKqYE4DKhZhoDA5yFbFJHZlEp+G6H
+t+snMyuzEWNWq3wGI/gaglatUMq6airA50qticbw8kvz+67pPh2gkAgMXBHEGgPW
+m0xnqaWf+MyQCUfaxjvxAq68Ced+H9ULLYFrzWAIuSh1M+QartuvP1ZOIcDpY83i
+RybTJC5MLgGE0COM7oOtPfXO/rvdf6jqTr54HhYwq18aWrqjnacZi0JzNEFRtpNa
+5FNbwbQGT4Y8J1rOgbyjrd712oRhfjMAU39w4b6gEIATB4zDnMVkdb/Rde/nB7i4
+CqDB9iSEbtQN4Ev5fXpIDrmhbdT/CURpzRvIt68x08qvX8KQwqDbLz39luocApxN
+lnTihGiYAiNflMpDvhNL8MSLxYgL5Or2KVF/Ppc+1Qw23BEYDlaRRzc71PWdrVr8
+UxEdFtqQnnthO7PabrwmLiPeArIGL4U8wrbXA3GbkbDtClftWMaC9JrzVJvXp1z7
+sXZPhdZzSCg3n3ZbAGKYUx/G8AHojLKfAF3BHufnU9qM+6TS/KtTnhrvHSgYPcBn
+etI7DWZ/mUnLwnsWfiQ3n5PeeUq/nU+IFJT+Y3r+TfFVCiGPW60XpfLzH1U4otKq
+KaEnCQX6S7p1Jinx+FHL9fg1I50E6QUNO+N8XO4ay3Jzumz2yjZeudyt+uy954Hq
+RfmDGYImqrkYrzd8d6hNUTBGnUfUTvq2k/orKhvcxtX+tr9WhNshnJcK18SgBRKT
+6XLybyioikVSpUGsL95kIhrspryO8v7/M1igWWrLu9fe/jUJLCFzlbGSRYDn+QTp
+z7qpbBvxHPgu1fKurZ96nCcigVxQgY5rPwpQvG+mkD6YOhgDvSAjTos7Fagz6nb6
+01MufCVvFx+BBZEsol0Ag23RhXeJXvxkcF//hcPseCA/oB9Aqzyu+ml9mgp4v6P+
+AgVopgGCfZR31CQ2b9AxdSARFCj2AFE9AdeNy268KSx8wLWAlzUcnGi57eK8WJM3
+KTDOwJZDgZkjYyMZATpxOj8w3euAflQjQmyXpN1/Q0BW66Mj9+XzVk2yEpF2S0iE
+xKzPcNEzlGMo1xo6mqVE/kIuRSodXuGp5Eoo8ITvpYWcSdtCTSKJNxAUqry/k9bg
+9sf3jSmSHzUd92pdM02p8A42HcaPGLmbuFjIfZPK7KoYmIdhJqy7s08CFUlk9XI/
+PxdYph5J4WkAbeomPGUTFxEWV1cM2lvW4hotrx8MS50WLVZxxY1p7D+JxN3KeJyc
+mytYpg2dxr8UF64NFKuyEmunkDTdYH2Oi7B7mAcw/QlBN+qCARP+tA==
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/good_priv_dsa.pem

@@ -0,0 +1,12 @@
+-----BEGIN DSA PRIVATE KEY-----
+MIIBvAIBAAKBgQC1RlSYmT8VVtunF3xcpSdJfihaHAGzLH0nf2ooHcKIH6PyxjCe
+Q93rFB69uyGPUJVawz3w0Y1B7B6h5eXI4SEKA4iqmSHXdFonO7wvOT5DTkzQl3yX
+B1s4xU8+GW1MtUNKxHPzFpX40797Z1enO/EZRNLYt0P4IG86s/O+BqD6IwIVAJ24
+m8A6ZFqsunyy2L5o9UInE+gfAoGAPuEeCrIginLFwSdwyrxEwC/gblKvOf/9+iMB
+Jo+5fN2E9AHKrCsCa53E2lnUbXOdSKDR6yVmUQSB3EsBDoLqDOVJh/BWVTABebIO
+WwnjQZX9UBGnsJwD4zpvtXLU4qnyFywSr1kdLDHMsGS3WVocJ9jOEH7Rh0xMM423
+yYS4bUQCgYEApxLO5sTQS/Ej8+BFJQrMS3xHpONQxiMnTLE3q6qZXJRgHDgsqqwZ
+pAfZCjRxvvfUfBGzjKwJlGQOLZVaGZOArGQF7NRtOfCHZtMBg1vubewXs64gmH5G
+aXvJ17D6W2vCO04R/vXh43qKLDcPu7wGng+eWNaw/LkbdfC4k8uVfp4CFQCHe0yn
+rgxFphSFqf8Spchmsg/coA==
+-----END DSA PRIVATE KEY-----

data/spec/fixtures/good_priv_rsa.pem

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICWwIBAAKBgQDm4VY+mDoYUsH+7idaNXP6Bq+YIXwqGNar6zgbPEe6qgpF9nSQ
+B98gMObcZ9H7qGm3e/bQTCrlBAB/jMUQQbTyPsEy3pIKeWoPl7GTQpcSS9WZoHYX
+yf4TN8MMOeJ3rGbyGb8Xm13R+SBpOMOZfnT3KUJLznIYVtBvv+uFz/C9ewIDAQAB
+AoGAMJzLkvxsZwitziaI5KaSl9dmi4qpYRe/w40QUDO+CqCY7yg4XMc7hMSnJ0s4
+3FsWf0q7qhoPgg74p+KU75pWJbEHoYor6LqDuxov4DSx/2SfqmDBIAb9IQ4KWDr2
+WU/o2/ivbHJ89FxCCroMzNg+qm8pAHVYQ72E/w/1sSRuQPECQQD4fes0OrE8qlJ0
+0UCxiTbotreNY7N/pKPIFqL/+ODcXJIHCyvVAMXw469r9KacrC/t8qKNatWk3mP1
+uZzfoAJJAkEA7dsxOJcTqMAncOzbP2cXPkGvzyS06mUoziuZWDc+NAOy4R/V/xHW
++CUleXs06G9c/LoZ+E80MP600YvPtKUBowJAZXXMfnPkgDevGUGDX7n98IECazml
+Rd3sfbs4bLmq3m7xtOyLxhnduGDO9I5dJSVtIIPseT+A4iNnvyI9elVz+QJALTBe
+mpTBTGctVxv4z4Pje5V5NE6R/JI5fWn1GThtne4x9ulYe7xE7iIIi5rnw10c+nrU
+4kMR9Fj/u2vnizdqJwJACb7DY5rKZa/xgzgLtE5jW60zZWvwS9LYUs+1ND6CeiFy
+s3EiH2z+zbSO+cnMtCutdRKIHk3wy6tyRKOq0EMafA==
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/good_pub_dsa.ssh

@@ -0,0 +1 @@
+ssh-dss AAAAB3NzaC1kc3MAAACBALVGVJiZPxVW26cXfFylJ0l+KFocAbMsfSd/aigdwogfo/LGMJ5D3esUHr27IY9QlVrDPfDRjUHsHqHl5cjhIQoDiKqZIdd0Wic7vC85PkNOTNCXfJcHWzjFTz4ZbUy1Q0rEc/MWlfjTv3tnV6c78RlE0ti3Q/ggbzqz874GoPojAAAAFQCduJvAOmRarLp8sti+aPVCJxPoHwAAAIA+4R4KsiCKcsXBJ3DKvETAL+BuUq85//36IwEmj7l83YT0AcqsKwJrncTaWdRtc51IoNHrJWZRBIHcSwEOguoM5UmH8FZVMAF5sg5bCeNBlf1QEaewnAPjOm+1ctTiqfIXLBKvWR0sMcywZLdZWhwn2M4QftGHTEwzjbfJhLhtRAAAAIEApxLO5sTQS/Ej8+BFJQrMS3xHpONQxiMnTLE3q6qZXJRgHDgsqqwZpAfZCjRxvvfUfBGzjKwJlGQOLZVaGZOArGQF7NRtOfCHZtMBg1vubewXs64gmH5GaXvJ17D6W2vCO04R/vXh43qKLDcPu7wGng+eWNaw/LkbdfC4k8uVfp4= user@host

data/spec/fixtures/good_pub_rsa.pem

@@ -0,0 +1,5 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIGJAoGBAObhVj6YOhhSwf7uJ1o1c/oGr5ghfCoY1qvrOBs8R7qqCkX2dJAH3yAw
+5txn0fuoabd79tBMKuUEAH+MxRBBtPI+wTLekgp5ag+XsZNClxJL1ZmgdhfJ/hM3
+www54nesZvIZvxebXdH5IGk4w5l+dPcpQkvOchhW0G+/64XP8L17AgMBAAE=
+-----END RSA PUBLIC KEY-----

data/spec/fixtures/good_pub_rsa.ssh

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEApfGJ2lzcKgWq50u4yhZyP7yDjA4CF2pV19TUOlXg4a40FCuKi7JIqPCyixmrWYrvRFz+5zY+gHWOHkCfjNaDryUgPsBMzk2DZDD8fsrJ5KU7QDAa1RMbixnWsWTDcXGhHxC7jtRV7qKFvribLYEoUfVbWZYQR3Wl9kfc78sF6Z2TZuL2Fb9YJc5f2uDz6+I6oy8LtGci4Y2hKVYxrN5tgvFcwkE8JsRaAnjWicfoHRUIBZ/tdT76EMhBEKdO63hO9AZ8phTyZoJyLzykDRaelBUYXjG0LQXTq4jiJhKa07kv0XIgNwnz4zB9qtiOHXm6KZZDxy7xnVXOFum+JqcUxQ== user@host

data/spec/log/exception_logger_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe RightSupport::Log::ExceptionLogger do
+  before(:all) do
+    @actual_logger = Logger.new(StringIO.new)
+    @logger = RightSupport::Log::ExceptionLogger.new(@actual_logger)
+    @exception = Exception.new('message')
+  end
+
+  context :exception do
+    it 'logs an error with exception information' do
+      flexmock(@actual_logger).should_receive(:fatal)
+      @logger.exception('desc', @exception)
+    end
+  end
+
+  context 'class methods' do
+    context :format_exception do
+      it 'includes the description' do
+        RightSupport::Log::ExceptionLogger.format_exception('desc').should == 'desc'
+      end
+
+      it 'includes the exception message if present' do
+        e = ArgumentError.new("err")
+        RightSupport::Log::ExceptionLogger.format_exception('desc', e).should =~ /desc \(ArgumentError: err.*/
+      end
+
+      it 'includes the exception string if present' do
+        RightSupport::Log::ExceptionLogger.format_exception('desc', 'err', :no_trace).should == 'desc (err)'
+      end
+
+      context 'with backtrace=:no_trace' do
+        it 'does not include a backtrace' do
+          e = ArgumentError.new("err")
+          RightSupport::Log::ExceptionLogger.format_exception('desc', e, :no_trace).should == 'desc (ArgumentError: err)'
+        end
+      end
+
+      context 'with backtrace=:caller' do
+        it 'includes a single line of backtrace' do
+          begin
+            raise ArgumentError.new("err")
+          rescue Exception => e
+            RightSupport::Log::ExceptionLogger.format_exception('desc', e, :caller).should == "desc (ArgumentError: err IN #{e.backtrace[0]})"
+          end
+        end
+
+        it 'defaults to :caller trace' do
+          begin
+            raise ArgumentError.new("err")
+          rescue Exception => e
+            RightSupport::Log::ExceptionLogger.format_exception('desc', e).should == "desc (ArgumentError: err IN #{e.backtrace[0]})"
+          end
+        end
+
+        it 'excludes backtrace if the exception does not respond to backtrace' do
+          RightSupport::Log::ExceptionLogger.format_exception('desc', 'err').should == "desc (err)"
+        end
+      end
+
+      context 'with backtrace=:trace' do
+        it 'includes a full backtrace' do
+          begin
+            raise ArgumentError.new("err")
+          rescue Exception => e
+            RightSupport::Log::ExceptionLogger.format_exception('desc', e, :trace).should == "desc (ArgumentError: err IN\n  " + e.backtrace.join("\n  ") + ")"
+          end
+        end
+
+        it 'excludes backtrace if the exception does not respond to backtrace' do
+          RightSupport::Log::ExceptionLogger.format_exception('desc', 'err').should == "desc (err)"
+        end
+      end
+    end
+  end
+end

data/spec/log/filter_logger_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe RightSupport::Log::FilterLogger do
+  it 'does method_missing correctly'
+  it 'does respond_to? correctly'
+  it 'transparently proxies Logger methods to underlying object'
+  it 'filters log messages'
+end

data/spec/log/mixin_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+class InnocentVictim
+  include RightSupport::Log::Mixin
+end
+
+describe RightSupport::Log::Mixin do
+  context 'when mixed into a base class' do
+    before(:each) do
+      @victim = InnocentVictim.new
+    end
+
+    it 'provides a class-level accessor' do
+      @victim.class.should respond_to(:logger)
+      @victim.class.should respond_to(:logger=)
+    end
+
+    it 'provides an instance-level accessor' do
+      @victim.should respond_to(:logger)
+    end
+
+    context :logger do
+      context 'without a logger' do
+        before(:each) do
+          @victim.class.logger = nil
+        end
+
+        it 'uses the default logger' do
+          flexmock(RightSupport::Log::Mixin.default_logger).should_receive(:info).twice.and_return(true)
+          @victim.class.logger.info('lalalala').should be_true
+          @victim.logger.info('lalalala').should be_true
+        end
+      end
+
+      context 'with class logger' do
+        before(:each) do
+          @logger = mock_logger
+          @victim.class.logger = @logger
+        end
+
+        it 'uses class logger' do
+          @logger.should_receive(:info).and_return(true).twice
+          @victim.class.logger.info('lalalala').should be_true
+          @victim.logger.info('lalalala').should be_true
+        end
+
+        context 'with instance logger' do
+          before(:each) do
+            @instance_logger = mock_logger
+            @victim.logger = @instance_logger
+          end
+
+          it 'uses instance logger' do
+            @instance_logger.should_receive(:info).and_return(true).once
+            @logger.should_receive(:info).never
+            @victim.logger.info('lalalala').should be_true
+          end
+        end
+      end
+    end
+  end
+end

data/spec/log/multiplexer_spec.rb

@@ -0,0 +1,54 @@
+#
+# Copyright (c) 2009-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::Log::Multiplexer do
+
+  before(:all) do
+    @target1 = RightSupport::Log::NullLogger.new
+    @target2 = RightSupport::Log::NullLogger.new
+    @target3 = RightSupport::Log::NullLogger.new
+    @multiplexer = RightSupport::Log::Multiplexer.new(@target1, @target2, @target3)
+  end
+
+  it 'multiplexes method calls to all callers' do
+    flexmock(@target1).should_receive(:some_method).with('arg', 'arg2').once
+    flexmock(@target2).should_receive(:some_method).with('arg', 'arg2').once
+    flexmock(@target3).should_receive(:some_method).with('arg', 'arg2').once
+    @multiplexer.some_method('arg', 'arg2')
+  end
+
+  it 'returns the result returned by the first target' do
+    flexmock(@target1).should_receive(:some_method).with('arg', 'arg2').and_return('res1').once
+    flexmock(@target2).should_receive(:some_method).with('arg', 'arg2').and_return('res2').once
+    flexmock(@target3).should_receive(:some_method).with('arg', 'arg2').and_return('res3').once
+    @multiplexer.some_method('arg', 'arg2').should == 'res1'
+  end
+
+  it 'multiplexes #warn by undefining Object#warn' do
+    flexmock(@target1).should_receive(:warn).with('arg').and_return('res1')
+    flexmock(@target2).should_receive(:warn).with('arg').and_return('res2')
+    flexmock(@target3).should_receive(:warn).with('arg').and_return('res3')
+    @multiplexer.warn('arg').should == 'res1'
+  end
+end

data/spec/log/null_logger_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe RightSupport::Log::NullLogger do
+  before(:each) do
+    @logger = RightSupport::Log::NullLogger.new
+  end
+
+  context 'log levels' do
+    [:debug, :info, :warn, :error, :fatal].each do |method|
+      it "responds to ##{method}" do
+        block_called = false
+        @logger.__send__(method, 'lalalala').should be_true
+        @logger.__send__(method) { block_called = true ; 'lalalala' }.should be_true
+        block_called.should be_true
+      end
+    end
+  end
+
+  context '<< method' do
+    it 'responds like Logger' do
+      (@logger << 'lalalala').should == 8
+    end
+  end
+
+  context :close do
+    it 'responds' do
+      @logger.close.should be_nil
+    end
+
+    it 'is idempotent' do
+      @logger.close.should be_nil
+      @logger.close.should be_nil
+      @logger.close.should be_nil
+    end
+  end
+end