hoodoo 1.0.2

data/spec/communicators/slow_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Hoodoo::Communicators::Slow do
+  it 'complains if #communicate is called directly' do
+    expect {
+      Hoodoo::Communicators::Slow.new.communicate( {} )
+    }.to raise_error( RuntimeError )
+  end
+
+  it 'does not complain if #dropped is called directly' do
+    expect {
+      Hoodoo::Communicators::Slow.new.dropped( 1 )
+    }.to_not raise_error()
+  end
+end

data/spec/data/resources/caller_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Resources::Caller do
+  it 'should match schema expectations' do
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(true)
+
+    expect(schema.properties.count).to eq(5)
+
+    expect(schema.properties['authentication_secret']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['name']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['identity']).to be_a(Hoodoo::Presenters::Hash)
+    expect(schema.properties['permissions']).to be_a(Hoodoo::Presenters::Object)
+    expect(schema.properties['permissions'].properties['resources']).to be_a(Hoodoo::Presenters::Hash)
+    expect(schema.properties['identity']).to be_a(Hoodoo::Presenters::Hash)
+  end
+
+  it 'should allow arbitrary identity values' do
+    result = described_class.validate(
+      {
+        "identity" => {
+          "array"   => [],
+          "integer" => 1,
+          "string"  => "thisisastring",
+          "object"  => { "key" => "value" }
+        },
+        "permissions" => {
+          "resources" => {}
+        },
+        "scoping" => {}
+      },
+      false
+    )
+
+    expect(result.errors).to eq([])
+  end
+
+  it 'should allow arbitrary scoping values' do
+    result = described_class.validate(
+      {
+        "identity" => {},
+        "permissions" => {
+          "resources" => {}
+        },
+        "scoping" => {
+          "array"   => [],
+          "integer" => 1,
+          "string"  => "thisisastring",
+          "object"  => { "key" => "value" }
+        }
+      },
+      false
+    )
+
+    expect(result.errors).to eq([])
+  end
+
+  it 'should be renderable with all data' do
+    id         = Hoodoo::UUID.generate
+    created_at = Time.now
+    json       = described_class.render(
+      {
+        "name"       => "Test Caller",
+        "identity"   => {
+          "array"   => [],
+          "integer" => 1,
+          "string"  => "thisisastring",
+          "object"  => { "key" => "value" }
+        },
+        "permissions" => {
+          "resources" => {
+            "Caller" => {
+              "else" => "allow"
+            },
+            "Member" => {
+              "actions" => {
+                "list" => "allow"
+              },
+              "else"    => "deny"
+            }
+          }
+        },
+        "scoping"    => {
+          "array"   => [],
+          "integer" => 1,
+          "string"  => "thisisastring",
+          "object"  => { "key" => "value" }
+        }
+      },
+      id,
+      created_at
+    )
+
+    expect(json).to eq(
+      {
+        'id'         => id,
+        'created_at' => created_at.utc.iso8601,
+        'kind'       => 'Caller',
+        "name"       => "Test Caller",
+        "identity"   => {
+          "array"   => [],
+          "integer" => 1,
+          "string"  => "thisisastring",
+          "object"  => { "key" => "value" }
+        },
+        "permissions" => {
+          "resources" => {
+            "Caller" => {
+              "else" => "allow"
+            },
+            "Member" => {
+              "actions" => {
+                "list" => "allow"
+              },
+              "else"    => "deny"
+            }
+          }
+        },
+        "scoping"    => {
+          "array"   => [],
+          "integer" => 1,
+          "string"  => "thisisastring",
+          "object"  => { "key" => "value" }
+        },
+        "language" => "en-nz"
+      }
+    )
+  end
+
+  it 'should be renderable with minimal data' do
+    id         = Hoodoo::UUID.generate
+    created_at = Time.now
+    json       = described_class.render(
+      {
+        "identity"    => {},
+        "permissions" => { "resources" => {} },
+        "scoping"     => {}
+      },
+      id,
+      created_at
+    )
+
+    expect(json).to eq(
+      {
+        'id'          => id,
+        'created_at'  => created_at.utc.iso8601,
+        'kind'        => 'Caller',
+        "identity"    => {},
+        "permissions" => { "resources" => {} },
+        "scoping"     => {},
+        "language"    => "en-nz"
+      }
+    )
+  end
+end

data/spec/data/resources/errors_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Resources::Errors do
+  it 'should match schema expectations' do
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(false)
+
+    expect(schema.properties.count).to eq(2)
+
+    expect(schema.properties['interaction_id']).to be_a(Hoodoo::Presenters::UUID)
+    expect(schema.properties['interaction_id'].required).to eq(false)
+
+    expect(schema.properties['errors']).to be_a(Hoodoo::Presenters::Array)
+    expect(schema.properties['errors'].required).to eq(true)
+
+    expect(schema.properties['errors'].properties.count).to eq(3)
+    expect(schema.properties['errors'].properties['code']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['errors'].properties['message']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['errors'].properties['reference']).to be_a(Hoodoo::Presenters::Text)
+  end
+end

data/spec/data/resources/log_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Resources::Log do
+  it 'should match schema expectations' do
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(false)
+    expect(schema.properties.count).to eq(5)
+
+    expect(schema.properties['level']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['level'].required).to eq(true)
+    expect(schema.properties['component']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['component'].required).to eq(true)
+    expect(schema.properties['code']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['code'].required).to eq(true)
+
+    expect(schema.properties['interaction_id']).to be_a(Hoodoo::Presenters::UUID)
+    expect(schema.properties['data']).to be_a(Hoodoo::Presenters::Hash)
+  end
+end

data/spec/data/resources/session_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Resources::Session do
+  it 'should match schema expectations' do
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(false)
+
+    expect(schema.properties.count).to eq(2)
+
+    expect(schema.properties['caller_id']).to be_a(Hoodoo::Presenters::UUID)
+    expect(schema.properties['caller_id'].resource).to eq(:Caller)
+    expect(schema.properties['expires_at']).to be_a(Hoodoo::Presenters::DateTime)
+  end
+end

data/spec/data/types/error_primitive_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Types::ErrorPrimitive do
+  it 'should match schema expectations' do
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(false)
+
+    expect(schema.properties.count).to eq(3)
+
+    expect(schema.properties['code']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['message']).to be_a(Hoodoo::Presenters::Text)
+    expect(schema.properties['reference']).to be_a(Hoodoo::Presenters::Text)
+  end
+end

data/spec/data/types/permissions_defaults_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Types::PermissionsDefaults do
+  it 'should match schema expectations' do
+
+    # List of permitted policies
+    policies = ['allow', 'deny', 'ask']
+
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(false)
+
+    expect(schema.properties.count).to eq(1)
+
+    # Resources hash
+
+    expect(schema.properties['default']).to be_a(Hoodoo::Presenters::Object)
+    expect(schema.properties['default'].default).to eq({'else'=>'deny'})
+    expect(schema.properties['default'].properties.count).to eq(2)
+
+    expect(schema.properties['default'].properties['actions']).to be_a(Hoodoo::Presenters::Object)
+    expect(schema.properties['default'].properties['else']).to be_a(Hoodoo::Presenters::Enum)
+    expect(schema.properties['default'].properties['else'].from).to match_array(policies)
+  end
+end

data/spec/data/types/permissions_full_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Types::PermissionsFull do
+  it 'should match schema expectations' do
+
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(false)
+
+    expect(schema.properties.count).to eq(2)
+
+    # Resources hash
+    expect(schema.properties['resources']).to be_a(Hoodoo::Presenters::Hash)
+    expect(schema.properties['resources'].properties.count).to eq(2)
+
+    # Default hash
+    expect(schema.properties['default']).to be_a(Hoodoo::Presenters::Object)
+    expect(schema.properties['default'].properties.count).to eq(2)
+
+  end
+
+  it 'should accept a valid hash' do
+
+    errors = described_class.validate({
+      'resources' => {
+        'member' => {
+          'actions' => {
+            'list' => 'allow',
+            'show' => 'ask'
+          },
+          'else' => 'deny'
+        }
+      },
+      'default' => {
+        'actions' => {
+          'show' => 'allow'
+        },
+        'else' => 'deny'
+      }
+    })
+    expect(errors.has_errors?).to be_falsey
+
+  end
+end

data/spec/data/types/permissions_resources_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Types::PermissionsResources do
+  it 'should match schema expectations' do
+
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(false)
+
+    expect(schema.properties.count).to eq(1)
+
+    # Resources hash
+    expect(schema.properties['resources']).to be_a(Hoodoo::Presenters::Hash)
+    expect(schema.properties['resources'].properties.count).to eq(2)
+
+  end
+
+  it 'should accept a valid hash' do
+
+    errors = described_class.validate({
+      'resources' => {
+        'member' => {
+          'actions' => {
+            'list' => 'allow',
+            'show' => 'ask'
+          },
+          'else' => 'deny'
+        }
+      }
+    })
+    expect(errors.has_errors?).to be_falsey
+
+  end
+end

data/spec/data/types/permissions_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Hoodoo::Data::Types::Permissions do
+  it 'should match schema expectations' do
+
+    # List of permitted policies
+    policies = ['allow', 'deny', 'ask']
+
+    schema = described_class.get_schema()
+
+    expect(schema.is_internationalised?()).to eq(false)
+
+    expect(schema.properties.count).to eq(2)
+
+    # Resources hash
+
+    expect(schema.properties['actions']).to be_a(Hoodoo::Presenters::Object)
+    expect(schema.properties['actions'].properties.count).to eq(5)
+
+    expect(schema.properties['actions'].properties['show']).to be_a(Hoodoo::Presenters::Enum)
+    expect(schema.properties['actions'].properties['list']).to be_a(Hoodoo::Presenters::Enum)
+    expect(schema.properties['actions'].properties['create']).to be_a(Hoodoo::Presenters::Enum)
+    expect(schema.properties['actions'].properties['update']).to be_a(Hoodoo::Presenters::Enum)
+    expect(schema.properties['actions'].properties['delete']).to be_a(Hoodoo::Presenters::Enum)
+
+
+    expect(schema.properties['actions'].properties['show'].from).to match_array(policies)
+    expect(schema.properties['actions'].properties['list'].from).to match_array(policies)
+    expect(schema.properties['actions'].properties['create'].from).to match_array(policies)
+    expect(schema.properties['actions'].properties['update'].from).to match_array(policies)
+    expect(schema.properties['actions'].properties['delete'].from).to match_array(policies)
+
+    # Else enum
+    expect(schema.properties['else']).to be_a(Hoodoo::Presenters::Enum)
+    expect(schema.properties['else'].from).to match_array(policies)
+  end
+end

data/spec/errors/error_descriptions_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Hoodoo::ErrorDescriptions do
+
+  # Test that DSL exceptions are raised as expected
+
+  context 'incorrect definitions' do
+    it 'should complain about missing message' do
+      expect {
+        Hoodoo::ErrorDescriptions.new( :test_domain ) do
+          error 'http_123', 'status' => 123
+        end
+      }.to raise_error(RuntimeError, "Error description options hash missing required key 'message'")
+    end
+
+    it 'should complain about missing status' do
+      expect {
+        Hoodoo::ErrorDescriptions.new( :test_domain ) do
+          error 'http_123', 'message' => 'hello world'
+        end
+      }.to raise_error(RuntimeError, "Error description options hash missing required key 'status'")
+    end
+  end
+
+  # Test that a correctly called DSL leads to the Right Things happening when
+  # called from the constructor.
+
+  context 'correct definitions' do
+    describe '#describe' do
+      it 'should report correct custom definitions' do
+        desc = Hoodoo::ErrorDescriptions.new( :test_domain ) do
+          error 'http_234_no_references',  'status' => 234, :message => '234 message'
+          error 'http_345_has_reference',  :status => 345, 'message' => '345 message', 'reference' => [ :ref1 ]
+          error 'http_456_has_references', 'status' => 456, 'message' => '456 message', :reference => [ :ref2, :ref3, :ref4 ]
+        end
+
+        expect(desc.describe('test_domain.http_234_no_references')).to eq('status' => 234, 'message' => '234 message')
+        expect(desc.describe('test_domain.http_345_has_reference')).to eq('status' => 345, 'message' => '345 message', 'reference' => [ 'ref1' ])
+        expect(desc.describe('test_domain.http_456_has_references')).to eq('status' => 456, 'message' => '456 message', 'reference' => [ 'ref2', 'ref3', 'ref4' ])
+      end
+    end
+  end
+
+  # Test that a correctly called DSL leads to the Right Things happening when
+  # called from outside the constructor.
+
+  context 'correct definitions' do
+    before do
+      @desc = Hoodoo::ErrorDescriptions.new
+      @desc.errors_for( :test_domain ) do
+        error 'http_345_no_references',  'status' => 345, 'message' => '345 message'
+        error 'http_456_has_reference',  'status' => 456, 'message' => '456 message', 'reference' => [ :ref1 ]
+        error 'http_567_has_references', 'status' => 567, 'message' => '567 message', 'reference' => [ :ref2, :ref3, :ref4 ]
+      end
+    end
+
+    # * Check errors are defined as expected by examining schema
+    # * Check HTTP code & default messages
+    # * Check HTTP code & custom messages
+    # * Test exceptions for missing reference and references
+    # * Test adding a reference, or many references, with commans
+    # * Test adding extra reference data (appears at end)
+
+    describe '#describe' do
+      it 'should describe some default definitions' do
+        expect(@desc.describe('platform.malformed')).to_not be_nil
+        expect(@desc.describe('generic.malformed')).to_not be_nil
+      end
+
+      it 'should report correct custom definitions' do
+        expect(@desc.describe('test_domain.http_345_no_references')).to eq('status' => 345, 'message' => '345 message')
+        expect(@desc.describe('test_domain.http_456_has_reference')).to eq('status' => 456, 'message' => '456 message', 'reference' => [ 'ref1' ])
+        expect(@desc.describe('test_domain.http_567_has_references')).to eq('status' => 567, 'message' => '567 message', 'reference' => [ 'ref2', 'ref3', 'ref4' ])
+        expect(@desc.describe('test_domain.invalid')).to be_nil
+      end
+    end
+
+    describe '#recognised?' do
+      it 'should recognise default definitions' do
+        expect(@desc.recognised?('platform.malformed')).to eq(true)
+        expect(@desc.recognised?('generic.malformed')).to eq(true)
+      end
+
+      it 'should recognise custom definitions' do
+        expect(@desc.recognised?('test_domain.http_345_no_references')).to eq(true)
+        expect(@desc.recognised?('test_domain.http_456_has_reference')).to eq(true)
+        expect(@desc.recognised?('test_domain.http_567_has_references')).to eq(true)
+      end
+
+      it 'should not recognise invalid definitions' do
+        expect(@desc.recognised?('platform.invalid')).to eq(false)
+        expect(@desc.recognised?('generic.invalid')).to eq(false)
+        expect(@desc.recognised?('test_domain.invalid')).to eq(false)
+        expect(@desc.recognised?('invalid.malformed')).to eq(false)
+      end
+    end
+  end
+end