time_window_drop_collector 0.0.11 → 0.1.1

data/lib/time_window_drop_collector.rb

@@ -3,8 +3,10 @@ require "dalli"
 require_relative "time_window_drop_collector/version"
 require_relative "time_window_drop_collector/config"
 require_relative "time_window_drop_collector/logger"
+require_relative "time_window_drop_collector/utils"
 require_relative "time_window_drop_collector/storage"
 require_relative "time_window_drop_collector/wrapper"
+require_relative "time_window_drop_collector/results"
 require_relative "time_window_drop_collector/wrappers/memcache"
 require_relative "time_window_drop_collector/wrappers/mock"
 require_relative "time_window_drop_collector/wrappers/redis"
@@ -14,6 +16,8 @@ class TimeWindowDropCollector
   attr_reader :config, :wrapper, :storage
 
   def initialize( &block )
+    TimeWindowDropCollector::Logger.log "INITIALIZING version: #{TimeWindowDropCollector::VERSION}"
+
     @config = {
       :window       => 600,
       :slices       => 10,
@@ -23,15 +27,32 @@ class TimeWindowDropCollector
 
     @config.merge!( TimeWindowDropCollector::Config.extract( block ) ) if block_given?
 
+    TimeWindowDropCollector::Logger.log "CONFIG: #{config}"
+
     @wrapper = TimeWindowDropCollector::Wrapper.instance( config[:client], config[:client_opts] )
     @storage = TimeWindowDropCollector::Storage.new( wrapper, config[:window], config[:slices] )
   end
 
-  def drop( key )
-    storage.incr( key )
+  def drop( keys )
+    keys = [keys] unless keys.is_a? Array
+    keys = keys.map(&:to_s)
+
+    TimeWindowDropCollector::Logger.log "DROP keys: #{keys.join(", ")}"
+    storage.incr( keys )
   end
 
-  def count( key )
-    storage.count( key )
+  def count( orig_keys )
+    keys = orig_keys.is_a?(Array) ? orig_keys : [orig_keys]
+    keys = keys.map(&:to_s)
+
+    TimeWindowDropCollector::Logger.log "COUNT keys: #{keys.join(", ")}"
+
+    result = storage.count( keys )
+    result = TimeWindowDropCollector::Results.new( result )
+    result = result[orig_keys.to_s] unless orig_keys.is_a? Array
+
+    TimeWindowDropCollector::Logger.log "COUNT result: #{result}"
+
+    result
   end
 end

data/lib/time_window_drop_collector/logger.rb

@@ -1,5 +1,5 @@
 module TimeWindowDropCollector::Logger
   def self.log( message )
-    puts "[TWDC #{Time.now.strftime( "%F %T" )}] #{message}"
+    puts "[TWDC #{Time.now.strftime( "%F %T" )}] #{message}" if ENV["TWDC_DEBUG"]
   end
 end

data/lib/time_window_drop_collector/results.rb

@@ -0,0 +1,11 @@
+class TimeWindowDropCollector::Results
+  attr_reader :keys_values
+
+  def initialize( keys_values )
+    @keys_values = keys_values
+  end
+
+  def []( key )
+    keys_values[key].to_i
+  end
+end

data/lib/time_window_drop_collector/storage.rb

@@ -1,46 +1,22 @@
 class TimeWindowDropCollector::Storage
+  include TimeWindowDropCollector::Utils
+
   attr_reader :wrapper, :window, :slices
 
   def initialize( wrapper, window, slices )
     @wrapper = wrapper
-    @window = window
-    @slices = slices
-  end
-
-  def incr( key )
-    wrapper.incr( time_key( key ), window )
-  end
-
-  def count( key )
-    time_keys = time_keys( key )
-    values    = wrapper.values_for( time_keys )
-
-    values.map( &:to_i ).inject( :+ ).to_i
-  end
-
-  def time_key( key, time = timestamp )
-    "drop_window_#{key}_#{slice_start_timestamp( time )}"
-  end
-
-  def time_keys( key )
-    now = timestamp
-
-    ( 0..( slices - 1 ) ).map{ |i|
-      time_key( key, now - ( ( i*slice_milliseconds ) / 1000 ) )
-    }
-  end
-
-  def timestamp
-    Time.now
+    @window  = window
+    @slices  = slices
   end
 
-  def slice_milliseconds
-    ( window * 1000 ) / slices
+  def incr( keys )
+    wrapper.incr( timestamp_key_multi( keys ), window )
   end
 
-  def slice_start_timestamp( time )
-    time_milliseconds = ( time.to_f * 1000 ).truncate
+  def count( keys )
+    window_keys = window_keys_multi( keys )
+    keys_values = wrapper.get( window_keys )
 
-    ( time_milliseconds / slice_milliseconds ) * slice_milliseconds
+    grouping_count( keys_values )
   end
 end

data/lib/time_window_drop_collector/utils.rb

@@ -0,0 +1,49 @@
+module TimeWindowDropCollector::Utils
+  def grouping_count( key_values )
+    groups = key_values.group_by { |k,v| k.match( /drop_window_(.*)_/ )[1]  }
+
+    result = {}
+
+    groups.each do |k,v|
+      result[k] = v.inject(0) { |acc,e| acc += e[1].to_i }
+    end
+
+    result
+  end
+
+  def timestamp_key( key, time = timestamp )
+    "drop_window_#{key}_#{slice_start_timestamp( time )}"
+  end
+
+  def timestamp_key_multi( keys )
+    now = timestamp
+
+    keys.map { |key| timestamp_key( key, now ) }.flatten
+  end
+
+  def window_keys( key, now = timestamp )
+    ( 0..( slices - 1 ) ).map{ |i|
+      timestamp_key( key, now - ( ( i*slice_milliseconds ) / 1000 ) )
+    }
+  end
+
+  def window_keys_multi( keys )
+    now = timestamp
+
+    keys.map { |key| window_keys( key, now ) }.flatten
+  end
+
+  def timestamp
+    Time.now
+  end
+
+  def slice_milliseconds
+    @slice_milliseconds ||= ( window * 1000 ) / slices
+  end
+
+  def slice_start_timestamp( time )
+    time_milliseconds = ( time.to_f * 1000 ).truncate
+
+    ( time_milliseconds / slice_milliseconds ) * slice_milliseconds
+  end
+end

data/lib/time_window_drop_collector/version.rb

@@ -1,3 +1,3 @@
 class TimeWindowDropCollector
-  VERSION = "0.0.11"
+  VERSION = "0.1.1"
 end

data/lib/time_window_drop_collector/wrappers/memcache.rb

@@ -7,12 +7,16 @@ class TimeWindowDropCollector
         @client = Dalli::Client.new( opts )
       end
 
-      def incr( key, expire_time )
-        client.incr( key, 1, expire_time, 1 )
+      def incr( keys, expire_time )
+        client.multi do
+          keys.each do |key|
+            client.incr( key, 1, expire_time, 1 )
+          end
+        end
       end
 
-      def values_for( keys )
-        client.get_multi( keys ).values
+      def get( keys )
+        client.get_multi( keys )
       end
     end
   end

data/lib/time_window_drop_collector/wrappers/mock.rb

@@ -7,12 +7,14 @@ class TimeWindowDropCollector
 				@client = MemcacheMock.new
 			end
 
-			def incr( key, expire_time )
-				client.incr( key, 1, nil, 1 )
+			def incr( keys, expire_time )
+				keys.each do |key|
+					client.incr( key, 1, nil, 1 )
+				end
 			end
 
-			def values_for( keys )
-				client.get_multi( keys ).values
+			def get( keys )
+				client.get_multi( keys )
 			end
 		end
 	end

data/lib/time_window_drop_collector/wrappers/rails_cache.rb

@@ -7,13 +7,14 @@ class TimeWindowDropCollector
 				@client = Rails.cache
 			end
 
-			def incr( key, expire_time )
-				value = client.read( key ).to_i + 1
-				client.write( key, value, :expires_in => expire_time )
+			def incr( keys, expire_time )
+				keys.each do |key|
+					client.increment( key, 1, :expires_in => expire_time )
+				end
 			end
 
-			def values_for( keys )
-				client.read_multi( keys ).values
+			def get( keys )
+				client.read_multi( keys )
 			end
 		end
 	end

data/lib/time_window_drop_collector/wrappers/redis.rb

@@ -7,15 +7,25 @@ class TimeWindowDropCollector
         @client = ::Redis.new( opts )
       end
 
-  		def incr( key, expire_time )
+  		def incr( keys, expire_time )
         client.multi do
-          client.incr( key )
-          client.expire( key, expire_time )
+          keys.each do |key|
+            client.incr( key )
+            client.expire( key, expire_time )
+          end
         end
   		end
 
-  		def values_for( keys )
-  			client.mget( *keys )
+  		def get( keys )
+  			values = client.mget( *keys )
+
+        result = {}
+
+        keys.each_with_index do |key, i|
+          result[key] = values[i]
+        end
+
+        result
   		end
   	end
   end

data/test/logger_test.rb

@@ -1,6 +1,15 @@
 require_relative "test_helper"
 
 class LoggerTest < Test::Unit::TestCase
+  def setup
+    @old_env = ENV["TWDC_DEBUG"]
+    ENV["TWDC_DEBUG"] = "on"
+  end
+
+  def teardown
+    ENV["TWDC_DEBUG"] = @old_env
+  end
+
   def test_log
     IO.any_instance.expects( :puts ).with( "[TWDC 2001-02-01 04:05:06] hello!" )
 

data/test/mock_wrapper_test.rb

@@ -9,13 +9,14 @@ class MockWrapperTest < Test::Unit::TestCase
 
   def test_incr
     wrapper = TimeWindowDropCollector::Wrappers::Mock.new( ["arg1"] )
-    wrapper.client.expects( :incr ).with( "key", 1, nil, 1 )
-    wrapper.incr( "key", "expire_time" )
+    wrapper.client.expects( :incr ).with( "key1", 1, nil, 1 )
+    wrapper.client.expects( :incr ).with( "key2", 1, nil, 1 )
+    wrapper.incr( ["key1", "key2"], "expire_time" )
   end
 
   def test_values_for
     wrapper = TimeWindowDropCollector::Wrappers::Mock.new( ["arg1"] )
-    wrapper.client.expects( :get_multi ).with( "keys" ).returns( {:a => 1, :b => 2} )
-    assert_equal( [1, 2], wrapper.values_for( "keys" ))
+    wrapper.client.expects( :get_multi ).with( "keys" ).returns( "keys_values" )
+    assert_equal( "keys_values", wrapper.get( "keys" ))
   end
 end

data/test/rails_cache_wrapper_test.rb

@@ -14,15 +14,15 @@ class MemcacheWrapperTest < Test::Unit::TestCase
 
   def test_incr
     wrapper = TimeWindowDropCollector::Wrappers::RailsCache.new( ["arg1"] )
-    wrapper.client.expects( :read ).with( "key" ).returns( 2 )
-    wrapper.client.expects( :write ).with( "key", 3, :expires_in => "expire_time" )
+    wrapper.client.expects( :increment ).with( "key1", 1, :expires_in => "expire_time" )
+    wrapper.client.expects( :increment ).with( "key2", 1, :expires_in => "expire_time" )
 
-    wrapper.incr( "key", "expire_time" )
+    wrapper.incr( ["key1", "key2"], "expire_time" )
   end
 
   def test_values_for
     wrapper = TimeWindowDropCollector::Wrappers::RailsCache.new( ["arg1"] )
-    wrapper.client.expects( :read_multi ).with( "keys" ).returns( {:a => 1, :b => 2} )
-    assert_equal( [1, 2], wrapper.values_for( "keys" ))
+    wrapper.client.expects( :read_multi ).with( "keys" ).returns( "keys_values" )
+    assert_equal( "keys_values", wrapper.get( "keys" ))
   end
 end

data/test/redis_wrapper_test.rb

@@ -21,10 +21,13 @@ class RedisWrapperTest < Test::Unit::TestCase
     Redis.expects( :new ).returns( RedisMock.new )
     wrapper = TimeWindowDropCollector::Wrappers::Redis.new( nil )
 
-    wrapper.client.expects( :incr ).with( "key" )
-    wrapper.client.expects( :expire ).with( "key", "expire_time" )
+    wrapper.client.expects( :incr ).with( "key1" )
+    wrapper.client.expects( :expire ).with( "key1", "expire_time" )
 
-    wrapper.incr( "key", "expire_time" )
+    wrapper.client.expects( :incr ).with( "key2" )
+    wrapper.client.expects( :expire ).with( "key2", "expire_time" )
+
+    wrapper.incr( ["key1", "key2"], "expire_time" )
   end
 
   def test_incr_agregates_commands_under_multi
@@ -36,12 +39,12 @@ class RedisWrapperTest < Test::Unit::TestCase
     wrapper.incr( nil, nil )
   end
 
-  def test_values_for
+  def test_get
     Redis.expects( :new ).returns( RedisMock.new )
     wrapper = TimeWindowDropCollector::Wrappers::Redis.new( nil )
 
     wrapper.client.expects( :mget ).with( "key1", "key2" ).returns( [1, 2] )
 
-    assert_equal( [1, 2], wrapper.values_for( ["key1", "key2"] ))
+    assert_equal( { "key1" => 1, "key2" => 2 }, wrapper.get( ["key1", "key2"] ))
   end
 end

data/test/storage_test.rb

@@ -2,21 +2,21 @@ require_relative "test_helper"
 
 class StorageTest < Test::Unit::TestCase
   def setup
-    @client = mock()
-    @storage = TimeWindowDropCollector::Storage.new( @client, 600, 10 )
+    @wrapper = mock()
+    @storage = TimeWindowDropCollector::Storage.new( @wrapper, 600, 10 )
   end
 
-  def test_time_key_when_time_is_present
+  def test_timestamp_key_when_time_is_present
     timestamp = Time.new( 2001, 2, 3, 4, 5 )
-    assert_equal( "drop_window_key_981169500000", @storage.time_key( "key", timestamp ) )
+    assert_equal( "drop_window_key_981169500000", @storage.timestamp_key( "key", timestamp ) )
   end
 
-  def test_time_key_when_time_is_not_present
+  def test_timestamp_key_when_time_is_not_present
     @storage.stubs( :timestamp ).returns( Time.new( 2012, 4, 3, 2, 1 ))
-    assert_equal( "drop_window_key_1333411260000", @storage.time_key( "key" ))
+    assert_equal( "drop_window_key_1333411260000", @storage.timestamp_key( "key" ))
   end
 
-  def test_time_keys_should_return_10_keys_for_the_last_10_minutes
+  def test_window_keys_should_return_10_keys_for_the_last_10_minutes
     keys = [
       "drop_window_key_1325560800000",
       "drop_window_key_1325560740000",
@@ -31,56 +31,87 @@ class StorageTest < Test::Unit::TestCase
     ]
 
     Delorean.time_travel_to( '2012-01-03 04:20' ) do
-      assert_equal( keys, @storage.time_keys( "key" ))
+      assert_equal( keys, @storage.window_keys( "key" ))
     end
   end
 
   def test_incr
-    @storage.expects( :time_key ).with( "key" ).returns( "time_key" )
-    @client.expects( :incr ).with( "time_key", 600 )
+    @storage.expects( :timestamp_key_multi ).with( ["keys"] ).returns( "timestamp_keys" )
+    @wrapper.expects( :incr ).with( "timestamp_keys", 600 )
 
-    @storage.incr( "key" )
+    @storage.incr( ["keys"] )
   end
 
   def test_count
-    keys = [
-      "drop_window_key_201201031416",
-      "drop_window_key_201201031415",
-      "drop_window_key_201201031414",
-      "drop_window_key_201201031413",
-      "drop_window_key_201201031412"
-    ]
+    @storage.expects( :window_keys_multi ).with( "keys" ).returns( "window_keys" )
+    @wrapper.expects( :get ).with( "window_keys" ).returns( "keys_values" )
+    @storage.expects( :grouping_count ).with( "keys_values" ).returns( "grouping_keys_counts" )
 
-    values = [nil, 1, "2", 3, 4, 5]
+    assert_equal( "grouping_keys_counts", @storage.count( "keys" ))
+  end
+
+  def test_grouping_count
+    key_values = {
+      "drop_window_key1_201201031416" => 1,
+      "drop_window_key1_201201031415" => 2,
+      "drop_window_key1_201201031414" => 3,
+      "drop_window_key1_201201031413" => 4,
+      "drop_window_key1_201201031412" => 5,
+      "drop_window_key2_201201031413" => 6,
+      "drop_window_key2_201201031412" => 7
+    }
+
+    key_counts = @storage.grouping_count( key_values )
+
+    assert_equal( 15, key_counts["key1"])
+    assert_equal( 13, key_counts["key2"])
+  end
 
-    @storage.expects( :time_keys ).with( "key" ).returns( "keys" )
-    @client.expects( :values_for ).with( "keys" ).returns( values )
+  def test_grouping_count_with_nil_values
+    key_values = {
+      "drop_window_key1_201201031416" => 1,
+      "drop_window_key1_201201031414" => nil,
+      "drop_window_key2_201201031413" => 6,
+      "drop_window_key2_201201031412" => 7,
+      "drop_window_key3_201201031412" => nil
+    }
 
-    assert_equal( 15, @storage.count( "key" ))
+    key_counts = @storage.grouping_count( key_values )
+
+    assert_equal( 1, key_counts["key1"])
+    assert_equal( 13, key_counts["key2"])
+    assert_equal( 0, key_counts["key3"])
   end
 
-  def test_count_when_empty_values
-    @storage.stubs( :time_keys )
-    @client.expects( :values_for ).returns( [] )
-    assert_equal( 0, @storage.count( "key" ))
+    def test_grouping_when_not_key
+    key_values = {
+      "drop_window_key1_201201031416" => 1,
+      "drop_window_key2_201201031412" => 7
+    }
+
+    key_counts = @storage.grouping_count( key_values )
+
+    assert_equal( 1, key_counts["key1"])
+    assert_equal( 7, key_counts["key2"])
+    assert_equal( nil, key_counts["key3"])
   end
 
   def test_integration_count
     client  = TimeWindowDropCollector::Wrapper.instance( :mock )
     storage = TimeWindowDropCollector::Storage.new( client, 600, 10 )
 
-    key_1 = 1
-    key_2 = 2
-    key_3 = 3
+    storage.incr( ["key_1"] )
+    storage.incr( ["key_2"] )
+    storage.incr( ["key_3"] )
+    storage.incr( ["key_2"] )
+    storage.incr( ["key_2", "key_1"] )
 
-    storage.incr( key_1 )
-    storage.incr( key_2 )
-    storage.incr( key_3 )
-    storage.incr( key_2 )
+    keys_values = storage.count( ["key_1", "key_2", "key_3", "key_4"] )
 
-    assert_equal( 1, storage.count( key_1 ))
-    assert_equal( 2, storage.count( key_2 ))
-    assert_equal( 1, storage.count( key_3 ))
+    assert_equal( 2, keys_values["key_1"])
+    assert_equal( 3, keys_values["key_2"])
+    assert_equal( 1, keys_values["key_3"])
+    assert_equal( nil, keys_values["key_4"])
   end
 
   def test_slice_start_timestamp
@@ -156,79 +187,77 @@ class StorageTest < Test::Unit::TestCase
     client  = TimeWindowDropCollector::Wrapper.instance( :mock )
     storage = TimeWindowDropCollector::Storage.new( client, 600, 10 )
 
-    key_1 = 1
-
     Delorean.time_travel_to( '2012-01-03 11:00' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:01' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:02' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:03' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:04' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:05' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:06' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:07' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:08' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:09' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:10' ) do
-      storage.incr( key_1 )
+      storage.incr( ["key_1"] )
     end
 
     # counters
     Delorean.time_travel_to( '2012-01-03 10:59' ) do
-      assert_equal( 0, storage.count( key_1 ))
+      assert_equal( nil, storage.count( ["key_1"] )["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:00' ) do
-      assert_equal( 1, storage.count( key_1 ))
+      assert_equal( 1, storage.count( ["key_1"] )["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:05' ) do
-      assert_equal( 6, storage.count( key_1 ))
+      assert_equal( 6, storage.count( ["key_1"] )["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:10' ) do
-      assert_equal( 10, storage.count( key_1 ))
+      assert_equal( 10,  storage.count( ["key_1"] )["key_1"])
     end
 
     Delorean.time_travel_to( '2012-01-03 11:15' ) do
-      assert_equal( 5, storage.count( key_1 ))
+      assert_equal( 5, storage.count( ["key_1"] )["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:19' ) do
-      assert_equal( 1, storage.count( key_1 ))
+      assert_equal( 1,  storage.count( ["key_1"] )["key_1"] )
     end
 
     Delorean.time_travel_to( '2012-01-03 11:20' ) do
-      assert_equal( 0, storage.count( key_1 ))
+      assert_equal( nil,  storage.count( ["key_1"] )["key_1"] )
     end
   end
 end

data/test/time_window_drop_collector_test.rb

@@ -2,7 +2,6 @@ require_relative "test_helper"
 
 class TimeWindowDropCollectorTest < Test::Unit::TestCase
   def setup
-    @twdc = TimeWindowDropCollector::Logger.stubs( :log )
   end
 
   def test_initialize_with_empty_config
@@ -34,7 +33,7 @@ class TimeWindowDropCollectorTest < Test::Unit::TestCase
 
   def test_drop
     storage = mock()
-    storage.expects( :incr ).with( "key" )
+    storage.expects( :incr ).with( ["key"] )
 
     twdc = TimeWindowDropCollector.new
     twdc.stubs( :storage ).returns( storage )
@@ -44,12 +43,12 @@ class TimeWindowDropCollectorTest < Test::Unit::TestCase
 
   def test_count
     storage = mock()
-    storage.expects( :count ).with( "key" )
+    storage.expects( :count ).with( ["key"] ).returns( { "key" => 10 } )
 
     twdc = TimeWindowDropCollector.new
     twdc.stubs( :storage ).returns( storage )
 
-    twdc.count( "key" )
+    assert_equal( 10, twdc.count( "key" ) )
   end
 
   def test_integration_new
@@ -67,4 +66,45 @@ class TimeWindowDropCollectorTest < Test::Unit::TestCase
     assert_equal( 100, twdc.storage.window )
     assert_equal( 20, twdc.storage.slices )
   end
+
+  def test_integration_drop_and_count
+    twdc = TimeWindowDropCollector.new { client :mock }
+
+    twdc.drop( "key_1" )
+    twdc.drop( "key_1" )
+    twdc.drop( "key_2" )
+    twdc.drop( "key_2" )
+    twdc.drop( ["key_2"] )
+    twdc.drop( ["key_3", "key_4", "key_5"] )
+
+    assert_equal( 2, twdc.count( "key_1" ) )
+    assert_equal( 3, twdc.count( "key_2" ) )
+    assert_equal( 1, twdc.count( "key_3" ) )
+    assert_equal( 1, twdc.count( "key_4" ) )
+    assert_equal( 1, twdc.count( "key_5" ) )
+    assert_equal( 0, twdc.count( "key_6" ) )
+
+    assert_equal( 2, twdc.count( ["key_1", "key_2"] )["key_1"] )
+    assert_equal( 3, twdc.count( ["key_1", "key_2"] )["key_2"] )
+    assert_equal( 0, twdc.count( ["key_6"] )["key_6"] )
+  end
+
+  def test_integration_drop_array_keys
+    twdc = TimeWindowDropCollector.new { client :mock }
+
+    twdc.drop( ["key_1", "key_2"] )
+
+    assert_equal( 1, twdc.count( "key_1" ) )
+    assert_equal( 1, twdc.count( "key_2" ) )
+  end
+
+  def test_integration_drop_and_count_with_numerical_keys
+    twdc = TimeWindowDropCollector.new { client :mock }
+
+    twdc.drop( 1000 )
+    twdc.drop( [1001])
+
+    assert_equal( 1, twdc.count( 1000 ) )
+    assert_equal( 1, twdc.count( 1001 ) )
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: time_window_drop_collector
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-25 00:00:00.000000000Z
+date: 2012-01-26 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70114503076580 !ruby/object:Gem::Requirement
+  requirement: &70135818124120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.21
   type: :development
   prerelease: false
-  version_requirements: *70114503076580
+  version_requirements: *70135818124120
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70114503076080 !ruby/object:Gem::Requirement
+  requirement: &70135818123620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -33,10 +33,10 @@ dependencies:
         version: 0.9.2.2
   type: :development
   prerelease: false
-  version_requirements: *70114503076080
+  version_requirements: *70135818123620
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70114503075620 !ruby/object:Gem::Requirement
+  requirement: &70135818123160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -44,10 +44,10 @@ dependencies:
         version: 0.10.0
   type: :development
   prerelease: false
-  version_requirements: *70114503075620
+  version_requirements: *70135818123160
 - !ruby/object:Gem::Dependency
   name: delorean
-  requirement: &70114503075160 !ruby/object:Gem::Requirement
+  requirement: &70135818122700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -55,10 +55,10 @@ dependencies:
         version: 1.2.0
   type: :development
   prerelease: false
-  version_requirements: *70114503075160
+  version_requirements: *70135818122700
 - !ruby/object:Gem::Dependency
   name: memcache_mock
-  requirement: &70114503074700 !ruby/object:Gem::Requirement
+  requirement: &70135818122240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -66,10 +66,10 @@ dependencies:
         version: 0.0.1
   type: :development
   prerelease: false
-  version_requirements: *70114503074700
+  version_requirements: *70135818122240
 - !ruby/object:Gem::Dependency
   name: dalli
-  requirement: &70114503074320 !ruby/object:Gem::Requirement
+  requirement: &70135818121860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -77,7 +77,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70114503074320
+  version_requirements: *70135818121860
 description: Counter storage system for a concrete time window
 email:
 - fguillen.mail@gmail.com
@@ -95,7 +95,9 @@ files:
 - lib/time_window_drop_collector.rb
 - lib/time_window_drop_collector/config.rb
 - lib/time_window_drop_collector/logger.rb
+- lib/time_window_drop_collector/results.rb
 - lib/time_window_drop_collector/storage.rb
+- lib/time_window_drop_collector/utils.rb
 - lib/time_window_drop_collector/version.rb
 - lib/time_window_drop_collector/wrapper.rb
 - lib/time_window_drop_collector/wrappers/memcache.rb