ssdb-attr 0.0.11 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31499311caa45d7129e0a6c0d79a391db919ec93
-  data.tar.gz: b345e7431fa1263c4f5c714a76fb23b762443a3a
+  metadata.gz: b2b52304c9d46396222d910c03ab4a3eb12d0210
+  data.tar.gz: 036af4b696a6ab5b733c71d01de9447303000ba7
 SHA512:
-  metadata.gz: 3b164bab058e911c7bd893c70c07f0907f966f5e9d074f18df619443813e3b77ea04c7d461a1c623baca0514d5c65863e7a930e37034e595dc7e12410b526f2a
-  data.tar.gz: 3a319604d98f756e0f0ab569aeff4f03a5e5d6a60b862d4ab2a2dc3456e2531384a2f30156a06dcd6e1a0813f82add9ee4b4332b892ceeae3cf45a44de863ec1
+  metadata.gz: bcee95b48f327fac5b65c582c89539c2c45a11e88b136e8084a229d5ed898e93bf4d1c0f472b05a68827acffb9ae25fd4a33f3ff04a4fcaf2972efb83305e2df
+  data.tar.gz: f66d638aead72c1de92caf614bb03d8d07c6358f59967fa9bb1c3b1835982fa26fd04c24d2922422506b15a900c46c3defcfc964983416aaa4b15f28371ee3c7

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-version

@@ -1 +1 @@
-ruby-2.1.2
+ruby-2.3.0

data/Gemfile

@@ -1,5 +1,4 @@
-# source 'https://rubygems.org'
-source 'https://ruby.taobao.org'
+source 'https://gems.ruby-china.org'
 
 # Specify your gem's dependencies in ssdb-attr.gemspec
 gemspec

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    ssdb-attr (0.0.10)
+    ssdb-attr (0.0.11)
       activesupport (~> 4.2.1)
       connection_pool (~> 2.2.0)
       redis (~> 3.2.1)
 
 GEM
-  remote: https://ruby.taobao.org/
+  remote: https://gems.ruby-china.org/
   specs:
     activemodel (4.2.1)
       activesupport (= 4.2.1)
@@ -26,12 +26,33 @@ GEM
       tzinfo (~> 1.1)
     arel (6.0.0)
     builder (3.2.2)
+    coderay (1.1.1)
     connection_pool (2.2.0)
+    diff-lcs (1.2.5)
     i18n (0.7.0)
     json (1.8.2)
+    method_source (0.8.2)
     minitest (5.5.1)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
     rake (10.4.2)
-    redis (3.2.1)
+    redis (3.2.2)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    slop (3.6.0)
     sqlite3 (1.3.10)
     thread_safe (0.3.5)
     tzinfo (1.2.2)
@@ -44,7 +65,11 @@ DEPENDENCIES
   activerecord (~> 4.2.1)
   activerecord-nulldb-adapter
   bundler (~> 1.5)
-  minitest (~> 5.5.1)
+  pry
   rake
+  rspec (~> 3.5.0)
   sqlite3
   ssdb-attr!
+
+BUNDLED WITH
+   1.13.6

data/Rakefile

@@ -1,7 +1,8 @@
 require "bundler/gem_tasks"
-require 'rake/testtask'
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.pattern = "test/**/*_test.rb"
+desc "run all the specs"
+task :test do
+  sh "rspec spec"
 end
+task :default => :test
+task :spec => :test

data/lib/ssdb-attr.rb

@@ -1,5 +1,7 @@
 require "redis"
 require "connection_pool"
+require 'active_support'
+require "active_support/core_ext"
 require "active_support/concern"
 require "active_support/inflector"
 require "ssdb-attr/version"
@@ -7,19 +9,82 @@ require "ssdb/attr"
 
 module SSDBAttr
   class << self
-    attr_accessor :pool
+    attr_accessor :pools
+    attr_accessor :default_pool_name
 
-    def setup(options={})
-      pool_size = (options[:pool]     || 1).to_i
-      timeout   = (options[:timeout]  || 2).to_i
+    #
+    # Globally setup SSDBAttr
+    #
+    # This method will setup the connecton pool to SSDB server.
+    #
+    # You should pass following values in `options` hash:
+    #
+    # `url/host+port`: To locate the SSDB server, `url` takes precedence.
+    # `pool`: Pool size of the connection pool. Default to 1.
+    # `timeout`: Timeout of the connection pool, in second, Default to 2.
+    #
+    # @param [Hash] options
+    #
+    # @return [void]
+    #
+    def setup(configuration)
+      raise "SSDB-Attr could not initialize!" if configuration.nil?
 
-      SSDBAttr.pool = ConnectionPool.new(size: pool_size, timeout: timeout) do
-        if options[:url].present?
-          Redis.new(url: options[:url])
-        else
-          Redis.new(host: options[:host], port: options[:port])
+      SSDBAttr.pools = {}
+
+      if configuration.is_a?(Hash)
+        # Only one and the default connection pool.
+        conf = configuration.symbolize_keys
+
+        pool_name = conf[:name] || :default
+
+        SSDBAttr.pools[pool_name.to_sym] = create_pool(configuration)
+        SSDBAttr.default_pool_name = pool_name
+      end
+
+      if configuration.is_a?(Array)
+        # Multiple connection pools
+        configuration.each do |c|
+          conf = c.symbolize_keys
+
+          pool_name = conf[:name]
+
+          raise "ssdb-attr: Pool name not specified!" if pool_name.blank?
+
+          SSDBAttr.pools[pool_name.to_sym] = create_pool(conf)
+          SSDBAttr.default_pool_name = pool_name if conf[:default]
         end
       end
+
+      raise "ssdb-attr: No default pool in configuration!" if SSDBAttr.pool.nil?
+    end
+
+    def pool(name=nil)
+      name = name || SSDBAttr.default_pool_name
+      SSDBAttr.pools[name.to_sym]
+    end
+
+    def default_pool
+      SSDBAttr.pools[SSDBAttr.default_pool_name]
+    end
+
+    def create_pool(pool_options)
+      defaults = { :pool_size => 1, :timeout => 1 }
+
+      options = pool_options.reverse_merge(defaults).deep_symbolize_keys
+
+      ConnectionPool.new(:size => options[:pool_size], :timeout => options[:timeout]) do
+        create_conn(options)
+      end
     end
+
+    def create_conn(conn_options)
+      if !conn_options[:url].nil?
+        Redis.new(:url => conn_options[:url])
+      else
+        Redis.new(:host => conn_options[:host], :port => conn_options[:port])
+      end
+    end
+
   end
 end

data/lib/ssdb-attr/version.rb

@@ -1,3 +1,3 @@
 module SSDBAttr
-  VERSION = "0.0.11"
+  VERSION = "0.1.0"
 end

data/lib/ssdb/attr.rb

@@ -3,107 +3,167 @@ module SSDB
     extend ActiveSupport::Concern
 
     included do
-      define_model_callbacks :update_ssdb_attrs, only: [:before, :after]
-      after_create :init_ssdb_attrs
-      after_destroy :clear_ssdb_attrs
+      instance_variable_set(:@ssdb_attr_names, [])
+
+      after_commit :save_ssdb_attrs,  on: %i(create update)
+      after_commit :clear_ssdb_attrs, on: :destroy
     end
 
-    def update_ssdb_attrs(attributes)
-      # Determine what attrs are requested to be updated
-      attributes = attributes.symbolize_keys
-      attr_names = attributes.keys & self.class.ssdb_attr_names
+    module ClassMethods
+      attr_reader :ssdb_attr_names
+      attr_reader :ssdb_attr_id_field
+      attr_reader :ssdb_attr_pool_name
 
-      # Determine dirty fields
-      attr_names.each do |name|
-        send("#{name}_will_change!") unless attributes[name] == send(name)
+      #
+      # 设置获取 SSDB Attr Id 的方式
+      #
+      # @param [String/Symbol] field_name
+      #
+      # @return [String]
+      #
+      def ssdb_attr_id(field_name)
+        raise if field_name.nil?
+        @ssdb_attr_id_field = field_name
       end
 
-      run_callbacks :update_ssdb_attrs do
-        SSDBAttr.pool.with do |conn|
-          attr_names.each { |name| send("#{name}=", attributes[name]) }
-        end
+      def ssdb_attr_pool(pool_name)
+        @ssdb_attr_pool_name = pool_name
       end
 
-      # Clear dirty fields
-      clear_attribute_changes(attr_names)
+      #
+      # Method to define a SSDB attribute in a Ruby Class
+      #
+      # @param [String/Symbol] name Attribute name.
+      # @param [String/Symbol] type Attribute type, now supports: string/integer
+      # @param [options] options Extra options.
+      #
+      # @return [void]
+      #
+      def ssdb_attr(name, type, options = {})
+        unless %i(string integer).include?(type)
+          raise "Type not supported, only `:string` and `:integer` are supported now."
+        end
 
-      true # always return true
-    end
+        @ssdb_attr_names << name.to_s
+
+        define_method(name) do
+          instance_variable_get("@#{name}") || begin
+            val = ssdb_attr_pool.with { |conn| conn.get(ssdb_attr_key(name)) } || options[:default]
+            instance_variable_set("@#{name}", val)
+          end
+          typecaster(instance_variable_get("@#{name}"), type)
+        end
+
+        define_method("#{name}=") do |val|
+          send("#{name}_will_change!") unless typecaster(val, type) == send(name)
+          instance_variable_set("@#{name}", val)
+        end
+
+        define_method("#{name}_was")          { attribute_was(name) }
+
+        define_method("#{name}_change")       { attribute_change(name) }
+
+        define_method("#{name}_changed?")     { attribute_changed?(name) }
+
+        define_method("restore_#{name}!")     { restore_attribute!(name) }
+
+        define_method("#{name}_will_change!") { attribute_will_change!(name) }
 
-    def init_ssdb_attrs
-      self.class.ssdb_attr_names.each do |attribute|
-        SSDBAttr.pool.with { |conn| conn.set(to_ssdb_attr_key(attribute), self.send(attribute)) }
       end
     end
 
-    def clear_ssdb_attrs
-      self.class.ssdb_attr_names.each do |attribute|
-        SSDBAttr.pool.with { |conn| conn.del(to_ssdb_attr_key(attribute)) }
+    #
+    # Overwrite `reload` method in ActiveRecord to reload SSDB attributes as well.
+    #
+    #
+    # @return [void]
+    #
+    def reload
+      super.tap do
+        reload_ssdb_attrs
       end
     end
 
-    def to_ssdb_attr_key(name)
-      klass = self.class
+    private
 
-      custom_id = klass.instance_variable_get("@ssdb_attr_id")
+    def ssdb_attr_pool
+      SSDBAttr.pool(self.class.ssdb_attr_pool_name)
+    end
 
-      if custom_id.present?
-        "#{klass.name.tableize}:#{self.send(custom_id)}:#{name}"
+    #
+    # Cast the value from SSDB to the correct type.
+    #
+    # @param [Any] val Any value taken from SSDB Server.
+    # @param [String/Symbol] type Target value to cast to.
+    #
+    # @return [Any]
+    #
+    def typecaster(val, type)
+      case type.to_sym
+      when :string  then val.to_s
+      when :integer then val.to_i
       else
-        "#{klass.name.tableize}:#{id}:#{name}"
+        raise "Typecaster: i don't know this type: #{type}."
       end
     end
 
-    private
+    def ssdb_attr_id
+      send(self.class.ssdb_attr_id_field || :id)
+    end
+
 
-    def touch_db_column(names)
-      names == true ? touch : touch(*names)
+    #
+    # Return the SSDB key for a attribute
+    #
+    # @param [String] name Attribute name.
+    #
+    # @return [String]
+    #
+    def ssdb_attr_key(name)
+      "#{self.class.name.tableize}:#{ssdb_attr_id}:#{name}"
     end
 
-    module ClassMethods
-      def ssdb_attr_names
-        @ssdb_attr_names ||= []
+    #
+    # Delete all SSDB Attributes of current object in the server.
+    #
+    #
+    # @return [void]
+    #
+    def clear_ssdb_attrs
+      ssdb_attr_pool.with do |conn|
+        self.class.ssdb_attr_names.each { |attr| conn.del(ssdb_attr_key(attr)) }
       end
+    end
 
-      def ssdb_attr_id(sym)
-        @ssdb_attr_id = sym
+    #
+    # Save changed SSDb Attributes to the server.
+    #
+    #
+    # @return [void]
+    #
+    def save_ssdb_attrs
+      params = (previous_changes.keys & self.class.ssdb_attr_names).map do |attr|
+        ["#{ssdb_attr_key(attr)}", previous_changes[attr][1]]
       end
 
-      # ssdb_attr :content,        :string,   default: 0, touch: true
-      # ssdb_attr :writer_version, :integer,  default: 0, touch: [:field1, :field2, :field3]
-      #
-      # [counter description]
-      # @param name [type] [description]
-      # @param name [type] [description]
-      # @param options={} [type] [description]
-      # @param block [description]
-      #
-      # @return [type] [description]
-      def ssdb_attr(name, type, options={})
-        unless [:string, :integer].include?(type)
-          raise "Type not supported, only `:string` and `:integer` are supported now."
-        end
-
-        self.ssdb_attr_names << name
-
-        define_method(name) do
-          conversion = type == :string ? :to_s : :to_i
-          value = SSDBAttr.pool.with { |conn| conn.get("#{to_ssdb_attr_key(name)}") }
-          (value || options[:default]).send(conversion)
-        end
-
-        define_method("#{name}=") do |val|
-          SSDBAttr.pool.with { |conn| conn.set("#{to_ssdb_attr_key(name)}", val) }
-          touch_db_column(options[:touch]) if options[:touch].present?
-        end
-
-        define_method("#{name}_will_change!") do
-          attribute_will_change!(name)
-        end
+      ssdb_attr_pool.with do |conn|
+        conn.mset(*params.flatten)
+      end if params.length > 0
+    end
 
-        define_method("#{name}_changed?") do
-          attribute_changed?(name)
-        end
+    #
+    # Reload attribute values from the server.
+    #
+    # This method will overwrite current changed but not saved values in the object.
+    #
+    #
+    # @return [void]
+    #
+    def reload_ssdb_attrs
+      values = ssdb_attr_pool.with { |conn| conn.mget(*self.class.ssdb_attr_names) }
+
+      self.class.ssdb_attr_names.each_with_index do |attr, index|
+        instance_variable_set("@#{attr}", values[index])
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,16 +1,20 @@
-require 'active_record'
-require 'nulldb'
-require 'ssdb-attr'
-require 'minitest/spec'
-require 'minitest/autorun'
-require 'minitest/mock'
-require 'minitest/pride'
+require "active_record"
+require "nulldb"
+require "ssdb-attr"
 
-SSDBAttr.setup url: 'redis://localhost:6379/15'
+# Setup ActiveRecord
+ActiveRecord::Base.raise_in_transactional_callbacks = true if ActiveRecord::VERSION::STRING >= "4.2"
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
-# Setup activerecord
-ActiveRecord::Base.raise_in_transactional_callbacks = true if ActiveRecord::VERSION::STRING >= '4.2'
+# Setup tables for test
+tbls = [
+  { "posts" => "updated_at DATETIME, saved_at DATETIME, changed_at DATETIME" },
+  { "custom_id_fields" => "uuid VARCHAR" },
+  { "custom_pool_names" => "uuid VARCHAR" }
+]
 
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', database: ':memory:'
-
-ActiveRecord::Base.connection.execute "CREATE TABLE posts (id INTEGER NOT NULL PRIMARY KEY, updated_at DATETIME, content_updated_at DATETIME, title_updated_at DATETIME)"
+tbls.each do |tbl|
+  tbl.each do |tbl_name, sql|
+    ActiveRecord::Base.connection.execute "CREATE TABLE #{tbl_name} (id INTEGER NOT NULL PRIMARY KEY, #{sql})"
+  end
+end

data/spec/ssdb-attr_spec.rb

@@ -1,9 +1,131 @@
-require 'spec_helper'
+# require 'spec_helper'
+require "ssdb-attr"
 
 describe SSDBAttr do
+
+  describe "#pool" do
+    it "should fetch the named pool if a connection name is passed" do
+      options = { :url => "redis://localhost:8888" }
+
+      SSDBAttr.setup(options)
+
+      pool_dbl = double(ConnectionPool)
+
+      expect(SSDBAttr.pools).to receive(:[]).with(:foo).and_return(pool_dbl)
+      expect(SSDBAttr.pool(:foo)).to eq(pool_dbl)
+    end
+
+    it "should return the default pool if connection name of nil is passed" do
+      options = { :url => "redis://localhost:8888" }
+
+      SSDBAttr.setup(options)
+
+      pool_dbl = double(ConnectionPool)
+
+      SSDBAttr.default_pool_name = :default_foo
+
+      expect(SSDBAttr.pools).to receive(:[]).with(:default_foo).and_return(pool_dbl)
+      expect(SSDBAttr.pool).to eq(pool_dbl)
+    end
+  end
+
   describe "#setup" do
-    it "should setup a ssdb connection pool" do
-      SSDBAttr.pool.wont_be_nil
+    context "with only one pool" do
+      it "should setup a ssdb connection pool with no name specified" do
+        options = { :url => "redis://localhost:8888" }
+
+        SSDBAttr.setup(options)
+
+        expect(SSDBAttr.pools.size).to eq(1)
+        expect(SSDBAttr.pools[:default]).not_to be_nil
+        expect(SSDBAttr.default_pool_name).to eq(:default)
+      end
+
+      it "should setup a ssdb connection pool with name specified" do
+        options = { :url => "redis://localhost:8888", :name => :main }
+
+        SSDBAttr.setup(options)
+
+        expect(SSDBAttr.pools.size).to eq(1)
+        expect(SSDBAttr.default_pool_name).to eq(:main)
+        expect(SSDBAttr.pools[:main]).not_to be_nil
+        expect(SSDBAttr.default_pool).to eq(SSDBAttr.pools[:main])
+      end
+    end
+
+    context "with pools" do
+      it "should raise error if no name specified" do
+        options = [
+          { :url => "redis://localhost:8888" },
+          { :url => "redis://localhost:6379" }
+        ]
+
+        expect { SSDBAttr.setup(options) }.to raise_error(RuntimeError)
+      end
+
+      it "should raise error if no default specified" do
+        options = [
+          { :url => "redis://localhost:8888", :name => :pool1 },
+          { :url => "redis://localhost:6379", :name => :pool2 }
+        ]
+
+        expect { SSDBAttr.setup(options) }.to raise_error(RuntimeError)
+      end
+
+      it "should initialize correctly" do
+        options = [
+          { :url => "redis://localhost:8888", :name => :ssdb,  :pool_size => 10, :timeout => 2, :default => true },
+          { :url => "redis://localhost:6379", :name => :redis, :pool_size => 5,  :timeout => 3 }
+        ]
+
+        SSDBAttr.setup(options)
+
+        expect(SSDBAttr.pools.size).to eq(2)
+        expect(SSDBAttr.pools[:ssdb]).to be_a(ConnectionPool)
+        expect(SSDBAttr.pools[:redis]).to be_a(ConnectionPool)
+        expect(SSDBAttr.default_pool_name).to eq(:ssdb)
+        expect(SSDBAttr.default_pool).to eq(SSDBAttr.pools[:ssdb])
+      end
+    end
+  end
+
+  describe "#create_pool" do
+    it "will use create a connection pool" do
+      pool = SSDBAttr.create_pool(:url => "redis://localhost:8888", :pool_size => 10, :timeout => 18)
+
+      expect(pool).not_to be_nil
+      expect(pool).to be_a(ConnectionPool)
+      expect(pool.instance_variable_get(:@size)).to eq(10)
+      expect(pool.instance_variable_get(:@timeout)).to eq(18)
+
+      conn = pool.with { |conn| conn }
+      expect(conn).to be_a(Redis)
+      expect(conn.client.host).to eq("localhost")
+      expect(conn.client.port).to eq(8888)
+    end
+  end
+
+  describe "#create_conn" do
+    context "with url" do
+      it do
+        conn = SSDBAttr.create_conn(:url => "redis://localhost:8888")
+
+        expect(conn).not_to be_nil
+        expect(conn).to be_a(Redis)
+        expect(conn.client.host).to eq("localhost")
+        expect(conn.client.port).to eq(8888)
+      end
+    end
+
+    context "with host/port options" do
+      it do
+        conn = SSDBAttr.create_conn(:host => "localhost", :port => "8888")
+
+        expect(conn).not_to be_nil
+        expect(conn).to be_a(Redis)
+        expect(conn.client.host).to eq("localhost")
+        expect(conn.client.port).to eq(8888)
+      end
     end
   end
 end

data/spec/ssdb/attr_spec.rb

@@ -1,86 +1,232 @@
-require 'spec_helper'
+require "spec_helper"
 
 class Post < ActiveRecord::Base
   include SSDB::Attr
 
-  ssdb_attr :title,           :string, touch: [:content_updated_at]
-  ssdb_attr :content,         :string, touch: true
-  ssdb_attr :version,         :integer, default: 22
-  ssdb_attr :counter,         :integer, default: 4
+  ssdb_attr :name, :string
+  ssdb_attr :int_version, :integer
+  ssdb_attr :default_title, :string, default: "Untitled"
+  ssdb_attr :title, :string
+  ssdb_attr :content, :string
+  ssdb_attr :version, :integer, default: 1
+  ssdb_attr :default_version, :integer, :default => 100
+  ssdb_attr :field_with_validation, :string
 
-  before_update_ssdb_attrs  :before_callback1, :before_callback2
-  after_update_ssdb_attrs   :after_callback1, :after_callback2
+  validate :validate_field
 
-  def before_callback1
-    puts "before callback 1"
-
-    if title_changed?
-      puts "title changed detected."
+  def validate_field
+    if field_with_validation == "foobar"
+      errors.add(:field_with_validation, "foobar error")
     end
   end
+end
 
-  def before_callback2
-    puts "before callback 2"
-  end
+class CustomIdField < ActiveRecord::Base
+  include SSDB::Attr
 
-  def after_callback1
-    puts "after callback 1"
-  end
+  ssdb_attr_id :uuid
+  ssdb_attr :content, :string
+end
 
-  def after_callback2
-    puts "after callback 2"
-  end
+class CustomPoolName < ActiveRecord::Base
+  include SSDB::Attr
 
-  # touch_ssdb_attr [:title, :content], touch: [:content_at]
-  #
-  # dummy.update_ssdb_attrs(title: 'abc', content: 'cbd')
-  #
-  # before_update_ssdb_attributes args*
-  # after_update_ssdb_attributes :touch_updated_at
+  ssdb_attr_pool :foo_pool
+
+  ssdb_attr :foo_id, :integer
 end
 
 describe SSDB::Attr do
 
-  describe "method created" do
+  before(:all) do
+    # Connect to test SSDB server
+    SSDBAttr.setup(:url => "redis://localhost:8888")
+
+    # Clean up SSDB
+    system('printf "7\nflushdb\n\n4\nping\n\n" | nc 127.0.0.1 8888 -i 1 > /dev/null')
+
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.execute "DELETE FROM #{table}"
+    end
   end
 
-  describe "#update_ssdb_attrs" do
-    if 'should correctly set values'
-      post = Post.create
+  context "Post" do
+    let(:post) { Post.create(updated_at: 1.day.ago, saved_at: 1.day.ago, changed_at: 1.day.ago) }
+    let(:redis) { Redis.new(:url => 'redis://localhost:8888') }
+
+    describe "@ssdb_attr_names" do
+      it "should set `@ssdb_attr_names` correctly"  do
+        ssdb_attr_names = Post.instance_variable_get(:@ssdb_attr_names)
+        expect(ssdb_attr_names).to match_array(["name", "int_version", "default_title", "title",
+          "content", "version", "default_version", "field_with_validation"])
+      end
+    end
+
+    it "should respond to methods" do
+      expect(post.respond_to?(:name)).to be true
+      expect(post.respond_to?(:name=)).to be true
+      expect(post.respond_to?(:name_was)).to be true
+      expect(post.respond_to?(:name_change)).to be true
+      expect(post.respond_to?(:name_changed?)).to be true
+      expect(post.respond_to?(:restore_name!)).to be true
+      expect(post.respond_to?(:name_will_change!)).to be true
+    end
+
+    describe "#attribute=" do
+      it "shouldn't change the attribute value in SSDB" do
+        post.title = "foobar"
+        expect(redis.get(post.send(:ssdb_attr_key, :title))).not_to eq("foobar")
+      end
+
+      it "should change the attribute value" do
+        post.title = "foobar"
+        expect(post.title).to eq("foobar")
+      end
+
+      it "should track attirbute changes if value changed" do
+        expect(post).to receive(:title_will_change!)
+        post.title = "foobar"
+      end
+
+      it "shouldn't track attirbute changes unless value changed" do
+        expect(post).not_to receive(:title_will_change!)
+        post.title = ""
+      end
+    end
+
+    describe "#reload_ssdb_attrs" do
+      it "should reload attribute values from SSDB" do
+        post = Post.create(title: "foobar", version: 4)
+        post.title = "fizzbuzz"
+        post.version = 3
+
+        post.send(:reload_ssdb_attrs)
+        expect(post.title).to eq("foobar")
+        expect(post.version).to eq(4)
+      end
+    end
+
+    describe "#save_ssdb_attrs" do
+      it "should save attribute values in SSDB" do
+        allow(post).to receive(:previous_changes).and_return({"title"=>["", "foobar2"]})
+        post.send(:save_ssdb_attrs)
+        expect(redis.get("posts:#{post.id}:title")).to eq("foobar2")
+      end
+    end
+
+    describe "#clear_ssdb_attrs" do
+      before do
+        post.update(:title => "foobar2")
+      end
+
+      it "should remove attribute from ssdb" do
+        post.send(:clear_ssdb_attrs)
+        expect(redis.exists("posts:#{post.id}:title")).to be false
+      end
+    end
+
+    describe "#ssdb_attr_key" do
+      it "should return correct key" do
+        expect(post.send(:ssdb_attr_key, "name")).to eq("posts:#{post.id}:name")
+      end
+    end
+
+    context "type: :integer" do
+      it "default value should be 0" do
+        expect(post.int_version).to eq(0)
+      end
+
+      it "should hold integer value and return it" do
+        post.int_version = 4
+        expect(post.int_version).to eq(4)
+      end
 
-      post.update_ssdb_attrs(title: 'bar2')
-      post.update_ssdb_attrs(title: 'bar2')
+      it "default value with `:default` option" do
+        expect(post.default_version).to eq(100)
+      end
+    end
+
+    context "type: :string" do
+      it "default value" do
+        expect(post.title).to eq("")
+      end
+
+      it "default value with `:default` option" do
+        expect(post.default_title).to eq("Untitled")
+      end
+    end
+
+    context "callbacks" do
+      it "should save attribute values in SSDB when AR object save" do
+        post = Post.new
+        expect(post).to receive(:save_ssdb_attrs)
+        post.save
+      end
+
+      it "should clear attribute values in SSDB when AR object destroyed" do
+        expect(post).to receive(:clear_ssdb_attrs)
+        post.destroy
+      end
+    end
 
-      # title =  'foo'
-      # content = 'bar'
-      #
-      # title.must_equal 'foo'
-      # content.must_equal 'bar'
-      #
-      #post.title.must_equal 'foo'
-      #post.content.must_equal 'bar'
+    context "validation" do
+      it "should call the validation method" do
+        post.field_with_validation = "hellow world"
+        expect(post).to receive(:validate_field)
+        post.save
+      end
+
+      context "on validation passed" do
+        it do
+          post.field_with_validation = "hello world"
+
+          expect(post.save).to eq(true)
+          expect(redis.get("posts:#{post.id}:field_with_validation")).to eq("hello world")
+          expect(post.errors.empty?).to be_truthy
+        end
+      end
+
+      context "on validation failed" do
+        it "should not update the value in SSDB if validation fails" do
+          post.field_with_validation = "foobar"
+
+          expect(post.save).to eq(false)
+          expect(redis.get("posts:#{post.id}:field_with_validation")).not_to eq("foobar")
+          expect(post.errors.empty?).not_to be_truthy
+          expect(post.errors[:field_with_validation]).to eq(["foobar error"])
+        end
+      end
     end
   end
 
-  describe "#ssdb_attr" do
-    it 'should set default value correctly' do
-      post = Post.create
+  context "CustomIdField" do
+    let(:custom_id_field) { CustomIdField.create(:uuid => 123) }
 
-      post.counter.must_equal 4
+    it "should use the custom id correctly" do
+      expect(CustomIdField.instance_variable_get(:@ssdb_attr_id_field)).to eq(:uuid)
+      expect(custom_id_field.send(:ssdb_attr_key, "content")).to eq("custom_id_fields:123:content")
     end
+  end
 
-    it "should convert to string correctly" do
-      post = Post.create
+  context "CustomPoolName" do
 
-      post.title = 120
-      post.title.must_equal '120'
+    it "should respond to methods" do
+      expect(CustomPoolName).to respond_to(:ssdb_attr_pool)
     end
 
-    it "should convert to integer correctly" do
-      post = Post.create
+    it "should set SSDBAttr connection for class correct" do
+      expect(CustomPoolName.ssdb_attr_pool_name).to eq(:foo_pool)
+    end
+
+    describe ".ssdb_attr_pool" do
+      it do
+        ccn = CustomPoolName.new
+
+        pool_dbl = double(ConnectionPool)
 
-      post.version = '120'
-      post.version.must_equal 120
+        expect(SSDBAttr).to receive(:pool).with(:foo_pool).and_return(pool_dbl)
+        expect(ccn.send(:ssdb_attr_pool)).to eq(pool_dbl)
+      end
     end
   end
 end

data/ssdb-attr.gemspec

@@ -25,7 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "minitest", "~> 5.5.1"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec", "~> 3.5.0"
   spec.add_development_dependency "activerecord", "~> 4.2.1"
   spec.add_development_dependency "activerecord-nulldb-adapter"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ssdb-attr
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.1.0
 platform: ruby
 authors:
 - Larry Zhao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-26 00:00:00.000000000 Z
+date: 2016-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -95,19 +95,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.5.1
+        version: 3.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.5.1
+        version: 3.5.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -144,6 +158,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - ".ruby-gemset"
 - ".ruby-version"
 - Gemfile
@@ -157,7 +172,6 @@ files:
 - spec/ssdb-attr_spec.rb
 - spec/ssdb/attr_spec.rb
 - ssdb-attr.gemspec
-- test/ssdb_attr_test.rb
 homepage: ''
 licenses:
 - MIT
@@ -178,7 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: Provide simple helpers on persist values in redis for performance. Works
@@ -187,4 +201,3 @@ test_files:
 - spec/spec_helper.rb
 - spec/ssdb-attr_spec.rb
 - spec/ssdb/attr_spec.rb
-- test/ssdb_attr_test.rb

data/test/ssdb_attr_test.rb

@@ -1,161 +0,0 @@
-require 'ssdb-attr'
-require 'active_record'
-ActiveRecord::Base.raise_in_transactional_callbacks = true if ActiveRecord::VERSION::STRING >= '4.2'
-
-require 'minitest/autorun'
-require 'minitest/spec'
-require 'minitest/pride'
-test_framework = defined?(MiniTest::Test) ? MiniTest::Test : MiniTest::Unit::TestCase
-
-require File.expand_path(File.dirname(__FILE__) + "/../lib/ssdb/attr")
-
-def connect!
-  SSDBAttr.setup(url: 'redis://localhost:6379/15')
-  ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
-end
-
-def setup!
-  connect!
-  { 'posts' => 'updated_at DATETIME, saved_at DATETIME, changed_at DATETIME' }.each do |table_name, columns_as_sql_string|
-    ActiveRecord::Base.connection.execute "CREATE TABLE #{table_name} (id INTEGER NOT NULL PRIMARY KEY, #{columns_as_sql_string})"
-  end
-
-  { 'chat_messages' => 'uuid VARCHAR' }.each do |table_name, columns_as_sql_string|
-    ActiveRecord::Base.connection.execute "CREATE TABLE #{table_name} (id INTEGER NOT NULL PRIMARY KEY, #{columns_as_sql_string})"
-  end
-end
-
-setup!
-
-class Post < ActiveRecord::Base
-  include SSDB::Attr
-
-  ssdb_attr :name, :string
-  ssdb_attr :int_version, :integer
-  ssdb_attr :default_title, :string, default: "Untitled"
-  ssdb_attr :plain_touch, :string, touch: true
-  ssdb_attr :custom_touch_single_column, :string, touch: :saved_at
-  ssdb_attr :custom_touch_multiple_columns, :string, touch: [:saved_at, :changed_at]
-  ssdb_attr :title, :string
-  ssdb_attr :content, :string
-  ssdb_attr :version, :integer, default: 1
-
-  before_update_ssdb_attrs :before1, :before2
-  after_update_ssdb_attrs :after1, :after2
-
-  def callback_out
-    @callback_out ||= []
-  end
-
-  [:before1, :before2, :after1, :after2].each do |name|
-    define_method(name) do
-      callback_out << name
-    end
-  end
-end
-
-class ChatMessage < ActiveRecord::Base
-  include SSDB::Attr
-
-  ssdb_attr :content, :string
-  ssdb_attr_id :uuid
-end
-
-class SsdbAttrTest < test_framework
-  def setup
-    SSDBAttr.pool.with { |conn| conn.flushdb }
-    ActiveRecord::Base.connection.tables.each do |table|
-      ActiveRecord::Base.connection.execute "DELETE FROM #{table}"
-    end
-    @post = Post.create(updated_at: 1.day.ago, saved_at: 1.day.ago, changed_at: 1.day.ago)
-    @chat_message = ChatMessage.create(uuid: SecureRandom.uuid)
-  end
-
-  def test_respond_to_methods
-    assert_equal true, @post.respond_to?(:name)
-    assert_equal true, @post.respond_to?(:name=)
-    assert_equal true, @post.respond_to?(:name_changed?)
-    assert_equal true, @post.respond_to?(:name_will_change!)
-  end
-
-  def test_integer_attribute
-    @post.int_version = "4"
-    assert_equal 4, @post.int_version
-  end
-
-  def test_with_default_value
-    assert_equal "Untitled", @post.default_title
-  end
-
-  def test_with_plain_touch
-    original_updated_at = @post.updated_at
-    @post.plain_touch = "something"
-    refute_equal original_updated_at, @post.updated_at
-  end
-
-  def test_with_custom_touch_signle_column
-    original_saved_at = @post.saved_at
-    @post.custom_touch_single_column = "something"
-    refute_equal original_saved_at, @post.saved_at
-  end
-
-  def test_with_custom_touch_multiple_columns
-    original_saved_at, original_changed_at = @post.saved_at, @post.changed_at
-    @post.custom_touch_multiple_columns = "something"
-    refute_equal original_saved_at, @post.saved_at
-    refute_equal original_changed_at, @post.changed_at
-  end
-
-  def test_to_ssdb_attr_key
-    assert_equal "posts:#{@post.id}:name", @post.to_ssdb_attr_key("name")
-  end
-
-  def test_custom_ssdb_attr_id
-    assert_equal "chat_messages:#{@chat_message.uuid}:content", @chat_message.to_ssdb_attr_key("content")
-  end
-
-  def test_update_ssdb_attrs_with_symbolize_keys
-    @post.update_ssdb_attrs(title: "note one", content: "testing!!!", version: 1)
-    assert_equal "note one", @post.title
-    assert_equal "testing!!!", @post.content
-    assert_equal 1, @post.version
-  end
-
-  def test_update_ssdb_attrs_with_string_keys
-    @post.update_ssdb_attrs("title" => "note one", "content" => "testing!!!", "version" => 1)
-    assert_equal "note one", @post.title
-    assert_equal "testing!!!", @post.content
-    assert_equal 1, @post.version
-  end
-
-  def test_update_ssdb_attrs_on_object_return_true
-    assert_equal true, @post.update_ssdb_attrs(title: "note one", content: "testing!!!", version: 1)
-  end
-
-  def test_update_ssdb_attrs_callbacks
-    @post.update_ssdb_attrs(title: "something")
-    assert_equal [:before1, :before2, :after1, :after2], @post.callback_out
-  end
-
-  def test_object_destroy_callbacks
-    @post.update_ssdb_attrs(title: "note one", content: "nice job!")
-    ssdb_title_key = @post.to_ssdb_attr_key(:title)
-    ssdb_content_key = @post.to_ssdb_attr_key(:content)
-    assert_equal true, SSDBAttr.pool.with { |conn| conn.exists(ssdb_title_key) }
-    assert_equal true, SSDBAttr.pool.with { |conn| conn.exists(ssdb_content_key) }
-    @post.destroy
-    assert_equal false, SSDBAttr.pool.with { |conn| conn.exists(ssdb_title_key) }
-    assert_equal false, SSDBAttr.pool.with { |conn| conn.exists(ssdb_content_key) }
-  end
-
-  def test_object_create_callbacks
-    title_key = @post.to_ssdb_attr_key(:title)
-    default_title_key = @post.to_ssdb_attr_key(:default_title)
-    version_key = @post.to_ssdb_attr_key(:version)
-
-    assert_equal 10, SSDBAttr.pool.with { |conn| conn.keys.count }
-    assert_equal true, SSDBAttr.pool.with { |conn| conn.exists(title_key) }
-    assert_equal "Untitled", SSDBAttr.pool.with { |conn| conn.get(default_title_key) }
-    assert_equal "1", SSDBAttr.pool.with { |conn| conn.get(version_key) }
-  end
-end