findable 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87900a069a5960243f4231d883d417f0b39c319c
-  data.tar.gz: 44fe61ca87bf212c297cacec0dd8c429dc371d65
+  metadata.gz: 4305f6cde690c51441bbdd0da26eae24b10d7b04
+  data.tar.gz: 40f6aedbad7fdc92cb81b4a423712b118111eb02
 SHA512:
-  metadata.gz: c65b156840c789ea9338d6e574a67befcc28c6f8c3dfcdcff59aef446d3a37bb754b1018d2904b988e26783af48d6a2fa2676fdd570d04f7b385dcda3d079210
-  data.tar.gz: 9c851c3620d17317a35aeda778b80b23997ef0778e44e1de5750d5f403bf324e9eb12920b81726c3724ce54e4e5814241a24e423f3fa970fa424b885561841b0
+  metadata.gz: 1535776a557a195a0a7757446136ab67a834a66c08dd28a952b535037110eb0eff880e322b78c8ecaeba1181b47309e1a21c11c3aa9191874811b132554799de
+  data.tar.gz: 918c3a3636e3c6dc952e0aa3544acc04843c61dc8ac6412975f04102c350fc5d3d001fb1fa3349c97fc056bec11906c87dd30f61f83569a1eb356aa45e3dde67

data/.coveralls.yml

@@ -1,2 +1 @@
 repo_token: fbWiPxpNWcR8fOyueZ7IWw1pMbl20ZvRN
-

data/.gitignore

@@ -13,4 +13,3 @@
 *.a
 mkmf.log
 .DS_Store
-

data/.travis.yml

@@ -7,4 +7,3 @@ gemfile:
 script: bundle exec rake spec
 services:
   - redis-server
-

data/README.md

@@ -7,6 +7,10 @@
 
 Redis wrapper with API like ActiveRecord.
 
+## Requirements
+
+- Redis
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/findable.gemspec

@@ -20,13 +20,14 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "activesupport"
   spec.add_dependency "activemodel"
-  spec.add_dependency "redis-objects"
+  spec.add_dependency "redis"
   spec.add_dependency "oj"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "coveralls"
   spec.add_development_dependency "simplecov"

data/lib/findable.rb

@@ -1,7 +1,7 @@
 require "active_support"
 require "active_support/core_ext"
 require "active_model"
-require "redis/objects"
+require "redis"
 require "oj"
 
 require "findable/version"

data/lib/findable/associations/active_record_ext.rb

@@ -15,14 +15,7 @@ module Findable
               model.where(foreign_key => public_send(self.class.primary_key))
             end
 
-            reflection = ActiveRecord::Reflection.create(
-              :has_many,
-              name.to_sym,
-              nil,
-              options,
-              self,
-            )
-            ActiveRecord::Reflection.add_reflection(self, name.to_sym, reflection)
+            Utils.add_reflection(:has_many, name.to_sym, options, self)
           else
             super
           end
@@ -39,14 +32,7 @@ module Findable
               model.find_by(foreign_key => public_send(self.class.primary_key))
             end
 
-            reflection = ActiveRecord::Reflection.create(
-              :has_one,
-              name.to_sym,
-              nil,
-              options,
-              self,
-            )
-            ActiveRecord::Reflection.add_reflection(self, name.to_sym, reflection)
+            Utils.add_reflection(:has_one, name.to_sym, options, self)
           else
             super
           end
@@ -68,14 +54,7 @@ module Findable
               public_send("#{foreign_key}=", value)
             end
 
-            reflection = ActiveRecord::Reflection.create(
-              :belongs_to,
-              name.to_sym,
-              nil,
-              options,
-              self,
-            )
-            ActiveRecord::Reflection.add_reflection(self, name.to_sym, reflection)
+            Utils.add_reflection(:belongs_to, name.to_sym, options, self)
           else
             super
           end

data/lib/findable/associations/utils.rb

@@ -19,6 +19,17 @@ module Findable
         options = copied.extract_options!
         [copied.first, options]
       end
+
+      def self.add_reflection(macro, name, options, ar)
+        reflection = ActiveRecord::Reflection.create(
+          macro.to_sym,
+          name.to_sym,
+          nil,
+          options,
+          ar
+        )
+        ActiveRecord::Reflection.add_reflection(ar, name.to_sym, reflection)
+      end
     end
   end
 end

data/lib/findable/base.rb

@@ -13,9 +13,8 @@ module Findable
     class << self
       ## field definitions
 
-      def define_field(attr, options = {})
+      def define_field(attr)
         unless public_method_defined?(attr)
-          options.symbolize_keys!
           define_attribute_methods attr
           define_method(attr) { attributes[attr.to_sym] }
           column_names << attr.to_sym

data/lib/findable/errors.rb

@@ -8,10 +8,6 @@ module Findable
     end
   end
 
-  class ModelNotFound < FindableError
-    def initialize(model_name)
-      super("#{model_name} not found.")
-    end
-  end
+  class LockTimeout < FindableError; end
 end
 

data/lib/findable/query.rb

@@ -1,5 +1,6 @@
 require "findable/query/connection"
 require "findable/query/namespace"
+require "findable/query/lock"
 
 module Findable
   class Query
@@ -27,7 +28,7 @@ module Findable
     end
 
     def insert(hash)
-      transaction do
+      lock do
         hash[:id] = auto_incremented_id(hash[:id])
         redis.hset(data_key, hash[:id], Oj.dump(hash))
       end
@@ -35,7 +36,7 @@ module Findable
     end
 
     def import(hashes)
-      transaction do
+      lock do
         auto_incremented = hashes.each_with_object([]) do |hash, obj|
           hash["id"] = auto_incremented_id(hash["id"])
           obj << hash["id"]
@@ -55,22 +56,9 @@ module Findable
       end
     end
 
-    def transaction
+    def lock
       raise ArgumentError, "Require block" unless block_given?
-      if Thread.current[thread_key]
-        yield
-      else
-        begin
-          Thread.current[thread_key] = true
-          Redis::Lock.new(lock_key).lock do
-            yield
-          end
-        rescue Redis::Lock::LockTimeout
-          raise
-        ensure
-          Thread.current[thread_key] = nil
-        end
-      end
+      Lock.new(lock_key, thread_key).lock { yield }
     end
 
     private

data/lib/findable/query/connection.rb

@@ -11,7 +11,7 @@ module Findable
         # Generate connection with redis options or default connection.
         # @return [Redis] Redis connection
         def generate_redis_connection!
-          redis_options ? Redis.new(*redis_options) : Redis.current
+          redis_options ? Redis.new(**redis_options) : Redis.current
         end
 
         # Returns redis options from configuration.

data/lib/findable/query/lock.rb

@@ -0,0 +1,59 @@
+require "findable/query/connection"
+
+module Findable
+  class Query
+    class Lock
+      include Findable::Query::Connection
+
+      def initialize(lock_key, thread_key, options = {})
+        @lock_key = lock_key
+        @thread_key = thread_key
+        @options = options.symbolize_keys!
+      end
+
+      def lock
+        if Thread.current[@thread_key]
+          yield
+        else
+          Thread.current[@thread_key] = true
+          try_lock!(Time.current)
+          begin
+            yield
+          ensure
+            Thread.current[@thread_key] = nil
+            unlock!
+          end
+        end
+      end
+
+      def unlock!
+        redis.del(@lock_key)
+      end
+
+      private
+        def try_lock!(start)
+          loop do
+            break if redis.setnx(@lock_key, expiration)
+
+            current = redis.get(@lock_key).to_f
+            if current < Time.current.to_f
+              old = redis.getset(@lock_key, expiration).to_f
+              break if old < Time.current.to_f
+            end
+
+            Kernel.sleep(0.1)
+            raise Findable::LockTimeout if (Time.current.to_f - start) > timeout
+          end
+        end
+
+        def expiration
+          (Time.current + timeout).to_f
+        end
+
+        def timeout
+          (@options[:timeout] || 5).to_f
+        end
+    end
+  end
+end
+

data/lib/findable/version.rb

@@ -1,4 +1,4 @@
 module Findable
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end
 

data/spec/active_model_lint_spec.rb

@@ -1,71 +1,71 @@
 require "spec_helper"
 
 describe ActiveModel::Lint::Tests do
-  include_context "FindableModels"
+  include_context "TemporaryModel"
 
   context "#test_to_key" do
     it "The model should respond to to_key" do
-      expect(findable_instance).to respond_to(:to_key)
+      expect(instance).to respond_to(:to_key)
     end
 
     it "to_key should return nil when `persisted?` returns false" do
-      allow(findable_instance).to receive(:persisted?).and_return(false)
-      expect(findable_instance.to_key).to be_nil
+      allow(instance).to receive(:persisted?).and_return(false)
+      expect(instance.to_key).to be_nil
     end
   end
 
   context "#test_to_param" do
     it "The model should respond to to_param" do
-      expect(findable_instance).to respond_to(:to_param)
+      expect(instance).to respond_to(:to_param)
     end
 
     it "to_param should return nil when `persisted?` returns false" do
-      allow(findable_instance).to receive(:to_key).and_return([1])
-      allow(findable_instance).to receive(:persisted?).and_return(false)
-      expect(findable_instance.to_param).to be_nil
+      allow(instance).to receive(:to_key).and_return([1])
+      allow(instance).to receive(:persisted?).and_return(false)
+      expect(instance.to_param).to be_nil
     end
   end
 
   context "#test_to_partial_path" do
     it "The model should respond to to_partial_path" do
-      expect(findable_instance).to respond_to(:to_partial_path)
+      expect(instance).to respond_to(:to_partial_path)
     end
 
-    it { expect(findable_instance.to_partial_path).to be_kind_of(String) }
+    it { expect(instance.to_partial_path).to be_kind_of(String) }
   end
 
   context "#test_persisted?" do
     it "The model should respond to persisted?" do
-      expect(findable_instance).to respond_to(:persisted?)
+      expect(instance).to respond_to(:persisted?)
     end
 
     it "persisted?" do
-      bool = findable_instance.persisted?
+      bool = instance.persisted?
       expect(bool == true || bool == false).to be_truthy
     end
   end
 
   context "#test_model_naming" do
     it "The model class should respond to model_name" do
-      expect(findable_instance).to respond_to(:model_name)
+      expect(instance).to respond_to(:model_name)
     end
 
-    it { expect(findable_model.model_name).to respond_to(:to_str) }
-    it { expect(findable_model.model_name.human).to respond_to(:to_str) }
-    it { expect(findable_model.model_name.singular).to respond_to(:to_str) }
-    it { expect(findable_model.model_name.plural).to respond_to(:to_str) }
+    it { expect(model.model_name).to respond_to(:to_str) }
+    it { expect(model.model_name.human).to respond_to(:to_str) }
+    it { expect(model.model_name.singular).to respond_to(:to_str) }
+    it { expect(model.model_name.plural).to respond_to(:to_str) }
 
-    it { expect(findable_instance).to respond_to(:model_name) }
-    it { expect(findable_instance.model_name).to eq(findable_model.model_name) }
+    it { expect(instance).to respond_to(:model_name) }
+    it { expect(instance.model_name).to eq(model.model_name) }
   end
 
   context "#test_errors_aref" do
     it "The model should respond to errors" do
-      expect(findable_instance).to respond_to(:errors)
+      expect(instance).to respond_to(:errors)
     end
 
     it "errors#[] should return an Array" do
-      expect(findable_instance.errors[:hello]).to be_kind_of(Array)
+      expect(instance.errors[:hello]).to be_kind_of(Array)
     end
   end
 end

data/spec/findable/associations/active_record_ext_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Findable::Associations::ActiveRecordExt do
+  let(:company) { Company.first }
+  let(:store) { Store.first }
+  let(:email) { Email.first }
+  let(:user) { User.first }
+
+  describe "#has_many" do
+    it { expect(company.users).to be_kind_of(Array) }
+    it { expect(company.users.first).to be_kind_of(User) }
+    it { expect(company.stores).to be_kind_of(ActiveRecord::Relation) }
+    it { expect(company.stores.first).to be_kind_of(Store) }
+  end
+
+  describe "#has_one" do
+    it { expect(company.image).to be_kind_of(Image) }
+    it { expect(store.email).to be_kind_of(Email) }
+  end
+
+  describe "#belongs_to" do
+    it { expect(email.user).to be_kind_of(User) }
+    it { expect(store.company).to be_kind_of(Company) }
+    it {
+      email.user = user
+      expect(email.user_id).to eq(user.id)
+    }
+  end
+end
+

data/spec/findable/associations/utils_spec.rb

@@ -4,12 +4,12 @@ describe Findable::Associations::Utils do
   let(:utils) { Findable::Associations::Utils }
 
   describe "#model_for" do
-    include_context "FindableModels"
-    let(:model_name) { findable_model.model_name }
+    include_context "TemporaryModel"
+    let(:model_name) { model.model_name }
 
-    it { expect(utils.model_for(model_name.singular)).to eq(findable_model) }
-    it { expect(utils.model_for(model_name.plural, collection: true)).to eq(findable_model) }
-    it { expect(utils.model_for("invalid", class_name: model_name.name)).to eq(findable_model) }
+    it { expect(utils.model_for(model_name.singular)).to eq(model) }
+    it { expect(utils.model_for(model_name.plural, collection: true)).to eq(model) }
+    it { expect(utils.model_for("invalid", class_name: model_name.name)).to eq(model) }
 
     it { expect { utils.model_for("invalid") }.to raise_error }
     it { expect { utils.model_for("invalid", safe: true) }.not_to raise_error }

data/spec/findable/associations_spec.rb

@@ -1,21 +1,34 @@
 require "spec_helper"
 
 describe Findable::Associations do
-  include_context "AssociationModels"
-  let(:group) { Group.first }
-  let(:info) { Info.first }
-  let(:tag) { Tag.first }
+  let(:category) { Category.first }
+  let(:product) { Product.first }
+  let(:image) { Image.first }
+  let(:user) { User.find(UserData.first[:id]) }
+  let(:user2) { User.find(UserData.last[:id]) }
+  let(:other_company) { Company.last }
 
   describe "#has_many" do
-    it { expect(group.tags.map(&:id).sort).to eq(Tag.all.map(&:id).sort) }
+    it { expect(category.products).to be_kind_of(Array) }
+    it { expect(category.products.first).to be_kind_of(Product) }
+    it { expect(user.pictures).to be_kind_of(ActiveRecord::Relation) }
+    it { expect(user.pictures.first).to be_kind_of(Picture) }
   end
 
   describe "#has_one" do
-    it { expect(group.info.id).to eq(info.id) }
+    it { expect(product.image).to be_kind_of(Image) }
+    it { expect(user.email).to be_kind_of(Email) }
   end
 
   describe "#belongs_to" do
-    it { expect(tag.group.id).to eq(group.id) }
+    it { expect(product.category).to be_kind_of(Category) }
+    it { expect(user.company).to be_kind_of(Company) }
+    it { expect(user.content).to be_kind_of(Image) }
+    it { expect(user2.content).to be_kind_of(Picture) }
+    it {
+      user.company = other_company
+      expect(user).to have_attributes(company_id: other_company.id)
+    }
   end
 end
 

data/spec/findable/base_spec.rb

@@ -1,5 +1,75 @@
 require "spec_helper"
 
 describe Findable::Base do
+  include_context "TemporaryModel"
+  include_context "ReadOnlyModel"
+
+  describe ".primary_key" do
+    it { expect(model.primary_key).to eq("id") }
+  end
+
+  describe ".column_names" do
+    it { expect(model.column_names).to eq([:id, :name]) }
+  end
+
+  describe ".all" do
+    it { expect(read_model.all).to be_kind_of(Array) }
+    it { expect(read_model.all.size).to eq(1) }
+  end
+
+  describe ".find" do
+    it { expect(read_model.find(id)).to be_kind_of(read_model) }
+    it { expect(read_model.find([id])).to be_kind_of(Array) }
+    it {
+      expect {
+        read_model.find(invalid_id)
+      }.to raise_error(Findable::RecordNotFound)
+    }
+  end
+
+  describe ".find_by" do
+    it { expect(read_model.find_by(id: id)).to be_kind_of(read_model) }
+    it { expect(read_model.find_by(id: invalid_id)).to be_nil }
+    it { expect(read_model.find_by(id: id, name: name)).to be_kind_of(read_model) }
+    it { expect(read_model.find_by(id: id, name: invalid_name)).to be_nil }
+    it { expect(read_model.find_by(name: name)).to be_kind_of(read_model) }
+    it { expect(read_model.find_by(name: invalid_name)).to be_nil }
+    it { expect(read_model.find_by(id)).to be_kind_of(read_model) }
+    it { expect(read_model.find_by(invalid_id)).to be_nil }
+  end
+
+  describe ".find_by!" do
+    it {
+      expect {
+        read_model.find_by!(id: id)
+      }.not_to raise_error
+    }
+    it {
+      expect {
+        read_model.find_by!(id: invalid_id)
+      }.to raise_error(Findable::RecordNotFound)
+    }
+  end
+
+  describe ".where" do
+    it { expect(read_model.where(id: id)).to be_kind_of(Array) }
+    it { expect(read_model.where(id: id).first).to be_kind_of(read_model) }
+    it { expect(read_model.where(id: invalid_id)).to be_empty }
+    it { expect(read_model.where(id: id, name: name)).to be_kind_of(Array) }
+    it { expect(read_model.where(id: id, name: name).first).to be_kind_of(read_model) }
+    it { expect(read_model.where(id: invalid_id, name: name)).to be_empty }
+    it { expect(read_model.where(name: name)).to be_kind_of(Array) }
+    it { expect(read_model.where(name: name).first).to be_kind_of(read_model) }
+    it { expect(read_model.where(name: invalid_name)).to be_empty }
+  end
+
+  describe ".create" do
+    it {
+      expect {
+        model.create(name: "example")
+      }.to change { model.count }.by(1)
+    }
+    it { expect(model).to respond_to(:create!) }
+  end
 end
 

data/spec/findable/errors_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "Errors" do
+  include_context "ReadOnlyModel"
+
+  describe Findable::FindableError do
+    it { is_expected.to be_kind_of(StandardError) }
+  end
+
+  describe Findable::RecordNotFound do
+    let(:error) { Findable::RecordNotFound.new(read_model, {id: 1}) }
+    it { expect(error).to be_kind_of(Findable::FindableError) }
+    it { expect(error.message).to match(Regexp.new(read_model.model_name.name)) }
+    it { expect(error.message).to match(Regexp.new({id: 1}.inspect)) }
+  end
+end
+

data/spec/findable/query/connection_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe Findable::Query::Connection do
+  before do
+    class QueryEx; end
+    QueryEx.include Findable::Query::Connection
+  end
+
+  after do
+    Object.send(:remove_const, "QueryEx")
+  end
+
+  let(:query) { QueryEx.new }
+  let(:custom_options) { {host: "localhost", port: 6379, db: 15} }
+
+  describe "#redis" do
+    it { expect(query.redis).to be_kind_of(Redis) }
+    it {
+      expect(query).to receive(:generate_redis_connection!)
+      query.redis
+    }
+  end
+
+  describe "#generate_redis_connection!" do
+    context "when redis_options is nil" do
+      before { Findable.config.redis_options = nil }
+
+      it { expect(query.send(:generate_redis_connection!)).to be_kind_of(Redis) }
+      it {
+        expect(Redis).not_to receive(:new)
+        expect(Redis).to receive(:current)
+        query.redis
+      }
+    end
+
+    context "when redis_options is not nil" do
+      before { Findable.config.redis_options = custom_options }
+
+      it { expect(query.send(:generate_redis_connection!)).to be_kind_of(Redis) }
+      it {
+        expect(Redis).to receive(:new)
+        expect(Redis).not_to receive(:current)
+        query.redis
+      }
+    end
+  end
+
+  describe "#redis_options" do
+    context "with custom options" do
+      it {
+        Findable.config.redis_options = custom_options
+        expect(query.send(:redis_options)).to eq(custom_options)
+      }
+    end
+
+    context "without custom options" do
+      after { expect(query.send(:redis_options)).to be_nil }
+
+      it { Findable.config.redis_options = nil }
+      it { Findable.config.redis_options = {} }
+    end
+  end
+end
+

data/spec/findable/query/namespace_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Findable::Query::Namespace do
+  include_context "TemporaryModel"
+
+  before do
+    QueryEx = Class.new
+    QueryEx.include Findable::Query::Namespace
+  end
+
+  after { Object.send(:remove_const, "QueryEx") }
+
+  let(:namespace) { Findable::Query::Namespace }
+  let(:query) { QueryEx.new(model) }
+
+  describe "Method definitions of various keys" do
+    it {
+      namespace::KEY_NAMES.each do |name|
+        expect(query.public_send("#{name}_key")).to be_kind_of(String)
+        expect(query.public_send("#{name}_key")).to start_with(namespace::PREFIX)
+      end
+    }
+  end
+
+  describe "#initialize" do
+    it { expect(query.instance_eval { @_model }).to eq(model) }
+  end
+
+  describe "#thread_key" do
+    it { expect(query.thread_key).to be_kind_of(String) }
+    it { expect(query.thread_key).to start_with(namespace::PREFIX) }
+  end
+
+  describe "#basename" do
+    it { expect(query.send(:basename)).to eq("sizes") }
+  end
+
+  describe "#namespaces" do
+    it { expect(query.send(:namespaces)).to be_kind_of(Hash) }
+    it {
+      expect(query.send(:namespaces)).to satisfy {|hash|
+        namespace::KEY_NAMES.all? {|key| hash.has_key?(key) }
+      }
+    }
+    it {
+      query.send(:namespaces)
+      expect(query).not_to receive(:basename)
+      query.send(:namespaces)
+    }
+  end
+end
+

data/spec/findable/query_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Findable::Query do
+  include_context "TemporaryModel"
+  include_context "ReadOnlyModel"
+
+  let(:auto_increment_key) { Findable::Query::Namespace::AUTO_INCREMENT_KEY }
+
+  describe "#data" do
+    it { expect(read_model.query.data).to be_kind_of(Array) }
+    it { expect(read_model.query.data.size).to eq(1) }
+  end
+
+  describe "#ids" do
+    it { expect(read_model.query.ids).to be_kind_of(Array) }
+    it { expect(read_model.query.ids).to eq([1]) }
+  end
+
+  describe "#count" do
+    it { expect(read_model.query.count).to eq(1) }
+  end
+
+  describe "#find_by_ids" do
+    let(:raw_value) { read_model.query.find_by_ids(1) }
+    let(:loaded_value) { Oj.load(raw_value.first) }
+
+    it { expect(raw_value).to be_kind_of(Array) }
+    it { expect(raw_value.first).to be_kind_of(String) }
+    it { expect(loaded_value[:id]).to eq(1) }
+  end
+
+  describe "#exists?" do
+    it { expect(read_model.exists?(1)).to be_truthy }
+    it { expect(read_model.exists?(2)).to be_falsey }
+  end
+
+  describe "#insert" do
+    it { expect(model.query.insert(name: name)).to be_kind_of(Hash) }
+    it { expect(model.query.insert(name: name)[:id]).not_to be_nil }
+    it { expect(model.query.insert(name: name)[:name]).to eq(name) }
+    it {
+      expect {
+        model.query.insert(name: name)
+      }.to change { model.query.count }.by(1)
+    }
+  end
+
+  describe "#import" do
+  end
+
+  describe "#delete" do
+    let!(:params) { model.query.insert(name: name) }
+
+    it {
+      expect {
+        model.query.delete(params[:id])
+      }.to change { model.query.count }.by(-1)
+    }
+  end
+
+  describe "#delete_all" do
+    before {
+      model.query.insert(name: name)
+      model.query.delete_all
+    }
+
+    it { expect(model.query.redis.exists(model.query.data_key)).to be_falsey }
+    it { expect(model.query.redis.exists(model.query.info_key)).to be_falsey }
+  end
+
+  describe "#transaction" do
+  end
+
+  describe "#auto_incremented_id" do
+    context "when id is nil" do
+      let!(:id) { model.query.send(:auto_incremented_id, nil) }
+      let(:info_id) {
+        model.query.redis.hget(model.query.info_key, auto_increment_key).to_i
+      }
+
+      it { expect(id).to be_kind_of(Integer) }
+      it { expect(id).to eq(info_id) }
+    end
+
+    context "when id is not nil" do
+      before { model.query.redis.hset(model.query.info_key, auto_increment_key, 10) }
+
+      it {
+        expect_any_instance_of(Redis).not_to receive(:hset)
+        id = model.query.send(:auto_incremented_id, 5)
+        expect(id).to eq(5)
+      }
+
+      it {
+        expect_any_instance_of(Redis).to receive(:hset)
+        id = model.query.send(:auto_incremented_id, 15)
+        expect(id).to eq(15)
+      }
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -13,12 +13,18 @@ SimpleCov.start do
   add_filter "example"
 end
 
+require "bundler/setup"
+require "active_record"
+require "sqlite3"
 require "pry"
+
 require "findable"
+require "findable/associations/active_record_ext"
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
+  config.order = :random
   config.after(:each) { Findable.config.reset }
 end
 

data/spec/support/initialize_database.rb

@@ -0,0 +1,107 @@
+# =========================
+# Initialize and Migrations
+# =========================
+
+# Initialize Redis
+Redis.current.flushdb
+
+# Initialize SQLite
+ActiveRecord::Base.establish_connection({
+  adapter: "sqlite3",
+  database: ":memory:",
+})
+
+ActiveRecord::Migration.create_table :companies do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :stores do |t|
+  t.string :name
+  t.integer :company_id
+end
+
+ActiveRecord::Migration.create_table :emails do |t|
+  t.string :address
+  t.integer :store_id
+  t.integer :user_id
+end
+
+ActiveRecord::Migration.create_table :pictures do |t|
+  t.string :name
+  t.integer :user_id
+end
+
+# =========================
+# Model definitions
+# =========================
+
+# Model < Findable
+%w(Category Product Image User).each do |class_name|
+  Object.const_set(class_name, Class.new(Findable::Base))
+end
+
+# Model < ActiveRecord
+%w(Company Store Email Picture).each do |class_name|
+  Object.const_set(class_name, Class.new(ActiveRecord::Base))
+end
+
+ActiveRecord::Base.subclasses.each do |ar|
+  ar.include Findable::Associations::ActiveRecordExt
+end
+
+# Associations
+Category.has_many :products
+Product.belongs_to :category
+Product.has_one :image
+Image.belongs_to :product
+
+Company.has_many :stores
+Store.belongs_to :company
+Store.has_one :email
+Email.belongs_to :store
+
+User.belongs_to :content, polymorphic: true
+
+User.has_many :pictures
+Picture.belongs_to :user
+
+User.has_one :email
+Email.belongs_to :user
+
+Company.has_many :users
+User.belongs_to :company
+
+Company.has_one :image
+Image.belongs_to :company
+
+# =========================
+# Data import
+# =========================
+CategoryData = [{id: 1, name: "Book"}]
+Category.query.import(CategoryData)
+
+ProductData = [
+  {id: 1, name: "book 1", category_id: 1},
+  {id: 2, name: "book 2", category_id: 1},
+]
+Product.query.import(ProductData)
+
+ImageData = [
+  {id: 1, product_id: 1, company_id: 1},
+  {id: 2, product_id: 2, company_id: 1},
+]
+Image.query.import(ImageData)
+
+UserData = [
+  {id: 1, name: "user 1", content_type: "Image", content_id: 1, company_id: 1},
+  {id: 2, name: "user 2", content_type: "Picture", content_id: 1, company_id: 1}
+]
+User.query.import(UserData)
+
+Company.create!(id: 1, name: "company 1")
+Company.create!(id: 2, name: "company 2")
+Store.create(id: 1, name: "store 1", company_id: 1)
+Email.create!(id: 1, address: "findable@example.com", store_id: 1, user_id: 1)
+Picture.create!(id: 1, name: "picture 1", user_id: 1)
+Picture.create!(id: 2, name: "picture 2", user_id: 1)
+

data/spec/support/shared_contexts.rb

@@ -0,0 +1,16 @@
+shared_context "TemporaryModel" do
+  before { class Size < Findable::Base; define_field :name; end }
+  after { Size.delete_all; Object.send(:remove_const, "Size") }
+  let(:model) { Size }
+  let(:instance) { model.new }
+end
+
+# model for read only test
+shared_context "ReadOnlyModel" do
+  let(:read_model) { Category }
+  let(:id) { CategoryData.first[:id] }
+  let(:invalid_id) { CategoryData.last[:id] + 1 }
+  let(:name) { CategoryData.first[:name] }
+  let(:invalid_name) { "invalid" }
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: findable
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - i2bskn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-06 00:00:00.000000000 Z
+date: 2015-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: redis-objects
+  name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: pry
   requirement: !ruby/object:Gem::Requirement
@@ -189,6 +203,7 @@ files:
 - lib/findable/errors.rb
 - lib/findable/query.rb
 - lib/findable/query/connection.rb
+- lib/findable/query/lock.rb
 - lib/findable/query/namespace.rb
 - lib/findable/railtie.rb
 - lib/findable/seed.rb
@@ -198,15 +213,18 @@ files:
 - lib/generators/findable/templates/seeds.rb
 - lib/tasks/findable.rake
 - spec/active_model_lint_spec.rb
-- spec/findable/.keep
+- spec/findable/associations/active_record_ext_spec.rb
 - spec/findable/associations/utils_spec.rb
 - spec/findable/associations_spec.rb
 - spec/findable/base_spec.rb
 - spec/findable/configuration_spec.rb
+- spec/findable/errors_spec.rb
+- spec/findable/query/connection_spec.rb
+- spec/findable/query/namespace_spec.rb
+- spec/findable/query_spec.rb
 - spec/spec_helper.rb
-- spec/support/.keep
-- spec/support/initialize_redis.rb
-- spec/support/shard_contexts.rb
+- spec/support/initialize_database.rb
+- spec/support/shared_contexts.rb
 homepage: https://github.com/i2bskn/findable
 licenses:
 - MIT
@@ -233,12 +251,15 @@ specification_version: 4
 summary: Redis wrapper with API like ActiveRecord.
 test_files:
 - spec/active_model_lint_spec.rb
-- spec/findable/.keep
+- spec/findable/associations/active_record_ext_spec.rb
 - spec/findable/associations/utils_spec.rb
 - spec/findable/associations_spec.rb
 - spec/findable/base_spec.rb
 - spec/findable/configuration_spec.rb
+- spec/findable/errors_spec.rb
+- spec/findable/query/connection_spec.rb
+- spec/findable/query/namespace_spec.rb
+- spec/findable/query_spec.rb
 - spec/spec_helper.rb
-- spec/support/.keep
-- spec/support/initialize_redis.rb
-- spec/support/shard_contexts.rb
+- spec/support/initialize_database.rb
+- spec/support/shared_contexts.rb

data/spec/support/initialize_redis.rb

@@ -1,2 +0,0 @@
-Redis.current.flushdb
-

data/spec/support/shard_contexts.rb

@@ -1,29 +0,0 @@
-shared_context "FindableModels" do
-  before { class Tag < Findable::Base; end }
-  after { Object.send(:remove_const, "Tag") }
-
-  let(:findable_model) { Tag }
-  let(:findable_instance) { Tag.new }
-end
-
-shared_context "AssociationModels" do
-  before do
-    class Group < Findable::Base; end
-    class Tag < Findable::Base; end
-    class Info < Findable::Base; end
-    Group.has_many :tags
-    Group.has_one :info
-    Tag.belongs_to :group
-    Info.belongs_to :group
-
-    Group.query.import([{id: 1, name: "group1"}])
-    Tag.query.import([
-      {id: 1, name: "tag1", group_id: 1},
-      {id: 2, name: "tag2", group_id: 1},
-    ])
-    Info.query.import([{id: 1, group_id: 1}])
-  end
-
-  after { %w(Group Tag Info).each {|name| Object.send(:remove_const, name) } }
-end
-