ruby_doozer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca8f8f8ae259ceb2da7979c8ca5c7a2307b6fcc7
-  data.tar.gz: 4faf064cc2e33a25a3e612f66d59c528c948e491
+  metadata.gz: ef156e41c4d70417b9ccb4128c22b817c926c474
+  data.tar.gz: c8c054bea13c4933368e12838526de1febe4e37a
 SHA512:
-  metadata.gz: 2f085c6219b6a3901d37937079036df515e5ad9fe4e54253147109e10cb3d8b51fa74cab823336883f7ad0d049d53149474f8d1fa31384a167137be7574b8a2f
-  data.tar.gz: 1a3c63775c7587c24f984b5d130c9aa17c464d338c305434df7f4127a472a154891f229f4639f96728b538db3bad9f89b55d9d44eba4d5cb7984d2f275d602fa
+  metadata.gz: 9483ea907342682619bb3e44a5bffa9c63b0f9519fedc9ced96b7e4b579fe07c2e6ab73f259a6711db5ad1f9f0b130f8d84187336523ac8660030121f57d81ef
+  data.tar.gz: 8c5c70714dff4fe12c1cb7fda7573bcb37cb73f927f388460a6e0772d66d3e07778ea218d4d730b6c89af09255b7404e125c890a235eee3550fdb9b0cceca1b0

data/README.md

@@ -68,11 +68,60 @@ sleep 0.5
 database_config = config_registry['master']
 slave_database_config = config_registry['secondary']
 
+# Register for any changes to the configuration, including updates
+config_registry.on_update('master') do |path, value|
+  puts "Time to re-establish database connections to new server: #{value}"
+end
+
+# Change the configuration and all subscribers will be notified
+config_registry['master'] = "Some updated JSON config string"
+```
+
+### Cached Registry
+
+Cached Registry is a specialized registry that keeps a local copy of the entire
+registry in memory. It also keeps the local copy synchronized with any changes
+that occur in doozer
+
+The local copy is useful for scenarios where frequent reads are being
+performed against the Registry and the data must be kept up to date.
+
+Cached Registry can also distinguish between creates and updates.
+The new #on_update callbacks will be called when existing data has been modified.
+As a result Registry#on_update callbacks will only be called for existing data
+
+```ruby
+require 'rubygems'
+require 'ruby_doozer'
+
+SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('registry.log')
+
+region      = "Development"
+application = "sprites"
+path        = "/#{region}/#{application}/config/resources".downcase
+
+config_registry = RubyDoozer::CachedRegistry.new(:root_path => path)
+
+# Store the configuration information in doozer as a serialized string
+config_registry['master'] = "Some JSON config string"
+
+# Allow time for Doozer to publish the new config
+sleep 0.5
+
+# Retrieve the current configuration
+database_config = config_registry['master']
+slave_database_config = config_registry['secondary']
+
 # Register for any changes to the configuration
 config_registry.on_update('master') do |path, value|
   puts "Time to re-establish database connections to new server: #{value}"
 end
 
+# Register for all create events
+config_registry.on_create('*') do |path, value|
+  puts "CREATED #{path}"
+end
+
 # Change the configuration and all subscribers will be notified
 config_registry['master'] = "Some updated JSON config string"
 ```

data/lib/ruby_doozer/cached_registry.rb

@@ -0,0 +1,128 @@
+require 'thread_safe'
+require 'gene_pool'
+require 'semantic_logger'
+
+#
+# CachedRegistry
+#
+# Store information in doozer and subscribe to future changes
+# and keep a local copy of the information in doozer
+#
+# Notifies registered subscribers when information has changed
+#
+# All paths specified are relative to the root_path. As such the root path
+# is never returned, nor is it required when a path is supplied as input.
+# For example, with a root_path of /foo/bar, any paths passed in will leave
+# out the root_path: host/name
+#
+# Keeps a local copy in memory of all descendant values of the supplied root_path
+# Allows high-frequency calls to retrieve registry data
+# The cache will be kept in synch with any changes on the server
+module RubyDoozer
+  class CachedRegistry < Registry
+    # Logging instance for this class
+    include SemanticLogger::Loggable
+
+    # Create a Registry instance to manage a path of information within doozer
+    #
+    # See RubyDoozer::Registry for complete list of options
+    #
+    def initialize(params)
+      super
+      @registry = ThreadSafe::Hash.new
+
+      path = "#{@root_path}/**"
+      doozer_pool.with_connection do |doozer|
+        @current_revision = doozer.current_revision
+        # Fetch all the configuration information from Doozer and set the internal copy
+        doozer.walk(path, @current_revision).each do |node|
+          @registry[relative_path(node.path)] = node.value
+        end
+      end
+
+      # Start monitoring thread
+      monitor_thread
+    end
+
+    # Retrieve the latest value from a specific path from the registry
+    def [](path)
+      @registry[path]
+    end
+
+    # Iterate over every key, value pair in the registry at the root_path
+    #
+    # Example:
+    #   registry.each_pair {|k,v| puts "#{k} => #{v}"}
+    def each_pair(&block)
+      # Have to duplicate the registry otherwise changes to the registry will
+      # interfere with the iterator
+      @registry.dup.each_pair(&block)
+    end
+
+    # Returns [Array<String>] all paths in the registry
+    def paths
+      @registry.keys
+    end
+
+    # Returns a copy of the registry as a Hash
+    def to_h
+      @registry.dup
+    end
+
+    # When an entry is created the block will be called
+    #  Parameters
+    #    path
+    #      The relative path to watch for changes
+    #    block
+    #      The block to be called
+    #
+    #  Parameters passed to the block:
+    #    path
+    #      The path that was created
+    #      Supplying a path of '*' means all paths
+    #      Default: '*'
+    #
+    #    value
+    #      New value from doozer
+    #
+    # Example:
+    #   registry.on_update do |path, value|
+    #     puts "#{path} was created with #{value}"
+    #   end
+    def on_create(path='*', &block)
+      ((@create_subscribers ||= ThreadSafe::Hash.new)[path] ||= ThreadSafe::Array.new) << block
+    end
+
+    ############################
+    protected
+
+    # The path has been added or updated in the registry
+    def changed(path, value)
+      previous_value = @registry[path]
+
+      # Update in memory copy
+      @registry[path] = value
+
+      # It is an update if we already have a value
+      if previous_value
+        # Call parent which will notify Updated Subscribers
+        super
+      else
+        logger.debug { "Created: #{path} => #{value}" }
+
+        return unless @create_subscribers
+
+        # Subscribers to specific paths
+        if subscribers = @create_subscribers[path]
+          subscribers.each{|subscriber| subscriber.call(path, value)}
+        end
+
+        # Any subscribers for all events?
+        if all_subscribers = @create_subscribers['*']
+          all_subscribers.each{|subscriber| subscriber.call(path, value)}
+        end
+      end
+    end
+
+  end
+end

data/lib/ruby_doozer/registry.rb

@@ -1,6 +1,7 @@
 require 'thread_safe'
 require 'gene_pool'
 require 'semantic_logger'
+require 'sync_attr'
 
 #
 # Registry
@@ -16,10 +17,11 @@ require 'semantic_logger'
 #
 module RubyDoozer
   class Registry
+    include SyncAttr
     # Logging instance for this class
     include SemanticLogger::Loggable
 
-    attr_reader :doozer_config, :doozer_pool
+    attr_reader :doozer_config, :doozer_pool, :current_revision
 
     # Create a Registry instance to manage a path of information within doozer
     #
@@ -29,12 +31,6 @@ module RubyDoozer
     #   significant traffic since it will also monitor Doozer Admin changes
     #   Mandatory
     #
-    # :cache [Boolean]
-    #   Keep a local copy in memory of all descendant values of the supplied root_path
-    #   Allows high-frequency calls to retrieve registry data
-    #   The cache will be kept in synch with any changes on the server
-    #   Default: true
-    #
     # :doozer [Hash]
     #   Doozer configuration information
     #
@@ -98,9 +94,6 @@ module RubyDoozer
       @root_path = @root_path[0..-2] if @root_path.end_with?("/")
       @root_path_with_trail = "#{@root_path}/"
 
-      local_copy = params.delete(:cache)
-      @registry = (local_copy == false) ? nil : ThreadSafe::Hash.new
-
       @doozer_config = params.delete(:doozer) || {}
       @doozer_config[:servers]                ||= ['127.0.0.1:8046']
       @doozer_config[:read_timeout]           ||= 5
@@ -122,47 +115,23 @@ module RubyDoozer
         RubyDoozer::Client.new(@doozer_config)
       end
 
-      @create_subscribers = ThreadSafe::Hash.new
-      @update_subscribers = ThreadSafe::Hash.new
-      @delete_subscribers = ThreadSafe::Hash.new
-
-      revision = nil
-      path = "#{@root_path}/**"
-      doozer_pool.with_connection do |doozer|
-        revision = doozer.current_revision
-        if @registry
-          # Fetch all the configuration information from Doozer and set the internal copy
-          doozer.walk(path, revision).each do |node|
-            @registry[relative_path(node.path)] = node.value
-          end
-        end
-      end
-
-      # Start monitoring thread to keep the registry in synch with doozer
-      @monitor_thread = Thread.new { watch_registry(path, revision + 1) }
-
       # Generate warning log entries for any unknown configuration options
       params.each_pair {|k,v| logger.warn "Ignoring unknown configuration option: #{k}"}
     end
 
+    # Start callback monitoring thread
+    sync_attr_reader :monitor_thread do
+      Thread.new { watch_registry }
+    end
+
     # Retrieve the latest value from a specific path from the registry
-    # If :cache was set to false on the initializer this call will
-    # make a network call to doozer to retrieve the current value
-    # Otherwise it is an in memory call and can be called frequently
     def [](path)
-      if @registry
-        @registry[path]
-      else
-        doozer_pool.with_connection do |doozer|
-          doozer[full_path(path)]
-        end
+      doozer_pool.with_connection do |doozer|
+        doozer[full_path(path)]
       end
     end
 
     # Replace the latest value at a specific path
-    # The in-memory copy will be updated when doozer sends out the change
-    # TODO Should we also update the in memory copy rather than wait for the change
-    #      notification?
     def []=(path,value)
       doozer_pool.with_connection do |doozer|
         doozer[full_path(path)] = value
@@ -170,15 +139,10 @@ module RubyDoozer
     end
 
     # Delete the value at a specific path
-    # The in-memory copy will be updated when doozer sends out the change
-    # TODO Should we also delete the in memory copy rather than wait for the change
-    #      notification?
     def delete(path)
-      old_value = @registry[path] if @registry
       doozer_pool.with_connection do |doozer|
         doozer.delete(full_path(path))
       end
-      old_value
     end
 
     # Iterate over every key, value pair in the registry at the root_path
@@ -190,27 +154,26 @@ module RubyDoozer
     # Example:
     #   registry.each_pair {|k,v| puts "#{k} => #{v}"}
     def each_pair(&block)
-      if @registry
-        @registry.dup.each_pair(&block)
-      else
-        path = "#{@root_path}/**"
-        doozer_pool.with_connection do |doozer|
-          doozer.walk(path, revision).each do |node|
-            block.call(relative_path(node.path), node.value)
-          end
+      path = "#{@root_path}/**"
+      doozer_pool.with_connection do |doozer|
+        doozer.walk(path, doozer.current_revision).each do |node|
+          block.call(relative_path(node.path), node.value)
         end
       end
     end
 
+    # Returns [Array<String>] all paths in the registry
+    def paths
+      paths = []
+      each_pair {|k,v| paths << k}
+      paths
+    end
+
     # Returns a copy of the registry as a Hash
     def to_h
-      if @registry
-        @registry.dup
-      else
-        h = {}
-        each_pair {|k,v| h[k] = v}
-        h
-      end
+      h = {}
+      each_pair {|k,v| h[k] = v}
+      h
     end
 
     # Cleanup on process termination
@@ -224,39 +187,18 @@ module RubyDoozer
       @doozer_pool = nil
     end
 
-    # When an entry is created the block will be called
-    #  Parameters
-    #    path
-    #      The relative path _excluding_ the root_path to watch for changes
-    #      #TODO Or a regular expression
-    #    block
-    #      The block to be called
-    #
-    #  Parameters passed to the block:
-    #    path
-    #      The path that was created
-    #
-    #    value
-    #      New value from doozer
-    #
-    # Example:
-    #   registry.on_update do |path, value|
-    #     puts "#{path} was created with #{value}"
-    #   end
-    def on_create(path, &block)
-      (@create_subscribers[path] ||= ThreadSafe::Array.new) << block
-    end
-
     # When an entry is updated the block will be called
     #  Parameters
     #    path
-    #      The relative path _excluding_ the root_path to watch for changes
+    #      The relative path to watch for changes
     #    block
     #      The block to be called
     #
     #  Parameters passed to the block:
     #    path
-    #      The path that was deleted from doozer
+    #      The path that was updated in doozer
+    #      Supplying a path of '*' means all paths
+    #      Default: '*'
     #
     #    value
     #      New value from doozer
@@ -269,24 +211,24 @@ module RubyDoozer
     #   registry.on_update do |path, value, old_value|
     #     puts "#{path} was updated to #{value} with previous value #{old_value}"
     #   end
-    #
-    # Warning:
-    #   If :cache is set to false then on_update will never be called
-    #   Every change will go to subscribers of #on_create()
-    def on_update(path, &block)
-      (@update_subscribers[path] ||= ThreadSafe::Array.new) << block
+    def on_update(path='*', &block)
+      # Start monitoring thread if not already started
+      monitor_thread
+      ((@update_subscribers ||= ThreadSafe::Hash.new)[path] ||= ThreadSafe::Array.new) << block
     end
 
     # When an entry is deleted the block will be called
     #  Parameters
     #    path
-    #      The relative path _excluding_ the root_path to watch for changes
+    #      The relative path to watch for changes
     #    block
     #      The block to be called
     #
     #  Parameters passed to the block:
     #    path
     #      The path that was deleted from doozer
+    #      Supplying a path of '*' means all paths
+    #      Default: '*'
     #
     #    old_value
     #      nil if :cache is false
@@ -296,16 +238,15 @@ module RubyDoozer
     #   registry.on_delete do |path, old_value|
     #     puts "#{path} was deleted with previous value #{old_value}"
     #   end
-    def on_delete(path, &block)
-      (@delete_subscribers[path] ||= ThreadSafe::Array.new) << block
+    def on_delete(path='*', &block)
+      # Start monitoring thread if not already started
+      monitor_thread
+      ((@delete_subscribers ||= ThreadSafe::Hash.new)[path] ||= ThreadSafe::Array.new) << block
     end
 
     ############################
     protected
 
-    #Subscription = Struct.new(:path, :block, :reg_exp)
-
-
     # Returns the full path given a relative path
     def full_path(relative_path)
       "#{@root_path}/#{relative_path}"
@@ -318,42 +259,54 @@ module RubyDoozer
 
     # The path has been added or updated in the registry
     def changed(path, value)
-      logger.debug { "Changed: #{path} => #{value}" }
-      old_value = nil
+      logger.debug { "Updated: #{path} => #{value}" }
 
-      # Keeping a local copy of the registry?
-      if @registry
-        # Already have a value?
-        old_value = @registry[path]
+      return unless @update_subscribers
 
-        # Update in memory copy
-        @registry[path] = value
+      # Subscribers to specific paths
+      if subscribers = @update_subscribers[path]
+        subscribers.each{|subscriber| subscriber.call(path, value)}
       end
 
-      if subscribers = old_value ? @update_subscribers[path] : @create_subscribers[path]
-        subscribers.each{|subscriber| subscriber.call(path, value, old_value)}
+      # Any subscribers for all events?
+      if all_subscribers = @update_subscribers['*']
+        all_subscribers.each{|subscriber| subscriber.call(path, value)}
       end
     end
 
     # Existing data has been removed from the registry
     def deleted(path)
       logger.debug { "Deleted: #{path}" }
-      old_value = @registry.delete(path) if @registry
+
+      return unless @delete_subscribers
+
+      # Subscribers to specific paths
       if subscribers = @delete_subscribers[path]
-        subscribers.each{|subscriber| subscriber.call(path, old_value)}
+        subscribers.each{|subscriber| subscriber.call(path)}
+      end
+
+      # Any subscribers for all events?
+      if all_subscribers = @delete_subscribers['*']
+        all_subscribers.each{|subscriber| subscriber.call(path)}
       end
     end
 
     # Waits for any updates from Doozer and updates the internal service registry
-    def watch_registry(watch_path, revision)
+    def watch_registry
+      watch_path = "#{@root_path}/**"
       logger.info "Start monitoring #{watch_path}"
       # This thread must use its own dedicated doozer connection
       doozer = RubyDoozer::Client.new(@doozer_config)
+      @current_revision ||= doozer.current_revision
 
-      # Watch for any changes
-      doozer.watch(watch_path, revision) do |node|
+      # Watch for any new changes
+      logger.debug "Monitoring thread started. Waiting for Registry Changes"
+      doozer.watch(watch_path, @current_revision + 1) do |node|
         logger.trace "Registry Change Notification", node
 
+        # Update the current_revision with every change notification
+        @current_revision = node.rev
+
         # Remove the Root path
         path = relative_path(node.path)
 
@@ -365,9 +318,11 @@ module RubyDoozer
         else
           logger.error "Unknown flags returned by doozer:#{node.flags}"
         end
-        logger.trace "Updated registry", @registry
       end
       logger.info "Stopping monitoring thread normally"
+
+    # #TODO need more exception handling here
+
     rescue Exception => exc
       logger.error "Exception in monitoring thread", exc
     ensure

data/lib/ruby_doozer/version.rb

@@ -1,3 +1,3 @@
 module RubyDoozer #:nodoc
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/ruby_doozer.rb

@@ -1,6 +1,7 @@
 require 'semantic_logger'
 
 module RubyDoozer
-  autoload :Client,   'ruby_doozer/client'
-  autoload :Registry, 'ruby_doozer/registry'
+  autoload :Client,         'ruby_doozer/client'
+  autoload :Registry,       'ruby_doozer/registry'
+  autoload :CachedRegistry, 'ruby_doozer/cached_registry'
 end

data/test/cached_registry_test.rb

@@ -0,0 +1,152 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'ruby_doozer'
+
+# NOTE:
+# This test assumes that doozerd is running locally on the default port of 8046
+
+# Register an appender if one is not already registered
+if SemanticLogger::Logger.appenders.size == 0
+  SemanticLogger::Logger.default_level = :trace
+  SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
+end
+
+# Unit Test for RubyDoozer::Client
+class CachedRegistryTest < Test::Unit::TestCase
+  context RubyDoozer::CachedRegistry do
+    context "with test data" do
+      setup do
+        @test_data = {
+          'bar' => 'test',
+          'one' => 'one',
+          'two' => 'two',
+        }
+        # Doozer does not allow '_' in path names
+        @root_path = "/registrytest"
+        @registry = RubyDoozer::CachedRegistry.new(:root_path => @root_path)
+        @test_data.each_pair {|k,v| @registry[k] = v}
+        # Give doozer time to send back the changes
+        sleep 0.5
+      end
+
+      def teardown
+        if @registry
+          @test_data.each_pair {|k,v| @registry.delete(k)}
+          @registry.delete('three')
+          @registry.finalize
+        end
+      end
+
+      should "have complete registry" do
+        @test_data.each_pair do |k,v|
+          assert_equal v, @registry[k], "Expected #{k}=>#{v}, #{@registry.to_h.inspect}"
+        end
+      end
+
+      should "iterate over complete registry" do
+        @registry.each_pair do |k,v|
+          assert_equal v, @test_data[k], "Registry #{k}=>#{v}, #{@registry.to_h.inspect}"
+        end
+      end
+
+      should "successfully set and retrieve data" do
+        @registry['three'] = 'value'
+        # Give doozer time to send back the change
+        sleep 0.5
+        result = @registry['three']
+        assert_equal 'value', result
+      end
+
+      [nil, '*'].each do |monitor_path|
+        context "with monitor_path:#{monitor_path}" do
+          should "callback on create" do
+            created_path = nil
+            created_value = nil
+            @registry.on_create(monitor_path||'three') do |path, value|
+              created_path = path
+              created_value = value
+            end
+            @registry['three'] = 'created'
+            # Allow doozer to send back the change
+            sleep 0.5
+            assert_equal 'three', created_path
+            assert_equal 'created', created_value
+          end
+
+          should "callback on update" do
+            updated_path = nil
+            updated_value = nil
+            @registry.on_update(monitor_path||'bar') do |path, value|
+              updated_path = path
+              updated_value = value
+            end
+            @registry['bar'] = 'updated'
+            # Allow doozer to send back the change
+            sleep 0.5
+            assert_equal 'bar', updated_path
+            assert_equal 'updated', updated_value
+          end
+
+          should "callback on delete" do
+            deleted_path = nil
+            @registry.on_delete(monitor_path||'bar') do |path|
+              deleted_path = path
+            end
+            # Allow doozer to send back the change
+            @registry.delete('bar')
+            sleep 0.5
+            assert_equal 'bar', deleted_path
+          end
+        end
+      end
+
+      ['other', 'one'].each do |monitor_path|
+        context "with monitor_path:#{monitor_path}" do
+          should "not callback on create" do
+            created_path = nil
+            created_value = nil
+            @registry.on_create(monitor_path) do |path, value|
+              created_path = path
+              created_value = value
+            end
+            @registry['three'] = 'created'
+            # Allow doozer to send back the change
+            sleep 0.5
+            assert_equal nil, created_path
+            assert_equal nil, created_value
+          end
+
+          should "not callback on update" do
+            updated_path = nil
+            updated_value = nil
+            @registry.on_update(monitor_path) do |path, value|
+              updated_path = path
+              updated_value = value
+            end
+            @registry['bar'] = 'updated'
+            # Give doozer time to send back the change
+            sleep 0.5
+            assert_equal nil, updated_path
+            assert_equal nil, updated_value
+          end
+
+          should "not callback on delete" do
+            deleted_path = nil
+            @registry.on_delete(monitor_path) do |path|
+              deleted_path = path
+            end
+            @registry.delete('bar')
+            # Give doozer time to send back the change
+            sleep 0.5
+            assert_equal nil, deleted_path
+          end
+        end
+      end
+    end
+
+  end
+end

data/test/registry_test.rb

@@ -44,74 +44,89 @@ class RegistryTest < Test::Unit::TestCase
         end
       end
 
-      # Run tests with and without a local cache
-      [true, false].each do |cache|
-        context "cache:#{cache}" do
-          should "have complete registry" do
-            @test_data.each_pair do |k,v|
-              assert_equal v, @registry[k], "Expected #{k}=>#{v}, #{@registry.to_h.inspect}"
-            end
-          end
+      should "have complete registry" do
+        @test_data.each_pair do |k,v|
+          assert_equal v, @registry[k], "Expected #{k}=>#{v}, #{@registry.to_h.inspect}"
+        end
+      end
 
-          should "iterate over complete registry" do
-            @registry.each_pair do |k,v|
-              assert_equal v, @test_data[k], "Registry #{k}=>#{v}, #{@registry.to_h.inspect}"
-            end
-          end
+      should "iterate over complete registry" do
+        @registry.each_pair do |k,v|
+          assert_equal v, @test_data[k], "Registry #{k}=>#{v}, #{@registry.to_h.inspect}"
+        end
+      end
+
+      should "successfully set and retrieve data" do
+        @registry['three'] = 'value'
+        # Allow doozer to send back the change
+        sleep 0.3
+        result = @registry['three']
+        assert_equal 'value', result
+      end
 
-          should "successfully set and retrieve data" do
-            @registry['three'] = 'value'
+      [nil, '*'].each do |monitor_path|
+        context "with monitor_path:#{monitor_path}" do
+          should "callback on update" do
+            updated_path = nil
+            updated_value = nil
+            @registry.on_update(monitor_path||'bar') do |path, value|
+              updated_path = path
+              updated_value = value
+            end
+            # Allow monitoring thread to start
+            sleep 0.1
+            @registry['bar'] = 'updated'
             # Allow doozer to send back the change
-            sleep 0.5
-            result = @registry['three']
-            assert_equal 'value', result
+            sleep 0.3
+            assert_equal 'bar', updated_path
+            assert_equal 'updated', updated_value
           end
 
-          should "invoke callbacks on create" do
-            created_path = nil
-            created_value = nil
-            @registry.on_create('three') do |path, value|
-              created_path = path
-              created_value = value
+          should "callback on delete" do
+            deleted_path = nil
+            @registry.on_delete(monitor_path||'bar') do |path|
+              deleted_path = path
             end
-            @registry['three'] = 'created'
+            # Allow monitoring thread to start
+            sleep 0.1
             # Allow doozer to send back the change
-            sleep 0.5
-            assert_equal 'three', created_path
-            assert_equal 'created', created_value
+            @registry.delete('bar')
+            sleep 0.3
+            assert_equal 'bar', deleted_path
           end
+        end
+      end
 
-          should "invoke callbacks on update" do
-            # Update only triggers when the cache is enabled
-            if cache
-              updated_path = nil
-              updated_value = nil
-              @registry.on_update('bar') do |path, value|
-                updated_path = path
-                updated_value = value
-              end
-              @registry['bar'] = 'updated'
-              # Allow doozer to send back the change
-              sleep 0.5
-              assert_equal 'bar', updated_path
-              assert_equal 'updated', updated_value
+      ['other', 'one'].each do |monitor_path|
+        context "with monitor_path:#{monitor_path}" do
+          should "not callback on update" do
+            updated_path = nil
+            updated_value = nil
+            @registry.on_update(monitor_path) do |path, value|
+              updated_path = path
+              updated_value = value
             end
+            # Allow monitoring thread to start
+            sleep 0.1
+            @registry['bar'] = 'updated'
+            # Allow doozer to send back the change
+            sleep 0.3
+            assert_equal nil, updated_path
+            assert_equal nil, updated_value
           end
 
-          should "invoke callbacks on delete" do
+          should "not callback on delete" do
             deleted_path = nil
-            deleted_value = nil
-            @registry.on_delete('bar') do |path, old_value|
+            @registry.on_delete(monitor_path) do |path|
               deleted_path = path
-              deleted_value = old_value
             end
+            # Allow monitoring thread to start
+            sleep 0.1
             # Allow doozer to send back the change
             @registry.delete('bar')
-            sleep 0.5
-            assert_equal 'bar', deleted_path
-            assert_equal 'test', deleted_value
+            sleep 0.3
+            assert_equal nil, deleted_path
           end
-
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_doozer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Reid Morrison
@@ -79,11 +79,13 @@ files:
 - README.md
 - Rakefile
 - lib/ruby_doozer.rb
+- lib/ruby_doozer/cached_registry.rb
 - lib/ruby_doozer/client.rb
 - lib/ruby_doozer/exceptions.rb
 - lib/ruby_doozer/msg.pb.rb
 - lib/ruby_doozer/registry.rb
 - lib/ruby_doozer/version.rb
+- test/cached_registry_test.rb
 - test/client_test.rb
 - test/registry_test.rb
 homepage: https://github.com/ClarityServices/ruby_doozer