hoodoo 1.0.2

data/spec/active/active_record/support_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper.rb'
+
+describe Hoodoo::ActiveRecord::Support do
+  context '#self.process_to_map' do
+    it 'processes as expected' do
+      proc1 = Proc.new { puts "hello" }
+      proc2 = Proc.new { puts "world" }
+
+      hash = {
+        :foo => nil,
+        'bar' => nil,
+        :baz => proc1,
+        'boo' => proc2
+      }
+
+      map = described_class.process_to_map( hash )
+
+      # Ensure all keys become strings. The 'nil' values should become matcher
+      # Procs per Hoodoo::ActiveRecord::Finder::SearchHelper.cs_match, however
+      # you can't compare Proc instances; so instead run those Procs and check
+      # the expected results.
+      #
+      # Since a created Proc is supposed to encode the attribute name into the
+      # Proc via the key in the input hash, any run-time specification of an
+      # attribute name ought to be ignored if the mapping method is working as
+      # expected.
+
+      expect( map[ 'foo' ] ).to be_a( Proc )
+      expect( map[ 'foo' ].call( 'ignored', 'val1' ) ).to eq( [ 'foo = ? AND foo IS NOT NULL', 'val1' ] )
+
+      expect( map[ 'bar' ] ).to be_a( Proc )
+      expect( map[ 'bar' ].call( 'ignored', 'val2' ) ).to eq( [ 'bar = ? AND bar IS NOT NULL', 'val2' ] )
+
+      expect( map[ 'baz' ] ).to eq( proc1 )
+
+      expect( map[ 'boo' ] ).to eq( proc2 )
+    end
+  end
+
+  context '#full_scope_for' do
+
+    # Here we not only test the full scope generator with all mixins included,
+    # and test them all in a *deactivated* state, we also check that inheritance
+    # can then override that condition without disturbing the base class to
+    # ensure that "class attribute" style code, rather than "@@" class variable
+    # style code, is being maintained in the mixins. Then check the reverse -
+    # make sure things in the base class do get inherited by subclasses.
+
+    before :all do
+      @thtname1 = 'r_spec_full_scope_for_test_foo_history'
+      @thtname2 = 'r_spec_full_scope_for_test_with_directives_foo_history'
+
+      spec_helper_silence_stdout() do
+        ActiveRecord::Migration.create_table( :r_spec_full_scope_for_test_bases ) do | t |
+          t.timestamps :null => true
+        end
+
+        ActiveRecord::Migration.create_table( :r_spec_full_scope_for_test_subclasses ) do | t |
+          t.string :foo
+          t.timestamps :null => true
+        end
+
+        ActiveRecord::Migration.create_table( @thtname1 ) do | t |
+          t.string :foo
+          t.timestamps :null => true
+        end
+
+        ActiveRecord::Migration.create_table( :rspec_full_scope_for_test_base_with_directives_custom ) do | t |
+          t.string :bar
+          t.timestamps :null => true
+        end
+
+        ActiveRecord::Migration.create_table( @thtname2 ) do | t |
+          t.string :bar
+          t.timestamps :null => true
+        end
+      end
+
+      # Note inheritance from plain ActiveRecord::Base, important for
+      # additional coverage. Module inclusions are thus done manually.
+
+      class RSpecFullScopeForTestBase < ActiveRecord::Base
+        include Hoodoo::ActiveRecord::Secure
+        include Hoodoo::ActiveRecord::Dated
+        include Hoodoo::ActiveRecord::Translated
+      end
+
+      class RSpecFullScopeForTestSubclass < RSpecFullScopeForTestBase
+        TEST_HISTORY_TABLE_NAME = 'r_spec_full_scope_for_test_foo_history'
+
+        self.table_name = :r_spec_full_scope_for_test_subclasses
+        secure_with( :foo => :foo )
+        dating_enabled( :history_table_name => TEST_HISTORY_TABLE_NAME )
+      end
+
+      # Note inheritance from Hoodoo::ActiveRecord::Base, important for
+      # additional coverage. Module inclusions are automatic.
+
+      class RSpecFullScopeForTestBaseWithDirectives < Hoodoo::ActiveRecord::Base
+        TEST_HISTORY_TABLE_NAME = 'r_spec_full_scope_for_test_with_directives_foo_history'
+
+        self.table_name = :rspec_full_scope_for_test_base_with_directives_custom
+        secure_with( :bar => :foo )
+        dating_enabled( :history_table_name => TEST_HISTORY_TABLE_NAME )
+      end
+
+      class RSpecFullScopeForTestBaseSubclassWithoutOverrides < RSpecFullScopeForTestBaseWithDirectives
+        # No overrides at all
+      end
+    end
+
+    before :each do
+
+      # Get a good-enough-for-test interaction and context.
+
+      @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
+
+      # Now set up the data inside that context so that the tests generate
+      # predictable SQL output.
+
+      @test_time_value = DateTime.now
+      @context.request.dated_at = @test_time_value
+
+      @test_scoping_value = 23
+      @session.scoping = OpenStruct.new
+      @session.scoping.foo = [ @test_scoping_value ]
+    end
+
+    context '(with subclass overriding base class)' do
+      it 'prerequisites' do
+        expect( RSpecFullScopeForTestBase.all().to_sql() ).to_not eq( RSpecFullScopeForTestSubclass.all().to_sql() )
+      end
+
+      it 'gets "all" scope in the base class' do
+
+        # There are no module activations in the base class so we expect to
+        # get the "all" context, the subclass's activations having not made
+        # any difference to it.
+
+        auto_scope   = described_class.full_scope_for( RSpecFullScopeForTestBase, @context ).to_sql()
+        manual_scope = RSpecFullScopeForTestBase.all().to_sql()
+
+        expect( auto_scope ).to eq( manual_scope )
+      end
+
+      context 'gets customised scope in the subclass:' do
+
+        # These first tests just make sure that the individual modules
+        # are generating expected scoping data, so that we aren't accidentally
+        # comparing malfunctioning scope inclusions against each other (e.g.
+        # empty strings).
+
+        it 'dated' do
+          manual_scope = RSpecFullScopeForTestSubclass.dated( @context ).to_sql()
+
+          expect( manual_scope ).to include( "FROM #{ @thtname1 }" )
+          expect( manual_scope ).to include( "effective_end > #{ RSpecFullScopeForTestSubclass.sanitize( @test_time_value ) }" )
+        end
+
+        it 'secure' do
+          manual_scope = RSpecFullScopeForTestSubclass.secure( @context ).to_sql()
+
+          expect( manual_scope ).to include( "\"r_spec_full_scope_for_test_subclasses\".\"foo\" = '#{ @test_scoping_value }'" )
+        end
+
+        pending 'translated' do
+          raise "Scope verification for '\#translated'"
+        end
+
+        # In this last one, we actually check full_scope_for; activations are in
+        # the subclass so we drive the non-context versions directly to verify
+        # that the context chain worked.
+
+        it 'everything' do
+          auto_scope   = described_class.full_scope_for( RSpecFullScopeForTestSubclass, @context ).to_sql()
+          manual_scope = RSpecFullScopeForTestSubclass.secure( @context ).dated( @context ).translated( @context ).to_sql()
+
+          expect( auto_scope ).to eq( manual_scope )
+        end
+      end
+    end
+
+    context '(with base class definitions used by subclass)' do
+      it 'prerequisites' do
+        expect( RSpecFullScopeForTestBaseWithDirectives.all().to_sql ).to eq( RSpecFullScopeForTestBaseSubclassWithoutOverrides.all().to_sql() )
+      end
+
+      # As above - some tests to check individual scopes work (paranoia), then
+      # the actual #full_scope_for test which puts it all together.
+
+      it 'dated' do
+        manual_scope = RSpecFullScopeForTestBaseSubclassWithoutOverrides.dated( @context ).to_sql()
+
+        expect( manual_scope ).to include( "FROM #{ @thtname2 }" )
+        expect( manual_scope ).to include( "effective_end > #{ RSpecFullScopeForTestBaseSubclassWithoutOverrides.sanitize( @test_time_value ) }" )
+      end
+
+      it 'secure' do
+        manual_scope = RSpecFullScopeForTestBaseSubclassWithoutOverrides.secure( @context ).to_sql()
+
+        expect( manual_scope ).to include( "\"rspec_full_scope_for_test_base_with_directives_custom\".\"bar\" = '#{ @test_scoping_value }'" )
+      end
+
+      pending 'translated' do
+        raise "Scope verification for '\#translated'"
+      end
+
+      it 'yields the same SQL' do
+        auto_scope   = described_class.full_scope_for( RSpecFullScopeForTestBaseSubclassWithoutOverrides, @context ).to_sql()
+        manual_scope = RSpecFullScopeForTestBaseSubclassWithoutOverrides.secure( @context ).dated( @context ).translated( @context ).to_sql()
+
+        expect( auto_scope ).to eq( manual_scope )
+      end
+    end
+  end
+end

data/spec/active/active_record/translated_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'active_record'
+
+describe Hoodoo::ActiveRecord::Translated do
+  pending 'is tested' do
+
+    # For RCov only
+
+    class Test
+      include Hoodoo::ActiveRecord::Translated
+      def self.all; end
+    end
+
+    ignored = true
+    Test.translated( ignored )
+
+    raise "Replace with real test"
+  end
+end

data/spec/active/active_record/uuid_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'active_record'
+
+describe Hoodoo::ActiveRecord::UUID do
+  before :all do
+    spec_helper_silence_stdout() do
+      tblname = :r_spec_model_uuid_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 RSpecModelUUIDTest < ActiveRecord::Base
+        include Hoodoo::ActiveRecord::UUID
+      end
+    end
+  end
+
+  it 'should gain a UUID' do
+    m = RSpecModelUUIDTest.new
+    m.save
+
+    expect( m.id ).to_not be_nil
+    expect( Hoodoo::UUID.valid?( m.id ) ).to eq( true )
+  end
+
+  it 'should complain about a bad UUID' do
+    m = RSpecModelUUIDTest.new
+    m.id = "hello"
+
+    expect( m.save ).to eq( false )
+    expect( Hoodoo::UUID.valid?( m.id ) ).to eq( false )
+    expect( m.errors ).to_not be_empty
+    expect( m.errors.messages ).to eq( { :id => [ 'is invalid' ] } )
+  end
+
+  it 'should not overwrite a good UUID' do
+    m = RSpecModelUUIDTest.new
+    uuid = Hoodoo::UUID.generate()
+    m.id = uuid
+    m.save
+
+    expect( m.id ).to eq( uuid )
+    expect( Hoodoo::UUID.valid?( m.id ) ).to eq( true )
+  end
+
+  # Accidental attribute assignment of "id" to "nil" on updates can cause
+  # really bad consequences if the UUID is then automatically assigned again;
+  # the resource primary key would change magically! Never allow this. If a
+  # primary key change is ever wanted, a new UUID must be explicitly given.
+  #
+  it 'should not update with a replacement UUID' do
+    m = RSpecModelUUIDTest.new
+    m.save!
+    id = m.id
+
+    # So it shouldn't save with a 'nil' ID...
+
+    m.assign_attributes( :id => nil )
+
+    expect( m.save ).to eq( false )
+    expect( m.errors.messages ).to eq( { :id => [ "can't be blank" ] } )
+
+    # ...and should be able to reload it with the original ID still.
+
+    m.id = id
+    m.reload
+    expect( m.id ).to eq( id )
+  end
+end

data/spec/active/active_record/writer_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+require 'active_record'
+
+describe Hoodoo::ActiveRecord::Writer do
+
+  context 'persist_in' do
+
+    ###########################################################################
+    # DATABASE AND MODEL SETUP
+    ###########################################################################
+
+    class RSpecModelWriterTestWithValidation < ActiveRecord::Base
+      self.primary_key = :id
+      self.table_name = :r_spec_model_writer_tests
+
+      include Hoodoo::ActiveRecord::Writer
+      include Hoodoo::ActiveRecord::ErrorMapping
+
+      validates :code, uniqueness: true
+    end
+
+    class RSpecModelWriterTestWithoutValidation < ActiveRecord::Base
+      self.primary_key = :id
+      self.table_name = :r_spec_model_writer_tests
+
+      include Hoodoo::ActiveRecord::Writer
+      include Hoodoo::ActiveRecord::ErrorMapping
+    end
+
+    before( :all ) do
+      spec_helper_silence_stdout() do
+        ActiveRecord::Migration.create_table(:r_spec_model_writer_tests, :id => false) do | t |
+          t.text :id
+          t.text :uuid
+          t.text :code
+          t.text :random_field
+
+          t.timestamps :null => false
+        end
+
+        ActiveRecord::Migration.add_index(:r_spec_model_writer_tests, :code, unique: true)
+      end
+    end
+
+    ###########################################################################
+    # TESTS
+    ###########################################################################
+
+    def unique_attributes
+      {
+        :id           => Hoodoo::UUID.generate(),
+        :code         => Hoodoo::UUID.generate(),
+        :random_field => Hoodoo::UUID.generate()
+      }
+    end
+
+    before( :each ) do
+      @record_with_app_validation = RSpecModelWriterTestWithValidation.create(
+        :id           => 'one',
+        :code         => 'unique',
+        :random_field => 'sudo random value'
+      )
+
+      @record_without_app_validation = RSpecModelWriterTestWithoutValidation.create(
+        :id           => 'two',
+        :code         => 'unique - but only far as the db is concerned',
+        :random_field => 'sudo random value'
+      )
+
+      @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
+
+    context 'saves valid records' do
+      def expect_no_error( record )
+        expect( record.persisted? ).to eq( true )
+        @context.response.add_errors( record.platform_errors )
+        expect( @context.response.halt_processing? ).to eq( false )
+      end
+
+      shared_examples 'a persist_in-able model' do | klass |
+        it 'via class method' do
+          expect(
+            record = klass.persist_in( @context, unique_attributes() )
+          ).to be_a( klass )
+
+          expect_no_error( record )
+        end
+
+        it 'via instance method' do
+          record = klass.new( unique_attributes() )
+          result = record.persist_in( @context )
+          expect( result ).to eq( :success )
+          expect_no_error( record )
+        end
+      end
+
+      context 'with AR validations present' do
+        it_behaves_like 'a persist_in-able model', RSpecModelWriterTestWithValidation
+      end
+
+      context 'with AR validations missing' do
+        it_behaves_like 'a persist_in-able model', RSpecModelWriterTestWithoutValidation
+      end
+    end
+
+    context 'adds correct errors for invalid records' do
+      def expect_correct_error( record, reference )
+        expect( record.persisted? ).to eq( false )
+        @context.response.add_errors( record.platform_errors )
+        expect( @context.response.errors.errors[ 0 ] ).to eq(
+          {
+            'code'      => 'generic.invalid_duplication',
+            'message'   => 'has already been taken',
+            'reference' => reference
+          }
+        )
+      end
+
+      shared_examples 'an errant model' do | klass, error_reference |
+        it 'via class method' do
+          expect(
+            record = klass.persist_in( @context, record_to_copy().attributes() )
+          ).to be_a( klass )
+
+          expect_correct_error( record, error_reference )
+        end
+
+        it 'via instance method' do
+          record = klass.new( record_to_copy().attributes() )
+          result = record.persist_in( @context )
+          expect( result ).to eq( :failure )
+          expect_correct_error( record, error_reference )
+        end
+      end
+
+      context 'with AR validations present' do
+
+        # Needed due to RSpec / scoping quirks; can't pass an instance variable
+        # to a shared example as a parameter; ends up 'nil' inside the example.
+        #
+        let( :record_to_copy ) { @record_with_app_validation }
+
+        it_behaves_like 'an errant model',
+                        RSpecModelWriterTestWithValidation,
+                        'code' # This being the name of a known duplication-violating field
+      end
+
+      context 'with AR validations missing' do
+        let( :record_to_copy ) { @record_without_app_validation }
+        it_behaves_like 'an errant model',
+                        RSpecModelWriterTestWithoutValidation,
+                        'model instance' # This being the default name for an unknown duplication-violation cause
+      end
+    end
+
+    # This tries to check that, despite the nested transaction and rollback
+    # behaviour inside #persist_in, deep internal exceptions still propagate
+    # out correctly. It assumes database rollbacks happened OK (that's up to
+    # AR and the DB driver) and just makes sure the exception gets out.
+    #
+    context 'when internal exceptions occur' do
+      it 'reports them correctly' do
+        record = RSpecModelWriterTestWithValidation.new( @record_with_app_validation.attributes() )
+
+        # This is a method called deep inside ActiveRecord in its Transactions
+        # mixin. It is private, so this test is fragile.
+
+        expect( record ).to receive( :add_to_transaction ).and_raise( 'boo!' )
+        expect { result = record.persist_in( @context ) }.to raise_error( RuntimeError, 'boo!' )
+      end
+    end
+
+    # Prove that we handle the classic ActiveRecord validation of:
+    #
+    #    Thread 1              Thread 2
+    #    Check for dup?        --
+    #    No dupe               Check for dup?
+    #    => Save record        No dupe
+    #    OK                    => Save record
+    #                          Fails
+    #
+    # Two handler threads are set up to run through this scenario and each
+    # uses a Ruby Queue to talk to the other when it needs to pause and wait
+    # for the other thread to advance, in order to ensure the articial race
+    # condition is provoked every time without reliance on dubious 'sleep's.
+    #
+    context 'with race conditions' do
+      shared_examples 'a robust model' do | use_transaction |
+        it 'and handles duplicates correctly' do
+          attrs    = unique_attributes()
+
+          record_1 = RSpecModelWriterTestWithValidation.new( attrs )
+          record_2 = RSpecModelWriterTestWithValidation.new( attrs )
+
+          queue_1  = Queue.new
+          queue_2  = Queue.new
+
+          thread_1 = Thread.new do
+            queue_1.pop() # Wait until thread 2 gets going
+
+            expect( record_1 ).to receive( :perform_validations ).once do
+              queue_2 << :go # Tell thread 2 to run validations
+              queue_1.pop()  # Wait for thread 2 to run validations
+              true # Indicate successful validation, let save happen
+            end
+
+            result = if use_transaction
+              record_1.transaction do
+                record_1.persist_in( @context )
+              end
+            else
+              record_1.persist_in( @context )
+            end
+
+            expect( result ).to eq( :success )
+
+            queue_2 << :go # Tell thread 2 to save
+          end
+
+          thread_2 = Thread.new do
+            queue_1 << :go
+            queue_2.pop() # Wait for thread 1 to run validations, then tell us to go
+
+            expect( record_2 ).to receive( :perform_validations ).once do
+              queue_1 << :go # Now tell thread 1 to save
+              queue_2.pop() # Wait for thread 2 to do the same as the above
+              true # Indicate successful validation, let save happen
+            end
+
+            # Since the validation above will succeed but then try to save and that
+            # will fail, we expect the Writer module to re-query "valid?" and in the
+            # end to return ":failure".
+
+            expect( record_2 ).to receive( :valid? ).once.and_call_original
+
+            result = if use_transaction
+              record_2.transaction do
+                record_2.persist_in( @context )
+              end
+            else
+              record_2.persist_in( @context )
+            end
+
+            expect( result ).to eq( :failure )
+          end
+
+          thread_1.join()
+          thread_2.join()
+        end
+      end
+
+      context 'and no outer transaction' do
+        it_behaves_like 'a robust model', false
+      end
+
+      context 'and an outer transaction' do
+        it_behaves_like 'a robust model', true
+      end
+    end
+
+  end
+
+end