active_record_handlersocket 0.0.1

data/lib/active_record_handlersocket/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordHandlersocket
+  VERSION = "0.0.1"
+end

data/spec/cases/connection_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe "ConnectionSpec" do
+  let :klass do
+    Person
+  end
+
+  let :another_klass do
+    Hobby
+  end
+
+  describe "hs_reconnect!" do
+    before :each do
+      ActiveRecord::Base.__send__(:hs_read_connection).close
+      ActiveRecord::Base.__send__(:hs_reset_opened_indexes)
+    end
+
+    it "should reconnect to handlersocket" do
+      expect(ActiveRecord::Base.hs_reconnect!).to be
+      expect{
+        klass.hsfind_by_id(1)
+      }.not_to raise_error(ActiveRecordHandlerSocket::CannotConnectError)
+    end
+
+    it "should reset opened indexes" do
+      expect(ActiveRecord::Base.hs_reconnect!).to be
+
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+    end
+  end
+
+  describe "hs_active?" do
+    context "when connected" do
+      before :each do
+        # open index
+        klass.hsfind_by_id(1)
+      end
+
+      it "should return true when connected" do
+        expect(ActiveRecord::Base.hs_active?).to be
+      end
+    end
+
+    context "when closed" do
+      before :each do
+        ActiveRecord::Base.__send__(:hs_read_connection).close
+      end
+
+      after :each do
+        ActiveRecord::Base.hs_reconnect!
+      end
+
+      it "should return false" do
+        expect(ActiveRecord::Base.hs_active?).not_to be
+      end
+    end
+  end
+
+  describe "hs_establish_connection" do
+    context "when no name given" do
+      before :each do
+        @original_connections = ActiveRecord::Base.__send__(:hs_connections)
+        ActiveRecordHandlerSocket::Connection::PrivateMethods.__send__(:class_variable_set, :@@hs_connections, {})
+      end
+
+      after :each do
+        ActiveRecordHandlerSocket::Connection::PrivateMethods.__send__(:class_variable_set, :@@hs_connections, @original_connections)
+      end
+
+      it "should add read connection" do
+        ActiveRecord::Base.__send__(:hs_establish_connection)
+        expect(ActiveRecord::Base.__send__(:hs_connections)[:read]).to be_kind_of(HandlerSocket)
+      end
+    end
+
+    context "when read connection" do
+      before :each do
+        @original_connections = ActiveRecord::Base.__send__(:hs_connections)
+        ActiveRecordHandlerSocket::Connection::PrivateMethods.__send__(:class_variable_set, :@@hs_connections, {})
+      end
+
+      after :each do
+        ActiveRecordHandlerSocket::Connection::PrivateMethods.__send__(:class_variable_set, :@@hs_connections, @original_connections)
+      end
+
+      it "should add read connection" do
+        ActiveRecord::Base.__send__(:hs_establish_connection, "test_hs_read")
+        expect(ActiveRecord::Base.__send__(:hs_connections)[:read]).to be_kind_of(HandlerSocket)
+      end
+    end
+
+    context "when unknown configuration name given" do
+      it "should raise error" do
+        expect{
+          ActiveRecord::Base.__send__(:hs_establish_connection, "production_hs_read")
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "hs_read_connection" do
+    it "should return handlersocket" do
+      expect(ActiveRecord::Base.__send__(:hs_read_connection)).to be_kind_of(HandlerSocket)
+    end
+  end
+end

data/spec/cases/finder_spec.rb

@@ -0,0 +1,313 @@
+require 'spec_helper'
+
+describe "FinderSpec" do
+  let :klass do
+    Person
+  end
+
+  let :another_klass do
+    Hobby
+  end
+
+  before :each do
+    @bob = FactoryGirl.create(:bob)
+    FactoryGirl.create(:pharrell)
+  end
+
+  describe "hsfind" do
+    context "when defined by handlersocket" do
+      before :each do
+        klass.delete_all
+      end
+
+      context "for :first" do
+        it "should call hsfind with method_missing" do
+          expect(klass).not_to respond_to(:hsfind_by_id)
+          expect(klass.hsfind_by_id(1)).to be_nil
+        end
+      end
+
+      context "for :multi" do
+        it "should call hsfind with method_missing" do
+          expect(klass).not_to respond_to(:hsfind_multi_by_id)
+          expect(klass.hsfind_multi_by_id(1)).to be_empty
+        end
+      end
+    end
+
+    context "when before definition by handlersocket" do
+      context "for :first" do
+        it "should raise error" do
+          expect{
+            klass.hsfind_by_name("Bob")
+          }.to raise_error(ActiveRecordHandlerSocket::UnknownIndexError)
+        end
+      end
+
+      context "for :multi" do
+        it "should raise error" do
+          expect{
+            klass.hsfind_multi_by_name("Bob")
+          }.to raise_error(ActiveRecordHandlerSocket::UnknownIndexError)
+        end
+      end
+    end
+
+    context "when records exist" do
+      context "for :first" do
+        it "should get one record by id" do
+          person    = klass.find_by_id(1)
+          hs_person = klass.hsfind_by_id(1)
+
+          expect(hs_person).to eql(person)
+        end
+
+        it "should get nil by unknown id" do
+          person    = klass.find_by_id(9)
+          hs_person = klass.hsfind_by_id(9)
+
+          expect(person).to be_nil
+          expect(hs_person).to be_nil
+        end
+      end
+
+      context "for :multi" do
+        it "should get one record by id" do
+          person    = klass.find_all_by_id([1])
+          hs_person = klass.hsfind_multi_by_id(1)
+
+          expect(hs_person).to eql(person)
+        end
+
+        it "should get some records by ids" do
+          people    = klass.find_all_by_id([1, 2])
+          hs_people = klass.hsfind_multi_by_id(1, 2)
+
+          expect(hs_people).to eql(people)
+        end
+
+        it "should get empty array by unknown id" do
+          people    = klass.find_all_by_id([9])
+          hs_people = klass.hsfind_multi_by_id(9)
+
+          expect(people).to be_empty
+          expect(hs_people).to be_empty
+        end
+      end
+    end
+
+    context "when finder with options" do
+      context "for :single" do
+        context "with operator option" do
+          it "should find greater value record" do
+            hs_person = klass.hsfind_by_id(0, :operator => ">")
+
+            expect(hs_person).to be_kind_of(klass)
+
+            hs_person = klass.hsfind_by_id(3, :operator => ">")
+
+            expect(hs_person).to be_nil
+          end
+
+          it "should find less value record" do
+            person    = klass.find_by_id(2)
+            hs_person = klass.hsfind_by_id(3, :operator => "<")
+
+            expect(hs_person).to eql(person)
+
+            hs_person = klass.hsfind_by_id(0, :operator => "<")
+
+            expect(hs_person).to be_nil
+          end
+        end
+
+        context "with limit option" do
+          it "should ignore limit option" do
+            person    = klass.find_by_id(2)
+            hs_person = klass.hsfind_by_id(3, :operator => "<", :limit => 10)
+
+            expect(hs_person).to eql(person)
+            expect(hs_person).not_to be_kind_of(Array)
+          end
+        end
+      end
+
+      context "for :multi" do
+        context "with operator option" do
+          it "should find greater value record" do
+            hs_people = klass.hsfind_multi_by_id(0, :operator => ">")
+
+            expect(hs_people.size).to  eql(1)
+            expect(hs_people.first).to be_kind_of(klass)
+
+            hs_people = klass.hsfind_multi_by_id(3, :operator => ">")
+
+            expect(hs_people).to be_empty
+          end
+
+          it "should find less value record" do
+            people    = klass.find_all_by_id([2])
+            hs_people = klass.hsfind_multi_by_id(3, :operator => "<")
+
+            expect(hs_people).to eql(people)
+
+            hs_people = klass.hsfind_multi_by_id(0, :operator => "<")
+
+            expect(hs_people).to be_empty
+          end
+        end
+
+        context "with limit option" do
+          it "should find greater value records" do
+            people    = klass.find_all_by_id([1, 2])
+            hs_people = klass.hsfind_multi_by_id(0, :operator => ">", :limit => 10)
+
+            expect(hs_people).to eql(people)
+          end
+        end
+      end
+    end
+
+    describe "hsfind with connection" do
+      before :each do
+        ActiveRecord::Base.__send__(:hs_reconnect!)
+      end
+
+      it "should open index before find" do
+        expect{
+          klass.hsfind_by_id(1)
+        }.not_to raise_error(ActiveRecordHandlerSocket::CannotConnectError)
+        expect(ActiveRecord::Base.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).to be
+      end
+    end
+  end
+
+  describe "hs_open_index (before hsfind)" do
+    context "when index opened" do
+      it "should just return" do
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).to be
+
+        expect(klass.__send__(:hs_open_index, klass.__send__(:hs_index_key, "id"))).to be_nil
+      end
+    end
+
+    context "when open index" do
+      before :each do
+        ActiveRecord::Base.__send__(:hs_reconnect!)
+      end
+
+      it "should return true and mark opened" do
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+
+        expect(klass.__send__(:hs_open_index, klass.__send__(:hs_index_key, "id"))).to be
+
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).to be
+      end
+    end
+
+    context "when invalid result" do
+      before :each do
+        ActiveRecord::Base.__send__(:hs_reconnect!)
+        Hobby.hsfind_by_id(1)
+
+        ActiveRecord::Base.__send__(:hs_read_connection).stub(:open_index).and_return(2)
+        ActiveRecord::Base.__send__(:hs_read_connection).stub(:error).and_return("err")
+      end
+
+      it "should raise error" do
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+        expect(another_klass.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).to be
+
+        expect{
+          klass.__send__(:hs_open_index, klass.__send__(:hs_index_key, "id"))
+        }.to raise_error(ArgumentError)
+
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+        expect(another_klass.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).to be
+      end
+    end
+
+    context "when connection error" do
+      before :each do
+        ActiveRecord::Base.__send__(:hs_reconnect!)
+        another_klass.hsfind_by_id(1)
+
+        ActiveRecord::Base.__send__(:hs_read_connection).stub(:open_index).and_return(-1)
+        ActiveRecord::Base.__send__(:hs_read_connection).stub(:error).and_return("connection lost")
+      end
+
+      it "should raise error" do
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+        expect(another_klass.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).to be
+
+        expect{
+          klass.__send__(:hs_open_index, klass.__send__(:hs_index_key, "id"))
+        }.to raise_error(ActiveRecordHandlerSocket::CannotConnectError)
+
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+        expect(another_klass.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+      end
+    end
+  end
+
+  describe "hs_instantiate (after hsfind)" do
+    context "when valid result" do
+      it "should return single record" do
+        result = klass.__send__(:hs_instantiate, klass.__send__(:hs_index_key, "id"), [0, [["1", "MySQL", "19", "1"]]])
+
+        expect(result.size).to eql(1)
+
+        record = result.first
+        expect(record.id).to     eql(1)
+        expect(record.name).to   eql("MySQL")
+        expect(record.age).to    eql(19)
+        expect(record.status).to be
+      end
+
+      it "should return multi record" do
+        result = klass.__send__(:hs_instantiate, klass.__send__(:hs_index_key, "id"), [0, [["1", "MySQL", "19", "1"], ["2", "%#123", "55", "0"]]])
+
+        expect(result.size).to eql(2)
+
+        record = result.first
+        expect(record.id).to     eql(1)
+        expect(record.name).to   eql("MySQL")
+        expect(record.age).to    eql(19)
+        expect(record.status).to be
+
+        record = result.last
+        expect(record.id).to         eql(2)
+        expect(record.name).to       eql("%#123")
+        expect(record.age).to        eql(55)
+        expect(record.status).not_to be
+      end
+    end
+
+    context "when invalid result" do
+      it "should raise error" do
+        expect{
+          klass.__send__(:hs_instantiate, klass.__send__(:hs_index_key, "id"), [2, "kpnum"])
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when connection error" do
+      before :each do
+        klass.hsfind_by_id(1)
+        another_klass.hsfind_by_id(1)
+      end
+
+      it "should raise error and mark opened_index closed" do
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).to be
+        expect(another_klass.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).to be
+
+        expect{
+          klass.__send__(:hs_instantiate, klass.__send__(:hs_index_key, "id"), [-1, "connection lost"])
+        }.to raise_error(ActiveRecordHandlerSocket::CannotConnectError)
+
+        expect(klass.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+        expect(another_klass.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+      end
+    end
+  end
+end

data/spec/cases/manager_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe "ManagerSpec" do
+  let :klass do
+    Person
+  end
+
+  let :another_klass do
+    Hobby
+  end
+
+  before :each do
+    @bob = FactoryGirl.create(:bob)
+    FactoryGirl.create(:pharrell)
+
+    ActiveRecord::Base.__send__(:hs_reset_opened_indexes)
+  end
+
+  describe "module attributes" do
+    describe "hs_indexes" do
+      it "should be private" do
+        expect{
+          klass.hs_indexes
+        }.to raise_error(NoMethodError)
+      end
+
+      it "should not writable" do
+        expect{
+          klass.__send__(:hs_indexes=, {})
+        }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "hs_index_count_cache" do
+      it "should be private" do
+        expect{
+          klass.hs_index_count_cache
+        }.to raise_error(NoMethodError)
+      end
+
+      it "should not writable" do
+        expect{
+          klass.__send__(:hs_index_count_cache=, 0)
+        }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe "handlersocket" do
+    it "should not overwrite by another class" do
+      expect(ActiveRecord::Base.__send__(:hs_indexes).has_key?(klass.__send__(:hs_index_key, "id"))).to be
+      expect(ActiveRecord::Base.__send__(:hs_indexes).has_key?(another_klass.__send__(:hs_index_key, "id"))).to be
+    end
+
+    it "should not increment id by each set" do
+      initial_count = klass.__send__(:hs_index_count_cache)
+      klass.__send__(:handlersocket, "test_id", "PRIMARY", ["id"])
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "test_id")][:id]).to eql(initial_count + 1)
+      another_klass.__send__(:handlersocket, "test_id", "PRIMARY", ["id"])
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "test_id")][:id]).to eql(initial_count + 2)
+      klass.__send__(:handlersocket, "test_id", "PRIMARY", ["id"])
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "test_id")][:id]).to eql(initial_count + 3)
+    end
+  end
+
+  describe "hs_index_key" do
+    it "should be private method" do
+      expect{
+        klass.hs_index_key("bar")
+      }.to raise_error(NoMethodError)
+    end
+
+    it "should concat class name and key name" do
+      expect(klass.__send__(:hs_index_key, "bar")).to eql(klass.__send__(:hs_index_key, "bar"))
+      expect(another_klass.__send__(:hs_index_key, "baz")).to eql(another_klass.__send__(:hs_index_key, "baz"))
+    end
+  end
+
+  describe "hs_fetch_key" do
+    it "should be private method" do
+      expect{
+        klass.hs_fetch_key("id")
+      }.to raise_error(NoMethodError)
+    end
+
+    it "should fetch setting" do
+      setting = klass.__send__(:hs_fetch_key, klass.__send__(:hs_index_key, "id"))
+      expect(setting[:id]).to be_kind_of(Fixnum)
+      expect(setting[:index]).to eql("PRIMARY")
+      expect(setting[:fields]).to eql(["id", "name", "age", "status"])
+      expect(setting[:opened]).not_to be
+    end
+
+    it "should require index_key not just a key" do
+      expect{
+        klass.__send__(:hs_fetch_key, "id")
+      }.to raise_error(ActiveRecordHandlerSocket::UnknownIndexError)
+    end
+
+    it "should raise error with unknown key given" do
+      expect{
+        klass.__send__(:hs_fetch_key, klass.__send__(:hs_index_key, "name"))
+      }.to raise_error(ActiveRecordHandlerSocket::UnknownIndexError)
+    end
+
+    it "should include unknown key in error message" do
+      message = ""
+
+      begin
+        klass.__send__(:hs_fetch_key, klass.__send__(:hs_index_key, "name"))
+      rescue ActiveRecordHandlerSocket::UnknownIndexError => e
+        message = e.message
+      end
+
+      expect(message).to include(klass.__send__(:hs_index_key, "name"))
+    end
+  end
+
+  describe "hs_index_count" do
+    it "should be private method" do
+      expect{
+        klass.hs_index_count
+      }.to raise_error(NoMethodError)
+    end
+
+    it "should increment hs_index_count_cache" do
+      initial_count = klass.__send__(:hs_index_count_cache)
+      klass.__send__(:hs_index_count)
+      expect(klass.__send__(:hs_index_count_cache)).to eql(initial_count + 1)
+      klass.__send__(:hs_index_count)
+      expect(klass.__send__(:hs_index_count_cache)).to eql(initial_count + 2)
+    end
+  end
+
+  describe "hs_reset_opened_index" do
+    it "should mark not opened for all index settings" do
+      klass.hsfind_by_id(1)
+      another_klass.hsfind_by_id(1)
+
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).to be
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).to be
+
+      klass.__send__(:hs_reset_opened_indexes)
+
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+      expect(ActiveRecord::Base.__send__(:hs_indexes)[another_klass.__send__(:hs_index_key, "id")][:opened]).not_to be
+    end
+  end
+end