puppet-debugger 0.6.1 → 0.7.0

data/lib/puppet-debugger/input_responder_plugin.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+require 'puppet-debugger/support/errors'
+require 'forwardable'
+
+module PuppetDebugger
+    class InputResponderPlugin
+      include Singleton
+      extend Forwardable
+      attr_accessor :debugger
+      def_delegators :debugger, :scope, :node, :environment,
+                     :add_hook, :handle_input, :delete_hook, :function_map
+      def_delegators :scope, :compiler, :catalog
+      def_delegators :node, :facts
+
+      def self.command_words
+        self::COMMAND_WORDS
+      end
+
+      def self.summary
+        self::SUMMARY
+      end
+
+      def self.command_group
+        self::COMMAND_GROUP
+      end
+
+      def self.details
+        { words: command_words, summary: summary, group: command_group }
+      end
+
+      # @param args [Array[String]] - an array of arguments to pass to the plugin command
+      # @param debugger PuppetDebugger::Cli  - an instance of the PuppetDebugger::Cli object
+      # @return the output of the plugin command
+      def self.execute(args = [], debugger)
+        instance.debugger = debugger
+        instance.run(args)
+      end
+
+      # @param args [Array[String]] - an array of arguments to pass to the plugin command
+      # @return the output of the plugin command
+      def run(args = [])
+        raise NotImplementedError
+      end
+    end
+end

data/lib/puppet-debugger/plugin_test_helper.rb

@@ -0,0 +1,44 @@
+# https://relishapp.com/rspec/rspec-core/v/3-6/docs/example-groups/shared-examples
+RSpec.shared_examples "plugin_tests" do |parameter|
+  let(:plugin) do
+    instance = PuppetDebugger::InputResponders::Commands.plugin_from_command(subject.to_s).instance
+    instance.debugger = debugger
+    instance
+  end
+
+  let(:output) do
+    StringIO.new
+  end
+
+  let(:debugger) do
+    PuppetDebugger::Cli.new({ out_buffer: output }.merge(options))
+  end
+
+  let(:options) do
+    {}
+  end
+
+  it "commands contant is an array" do
+    expect(plugin.class::COMMAND_WORDS).to be_a(Array)
+  end
+
+  it "commands must contain at least one word" do
+    expect(plugin.class::COMMAND_WORDS.count).to  be > 0
+  end
+
+  it "summary must be a string" do
+    expect(plugin.class::SUMMARY).to be_a(String)
+  end
+
+  it 'implements run' do
+    expect{plugin.run([])}.not_to raise_error(NotImplementedError)
+  end
+
+  it 'be looked up via any command words' do
+    plugin.class::COMMAND_WORDS.each do |word|
+      actual = PuppetDebugger::InputResponders::Commands.plugin_from_command(word.to_s).instance.class
+      expect(actual).to eq(plugin.class)
+    end
+  end
+
+end

data/lib/puppet-debugger/support.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'puppet/pops'
 require 'facterdb'
 require 'tempfile'
@@ -17,8 +18,6 @@ module PuppetDebugger
     include PuppetDebugger::Support::Functions
     include PuppetDebugger::Support::Node
     include PuppetDebugger::Support::Loader
-    include PuppetDebugger::Support::InputResponders
-    include PuppetDebugger::Support::Play
 
     # parses the error type into a more useful error message defined in errors.rb
     # returns new error object or the original if error cannot be parsed
@@ -45,6 +44,10 @@ module PuppetDebugger
       end
     end
 
+    def static_responder_list
+      PuppetDebugger::InputResponders::Commands.command_list
+    end
+
     # this is the lib directory of this gem
     # in order to load any puppet functions from this gem we need to add the lib path
     # of this gem
@@ -61,10 +64,6 @@ module PuppetDebugger
       end
     end
 
-    def keyword_expression
-      @keyword_expression ||= Regexp.new(/^exit|^:set|^play|^classification|^facts|^vars|^functions|^whereami|^classes|^resources|^krt|^environment|^reset|^help/)
-    end
-
     def known_resource_types
       res = {
         hostclasses: scope.environment.known_resource_types.hostclasses.keys,
@@ -136,20 +135,25 @@ module PuppetDebugger
         # because the repl is not a module we leave the modname blank
         scope.environment.known_resource_types.import_ast(ast, '')
 
-        if $benchmark
+        exec_hook :before_eval, '', self, self
+        if bench
           result = nil
           time = Benchmark.realtime do
             result = parser.evaluate_string(scope, input, File.expand_path(file))
           end
-          [result, "Time elapsed #{(time*1000).round(2)} ms"]
+          out = [result, "Time elapsed #{(time * 1000).round(2)} ms"]
         else
-          parser.evaluate_string(scope, input, File.expand_path(file))
+          out = parser.evaluate_string(scope, input, File.expand_path(file))
         end
+        exec_hook :after_eval, out, self, self
+        out
       end
     end
 
     def puppet_lib_dir
       # returns something like "/Library/Ruby/Gems/2.0.0/gems/puppet-4.2.2/lib/puppet.rb"
+      # "/Users/adam/.rbenv/versions/2.2.6/lib/ruby/gems/2.2.0/gems/puppet-4.9.4/lib"
+
       # this is only useful when returning a namespace with the functions
       @puppet_lib_dir ||= File.dirname(Puppet.method(:[]).source_location.first)
     end

data/lib/puppet-debugger/support/compiler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'tempfile'
 
 module PuppetDebugger

data/lib/puppet-debugger/support/environment.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module PuppetDebugger
   module Support
     module Environment
@@ -7,6 +8,7 @@ module PuppetDebugger
       def puppet_environment
         @puppet_environment ||= create_environment
       end
+      alias :environment :puppet_environment
 
       # returns an array of module directories, generally this is the only place
       # to look for puppet code by default.  This is read from the puppet configuration

data/lib/puppet-debugger/support/errors.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module PuppetDebugger
   module Exception
     class Error < StandardError
@@ -8,9 +9,17 @@ module PuppetDebugger
       end
     end
 
+
+
     class FatalError < Error
     end
 
+    class InvalidCommand < Error
+      def message
+        data[:message]
+      end
+    end
+
     class ConnectError < Error
       def message
         out = <<-EOF

data/lib/puppet-debugger/support/facts.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module PuppetDebugger
   module Support
     module Facts
@@ -46,7 +47,7 @@ module PuppetDebugger
         node_facts = FacterDB.get_facts(dynamic_facterdb_filter).first
         if node_facts.nil?
           message = <<-EOS
-Using filter: #{facterdb_filter}
+Using filter: #{dynamic_facterdb_filter}
 Bad FacterDB filter, please change the filter so it returns a result set.
 See https://github.com/camptocamp/facterdb/#with-a-string-filter
           EOS

data/lib/puppet-debugger/support/functions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module PuppetDebugger
   module Support
     module Functions
@@ -43,7 +44,8 @@ module PuppetDebugger
             obj = {}
             name = File.basename(file, '.rb')
             obj[:name] = name
-            obj[:parent] = mod_finder.match(file)[1]
+            # return the last matched in cases where rbenv might be involved
+            obj[:parent] = file.scan(mod_finder).flatten.last
             @functions["#{obj[:parent]}::#{name}"] = obj
           end
         end

data/lib/puppet-debugger/support/loader.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+
 module PuppetDebugger
   module Support
+    # the Loader module wraps a few puppet loader functions
     module Loader
       def create_loader(environment)
         Puppet::Pops::Loaders.new(environment)

data/lib/puppet-debugger/support/node.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'puppet/indirector/node/rest'
 
 module PuppetDebugger

data/lib/puppet-debugger/support/scope.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module PuppetDebugger
   module Support
     module Scope

data/lib/puppet/application/debugger.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'puppet/application'
 require 'optparse'
 require 'puppet/util/command_line'

data/lib/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module PuppetDebugger
-  VERSION = '0.6.1'
+  VERSION = '0.7.0'
 end

data/puppet-debugger.gemspec

@@ -1,37 +1,42 @@
 
+# frozen_string_literal: true
+
 require './lib/version'
 require 'date'
 
 Gem::Specification.new do |s|
-  s.name = "puppet-debugger"
+  s.name = 'puppet-debugger'
   s.version = PuppetDebugger::VERSION
   s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|resources|local_test_results|pec)/}) }
-  s.bindir        = "bin"
-  s.executables = ["pdb"]
+  s.bindir        = 'bin'
+  s.executables = ['pdb']
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if s.respond_to?(:metadata)
     s.metadata['allowed_push_host'] = 'https://rubygems.org'
   else
-    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
   end
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.require_paths = ["lib"]
-  s.authors = ["Corey Osman"]
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.require_paths = ['lib']
+  s.authors = ['Corey Osman']
   s.date = DateTime.now.strftime('%Y-%m-%d')
-  s.description = "A interactive command line tool for evaluating and debugging the puppet language"
-  s.email = "corey@nwops.io"
+  s.description = 'A interactive command line tool for evaluating and debugging the puppet language'
+  s.email = 'corey@nwops.io'
   s.extra_rdoc_files = [
-    "CHANGELOG.md",
-    "LICENSE.txt",
-    "README.md"
+    'CHANGELOG.md',
+    'LICENSE.txt',
+    'README.md'
   ]
   s.homepage = "http://github.com/nwops/puppet-debugger"
   s.licenses = ["MIT"]
   s.rubygems_version = "2.4.5.1"
   s.summary = "A repl based debugger for the puppet language"
+  s.add_runtime_dependency(%q<pluginator>, ["~> 1.4.1"])
   s.add_runtime_dependency(%q<puppet>, [">= 3.8"])
-  s.add_runtime_dependency(%q<facterdb>, [">= 0.3.8"])
-  s.add_runtime_dependency(%q<awesome_print>, ["~> 1.6"])
+  s.add_runtime_dependency(%q<facterdb>, ["~> 0.3.1"])
+  s.add_runtime_dependency(%q<awesome_print>, ["~> 1.7"])
   s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-end
+  s.add_development_dependency(%q<rspec>, ["~> 3.6"])
+
+end

data/run_container_test.sh

@@ -2,7 +2,7 @@
 export PATH=$PATH:/usr/local/bundle
 gem install bundler > /dev/null
 gem update --system > /dev/null
-bundle install --no-color --without development
+bundle update
 bundle exec puppet module install puppetlabs-stdlib
 echo "Running tests, output to ${OUT_DIR}/results.txt"
 bundle exec rspec --out "${OUT_DIR}/results.txt" --format documentation

data/spec/environment_spec.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 require 'stringio'
 describe 'environment' do
   let(:output) do
-    StringIO.new('', 'w')
+    StringIO.new
   end
 
   let(:debugger) do

data/spec/facts_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe 'facts' do

data/spec/hooks_spec.rb

@@ -0,0 +1,341 @@
+require_relative 'spec_helper'
+
+describe PuppetDebugger::Hooks do
+  before do
+    @hooks = PuppetDebugger::Hooks.new
+  end
+
+  let(:output) do
+    StringIO.new
+  end
+
+  let(:debugger) do
+    PuppetDebugger::Cli.new(out_buffer: output)
+  end
+  
+  describe "adding a new hook" do
+    it 'should not execute hook while adding it' do
+      run = false
+      @hooks.add_hook(:test_hook, :my_name) { run = true }
+      expect(run).to eq false
+    end
+
+    it 'should not allow adding of a hook with a duplicate name' do
+      @hooks.add_hook(:test_hook, :my_name) {}
+
+      expect { @hooks.add_hook(:test_hook, :my_name) {} }.to raise_error ArgumentError
+    end
+
+    it 'should create a new hook with a block' do
+      @hooks.add_hook(:test_hook, :my_name) { }
+      expect(@hooks.hook_count(:test_hook)).to eq 1
+    end
+
+    it 'should create a new hook with a callable' do
+      @hooks.add_hook(:test_hook, :my_name, proc { })
+      expect(@hooks.hook_count(:test_hook)).to eq 1
+    end
+
+    it 'should use block if given both block and callable' do
+      run = false
+      foo = false
+      @hooks.add_hook(:test_hook, :my_name, proc { foo = true }) { run = true }
+      expect(@hooks.hook_count(:test_hook)).to eq 1
+      @hooks.exec_hook(:test_hook)
+      expect(run).to eq true
+      expect(foo).to eq false
+    end
+
+    it 'should raise if not given a block or any other object' do
+      expect { @hooks.add_hook(:test_hook, :my_name) }.to raise_error ArgumentError
+    end
+
+    it 'should create multiple hooks for an event' do
+      @hooks.add_hook(:test_hook, :my_name) {}
+      @hooks.add_hook(:test_hook, :my_name2) {}
+      expect(@hooks.hook_count(:test_hook)).to eq 2
+    end
+
+    it 'should return a count of 0 for an empty hook' do
+      expect(@hooks.hook_count(:test_hook)).to eq 0
+    end
+  end
+
+  describe "PuppetDebugger::Hooks#merge" do
+    describe "merge!" do
+      it 'should merge in the PuppetDebugger::Hooks' do
+        h1 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing) {}
+        h2 = PuppetDebugger::Hooks.new
+
+        h2.merge!(h1)
+        expect(h2.get_hook(:test_hook, :testing)).to eq h1.get_hook(:test_hook, :testing)
+      end
+
+      it 'should not share merged elements with original' do
+        h1 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing) {}
+        h2 = PuppetDebugger::Hooks.new
+
+        h2.merge!(h1)
+        h2.add_hook(:test_hook, :testing2) {}
+        expect(h2.get_hook(:test_hook, :testing2)).not_to eq h1.get_hook(:test_hook, :testing2)
+      end
+
+      it 'should NOT overwrite hooks belonging to shared event in receiver' do
+        h1 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing) {}
+        callable = proc {}
+        h2 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing2, callable)
+
+        h2.merge!(h1)
+        expect(h2.get_hook(:test_hook, :testing2)).to eq callable
+      end
+
+      it 'should overwrite identical hook in receiver' do
+        callable1 = proc { :one }
+        h1 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing, callable1)
+        callable2 = proc { :two }
+        h2 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing, callable2)
+
+        h2.merge!(h1)
+        expect(h2.get_hook(:test_hook, :testing)).to eq callable1
+        expect(h2.hook_count(:test_hook)).to eq 1
+      end
+
+      it 'should preserve hook order' do
+        name = ""
+        h1 = PuppetDebugger::Hooks.new
+        h1.add_hook(:test_hook, :testing3) { name << "h" }
+        h1.add_hook(:test_hook, :testing4) { name << "n" }
+
+        h2 = PuppetDebugger::Hooks.new
+        h2.add_hook(:test_hook, :testing1) { name << "j" }
+        h2.add_hook(:test_hook, :testing2) { name << "o" }
+
+        h2.merge!(h1)
+        h2.exec_hook(:test_hook)
+
+        expect(name).to eq "john"
+      end
+
+      describe "merge" do
+        it 'should return a fresh, independent instance' do
+          h1 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = PuppetDebugger::Hooks.new
+
+          h3 = h2.merge(h1)
+          expect(h3).not_to eq h1
+          expect(h3).not_to eq h2
+        end
+
+        it 'should contain hooks from original instance' do
+          h1 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = PuppetDebugger::Hooks.new.add_hook(:test_hook2, :testing) {}
+
+          h3 = h2.merge(h1)
+          expect(h3.get_hook(:test_hook, :testing)).to eq h1.get_hook(:test_hook, :testing)
+          expect(h3.get_hook(:test_hook2, :testing)).to eq h2.get_hook(:test_hook2, :testing)
+        end
+
+        it 'should not affect original instances when new hooks are added' do
+          h1 = PuppetDebugger::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = PuppetDebugger::Hooks.new.add_hook(:test_hook2, :testing) {}
+
+          h3 = h2.merge(h1)
+          h3.add_hook(:test_hook3, :testing) {}
+
+          expect(h1.get_hook(:test_hook3, :testing)).to eq nil
+          expect(h2.get_hook(:test_hook3, :testing)).to eq nil
+        end
+      end
+
+    end
+  end
+
+  describe "dupping a PuppetDebugger::Hooks instance" do
+    it 'should share hooks with original' do
+      @hooks.add_hook(:test_hook, :testing) do
+        :none_such
+      end
+
+      hooks_dup = @hooks.dup
+      expect(hooks_dup.get_hook(:test_hook, :testing)).to eq @hooks.get_hook(:test_hook, :testing)
+    end
+
+    it 'adding a new event to dupped instance should not affect original' do
+      @hooks.add_hook(:test_hook, :testing) { :none_such }
+      hooks_dup = @hooks.dup
+
+      hooks_dup.add_hook(:other_test_hook, :testing) { :okay_man }
+
+      expect(hooks_dup.get_hook(:other_test_hook, :testing)).not_to eq @hooks.get_hook(:other_test_hook, :testing)
+    end
+
+    it 'adding a new hook to dupped instance should not affect original' do
+      @hooks.add_hook(:test_hook, :testing) { :none_such }
+      hooks_dup = @hooks.dup
+
+      hooks_dup.add_hook(:test_hook, :testing2) { :okay_man }
+
+      expect(hooks_dup.get_hook(:test_hook, :testing2)).not_to eq @hooks.get_hook(:test_hook, :testing2)
+    end
+
+  end
+
+  describe "getting hooks" do
+    describe "get_hook" do
+      it 'should return the correct requested hook' do
+        run = false
+        fun = false
+        @hooks.add_hook(:test_hook, :my_name) { run = true }
+        @hooks.add_hook(:test_hook, :my_name2) { fun = true }
+        @hooks.get_hook(:test_hook, :my_name).call
+        expect(run).to eq true
+        expect(fun).to eq false
+      end
+
+      it 'should return nil if hook does not exist' do
+        expect(@hooks.get_hook(:test_hook, :my_name)).to eq nil
+      end
+    end
+
+    describe "get_hooks" do
+      it 'should return a hash of hook names/hook functions for an event' do
+        hook1 = proc { 1 }
+        hook2 = proc { 2 }
+        @hooks.add_hook(:test_hook, :my_name1, hook1)
+        @hooks.add_hook(:test_hook, :my_name2, hook2)
+        hash = @hooks.get_hooks(:test_hook)
+        expect(hash.size).to eq 2
+        expect(hash[:my_name1]).to eq hook1
+        expect(hash[:my_name2]).to eq hook2
+      end
+
+      it 'should return an empty hash if no hooks defined' do
+        expect(@hooks.get_hooks(:test_hook)).to eq({})
+      end
+    end
+  end
+
+  describe "clearing all hooks for an event" do
+    it 'should clear all hooks' do
+      @hooks.add_hook(:test_hook, :my_name) { }
+      @hooks.add_hook(:test_hook, :my_name2) { }
+      @hooks.add_hook(:test_hook, :my_name3) { }
+      @hooks.clear_event_hooks(:test_hook)
+      expect(@hooks.hook_count(:test_hook)).to eq 0
+    end
+  end
+
+  describe "deleting a hook" do
+    it 'should successfully delete a hook' do
+      @hooks.add_hook(:test_hook, :my_name) {}
+      @hooks.delete_hook(:test_hook, :my_name)
+      expect(@hooks.hook_count(:test_hook)).to eq 0
+    end
+
+    it 'should return the deleted hook' do
+      run = false
+      @hooks.add_hook(:test_hook, :my_name) { run = true }
+      @hooks.delete_hook(:test_hook, :my_name).call
+      expect(run).to eq true
+    end
+
+    it 'should return nil if hook does not exist' do
+      expect(@hooks.delete_hook(:test_hook, :my_name)).to eq nil
+    end
+  end
+
+  describe "executing a hook" do
+    it 'should execute block hook' do
+      run = false
+      @hooks.add_hook(:test_hook, :my_name) { run = true }
+      @hooks.exec_hook(:test_hook)
+      expect(run).to eq true
+    end
+
+    it 'should execute proc hook' do
+      run = false
+      @hooks.add_hook(:test_hook, :my_name, proc { run = true })
+      @hooks.exec_hook(:test_hook)
+      expect(run).to eq true
+    end
+
+    it 'should execute a general callable hook' do
+      callable = Object.new.tap do |obj|
+        obj.instance_variable_set(:@test_var, nil)
+        class << obj
+          attr_accessor :test_var
+          def call() @test_var = true; end
+        end
+      end
+
+      @hooks.add_hook(:test_hook, :my_name, callable)
+      @hooks.exec_hook(:test_hook)
+      expect(callable.test_var).to eq true
+    end
+
+    it 'should execute all hooks for an event if more than one is defined' do
+      x = nil
+      y = nil
+      @hooks.add_hook(:test_hook, :my_name1) { y = true }
+      @hooks.add_hook(:test_hook, :my_name2) { x = true }
+      @hooks.exec_hook(:test_hook)
+      expect(x).to eq true
+      expect(y).to eq true
+    end
+
+    it 'should execute hooks in order' do
+      array = []
+      @hooks.add_hook(:test_hook, :my_name1) { array << 1 }
+      @hooks.add_hook(:test_hook, :my_name2) { array << 2 }
+      @hooks.add_hook(:test_hook, :my_name3) { array << 3 }
+      @hooks.exec_hook(:test_hook)
+      expect(array).to eq [1, 2, 3]
+    end
+
+    it 'return value of exec_hook should be that of last executed hook' do
+      @hooks.add_hook(:test_hook, :my_name1) { 1 }
+      @hooks.add_hook(:test_hook, :my_name2) { 2 }
+      @hooks.add_hook(:test_hook, :my_name3) { 3 }
+      expect(@hooks.exec_hook(:test_hook)).to eq 3
+    end
+
+    it 'should add exceptions to the errors array' do
+      @hooks.add_hook(:test_hook, :foo1) { raise 'one' }
+      @hooks.add_hook(:test_hook, :foo2) { raise 'two' }
+      @hooks.add_hook(:test_hook, :foo3) { raise 'three' }
+      @hooks.exec_hook(:test_hook)
+      expect(@hooks.errors.map(&:message)).to eq ['one', 'two', 'three']
+    end
+
+    it 'should return the last exception raised as the return value' do
+      @hooks.add_hook(:test_hook, :foo1) { raise 'one' }
+      @hooks.add_hook(:test_hook, :foo2) { raise 'two' }
+      @hooks.add_hook(:test_hook, :foo3) { raise 'three' }
+      expect(@hooks.exec_hook(:test_hook)).to eq @hooks.errors.last
+    end
+  end
+
+  describe "anonymous hooks" do
+    it 'should allow adding of hook without a name' do
+      @hooks.add_hook(:test_hook, nil) {}
+      expect(@hooks.hook_count(:test_hook)).to eq 1
+    end
+
+    it 'should only allow one anonymous hook to exist' do
+      @hooks.add_hook(:test_hook, nil) {  }
+      @hooks.add_hook(:test_hook, nil) {  }
+      expect(@hooks.hook_count(:test_hook)).to eq 1
+    end
+
+    it 'should execute most recently added anonymous hook' do
+      x = nil
+      y = nil
+      @hooks.add_hook(:test_hook, nil) { y = 1 }
+      @hooks.add_hook(:test_hook, nil) { x = 2 }
+      @hooks.exec_hook(:test_hook)
+      expect(y).to eq nil
+      expect(x).to eq 2
+    end
+  end
+
+end