hoodoo 1.0.2

data/spec/services/middleware/string_inquirer_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper.rb'
+
+describe Hoodoo::StringInquirer do
+  it 'should define implicit methods ending in "?"' do
+    greeting = Hoodoo::StringInquirer.new( 'hello' )
+    expect(greeting.hello?()).to eq(true)
+    expect(greeting.hi?()).to eq(false)
+  end
+
+  it 'should not define implicit methods that do not end in "?"' do
+    greeting = Hoodoo::StringInquirer.new( 'hello' )
+    expect {
+      greeting.hello()
+    }.to raise_error(NoMethodError)
+  end
+
+  # The above tests don't cause proper coverage according to RCov, so force
+  # the issue...
+  #
+  context 'poke private API for code coverage' do
+    it 'should sigh quietly to itself' do
+      greeting = Hoodoo::StringInquirer.new( 'hello' )
+      expect(greeting.send(:respond_to_missing?, :hello?, false)).to eq(true)
+      expect(greeting.send(:method_missing, :hello?)).to eq(true)
+      expect {
+        greeting.send(:method_missing, :hello)
+      }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/services/services/application_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+class RSpecTestImplementationA < Hoodoo::Services::Implementation
+end
+
+class RSpecTestImplementationB < Hoodoo::Services::Implementation
+end
+
+class RSpecTestInterfaceA < Hoodoo::Services::Interface
+  interface :RSpecTestResource do
+    endpoint :rspec_test_application_a, RSpecTestImplementationA
+  end
+end
+
+class RSpecTestInterfaceB < Hoodoo::Services::Interface
+  interface :RSpecTestResource do
+    endpoint :rspec_test_application_b, RSpecTestImplementationA
+  end
+end
+
+class RSpecTestService < Hoodoo::Services::Service
+end
+
+class RSpecTestService2 < Hoodoo::Services::Service
+end
+
+describe Hoodoo::Services::Service do
+  it 'should complain about incorrect interface classes' do
+    expect {
+      RSpecTestService.comprised_of( Hash )
+    }.to raise_error(RuntimeError, "Hoodoo::Services::Implementation::comprised_of expects Hoodoo::Services::Interface subclasses only - got 'Hash'")
+
+    expect {
+      RSpecTestService.comprised_of( Hoodoo::Services::Interface )
+    }.to raise_error(RuntimeError, "Hoodoo::Services::Implementation::comprised_of expects Hoodoo::Services::Interface subclasses only - got 'Hoodoo::Services::Interface'")
+  end
+
+  it 'should complain if called directly' do
+    expect {
+      RSpecTestService.new.call( nil )
+    }.to raise_error(RuntimeError, "Hoodoo::Services::Implementation subclasses should only be called through the middleware - add 'use Hoodoo::Services::Middleware' to (e.g.) config.ru")
+  end
+
+  it 'should correctly report its component classes' do
+    RSpecTestService.comprised_of( RSpecTestInterfaceA,
+                                              RSpecTestInterfaceB )
+
+    expect(RSpecTestService.component_interfaces).to eq([
+      RSpecTestInterfaceA,
+      RSpecTestInterfaceB
+    ])
+
+    expect(RSpecTestService.new.component_interfaces).to eq([
+      RSpecTestInterfaceA,
+      RSpecTestInterfaceB
+    ])
+  end
+
+  it 'allows multiple calls to declare component classes and removes duplicates' do
+    RSpecTestService2.comprised_of( RSpecTestInterfaceB )
+    RSpecTestService2.comprised_of( RSpecTestInterfaceA )
+    RSpecTestService2.comprised_of( RSpecTestInterfaceB )
+
+    expect(RSpecTestService2.component_interfaces).to eq([
+      RSpecTestInterfaceB,
+      RSpecTestInterfaceA
+    ])
+
+    expect(RSpecTestService2.new.component_interfaces).to eq([
+      RSpecTestInterfaceB,
+      RSpecTestInterfaceA
+    ])
+  end
+end

data/spec/services/services/context_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class RSpecTestContextImplementation < Hoodoo::Services::Implementation
+end
+
+class RSpecTestContextInterface < Hoodoo::Services::Interface
+  interface :RSpecTestResource do
+    endpoint :rspec_test_service_stub, RSpecTestContextImplementation
+  end
+end
+
+class RSpecTestContext < Hoodoo::Services::Service
+  comprised_of RSpecTestContextInterface
+end
+
+describe Hoodoo::Services::Context do
+
+  it 'should initialise correctly' do
+    ses = Hoodoo::Services::Session.new
+    req = Hoodoo::Services::Request.new
+    res = Hoodoo::Services::Response.new( Hoodoo::UUID.generate() )
+    mid = Hoodoo::Services::Middleware.new( RSpecTestContext.new )
+    int = Hoodoo::Services::Middleware::Interaction.new( {}, mid )
+
+    con = Hoodoo::Services::Context.new( ses, req, res, int )
+
+    expect(con.session).to eq(ses)
+    expect(con.request).to eq(req)
+    expect(con.response).to eq(res)
+    expect(con.owning_interaction).to eq(int)
+  end
+
+  it 'should report endpoints' do
+    ses = Hoodoo::Services::Session.new
+    req = Hoodoo::Services::Request.new
+    res = Hoodoo::Services::Response.new( Hoodoo::UUID.generate() )
+    mid = Hoodoo::Services::Middleware.new( RSpecTestContext.new )
+    int = Hoodoo::Services::Middleware::Interaction.new( {}, mid )
+
+    con = Hoodoo::Services::Context.new( ses, req, res, int )
+
+    expect(con.resource(:RSpecTestResource)).to be_a( Hoodoo::Services::Middleware::InterResourceLocal )
+    expect(con.resource(:RSpecTestResource).instance_variable_get( '@discovery_result' ) ).to be_a( Hoodoo::Services::Discovery::ForLocal )
+    expect(con.resource(:RSpecTestResource).instance_variable_get( '@discovery_result' ) .interface_class).to eq( RSpecTestContextInterface )
+    expect(con.resource(:AnotherResource)).to be_a( Hoodoo::Services::Middleware::InterResourceRemote )
+    expect(con.resource(:AnotherResource).instance_variable_get( '@discovery_result' ) ).to be_a( Hoodoo::Services::Discovery::ForRemote )
+  end
+end

data/spec/services/services/implementation_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class RSpecTestImplementationImplementation < Hoodoo::Services::Implementation
+end
+
+class RSpecTestImplementationInterface < Hoodoo::Services::Interface
+  interface :RSpecTestResource do
+    endpoint :rspec_test_service_stub, RSpecTestImplementationImplementation
+  end
+end
+
+class RSpecTestImplementation < Hoodoo::Services::Service
+  comprised_of RSpecTestImplementationInterface
+end
+
+describe Hoodoo::Services::Implementation do
+  it 'should raise base class exceptions' do
+    mid = Hoodoo::Services::Middleware.new( RSpecTestImplementation.new )
+    int = Hoodoo::Services::Middleware::Interaction.new( {}, mid )
+    con = int.context
+    imp = Hoodoo::Services::Implementation.new
+
+    expect {
+      imp.list( con )
+    }.to raise_error(RuntimeError, "Hoodoo::Services::Implementation subclasses must implement 'list'")
+
+    expect {
+      imp.show( con )
+    }.to raise_error(RuntimeError, "Hoodoo::Services::Implementation subclasses must implement 'show'")
+
+    expect {
+      imp.create( con )
+    }.to raise_error(RuntimeError, "Hoodoo::Services::Implementation subclasses must implement 'create'")
+
+    expect {
+      imp.update( con )
+    }.to raise_error(RuntimeError, "Hoodoo::Services::Implementation subclasses must implement 'update'")
+
+    expect {
+      imp.delete( con )
+    }.to raise_error(RuntimeError, "Hoodoo::Services::Implementation subclasses must implement 'delete'")
+
+    expect( imp.verify( con, :show ) ).to eq( Hoodoo::Services::Permissions::DENY )
+  end
+end

data/spec/services/services/interface_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+class RSpecTestInterfaceImplementationA < Hoodoo::Services::Implementation
+end
+
+class RSpecTestInterfaceImplementationB < Hoodoo::Services::Implementation
+end
+
+class RSpecTestInterfaceInterfaceA < Hoodoo::Services::Interface
+  interface 'RSpecTestInterfaceAResource' do
+    version 42
+    endpoint :rspec_test_interface_a, RSpecTestInterfaceImplementationA
+    actions :show, :create, :delete
+    embeds :embed_one, :embed_two, :embed_three
+
+    to_list do
+      limit  25
+      sort   :sort_one => [ :left, :right ], default( :sort_two ) => [ :up, :down ]
+      search :search_one, :search_two, :search_three
+      filter :filter_one, :filter_two, :filter_three
+    end
+
+    to_create do
+      text :foo
+      enum :bar, :from => [ 'baz', :boo ]
+    end
+
+    to_update do
+      text :hello
+      uuid :world, :resource => :Earth
+    end
+
+    errors_for 'transaction' do
+      error 'duplicate_transaction', status: 409, message: 'Duplicate transaction', :required => [ :client_uid ]
+    end
+  end
+end
+
+class RSpecTestInterfaceInterfaceB < Hoodoo::Services::Interface
+  interface :RSpecTestInterfaceBResource do
+    endpoint :rspec_test_interface_b, RSpecTestInterfaceImplementationB
+
+    to_create do
+      text :one
+      text :two, :required => true
+    end
+
+    update_same_as_create
+  end
+end
+
+class RSpecTestInterfaceInterfaceDefault < Hoodoo::Services::Interface
+  interface :RSpecTestInterfaceDefaultResource do
+    endpoint :rspec_test_interface_default, RSpecTestInterfaceImplementationA # (sic.)
+  end
+end
+
+describe Hoodoo::Services::Interface do
+
+  context 'DSL test classes' do
+
+    it 'acquires defaults' do
+      expect(RSpecTestInterfaceInterfaceDefault.version).to eq(1)
+      expect(RSpecTestInterfaceInterfaceDefault.endpoint).to eq(:rspec_test_interface_default)
+      expect(RSpecTestInterfaceInterfaceDefault.resource).to be_a(Symbol)
+      expect(RSpecTestInterfaceInterfaceDefault.resource).to eq(:RSpecTestInterfaceDefaultResource)
+      expect(RSpecTestInterfaceInterfaceDefault.implementation).to eq(RSpecTestInterfaceImplementationA)
+      expect(RSpecTestInterfaceInterfaceDefault.actions).to eq(Set.new([:list, :show, :create, :update, :delete]))
+      expect(RSpecTestInterfaceInterfaceDefault.public_actions).to be_empty
+      expect(RSpecTestInterfaceInterfaceDefault.embeds).to be_empty
+      expect(RSpecTestInterfaceInterfaceDefault.to_list.limit).to eq(50)
+      expect(RSpecTestInterfaceInterfaceDefault.to_list.sort).to eq({'created_at' => Set.new(['desc', 'asc'])})
+      expect(RSpecTestInterfaceInterfaceDefault.to_list.default_sort_key).to eq('created_at')
+      expect(RSpecTestInterfaceInterfaceDefault.to_list.default_sort_direction).to eq('desc')
+      expect(RSpecTestInterfaceInterfaceDefault.to_list.search).to be_empty
+      expect(RSpecTestInterfaceInterfaceDefault.to_list.filter).to be_empty
+      expect(RSpecTestInterfaceInterfaceDefault.to_create).to be_nil
+      expect(RSpecTestInterfaceInterfaceDefault.to_update).to be_nil
+    end
+
+    # This is checking most of the DSL in non-error call cases
+    #
+    it 'should be correctly configured (A)' do
+      expect(RSpecTestInterfaceInterfaceA.version).to eq(42)
+      expect(RSpecTestInterfaceInterfaceA.endpoint).to eq(:rspec_test_interface_a)
+      expect(RSpecTestInterfaceInterfaceA.resource).to be_a(Symbol)
+      expect(RSpecTestInterfaceInterfaceA.resource).to eq(:RSpecTestInterfaceAResource)
+      expect(RSpecTestInterfaceInterfaceA.implementation).to eq(RSpecTestInterfaceImplementationA)
+      expect(RSpecTestInterfaceInterfaceA.actions).to eq(Set.new([:show, :create, :delete]))
+      expect(RSpecTestInterfaceInterfaceA.embeds).to eq(['embed_one', 'embed_two', 'embed_three'])
+      expect(RSpecTestInterfaceInterfaceA.to_list.limit).to eq(25)
+      expect(RSpecTestInterfaceInterfaceA.to_list.sort).to eq({'created_at'=>Set.new(['desc', 'asc']), 'sort_one' => Set.new(['left', 'right']), 'sort_two' => Set.new(['up', 'down'])})
+      expect(RSpecTestInterfaceInterfaceA.to_list.default_sort_key).to eq('sort_two')
+      expect(RSpecTestInterfaceInterfaceA.to_list.default_sort_direction).to eq('up')
+      expect(RSpecTestInterfaceInterfaceA.to_list.search).to eq(['search_one', 'search_two', 'search_three'])
+      expect(RSpecTestInterfaceInterfaceA.to_list.filter).to eq(['filter_one', 'filter_two', 'filter_three'])
+      expect(RSpecTestInterfaceInterfaceA.to_create).to_not be_nil
+      expect(RSpecTestInterfaceInterfaceA.to_create.get_schema().properties['foo']).to be_a(Hoodoo::Presenters::Text)
+      expect(RSpecTestInterfaceInterfaceA.to_create.get_schema().properties['bar']).to be_a(Hoodoo::Presenters::Enum)
+      expect(RSpecTestInterfaceInterfaceA.to_create.get_schema().properties['bar'].from).to eq(["baz", "boo"])
+      expect(RSpecTestInterfaceInterfaceA.to_update.get_schema().properties['hello']).to be_a(Hoodoo::Presenters::Text)
+      expect(RSpecTestInterfaceInterfaceA.to_update.get_schema().properties['world']).to be_a(Hoodoo::Presenters::UUID)
+      expect(RSpecTestInterfaceInterfaceA.to_update.get_schema().properties['world'].resource).to eq(:Earth)
+      expect(RSpecTestInterfaceInterfaceA.errors_for.describe('transaction.duplicate_transaction')).to eq({'status' => 409, 'message' => 'Duplicate transaction', 'required' => [ :client_uid ]})
+    end
+
+    it 'should be correctly configured (B)' do
+
+      # Check that to_create has 'required' fields present.
+      #
+      expect(RSpecTestInterfaceInterfaceB.to_create).to_not be_nil
+      expect(RSpecTestInterfaceInterfaceB.to_create.get_schema().properties['two'].required).to be(true)
+
+      # Test #update_same_as_create.
+      #
+      expect(RSpecTestInterfaceInterfaceB.to_update).to_not be_nil
+      expect(RSpecTestInterfaceInterfaceB.to_update.get_schema().properties['one']).to be_a(Hoodoo::Presenters::Text)
+      expect(RSpecTestInterfaceInterfaceB.to_update.get_schema().properties['two']).to be_a(Hoodoo::Presenters::Text)
+
+      # Tests both to_update / update_same_as_create not having 'required'
+      # fields enforced.
+      #
+      expect(RSpecTestInterfaceInterfaceB.to_update.get_schema().properties['two'].required).to be(false)
+    end
+  end
+
+  context 'DSL errors' do
+    it 'should complain about interface redefinition' do
+      expect {
+        RSpecTestInterfaceInterfaceB.interface :FooB do
+        end
+      }.to raise_error(RuntimeError, 'Hoodoo::Services::Interface subclass unexpectedly ran ::interface more than once')
+    end
+
+    it 'should complain about no endpoint' do
+      class RSpecTestInterfaceInterfaceC < Hoodoo::Services::Interface
+      end
+
+      expect {
+        RSpecTestInterfaceInterfaceC.interface :FooC do
+        end
+      }.to raise_error(RuntimeError, "Hoodoo::Services::Interface subclasses must always call the 'endpoint' DSL method in their interface descriptions")
+    end
+
+    it 'should complain about incorrect implementation classes' do
+      class RSpecTestInterfaceInterfaceD < Hoodoo::Services::Interface
+      end
+
+      expect {
+        RSpecTestInterfaceInterfaceD.interface :FooD do
+          endpoint :an_endpoint, Hoodoo::Services::Implementation # Not a *subclass*, so just as invalid as some other unrelated Class
+        end
+      }.to raise_error(RuntimeError, "Hoodoo::Services::Interface#endpoint must provide Hoodoo::Services::Implementation subclasses, but 'Hoodoo::Services::Implementation' was given instead")
+    end
+
+    context 'in #action' do
+      it 'should complain about incorrect actions' do
+        class RSpecTestInterfaceImplementationE < Hoodoo::Services::Implementation
+        end
+        class RSpecTestInterfaceInterfaceE < Hoodoo::Services::Interface
+        end
+
+        expect {
+          RSpecTestInterfaceInterfaceE.interface :FooE do
+            endpoint :an_endpoint, RSpecTestInterfaceImplementationE
+            actions :create, :made_this_up, :delete, :made_this_up_too
+          end
+        }.to raise_error(RuntimeError, "Hoodoo::Services::Interface#actions does not recognise one or more actions: 'made_this_up, made_this_up_too'")
+      end
+    end
+
+    context 'in #public_action' do
+      it 'should complain about incorrect actions' do
+        class RSpecTestInterfaceImplementationF < Hoodoo::Services::Implementation
+        end
+        class RSpecTestInterfaceInterfaceF < Hoodoo::Services::Interface
+        end
+
+        expect {
+          RSpecTestInterfaceInterfaceF.interface :FooF do
+            endpoint :an_endpoint, RSpecTestInterfaceImplementationF
+            public_actions :create, :made_this_up, :delete, :made_this_up_too
+          end
+        }.to raise_error(RuntimeError, "Hoodoo::Services::Interface#public_actions does not recognise one or more actions: 'made_this_up, made_this_up_too'")
+      end
+    end
+
+    context 'in #public_action' do
+      it 'should complain about incorrect actions' do
+        class RSpecTestInterfaceImplementationG < Hoodoo::Services::Implementation
+        end
+        class RSpecTestInterfaceInterfaceG < Hoodoo::Services::Interface
+        end
+
+        expect {
+          RSpecTestInterfaceInterfaceG.interface :FooG do
+            endpoint :an_endpoint, RSpecTestInterfaceImplementationG
+            secure_log_for :create => :both, :made_this_up => :request, :delete => :response, :made_this_up_too => :both
+          end
+        }.to raise_error(RuntimeError, "Hoodoo::Services::Interface#secure_log_for does not recognise one or more actions: 'made_this_up, made_this_up_too'")
+      end
+    end
+
+    # This is exercised in non-failure cases by
+    # middleware_permissions_spec.rb.
+    #
+    context 'in #additional_permissions_for' do
+      it 'should complain about a missing block' do
+        class RSpecTestInterfaceImplementationH < Hoodoo::Services::Implementation
+        end
+        class RSpecTestInterfaceInterfaceH < Hoodoo::Services::Interface
+        end
+
+        expect {
+          RSpecTestInterfaceInterfaceH.interface :FooH do
+            endpoint :an_endpoint, RSpecTestInterfaceImplementationH
+            additional_permissions_for( :show )
+          end
+        }.to raise_error(RuntimeError, 'Hoodoo::Services::Interface#additional_permissions_for must be passed a block')
+      end
+    end
+
+    # This is really an internal sanity test for code coverage purposes...
+    #
+    it 'should complain about incorrect instantiation' do
+      expect {
+        Hoodoo::Services::Interface::ToListDSL.new( Array.new ) do
+        end
+      }.to raise_error(RuntimeError, "Hoodoo::Services::Interface::ToListDSL\#initialize requires a Hoodoo::Services::Interface::ToList instance - got 'Array'")
+    end
+
+    context 'in #limit' do
+      it 'should complain about incorrect types' do
+        expect {
+          Hoodoo::Services::Interface::ToListDSL.new( Hoodoo::Services::Interface::ToList.new ) do
+            limit "hello"
+          end
+        }.to raise_error(RuntimeError, "Hoodoo::Services::Interface::ToListDSL\#limit requires an Integer - got 'String'")
+      end
+    end
+
+    context 'in #sort' do
+      it 'should complain about incorrect types' do
+        expect {
+          Hoodoo::Services::Interface::ToListDSL.new( Hoodoo::Services::Interface::ToList.new ) do
+            sort "hello"
+          end
+        }.to raise_error(RuntimeError, "Hoodoo::Services::Interface::ToListDSL\#sort requires a Hash - got 'String'")
+      end
+    end
+
+    context 'in #default' do
+      it 'should complain about incorrect types' do
+        expect {
+          Hoodoo::Services::Interface::ToListDSL.new( Hoodoo::Services::Interface::ToList.new ) do
+            default 42
+          end
+        }.to raise_error(RuntimeError, "Hoodoo::Services::Interface::ToListDSL\#default requires a String or Symbol - got 'Fixnum'")
+      end
+    end
+  end
+end