torquebox-cache 2.0.0.beta1-java

data/spec/dm-infinispan-adapter_spec.rb

@@ -0,0 +1,375 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require File.dirname(__FILE__) + '/spec_helper'
+require 'dm-core'
+require 'datamapper/model'
+
+describe DataMapper::Adapters::InfinispanAdapter do
+
+  before :all do
+    @adapter = DataMapper.setup(:default, :adapter => 'infinispan')
+    @heffalump_index = File.join( File.dirname(__FILE__), '..', 'rubyobj.Heffalump' )
+    class ::Heffalump
+      include DataMapper::Resource
+
+      property :id,        Serial
+      property :color,     String
+      property :num_spots, Integer
+      property :striped,   Boolean
+    end
+
+    DataMapper.finalize
+    Heffalump.auto_migrate!
+  end
+
+  it "should use the infinispan search manager" do
+    @adapter.search_manager.should_not be_nil
+  end
+
+  after :all do
+    @adapter.stop
+    FileUtils.rm_rf @heffalump_index
+  end
+
+  describe '#auto_migrate!' do
+    it 'should clear the cache' do
+      Heffalump.create(:color => 'magenta')
+      Heffalump.all.size.should == 1
+      Heffalump.auto_migrate!
+      Heffalump.all.size.should == 0
+    end
+  end
+  
+  describe '#auto_upgrade!' do
+    it 'should not clear the cache' do
+      Heffalump.create(:color => 'magenta')
+      Heffalump.all.size.should == 1
+      Heffalump.auto_upgrade!
+      Heffalump.all.size.should == 1
+    end
+  end
+  
+  describe '#create' do
+    it 'should not raise any errors' do
+      lambda {
+        Heffalump.create(:color => 'peach')
+      }.should_not raise_error
+    end
+
+    it 'should set the identity field for the resource' do
+      heffalump = Heffalump.new(:color => 'peach')
+      heffalump.id.should be_nil
+      heffalump.save
+      heffalump.id.should_not be_nil
+    end
+  end
+
+  describe '#read' do
+    before :all do
+      @heffalump = Heffalump.create(:color => 'brownish hue')
+    end
+
+    it 'should not raise any errors' do
+      lambda {
+        Heffalump.all()
+      }.should_not raise_error
+    end
+
+    it 'should return stuff' do
+      Heffalump.all.should be_include(@heffalump)
+    end
+  end
+
+  describe '#update' do
+    before do
+      @heffalump = Heffalump.create(:color => 'indigo')
+    end
+
+    it 'should not raise any errors' do
+      lambda {
+        @heffalump.color = 'violet'
+        @heffalump.save
+      }.should_not raise_error
+    end
+
+    it 'should not alter the identity field' do
+      id = @heffalump.id
+      @heffalump.color = 'violet'
+      @heffalump.save
+      @heffalump.id.should == id
+    end
+
+    it 'should update altered fields' do
+      @heffalump.color = 'violet'
+      @heffalump.save
+      Heffalump.get(*@heffalump.key).color.should == 'violet'
+    end
+
+    it 'should not alter other fields' do
+      color = @heffalump.color
+      @heffalump.num_spots = 3
+      @heffalump.save
+      Heffalump.get(*@heffalump.key).color.should == color
+    end
+  end
+
+  describe '#delete' do
+    before do
+      @heffalump = Heffalump.create(:color => 'forest green')
+    end
+
+    it 'should not raise any errors' do
+      lambda {
+        @heffalump.destroy
+      }.should_not raise_error
+    end
+
+    it 'should delete the requested resource' do
+      id = @heffalump.id
+      @heffalump.destroy
+      Heffalump.get(id).should be_nil
+    end
+  end
+
+  describe 'query matching' do
+    before :all do
+      Heffalump.auto_migrate!
+      @red  = Heffalump.create(:color => 'red')
+      @two  = Heffalump.create(:num_spots => 2)
+      @five = Heffalump.create(:num_spots => 5)
+    end
+
+    describe 'conditions' do
+      describe 'eql' do
+        it 'should be able to search for objects included in an inclusive range of values' do
+          Heffalump.all(:num_spots => 1..5).should be_include(@five)
+        end
+
+        it 'should be able to search for objects included in an exclusive range of values' do
+          Heffalump.all(:num_spots => 1...6).should be_include(@five)
+        end
+
+        it 'should not be able to search for values not included in an inclusive range of values' do
+          Heffalump.all(:num_spots => 1..4).should_not be_include(@five)
+        end
+
+        it 'should not be able to search for values not included in an exclusive range of values' do
+          Heffalump.all(:num_spots => 1...5).should_not be_include(@five)
+        end
+      end
+
+      describe 'not' do
+        it 'should be able to search for objects with not equal value' do
+          Heffalump.all(:color.not => 'red').should_not be_include(@red)
+        end
+
+        it 'should include objects that are not like the value' do
+          Heffalump.all(:color.not => 'black').should be_include(@red)
+        end
+
+        it 'should be able to search for objects with not nil value' do
+          Heffalump.all(:color.not => nil).should be_include(@red)
+        end
+
+        it 'should not include objects with a nil value' do
+          Heffalump.all(:color.not => nil).should_not be_include(@two)
+        end
+
+        it 'should be able to search for object with a nil value using required properties' do
+          Heffalump.all(:id.not => nil).should == [ @red, @two, @five ]
+        end
+
+        it 'should be able to search for objects not in an empty list (match all)' do
+          Heffalump.all(:color.not => []).should == [ @red, @two, @five ]
+        end
+
+        it 'should be able to search for objects in an empty list and another OR condition (match none on the empty list)' do
+          Heffalump.all(
+            :conditions => DataMapper::Query::Conditions::Operation.new(
+              :or,
+              DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:color], []),
+              DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:num_spots], [5])
+            )
+          ).should == [ @five ]
+        end
+
+        it 'should be able to search for objects not included in an array of values' do
+          Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should be_include(@two)
+        end
+
+        it 'should be able to search for objects not included in an array of values' do
+          Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should_not be_include(@five)
+        end
+
+        it 'should be able to search for objects not included in an inclusive range of values' do
+          Heffalump.all(:num_spots.not => 1..4).should be_include(@five)
+        end
+
+        it 'should be able to search for objects not included in an exclusive range of values' do
+          Heffalump.all(:num_spots.not => 1...5).should be_include(@five)
+        end
+
+        it 'should not be able to search for values not included in an inclusive range of values' do
+          Heffalump.all(:num_spots.not => 1..5).should_not be_include(@five)
+        end
+
+        it 'should not be able to search for values not included in an exclusive range of values' do
+          Heffalump.all(:num_spots.not => 1...6).should_not be_include(@five)
+        end
+      end
+
+      describe 'like' do
+        it 'should be able to search for objects that match value' do
+          Heffalump.all(:color.like => '%ed').should be_include(@red)
+        end
+
+        it 'should not search for objects that do not match the value' do
+          Heffalump.all(:color.like => '%blak%').should_not be_include(@red)
+        end
+      end
+
+      describe 'regexp' do
+        before do
+          if (defined?(DataMapper::Adapters::SqliteAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqliteAdapter) ||
+              defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
+            pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+          end
+        end
+
+        it 'should be able to search for objects that match value' do
+          Heffalump.all(:color => /ed/).should be_include(@red)
+        end
+
+        it 'should not be able to search for objects that do not match the value' do
+          Heffalump.all(:color => /blak/).should_not be_include(@red)
+        end
+
+        it 'should be able to do a negated search for objects that match value' do
+          Heffalump.all(:color.not => /blak/).should be_include(@red)
+        end
+
+        it 'should not be able to do a negated search for objects that do not match value' do
+          Heffalump.all(:color.not => /ed/).should_not be_include(@red)
+        end
+
+      end
+
+      describe 'gt' do
+        it 'should be able to search for objects with value greater than' do
+          Heffalump.all(:num_spots.gt => 1).should be_include(@two)
+        end
+
+        it 'should not find objects with a value less than' do
+          Heffalump.all(:num_spots.gt => 3).should_not be_include(@two)
+        end
+      end
+
+      describe 'gte' do
+        it 'should be able to search for objects with value greater than' do
+          Heffalump.all(:num_spots.gte => 1).should be_include(@two)
+        end
+
+        it 'should be able to search for objects with values equal to' do
+          Heffalump.all(:num_spots.gte => 2).should be_include(@two)
+        end
+
+        it 'should not find objects with a value less than' do
+          Heffalump.all(:num_spots.gte => 3).should_not be_include(@two)
+        end
+      end
+
+      describe 'lt' do
+        it 'should be able to search for objects with value less than' do
+          Heffalump.all(:num_spots.lt => 3).should be_include(@two)
+        end
+
+        it 'should not find objects with a value less than' do
+          Heffalump.all(:num_spots.gt => 2).should_not be_include(@two)
+        end
+      end
+
+      describe 'lte' do
+        it 'should be able to search for objects with value less than' do
+          Heffalump.all(:num_spots.lte => 3).should be_include(@two)
+        end
+
+        it 'should be able to search for objects with values equal to' do
+          Heffalump.all(:num_spots.lte => 2).should be_include(@two)
+        end
+
+        it 'should not find objects with a value less than' do
+          Heffalump.all(:num_spots.lte => 1).should_not be_include(@two)
+        end
+      end
+    end
+
+    describe 'limits' do
+      it 'should be able to limit the objects' do
+        Heffalump.all(:limit => 2).length.should == 2
+      end
+    end
+  end
+
+  describe "with persistence" do
+    before :all do
+      @configured_dir  = File.join( File.dirname(__FILE__), '..', random_string + "-dm-infinispan-adapter.cache" )
+      @default_dir     = File.join(File.dirname(__FILE__), '..', 'Infinispan-FileCacheStore')
+      @snuffy          = File.join( File.dirname(__FILE__), '..', 'rubyobj.Snuffleupagus' ) 
+      FileUtils.mkdir( @configured_dir )
+      class Snuffleupagus
+        include DataMapper::Resource
+        property :id, Serial
+        property :birthday, Date
+      end
+      Snuffleupagus.configure_index!
+    end
+
+    after :all do
+      #FileUtils.rm_rf( @configured_dir )
+      #FileUtils.rm_rf( @default_dir )
+      FileUtils.rm_rf( @snuffy )
+    end
+
+    it "should store data in a configured directory" do
+      adapter = DataMapper.setup(:dminfinispanadapterconfigured, :adapter => 'infinispan', :persist => @configured_dir.to_s)
+      snuffy = Snuffleupagus.create(:birthday=>Date.today)
+      File.exist?("#{@configured_dir.to_s}/dminfinispanadapterconfigured").should be_true
+      snuffy.should_not be_nil
+      adapter.stop
+    end
+
+    it "should store data in a default directory" do
+      adapter = DataMapper.setup(:dminfinispanadapterdefault, :adapter => 'infinispan', :persist=>true)
+      snuffy = Snuffleupagus.create(:birthday=>Date.today)
+      File.exist?( @default_dir ).should be_true
+      snuffy.should_not be_nil
+      snuffy.id.should_not be_nil
+      adapter.stop
+    end
+
+    it "should store dates" do
+      adapter = DataMapper.setup(:default, :adapter => 'infinispan', :persist=>true)
+      snuffy = Snuffleupagus.create(:birthday => Date.today)
+      snuffy.should_not be_nil
+      snuffy.getBirthday.should_not be_nil
+      adapter.stop
+    end
+
+  end
+end
+
+

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--format progress
+--loadby mtime
+--reverse
+

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'dm-core/spec/shared/adapter_spec'
+require 'dm-core/spec/lib/pending_helpers'
+require 'datamapper/dm-infinispan-adapter'
+require 'cache'
+
+Spec::Runner.configure do |config|
+  config.include(DataMapper::Spec::PendingHelpers)
+end
+
+def random_string( length = 20 )
+  chars = ('a'..'z').to_a + ('A'..'Z').to_a
+  dir_string = (0...length).collect { chars[Kernel.rand(chars.length)] }.join
+end

data/spec/torque_box_store_spec.rb

@@ -0,0 +1,220 @@
+require 'active_support/cache/torque_box_store'
+require 'logger'
+
+java_import org.infinispan.config.Configuration::CacheMode
+include ActiveSupport::Cache
+
+TORQUEBOX_APP_NAME = 'active-support-unit-test'
+
+describe ActiveSupport::Cache::TorqueBoxStore do
+
+  before(:each) do
+    TorqueBox::ServiceRegistry.service_registry = nil
+    @cache = ActiveSupport::Cache::TorqueBoxStore.new()
+  end
+
+  describe "basics" do
+
+    it "should write and read a string" do
+      @cache.write("key", "value").should be_true
+      @cache.read("key").should == "value"
+    end
+
+    it "should write and read a number" do
+      @cache.write("key", 42).should be_true
+      @cache.read("key").should == 42
+    end
+
+    it "should exist after writing" do
+      @cache.write("key", 42).should be_true
+      @cache.exist?("key").should be_true
+    end
+
+    it "should be gone after deleting" do
+      @cache.write("key", 42).should be_true
+      @cache.read("key").should == 42
+      @cache.delete("key").should be_true
+      @cache.read("key").should be_nil
+    end
+
+    it "should overwrite an existing key" do
+      @cache.write("key", 42).should be_true
+      @cache.read("key").should == 42
+      @cache.write("key", 44).should be_true
+      @cache.read("key").should == 44
+    end
+
+  end
+
+  describe "options" do
+
+    it "should be expirable" do
+      @cache.write("key", 42, :expires_in => 1.second).should be_true
+      @cache.read("key").should == 42
+      sleep(1.1)
+      @cache.read("key").should be_nil
+    end
+
+    it "should optionally not overwrite an existing key" do
+      @cache.write("key", 42).should be_true
+      @cache.read("key").should == 42
+      @cache.write("key", 44, :unless_exist => true).should be_true
+      @cache.read("key").should == 42
+    end
+
+    it "should merge initialized options" do
+      @cache = ActiveSupport::Cache::TorqueBoxStore.new(:expires_in => 1.second)
+      @cache.write("key", 42).should be_true
+      @cache.read("key").should == 42
+      sleep(1.1)
+      @cache.read("key").should be_nil
+    end
+
+  end
+
+  describe "fetching" do
+
+    it "should fetch existing keys" do
+      @cache.write("today", "Monday")
+      @cache.fetch("today").should == "Monday"
+    end
+
+    it "should fetch block values for missing keys" do
+      @cache.fetch("city").should be_nil
+      @cache.fetch("city") {
+        "Duckburgh"
+      }.should == "Duckburgh"
+      @cache.fetch("city").should == "Duckburgh"
+    end
+
+    it "should fetch block values when forced" do
+      @cache.write("today", "Monday")
+      @cache.fetch("today").should == "Monday"
+      @cache.fetch("today", :force => true) { "Tuesday" }.should == "Tuesday"
+    end
+
+    it "should support :race_condition_ttl" do
+      database = mock('database')
+      fetch_options = { :expires_in => 0.1.seconds, :race_condition_ttl => 30.seconds }
+      # First fetch looks up from database and populates
+      database.should_receive(:town).and_return("Pantsville")
+      @cache.fetch("town", fetch_options) {
+        database.town
+      }.should == "Pantsville"
+      # Sleep until the entry is expired
+      sleep(0.2)
+      # Create a set of CountDownLatches to test :race_condition_ttl
+      # without relying on sleep calls
+      read_latch = java.util.concurrent.CountDownLatch.new(1)
+      write_latch = java.util.concurrent.CountDownLatch.new(1)
+      # Read the cache from two threads but only one should hit our database
+      database.should_receive(:town).once.and_return {
+        # Trigger the read latch so the other thread can read the cached value
+        read_latch.count_down
+        write_latch.await(15, java.util.concurrent.TimeUnit::SECONDS)
+        "NoPantsville"
+      }
+      other_thread = Thread.new {
+        read_latch.await(15, java.util.concurrent.TimeUnit::SECONDS)
+        @cache.fetch("town", fetch_options) {
+          database.town
+        }.should == "Pantsville"
+        # Trigger the write latch to update the cached value
+        write_latch.count_down
+      }
+      @cache.fetch("town", fetch_options) {
+        database.town
+      }.should == "NoPantsville"
+      other_thread.join
+      @cache.read("town").should == "NoPantsville"
+    end
+
+  end
+
+  describe "multiples" do
+
+    before(:each) do
+      @cache.write("john", "guitar")
+      @cache.write("paul", "bass")
+      @cache.write("george", "lead")
+      @cache.write("ringo", "drums")
+    end
+
+    it "should delete by regexp" do
+      @cache.delete_matched /g/
+      @cache.read("george").should be_nil
+      @cache.read("ringo").should be_nil
+      @cache.read("john").should == "guitar"
+      @cache.read("paul").should == "bass"
+    end
+
+    it "should clear all entries" do
+      @cache.clear
+      @cache.read("george").should be_nil
+      @cache.read("ringo").should be_nil
+      @cache.read("john").should be_nil
+      @cache.read("paul").should be_nil
+    end
+
+    it "should cleanup expired entries" do
+      @cache.write("jimi", "guitar", :expires_in => 1.second)
+      @cache.exist?("jimi").should be_true
+      sleep(1.1)
+      @cache.cleanup
+      @cache.exist?("jimi").should be_false
+      @cache.exist?("ringo").should be_true
+    end
+
+    it "should read multiple values" do
+      @cache.read_multi("john", "paul").should == {"john" => "guitar", "paul" => "bass"}
+    end
+
+  end
+
+  describe "advanced" do
+    
+    it "should support incrementation" do
+      @cache.write("key", 42).should be_true
+      @cache.read("key").should == 42
+      @cache.increment("key").should == 43
+      @cache.read("key").should == 43
+    end
+
+    it "should support decrementation" do
+      @cache.write("key", 42).should be_true
+      @cache.read("key").should == 42
+      @cache.decrement("key").should == 41
+      @cache.read("key").should == 41
+    end
+
+  end
+
+  describe "clustering" do
+    
+    it "should default to invalidation mode" do
+      @cache.clustering_mode.should == CacheMode::INVALIDATION_ASYNC
+      TorqueBoxStore.new(:mode => :unknown).clustering_mode.should == CacheMode::INVALIDATION_ASYNC
+    end
+
+    [:repl, :dist, :invalidation].each do |mode|
+      it "should be configurable in #{mode} mode" do
+        TorqueBoxStore.new(:mode => mode).clustering_mode.to_s.should == "#{mode.to_s.upcase}_ASYNC"
+        TorqueBoxStore.new(:mode => mode, :sync => true).clustering_mode.to_s.should == "#{mode.to_s.upcase}_SYNC"
+      end
+    end
+
+    it "should support replicated mode" do
+      [:r, :repl, :replicated, :replication].each do |mode|
+        TorqueBoxStore.new(:mode => mode).clustering_mode.should be_replicated
+      end
+    end
+
+    it "should support distributed mode" do
+      [:d, :dist, :distributed, :distribution].each do |mode|
+        TorqueBoxStore.new(:mode => mode).clustering_mode.should be_distributed
+      end
+    end
+
+  end
+
+end