hoodoo 1.0.2

data/spec/services/discovery/discovery_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Discovery do
+  context 'alone' do
+    it 'supports announcement directly' do
+      d = described_class.new
+      expect( d.announce( 'Foo', 3 ) ).to eq( nil )
+    end
+
+    # Note intentional mixed Symbol / String usage.
+
+    it 'records local announcements' do
+      d = described_class.new
+      expect( d.announce( 'Foo', 3 ) ).to eq( nil )
+      expect( d.is_local?( :Foo, 3 ) ).to eq( true )
+      expect( d.is_local?( 'Foo', 2 ) ).to eq( false )
+      expect( d.is_local?( 'Bar', 3 ) ).to eq( false )
+      expect( d.is_local?( 'Bar', 2 ) ).to eq( false )
+    end
+
+    it 'complains about missing subclass implementations' do
+      d = described_class.new
+      expect {
+        d.discover( 'Foo', 3 )
+      }.to raise_exception( RuntimeError, "Hoodoo::Services::Discovery::Base subclass does not implement remote discovery required for resource 'Foo' / version '3'" )
+    end
+  end
+
+  context 'when subclassed' do
+    class RSpecTestDiscoverer < described_class
+      def announce_remote( resource, version, options )
+        'announce'
+      end
+      def discover_remote( resource, version )
+        'discover'
+      end
+    end
+
+    it 'calls with configuration options' do
+      opts = { :foo => :bar, :bar => :baz }
+      expect_any_instance_of( RSpecTestDiscoverer ).to receive( :configure_with ).with( opts ).and_call_original
+      RSpecTestDiscoverer.new( opts )
+    end
+
+    it 'passes announcements on' do
+      opts = { :foo => :bar, :bar => :baz }
+      d = RSpecTestDiscoverer.new
+      expect( d ).to receive( :announce_remote ).with( :Foo, 3, opts ).and_call_original
+      expect( d.announce( :Foo, '3', opts ) ).to eq( 'announce' )
+      expect( d ).to receive( :announce_remote ).with( :Foo, 3, {} ).and_call_original
+      expect( d.announce( 'Foo', 3 ) ).to eq( 'announce' )
+      expect( d ).to receive( :announce_remote ).with( :Foo, 1, {} ).and_call_original
+      expect( d.announce( :Foo ) ).to eq( 'announce' )
+    end
+
+    it 'does not pass local discovery on' do
+      d = RSpecTestDiscoverer.new
+      d.announce( 'Baz', 4 )
+
+      expect( d ).to_not receive( :discover_remote )
+      expect( d.discover( :Baz, '4' ) ).to eq( 'announce' )
+    end
+
+    it 'passes remote discovery on' do
+      d = RSpecTestDiscoverer.new
+      d.announce( :Bar, 2 )
+      d.instance_variable_set( '@known_local_resources', {} ) # Hack for test!
+
+      expect( d ).to receive( :discover_remote ).with( :Bar, 2 ).and_call_original
+      expect( d.discover( 'Bar', 2 ) ).to eq( 'discover' )
+    end
+  end
+end

data/spec/services/discovery/results/for_amqp_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Discovery::ForAMQP do
+  it 'stores known quantities and retrieves them' do
+    r = described_class.new(
+      resource: 'Foo', # Note String
+      version: 3,
+      queue_name: 'queue.foo',
+      equivalent_path: '/v3/foos'
+    )
+
+    expect( r.resource        ).to eq( :Foo ) # Note Symbol
+    expect( r.version         ).to eq( 3 )
+    expect( r.queue_name      ).to eq( 'queue.foo' )
+    expect( r.equivalent_path ).to eq( '/v3/foos' )
+  end
+end

data/spec/services/discovery/results/for_http_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Discovery::ForHTTP do
+
+  let( :endpoint_uri ) { URI.parse( 'http://foo.bar/v1/foos' ) }
+  let( :proxy_uri    ) { URI.parse( 'http://bar.baz/v1/bars' ) }
+
+  it 'stores mandatory quantities and retrieves them' do
+    r = described_class.new(
+      resource: 'Foo', # Note String
+      version: 3,
+      endpoint_uri: endpoint_uri(),
+    )
+
+    expect( r.resource     ).to eq( :Foo ) # Note Symbol
+    expect( r.version      ).to eq( 3 )
+    expect( r.endpoint_uri ).to eq( endpoint_uri() )
+  end
+
+  it 'stores all known quantities and retrieves them' do
+    r = described_class.new(
+      resource: :Bar, # Note Symbol
+      version: 2,
+      endpoint_uri: endpoint_uri(),
+      proxy_uri: proxy_uri(),
+      ca_file: 'foo.pem',
+      http_timeout: 0.25
+    )
+
+    expect( r.resource     ).to eq( :Bar ) # Also Symbol
+    expect( r.version      ).to eq( 2 )
+    expect( r.endpoint_uri ).to eq( endpoint_uri() )
+    expect( r.proxy_uri    ).to eq( proxy_uri() )
+    expect( r.ca_file      ).to eq( 'foo.pem' )
+    expect( r.http_timeout ).to eq( 0.25 )
+  end
+end

data/spec/services/discovery/results/for_local_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Discovery::ForLocal do
+  it 'stores known quantities and retrieves them' do
+    r = described_class.new(
+      resource: 'Foo', # Note String
+      version: 3,
+      base_path: '/v3/foos',
+      routing_regexp: /\/v3\/foos.*/,
+      interface_class: Array, # Just any old class
+      implementation_instance: Array.new # Just any old comparable class instance
+    )
+
+    expect( r.resource                ).to eq( :Foo ) # Note Symbol
+    expect( r.version                 ).to eq( 3 )
+    expect( r.base_path               ).to eq( '/v3/foos' )
+    expect( r.routing_regexp          ).to eq( /\/v3\/foos.*/ )
+    expect( r.interface_class         ).to eq( Array )
+    expect( r.implementation_instance ).to eq( Array.new )
+  end
+end

data/spec/services/discovery/results/for_remote_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Discovery::ForRemote do
+  it 'stores known quantities and retrieves them' do
+    r = described_class.new(
+      resource: 'Foo', # Note String
+      version: 3,
+      wrapped_endpoint: Array.new # Just any old comparable class instance
+    )
+
+    expect( r.resource           ).to eq( :Foo ) # Note Symbol
+    expect( r.version            ).to eq( 3 )
+    expect( r.wrapped_endpoint   ).to eq( Array.new )
+  end
+end

data/spec/services/middleware/amqp_log_message_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper.rb'
+
+describe Hoodoo::Services::Middleware::AMQPLogMessage do
+
+  require 'msgpack'
+
+  let( :now ) do
+    Time.now
+  end
+
+  let( :source_hash ) do
+    {
+      :id => '1',
+      :level => 'info',
+      :component => 'RSpec',
+      :code => 'hello',
+
+      :data => { 'this' => 'that' },
+
+      :interaction_id => '3',
+      :caller_id => '2',
+      :identity => { :foo => '4', :bar => '5' }
+    }
+  end
+
+  let( :hash ) do
+    source_hash().merge( :reported_at => now() )
+  end
+
+  let( :compare_hash ) do
+    Hoodoo::Utilities.stringify(
+      source_hash().merge(
+        :reported_at => now().strftime( Hoodoo::Services::Middleware::AMQPLogMessage::TIME_FORMATTER )
+      )
+    )
+  end
+
+  it 'serializes' do
+    obj = described_class.new( hash )
+    expect( MessagePack.unpack( obj.serialize ) ).to eq( compare_hash )
+  end
+
+  it 'deserializes' do
+    obj = described_class.new( hash )
+    expect( MessagePack.unpack( obj.serialize ) ).to eq( compare_hash )
+    obj.id = nil # Clear some instance vars
+    obj.level = nil
+    obj.deserialize # Should reset instance vars based on prior serialization
+    expect( MessagePack.unpack( obj.serialize ) ).to eq( compare_hash )
+  end
+
+  it 'handles nil' do
+    local_compare_hash = Hoodoo::Utilities.stringify(
+      source_hash.merge( :reported_at => nil )
+    )
+
+    obj = described_class.new( source_hash )
+    expect( MessagePack.unpack( obj.serialize ) ).to eq( local_compare_hash )
+  end
+end

data/spec/services/middleware/amqp_log_writer_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper.rb'
+require 'timecop'
+
+describe Hoodoo::Services::Middleware::AMQPLogWriter do
+  before :each do
+    @session_id     = Hoodoo::UUID.generate
+    @caller_id      = Hoodoo::UUID.generate
+    @caller_version = 2
+    @session        = Hoodoo::Services::Session.new( {
+      :session_id     => @session_id,
+      :memcached_host => '0.0.0.0:0',
+      :caller_id      => @caller_id,
+      :caller_version => @caller_version
+    } )
+
+    @permissions_hash = {
+      'default' => {
+        'else' => 'deny',
+        'actions' => {
+          'show' => 'ask'
+        }
+      },
+      'resources' => {
+        'Clock' => {
+          'else' => 'allow',
+          'actions' => {
+            'show' => 'deny'
+          }
+         }
+       }
+     }
+
+    @session.permissions = Hoodoo::Services::Permissions.new( @permissions_hash )
+
+    @identity_id_1    = Hoodoo::UUID.generate
+    @identity_id_2    = Hoodoo::UUID.generate
+    @identity_id_3    = Hoodoo::UUID.generate
+
+    @authorised_ids   = [ Hoodoo::UUID.generate, Hoodoo::UUID.generate ]
+    @authorised_codes = [ 'CODE_A', 'CODE_B' ]
+
+    @session.identity = {
+      :id_1 => @identity_id_1,
+      :id_2 => @identity_id_2,
+      :id_3 => @identity_id_3,
+    }
+
+    @session.scoping = {
+      :authorised_ids   => @authorised_ids,
+      :authorised_codes => @authorised_codes
+    }
+
+    @alchemy = OpenStruct.new
+    @queue   = 'foo.bar'
+    @logger  = described_class.new( @alchemy, @queue )
+  end
+
+  it 'sends expected data' do
+    Timecop.freeze do
+      level          = 'warn'
+      component      = 'test_component'
+      code           = 'test_code'
+      reported_at    = Time.now
+      id             = Hoodoo::UUID.generate
+      interaction_id = Hoodoo::UUID.generate
+      data           = {
+        :id             => id,
+        :session        => @session.to_h(),
+        :interaction_id => interaction_id
+      }
+
+      expected_hash  = {
+        :id             => id,
+        :level          => 'warn',
+        :component      => component,
+        :code           => code,
+        :reported_at    => reported_at,
+
+        :data           => data,
+
+        :interaction_id => interaction_id,
+        :caller_id      => @session.caller_id,
+        :identity       => Hoodoo::Utilities.stringify( @session.identity.to_h ),
+
+        :routing_key    => @queue,
+      }
+
+      expect( Hoodoo::Services::Middleware::AMQPLogMessage ).to receive( :new ).with( expected_hash ).and_return( {} )
+      expect_any_instance_of( Hash ).to receive( :serialize ).once
+      expect( @alchemy ).to receive( :send_message ).with( {} ).once
+
+      @logger.report( level, component, code, data )
+    end
+  end
+end

data/spec/services/middleware/endpoints/inter_resource_local_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Middleware::InterResourceLocal do
+
+  # No tests here yet. Full coverage is achieved by other tests running
+  # through the HTTP and AMQP endpoints (amongst other stuff), since
+  # those inherit from this code.
+
+end

data/spec/services/middleware/endpoints/inter_resource_remote_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Middleware::InterResourceRemote do
+
+  # No tests here yet. Full coverage is achieved by other tests running
+  # through the HTTP and AMQP endpoints (amongst other stuff), since
+  # those inherit from this code.
+
+end

data/spec/services/middleware/exception_reporting/base_reporter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter do
+  class TestERBase < described_class
+  end
+
+  it 'is a singleton' do
+    expect( TestERBase.instance ).to be_a( TestERBase )
+  end
+
+  it 'provides a reporting example' do
+    expect {
+      TestERBase.instance.report( RuntimeError.new )
+    }.to raise_exception( RuntimeError )
+  end
+end

data/spec/services/middleware/exception_reporting/exception_reporting_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Middleware::ExceptionReporting do
+
+  class TestReporterA < Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter
+    def report( e, env = nil )
+      expectable_hook_a( e, env )
+      sleep 0.2 # Deliberate delay to make sure ::wait() works;
+                # intermittent failures would imply it doesn't.
+    end
+  end
+
+  class TestReporterB < Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter
+    def report( e, env = nil )
+      expectable_hook_b( e, env )
+    end
+  end
+
+  class TestReporterC < Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter
+    def report( e, env = nil )
+      raise 'I am broken'
+    end
+  end
+
+  after :each do
+    Hoodoo::Services::Middleware::ExceptionReporting.wait()
+    Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterA )
+    Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterB )
+    Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterC )
+  end
+
+  it 'lets me add and remove handlers' do
+    Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterA )
+    Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterB )
+    Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterA )
+    Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterB )
+  end
+
+  it 'calls handler A' do
+    Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterA )
+    ex = RuntimeError.new( 'A' )
+    ha = { :foo => :bar }
+    expect( TestReporterA.instance ).to receive( :expectable_hook_a ).once.with( ex, ha )
+    Hoodoo::Services::Middleware::ExceptionReporting.report( ex, ha )
+  end
+
+  it 'calls handler B' do
+    Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterB )
+    ex = RuntimeError.new( 'B' )
+    expect( TestReporterB.instance ).to receive( :expectable_hook_b ).once.with( ex, nil )
+    Hoodoo::Services::Middleware::ExceptionReporting.report( ex )
+  end
+
+  it 'calls all handlers' do
+    Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterA )
+    Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterB )
+
+    ex_one = RuntimeError.new( 'One' )
+    ex_two = RuntimeError.new( 'Two' )
+
+    expect( TestReporterA.instance ).to receive( :expectable_hook_a ).once.with( ex_one, nil )
+    expect( TestReporterB.instance ).to receive( :expectable_hook_b ).once.with( ex_one, nil )
+    expect( TestReporterA.instance ).to receive( :expectable_hook_a ).once.with( ex_two, nil )
+    expect( TestReporterB.instance ).to receive( :expectable_hook_b ).once.with( ex_two, nil )
+
+    Hoodoo::Services::Middleware::ExceptionReporting.report( ex_one, nil )
+    Hoodoo::Services::Middleware::ExceptionReporting.report( ex_two, nil )
+  end
+
+  it 'complains about bad additions' do
+    expect {
+      Hoodoo::Services::Middleware::ExceptionReporting.add( Object )
+    }.to raise_exception( RuntimeError )
+  end
+
+  it 'complains about bad removals' do
+    expect {
+      Hoodoo::Services::Middleware::ExceptionReporting.remove( Object )
+    }.to raise_exception( RuntimeError )
+  end
+
+  it 'ignores exceptions in reporters' do
+    Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterC ) # Add "exception raiser first
+    Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterA ) # Then this after, which should still be called
+
+    ex = RuntimeError.new( 'A' )
+    ha = { :foo => :bar }
+
+    expect( TestReporterA.instance ).to receive( :expectable_hook_a ).once.with( ex, ha )
+    Hoodoo::Services::Middleware::ExceptionReporting.report( ex, ha )
+  end
+end