hoodoo 1.0.2

data/spec/presenters/types/integer_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Hoodoo::Presenters::Integer do
+
+  before do
+    @inst = Hoodoo::Presenters::Integer.new('one',:required => false)
+  end
+
+  describe '#validate' do
+    it 'should return [] when valid integer' do
+      expect(@inst.validate(12).errors).to eq([])
+    end
+
+    it 'should return correct error when data is not a integer' do
+      errors = @inst.validate('adskncasc')
+
+      err = [  {'code'=>"generic.invalid_integer", 'message'=>"Field `one` is an invalid integer", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should not return error when not required and absent' do
+      expect(@inst.validate(nil).errors).to eq([])
+    end
+
+    it 'should return error when required and absent' do
+      @inst.required = true
+      expect(@inst.validate(nil).errors).to eq([
+        {'code'=>"generic.required_field_missing", 'message'=>"Field `one` is required", 'reference'=>"one"}
+      ])
+    end
+
+    it 'should return correct error with non integer types' do
+      err = [  {'code'=>"generic.invalid_integer", 'message'=>"Field `one` is an invalid integer", 'reference'=>"one"}]
+
+      expect(@inst.validate('asckn').errors).to eq(err)
+      expect(@inst.validate(34534.234).errors).to eq(err)
+      expect(@inst.validate(true).errors).to eq(err)
+      expect(@inst.validate({}).errors).to eq(err)
+      expect(@inst.validate([]).errors).to eq(err)
+    end
+
+    it 'should return correct error with path' do
+      errors = @inst.validate('scdacs','ordinary')
+      expect(errors.errors).to eq([
+        {'code'=>"generic.invalid_integer", 'message'=>"Field `ordinary.one` is an invalid integer", 'reference'=>"ordinary.one"}
+      ])
+    end
+  end
+
+end

data/spec/presenters/types/object_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe Hoodoo::Presenters::Object do
+
+  before do
+    @inst = Hoodoo::Presenters::Object.new('one',:required => false)
+
+    class TestPresenterObject < Hoodoo::Presenters::Base
+
+      schema do
+        # Intentional mix of strings and symbols in default object
+        object :a_default_object, :default => { :an_integer => 42, 'some_text' => 'hello' } do
+          integer :an_integer
+          text :some_text
+        end
+        object :an_object_with_entry_defaults do
+          integer :an_integer, :default => 42
+          text :some_text
+        end
+      end
+
+    end
+  end
+
+  describe '#validate' do
+    it 'should return [] when valid object' do
+      expect(@inst.validate({}).errors).to eq([])
+    end
+
+    it 'should return correct error when data is not an object' do
+      errors = @inst.validate(2347234)
+
+      err = [{'code'=>"generic.invalid_object", 'message'=>"Field `one` is an invalid object", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should not return error when not required and absent' do
+      expect(@inst.validate(nil).errors).to eq([])
+    end
+
+    it 'should return error when required and absent' do
+      @inst.required = true
+      expect(@inst.validate(nil).errors).to eq([
+        {'code'=>"generic.required_field_missing", 'message'=>"Field `one` is required", 'reference'=>"one"}
+      ])
+    end
+
+    it 'should return correct error with non object types' do
+      err = [{'code'=>"generic.invalid_object", 'message'=>"Field `one` is an invalid object", 'reference'=>"one"}]
+
+      expect(@inst.validate('asckn').errors).to eq(err)
+      expect(@inst.validate(34534).errors).to eq(err)
+      expect(@inst.validate(2123.23).errors).to eq(err)
+      expect(@inst.validate(true).errors).to eq(err)
+      expect(@inst.validate([]).errors).to eq(err)
+    end
+
+    it 'should return correct error with path' do
+      errors = @inst.validate('scdacs','ordinary')
+      expect(errors.errors).to eq([
+        {'code'=>"generic.invalid_object", 'message'=>"Field `ordinary.one` is an invalid object", 'reference'=>"ordinary.one"}
+      ])
+    end
+  end
+
+
+  describe '#render' do
+    it 'renders correctly with whole-object default (1)' do
+      data = nil
+
+      expect(TestPresenterObject.render(data)).to eq({
+        'a_default_object' => {
+          'an_integer' => 42,
+          'some_text' => 'hello'
+        }
+      })
+    end
+
+    it 'renders correctly with whole-object default (2)' do
+      data = {}
+
+      expect(TestPresenterObject.render(data)).to eq({
+        'a_default_object' => {
+          'an_integer' => 42,
+          'some_text' => 'hello'
+        }
+      })
+    end
+
+    it 'must not override a provided object, even if nil' do
+      data = { 'a_default_object' => nil }
+      expect(TestPresenterObject.render(data)).to eq(data)
+    end
+
+    it 'must not override a provided object, even if "empty"' do
+      data = { 'a_default_object' => {} }
+      expect(TestPresenterObject.render(data)).to eq(data)
+    end
+
+    it 'provides default values for fields, where provided (1)' do
+      data = {
+        'a_default_object' => {
+          'an_integer' => 20
+        },
+        'an_object_with_entry_defaults' => {
+          'some_text' => 'hello'
+        }
+      }
+
+      expect(TestPresenterObject.render(data)).to eq({
+        'a_default_object' => {
+          'an_integer' => 20
+        },
+        'an_object_with_entry_defaults' => {
+          'an_integer' => 42,
+          'some_text' => 'hello'
+        }
+      })
+    end
+
+    it 'must not overwrite explicit object nil with object-with-field-defaults' do
+      data = {
+        'a_default_object' => {
+          'an_integer' => 20
+        },
+        'an_object_with_entry_defaults' => nil
+      }
+
+      expect(TestPresenterObject.render(data)).to eq(data)
+    end
+
+    it 'adds fields with defaults to empty objects' do
+      data = {
+        'a_default_object' => {
+          'an_integer' => 59
+        },
+        'an_object_with_entry_defaults' => {}
+      }
+
+      expect(TestPresenterObject.render(data)).to eq({
+        'a_default_object' => {
+          'an_integer' => 59
+        },
+        'an_object_with_entry_defaults' => {
+          'an_integer' => 42
+        }
+      })
+    end
+
+    it 'must not overwrite explicit field nil with field defaults' do
+      data = {
+        'a_default_object' => {
+          'an_integer' => 20
+        },
+        'an_object_with_entry_defaults' => {
+          'an_integer' => nil
+        }
+      }
+
+      expect(TestPresenterObject.render(data)).to eq(data)
+    end
+
+    it 'must not overwrite explicit field value with field defaults' do
+      data = {
+        'a_default_object' => {
+          'an_integer' => 20
+        },
+        'an_object_with_entry_defaults' => {
+          'an_integer' => 21
+        }
+      }
+
+      expect(TestPresenterObject.render(data)).to eq(data)
+    end
+  end
+
+end

data/spec/presenters/types/string_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Hoodoo::Presenters::String do
+
+  before do
+    @inst = Hoodoo::Presenters::String.new('one',:required => false, :length => 10)
+  end
+
+  describe '#initialize' do
+    it 'should raise an error if length is not defined' do
+      expect {
+        Hoodoo::Presenters::String.new('one',:required => false)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#validate' do
+    it 'should return [] when valid string' do
+      expect(@inst.validate('ascinas').errors).to eq([])
+    end
+
+    it 'should return correct error when data is not a string' do
+      errors = @inst.validate(23424)
+
+      err = [  {'code'=>"generic.invalid_string", 'message'=>"Field `one` is an invalid string", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should not return error when not required and absent' do
+      expect(@inst.validate(nil).errors).to eq([])
+    end
+
+    it 'should return error when required and absent' do
+      @inst.required = true
+      expect(@inst.validate(nil).errors).to eq([
+        {'code'=>"generic.required_field_missing", 'message'=>"Field `one` is required", 'reference'=>"one"}
+      ])
+    end
+
+    it 'should return correct error with non string types' do
+      err = [  {'code'=>"generic.invalid_string", 'message'=>"Field `one` is an invalid string", 'reference'=>"one"}]
+
+      expect(@inst.validate(34534).errors).to eq(err)
+      expect(@inst.validate(234234.44).errors).to eq(err)
+      expect(@inst.validate(true).errors).to eq(err)
+      expect(@inst.validate({}).errors).to eq(err)
+      expect(@inst.validate([]).errors).to eq(err)
+    end
+
+    it 'should return correct error with path' do
+      errors = @inst.validate(234234,'ordinary')
+      expect(errors.errors).to eq([
+        {'code'=>"generic.invalid_string", 'message'=>"Field `ordinary.one` is an invalid string", 'reference'=>"ordinary.one"}
+      ])
+    end
+
+    it 'should return correct error when length is exceeded' do
+      errors = @inst.validate('12345678901')
+      expect(errors.errors).to eq([
+        {'code'=>"generic.invalid_string", 'message'=>"Field `one` is longer than maximum length `10`", 'reference'=>"one"}
+      ])
+    end
+  end
+
+end

data/spec/presenters/types/tags_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Hoodoo::Presenters::Tags do
+
+  # This is just a copy of the Hoodoo::Presenters::Text tests, which is in
+  # turn a copy of Hoodoo::Presenters::String with minor changes (at the
+  # time of writing). The intent is to provide coverage for potential changes
+  # to the tag implementation in future, even though right now it's just a
+  # direct inheritance from Text with no changes.
+
+  before do
+    @inst = Hoodoo::Presenters::Tags.new('one',:required => false)
+  end
+
+  describe '#validate' do
+    it 'should return no errors when valid string' do
+      expect(@inst.validate('ascinas').errors).to eq([])
+    end
+
+    it 'should return correct error when data is not a string' do
+      errors = @inst.validate(23424)
+
+      err = [  {'code'=>"generic.invalid_string", 'message'=>"Field `one` is an invalid string", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should not return error when not required and absent' do
+      expect(@inst.validate(nil).errors).to eq([])
+    end
+
+    it 'should return error when required and absent' do
+      @inst.required = true
+      expect(@inst.validate(nil).errors).to eq([
+        {'code'=>"generic.required_field_missing", 'message'=>"Field `one` is required", 'reference'=>"one"}
+      ])
+    end
+
+    it 'should return correct error with non string types' do
+      err = [  {'code'=>"generic.invalid_string", 'message'=>"Field `one` is an invalid string", 'reference'=>"one"}]
+
+      expect(@inst.validate(34534).errors).to eq(err)
+      expect(@inst.validate(234234.44).errors).to eq(err)
+      expect(@inst.validate(true).errors).to eq(err)
+      expect(@inst.validate({}).errors).to eq(err)
+      expect(@inst.validate([]).errors).to eq(err)
+    end
+
+    it 'should return correct error with path' do
+      errors = @inst.validate(234234,'ordinary')
+      expect(errors.errors).to eq([
+        {'code'=>"generic.invalid_string", 'message'=>"Field `ordinary.one` is an invalid string", 'reference'=>"ordinary.one"}
+      ])
+    end
+  end
+
+end

data/spec/presenters/types/text_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Hoodoo::Presenters::Text do
+
+  before do
+    @inst = Hoodoo::Presenters::Text.new('one',:required => false)
+  end
+
+  describe '#validate' do
+    it 'should return no errors when valid string' do
+      expect(@inst.validate('ascinas').errors).to eq([])
+    end
+
+    it 'should return correct error when data is not a string' do
+      errors = @inst.validate(23424)
+
+      err = [  {'code'=>"generic.invalid_string", 'message'=>"Field `one` is an invalid string", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should not return error when not required and absent' do
+      expect(@inst.validate(nil).errors).to eq([])
+    end
+
+    it 'should return error when required and absent' do
+      @inst.required = true
+      expect(@inst.validate(nil).errors).to eq([
+        {'code'=>"generic.required_field_missing", 'message'=>"Field `one` is required", 'reference'=>"one"}
+      ])
+    end
+
+    it 'should return correct error with non string types' do
+      err = [  {'code'=>"generic.invalid_string", 'message'=>"Field `one` is an invalid string", 'reference'=>"one"}]
+
+      expect(@inst.validate(34534).errors).to eq(err)
+      expect(@inst.validate(234234.44).errors).to eq(err)
+      expect(@inst.validate(true).errors).to eq(err)
+      expect(@inst.validate({}).errors).to eq(err)
+      expect(@inst.validate([]).errors).to eq(err)
+    end
+
+    it 'should return correct error with path' do
+      errors = @inst.validate(234234,'ordinary')
+      expect(errors.errors).to eq([
+        {'code'=>"generic.invalid_string", 'message'=>"Field `ordinary.one` is an invalid string", 'reference'=>"ordinary.one"}
+      ])
+    end
+  end
+
+end

data/spec/presenters/types/uuid_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Hoodoo::Presenters::UUID do
+
+  describe '#validate' do
+    it 'should return no errors when valid UUID' do
+      expect(Hoodoo::Presenters::UUID.new('one').validate(Hoodoo::UUID.generate()).errors).to eq([])
+    end
+
+    it 'should return correct error when data is not a UUID-like string (1)' do
+      errors = Hoodoo::Presenters::UUID.new('one').validate('1234')
+
+      err = [  {'code'=>"generic.invalid_uuid", 'message'=>"Field `one` is an invalid UUID", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should return correct error when data is not a UUID-like string (2)' do
+      errors = Hoodoo::Presenters::UUID.new('one').validate('01234567890123456789012345678901z')
+
+      err = [  {'code'=>"generic.invalid_uuid", 'message'=>"Field `one` is an invalid UUID", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should return correct error when data is not a UUID-like string (3)' do
+      errors = Hoodoo::Presenters::UUID.new('one').validate('3ba258c0-4ce3-0132-9862-28373700b71c')
+
+      err = [  {'code'=>"generic.invalid_uuid", 'message'=>"Field `one` is an invalid UUID", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should return correct error when data is not even a string (1)' do
+      errors = Hoodoo::Presenters::UUID.new('one').validate(1234)
+
+      err = [  {'code'=>"generic.invalid_uuid", 'message'=>"Field `one` is an invalid UUID", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+
+    it 'should return correct error when data is not even a string (2)' do
+      errors = Hoodoo::Presenters::UUID.new('one').validate(Hoodoo::UUID.generate().to_sym)
+
+      err = [  {'code'=>"generic.invalid_uuid", 'message'=>"Field `one` is an invalid UUID", 'reference'=>"one"}]
+      expect(errors.errors).to eq(err)
+    end
+  end
+
+end