time_window_drop_collector 0.0.5

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp
+.rvmrc

data/.rvmrc.example

@@ -0,0 +1 @@
+rvm use 1.9.2@time_window_drop_collector

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,68 @@
+# Time Window Drop Collector
+
+System to keep record of an _amount_ for a concrete duration.
+
+With _Time Window Drop Collector_ you can define a **maximun time** you want to keep the record.
+
+You can also keep record for **different keys**.
+
+## How to use
+
+### Install
+
+    gem install time_window_drop_collector
+
+### Config
+
+These are the default values
+
+    twdc =
+      TimeWindowDropCollector.new do
+        client :memcache, "localhost:11211"     # underneeth client
+        window 600                              # in seconds
+        slices 10                               # one slice every minute
+      end
+
+### Use
+
+    twdc.drop( "id1" )
+    twdc.drop( "id1" )
+    twdc.drop( "id2" )
+    twdc.drop( ["id1", "id2"] )
+
+    twdc.count( "id1" )  # => 3
+
+    # after 10 minutes
+    twdc.count( "id1" )  # => 0
+
+## Cache clients wrappers
+
+Now we have implementation for 3 diferent underneeth cache clients.
+
+### Memcache
+
+It uses the Dalli Client for memcache.
+
+    twdc =
+      TimeWindowDropCollector.new do
+        client :memcache, "localhost:11211"
+      end
+
+### Rails cache
+
+It uses the `Rails.cache` accesible
+
+    twdc =
+      TimeWindowDropCollector.new do
+        client :rails_cache
+      end
+
+
+### Redis
+
+    twdc =
+      TimeWindowDropCollector.new do
+        client :redis, { :host => "host", :port => "port" }
+      end
+
+At the moment this wrapper does not support auto-key-clean so the stored keys will be there until anyone delete them.

data/Rakefile

@@ -0,0 +1,18 @@
+# require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rake/testtask'
+require 'bundler'
+
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << '.'
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+

data/lib/time_window_drop_collector/config.rb

@@ -0,0 +1,20 @@
+module TimeWindowDropCollector::Config
+  def self.extract( block )
+    @opts = {}
+    instance_eval( &block )
+    @opts
+  end
+
+  def self.client( type, *opts )
+    @opts[:client] = type
+    @opts[:client_opts] = opts
+  end
+
+  def self.window( seconds )
+    @opts[:window] = seconds
+  end
+
+  def self.slices( num )
+    @opts[:slices] = num
+  end
+end

data/lib/time_window_drop_collector/logger.rb

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

data/lib/time_window_drop_collector/storage.rb

@@ -0,0 +1,46 @@
+class TimeWindowDropCollector::Storage
+  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
+  end
+
+  def 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

@@ -0,0 +1,3 @@
+class TimeWindowDropCollector
+  VERSION = "0.0.5"
+end

data/lib/time_window_drop_collector/wrapper.rb

@@ -0,0 +1,16 @@
+module TimeWindowDropCollector::Wrapper
+  def self.instance( type, opts = nil )
+    case type
+    when :memcache
+      TimeWindowDropCollector::Wrappers::Memcache.new( opts )
+    when :redis
+      TimeWindowDropCollector::Wrappers::Redis.new( opts )
+    when :rails_cache
+      TimeWindowDropCollector::Wrappers::RailsCache.new( opts )
+    when :mock
+      TimeWindowDropCollector::Wrappers::Mock.new( opts )
+    else
+      raise ArgumentError, "type not supported: '#{type}'"
+    end
+  end
+end

data/lib/time_window_drop_collector/wrappers/memcache.rb

@@ -0,0 +1,19 @@
+class TimeWindowDropCollector
+  module Wrappers
+    class Memcache
+      attr_reader :client
+
+      def initialize( opts )
+        @client = Dalli::Client.new( *opts )
+      end
+
+      def incr( key, expire_time )
+        client.incr( key, 1, expire_time, 1 )
+      end
+
+      def values_for( keys )
+        client.get_multi( keys ).values
+      end
+    end
+  end
+end

data/lib/time_window_drop_collector/wrappers/mock.rb

@@ -0,0 +1,19 @@
+class TimeWindowDropCollector
+	module Wrappers
+		class Mock
+			attr_reader :client
+
+			def initialize( opts )
+				@client = MemcacheMock.new
+			end
+
+			def incr( key, expire_time )
+				client.incr( key, 1, nil, 1 )
+			end
+
+			def values_for( keys )
+				client.get_multi( keys ).values
+			end
+		end
+	end
+end

data/lib/time_window_drop_collector/wrappers/rails_cache.rb

@@ -0,0 +1,21 @@
+class TimeWindowDropCollector
+	module Wrappers
+		class RailsCache
+			attr_reader :client
+
+			def initialize( opts )
+				@client = Rails.cache
+			end
+
+			def incr( key, expire_time )
+				value = client.read( key ).to_i + 1
+				client.write( key, value, :expires_in => expire_time )
+			end
+
+			def values_for( keys )
+				client.read_multi( keys ).values
+			end
+		end
+	end
+end
+

data/lib/time_window_drop_collector/wrappers/redis.rb

@@ -0,0 +1,20 @@
+class TimeWindowDropCollector
+  module Wrappers
+    class Redis
+  		attr_reader :client
+
+      def initialize( opts )
+        @client = ::Redis.new( *opts )
+      end
+
+  		def incr( key, expire_time )
+  			client.incr( key )
+  		end
+
+  		def values_for( keys )
+  			client.mget( *keys )
+  		end
+  	end
+  end
+end
+

data/lib/time_window_drop_collector.rb

@@ -0,0 +1,37 @@
+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/storage"
+require_relative "time_window_drop_collector/wrapper"
+require_relative "time_window_drop_collector/wrappers/memcache"
+require_relative "time_window_drop_collector/wrappers/mock"
+require_relative "time_window_drop_collector/wrappers/redis"
+require_relative "time_window_drop_collector/wrappers/rails_cache"
+
+class TimeWindowDropCollector
+  attr_reader :config, :wrapper, :storage
+
+  def initialize( &block )
+    @config = {
+      :window       => 600,
+      :slices       => 10,
+      :client       => :memcache,
+      :client_opts  => "localhost:11211"
+    }
+
+    @config.merge!( TimeWindowDropCollector::Config.extract( block ) ) if block_given?
+
+    @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 )
+  end
+
+  def count( key )
+    storage.count( key )
+  end
+end

data/test/config_test.rb

@@ -0,0 +1,23 @@
+require_relative "test_helper"
+
+class ConfigTest < Test::Unit::TestCase
+  def setup
+    TimeWindowDropCollector::Logger.stubs( :log )
+  end
+
+  def test_config
+    proc =
+      Proc.new do
+        client "client", "client_opt1", "client_opt2"
+        window "window"
+        slices "slices"
+      end
+
+    config = TimeWindowDropCollector::Config.extract( proc )
+
+    assert_equal( "client", config[:client] )
+    assert_equal( ["client_opt1", "client_opt2"], config[:client_opts] )
+    assert_equal( "window", config[:window] )
+    assert_equal( "slices", config[:slices] )
+  end
+end

data/test/logger_test.rb

@@ -0,0 +1,11 @@
+require_relative "test_helper"
+
+class LoggerTest < Test::Unit::TestCase
+  def test_log
+    IO.any_instance.expects( :puts ).with( "[TWDC 2001-02-01 04:05:06] hello!" )
+
+    Delorean.time_travel_to( "2001-02-01 04:05:06" ) do
+      TimeWindowDropCollector::Logger.log( "hello!" )
+    end
+  end
+end

data/test/memcache_wrapper_test.rb

@@ -0,0 +1,21 @@
+require_relative "test_helper"
+
+class MemcacheWrapperTest < Test::Unit::TestCase
+  def test_initialize
+    Dalli::Client.expects( :new ).with( "arg1" ).returns( "client" )
+    wrapper = TimeWindowDropCollector::Wrappers::Memcache.new( ["arg1"] )
+    assert_equal( "client", wrapper.client )
+  end
+
+  def test_incr
+    wrapper = TimeWindowDropCollector::Wrappers::Memcache.new( ["arg1"] )
+    wrapper.client.expects( :incr ).with( "key", 1, "expire_time", 1 )
+    wrapper.incr( "key", "expire_time" )
+  end
+
+  def test_values_for
+    wrapper = TimeWindowDropCollector::Wrappers::Memcache.new( ["arg1"] )
+    wrapper.client.expects( :get_multi ).with( "keys" ).returns( {:a => 1, :b => 2} )
+    assert_equal( [1, 2], wrapper.values_for( "keys" ))
+  end
+end

data/test/mock_wrapper_test.rb

@@ -0,0 +1,21 @@
+require_relative "test_helper"
+
+class MockWrapperTest < Test::Unit::TestCase
+  def test_initialize
+    MemcacheMock.expects( :new ).returns( "client" )
+    wrapper = TimeWindowDropCollector::Wrappers::Mock.new( ["arg1"] )
+    assert_equal( "client", wrapper.client )
+  end
+
+  def test_incr
+    wrapper = TimeWindowDropCollector::Wrappers::Mock.new( ["arg1"] )
+    wrapper.client.expects( :incr ).with( "key", 1, nil, 1 )
+    wrapper.incr( "key", "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" ))
+  end
+end

data/test/rails_cache_wrapper_test.rb

@@ -0,0 +1,28 @@
+require_relative "test_helper"
+
+class MemcacheWrapperTest < Test::Unit::TestCase
+  def setup
+    @rails_client = mock()
+    Rails.stubs( :cache ).returns( @rails_cache )
+  end
+
+  def test_initialize
+    Rails.expects( :cache ).returns( "client" )
+    wrapper = TimeWindowDropCollector::Wrappers::RailsCache.new( ["arg1"] )
+    assert_equal( "client", wrapper.client )
+  end
+
+  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.incr( "key", "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" ))
+  end
+end

data/test/redis_wrapper_test.rb

@@ -0,0 +1,26 @@
+require_relative "test_helper"
+
+class Redis
+  def initialize( *opts )
+  end
+end
+
+class MemcacheWrapperTest < Test::Unit::TestCase
+  def test_initialize
+    Redis.expects( :new ).with( "arg1", "arg2" ).returns( "client" )
+    wrapper = TimeWindowDropCollector::Wrappers::Redis.new( ["arg1", "arg2"] )
+    assert_equal( "client", wrapper.client )
+  end
+
+  def test_incr
+    wrapper = TimeWindowDropCollector::Wrappers::Redis.new( ["arg1"] )
+    wrapper.client.expects( :incr ).with( "key" )
+    wrapper.incr( "key", "expire_time" )
+  end
+
+  def test_values_for
+    wrapper = TimeWindowDropCollector::Wrappers::Redis.new( ["arg1"] )
+    wrapper.client.expects( :mget ).with( "key1", "key2" ).returns( [1, 2] )
+    assert_equal( [1, 2], wrapper.values_for( ["key1", "key2"] ))
+  end
+end

data/test/storage_test.rb

@@ -0,0 +1,234 @@
+require_relative "test_helper"
+
+class StorageTest < Test::Unit::TestCase
+  def setup
+    @client = mock()
+    @storage = TimeWindowDropCollector::Storage.new( @client, 600, 10 )
+  end
+
+  def test_time_key_when_time_is_present
+    timestamp = Time.new( 2001, 2, 3, 4, 5 )
+    assert_equal( "drop_window_key_981169500000", @storage.time_key( "key", timestamp ) )
+  end
+
+  def test_time_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" ))
+  end
+
+  def test_time_keys_should_return_10_keys_for_the_last_10_minutes
+    keys = [
+      "drop_window_key_1325560800000",
+      "drop_window_key_1325560740000",
+      "drop_window_key_1325560680000",
+      "drop_window_key_1325560620000",
+      "drop_window_key_1325560560000",
+      "drop_window_key_1325560500000",
+      "drop_window_key_1325560440000",
+      "drop_window_key_1325560380000",
+      "drop_window_key_1325560320000",
+      "drop_window_key_1325560260000"
+    ]
+
+    Delorean.time_travel_to( '2012-01-03 04:20' ) do
+      assert_equal( keys, @storage.time_keys( "key" ))
+    end
+  end
+
+  def test_incr
+    @storage.expects( :time_key ).with( "key" ).returns( "time_key" )
+    @client.expects( :incr ).with( "time_key", 600 )
+
+    @storage.incr( "key" )
+  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"
+    ]
+
+    values = [nil, 1, "2", 3, 4, 5]
+
+    @storage.expects( :time_keys ).with( "key" ).returns( "keys" )
+    @client.expects( :values_for ).with( "keys" ).returns( values )
+
+    assert_equal( 15, @storage.count( "key" ))
+  end
+
+  def test_count_when_empty_values
+    @storage.stubs( :time_keys )
+    @client.expects( :values_for ).returns( [] )
+    assert_equal( 0, @storage.count( "key" ))
+  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 )
+
+    assert_equal( 1, storage.count( key_1 ))
+    assert_equal( 2, storage.count( key_2 ))
+    assert_equal( 1, storage.count( key_3 ))
+  end
+
+  def test_slice_start_timestamp
+    storage = TimeWindowDropCollector::Storage.new( nil, 100, 10 )
+    time    = Time.new( 2001, 2, 3, 4, 5 )
+
+    assert_equal( 981169500000, storage.slice_start_timestamp( time ) )
+    assert_equal( 981169500000, storage.slice_start_timestamp( time + 1 ) )
+    assert_equal( 981169500000, storage.slice_start_timestamp( time + 9 ) )
+    assert_equal( 981169520000, storage.slice_start_timestamp( time + 25 ) )
+    assert_equal( 981169600000, storage.slice_start_timestamp( time + 100 ) )
+  end
+
+  def test_slice_start_timestamp_with_slice_sizes_no_integer
+    storage = TimeWindowDropCollector::Storage.new( nil, 100, 12 )
+    time    = Time.new( 2001, 2, 3, 4, 5 )
+
+    assert_equal( 981169493317, storage.slice_start_timestamp( time ) )
+    assert_equal( 981169493317, storage.slice_start_timestamp( time + 1 ) )
+    assert_equal( 981169501650, storage.slice_start_timestamp( time + 9 ) )
+    assert_equal( 981169518316, storage.slice_start_timestamp( time + 25 ) )
+    assert_equal( 981169593313, storage.slice_start_timestamp( time + 100 ) )
+  end
+
+  def test_slice_start_timestamp_with_slice_size_less_than_a_second
+    storage = TimeWindowDropCollector::Storage.new( nil, 100, 101 )
+    time    = Time.new( 2001, 2, 3, 4, 5 )
+
+    assert_equal( 981169499970, storage.slice_start_timestamp( time ) )
+    assert_equal( 981169500960, storage.slice_start_timestamp( time + 1 ) )
+    assert_equal( 981169508880, storage.slice_start_timestamp( time + 9 ) )
+    assert_equal( 981169524720, storage.slice_start_timestamp( time + 25 ) )
+    assert_equal( 981169599960, storage.slice_start_timestamp( time + 100 ) )
+  end
+
+  def test_window_size_consistency
+    window  = 100
+    slices  = 10
+    storage = TimeWindowDropCollector::Storage.new( nil, window, slices )
+    time    = Time.new( 2001, 2, 3, 4, 5 )
+
+    first_slice = storage.slice_start_timestamp( time )
+    last_slice = storage.slice_start_timestamp( time + 101 )
+
+    assert_equal( window, ( last_slice - first_slice ) / 1000 )
+  end
+
+  def test_window_size_consistency_with_slice_sizes_no_integer
+    window  = 100
+    slices  = 12
+    storage = TimeWindowDropCollector::Storage.new( nil, window, slices )
+    time    = Time.new( 2001, 2, 3, 4, 5 )
+
+    first_slice = storage.slice_start_timestamp( time )
+    last_slice = storage.slice_start_timestamp( time + 101 )
+
+    assert_equal( 99, ( last_slice - first_slice ) / 1000 )
+  end
+
+  def test_window_size_consistency_with_slice_sizes_less_than_a_second
+    window  = 100
+    slices  = 101
+    storage = TimeWindowDropCollector::Storage.new( nil, window, slices )
+    time    = Time.new( 2001, 2, 3, 4, 5 )
+
+    first_slice = storage.slice_start_timestamp( time )
+    last_slice = storage.slice_start_timestamp( time + 101 )
+
+    assert_equal( window, ( last_slice - first_slice ) / 1000 )
+  end
+
+  def test_integration_store_of_the_count_for_10_minutes
+    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 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:01' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:02' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:03' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:04' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:05' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:06' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:07' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:08' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:09' ) do
+      storage.incr( key_1 )
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:10' ) do
+      storage.incr( key_1 )
+    end
+
+    # counters
+    Delorean.time_travel_to( '2012-01-03 10:59' ) do
+      assert_equal( 0, storage.count( key_1 ))
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:00' ) do
+      assert_equal( 1, storage.count( key_1 ))
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:05' ) do
+      assert_equal( 6, storage.count( key_1 ))
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:10' ) do
+      assert_equal( 10, storage.count( key_1 ))
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:15' ) do
+      assert_equal( 5, storage.count( key_1 ))
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:19' ) do
+      assert_equal( 1, storage.count( key_1 ))
+    end
+
+    Delorean.time_travel_to( '2012-01-03 11:20' ) do
+      assert_equal( 0, storage.count( key_1 ))
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require "test/unit"
+require "mocha"
+require "delorean"
+require "memcache_mock"
+
+require_relative "../lib/time_window_drop_collector.rb"
+
+# mocking big classes
+class Rails
+  def self.cache
+  end
+end
+
+class Redis
+end
+

data/test/time_window_drop_collector_test.rb

@@ -0,0 +1,70 @@
+require_relative "test_helper"
+
+class TimeWindowDropCollectorTest < Test::Unit::TestCase
+  def setup
+    @twdc = TimeWindowDropCollector::Logger.stubs( :log )
+  end
+
+  def test_initialize_with_empty_config
+    TimeWindowDropCollector::Config.expects( :extract ).never
+    TimeWindowDropCollector::Wrapper.expects( :instance ).with( :memcache, "localhost:11211" ).returns( "wrapper" )
+    TimeWindowDropCollector::Storage.expects( :new ).with( "wrapper", 600, 10 ).returns( "storage" )
+
+    twdc = TimeWindowDropCollector.new
+
+    assert_equal( "wrapper", twdc.wrapper )
+    assert_equal( "storage", twdc.storage )
+  end
+
+
+  def test_initialize_with_block_config
+    config = {
+      :window       => "window",
+      :slices       => "slices",
+      :client       => "client",
+      :client_opts  => "client_opts"
+    }
+
+    TimeWindowDropCollector::Config.expects( :extract ).returns( config )
+    TimeWindowDropCollector::Wrapper.expects( :instance ).with( "client", "client_opts" ).returns( "wrapper" )
+    TimeWindowDropCollector::Storage.expects( :new ).with( "wrapper", "window", "slices" ).returns( "storage" )
+
+    twdc = TimeWindowDropCollector.new {}
+  end
+
+  def test_drop
+    storage = mock()
+    storage.expects( :incr ).with( "key" )
+
+    twdc = TimeWindowDropCollector.new
+    twdc.stubs( :storage ).returns( storage )
+
+    twdc.drop( "key" )
+  end
+
+  def test_count
+    storage = mock()
+    storage.expects( :count ).with( "key" )
+
+    twdc = TimeWindowDropCollector.new
+    twdc.stubs( :storage ).returns( storage )
+
+    twdc.count( "key" )
+  end
+
+  def test_integration_new
+    twdc =
+      TimeWindowDropCollector.new do
+        client :memcache
+        window 100
+        slices 20
+      end
+
+    assert( twdc.wrapper.is_a? TimeWindowDropCollector::Wrappers::Memcache )
+    assert( twdc.wrapper.client.is_a? Dalli::Client )
+    assert( twdc.storage.is_a? TimeWindowDropCollector::Storage )
+
+    assert_equal( 100, twdc.storage.window )
+    assert_equal( 20, twdc.storage.slices )
+  end
+end

data/test/wrapper_test.rb

@@ -0,0 +1,23 @@
+require_relative "test_helper"
+
+class WrapperTest < Test::Unit::TestCase
+  def test_instance_when_memcache
+    instance = TimeWindowDropCollector::Wrapper.instance( :memcache, "localhost:11211" )
+    assert( instance.is_a? TimeWindowDropCollector::Wrappers::Memcache )
+  end
+
+  def test_instance_when_mock
+    instance = TimeWindowDropCollector::Wrapper.instance( :mock )
+    assert( instance.is_a? TimeWindowDropCollector::Wrappers::Mock )
+  end
+
+  def test_instance_when_redis
+    instance = TimeWindowDropCollector::Wrapper.instance( :redis, ["server", "port"] )
+    assert( instance.is_a? TimeWindowDropCollector::Wrappers::Redis )
+  end
+
+  def test_instance_when_rails_cache
+    instance = TimeWindowDropCollector::Wrapper.instance( :rails_cache )
+    assert( instance.is_a? TimeWindowDropCollector::Wrappers::RailsCache )
+  end
+end

data/time_window_drop_collector.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path( "../lib", __FILE__ )
+require "time_window_drop_collector/version"
+
+Gem::Specification.new do |s|
+  s.name        = "time_window_drop_collector"
+  s.version     = TimeWindowDropCollector::VERSION
+  s.authors     = ["Fernando Guillen", "Carlos Moutinho"]
+  s.email       = ["fguillen.mail@gmail.com", "carlosmoutinho@gmail.com"]
+  s.homepage    = ""
+  s.summary     = "Counter storage system for a concrete time window"
+  s.description = "Counter storage system for a concrete time window"
+
+  s.rubyforge_project = "time_window_drop_collector"
+
+  s.files         = `git ls-files`.split( "\n" )
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split( "\n" )
+  s.executables   = `git ls-files -- bin/*`.split( "\n" ).map{ |f| File.basename( f ) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler",         "1.0.21"
+  s.add_development_dependency "rake",            "0.9.2.2"
+  s.add_development_dependency "mocha",           "0.10.0"
+  s.add_development_dependency "delorean",        "1.2.0"
+  s.add_development_dependency "memcache_mock",   "0.0.1"
+
+  s.add_dependency "dalli"
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: time_window_drop_collector
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Fernando Guillen
+- Carlos Moutinho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-23 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70242052766820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.0.21
+  type: :development
+  prerelease: false
+  version_requirements: *70242052766820
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70242052766320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: *70242052766320
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70242052765860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: *70242052765860
+- !ruby/object:Gem::Dependency
+  name: delorean
+  requirement: &70242052765400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: *70242052765400
+- !ruby/object:Gem::Dependency
+  name: memcache_mock
+  requirement: &70242052764940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: *70242052764940
+- !ruby/object:Gem::Dependency
+  name: dalli
+  requirement: &70242052764560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70242052764560
+description: Counter storage system for a concrete time window
+email:
+- fguillen.mail@gmail.com
+- carlosmoutinho@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc.example
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- 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/storage.rb
+- lib/time_window_drop_collector/version.rb
+- lib/time_window_drop_collector/wrapper.rb
+- lib/time_window_drop_collector/wrappers/memcache.rb
+- lib/time_window_drop_collector/wrappers/mock.rb
+- lib/time_window_drop_collector/wrappers/rails_cache.rb
+- lib/time_window_drop_collector/wrappers/redis.rb
+- test/config_test.rb
+- test/logger_test.rb
+- test/memcache_wrapper_test.rb
+- test/mock_wrapper_test.rb
+- test/rails_cache_wrapper_test.rb
+- test/redis_wrapper_test.rb
+- test/storage_test.rb
+- test/test_helper.rb
+- test/time_window_drop_collector_test.rb
+- test/wrapper_test.rb
+- time_window_drop_collector.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: time_window_drop_collector
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Counter storage system for a concrete time window
+test_files:
+- test/config_test.rb
+- test/logger_test.rb
+- test/memcache_wrapper_test.rb
+- test/mock_wrapper_test.rb
+- test/rails_cache_wrapper_test.rb
+- test/redis_wrapper_test.rb
+- test/storage_test.rb
+- test/test_helper.rb
+- test/time_window_drop_collector_test.rb
+- test/wrapper_test.rb