jruby-ehcache 0.5.0 → 1.0.0

data/test/ehcache.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="../../main/config/ehcache.xsd">
+
+    <!-- Disable for test ehcache.xml. Should go to the same place. -->
+    <diskStore path="java.io.tmpdir"/>
+
+    <cacheManagerPeerProviderFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
+                                     properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1, multicastGroupPort=4446, timeToLive=0"/>
+
+
+    <cacheManagerPeerListenerFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
+                                     properties="hostName=, port=, socketTimeoutMillis="/>
+
+
+    <defaultCache
+            name="default"
+            maxElementsInMemory="10"
+            eternal="false"
+            timeToIdleSeconds="5"
+            timeToLiveSeconds="10"
+            overflowToDisk="true"
+            />
+
+
+    <!-- Sample cache named sampleCache1 -->
+    <cache name="sampleCache1"
+           maxElementsInMemory="10000"
+           maxElementsOnDisk="1000"
+           eternal="false"
+           timeToIdleSeconds="360"
+           timeToLiveSeconds="1000"
+           overflowToDisk="true">
+    </cache>
+
+    <!-- Sample cache named sampleCache2. Is eternal. Is diskPersistent but does not overflow to disk -->
+    <cache name="sampleCache2"
+           maxElementsInMemory="1000"
+           eternal="true"
+           overflowToDisk="false"
+           diskPersistent="true"
+            />
+</ehcache>

data/test/ehcache.yml

@@ -0,0 +1,67 @@
+name: testing
+update_check: false
+monitoring: autodetect
+dynamic_config: true
+
+disk_store:
+  path: java.io.tmpdir
+
+transaction_manager:
+  class: net.sf.ehcache.transaction.manager.DefaultTransactionManagerLookup
+  properties: jndiName=java:/TransactionManager
+  property_separator: ";"
+
+peer_providers:
+- class: net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory
+  properties: peerDiscovery=automatic,multicastGroupAddress=230.0.0.1,multicastGroupPort=4446,timeToLive=1
+  property_separator: ","
+
+peer_listeners:
+- class: net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory
+
+default_cache:
+  max_elements_in_memory:  10000
+  time_to_live_seconds:  0
+  time_to_idle_seconds:  0
+  overflow_to_disk: true
+  eternal: false
+  disk_spool_buffer_size_mb: 30
+  disk_persistent: false
+  disk_expiry_thread_interval_seconds: 120
+  memory_store_eviction_policy: LRU
+
+caches:
+  # Sample cache named sampleCache1
+- name: sampleCache1
+  max_elements_in_memory: 10000
+  max_elements_on_disk: 1000
+  eternal: false
+  time_to_idle_seconds: 360
+  time_to_live_seconds: 1000
+  overflow_to_disk: true
+
+  #Sample cache named sampleCache2. Is eternal. Is diskPersistent but does not overflow to disk
+- name: sampleCache2
+  max_elements_in_memory: 1000
+  eternal: true
+  overflow_to_disk: false
+  disk_persistent: true
+
+- name: sampleCacheWithCacheConfigurations
+  max_elements_in_memory: 10
+  eternal: false
+  time_to_idle_seconds: 100
+  time_to_live_seconds: 100
+  overflow_to_disk: false
+  bootstrap_loader:
+    class: net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory
+    properties: "bootstrapAsynchronously=true, maximumChunkSizeBytes=5000000"
+    property_separator: ","
+  event_listeners:
+    - class: net.sf.ehcache.distribution.RMICacheReplicatorFactory
+      properties: "replicateAsynchronously=false, replicatePuts=false, replicatePutsViaCopy=false, replicateUpdates=true, replicateUpdatesViaCopy=true, replicateRemovals=false"
+    - class: net.sf.ehcache.distribution.RMICacheReplicatorFactory
+      properties: "replicateAsynchronously=false, replicatePuts=false, replicatePutsViaCopy=false, replicateUpdates=true, replicateUpdatesViaCopy=true, replicateRemovals=false"
+#  extensions:
+#    - class: com.example.FileWatchingCacheRefresherExtensionFactory
+#      properties: "refreshIntervalMillis=18000, loaderTimeout=3000, flushPeriod=whatever, someOtherProperty=someValue"

data/test/test_cache.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestCache < Test::Unit::TestCase
+
+  def setup
+    @manager = Ehcache::CacheManager.new
+    @cache = @manager.cache
+  end
+
+  def teardown
+    @manager.shutdown if @manager
+  end
+
+  must 'correctly implement compare and swap' do
+    @cache.put('number', 42, {:ttl => 120})
+    assert_equal(42, @cache['number'])
+    @cache.compare_and_swap('number') {|n| n - 31}
+    assert_equal(11, @cache['number'])
+  end
+
+  must 'have aliases for isKeyInCache called include and member' do
+    @cache.put('something', 'no matter')
+    for key in %w[something nothing]
+      assert_equal(@cache.isKeyInCache(key), @cache.include?(key))
+      assert_equal(@cache.isKeyInCache(key), @cache.member?(key))
+    end
+  end
+
+  must 'implement each and include Enumerable' do
+    assert_kind_of(Enumerable, @cache)
+    assert_respond_to(@cache, :each)
+    @cache.put('1', 1)
+    @cache.put('2', 2)
+    assert @cache.all? {|e| e.is_a?(Java::NetSfEhcache::Element)}
+  end
+end

data/test/test_cache_manager.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestCacheManager < Test::Unit::TestCase
+  def setup
+    @cache_manager = Ehcache::CacheManager.new
+  end
+
+  def teardown
+    @cache_manager.shutdown if @cache_manager
+  end
+
+  must 'be the real Ehcache Java CacheManager' do
+    assert_kind_of(Java::NetSfEhcache::CacheManager, @cache_manager)
+  end
+
+  must 'use the ehcache.xml file in the test directory' do
+    @cache_manager.cache_names.each do |name|
+      puts "Cache: #{name}"
+    end
+  end
+
+  must 'implement each and include Enumerable' do
+    assert_kind_of(Enumerable, @cache_manager)
+    assert_respond_to(@cache_manager, :each)
+    assert @cache_manager.all? {|cache| cache.is_a?(Java::NetSfEhcache::Ehcache)}
+  end
+end

data/test/test_configuration.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestConfiguration < Test::Unit::TestCase
+  def setup
+    create_config
+  end
+
+  def test_is_a_real_ehcache_java_configuration_object
+    assert_valid_configuration(@config)
+  end
+
+  must 'initialize with ehcache.xml' do
+    create_config(File.join(File.dirname(__FILE__), 'ehcache.xml'))
+    assert_valid_configuration(@config)
+    assert_not_nil(@config.configuration_source)
+    cache_configs = @config.cache_configurations
+    assert_equal(2, cache_configs.size)
+  end
+
+  private
+
+  def create_config(*args)
+    @config = Ehcache::Config::Configuration.create(*args)
+  end
+
+  def assert_valid_configuration(config)
+    assert_kind_of(Java::NetSfEhcacheConfig::Configuration, config)
+  end
+end

data/test/test_ehcache.rb

@@ -3,9 +3,20 @@ require File.dirname(__FILE__) + '/test_helper.rb'
 class TestEhcache < Test::Unit::TestCase
 
   def setup
+    @manager = Ehcache::CacheManager.new
+    @cache = @manager.cache
+  end
+
+  def teardown
+    @manager.shutdown if @manager
   end
   
-  def test_truth
-    assert true
+  def test_demo_usage
+    @cache.put("answer", "42", {:ttl => 120})
+    answer = @cache.get("answer")
+    assert_equal("42", answer.value)
+    assert_equal(120, answer.ttl)
+    question = @cache["question"] || 'unknown'
+    assert_equal('unknown', question)
   end
 end

data/test/test_element.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestElement < Test::Unit::TestCase
+  ALIASES = {
+    :tti => :time_to_idle,
+    :ttl => :time_to_live
+  }
+
+  ALIASES.each do |short, long|
+    must "have reader alias named #{short} referring to #{long}" do
+      element = Ehcache::Element.new('', '')
+      assert_respond_to(element, long)
+      assert_respond_to(element, short)
+      assert_equal(element.send(long), element.send(long))
+    end
+
+    must "have writer alias named #{short} referring to #{long}" do
+      element = Ehcache::Element.new('', '')
+      long_writer = "#{long}=".to_sym
+      short_writer = "#{short}=".to_sym
+      assert_respond_to(element, long_writer)
+      assert_respond_to(element, short_writer)
+      
+      element.send(long_writer, 1)
+      assert_equal(1, element.send(long))
+      assert_equal(1, element.send(short))
+      element.send(short_writer, 2)
+      assert_equal(2, element.send(long))
+      assert_equal(2, element.send(short))
+    end
+  end
+
+  must 'process ttl option on create' do
+    element = Ehcache::Element.create('k', 'v', :ttl => 42)
+    assert_equal(element.ttl, 42)
+  end
+end

data/test/test_helper.rb

@@ -1,2 +1,22 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
 require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/ehcache'
+require 'ehcache'
+require 'java'
+
+module Test::Unit
+  class TestCase
+    def self.must(name, &block)
+      test_name = "test_#{name.gsub(/[\s.]+/, '_')}".to_sym
+      defined = instance_method(test_name) rescue false
+      raise "#{test_name} is already defined in #{self}" if defined
+      if block_given?
+        define_method(test_name, &block)
+      else
+        define_method(test_name) do
+          flunk "No implementation provided for #{name}"
+        end
+      end
+    end
+  end
+end

data/test/test_yaml_config.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestConfiguration < Test::Unit::TestCase
+  def setup
+    @yaml_file = File.join(File.dirname(__FILE__), 'ehcache.yml')
+    @config = Ehcache::Config::Configuration.create(@yaml_file)
+  end
+
+  must 'have valid top level attributes' do
+    assert_equal('testing', @config.getName)
+    assert_equal(false, @config.getUpdateCheck)
+    assert_equal(Ehcache::Config::Configuration::Monitoring::AUTODETECT, @config.getMonitoring)
+    assert_equal(true, @config.getDynamicConfig)
+  end
+
+  must 'have valid disk store configuration' do
+    disk_store = @config.getDiskStoreConfiguration
+    assert_not_nil(disk_store)
+    assert_equal(java.lang.System.getProperty('java.io.tmpdir'),
+                 disk_store.getPath)
+  end
+
+  must 'have valid transaction manager' do
+    tx_mgr = @config.getTransactionManagerLookupConfiguration
+    assert_factory_configuration_equals(tx_mgr,
+        :class => 'net.sf.ehcache.transaction.manager.DefaultTransactionManagerLookup',
+        :properties => 'jndiName=java:/TransactionManager',
+        :property_separator => ';')
+  end
+
+  must 'have valid peer provider' do
+    peer_providers = @config.getCacheManagerPeerProviderFactoryConfiguration
+    assert_equal(1, peer_providers.size)
+    peer_provider = peer_providers.first
+    assert_factory_configuration_equals(peer_provider,
+        :class => 'net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory',
+        :properties => 'peerDiscovery=automatic,multicastGroupAddress=230.0.0.1,multicastGroupPort=4446,timeToLive=1',
+        :property_separator => ',')
+  end
+
+  must 'have valid peer listener' do
+    peer_listeners = @config.getCacheManagerPeerListenerFactoryConfigurations
+    assert_equal(1, peer_listeners.size)
+    peer_listener = peer_listeners.first
+    assert_factory_configuration_equals(peer_listener,
+        :class => 'net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory')
+  end
+
+  must 'have valid default cache' do
+    default_cache = @config.getDefaultCacheConfiguration
+    expected = {
+        :getMaxElementsInMemory => 10000,
+        :getTimeToLiveSeconds => 0,
+        :getTimeToIdleSeconds => 0,
+        :isOverflowToDisk => true,
+        :isEternal => false,
+        :getDiskSpoolBufferSizeMB => 30,
+        :isDiskPersistent => false,
+        :getDiskExpiryThreadIntervalSeconds => 120,
+        :getMemoryStoreEvictionPolicy => Java::NetSfEhcacheStore::MemoryStoreEvictionPolicy::LRU
+    }
+    expected.each do |key, value|
+      assert_equal(value, default_cache.send(key))
+    end
+  end
+
+  must 'have two cache configurations' do
+    caches = @config.getCacheConfigurations
+    assert_equal(3, caches.size)
+    assert(caches.containsKey("sampleCache1"), "Should have sampleCache1")
+    assert(caches.containsKey("sampleCache2"), "Should have sampleCache2")
+  end
+
+  must 'have valid sampleCache1 configuration' do
+    cache = @config.getCacheConfigurations['sampleCache1']
+    expected = {
+        :getMaxElementsInMemory => 10000,
+        :getMaxElementsOnDisk => 1000,
+        :getTimeToLiveSeconds => 1000,
+        :getTimeToIdleSeconds => 360,
+        :isOverflowToDisk => true,
+        :isEternal => false
+    }
+    expected.each do |key, value|
+      assert_equal(value, cache.send(key))
+    end
+  end
+
+  must 'have valid sampleCache2 configuration' do
+    cache = @config.getCacheConfigurations['sampleCache2']
+    expected = {
+        :getMaxElementsInMemory => 1000,
+        :isOverflowToDisk => false,
+        :isEternal => true,
+        :isDiskPersistent => true
+    }
+    expected.each do |key, value|
+      assert_equal(value, cache.send(key))
+    end
+  end
+
+  must 'have valid sampleCacheWithCacheConfigurations configuration' do
+    cache = @config.getCacheConfigurations['sampleCacheWithCacheConfigurations']
+    expected = {
+      :getMaxElementsInMemory => 10,
+      :isEternal => false,
+      :getTimeToIdleSeconds => 100,
+      :getTimeToLiveSeconds => 100,
+      :isOverflowToDisk => false
+    }
+    expected.each do |key, value|
+      assert_equal(value, cache.send(key))
+    end
+  end
+
+  must 'have 2 event listeners in sampleCacheWithCacheConfigurations' do
+    cache = @config.getCacheConfigurations['sampleCacheWithCacheConfigurations']
+    assert_equal(2, cache.getCacheEventListenerConfigurations.size)
+    expected = {
+      :getFullyQualifiedClassPath => 'net.sf.ehcache.distribution.RMICacheReplicatorFactory',
+      :getProperties => "replicateAsynchronously=false, replicatePuts=false, replicatePutsViaCopy=false, replicateUpdates=true, replicateUpdatesViaCopy=true, replicateRemovals=false"
+    }
+    cache.getCacheEventListenerConfigurations.each do |event_listener|
+      expected.each do |key, value|
+        assert_equal(value, event_listener.send(key))
+      end
+    end
+  end
+
+  must 'have valid bootstrap loader in sampleCacheWithCacheConfigurations' do
+    cache = @config.getCacheConfigurations['sampleCacheWithCacheConfigurations']
+    assert_not_nil(cache.getBootstrapCacheLoaderFactoryConfiguration)
+    expected = {
+      :getFullyQualifiedClassPath => "net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory",
+      :getProperties => "bootstrapAsynchronously=true, maximumChunkSizeBytes=5000000",
+      :getPropertySeparator => ","
+    }
+    bootstrap_loader = cache.getBootstrapCacheLoaderFactoryConfiguration
+    expected.each do |key, value|
+      assert_equal(value, bootstrap_loader.send(key))
+    end
+  end
+
+  private
+
+  def assert_factory_configuration_equals(factory, values)
+    assert_not_nil(factory)
+    assert_kind_of(Hash, values)
+    if values.has_key?(:class)
+      assert_equal(values[:class], factory.getFullyQualifiedClassPath)
+    end
+    if values.has_key?(:properties)
+      assert_equal(values[:properties], factory.getProperties)
+    end
+    if values.has_key?(:property_separator)
+      assert_equal(values[:property_separator], factory.getPropertySeparator)
+    end
+  end
+end