right_support 2.6.17 → 2.7.0

data/spec/data/hash_tools_spec.rb

@@ -0,0 +1,471 @@
+require 'spec_helper'
+
+module RightSupport::Data::HashToolsSpec
+
+  class BetterHash < Hash
+    def bells_and_whistles; true; end
+  end
+
+  class HashLike
+    def initialize; @inner_hash = {}; end
+    def has_key?(key); @inner_hash.has_key?(key); end
+    def [](key); @inner_hash[key]; end
+    def []=(key, value); @inner_hash[key] = value; end
+    def delete(key); @inner_hash.delete(key); end
+    def merge!(other); @inner_hash.merge!(other); self; end
+    def ==(other); @inner_hash == other; end
+  end
+
+  class DuplicableValue
+    def initialize(value); @value = value; end
+    attr_accessor :value
+    def duplicable?; true; end
+    def ==(other); other.kind_of?(DuplicableValue) && value == other.value; end
+  end
+
+end
+
+describe RightSupport::Data::HashTools do
+  subject { RightSupport::Data::HashTools }
+
+  context '#hashable?' do
+    it 'should be true for hashes' do
+      subject.hashable?({}).should be_true
+    end
+
+    it 'should be true for hash-based objects' do
+      subject.hashable?(::RightSupport::Data::HashToolsSpec::BetterHash.new).should be_true
+    end
+
+    it 'should be true for hash-like objects' do
+      subject.hashable?(::RightSupport::Data::HashToolsSpec::HashLike.new).should be_true
+    end
+
+    it 'should be false for unhashable objects' do
+      subject.hashable?([1, 2, 3]).should be_false
+      subject.hashable?("hi there").should be_false
+    end
+  end
+
+  context '#hash_like?' do
+    it 'should be true for Hash' do
+      subject.hash_like?(::Hash).should be_true
+    end
+
+    it 'should be true for hash-based classes' do
+      subject.hash_like?(::RightSupport::Data::HashToolsSpec::BetterHash).should be_true
+    end
+
+    it 'should be true for hash-like classes' do
+      subject.hash_like?(::RightSupport::Data::HashToolsSpec::HashLike).should be_true
+    end
+
+    it 'should be false for non-hash classes' do
+      subject.hash_like?(Array).should be_false
+      subject.hash_like?(String).should be_false
+    end
+  end
+
+  context '#deep_get' do
+    hash = { 'tree' => { 'branch' => { 'leaf' => 42, 'other' => 41 },
+                         'other' => { 'leaf' => 43 } } }
+    {
+      :valid_leaf => {
+        :path => ['tree', 'branch', 'leaf'],
+        :expected => 42 },
+      :valid_other_leaf => {
+        :path => ['tree', 'branch', 'other'],
+        :expected => 41 },
+      :valid_branch => {
+        :path => ['tree', 'branch'],
+        :expected => { 'leaf' => 42, 'other' => 41 } },
+      :valid_other_branch => {
+        :path => ['tree', 'other'],
+        :expected => { 'leaf' => 43 } },
+      :invalid_leaf => {
+        :path => ['tree', 'branch', 'leaf', 'bogus'],
+        :expected => nil },
+      :invalid_branch => {
+        :path => ['tree', 'bogus'],
+        :expected => nil },
+      :nil => {
+        :path => nil,
+        :expected => nil },
+      :empty => {
+        :path => [],
+        :expected => nil }
+    }.each do |kind, data|
+      it "should deep get #{kind} paths" do
+        actual = subject.deep_get(hash, data[:path])
+        actual.should == data[:expected]
+      end
+    end
+  end
+
+  context '#deep_set!' do
+    {
+      :empty => {
+        :target => {},
+        :path => ['tree', 'branch', 'leaf'],
+        :value => 42,
+        :expected => { 'tree' => { 'branch' => { 'leaf' => 42 } } } },
+      :identical_structure => {
+        :target => { 'tree' => { 'branch' => { 'leaf' => 42 } } },
+        :path => ['tree', 'branch', 'leaf'],
+        :value => 41,
+        :expected => { 'tree' => { 'branch' => { 'leaf' => 41 } } } },
+      :similar_structure => {
+        :target => { 'tree' => { 'branch' => { 'other' => 41 } } },
+        :path => ['tree', 'branch', 'leaf'],
+        :value => 42,
+        :expected => { 'tree' => { 'branch' => { 'leaf' => 42, 'other' => 41 } } } },
+      :different_hash_subclass => {
+        :target => {},
+        :path => ['tree', 'branch', 'leaf'],
+        :value => 42,
+        :clazz => ::RightSupport::Data::HashToolsSpec::BetterHash,
+        :expected => { 'tree' => { 'branch' => { 'leaf' => 42 } } } },
+      :different_hash_like_class => {
+        :target => {},
+        :path => ['tree', 'branch', 'leaf'],
+        :value => 42,
+        :clazz => ::RightSupport::Data::HashToolsSpec::HashLike,
+        :expected => { 'tree' => { 'branch' => { 'leaf' => 42 } } } }
+    }.each do |kind, data|
+      it "should deep set values in #{kind} hashes" do
+        subject.deep_set!(data[:target], data[:path], data[:value], data[:clazz])
+        data[:target].should == data[:expected]
+        expected_class = data[:clazz] || data[:target].class
+        data[:target].values.first.class.should == expected_class
+      end
+    end
+  end
+
+  context '#deep_clone' do
+    def deep_check_object_id(a, b, &leaf_callback)
+      a.object_id.should_not == b.object_id
+      a.each do |k, v|
+        if subject.hashable?(v)
+          deep_check_object_id(v, b[k])
+        elsif leaf_callback
+          leaf_callback.call(v, b[k])
+        elsif v.respond_to?(:duplicable?) && v.duplicable?
+          v.object_id.should_not == b[k].object_id
+        else
+          v.object_id.should == b[k].object_id
+        end
+      end
+    end
+
+    {
+      :empty => {},
+      :shallow => { :x => 1, :y => 2 },
+      :deep => { :x => 1, :y => { :a => 'A' }, :z => { :b => 'B', :c => { :foo => :bar }} },
+      :duplicable => {
+        :tree => {
+          :branch => {
+            :a => ::RightSupport::Data::HashToolsSpec::DuplicableValue.new(1),
+            :b => ::RightSupport::Data::HashToolsSpec::DuplicableValue.new('hi there') } } }
+    }.each do |kind, data|
+      it "should deep clone values in #{kind} hashes" do
+        actual = subject.deep_clone(data)
+        actual.should == data
+        if :duplicable == kind
+          # verify that leaves are duplicable
+          data[:tree][:branch][:a].duplicable?.should be_true
+          data[:tree][:branch][:b].duplicable?.should be_true
+        end
+        deep_check_object_id(actual, data)
+      end
+    end
+
+    it 'should deep clone leaves using callback when given' do
+      initial = { :x => 1, :y => { :a => [1, 2, 3], :b => [4, 5, 6] } }
+      actual = subject.deep_clone(initial) { |value| value.kind_of?(Array) ? value.clone : value }
+      actual.should == initial
+      deep_check_object_id(actual, initial) do |a, b|
+        if a.kind_of?(Array)
+          a.object_id.should_not == b.object_id
+        else
+          a.object_id.should == b.object_id
+        end
+      end
+    end
+  end
+
+  context '#deep_merge!' do
+    {
+      :identical => {
+        :left     => { :one => 1 },
+        :right    => { :one => 1 },
+        :expected => { :one => 1 } },
+      :disjoint => {
+        :left     => { :one => 1 },
+        :right    => { :two => 1 },
+        :expected => { :one => 1, :two => 1 } },
+      :value_diff => {
+        :left     => { :one => 1 },
+        :right    => { :one => 2 },
+        :expected => { :one => 2 } },
+      :recursive_disjoint => {
+        :left     => { :one => { :a => 1, :b => 2 }, :two => 3 },
+        :right    => { :one => { :a => 1 }, :two => 3 },
+        :expected => { :one => { :a => 1, :b => 2 }, :two => 3 } },
+      :recursive_value_diff => {
+        :left     => { :one => { :a => 1, :b => 2 }, :two => 3 },
+        :right    => { :one => { :a => 1, :b => 3 }, :two => 3 },
+        :expected => { :one => { :a => 1, :b => 3 }, :two => 3 } },
+      :recursive_disjoint_and_value_diff => {
+        :left     => { :one => { :a => 1, :b => 2, :c => 3 }, :two => 3, :three => 4 },
+        :right    => { :one => { :a => 1, :b => 3, :d => 4 }, :two => 5, :four => 6 },
+        :expected => { :one => { :a => 1, :b => 3, :c => 3 , :d => 4 }, :two => 5, :three => 4, :four => 6 } }
+    }.each do |kind, data|
+      it "should deep merge #{kind} hashes" do
+        actual = subject.deep_merge!(data[:left], data[:right])
+        actual.should == data[:expected]
+      end
+    end
+  end
+
+  context "#deep_remove!" do
+    {
+      :empty => {
+        :target   => {},
+        :source   => {},
+        :expected => {} },
+      :identical => {
+        :target   => { :x => 1, :y => { :foo => :bar } },
+        :source   => { :x => 1, :y => { :foo => :bar } },
+        :expected => {} },
+      :greater_target => {
+        :target   => { :x => 1, :y => { :a => 'a', :b => 'b' } },
+        :source   => { :x => 1, :y => { :a => 'a' } },
+        :expected => { :y => { :b => 'b' } } },
+      :greater_source => {
+        :target   => { :x => 1, :y => { :a => 'a' } },
+        :source   => { :x => 1, :y => { :a => 'a', :b => 'b' } },
+        :expected => { :y => {} } },
+      :disjoint => {
+        :target   => { :x => 1, :y => { :a => 'a' } },
+        :source   => { :x => 2, :y => { :b => 'b' } },
+        :expected => { :x => 1, :y => { :a => 'a' } } }
+    }.each do |kind, data|
+      it "should deep remove values from #{kind} hashes" do
+        actual = subject.deep_remove!(data[:target], data[:source])
+        actual.should == data[:expected]
+      end
+    end
+  end
+
+  context "#deep_create_patch" do
+    {
+      :identical => {
+        :left     => { :one => 1 },
+        :right    => { :one => 1 },
+        :expected => { :left_only  => {},
+                       :right_only => {},
+                       :diff       => {} } },
+      :disjoint => {
+        :left     => { :one => 1 },
+        :right    => { :two => 1 },
+        :expected => { :left_only  => { :one => 1},
+                       :right_only => { :two => 1},
+                       :diff       => {} }
+        },
+      :value_diff => {
+        :left     => { :one => 1 },
+        :right    => { :one => 2 },
+        :expected => { :left_only  => {},
+                       :right_only => {},
+                       :diff       => { :one => { :left => 1, :right => 2} } } },
+      :recursive_disjoint => {
+        :left     => { :one => { :a => 1, :b => 2 }, :two => 3 },
+        :right    => { :one => { :a => 1 }, :two => 3 },
+        :expected => { :left_only  => { :one => { :b => 2 }},
+                       :right_only => {},
+                       :diff       => {} } },
+      :recursive_value_diff => {
+        :left     => { :one => { :a => 1, :b => 2 }, :two => 3 },
+        :right    => { :one => { :a => 1, :b => 3 }, :two => 3 },
+        :expected => { :left_only  => {},
+                       :right_only => {},
+                       :diff       => { :one => { :b => { :left => 2, :right => 3 }} } } },
+      :recursive_disjoint_and_value_diff => {
+        :left     => { :one => { :a => 1, :b => 2, :c => 3 }, :two => 3, :three => 4 },
+        :right    => { :one => { :a => 1, :b => 3, :d => 4 }, :two => 5, :four => 6 },
+        :expected => { :left_only  => { :one => { :c => 3 }, :three => 4 },
+                       :right_only => { :one => { :d => 4 }, :four => 6 },
+                       :diff       => { :one => { :b => { :left => 2, :right => 3 }}, :two => { :left => 3, :right => 5 } } } }
+    }.each do |kind, data|
+      it "should deep create patch for #{kind} hashes" do
+        actual = subject.deep_create_patch(data[:left], data[:right])
+        actual.should == data[:expected]
+      end
+    end
+  end
+
+  context '#deep_apply_patch!' do
+    {
+      :empty_patch => {
+        :target   => { :one => 1 },
+        :patch    => { :left_only => {}, :right_only => {}, :diff => {} },
+        :expected => { :one => 1 } },
+      :disjoint => {
+        :target   => { :one => 1 },
+        :patch    => { :left_only => { :one => 2 }, :right_only => {}, :diff => { :one => { :left => 3, :right => 4 } } },
+        :expected => { :one => 1 } },
+      :removal => {
+        :target   => { :one => 1 },
+        :patch    => { :left_only => { :one => 1 }, :right_only => {}, :diff => {} },
+        :expected => {} },
+      :addition => {
+        :target   => { :one => 1 },
+        :patch    => { :left_only => {}, :right_only => { :two => 2 }, :diff => {} },
+        :expected => { :one => 1, :two => 2 } },
+      :substitution => {
+        :target   => { :one => 1 },
+        :patch    => { :left_only => {}, :right_only => {}, :diff => { :one => { :left => 1, :right => 2 } } },
+        :expected => { :one => 2 } },
+      :recursive_removal => {
+        :target   => { :one => { :a => 1, :b => 2 } },
+        :patch    => { :left_only => { :one => { :a => 1 }}, :right_only => {}, :diff => {} },
+        :expected => { :one => { :b => 2 } } },
+      :recursive_addition => {
+        :target   => { :one => { :a => 1 } },
+        :patch    => { :left_only => {}, :right_only => { :one => { :b => 2 } }, :diff => {} },
+        :expected => { :one => { :a => 1, :b => 2 } } },
+      :recursive_substitution => {
+        :target   => { :one => { :a => 1 } },
+        :patch    => { :left_only => {}, :right_only => {}, :diff => { :one => { :a => { :left => 1, :right => 2 } } } },
+        :expected => { :one => { :a => 2 } } },
+      :combined => {
+        :target   => { :one => { :a => 1, :b => 2 } },
+        :patch    => { :left_only => { :one => { :a => 1 } }, :right_only => { :one => { :c => 3 }}, :diff => { :one => { :b => { :left => 2, :right => 3 } } } },
+        :expected => { :one => { :b => 3, :c => 3 } } }
+    }.each do |kind, data|
+      it "should deep apply #{kind} patches" do
+        actual = subject.deep_apply_patch!(data[:target], data[:patch])
+        actual.should == data[:expected]
+      end
+    end
+  end
+
+  context '#deep_sorted_json' do
+
+    let(:flat_hash) do
+      result = {}
+      10.times do |i|
+        # try to ensure insertion order does not affect the unsorted extraction
+        # order by inserting keys out-of-order. insertion order historically has
+        # no affect on extraction order, but you never know about future Hash.
+        # if the Hash of tomorrow is always sorted, then goody.
+        i = (13 - i) % 10
+        key = (i + ?a.ord).chr
+        key = key.to_sym if 0 == (i % 2)  # every other key is a symbol
+        result[key] = i
+      end
+      result
+    end
+
+    let(:deep_hash) do
+      result          = {}
+      result['y']     = flat_hash.dup
+      result['y'][:z] = flat_hash.dup
+      result[:x]      = flat_hash.dup
+      result.merge!(flat_hash)
+      result
+    end
+
+    it 'should produce sorted json from a flat hash' do
+      expected = "{\"a\":0,\"b\":1,\"c\":2,\"d\":3,\"e\":4,\"f\":5,\"g\":6,\"h\":7,\"i\":8,\"j\":9}"
+      actual = subject.deep_sorted_json(flat_hash)
+      actual.should == expected
+    end
+
+    it 'should produce pretty sorted json from a flat hash' do
+      expected = <<EOF
+{
+  "a": 0,
+  "b": 1,
+  "c": 2,
+  "d": 3,
+  "e": 4,
+  "f": 5,
+  "g": 6,
+  "h": 7,
+  "i": 8,
+  "j": 9
+}
+EOF
+      expected = expected.strip
+      actual = subject.deep_sorted_json(flat_hash, pretty=true)
+      actual.should == expected
+    end
+
+    it 'should produce sorted json from a deep hash' do
+      expected = "{\"a\":0,\"b\":1,\"c\":2,\"d\":3,\"e\":4,\"f\":5,\"g\":6,\"h\":7,\"i\":8,\"j\":9," +
+                  "\"x\":{\"a\":0,\"b\":1,\"c\":2,\"d\":3,\"e\":4,\"f\":5,\"g\":6,\"h\":7,\"i\":8,\"j\":9}," +
+                  "\"y\":{\"a\":0,\"b\":1,\"c\":2,\"d\":3,\"e\":4,\"f\":5,\"g\":6,\"h\":7,\"i\":8,\"j\":9," +
+                         "\"z\":{\"a\":0,\"b\":1,\"c\":2,\"d\":3,\"e\":4,\"f\":5,\"g\":6,\"h\":7,\"i\":8,\"j\":9}}}"
+      actual = subject.deep_sorted_json(deep_hash)
+      actual.should == expected
+    end
+
+    it 'should produce pretty sorted json from a deep hash' do
+      expected = <<EOF
+{
+  "a": 0,
+  "b": 1,
+  "c": 2,
+  "d": 3,
+  "e": 4,
+  "f": 5,
+  "g": 6,
+  "h": 7,
+  "i": 8,
+  "j": 9,
+  "x": {
+    "a": 0,
+    "b": 1,
+    "c": 2,
+    "d": 3,
+    "e": 4,
+    "f": 5,
+    "g": 6,
+    "h": 7,
+    "i": 8,
+    "j": 9
+  },
+  "y": {
+    "a": 0,
+    "b": 1,
+    "c": 2,
+    "d": 3,
+    "e": 4,
+    "f": 5,
+    "g": 6,
+    "h": 7,
+    "i": 8,
+    "j": 9,
+    "z": {
+      "a": 0,
+      "b": 1,
+      "c": 2,
+      "d": 3,
+      "e": 4,
+      "f": 5,
+      "g": 6,
+      "h": 7,
+      "i": 8,
+      "j": 9
+    }
+  }
+}
+EOF
+      expected = expected.strip
+      actual = subject.deep_sorted_json(deep_hash, pretty=true)
+      actual.should == expected
+    end
+
+  end
+end

data/spec/data/uuid_spec.rb

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

@@ -0,0 +1,84 @@
+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 "shoudl 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=>10}).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

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