hoodoo 1.7.0 → 1.8.0

data/lib/hoodoo/version.rb

@@ -12,6 +12,6 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, ensure that the date in
   # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
   #
-  VERSION = '1.7.0'
+  VERSION = '1.8.0'
 
 end

data/spec/client/client_spec.rb

@@ -1079,5 +1079,22 @@ describe Hoodoo::Client do
         Hoodoo::Client.new
       }.to raise_error( RuntimeError, 'Hoodoo::Client: Please pass one of the "discoverer", "base_uri", "drb_uri" or "drb_port" parameters.' )
     end
+
+    context 'with ActiveSupport absent' do
+      before :all do
+        @old_discoverer = Hoodoo::Services::Discovery::ByConvention
+        Hoodoo::Services::Discovery.send( :remove_const, :ByConvention )
+      end
+
+      it 'lead to a useful exception if the ByDiscovery discoverer is requested' do
+        expect {
+          Hoodoo::Client.new( base_uri: 'http://localhost' )
+        }.to raise_error( RuntimeError, 'Hoodoo::Client: The constructor parameters indicate the use of a "by convention" discoverer. This discoverer requires ActiveSupport; ensure the ActiveSupport gem is present and "require"-able.' )
+      end
+
+      after :all do
+        Hoodoo::Services::Discovery.send( :const_set, :ByConvention, @old_discoverer )
+      end
+    end
   end
 end

data/spec/monkey/monkey_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper.rb'
+require 'benchmark'
+
+describe Hoodoo::Monkey do
+
+  BENCHMARK_ITERATIONS = 500000
+
+  # Have a base class which we will subclass in 'context's below. Define a
+  # different-signature instance and class method to test that the patched
+  # code still passes parameters and blocks properly. They're both the same
+  # name to make sure there's no accidental name-based overwiting of things
+  # to do with class versus instance methods anywhere.
+  #
+  class Foo
+    def bar( a, b, c, &block )
+      a + b + c + yield
+    end
+
+    def self.bar( x, &block )
+      x + yield
+    end
+  end
+
+  # Define patches for the above instance and class methods which double the
+  # returned value via calling 'super', testing the method chain in passing
+  # and providing an easily detectable value to see if the original, or the
+  # patched method has been called.
+  #
+  module InstanceExtendedFoo
+    module InstanceExtensions
+      def bar( a, b, c, &block )
+        super * 2
+      end
+    end
+  end
+
+  module ClassExtendedFoo
+    module ClassExtensions
+      def bar( x, &block )
+        super * 2
+      end
+    end
+  end
+
+  module ExtendedFoo
+    module InstanceExtensions
+      def bar( a, b, c, &block )
+        super * 2
+      end
+    end
+
+    module ClassExtensions
+      def bar( x, &block )
+        super * 2
+      end
+    end
+  end
+
+  # The next few contexts run a single "it" case because execution order is
+  # important. They each iterate the test set several times to prove that
+  # enable/disable cycles work properly.
+  #
+  context 'instance method patching' do
+
+    # Just register the instance extensions here.
+
+    class FooForInstanceTests < Foo; end
+
+    before :all do
+      Hoodoo::Monkey.register(
+        target_unit:      FooForInstanceTests,
+        extension_module: InstanceExtendedFoo
+      )
+    end
+
+    it 'works' do
+      expect( FooForInstanceTests.ancestors ).to_not include( InstanceExtendedFoo::InstanceExtensions )
+
+      1.upto( 10 ) do
+        expect( FooForInstanceTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+        expect( FooForInstanceTests.bar( 1 ) { 2 } ).to eq( 3 )
+
+        Hoodoo::Monkey.enable( extension_module: InstanceExtendedFoo )
+
+        expect( FooForInstanceTests.ancestors ).to include( InstanceExtendedFoo::InstanceExtensions )
+
+        expect( FooForInstanceTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 36 )
+        expect( FooForInstanceTests.bar( 1 ) { 2 } ).to eq( 3 )
+
+        Hoodoo::Monkey.disable( extension_module: InstanceExtendedFoo )
+      end
+    end
+  end
+
+  context 'class method patching' do
+
+    # Just register the class extensions here.
+
+    class FooForClassTests < Foo; end
+
+    before :all do
+      Hoodoo::Monkey.register(
+        target_unit:      FooForClassTests,
+        extension_module: ClassExtendedFoo
+      )
+    end
+
+    it 'works' do
+      expect( FooForClassTests.singleton_class.ancestors ).to_not include( ClassExtendedFoo::ClassExtensions )
+
+      1.upto( 10 ) do
+        expect( FooForClassTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+        expect( FooForClassTests.bar( 1 ) { 2 } ).to eq( 3 )
+
+        Hoodoo::Monkey.enable( extension_module: ClassExtendedFoo )
+
+        expect( FooForClassTests.singleton_class.ancestors ).to include( ClassExtendedFoo::ClassExtensions )
+
+        expect( FooForClassTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+        expect( FooForClassTests.bar( 1 ) { 2 } ).to eq( 6 )
+
+        Hoodoo::Monkey.disable( extension_module: ClassExtendedFoo )
+      end
+    end
+  end
+
+  context 'instance and class method patching' do
+
+    # Register the class and instance extensions here.
+
+    class FooForBothTests < Foo; end
+
+    before :all do
+      Hoodoo::Monkey.register(
+        target_unit:      FooForBothTests,
+        extension_module: ExtendedFoo
+      )
+    end
+
+    it 'works' do
+      expect( FooForBothTests.ancestors                 ).to_not include( ExtendedFoo::InstanceExtensions )
+      expect( FooForBothTests.singleton_class.ancestors ).to_not include( ExtendedFoo::ClassExtensions    )
+
+      1.upto( 10 ) do
+        expect( FooForBothTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+        expect( FooForBothTests.bar( 1 ) { 2 } ).to eq( 3 )
+
+        Hoodoo::Monkey.enable( extension_module: ExtendedFoo )
+
+        expect( FooForBothTests.ancestors                 ).to include( ExtendedFoo::InstanceExtensions )
+        expect( FooForBothTests.singleton_class.ancestors ).to include( ExtendedFoo::ClassExtensions    )
+
+        expect( FooForBothTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 36 )
+        expect( FooForBothTests.bar( 1 ) { 2 } ).to eq( 6 )
+
+        Hoodoo::Monkey.disable( extension_module: ExtendedFoo )
+      end
+    end
+  end
+
+  # A whole bunch of fiddly tests for different misuse or edge use cases.
+  #
+  context 'errant calls' do
+    before :each do
+      expect( Foo.ancestors                 ).to_not include( ExtendedFoo::InstanceExtensions )
+      expect( Foo.singleton_class.ancestors ).to_not include( ExtendedFoo::ClassExtensions    )
+    end
+
+    module NoIntanceOrClassExtensionsDefinedInside
+    end
+
+    it 'fault no-patch registration' do
+      expect {
+        Hoodoo::Monkey.register(
+          target_unit:      Foo,
+          extension_module: NoIntanceOrClassExtensionsDefinedInside
+        )
+      }.to raise_exception( RuntimeError, "Hoodoo::Monkey::register: You must define either an InstanceExtensions module ClassExtensions module or both inside 'NoIntanceOrClassExtensionsDefinedInside'" )
+    end
+
+    context 'fault unrecognised' do
+
+      class FooForUnrecognisedTests < Foo; end
+
+      before :all do
+        Hoodoo::Monkey.register(
+          target_unit:      FooForUnrecognisedTests,
+          extension_module: ExtendedFoo
+        )
+      end
+
+      it 'extension module enables' do
+        expect {
+          Hoodoo::Monkey.enable( extension_module: ExtendedFoo::InstanceExtensions )
+        }.to raise_exception( RuntimeError, "Hoodoo::Monkey::enable: Extension module 'ExtendedFoo::InstanceExtensions' is not registered" )
+      end
+
+      it 'extension module disables' do
+        expect {
+          Hoodoo::Monkey.disable( extension_module: ExtendedFoo::InstanceExtensions )
+        }.to raise_exception( RuntimeError, "Hoodoo::Monkey::disable: Extension module 'ExtendedFoo::InstanceExtensions' is not registered" )
+      end
+    end
+
+    class FooForSuccessiveEnableTests < Foo; end
+
+    it 'survive multiple successive enables' do
+      Hoodoo::Monkey.register(
+        target_unit:      FooForSuccessiveEnableTests,
+        extension_module: ExtendedFoo
+      )
+
+      expect( FooForSuccessiveEnableTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+      expect( FooForSuccessiveEnableTests.bar( 1 ) { 2 } ).to eq( 3 )
+
+      1.upto( 10 ) do
+        Hoodoo::Monkey.enable( extension_module: ExtendedFoo )
+      end
+
+      expect( FooForSuccessiveEnableTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 36 )
+      expect( FooForSuccessiveEnableTests.bar( 1 ) { 2 } ).to eq( 6 )
+    end
+
+    class FooForSuccessiveDisableTests < Foo; end
+
+    it 'survive multiple successive disables' do
+      Hoodoo::Monkey.register(
+        target_unit:      FooForSuccessiveDisableTests,
+        extension_module: ExtendedFoo
+      )
+
+      expect( FooForSuccessiveDisableTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+      expect( FooForSuccessiveDisableTests.bar( 1 ) { 2 } ).to eq( 3 )
+
+      Hoodoo::Monkey.enable( extension_module: ExtendedFoo )
+
+      expect( FooForSuccessiveDisableTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 36 )
+      expect( FooForSuccessiveDisableTests.bar( 1 ) { 2 } ).to eq( 6 )
+
+      1.upto( 10 ) do
+        Hoodoo::Monkey.disable( extension_module: ExtendedFoo )
+      end
+
+      expect( FooForSuccessiveDisableTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+      expect( FooForSuccessiveDisableTests.bar( 1 ) { 2 } ).to eq( 3 )
+    end
+
+    class FooForNotPreviouslyEnabledTests < Foo; end
+
+    it 'survive being disabled when not previously enabled' do
+      Hoodoo::Monkey.register(
+        target_unit:      FooForNotPreviouslyEnabledTests,
+        extension_module: ExtendedFoo
+      )
+
+      expect( FooForNotPreviouslyEnabledTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+      expect( FooForNotPreviouslyEnabledTests.bar( 1 ) { 2 } ).to eq( 3 )
+
+      Hoodoo::Monkey.disable( extension_module: ExtendedFoo )
+
+      expect( FooForNotPreviouslyEnabledTests.new.bar( 3, 4, 5 ) { 6 } ).to eq( 18 )
+      expect( FooForNotPreviouslyEnabledTests.bar( 1 ) { 2 } ).to eq( 3 )
+    end
+  end
+end

data/spec/monkey/patch/newrelic_traced_amqp_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper.rb'
+
+# We need to run these tests in order. First a bunch of shared examples
+# run. Then we check to see if hook methods were invoked in passing. You
+# can't do that in an 'after' hook as exceptions therein cause warnings
+# to be printed, but don't cause test failures.
+#
+describe Hoodoo::Monkey::Patch::NewRelicTracedAMQP, :order => :defined do
+
+  # Not every test in the 'an AMQP-based middleware/client endpoint' shared
+  # example group will provoke a request. We cannot expect to have the
+  # NewRelic hooks called for every example. We *can* expect them to be
+  # called several times though, so use 'allow' to track those calls and
+  # count them.
+  #
+  before :all do
+    @@endpoint_do_amqp_count       = 0
+    @@newrelic_crossapp_count      = 0
+    @@newrelic_agent_disable_count = 0
+
+    module NewRelic
+      class Agent
+        class CrossAppTracing
+        end
+      end
+    end
+
+    Hoodoo::Monkey.enable( extension_module: Hoodoo::Monkey::Patch::NewRelicTracedAMQP )
+  end
+
+  after :all do
+    Hoodoo::Monkey.disable( extension_module: Hoodoo::Monkey::Patch::NewRelicTracedAMQP )
+    Object.send( :remove_const, :NewRelic )
+  end
+
+  before :each do
+    expect( Hoodoo::Client::Endpoint::AMQP.ancestors ).to include( Hoodoo::Monkey::Patch::NewRelicTracedAMQP::InstanceExtensions )
+
+    original_do_amqp = Hoodoo::Client::Endpoint::AMQP.instance_method( :do_amqp )
+
+    # Count the number of times the AMQP endpoint's non-patched private
+    # "do_amqp" method is called. This calls through to the monkey patch
+    # under test, so we expect an equal number of calls to the NewRelic
+    # methods - *except* that "do_amqp" can deliberately raise an
+    # exception and there is test coverage for it. Thus, only increment
+    # the count if the call was successful - no exception raised.
+    #
+    allow_any_instance_of( Hoodoo::Client::Endpoint::AMQP ).to receive( :do_amqp ) do | instance, description_of_request |
+      result = original_do_amqp.bind( instance ).call( description_of_request )
+      @@endpoint_do_amqp_count += 1
+      result
+    end
+
+    allow( NewRelic::Agent::CrossAppTracing ).to receive( :tl_trace_http_request ) do | newrelic_request, &block |
+      @@newrelic_crossapp_count += 1
+
+      expect( newrelic_request ).to be_a( Hoodoo::Monkey::Patch::NewRelicTracedAMQP::AMQPNewRelicRequestWrapper )
+      block.call()
+    end
+
+    allow( NewRelic::Agent ).to receive( :disable_all_tracing ) do | &block |
+      @@newrelic_agent_disable_count += 1
+
+      result = block.call()
+      expect( result ).to be_a( Hoodoo::Monkey::Patch::NewRelicTracedAMQP::AMQPNewRelicResponseWrapper )
+      result
+    end
+  end
+
+  it_behaves_like 'an AMQP-based middleware/client endpoint'
+
+  context 'afterwards' do
+    it 'has non-zero NewRelic method call counts' do
+      expect( @@endpoint_do_amqp_count       ).to be > 5
+      expect( @@newrelic_crossapp_count      ).to eq( @@endpoint_do_amqp_count )
+      expect( @@newrelic_agent_disable_count ).to eq( @@endpoint_do_amqp_count )
+    end
+  end
+end
+
+describe Hoodoo::Monkey::Patch::NewRelicTracedAMQP::AMQPNewRelicRequestWrapper do
+  before :each do
+    @full_uri     = 'https://test.com:8080/1/Person/1234?_embed=Birthday'
+    @http_message = {
+      'scheme'  => 'http',
+      'verb'    => 'GET',
+
+      'host'    => 'test.com',
+      'port'    => '8080',
+      'path'    => '/1/Person/1234',
+      'query'   => { '_embed' => 'Birthday' },
+
+      'headers' => { 'CONTENT_TYPE' => 'application/json; charset=utf-8' },
+      'body'    => ''
+    }
+
+    @wrapper = described_class.new( @http_message, @full_uri )
+  end
+
+  it 'reports the correct "type" value' do
+    expect( @wrapper.type ).to eq( 'Hoodoo::Monkey::Patch::NewRelicTracedAMQP::AMQPNewRelicRequestWrapper' )
+  end
+
+  it 'reports the correct "host" value' do
+    expect( @wrapper.host ).to eq( @http_message[ 'host' ] )
+  end
+
+  it 'reports the correct "method" value' do
+    expect( @wrapper.method ).to eq( @http_message[ 'verb' ] )
+  end
+
+  it 'reports the correct "uri" value' do
+    expect( @wrapper.uri ).to eq( @full_uri )
+  end
+
+  it 'can read headers' do
+    expect( @wrapper[ 'CONTENT_TYPE' ] ).to eq( @http_message[ 'headers' ][ 'CONTENT_TYPE' ] )
+  end
+
+  it 'can write headers' do
+    @wrapper[ 'HTTP_X_FOO' ] = '23'
+    expect( @http_message[ 'headers' ][ 'HTTP_X_FOO' ] ).to eq( '23' )
+  end
+end
+
+describe Hoodoo::Monkey::Patch::NewRelicTracedAMQP::AMQPNewRelicResponseWrapper do
+
+  before :all do
+    module NewRelic
+      class Agent
+        class CrossAppTracing
+          NR_APPDATA_HEADER = 'X_Foo_AppData'
+        end
+      end
+    end
+  end
+
+  before :each do
+    @http_response = {
+      'headers'      => { NewRelic::Agent::CrossAppTracing::NR_APPDATA_HEADER => '4321' },
+      'CONTENT_TYPE' => 'application/json; charset=utf-8',
+      'HTTP_X_FOO'   => '46'
+    }
+
+    @wrapper = described_class.new( @http_response )
+  end
+
+  after :all do
+    Object.send( :remove_const, :NewRelic )
+  end
+
+  it 'accesses the NewRelic NR_APPDATA_HEADER correctly' do
+    expect( @wrapper[ NewRelic::Agent::CrossAppTracing::NR_APPDATA_HEADER ] ).to eq( @http_response[ 'headers' ][ NewRelic::Agent::CrossAppTracing::NR_APPDATA_HEADER ] )
+  end
+
+  it 'accesses other headers correctly' do
+    expect( @wrapper[ 'CONTENT_TYPE' ] ).to eq( @http_response[ 'CONTENT_TYPE' ] )
+    expect( @wrapper[ 'HTTP_X_FOO'   ] ).to eq( @http_response[ 'HTTP_X_FOO'   ] )
+  end
+end