rails_kvs_driver 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43aaa6cb1c1eda29e5fde51a68910efef0130eab
-  data.tar.gz: f4b8ad4279aeb5bb9fcc4932a7f19fc0f86397ca
+  metadata.gz: 1e593c4955c29dcdfe11f5ba320aa3d5e3262251
+  data.tar.gz: bb9a9327fdef6c49cf64acb0565a4ed0163142f8
 SHA512:
-  metadata.gz: e067da7e256b8ed8c2e10e150a544d982543c44fb13e42aecd6d9b40f7404ea6dcc830152f4f8aa1e641118fbffb5d01a86491e250623415c410495f227b2a77
-  data.tar.gz: 7b4fa836600e0f9a8134c2cd7b2a6443038786ad87139bb8de6af8cd9a3784e4f6015af0552bf02b5e1b54cc05df602378732565fe329a16cc1f451fa5b236b0
+  metadata.gz: a01624d8410630bba00809f990423862107247a81c78a17e207c3d65d54e4cb738414dc9ac13341784cb524926c108ccfb4f6194c6ea0be0e7793ad0e4b4db74
+  data.tar.gz: a46652a0bf33b7014009b6dceac46a8e37a75b98594a93a0ab40824f751110c260edf49d239630a73d4fdd5f0b73c5579a3cf2f9a42f0f3b3486cae36a22df1d

data/lib/rails_kvs_driver/defined_base_method.rb

@@ -0,0 +1,30 @@
+require 'rails_kvs_driver/sorted_set'
+module RailsKvsDriver
+  module DefinedBaseMethod
+    # initialize driver.
+    # @param kvs_instance  [Object] instance of key-value store.
+    # @param driver_config [Hash]   driver config.
+    def initialize(kvs_instance, driver_config)
+      @kvs_instance  = kvs_instance
+      @driver_config = driver_config
+    end
+
+    # return initialized SortedSet class.
+    #
+    def sorted_sets
+      RailsKvsDriver::SortedSet.new(self)
+    end
+
+    # execute the block of code for each key having string, and value.
+    # @param &block   [{|key, value| }] each the block of code for each key having string, and value.
+    def each
+      keys.each {|key| yield key, self[key] }
+    end
+
+    # get length of keys.
+    def length
+      keys.length
+    end
+
+  end
+end

data/lib/rails_kvs_driver/session.rb

@@ -0,0 +1,110 @@
+require 'connection_pool'
+require 'rails_kvs_driver/validation_driver_config'
+
+module RailsKvsDriver
+  # @attr DriverConnectionPool [Hash] This Constants pools the connecting driver.
+  # {
+  #   driver_class_name => [{:config => driver_config, :pool => ConnectionPool }, ....  ]
+  #
+  #   ...
+  #
+  # }
+  KVS_CONNECTION_POOL = Hash.new
+
+
+  module Session
+    include RailsKvsDriver::ValidationDriverConfig
+
+    # connect kvs and exec block.
+    # This function pools the connecting driver.
+    #
+    # @example
+    #   config = {
+    #     :host           => 'localhost', # host of KVS.
+    #     :port           => 6379,        # port of KVS.
+    #     :namespace      => 'Example',   # namespace of avoid a conflict with key
+    #     :timeout_sec    => 5,           # timeout seconds.
+    #     :pool_size      => 5,           # connection pool size.
+    #     :config_key     => :none        # this key is option.(defaults=:none)
+    #                                     #  when set this key.
+    #                                     #  will refer to a connection-pool based on config_key,
+    #                                     #  even if driver setting is the same without this key.
+    #   }
+    #   result = Driver.session(config) do |kvs|
+    #     kvs['example'] = 'abc'
+    #     kvs['example']
+    #   end
+    #
+    #   puts result  # => 'abc'
+    #
+    # @param driver_config [Hash] driver_config.
+    # @param &block [{|driver_instance| #something... }] exec block.
+    # @return [Object] status
+    def session(driver_config, &block)
+      driver_config = validate_driver_config!(driver_config)
+      driver_connection_pool(self, driver_config).with do |kvs_instance|
+        block.call(self.new(kvs_instance, driver_config))
+      end
+    end
+
+
+    private
+    # get driver connection pool
+    # if doesn't exist pool, it's made newly.
+    #
+    # @param driver_class   [RailsKvsDriver::Base]  driver_class
+    # @param driver_config  [Hash]                  driver_config
+    # @return [ConnectionPool] connection pool of driver
+    def driver_connection_pool(driver_class, driver_config)
+      pool = search_driver_connection_pool(driver_class, driver_config)
+      return (pool.nil?) ? set_driver_connection_pool(driver_class, driver_config) : pool
+    end
+
+    # set driver connection pool
+    #
+    # @param driver_class   [RailsKvsDriver::Base]  driver_class
+    # @param driver_config  [Hash]                  driver_config
+    # @return [ConnectionPool] connection pool of driver
+    def set_driver_connection_pool(driver_class, driver_config)
+      conf = {
+          size:     driver_config[:pool_size],
+          timeout:  driver_config[:timeout_sec]
+      }
+      pool = ConnectionPool.new(conf) { driver_class.connect(driver_config) }
+
+      RailsKvsDriver::KVS_CONNECTION_POOL[driver_class.name] ||= Array.new
+      RailsKvsDriver::KVS_CONNECTION_POOL[driver_class.name].push({config: driver_config, pool: pool})
+
+      return pool
+    end
+
+    # search driver connection pool
+    #
+    # @param driver_class   [RailsKvsDriver::Base]  driver_class
+    # @param driver_config  [Hash]                  driver_config
+    # @return [ConnectionPool] connection pool of driver, or nil
+    def search_driver_connection_pool(driver_class, driver_config)
+      if RailsKvsDriver::KVS_CONNECTION_POOL.has_key?(driver_class.name)
+        RailsKvsDriver::KVS_CONNECTION_POOL[driver_class.name].each do |pool_set|
+          return pool_set[:pool] if equal_driver_config?(pool_set[:config], driver_config)
+        end
+      end
+
+      return nil
+    end
+
+    # compare driver config.
+    #
+    # @param config1 [Hash] driver config
+    # @param config2 [Hash] driver config
+    def equal_driver_config?(config1, config2)
+      return false unless config1[:host]        == config2[:host]
+      return false unless config1[:port]        == config2[:port]
+      return false unless config1[:timeout_sec] == config2[:timeout_sec]
+      return false unless config1[:pool_size]   == config2[:pool_size]
+      return false unless config1[:config_key]  == config2[:config_key]
+      return true
+    end
+
+  end
+end

data/lib/rails_kvs_driver/sorted_set.rb

@@ -0,0 +1,88 @@
+module RailsKvsDriver
+  class SortedSet
+    attr_accessor :driver_instance
+
+    # initialize sorted_set
+    #
+    # @param driver_instance [RailsKvsDriver::Base]
+    def initialize(driver_instance)
+      @driver_instance = driver_instance
+    end
+
+    # get sorted_set
+    # when the key doesn't exist, it's made newly.
+    #
+    # @param key    [String] sorted_set key.
+    # @param member [String] member of sorted_set.(default=nil)
+    # @return [Array<Array> or Integer] member_set[member, score]. when set member, return score of member.
+    def [](key, member=nil)
+      if member.nil?
+        @driver_instance.get_sorted_set(key)
+      else
+        @driver_instance.get_sorted_set_score(key, member)
+      end
+    end
+
+    # add sorted_set
+    # when the key doesn't exist, it's made newly.
+    #
+    # @param key [String] sorted_set key
+    # @param member_set [Array<member,score>] array of member<String> and score<Float>
+    # @return [Array] member_set
+    def []=(key, member_set)
+      @driver_instance.add_sorted_set(key, member_set[0], member_set[1])
+      return member_set
+    end
+
+    # delete key
+    def delete(key)
+      @driver_instance.delete(key)
+    end
+
+    # execute the block of code for each sorted_set.
+    # @param &block   [{|key| }] each the block of code for each key of sorted set.
+    def each
+      keys.each {|key| yield key }
+    end
+
+    # execute the block of code for each member of sorted set.
+    #
+    # @param key      [String]  key of sorted set.
+    # @param reverse  [Boolean] order by desc.
+    # @param limit    [Integer] limit number to acquire at a time.
+    # @param &block   [{|member, score, position| }] each the block of code for each member of sorted set.
+    def each_member(key, reverse=false, limit=1000)
+      member_count    = @driver_instance.count_sorted_set_member(key)
+      member_position = 0
+
+      while member_position < member_count
+        @driver_instance.get_sorted_set(key, member_position, member_position + (limit-1), reverse).each do |data|
+          yield data[0], data[1], member_position
+          member_position += 1
+        end
+      end
+    end
+
+    # increment member's score of sorted set.
+    #
+    # @param key    [String]  key of sorted set.
+    # @param member [String]  member of sorted set.
+    # @param score  [Float]   increment score
+    # @return [Float] score after increment.
+    def increment(key, member, score)
+      @driver_instance.increment_sorted_set(key, member, score)
+    end
+
+    # get all keys from kvs.
+    # @return [Array<String>] array of key names.
+    # @abstract get all keys from kvs.(only having string value)
+    def keys
+      @driver_instance.get_sorted_set_keys
+    end
+
+    # get length of sorted_set.
+    def length
+      keys.length
+    end
+  end
+end

data/lib/rails_kvs_driver/validation_driver_config.rb

@@ -0,0 +1,27 @@
+module RailsKvsDriver
+  module ValidationDriverConfig
+    # Validate driver_config.
+    # This method raise ArgumentError, if missing driver_config.
+    #
+    # @param driver_config [Hash] driver config.
+    # @return [Hash] driver_config
+    def validate_driver_config!(driver_config)
+      raise_argument_error!(:host)        unless driver_config.has_key? :host
+      raise_argument_error!(:port)        unless driver_config.has_key? :port
+      raise_argument_error!(:namespace)   unless driver_config.has_key? :namespace
+      raise_argument_error!(:timeout_sec) unless driver_config.has_key? :timeout_sec
+      raise_argument_error!(:pool_size)   unless driver_config.has_key? :pool_size
+
+      driver_config[:config_key] = :none  unless driver_config.has_key? :config_key
+
+      return driver_config
+    end
+
+    # raise argument error.
+    #
+    # @param key [String] not exists key.
+    def raise_argument_error!(key)
+      raise ArgumentError, "driver_config does not include #{key}"
+    end
+  end
+end

data/lib/rails_kvs_driver/version.rb

@@ -1,3 +1,3 @@
 module RailsKvsDriver
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/rails_kvs_driver.rb

@@ -1,47 +1,40 @@
 require 'rails_kvs_driver/version'
-require 'connection_pool'
+require 'rails_kvs_driver/session'
+require 'rails_kvs_driver/defined_base_method'
 
 module RailsKvsDriver
   # This abstract class wrap accessing to Key-Value Store.
   # @abstract
   class Base
-
-    # @attr DriverConnectionPool [Hash] This Constants pools the connecting driver.
-    # {
-    #   driver_class_name => [{:config => driver_config, :pool => ConnectionPool }, ....  ]
-    #
-    #   ...
-    #
-    # }
-    DriverConnectionPool = Hash.new
+    extend RailsKvsDriver::Session
+    include RailsKvsDriver::DefinedBaseMethod
 
     # @attr @kvs_instance [Object] instance of KVS.
     attr_accessor :kvs_instance
 
     # @attr @driver_config [Hash] config of driver.
-    # {
-    #   :host           => 'localhost' # host of KVS.
-    #   :port           => 6379        # port of KVS.
-    #   :namespace      => 'Example'   # namespace of avoid a conflict with key
-    #   :timeout_sec    => 5           # timeout seconds.
-    #   :pool_size      => 5           # connection pool size.
-    # }
+    #  {
+    #     :host           => 'localhost', # host of KVS.
+    #     :port           => 6379,        # port of KVS.
+    #     :namespace      => 'Example',   # namespace of avoid a conflict with key
+    #     :timeout_sec    => 5,           # timeout seconds.
+    #     :pool_size      => 5,           # connection pool size.
+    #     :config_key     => :none,       # this key is option.(defaults=:none)
+    #                                     #  when set this key.
+    #                                     #  will refer to a connection-pool based on config_key,
+    #                                     #  even if driver setting is the same without this key.
+    #   }
     attr_accessor :driver_config
 
-    # initialize driver, and connect kvs.
-    # @param driver_config [Hash] driver config.
-    def initialize(driver_config)
-      @driver_config = validate_driver_config!(driver_config)
-      connect
-    end
-
     # connect with driver config.
-    # @return [Boolean] result
-    def connect
+    # @param driver_config [Hash]   driver config.
+    # @return [Object] instance of key-value store.
+    # @abstract connect with driver config. and return instance of kvs.
+    def self.connect(driver_config)
       raise NoMethodError
     end
 
-    # get value from kvs.
+    # get string value from kvs.
     # @param key [String] key.
     # @return [String] value
     # @abstract get value from kvs.
@@ -49,7 +42,7 @@ module RailsKvsDriver
       raise NoMethodError
     end
 
-    # set value to kvs.
+    # set string value to kvs.
     # @param key    [String] key.
     # @param value  [String] value.
     # @return [Boolean] result
@@ -60,8 +53,8 @@ module RailsKvsDriver
 
     # get all keys from kvs.
     # @return [Array<String>] array of key names.
-    # @abstract get all keys from kvs.
-    def all_keys
+    # @abstract get all keys from kvs.(only having string value)
+    def keys
       raise NoMethodError
     end
 
@@ -92,27 +85,32 @@ module RailsKvsDriver
       raise NoMethodError
     end
 
-    # remove sorted set from kvs.
-    # This function doesn't delete a key.
+    # count members of sorted set
     # @note same as sorted set of redis. refer to redis.
     #
-    # @param key    [String]  key of sorted set.
-    # @param member [String]  member of sorted set.
-    # @return [Boolean] result.
-    # @abstract remove sorted set from kvs.
-    def remove_sorted_set(key, member)
+    # @param key [String]  key of sorted set.
+    # @return [Integer] members num
+    def count_sorted_set_member(key)
       raise NoMethodError
     end
 
-    # increment score of member from sorted set.
+    # get array of sorted set.
     # @note same as sorted set of redis. refer to redis.
     #
-    # @param key    [String]  key of sorted set.
-    # @param member [String]  member of sorted set.
-    # @param score  [Float]   increment score.
-    # @return [Float] value after increment
-    # @abstract increment score of member from sorted set.
-    def increment_sorted_set(key, member, score)
+    # @param key      [String]  key of sorted set.
+    # @param start    [Integer] start index
+    # @param stop     [Integer] stop index
+    # @param reverse  [Boolean] order by desc.
+    # @return [Array<String, Float>>] array of the member and score.
+    # @abstract get array of sorted set.
+    def get_sorted_set(key, start=0, stop=-1, reverse=false)
+      raise NoMethodError
+    end
+
+    # get all sorted_set keys.
+    # @return [Array<String>] array of key names.
+    # @abstract get all keys from kvs.(only having sorted_set)
+    def get_sorted_set_keys
       raise NoMethodError
     end
 
@@ -123,140 +121,33 @@ module RailsKvsDriver
     # @param member [String]  member of sorted set.
     # @return [Float] score of member.
     # @abstract get the score of member.
-    def sorted_set_score(key, member)
+    def get_sorted_set_score(key, member)
       raise NoMethodError
     end
 
-    # get array of sorted set.
+    # increment score of member from sorted set.
     # @note same as sorted set of redis. refer to redis.
     #
-    # @param key      [String]  key of sorted set.
-    # @param start    [Integer] start index
-    # @param stop     [Integer] stop index
-    # @param reverse  [Boolean] order by desc.
-    # @return [Array<String, Float>>] array of the member and score.
-    # @abstract get array of sorted set.
-    def sorted_set(key, start=0, stop=-1, reverse=false)
+    # @param key    [String]  key of sorted set.
+    # @param member [String]  member of sorted set.
+    # @param score  [Float]   increment score.
+    # @return [Float] value after increment
+    # @abstract increment score of member from sorted set.
+    def increment_sorted_set(key, member, score)
       raise NoMethodError
     end
 
-    # count members of sorted set
+    # remove sorted set from kvs.
+    # This function doesn't delete a key.
     # @note same as sorted set of redis. refer to redis.
     #
-    # @param key [String]  key of sorted set.
-    # @return [Integer] members num
-    def count_sorted_set_member(key)
+    # @param key    [String]  key of sorted set.
+    # @param member [String]  member of sorted set.
+    # @return [Boolean] result.
+    # @abstract remove sorted set from kvs.
+    def remove_sorted_set(key, member)
       raise NoMethodError
     end
 
-    # execute the block of code for each member of sorted set.
-    # @param key      [String]  key of sorted set.
-    # @param reverse  [Boolean] order by desc.
-    # @param limit    [Integer] limit number to acquire at a time.
-    # @param &block   [{|member, score, position| }] each the block of code for each member of sorted set.
-    def each_sorted_set(key, reverse=false, limit=1000)
-      member_count    = count_sorted_set_member(key)
-      member_position = 0
-
-      while member_position < member_count
-        sorted_set(key, member_position, member_position + (limit-1), reverse).each do |data|
-          yield data[0], data[1], member_position
-          member_position += 1
-        end
-      end
-    end
-
-    # connect kvs and exec block.
-    # This function pools the connecting driver.
-    #
-    # @example
-    #   config = {
-    #     :host           => 'localhost' # host of KVS.
-    #     :port           => 6379        # port of KVS.
-    #     :namespace      => 'Example'   # namespace of avoid a conflict with key
-    #     :timeout_sec    => 5           # timeout seconds.
-    #     :pool_size      => 5           # connection pool size.
-    #   }
-    #   result = Driver.session(config) do |kvs|
-    #     kvs['example'] = 'abc'
-    #     kvs['example']
-    #   end
-    #
-    #   puts result  # => 'abc'
-    #
-    # @param driver_config [Hash] driver_config.
-    # @param &block [{|driver_instance| #something... }] exec block.
-    # @return [Object] status
-    def self.session(driver_config, &block)
-      driver_connection_pool(self, driver_config).with &block
-    end
-
-
-    private
-    # get driver connection pool
-    # if doesn't exist pool, it's made newly.
-    #
-    # @param driver_class   [RailsKvsDriver::Base]  driver_class
-    # @param driver_config  [Hash]                  driver_config
-    # @return [ConnectionPool] connection pool of driver
-    def self.driver_connection_pool(driver_class, driver_config)
-      pool = search_driver_connection_pool(driver_class, driver_config)
-      return (pool.nil?) ? set_driver_connection_pool(driver_class, driver_config) : pool
-    end
-
-    # set driver connection pool
-    #
-    # @param driver_class   [RailsKvsDriver::Base]  driver_class
-    # @param driver_config  [Hash]                  driver_config
-    # @return [ConnectionPool] connection pool of driver
-    def self.set_driver_connection_pool(driver_class, driver_config)
-      conf = {
-          size:     driver_config[:pool_size],
-          timeout:  driver_config[:timeout_sec]
-      }
-      pool = ConnectionPool.new(conf) { driver_class.new(driver_config) }
-
-      DriverConnectionPool[driver_class.name] = Array.new unless DriverConnectionPool.has_key?(driver_class.name)
-      DriverConnectionPool[driver_class.name].push({config: driver_config, pool: pool})
-
-      return pool
-    end
-
-    # search driver connection pool
-    #
-    # @param driver_class   [RailsKvsDriver::Base]  driver_class
-    # @param driver_config  [Hash]                  driver_config
-    # @return [ConnectionPool] connection pool of driver, or nil
-    def self.search_driver_connection_pool(driver_class, driver_config)
-      DriverConnectionPool[driver_class.name].each do |pool_set|
-        if pool_set[:config] == driver_config
-          return pool_set[:pool]
-        end
-      end if DriverConnectionPool.has_key?(driver_class.name)
-
-      return nil
-    end
-
-    # Validate driver_config.
-    # This method raise ArgumentError, if missing driver_config.
-    #
-    # @param driver_config [Hash] driver config.
-    # @return [Hash] driver_config
-    def validate_driver_config!(driver_config)
-      raise_argument_error!(:host)        unless driver_config.has_key? :host
-      raise_argument_error!(:port)        unless driver_config.has_key? :port
-      raise_argument_error!(:namespace)   unless driver_config.has_key? :namespace
-      raise_argument_error!(:timeout_sec) unless driver_config.has_key? :timeout_sec
-      raise_argument_error!(:pool_size)   unless driver_config.has_key? :pool_size
-
-      return driver_config
-    end
-
-    # raise argument error.
-    #
-    # @param key [String] not exists key.
-    def raise_argument_error!(key)
-      raise "driver_config does not include #{key}", ArgumentError
-    end
   end
 end

data/spec/rails_kvs_driver/defined_base_method_spec.rb

@@ -0,0 +1,44 @@
+require 'rspec'
+require 'spec_helper'
+
+describe RailsKvsDriver::DefinedBaseMethod do
+
+  context 'call initialize' do
+    it 'coping instance of driver_config' do
+      expect(MockDriver.new('kvs_dummy',nil).kvs_instance).to eq('kvs_dummy')
+    end
+
+    it 'coping instance of driver_config' do
+      expect(MockDriver.new(nil,@driver_config).driver_config).to eq(@driver_config)
+    end
+  end
+
+  context 'call sorted_sets' do
+    it 'return instance of RailsKvsDriver::SortedSet' do
+      expect(MockDriver.new(nil,nil).sorted_sets.instance_of?(RailsKvsDriver::SortedSet)).to be_true
+    end
+  end
+
+  context 'after iniaialized' do
+    before(:each) do
+      @instance = MockDriver.new(nil, nil)
+      @instance.stub({
+          :keys => [:a,:b,:c],
+          :[]   => 'nyaruko'
+      })
+    end
+
+    it 'call each' do
+      count = 0
+      expect{
+        @instance.each do |key, value|
+          count += 1
+        end
+      }.to change{count}.by(3)
+    end
+
+    it 'call length' do
+      expect(@instance.length).to eq(3)
+    end
+  end
+end

data/spec/rails_kvs_driver/session_spec.rb

@@ -0,0 +1,35 @@
+require 'rspec'
+require 'spec_helper'
+
+describe RailsKvsDriver::Session do
+  it 'defined KVS_CONNECTION_POOL' do
+    expect(RailsKvsDriver.const_defined?(:KVS_CONNECTION_POOL)).to be_true
+  end
+
+  it 'The structure of RailsKvsDriver::KVS_CONNECTION_POOL is correct.' do
+    MockDriver.session(@driver_config)  {}
+    MockDriver2.session(@driver_config) {}
+    MockDriver2.session(@driver_config.merge(a:0)) {}
+    MockDriver2.session(@driver_config.merge(port:100)) {}
+
+    expect(RailsKvsDriver::KVS_CONNECTION_POOL.length).to eq(2)
+    expect(RailsKvsDriver::KVS_CONNECTION_POOL['MockDriver2'].length).to eq(2)
+    expect(RailsKvsDriver::KVS_CONNECTION_POOL['MockDriver2'][0].length).to  eq(2)
+    expect(RailsKvsDriver::KVS_CONNECTION_POOL['MockDriver2'][0].has_key? :config).to  be_true
+    expect(RailsKvsDriver::KVS_CONNECTION_POOL['MockDriver2'][0].has_key? :pool).to    be_true
+  end
+
+  context 'call session' do
+    it 'to hand over driver instance to the block' do
+      MockDriver.session(@driver_config) do |instance|
+        expect(instance.class).to eq(MockDriver)
+        expect(instance.kvs_instance).to eq('dummy1')
+      end
+
+      MockDriver2.session(@driver_config) do |instance|
+        expect(instance.class).to eq(MockDriver2)
+        expect(instance.kvs_instance).to eq('dummy2')
+      end
+    end
+  end
+end

data/spec/rails_kvs_driver/sorted_set_spec.rb

@@ -0,0 +1,62 @@
+require 'rspec'
+require 'spec_helper'
+
+describe RailsKvsDriver::SortedSet do
+
+  before(:each) do
+    @driver = MockDriver.new(nil,nil)
+    @driver.stub({
+        add_sorted_set:          nil,
+        count_sorted_set_member: 100,
+        delete:                  true,
+        get_sorted_set:          [[:a,:b],[:c,:d]],
+        get_sorted_set_keys:     [:a,:b,:c],
+        get_sorted_set_score:    100,
+        increment_sorted_set:    10
+    })
+  end
+
+  it 'call []' do
+    expect((@driver.sorted_sets['hoge'] = ['test', 1])[0]).to eq('test')
+  end
+
+  it 'call []=' do
+    expect((@driver.sorted_sets['hoge'])[0][0]).to eq(:a)
+    expect(@driver.sorted_sets['hoge','fuga']).to eq(100)
+  end
+
+  it 'call delete' do
+    expect(@driver.sorted_sets.delete(:a)).to be_true
+  end
+
+  it 'call each' do
+    count = 0
+    expect{
+      @driver.sorted_sets.each do |key|
+        count += 1
+      end
+    }.to change{count}.by(3)
+  end
+
+  it 'call each_member' do
+    count = 0
+    expect{
+      @driver.sorted_sets.each_member('test',false, 10) do |member, score, position|
+        expect(position).to eq(count)
+        count += 1
+      end
+    }.to change{count}.by(100)
+  end
+
+  it 'call increment_member' do
+    expect( @driver.sorted_sets.increment(:a, :b, 1) ).to eq(10)
+  end
+
+  it 'call keys' do
+    expect(@driver.sorted_sets.keys.length).to eq(3)
+  end
+
+  it 'call length' do
+    expect(@driver.sorted_sets.length).to eq(3)
+  end
+end

data/spec/rails_kvs_driver/validate_driver_config_spec.rb

@@ -0,0 +1,45 @@
+require 'rspec'
+require 'spec_helper'
+
+describe RailsKvsDriver::ValidationDriverConfig do
+  class MockValidate
+    extend RailsKvsDriver::ValidationDriverConfig
+  end
+
+  context 'call validate_driver_config' do
+    it 'raise ArgumentError when there is not host.' do
+      @driver_config.delete(:host)
+      expect{ MockValidate.validate_driver_config!(@driver_config) }.to raise_error(ArgumentError)
+    end
+
+    it 'raise ArgumentError when there is not port.' do
+      @driver_config.delete(:port)
+      expect{ MockValidate.validate_driver_config!(@driver_config) }.to raise_error(ArgumentError)
+    end
+
+    it 'raise ArgumentError when there is not namespace.' do
+      @driver_config.delete(:namespace)
+      expect{ MockValidate.validate_driver_config!(@driver_config) }.to raise_error(ArgumentError)
+    end
+
+    it 'raise ArgumentError when there is not timeout_sec.' do
+      @driver_config.delete(:timeout_sec)
+      expect{ MockValidate.validate_driver_config!(@driver_config) }.to raise_error(ArgumentError)
+    end
+
+    it 'raise ArgumentError when there is not pool_size.' do
+      @driver_config.delete(:pool_size)
+      expect{ MockValidate.validate_driver_config!(@driver_config) }.to raise_error(ArgumentError)
+    end
+
+    it 'insert default value when there is not config_key' do
+      @driver_config[:config_key] = :Nyarukosan
+      validated_config = MockValidate.validate_driver_config!(@driver_config)
+      expect(validated_config[:config_key]).to eq(:Nyarukosan)
+
+      @driver_config.delete(:config_key)
+      validated_config = MockValidate.validate_driver_config!(@driver_config)
+      expect(validated_config[:config_key]).to eq(:none)
+    end
+  end
+end

data/spec/rails_kvs_driver_spec.rb

@@ -1,183 +1,69 @@
 require 'rspec'
 require 'spec_helper'
-require 'rails_kvs_driver'
-
-describe RailsKvsDriver do
-
-  before(:each) do
-    @driver_config = {
-        :host           => 'localhost', # host of KVS.
-        :port           => 6379,        # port of KVS.
-        :namespace      => 'Example',   # namespace of avoid a conflict with key
-        :timeout_sec    => 5,           # timeout seconds.
-        :pool_size      => 5,           # connection pool size.
-    }
-
-    class MockDriver < RailsKvsDriver::Base
-      def connect
-      end
-    end
-
-  end
 
+describe RailsKvsDriver::Base do
   it 'raise NoMethodError when does not override connect' do
-    expect{RailsKvsDriver::Base.new}.to raise_error
+    expect(RailsKvsDriver::Base.public_class_method('connect')).to be_true
+    expect{RailsKvsDriver::Base.connect('dummy')}.to raise_error(NoMethodError)
   end
 
   it 'raise NoMethodError when does not override []' do
     expect(MockDriver.method_defined?('[]')).to be_true
-    expect{MockDriver.new['a']}.to raise_error
+    expect{MockDriver.new(nil,nil)[nil]}.to raise_error(NoMethodError)
   end
 
   it 'raise NoMethodError when does not override []=' do
     expect(MockDriver.method_defined?('[]=')).to be_true
-    expect{MockDriver.new['a']='b'}.to raise_error
+    expect{MockDriver.new(nil,nil)[nil]=nil}.to raise_error(NoMethodError)
   end
 
-  it 'raise NoMethodError when does not override all_keys' do
-    expect(MockDriver.method_defined?(:all_keys)).to be_true
-    expect{MockDriver.new.all_keys}.to raise_error
+  it 'raise NoMethodError when does not override keys' do
+    expect(MockDriver.method_defined?(:keys)).to be_true
+    expect{MockDriver.new(nil,nil).keys}.to raise_error(NoMethodError)
   end
 
   it 'raise NoMethodError when does not override delete' do
     expect(MockDriver.method_defined?(:delete)).to be_true
-    expect{MockDriver.new.delete}.to raise_error
+    expect{MockDriver.new(nil,nil).delete(nil)}.to raise_error(NoMethodError)
   end
 
   it 'raise NoMethodError when does not override delete_all' do
     expect(MockDriver.method_defined?(:delete_all)).to be_true
-    expect{MockDriver.new.delete_all}.to raise_error
+    expect{MockDriver.new(nil,nil).delete_all}.to raise_error(NoMethodError)
   end
 
   it 'raise NoMethodError when does not override add_sorted_set' do
     expect(MockDriver.method_defined?(:add_sorted_set)).to be_true
-    expect{MockDriver.new.add_sorted_set}.to raise_error
+    expect{MockDriver.new(nil,nil).add_sorted_set(nil,nil,nil)}.to raise_error(NoMethodError)
   end
 
-  it 'raise NoMethodError when does not override remove_sorted_set' do
-    expect(MockDriver.method_defined?(:remove_sorted_set)).to be_true
-    expect{MockDriver.new.remove_sorted_set}.to raise_error
+  it 'raise NoMethodError when does not override get_sorted_set' do
+    expect(MockDriver.method_defined?(:get_sorted_set)).to be_true
+    expect{MockDriver.new(nil,nil).get_sorted_set(nil)}.to raise_error(NoMethodError)
   end
 
-  it 'raise NoMethodError when does not override increment_sorted_set' do
-    expect(MockDriver.method_defined?(:increment_sorted_set)).to be_true
-    expect{MockDriver.new.increment_sorted_set}.to raise_error
-  end
-
-  it 'raise NoMethodError when does not override sorted_set_score' do
-    expect(MockDriver.method_defined?(:sorted_set_score)).to be_true
-    expect{MockDriver.new.sorted_set_score}.to raise_error
-  end
-
-  it 'raise NoMethodError when does not override sorted_set' do
-    expect(MockDriver.method_defined?(:sorted_set)).to be_true
-    expect{MockDriver.new.sorted_set}.to raise_error
+  it 'raise NoMethodError when does not override get_sorted_set_keys' do
+    expect(MockDriver.method_defined?(:get_sorted_set_keys)).to be_true
+    expect{MockDriver.new(nil,nil).get_sorted_set_keys}.to raise_error(NoMethodError)
   end
 
   it 'raise NoMethodError when does not override count_sorted_set_member' do
     expect(MockDriver.method_defined?(:count_sorted_set_member)).to be_true
-    expect{MockDriver.new.count_sorted_set_member}.to raise_error
+    expect{MockDriver.new(nil,nil).count_sorted_set_member(nil)}.to raise_error(NoMethodError)
   end
 
-  context 'call initialize' do
-    it 'exec validation' do
-      expect{ MockDriver.new(@driver_config) }.not_to raise_error
-    end
-
-    it 'coping instance of driver_config' do
-      expect(MockDriver.new(@driver_config).driver_config).to eq(@driver_config)
-    end
+  it 'raise NoMethodError when does not override get_sorted_set_score' do
+    expect(MockDriver.method_defined?(:get_sorted_set_score)).to be_true
+    expect{MockDriver.new(nil,nil).get_sorted_set_score(nil,nil)}.to raise_error(NoMethodError)
   end
 
-  context 'call validate_driver_config' do
-    it 'raise ArgumentError when there is not host.' do
-      @driver_config.delete(:host)
-      expect{ MockDriver.new(@driver_config) }.to raise_error
-    end
-
-    it 'raise ArgumentError when there is not port.' do
-      @driver_config.delete(:port)
-      expect{ MockDriver.new(@driver_config) }.to raise_error
-    end
-
-    it 'raise ArgumentError when there is not namespace.' do
-      @driver_config.delete(:namespace)
-      expect{ MockDriver.new(@driver_config) }.to raise_error
-    end
-
-    it 'raise ArgumentError when there is not timeout_sec.' do
-      @driver_config.delete(:timeout_sec)
-      expect{ MockDriver.new(@driver_config) }.to raise_error
-    end
-
-    it 'raise ArgumentError when there is not pool_size.' do
-      @driver_config.delete(:pool_size)
-      expect{ MockDriver.new(@driver_config) }.to raise_error
-    end
+  it 'raise NoMethodError when does not override increment_sorted_set' do
+    expect(MockDriver.method_defined?(:increment_sorted_set)).to be_true
+    expect{MockDriver.new(nil,nil).increment_sorted_set(nil,nil,nil)}.to raise_error(NoMethodError)
   end
 
-  context 'call session' do
-    before(:each) do
-      class MockDriver2 < RailsKvsDriver::Base
-        def connect
-        end
-      end
-    end
-
-    it 'DriverConnectionPool is same instance.' do
-      expect(MockDriver::DriverConnectionPool.equal?(RailsKvsDriver::Base::DriverConnectionPool)).to be_true
-    end
-
-    it 'to hand over driver instance to the block' do
-      MockDriver.session(@driver_config) do |instance|
-        expect(instance.class).to eq(MockDriver)
-      end
-
-      MockDriver2.session(@driver_config) do |instance|
-        expect(instance.class).to eq(MockDriver2)
-      end
-    end
-
-    it 'The structure of DriverConnectionPool is correct.' do
-      MockDriver.session(@driver_config)  {}
-      MockDriver2.session(@driver_config) {}
-      MockDriver2.session(@driver_config.merge(a:0)) {}
-      MockDriver2.session(@driver_config.merge(a:1)) {}
-
-      expect(MockDriver::DriverConnectionPool.length).to eq(2)
-      expect(MockDriver::DriverConnectionPool['MockDriver2'].length).to eq(3)
-      expect(MockDriver::DriverConnectionPool['MockDriver2'][0].length).to  eq(2)
-      expect(MockDriver::DriverConnectionPool['MockDriver2'][0].has_key? :config).to  be_true
-      expect(MockDriver::DriverConnectionPool['MockDriver2'][0].has_key? :pool).to    be_true
-    end
-
-    it 'call each_sorted_set' do
-      class MockDriverEachTest < MockDriver
-        def sorted_set(key, start, stop, reverse)
-          count  = 0
-          result = Array.new
-          (start .. stop).each{ |num|
-            result.push ["example#{num}", count]
-            count += 1
-          }
-          return result
-        end
-        def count_sorted_set_member(*args)
-          100
-        end
-      end
-
-      MockDriverEachTest.session(@driver_config) do |instance|
-        count = 0
-        expect{
-          instance.each_sorted_set('test',false, 10) do |member, score, position|
-            expect(member).to   eq("example#{count}")
-            expect(score).to    eq(count%10)
-            expect(position).to eq(count)
-            count += 1
-          end
-        }.to change{count}.by(100)
-      end
-    end
+  it 'raise NoMethodError when does not override remove_sorted_set' do
+    expect(MockDriver.method_defined?(:remove_sorted_set)).to be_true
+    expect{MockDriver.new(nil,nil).remove_sorted_set(nil,nil)}.to raise_error(NoMethodError)
   end
 end

data/spec/spec_helper.rb

@@ -4,4 +4,29 @@ require 'rails_kvs_driver'
 
 RSpec.configure do |config|
   config.mock_framework = :rspec
+  config.before(:each) {
+    RailsKvsDriver::KVS_CONNECTION_POOL.clear
+
+    # mock config
+    @driver_config = {
+        :host           => 'localhost', # host of KVS.
+        :port           => 6379,        # port of KVS.
+        :namespace      => 'Example',   # namespace of avoid a conflict with key
+        :timeout_sec    => 5,           # timeout seconds.
+        :pool_size      => 5,           # connection pool size.
+    }
+  }
+end
+
+# mock driver class
+class MockDriver < RailsKvsDriver::Base
+  def self.connect(args)
+    'dummy1'
+  end
+end
+
+class MockDriver2 < MockDriver
+  def self.connect(args)
+    'dummy2'
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_kvs_driver
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - alfa-jpn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-08 00:00:00.000000000 Z
+date: 2013-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -93,9 +93,17 @@ files:
 - README.md
 - Rakefile
 - lib/rails_kvs_driver.rb
+- lib/rails_kvs_driver/defined_base_method.rb
+- lib/rails_kvs_driver/session.rb
+- lib/rails_kvs_driver/sorted_set.rb
+- lib/rails_kvs_driver/validation_driver_config.rb
 - lib/rails_kvs_driver/version.rb
 - rails_kvs_driver.gemspec
 - spec/common_example.rb
+- spec/rails_kvs_driver/defined_base_method_spec.rb
+- spec/rails_kvs_driver/session_spec.rb
+- spec/rails_kvs_driver/sorted_set_spec.rb
+- spec/rails_kvs_driver/validate_driver_config_spec.rb
 - spec/rails_kvs_driver_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/alfa-jpn/rails-kvs-driver
@@ -124,6 +132,10 @@ specification_version: 4
 summary: rails kvs driver wrap access key-value store.
 test_files:
 - spec/common_example.rb
+- spec/rails_kvs_driver/defined_base_method_spec.rb
+- spec/rails_kvs_driver/session_spec.rb
+- spec/rails_kvs_driver/sorted_set_spec.rb
+- spec/rails_kvs_driver/validate_driver_config_spec.rb
 - spec/rails_kvs_driver_spec.rb
 - spec/spec_helper.rb
 has_rdoc: