right_support 2.11.3 → 2.12.1

data/spec/data/mash_spec.rb

@@ -1,313 +0,0 @@
-require 'spec_helper'
-
-class AwesomeHash < Hash
-end
-
-describe RightSupport::Data::Mash do
-  subject { RightSupport::Data::Mash}
-  
-  before(:each) do
-    @hash = { "mash" => "indifferent", :hash => "different" }
-    @sub  = AwesomeHash.new("mash" => "indifferent", :hash => "different")
-  end
-
-  describe "#initialize" do
-    it 'converts all keys into strings when param is a Hash' do
-      mash = subject.new(@hash)
-
-      mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
-    end
-
-    it 'converts all pure Hash values into Mashes if param is a Hash' do
-      mash = subject.new :hash => @hash
-
-      mash["hash"].should be_an_instance_of(subject)
-      # sanity check
-      mash["hash"]["hash"].should == "different"
-    end
-
-    it 'doesn not convert Hash subclass values into Mashes' do
-      mash = subject.new :sub => @sub
-      mash["sub"].should be_an_instance_of(AwesomeHash)
-    end
-
-    it 'converts all value items if value is an Array' do
-      mash = subject.new :arry => { :hash => [@hash] }
-
-      mash["arry"].should be_an_instance_of(subject)
-      # sanity check
-      mash["arry"]["hash"].first["hash"].should == "different"
-
-    end
-
-    it 'delegates to superclass constructor if param is not a Hash' do
-      mash = subject.new("dash berlin")
-
-      mash["unexisting key"].should == "dash berlin"
-    end
-  end # describe "#initialize"
-
-
-
-  describe "#update" do
-    it 'converts all keys into strings when param is a Hash' do
-      mash = subject.new(@hash)
-      mash.update("starry" => "night")
-
-      mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
-    end
-
-    it 'converts all Hash values into Mashes if param is a Hash' do
-      mash = subject.new :hash => @hash
-      mash.update(:hash => { :hash => "is buggy in Ruby 1.8.6" })
-
-      mash["hash"].should be_an_instance_of(subject)
-    end
-  end # describe "#update"
-
-
-
-  describe "#[]=" do
-    it 'converts key into string' do
-      mash = subject.new(@hash)
-      mash[:hash] = { "starry" => "night" }
-
-      mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
-    end
-
-    it 'converts all Hash value into subject' do
-      mash = subject.new :hash => @hash
-      mash[:hash] = { :hash => "is buggy in Ruby 1.8.6" }
-
-      mash["hash"].should be_an_instance_of(subject)
-    end
-  end # describe "#[]="
-
-
-
-  describe "#key?" do
-    before(:each) do
-      @mash = subject.new(@hash)
-    end
-
-    it 'converts key before lookup' do
-      @mash.key?("mash").should be(true)
-      @mash.key?(:mash).should be(true)
-
-      @mash.key?("hash").should be(true)
-      @mash.key?(:hash).should be(true)
-
-      @mash.key?(:rainclouds).should be(false)
-      @mash.key?("rainclouds").should be(false)
-    end
-
-    it 'is aliased as include?' do
-      @mash.include?("mash").should be(true)
-      @mash.include?(:mash).should be(true)
-
-      @mash.include?("hash").should be(true)
-      @mash.include?(:hash).should be(true)
-
-      @mash.include?(:rainclouds).should be(false)
-      @mash.include?("rainclouds").should be(false)
-    end
-
-    it 'is aliased as member?' do
-      @mash.member?("mash").should be(true)
-      @mash.member?(:mash).should be(true)
-
-      @mash.member?("hash").should be(true)
-      @mash.member?(:hash).should be(true)
-
-      @mash.member?(:rainclouds).should be(false)
-      @mash.member?("rainclouds").should be(false)
-    end
-  end # describe "#key?"
-
-
-  describe "#dup" do
-    it 'returns instance of subject' do
-      subject.new(@hash).dup.should be_an_instance_of(subject)
-    end
-
-    it 'preserves keys' do
-      mash = subject.new(@hash)
-      dup  = mash.dup
-
-      mash.keys.sort.should == dup.keys.sort
-    end
-
-    it 'preserves value' do
-      mash = subject.new(@hash)
-      dup  = mash.dup
-
-      mash.values.sort.should == dup.values.sort
-    end
-  end
-
-
-
-  describe "#to_hash" do
-    it 'returns instance of subject' do
-      subject.new(@hash).to_hash.should be_an_instance_of(Hash)
-    end
-
-    it 'preserves keys' do
-      mash = subject.new(@hash)
-      converted  = mash.to_hash
-
-      mash.keys.sort.should == converted.keys.sort
-    end
-
-    it 'preserves value' do
-      mash = subject.new(@hash)
-      converted = mash.to_hash
-
-      mash.values.sort.should == converted.values.sort
-    end
-  end
-
-
-
-  describe "#symbolize_keys" do
-    it 'returns instance of subject' do
-      subject.new(@hash).symbolize_keys.should be_an_instance_of(Hash)
-    end
-
-    it 'converts keys to symbols' do
-      mash = subject.new(@hash)
-      converted  = mash.symbolize_keys
-
-      converted_keys = converted.keys.sort{|k1, k2| k1.to_s <=> k2.to_s}
-      orig_keys = mash.keys.map{|k| k.to_sym}.sort{|i1, i2| i1.to_s <=> i2.to_s}
-
-      converted_keys.should == orig_keys
-    end
-
-    it 'preserves value' do
-      mash = subject.new(@hash)
-      converted = mash.symbolize_keys
-
-      mash.values.sort.should == converted.values.sort
-    end
-  end
-
-
-
-  describe "#delete" do
-    it 'converts Symbol key into String before deleting' do
-      mash = subject.new(@hash)
-
-      mash.delete(:hash)
-      mash.key?("hash").should be(false)
-    end
-
-    it 'works with String keys as well' do
-      mash = subject.new(@hash)
-
-      mash.delete("mash")
-      mash.key?("mash").should be(false)
-    end
-  end
-
-
-
-  describe "#except" do
-    it "converts Symbol key into String before calling super" do
-      mash = subject.new(@hash)
-
-      hashless_mash = mash.except(:hash)
-      hashless_mash.key?("hash").should be(false)
-    end
-
-    it "works with String keys as well" do
-      mash = subject.new(@hash)
-
-      mashless_mash = mash.except("mash")
-      mashless_mash.key?("mash").should be(false)
-    end
-
-    it "works with multiple keys" do
-      mash = subject.new(@hash)
-
-      mashless = mash.except("hash", :mash)
-      mashless.key?(:hash).should be(false)
-      mashless.key?("mash").should be(false)
-    end
-
-    it "should return a mash" do
-      mash = subject.new(@hash)
-
-      hashless_mash = mash.except(:hash)
-      hashless_mash.class.should be(subject)
-    end
-  end
-
-
-
-  describe "#merge" do
-    before(:each) do
-      @mash = subject.new(@hash).merge(:no => "in between")
-    end
-
-    it 'returns instance of subject' do
-      @mash.should be_an_instance_of(subject)
-    end
-
-    it 'merges in give Hash' do
-      @mash["no"].should == "in between"
-    end
-  end
-
-
-
-  describe "#fetch" do
-    before(:each) do
-      @mash = subject.new(@hash).merge(:no => "in between")
-    end
-
-    it 'converts key before fetching' do
-      @mash.fetch("no").should == "in between"
-    end
-
-    it 'returns alternative value if key lookup fails' do
-      @mash.fetch("flying", "screwdriver").should == "screwdriver"
-    end
-  end
-
-
-  describe "#default" do
-    before(:each) do
-      @mash = subject.new(:yet_another_technical_revolution)
-    end
-
-    it 'returns default value unless key exists in mash' do
-      @mash.default("peak oil is now behind, baby").should == :yet_another_technical_revolution
-    end
-
-    it 'returns existing value if key is Symbol and exists in mash' do
-      @mash.update(:no => "in between")
-      @mash.default(:no).should == "in between"
-    end
-  end
-
-
-  describe "#values_at" do
-    before(:each) do
-      @mash = subject.new(@hash).merge(:no => "in between")
-    end
-
-    it 'is indifferent to whether keys are strings or symbols' do
-      @mash.values_at("hash", :mash, :no).should == ["different", "indifferent", "in between"]
-    end
-  end
-
-
-  describe "#stringify_keys!" do
-    it 'returns the mash itself' do
-      mash = subject.new(@hash)
-
-      mash.stringify_keys!.object_id.should == mash.object_id
-    end
-  end
-end

data/spec/data/token_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::Data::Token do
-
-  context :generate do
-    let(:match) { /^[0-9a-zA-Z]{13}$/ }
-
-    subject { described_class }
-
-    it 'generates UUIDs' do
-      seen = {}
-      100.times do
-        actual = subject.generate
-        actual.should =~ match
-        seen[actual].should be_nil
-        seen[actual] = true
-      end
-    end
-  end
-
-end

data/spec/data/uuid_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::Data::UUID do
-  subject { RightSupport::Data::UUID }
-
-  VALID_UUID = /[0-9a-f-]+/ #we're not too picky here...
-
-  context :generate do
-    context 'when no implementation is available' do
-      it 'raises Unavailable' do
-        flexmock(subject).should_receive(:implementation).and_return(nil)
-        lambda {
-          subject.generate
-        }.should raise_error(subject::Unavailable)
-      end
-    end
-
-    context 'when SimpleUUID is available' do
-      it 'generates UUIDs' do
-        subject.implementation = subject::SimpleUUID
-        subject.generate.should =~ VALID_UUID
-      end
-    end
-
-    context 'when UUIDTools v1 is available' do
-      it 'generates UUIDs' do
-        pending #need to rework tests to test 2 versions of 1 gem!
-      end
-    end
-
-    context 'when UUIDTools v2 is available' do
-      it 'generates UUIDs' do
-        subject.implementation = subject::UUIDTools2
-        subject.generate.should =~ VALID_UUID
-      end
-    end
-
-    context 'when UUID gem is available' do
-      it 'generates UUIDs' do
-        subject.implementation = subject::UUIDGem
-        subject.generate.should =~ VALID_UUID
-      end
-    end
-  end
-end

data/spec/db/cassandra_model_part1_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::DB::CassandraModel do
-
-  class Cassandra
-    class OrderedHash < Hash
-      def keys
-        super.sort
-      end
-    end
-  end
-
-  context "config" do
-    let(:config) {  {'test' => {'server' => 'connection'} \
-                    ,'developemnt' => {'server' => 'connection1'}} }
-    
-    ['test', 'developemnt'].each do |env|
-      it "should return correct env: #{env.inspect} config" do
-        RightSupport::DB::CassandraModel.config = config
-        old_rack_env = ENV['RACK_ENV']
-        ENV['RACK_ENV'] = env
-        config[env].should ==  RightSupport::DB::CassandraModel.env_config
-        ENV['RACK_ENV'] = old_rack_env
-      end
-    end
-
-    it "should raise error if config not set or not Hash" do
-        old_rack_env = ENV['RACK_ENV']
-        RightSupport::DB::CassandraModel.config = nil
-        ENV['RACK_ENV'] = 'nil_config'
-        lambda {
-          RightSupport::DB::CassandraModel.env_config
-        }.should raise_error RightSupport::DB::MissingConfiguration
-
-        ENV['RACK_ENV'] = old_rack_env
-    end
-
-    it "should raise error if no configuration find" do
-        RightSupport::DB::CassandraModel.config = config
-        old_rack_env = ENV['RACK_ENV']
-        ENV['RACK_ENV'] = 'super_environment'
-        lambda {
-          RightSupport::DB::CassandraModel.env_config
-        }.should raise_error RightSupport::DB::MissingConfiguration
-        ENV['RACK_ENV'] = old_rack_env
-    end
-
-  end
-
-  context "initialize" do
-    let(:env) { 'server_config' }
-    let(:column_family) { 'server_config_column_family' }
-    let(:default_keyspace) { 'ServerConfigSatelliteService' }
-    let(:default_keyspace_connection) { flexmock('cassandra') }
-
-    {
-      '[ring1, ring2, ring3]' => ['ring1', 'ring2', 'ring3'] \
-     ,'ring1, ring2, ring3' => ['ring1', 'ring2', 'ring3'] \
-     ,['ring1', 'ring2', 'ring3'] => ['ring1', 'ring2', 'ring3']
-    }.each do |config_string, congig_test|
-      it "should successfully intialize from #{config_string.inspect}" do
-
-
-        old_rack_env = ENV['RACK_ENV']
-        begin
-          ENV['RACK_ENV'] = env
-
-          flexmock(Cassandra).should_receive(:new).with(/#{default_keyspace}_#{env}/, congig_test , {:timeout=>20, :server_retry_period=>nil}).and_return(default_keyspace_connection)
-          default_keyspace_connection.should_receive(:disable_node_auto_discovery!).and_return(true)
-        
-
-          RightSupport::DB::CassandraModel.config = {env => {"server" => config_string}}
-          RightSupport::DB::CassandraModel.keyspace = default_keyspace
-          RightSupport::DB::CassandraModel.reconnect
-
-        ensure
-          ENV['RACK_ENV'] = old_rack_env
-        end
-
-
-      end
-    end
-  end
-end

data/spec/db/cassandra_model_part2_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::DB::CassandraModel do
-
-  class Cassandra
-    class OrderedHash < Hash
-      def keys
-        super.sort
-      end
-    end
-  end
-
-  describe "do_op() logging" do
-
-    before(:each) do
-      @logger = flexmock(:logger)
-      flexmock(RightSupport::Log::Mixin).should_receive(:default_logger).and_return(@logger)
-      @logger.should_receive(:debug).with(String)
-      @conn = flexmock(:connection)
-      flexmock(RightSupport::DB::CassandraModel).should_receive(:conn).and_return(@conn)
-      @conn.should_receive(:multi_get).and_return(true)
-      @conn.should_receive(:get).and_return(true)
-      @conn.should_receive(:get_indexed_slices).and_return(true)
-      @conn.should_receive(:get_columns).and_return(true)
-      @conn.should_receive(:insert).and_return(true)
-      @conn.should_receive(:remove).and_return(true)
-    end
-
-    it "logs requests" do
-      [:multi_get, :get, :get_indexed_slices, :get_columns, :insert, :remove].each do |method|
-        RightSupport::DB::CassandraModel.do_op(method,'test_column_family', 'test_key')
-      end
-    end
-
-  end
-
-  context "do_op_log" do
-    before(:each) do
-      @logger = flexmock(:logger)
-      flexmock(RightSupport::Log::Mixin).should_receive(:default_logger).and_return(@logger)
-      flexmock(Time).should_receive(:now).and_return(100.010)
-    end
-
-    it "should display size for the keys if they are array" do
-      first_started_at = 100.0
-      started_at = 100.0
-      @logger.should_receive(:debug).with("CassandraModel get, cf=cf_name, keys=5, time=10.0ms")
-      RightSupport::DB::CassandraModel.do_op_log(first_started_at, started_at, 0, :get, 'cf_name', [1,2,3,4,5])
-    end
-
-    it "should display size for the key equal 1 if not array" do
-      first_started_at = 100.0
-      started_at = 100.0
-      @logger.should_receive(:debug).with("CassandraModel get, cf=cf_name, keys=1, time=10.0ms")
-      RightSupport::DB::CassandraModel.do_op_log(first_started_at, started_at, 0, :get, 'cf_name', "10")
-    end
-
-  	it "should display attemps time in milliseconds (ms)" do
-      first_started_at = 100.0
-      started_at = 100.0
-      @logger.should_receive(:debug).with("CassandraModel get, cf=cf_name, keys=1, time=10.0ms")
-      RightSupport::DB::CassandraModel.do_op_log(first_started_at, started_at, 0, :get, 'cf_name', [11])
-    end
-
-    it "should display total time milliseconds (s)" do
-      first_started_at = 99.0
-      started_at = 100.0
-      @logger.should_receive(:debug).with("CassandraModel get, cf=cf_name, keys=1, time=10.0ms, retries=1, total_time=1010.0ms")
-      RightSupport::DB::CassandraModel.do_op_log(first_started_at, started_at, 1, :get, 'cf_name', [11])
-    end
-
-  end
-end