hoodoo 1.0.2

data/lib/hoodoo/version.rb

@@ -0,0 +1,17 @@
+########################################################################
+# File::    version.rb
+# (C)::     Loyalty New Zealand 2015
+#
+# Purpose:: Declare this gem's version number.
+# ----------------------------------------------------------------------
+#           27-Jan-2015 (ADH): Created (for gem under name Hoodoo).
+########################################################################
+
+module Hoodoo
+
+  # The Hoodoo gem version. If this changes, ensure that the date in
+  # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
+  #
+  VERSION = '1.0.2'
+
+end

data/spec/active/active_record/base_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'active_record'
+
+describe Hoodoo::ActiveRecord::Base do
+  before :all do
+    spec_helper_silence_stdout() do
+      tblname = :r_spec_model_base_tests
+
+      ActiveRecord::Migration.create_table( tblname, :id => false ) do | t |
+        t.string( :id, :limit => 32, :null => false )
+      end
+
+      ActiveRecord::Migration.add_index( tblname, :id, :unique => true )
+
+      class RSpecModelBaseTest < Hoodoo::ActiveRecord::Base
+      end
+    end
+  end
+
+  it 'has security capability' do
+    expect( RSpecModelBaseTest ).to respond_to( :secure )
+  end
+
+  it 'has dating capability' do
+    expect( RSpecModelBaseTest ).to respond_to( :dated )
+  end
+
+  it 'has internationalisation capability' do
+    expect( RSpecModelBaseTest ).to respond_to( :translated )
+  end
+
+  it 'finds things' do
+    m = RSpecModelBaseTest.new
+    m.save
+    expect( RSpecModelBaseTest.acquire( m.id ) ).to_not be_nil
+  end
+
+  it 'gains a UUID' do
+    m = RSpecModelBaseTest.new
+    m.save
+
+    expect( m.id ).to_not be_nil
+    expect( Hoodoo::UUID.valid?( m.id ) ).to eq( true )
+  end
+
+  it 'has creator capability' do
+    expect( RSpecModelBaseTest ).to respond_to( :new_in )
+  end
+
+  it 'has writer capability' do
+    expect( RSpecModelBaseTest ).to respond_to( :persist_in )
+  end
+
+  it 'supports error mapping' do
+    expect( RSpecModelBaseTest.new.platform_errors.has_errors? ).to eq( false )
+  end
+end

data/spec/active/active_record/creator_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'active_record'
+
+describe Hoodoo::ActiveRecord::Creator do
+  before :all do
+    spec_helper_silence_stdout() do
+      ActiveRecord::Migration.create_table( :r_spec_model_creator_tests, :id => :string ) do | t |
+        t.text :code
+        t.text :field_one
+
+        t.timestamps
+      end
+    end
+
+    class RSpecModelCreatorTest < ActiveRecord::Base
+      include Hoodoo::ActiveRecord::Creator
+      include Hoodoo::ActiveRecord::Dated
+    end
+  end
+
+  # ==========================================================================
+
+  context 'new_in' do
+    before :each do
+
+      # Get a good-enough-for-test interaction which has a context
+      # that contains a Session we can modify.
+
+      @interaction = Hoodoo::Services::Middleware::Interaction.new( {}, nil )
+      @interaction.context = Hoodoo::Services::Context.new(
+        Hoodoo::Services::Session.new,
+        @interaction.context.request,
+        @interaction.context.response,
+        @interaction
+      )
+
+      @context = @interaction.context
+      @session = @interaction.context.session
+    end
+
+    it 'creates with no special values' do
+      instance = RSpecModelCreatorTest.new_in( @context )
+
+      expect( instance.created_at ).to be_nil
+      expect( instance.updated_at ).to be_nil
+    end
+
+    it 'creates with specified dated-from value' do
+      time = Time.now.iso8601
+      @context.request.dated_from = time
+
+      instance = RSpecModelCreatorTest.new_in( @context )
+
+      expect( instance.created_at.iso8601 ).to eq( time )
+      expect( instance.updated_at.iso8601 ).to eq( time )
+    end
+
+    it 'creates with provided attributes' do
+      instance = RSpecModelCreatorTest.new_in( @context, code: 'code', field_one: 'one' )
+
+      expect( instance.code      ).to eq( 'code' )
+      expect( instance.field_one ).to eq( 'one'  )
+    end
+
+    it 'creates with a block' do
+      instance = RSpecModelCreatorTest.new_in( @context ) do | i |
+        i.code      = 'code'
+        i.field_one = 'one'
+      end
+
+      expect( instance.code      ).to eq( 'code' )
+      expect( instance.field_one ).to eq( 'one'  )
+    end
+
+    # Technically ActiveRecord documentation seems to indicate this is an
+    # either-or choice, but the code certainly supports both and it isn't
+    # *explicitly* stated as such, so we assume both can be mixed here.
+    #
+    it 'creates with provided attributes and a block' do
+      instance = RSpecModelCreatorTest.new_in( @context, code: 'code' ) do | i |
+        i.field_one = 'one'
+      end
+
+      expect( instance.code      ).to eq( 'code' )
+      expect( instance.field_one ).to eq( 'one'  )
+    end
+  end
+end

data/spec/active/active_record/dated_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+require 'active_record'
+
+describe Hoodoo::ActiveRecord::Dated do
+
+  before :all do
+    spec_helper_silence_stdout() do
+
+      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_tests, :id => false ) do | t |
+        t.text :id,  :null => false
+        t.text :data
+        t.timestamps
+      end
+
+      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_tests_history_entries, :id => false ) do | t |
+        t.text     :id,              :null => false
+        t.text     :uuid,            :null => false
+        t.text     :data
+        t.datetime :effective_start, :null => false
+        t.datetime :effective_end,   :null => false
+        t.timestamps
+      end
+
+      class RSpecModelEffectiveDateTest < ActiveRecord::Base
+        include Hoodoo::ActiveRecord::Dated
+        dating_enabled()
+      end
+
+      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_test_overrides, :id => false ) do | t |
+        t.text :id,  :null => false
+        t.text :data
+        t.timestamps
+      end
+
+      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_history_entries, :id => false ) do | t |
+        t.text     :id,              :null => false
+        t.text     :uuid,            :null => false
+        t.text     :data
+        t.datetime :effective_start, :null => false
+        t.datetime :effective_end,   :null => false
+        t.timestamps
+      end
+
+      class RSpecModelEffectiveDateTestOverride < ActiveRecord::Base
+        include Hoodoo::ActiveRecord::Dated
+
+        dating_enabled( :history_table_name => :r_spec_model_effective_date_history_entries )
+      end
+    end
+  end
+
+  shared_examples Hoodoo::ActiveRecord::Dated do
+
+    before( :all ) do
+
+      # Create some examples data for finding. The data has two different UUIDs
+      # which I'll referer to as A and B. The following tables contain the
+      # historical and current records separately with their attributes.
+      #
+      # Historical:
+      # -------------------------------------------------------------------
+      #  uuid | data    | created_at    | effective_end | effective_start |
+      # -------------------------------------------------------------------
+      #  A    | "one"   | now - 5 hours | now - 3 hours | now - 5 hours   |
+      #  B    | "two"   | now - 4 hours | now - 2 hours | now - 4 hours   |
+      #  A    | "three" | now - 5 hours | now - 1 hour  | now - 3 hours   |
+      #  B    | "four"  | now - 4 hours | now           | now - 2 hour    |
+      #
+      # Current:
+      # --------------------------------
+      #  uuid | data   | created_at    |
+      # --------------------------------
+      #  B    | "five" | now - 4 hours |
+      #  A    | "six"  | now - 5 hours |
+      #
+
+      @uuid_a = Hoodoo::UUID.generate
+      @uuid_b = Hoodoo::UUID.generate
+
+      @now  = Time.now.utc
+
+      # uuid, data, created_at, effective_end, effective_start
+      [
+        [ @uuid_a, "one",   @now - 5.hours, @now - 3.hours, @now - 5.hours ],
+        [ @uuid_b, "two",   @now - 4.hours, @now - 2.hours, @now - 4.hours ],
+        [ @uuid_a, "three", @now - 5.hours, @now - 1.hour,  @now - 3.hours ],
+        [ @uuid_b, "four",  @now - 4.hours, @now,           @now - 2.hours ]
+      ].each do | row_data |
+        model_klass.dated_with.new( {
+          :id              => row_data[ 0 ] + "-" + row_data[ 3 ].iso8601,
+          :uuid            => row_data[ 0 ],
+          :data            => row_data[ 1 ],
+          :created_at      => row_data[ 2 ],
+          :effective_end   => row_data[ 3 ],
+          :effective_start => row_data[ 4 ]
+        } ).save!
+      end
+
+      # uuid, data, created_at, updated_at
+      [
+        [ @uuid_b, "five", @now - 4.hours, @now          ],
+        [ @uuid_a, "six",  @now - 5.hours, @now - 1.hour ]
+      ].each do | row_data |
+        model_klass.new( {
+          :id         => row_data[ 0 ],
+          :data       => row_data[ 1 ],
+          :created_at => row_data[ 2 ],
+          :updated_at => row_data[ 3 ]
+        } ).save!
+      end
+
+    end
+
+    context '.dated_at' do
+      it 'returns counts correctly' do
+        expect( model_klass.dated_at( @now - 10.hours ).count ).to be 0
+        expect( model_klass.dated_at( @now ).count ).to be 2
+      end
+
+      def test_expectation( time, expected_data )
+        expect( model_klass.dated_at( time ).pluck( :data ) ).to match_array( expected_data )
+      end
+
+      it 'returns no records before any were effective' do
+        test_expectation( @now - 10.hours, [] )
+      end
+
+      it 'returns records that used to be effective starting at past time' do
+        test_expectation( @now - 5.hours, [ "one"           ] )
+        test_expectation( @now - 4.hours, [ "one", "two"    ] )
+        test_expectation( @now - 3.hours, [ "two", "three"  ] )
+        test_expectation( @now - 2.hours, [ "three", "four" ] )
+        test_expectation( @now - 1.hour,  [ "four", "six"   ] )
+      end
+
+      it 'returns records that are effective now' do
+        test_expectation( @now, [ "five", "six" ] )
+      end
+
+      it 'works with further filtering' do
+        expect( model_klass.dated_at( @now ).where( :id => @uuid_a ).pluck( :data ) ).to eq( [ "six" ] )
+      end
+
+    end
+
+    context '.dated' do
+      it 'returns counts correctly' do
+        # The contents of the Context are irrelevant aside from the fact that it
+        # needs a request to store the dated_at value.
+        request = Hoodoo::Services::Request.new
+        context = Hoodoo::Services::Context.new( nil, request, nil, nil )
+
+        context.request.dated_at = @now - 10.hours
+        expect( model_klass.dated( context ).count ).to be 0
+
+        context.request.dated_at = @now
+        expect( model_klass.dated( context ).count ).to be 2
+      end
+
+      def test_expectation( time, expected_data )
+        # The contents of the Context are irrelevant aside from the fact that it
+        # needs a request to store the dated_at value.
+        request = Hoodoo::Services::Request.new
+        context = Hoodoo::Services::Context.new( nil, request, nil, nil )
+        context.request.dated_at = time
+
+        expect( model_klass.dated( context ).pluck( :data ) ).to match_array( expected_data )
+      end
+
+      it 'returns no records before any were effective' do
+        test_expectation( @now - 10.hours, [] )
+      end
+
+      it 'returns records that used to be effective starting at past time' do
+        test_expectation( @now - 5.hours, [ "one"           ] )
+        test_expectation( @now - 4.hours, [ "one", "two"    ] )
+        test_expectation( @now - 3.hours, [ "two", "three"  ] )
+        test_expectation( @now - 2.hours, [ "three", "four" ] )
+        test_expectation( @now - 1.hour,  [ "four", "six"   ] )
+      end
+
+      it 'returns records that are effective now' do
+        test_expectation( @now, [ "five", "six" ] )
+      end
+
+      it 'works with further filtering' do
+
+        # The contents of the Context are irrelevant aside from the fact that it
+        # needs a request to store the dated_at value.
+        request = Hoodoo::Services::Request.new
+        context = Hoodoo::Services::Context.new( nil, request, nil, nil )
+        context.request.dated_at = @now
+
+        expect( model_klass.dated( context ).where( :id => @uuid_a ).pluck( :data ) ).to eq( [ "six" ] )
+      end
+
+      it 'works with dating last' do
+
+        # The contents of the Context are irrelevant aside from the fact that it
+        # needs a request to store the dated_at value.
+        request = Hoodoo::Services::Request.new
+        context = Hoodoo::Services::Context.new( nil, request, nil, nil )
+        context.request.dated_at = @now
+
+        expect( model_klass.where( :id => @uuid_a ).dated( context ).pluck( :data ) ).to eq( [ "six" ] )
+      end
+
+    end
+
+    context '.dated_historical_and_current' do
+
+      it 'returns counts correctly' do
+        expect( model_klass.dated_historical_and_current.count ).to be 6
+      end
+
+      it 'lists all historical and current records' do
+        expect( model_klass.dated_historical_and_current.pluck( :data ) ).to match_array( [ 'one', 'two', 'three', 'four', 'five', 'six' ] )
+      end
+
+    end
+
+  end
+
+  context "using default effective dating config" do
+
+    # Must be defined as a method rather than using a let statement as let
+    # statement values cannot be used in before blocks.
+    def model_klass
+      RSpecModelEffectiveDateTest
+    end
+
+    it_behaves_like Hoodoo::ActiveRecord::Dated
+
+  end
+
+  context "overriding history table name" do
+
+    # Must be defined as a method rather than using a let statement as let
+    # statement values cannot be used in before blocks.
+    def model_klass
+      RSpecModelEffectiveDateTestOverride
+    end
+
+    it_behaves_like Hoodoo::ActiveRecord::Dated
+
+  end
+
+end

data/spec/active/active_record/error_mapping_spec.rb

@@ -0,0 +1,360 @@
+require 'spec_helper'
+require 'active_record'
+
+describe Hoodoo::ActiveRecord::ErrorMapping do
+  before :all do
+    spec_helper_silence_stdout() do
+      ActiveRecord::Migration.create_table( :r_spec_model_error_mapping_tests ) do | t |
+        t.string   :uuid
+        t.boolean  :boolean
+        t.date     :date
+        t.datetime :datetime
+        t.decimal  :decimal, :precision => 5, :scale => 2
+        t.float    :float
+        t.integer  :integer
+        t.string   :string, :limit => 16
+        t.text     :text
+        t.time     :time
+        t.text     :array, :array => true
+      end
+
+      ActiveRecord::Migration.create_table( :r_spec_model_associated_error_mapping_tests ) do | t |
+        t.string :other_string
+
+        # For 'has_many' - can't use "t.reference" as the generated
+        # column name is too long!
+        #
+        t.integer :many_id
+        t.index   :many_id
+      end
+
+      class RSpecModelErrorMappingTest < ActiveRecord::Base
+        include Hoodoo::ActiveRecord::ErrorMapping
+
+        has_many :r_spec_model_associated_error_mapping_tests,
+                 :foreign_key => :many_id,
+                 :class_name  => :RSpecModelAssociatedErrorMappingTest
+
+        accepts_nested_attributes_for :r_spec_model_associated_error_mapping_tests
+
+        validates_presence_of :boolean,
+                              :date,
+                              :datetime,
+                              :decimal,
+                              :float,
+                              :integer,
+                              :string,
+                              :text,
+                              :time,
+                              :array
+
+        validates_uniqueness_of :integer
+        validates :string, :length => { :maximum => 16 }
+        validates :uuid, :uuid => true
+
+        validate do
+          if string == 'magic'
+            errors.add( 'this.thing', 'is not a column' )
+          end
+        end
+      end
+
+      class RSpecModelAssociatedErrorMappingTest < ActiveRecord::Base
+        belongs_to :r_spec_model_error_mapping_test,
+                   :foreign_key => :many_id,
+                   :class_name  => :RSpecModelErrorMappingTest
+
+        validates :other_string, :length => { :maximum => 6 }
+      end
+
+      class RSpecModelErrorMappingTestBase < ActiveRecord::Base
+        self.table_name = RSpecModelErrorMappingTest.table_name
+
+        include Hoodoo::ActiveRecord::ErrorMapping
+
+        validate do | instance |
+          instance.errors.add( :base, 'this is a test' )
+        end
+      end
+    end
+  end
+
+  before :each do
+    @errors = Hoodoo::Errors.new( Hoodoo::ErrorDescriptions.new )
+  end
+
+  let( :valid_model ) {
+    RSpecModelErrorMappingTest.new( {
+      :uuid     => Hoodoo::UUID.generate(),
+      :boolean  => true,
+      :date     => Time.now,
+      :datetime => Time.now,
+      :decimal  => 2.3,
+      :float    => 2.3,
+      :integer  => 42,
+      :string   => "hello",
+      :text     => "hello",
+      :time     => Time.now,
+      :array    => [ 'hello' ]
+    } )
+  }
+
+  it 'auto-validates and maps errors correctly' do
+
+    m = RSpecModelErrorMappingTest.new( :uuid => 'not a valid UUID' )
+    expect( m.adds_errors_to?( @errors ) ).to eq( true )
+
+    expect( @errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_boolean",
+        "message" => "can't be blank",
+        "reference" => "boolean"
+      },
+      {
+        "code" => "generic.invalid_date",
+        "message" => "can't be blank",
+        "reference" => "date"
+      },
+      {
+        "code" => "generic.invalid_datetime",
+        "message" => "can't be blank",
+        "reference" => "datetime"
+      },
+      {
+        "code" => "generic.invalid_decimal",
+        "message" => "can't be blank",
+        "reference" => "decimal"
+      },
+      {
+        "code" => "generic.invalid_float",
+        "message" => "can't be blank",
+        "reference" => "float"
+      },
+      {
+        "code" => "generic.invalid_integer",
+        "message" => "can't be blank",
+        "reference" => "integer"
+      },
+      {
+        "code" => "generic.invalid_string",
+        "message" => "can't be blank",
+        "reference" => "string"
+      },
+      {
+        "code" => "generic.invalid_string",
+        "message" => "can't be blank",
+        "reference" => "text"
+      },
+      {
+        "code" => "generic.invalid_time",
+        "message" => "can't be blank",
+        "reference" => "time"
+      },
+      {
+        "code" => "generic.invalid_array",
+        "message" => "can't be blank",
+        "reference" => "array"
+      },
+
+      # Checks that custom UUID validator is working.
+
+      {
+        "code" => "generic.invalid_uuid",
+        "message" => "is invalid",
+        "reference" => "uuid"
+      }
+    ] )
+  end
+
+  it 'maps "base" errors correctly' do
+    m = RSpecModelErrorMappingTestBase.new
+
+    expect( m.adds_errors_to?( @errors ) ).to eq( true )
+    expect( @errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_parameters",
+        "message" => "this is a test",
+        "reference" => "model instance"
+      }
+    ] )
+  end
+
+  it 'handles varying validation types' do
+    m = RSpecModelErrorMappingTest.new( {
+      :boolean  => true,
+      :date     => Time.now,
+      :datetime => Time.now,
+      :decimal  => 2.3,
+      :float    => 2.3,
+      :integer  => 42,
+      :string   => "hello - this is far too long for the maximum field length",
+      :text     => "hello",
+      :time     => Time.now,
+      :array    => [ 'hello' ]
+    } )
+
+    m.adds_errors_to?( @errors )
+    expect( @errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_string",
+        "message" => "is too long (maximum is 16 characters)",
+        "reference" => "string"
+      }
+    ] )
+  end
+
+  it 'handles varying validation types via the alternative interface' do
+    m = RSpecModelErrorMappingTest.new( {
+      :boolean  => true,
+      :date     => Time.now,
+      :datetime => Time.now,
+      :decimal  => 2.3,
+      :float    => 2.3,
+      :integer  => 42,
+      :string   => "hello - this is far too long for the maximum field length",
+      :text     => "hello",
+      :time     => Time.now,
+      :array    => [ 'hello' ]
+    } )
+
+    errors = m.platform_errors
+    expect( errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_string",
+        "message" => "is too long (maximum is 16 characters)",
+        "reference" => "string"
+      }
+    ] )
+  end
+
+  it 'handles arrays' do
+    m = RSpecModelErrorMappingTest.new( {
+      :boolean  => true,
+      :date     => Time.now,
+      :datetime => Time.now,
+      :decimal  => 2.3,
+      :float    => 2.3,
+      :integer  => 42,
+      :string   => 'hello',
+      :text     => 'world',
+      :time     => Time.now,
+      :array    => []
+    } )
+
+    array_col = RSpecModelErrorMappingTest.columns_hash[ 'array' ]
+    expect( array_col ).to receive( :array ).once.and_return( true )
+
+    m.adds_errors_to?( @errors )
+
+    expect( @errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_array",
+        "message" => "can't be blank",
+        "reference" => "array"
+      }
+    ] )
+  end
+
+  it 'maps duplicates' do
+    m = valid_model
+
+    m.adds_errors_to?( @errors )
+    expect( @errors.errors ).to eq( [] )
+    m.save!
+
+    n = m.dup
+    n.adds_errors_to?( @errors )
+    expect( @errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_duplication",
+        "message" => "has already been taken",
+        "reference" => "integer"
+      }
+    ] )
+  end
+
+  it 'handles downgrade to generic error code' do
+
+    class LocalHackableErrors < Hoodoo::ErrorDescriptions
+    end
+
+    @errors = Hoodoo::Errors.new( Hoodoo::ErrorDescriptions.new )
+
+    # We have to hack to test this...
+    #
+    desc = @errors.descriptions.instance_variable_get( '@descriptions' )
+    desc.delete( 'generic.invalid_boolean' )
+    desc.delete( 'generic.invalid_date' )
+
+    m = RSpecModelErrorMappingTest.new( {
+      :datetime => Time.now,
+      :decimal  => 2.3,
+      :float    => 2.3,
+      :integer  => 42,
+      :string   => "hello",
+      :text     => "hello",
+      :time     => Time.now,
+      :array    => [ 'hello' ]
+    } )
+
+    m.adds_errors_to?( @errors )
+
+    expect( @errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_parameters",
+        "message" => "can't be blank",
+        "reference" => "boolean"
+      },
+      {
+        "code" => "generic.invalid_parameters",
+        "message" => "can't be blank",
+        "reference" => "date"
+      }
+    ] )
+  end
+
+  it 'adds nothing if the model is valid' do
+    m = valid_model
+
+    expect( m.adds_errors_to?( @errors ) ).to eq( false )
+    expect( @errors.errors ).to eq( [] )
+
+    expect { m.save! }.to_not raise_error
+  end
+
+  it 'has-many associations are dereferenced' do
+    attrs = valid_model.attributes
+    attrs[ 'r_spec_model_associated_error_mapping_tests_attributes' ] = [
+      { :other_string => 'ok 1' },
+      { :other_string => 'ok 2' },
+      { :other_string => 'too long, so fails validation' }
+    ]
+
+    m = RSpecModelErrorMappingTest.new( attrs )
+
+    m.adds_errors_to?( @errors )
+
+    expect( @errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_string",
+        "message" => "is too long (maximum is 6 characters)",
+        "reference" => "r_spec_model_associated_error_mapping_tests.other_string"
+      }
+    ] )
+  end
+
+  it 'works with dot-separated non-attribute paths' do
+    m = valid_model
+    m.string = 'magic'
+
+    m.adds_errors_to?( @errors )
+
+    expect( @errors.errors ).to eq( [
+      {
+        "code" => "generic.invalid_parameters",
+        "message" => "is not a column",
+        "reference" => "this.thing"
+      }
+    ] )
+  end
+end