hoodoo 1.0.2

data/spec/services/services/permissions_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Permissions do
+  it 'initialises with a "deny" default fallback' do
+    p = described_class.new
+
+    expect( p.to_h ).to eq({
+      'default' => { 'else' => described_class::DENY }
+    })
+  end
+
+  it 'sets default fallback' do
+    p = described_class.new
+
+    p.set_default_fallback( described_class::ALLOW )
+
+    expect( p.to_h ).to eq({
+      'default' => { 'else' => described_class::ALLOW }
+    })
+  end
+
+  it 'sets default actions' do
+    p = described_class.new
+
+    p.set_default( 'create', described_class::ALLOW )
+    p.set_default( 'update', described_class::ASK   )
+    p.set_default( 'delete', described_class::DENY  )
+
+    expect( p.to_h ).to eq({
+      'default' => {
+        'actions' => {
+          'create' => described_class::ALLOW,
+          'update' => described_class::ASK,
+          'delete' => described_class::DENY
+        },
+        'else' => described_class::DENY
+      }
+    })
+  end
+
+  it 'sets resource fallback' do
+    p = described_class.new
+
+    p.set_resource_fallback( :Foo, described_class::ALLOW )
+    p.set_resource_fallback( :Bar, described_class::ASK )
+
+    expect( p.to_h ).to eq({
+      'default' => {
+        'else' => described_class::DENY
+      },
+      'resources' => {
+        'Foo' => {
+          'else' => described_class::ALLOW
+        },
+        'Bar' => {
+          'else' => described_class::ASK
+        }
+      }
+    })
+  end
+
+  it 'set resource actions' do
+    p = described_class.new
+
+    p.set_resource( :Foo, 'create', described_class::ALLOW )
+    p.set_resource( :Foo, 'update', described_class::ASK   )
+
+    p.set_resource_fallback( :Foo, described_class::ALLOW )
+
+    p.set_resource( :Bar, 'show',   described_class::DENY  )
+    p.set_resource( :Bar, 'delete', described_class::ALLOW )
+
+    expect( p.to_h ).to eq({
+      'default' => {
+        'else' => described_class::DENY
+      },
+      'resources' => {
+        'Foo' => {
+          'actions' => {
+            'create' => described_class::ALLOW,
+            'update' => described_class::ASK
+          },
+          'else' => described_class::ALLOW
+        },
+        'Bar' => {
+          'actions' => {
+            'show' => described_class::DENY,
+            'delete' => described_class::ALLOW
+          }
+        }
+      }
+    })
+  end
+
+  context 'with a resource but no resource fallback' do
+    before :each do
+      @p = described_class.new
+
+      @p.set_default_fallback( described_class::ASK )
+
+      @p.set_resource( :Foo, 'create', described_class::ALLOW )
+      @p.set_resource( :Foo, 'update', described_class::ASK   )
+      @p.set_resource( :Foo, 'delete', described_class::DENY  )
+
+      @expected = {
+        'resources' => {
+          'Foo' => {
+            'actions' => {
+              'create' => described_class::ALLOW,
+              'update' => described_class::ASK,
+              'delete' => described_class::DENY
+            }
+          },
+        },
+        'default' => {
+          'else' => described_class::ASK
+        }
+      }
+    end
+
+    it 'can be used to initialise a new instance as a Hash' do
+      p = described_class.new( @p.to_h )
+      expect( p.to_h ).to eq( @expected )
+    end
+
+    it 'behaves correctly' do
+      expect( @p.permitted?( :Foo, :create ) ).to eq( described_class::ALLOW )
+      expect( @p.permitted?( :Foo, :show ) ).to eq( described_class::ASK )
+      expect( @p.permitted?( :Foo, :list ) ).to eq( described_class::ASK )
+      expect( @p.permitted?( :Foo, :update ) ).to eq( described_class::ASK )
+      expect( @p.permitted?( :Foo, :delete ) ).to eq( described_class::DENY )
+    end
+  end
+
+  context 'with permissions set' do
+    before :each do
+      @p = described_class.new
+
+      @p.set_default_fallback( described_class::DENY )
+
+      @p.set_default( 'create', described_class::ASK   )
+      @p.set_default( 'update', described_class::DENY  )
+      @p.set_default( 'delete', described_class::ALLOW )
+
+      @p.set_resource( :Foo, 'create', described_class::ALLOW )
+      @p.set_resource( :Foo, 'update', described_class::ASK   )
+      @p.set_resource( :Foo, 'delete', described_class::DENY  )
+
+      @p.set_resource_fallback( :Foo, described_class::ALLOW )
+
+      @expected = {
+        'resources' => {
+          'Foo' => {
+            'actions' => {
+              'create' => described_class::ALLOW,
+              'update' => described_class::ASK,
+              'delete' => described_class::DENY
+            },
+            'else' => described_class::ALLOW
+          },
+        },
+        'default' => {
+          'actions' => {
+            'create' => described_class::ASK,
+            'update' => described_class::DENY,
+            'delete' => described_class::ALLOW
+          },
+          'else' => described_class::DENY
+        }
+      }
+    end
+
+    it 'can be loaded into another instance as a Hash' do
+      p = described_class.new
+      p.from_h!( @p.to_h )
+      expect( p.to_h ).to eq( @expected )
+    end
+
+    it 'can be used to initialise a new instance as a Hash' do
+      p = described_class.new( @p.to_h )
+      expect( p.to_h ).to eq( @expected )
+    end
+
+    it 'merges' do
+      p = described_class.new
+      p.set_resource_fallback( :Foo, described_class::ASK )
+      p.set_default( 'show', described_class::ALLOW )
+      p.set_default( 'update', described_class::ALLOW )
+      p.set_resource( :Bar, 'show', described_class::ALLOW )
+      @p.merge!( p.to_h )
+      expect( @p.to_h ).to eq( {
+        'resources' => {
+          'Foo' => {
+            'actions' => {
+              'create' => described_class::ALLOW,
+              'update' => described_class::ASK,
+              'delete' => described_class::DENY
+            },
+            'else' => described_class::ASK
+          },
+          'Bar' => {
+            'actions' => {
+              'show' => described_class::ALLOW
+            }
+          }
+        },
+        'default' => {
+          'actions' => {
+            'show'   => described_class::ALLOW,
+            'create' => described_class::ASK,
+            'update' => described_class::ALLOW,
+            'delete' => described_class::ALLOW
+          },
+          'else' => described_class::DENY
+        }
+      } )
+    end
+
+    it 'allows correctly' do
+      expect( @p.permitted?( :Foo, :create ) ).to eq( described_class::ALLOW )
+      expect( @p.permitted?( :Foo, :show ) ).to eq( described_class::ALLOW )
+      expect( @p.permitted?( :Foo, :list ) ).to eq( described_class::ALLOW )
+    end
+
+    it 'asks correctly' do
+      expect( @p.permitted?( :Foo, :update ) ).to eq( described_class::ASK )
+    end
+
+    it 'denies correctly' do
+      expect( @p.permitted?( :Foo, :delete ) ).to eq( described_class::DENY )
+    end
+
+    it 'action defaults work' do
+      expect( @p.permitted?( :Bar, :create ) ).to eq( described_class::ASK )
+      expect( @p.permitted?( :Bar, :update ) ).to eq( described_class::DENY )
+      expect( @p.permitted?( :Bar, :delete ) ).to eq( described_class::ALLOW )
+    end
+
+    it 'fallback default works' do
+      expect( @p.permitted?( :Bar, :show ) ).to eq( described_class::DENY )
+      expect( @p.permitted?( :Bar, :list ) ).to eq( described_class::DENY )
+    end
+
+    it 'empty hashes deny' do
+      @p.from_h!( {} )
+      expect( @p.permitted?( :Bar, :show ) ).to eq( described_class::DENY )
+    end
+  end
+end

data/spec/services/services/request_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Request do
+  context 'uri_path_components' do
+    before do
+      @r = Hoodoo::Services::Request.new
+    end
+
+    it 'should record path components properly' do
+      ary = [ 'one', 'two', 'three' ]
+      @r.uri_path_components = ary
+
+      expect(@r.uri_path_components).to eq(ary)
+      expect(@r.ident).to eq(ary.first)
+    end
+
+    it 'should deal with nil path components properly' do
+      ary = nil
+      @r.uri_path_components = ary
+
+      expect(@r.uri_path_components).to be_nil
+      expect(@r.ident).to be_nil
+    end
+
+    it 'should deal with non-array path components properly' do
+      ary = 'not an array'
+      @r.uri_path_components = ary
+
+      expect(@r.uri_path_components).to be_nil
+      expect(@r.ident).to be_nil
+    end
+
+    it 'rationalises date/time' do
+      [ :dated_at, :dated_from ].each do | attr |
+        now = DateTime.now
+        @r.send( "#{ attr }=", now )
+        expect( @r.send( attr ) ).to eq( now )
+
+        now = DateTime.now + 10
+        @r.send( "#{ attr }=", now.to_time )
+        expect( @r.send( attr ) ).to eq( now )
+
+        now = DateTime.now + 20
+        @r.send( "#{ attr }=", Hoodoo::Utilities::nanosecond_iso8601( now ) )
+        expect( @r.send( attr ) ).to eq( now )
+      end
+    end
+
+    it 'has correct default values' do
+      expect( @r.locale              ).to eq( 'en-nz'                    )
+      expect( @r.dated_at            ).to eq( nil                        )
+      expect( @r.body                ).to eq( nil                        )
+      expect( @r.uri_path_components ).to eq( []                         )
+      expect( @r.ident               ).to eq( nil                        )
+      expect( @r.uri_path_extension  ).to eq( ''                         )
+      expect( @r.list.offset         ).to eq( 0                          )
+      expect( @r.list.limit          ).to eq( 50                         )
+      expect( @r.list_sort_data      ).to eq( { 'created_at' => 'desc' } )
+      expect( @r.list.search_data    ).to eq( {}                         )
+      expect( @r.list.filter_data    ).to eq( {}                         )
+      expect( @r.embeds              ).to eq( []                         )
+      expect( @r.references          ).to eq( []                         )
+      expect( @r.headers             ).to eq( {}                         )
+
+      expect( @r.headers.frozen? ).to eq( true )
+    end
+
+    it 'supports deprecated accessors' do
+      expect( @r.list_offset         ).to eq( 0                          )
+      expect( @r.list_limit          ).to eq( 50                         )
+      expect( @r.list_sort_data      ).to eq( { 'created_at' => 'desc' } )
+      expect( @r.list_search_data    ).to eq( {}                         )
+      expect( @r.list_filter_data    ).to eq( {}                         )
+
+      lo = 10
+      ll = 20
+      ke = 'foo'
+      di = 'asc'
+      sd = { :foo => :bar }
+      fd = { :baz => :foo }
+
+      @r.list_offset         = lo
+      @r.list_limit          = ll
+      @r.list_sort_data      = { ke => di }
+      @r.list_search_data    = sd
+      @r.list_filter_data    = fd
+
+      expect( @r.list_offset         ).to eq( lo           )
+      expect( @r.list_limit          ).to eq( ll           )
+      expect( @r.list_sort_data      ).to eq( { ke => di } )
+      expect( @r.list_search_data    ).to eq( sd           )
+      expect( @r.list_filter_data    ).to eq( fd           )
+    end
+  end
+end

data/spec/services/services/response_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Response do
+  before :each do
+    @r = Hoodoo::Services::Response.new( Hoodoo::UUID.generate() )
+  end
+
+  it 'should acquire the expected default values when instantiated' do
+    expect(@r.errors).to be_a(Hoodoo::Errors)
+    expect(@r.errors.has_errors?).to eq(false)
+    expect(@r.http_status_code).to eq(200)
+    expect(@r.body).to eq({})
+    expect(@r.instance_variable_get('@headers')).to eq({})
+  end
+
+  context 'instantiation' do
+    it 'rejects a nil interaction ID' do
+      expect {
+        Hoodoo::Services::Response.new( nil )
+      }.to raise_error( RuntimeError, "Hoodoo::Services::Response.new must be given a valid Interaction ID (got 'nil')" )
+    end
+
+    it 'rejects a non-string interaction ID' do
+      expect {
+        Hoodoo::Services::Response.new( 12345 )
+      }.to raise_error( RuntimeError, "Hoodoo::Services::Response.new must be given a valid Interaction ID (got '12345')" )
+    end
+
+    it 'rejects an invalid string interaction ID' do
+      expect {
+        Hoodoo::Services::Response.new( 'hello' )
+      }.to raise_error( RuntimeError, "Hoodoo::Services::Response.new must be given a valid Interaction ID (got '\"hello\"')" )
+    end
+  end
+
+  context '#add_error and #halt_processing?' do
+    it 'should not say "halt" if there are no errors' do
+      expect(@r.errors.has_errors?).to eq(false)
+      expect(@r.halt_processing?).to eq(false)
+    end
+
+    it 'should say "halt" if there are errors' do
+      @r.add_error('platform.malformed')
+      expect(@r.errors.has_errors?).to eq(true)
+      expect(@r.halt_processing?).to eq(true)
+    end
+  end
+
+  context '#add_errors' do
+    it 'should merge errors (1)' do
+      e = Hoodoo::Errors.new
+      e.add_error( 'platform.malformed' )
+      e.add_error( 'generic.malformed' )
+
+      @r.add_error( 'platform.invalid_session' )
+      expect( @r.add_errors( e ) ).to eq( true )
+
+      expect(@r.errors.errors).to eq([
+        { 'code' => 'platform.invalid_session', 'message' => 'Invalid session'   },
+        { 'code' => 'platform.malformed',       'message' => 'Malformed request' },
+        { 'code' => 'generic.malformed',        'message' => 'Malformed payload' }
+      ])
+
+      # Should keep the HTTP status code from the first error added,
+      # which was the "invalid session" we added.
+
+      expect(@r.errors.http_status_code).to eq(401)
+    end
+
+    it 'should merge errors (2)' do
+      e = Hoodoo::Errors.new
+      e.add_error( 'platform.malformed' )
+      e.add_error( 'generic.malformed' )
+
+      expect( @r.add_errors( e ) ).to eq( true )
+      @r.add_error( 'platform.invalid_session' )
+
+      expect(@r.errors.errors).to eq([
+        { 'code' => 'platform.malformed',       'message' => 'Malformed request' },
+        { 'code' => 'generic.malformed',        'message' => 'Malformed payload' },
+        { 'code' => 'platform.invalid_session', 'message' => 'Invalid session'   }
+      ])
+
+      # Should keep the HTTP status code from the first error added,
+      # which was the "platform.malformed" from the merged set.
+
+      expect(@r.errors.http_status_code).to eq(422)
+    end
+
+    it 'should "merge" empty errors' do
+      e = Hoodoo::Errors.new
+
+      expect( @r.add_errors( e ) ).to eq( false )
+      @r.add_error( 'platform.invalid_session' )
+
+      expect(@r.errors.errors).to eq([
+        { 'code' => 'platform.invalid_session', 'message' => 'Invalid session' }
+      ])
+
+      # Should keep the HTTP status code from the first error added,
+      # which was the "platform.malformed" from the merged set.
+
+      expect(@r.errors.http_status_code).to eq(401)
+    end
+  end
+
+  context '#add_precompiled_error' do
+    it 'should let me add precompiled errors' do
+      expect {
+        @r.add_precompiled_error('test_domain.http_345_no_references 1', 'message 1', 'baz, foo 1')
+        @r.add_precompiled_error('test_domain.http_345_no_references 2', 'message 2', 'baz, foo 2')
+        @r.add_precompiled_error('test_domain.http_345_no_references 3', 'message 3', 'baz, foo 3')
+      }.to_not raise_error
+
+      expect(@r.errors.errors[0]).to eq({'code' => 'test_domain.http_345_no_references 1', 'message' => 'message 1', 'reference' => 'baz, foo 1'})
+      expect(@r.errors.errors[1]).to eq({'code' => 'test_domain.http_345_no_references 2', 'message' => 'message 2', 'reference' => 'baz, foo 2'})
+      expect(@r.errors.errors[2]).to eq({'code' => 'test_domain.http_345_no_references 3', 'message' => 'message 3', 'reference' => 'baz, foo 3'})
+    end
+  end
+
+  context '#add_header, #get_header and #headers' do
+    it 'should let me add headers' do
+      @r.add_header( 'X-Foo', 'baz' )
+      @r.add_header( 'X-Bar', 'boo' )
+
+      expect(@r.get_header('X-Foo')).to eq('baz')
+      expect(@r.get_header('X-FOO')).to eq('baz')
+      expect(@r.get_header('x-foo')).to eq('baz')
+      expect(@r.get_header('x-baR')).to eq('boo')
+      expect(@r.get_header('random')).to eq(nil)
+    end
+
+    it 'should list headers' do
+      @r.add_header( 'X-Foo', 'baz' )
+      @r.add_header( 'x-bar', 'boo' )
+      @r.add_header( 'X-BAZ', 'bin' )
+
+      expect(@r.headers).to eq({'X-Foo' => 'baz', 'x-bar' => 'boo', 'X-BAZ' => 'bin'})
+    end
+
+    it 'should complain if I try to set the same header twice without the overwrite flag set' do
+      @r.add_header( 'X-Foo', 'baz' )
+      expect {
+        @r.add_header( 'x-fOO', 'thing' )
+      }.to raise_error(RuntimeError, "Hoodoo::Services::Response\#add_header: Value 'baz' already defined for header 'X-Foo'")
+    end
+
+    it 'should allow me to overwrite a header value' do
+      @r.add_header( 'X-Foo', 'baz' )
+      @r.add_header( 'x-fOO', 'thing', true )
+      expect(@r.get_header('x-foo')).to eq('thing')
+    end
+  end
+
+  context '#for_rack' do
+
+    it 'should return default empty data correctly' do
+      status, headers, body = @r.for_rack
+
+      expected = JSON.generate({})
+      expect(status).to eq(200)
+      expect(headers).to eq({'Content-Length' => expected.length.to_s})
+      expect(body.body).to eq([expected])
+    end
+
+    it 'should return header data correctly' do
+      @r.add_header( 'X-Foo', :baz )
+      @r.add_header( :'X-Bar', 'boo' )
+
+      status, headers, body = @r.for_rack
+
+      expected = JSON.generate({})
+      expect(status).to eq(200)
+      expect(headers).to eq({'X-Foo' => 'baz', 'X-Bar' => 'boo', 'Content-Length' => expected.length.to_s})
+      expect(body.body).to eq([expected])
+    end
+
+    it 'should return error condition Rack data correctly' do
+      @r.add_error('platform.malformed') # 422 status
+      @r.add_error('platform.not_found', 'reference' => {:entity_name => 'hello'}) # 404 status
+
+      @r.body = { this: 'should be ignored' }
+
+      errors_hash = @r.errors.render(@r.instance_variable_get('@interaction_id'))
+      status, headers, body = @r.for_rack
+
+      expected = JSON.generate(errors_hash)
+      expect(status).to eq(422) # From the first error we stored, not the second
+      expect(headers).to eq({'Content-Length' => expected.length.to_s})
+      expect(body.body).to eq([expected])
+    end
+
+    it 'should return non-error condition Rack data correctly with a Hash body' do
+      response_hash = { this: 'should not be ignored' }
+      @r.body = response_hash
+
+      status, headers, body = @r.for_rack
+
+      expected = JSON.generate(response_hash)
+      expect(status).to eq(200) # From the first error we stored, not the second
+      expect(headers).to eq({'Content-Length' => expected.length.to_s})
+      expect(body.body).to eq([expected])
+    end
+
+    it 'should return non-error condition Rack data correctly with an Array body' do
+      response_array = [ { this: 'should not be ignored' }, { neither: 'should this' } ]
+      @r.body = response_array
+
+      status, headers, body = @r.for_rack
+
+      expected = JSON.generate({'_data' => response_array})
+      expect(status).to eq(200) # From the first error we stored, not the second
+      expect(headers).to eq({'Content-Length' => expected.length.to_s})
+      expect(body.body).to eq([expected])
+    end
+
+    it 'should allow pre-encoded strings in the body' do
+      @r.body = 'Hello World!'
+
+      status, headers, body = @r.for_rack
+
+      expect(status).to eq(200)
+      expect(body.body).to eq(['Hello World!'])
+    end
+
+    it 'should raise an exception when the body is in an unsupported format' do
+      @r.body = :foo
+
+      expect {
+        status, headers, body = @r.for_rack
+      }.to raise_error(RuntimeError, "Hoodoo::Services::Response\#for_rack given unrecognised body data class 'Symbol'")
+    end
+  end
+
+  context "#not_found" do
+
+    let(:ident) { 'an_ident' }
+    before { @r.not_found(ident) }
+
+    it 'sets the generic.not_found code' do
+      expect(@r.errors.errors.first['code']).to eq('generic.not_found')
+    end
+    it 'sets the the reference to be the ident passed in' do
+      expect(@r.errors.errors.first['reference']).to eq(ident)
+    end
+    it 'sets halt processing to true' do
+      expect(@r.halt_processing?).to eq(true)
+    end
+  end
+end