copyable 0.0.1

data/spec/syntax_checking/association_checker_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../helper/copyable_spec_helper'
+
+describe Copyable::AssociationChecker do
+
+  it 'should not throw an error if all associations are present' do
+    block = Proc.new do
+      associations({
+        copyable_pets: :copy,
+      })
+    end
+    association_checker = Copyable::AssociationChecker.new(CopyablePetFood)
+    expect { association_checker.verify!(block) }.to_not raise_error
+  end
+
+  it 'should throw an error if unrecognized associations are present' do
+    block = Proc.new do
+      associations({
+        copyable_pets: :copy,
+        what_is_this:  :copy,
+      })
+    end
+    association_checker = Copyable::AssociationChecker.new(CopyablePetFood)
+    expect { association_checker.verify!(block) }.to raise_error(Copyable::AssociationError)
+  end
+
+  it 'should not require "has many through" or "has one through" relationships to be listed' do
+    block = Proc.new do
+      associations({
+        copyable_toys:                    :copy,
+        copyable_pet_tag:                 :copy,
+        copyable_pet_profile:             :copy,
+        copyable_pet_foods:               :copy,
+        copyable_pet_sitting_patronages:  :copy,
+      })
+    end
+    association_checker = Copyable::AssociationChecker.new(CopyablePet)
+    expect { association_checker.verify!(block) }.to_not raise_error
+  end
+
+  it 'should not require "belongs to" relationships to be listed' do
+    block = Proc.new do
+      associations({
+        copyable_address:  :copy,
+      })
+    end
+    association_checker = Copyable::AssociationChecker.new(CopyablePetProfile)
+    expect { association_checker.verify!(block) }.to_not raise_error
+  end
+
+  it 'should require "has one" relationships to be listed' do
+    block = Proc.new do
+      associations({
+        # MISSING copyable_address:  :copy,
+      })
+    end
+    association_checker = Copyable::AssociationChecker.new(CopyablePetProfile)
+    expect { association_checker.verify!(block) }.to raise_error(Copyable::AssociationError)
+  end
+
+  it 'should require "has many" relationships to be listed' do
+    block = Proc.new do
+      associations({
+        # MISSING copyable_pet_sitting_patronages:  :copy,
+      })
+    end
+    association_checker = Copyable::AssociationChecker.new(CopyablePetSitter)
+    expect { association_checker.verify!(block) }.to raise_error(Copyable::AssociationError)
+  end
+
+  it 'should require "has and belongs to many" relationships to be listed' do
+    block = Proc.new do
+      associations({
+        # MISSING copyable_pets:  :copy,
+      })
+    end
+    association_checker = Copyable::AssociationChecker.new(CopyablePetFood)
+    expect { association_checker.verify!(block) }.to raise_error(Copyable::AssociationError)
+  end
+
+end

data/spec/syntax_checking/column_checker_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../helper/copyable_spec_helper'
+
+describe Copyable::ColumnChecker do
+
+  it 'should not throw an error if all columns are present' do
+    block = Proc.new do
+      columns({
+        name:       :copy,
+        kind:       :copy,
+        birth_year: :copy,
+      })
+    end
+    column_checker = Copyable::ColumnChecker.new(CopyablePet)
+    expect { column_checker.verify!(block) }.to_not raise_error
+  end
+
+  it 'should throw an error if columns are empty' do
+    block = Proc.new do
+      columns({})
+    end
+    column_checker = Copyable::ColumnChecker.new(CopyablePet)
+    expect { column_checker.verify!(block) }.to raise_error(Copyable::ColumnError)
+  end
+
+  it 'should throw an error if a column is missing' do
+    block = Proc.new do
+      columns({
+        name:       :copy,
+        birth_year: :copy,
+      })
+    end
+    column_checker = Copyable::ColumnChecker.new(CopyablePet)
+    expect { column_checker.verify!(block) }.to raise_error(Copyable::ColumnError)
+  end
+
+  it 'should throw an error if an unrecognized column is present' do
+    block = Proc.new do
+      columns({
+        name:       :copy,
+        kind:       :copy,
+        intruder:   :copy,
+        birth_year: :copy,
+      })
+    end
+    column_checker = Copyable::ColumnChecker.new(CopyablePet)
+    expect { column_checker.verify!(block) }.to raise_error(Copyable::ColumnError)
+  end
+
+end

data/spec/syntax_checking/declaration_checker_spec.rb

@@ -0,0 +1,58 @@
+require_relative '../helper/copyable_spec_helper'
+
+describe Copyable::DeclarationChecker do
+
+  it 'should throw an error if there are no declarations' do
+    block = Proc.new {}
+    expect { subject.verify!(block) }.to raise_error(Copyable::DeclarationError)
+  end
+
+  it 'should not throw an error if all required declarations are present' do
+    block = Proc.new do
+      disable_all_callbacks_and_observers_except_validate
+      columns
+      associations
+    end
+    expect { subject.verify!(block) }.to_not raise_error
+  end
+
+  it 'should not throw an error if all declarations are present' do
+    block = Proc.new do
+      disable_all_callbacks_and_observers_except_validate
+      columns
+      associations
+      after_copy
+    end
+    expect { subject.verify!(block) }.to_not raise_error
+  end
+
+  it 'should throw an error if an unknown declaration is present' do
+    block = Proc.new do
+      disable_all_callbacks_and_observers_except_validate
+      columns
+      unknown
+      associations
+      after_copy
+    end
+    expect { subject.verify!(block) }.to raise_error(Copyable::DeclarationError)
+  end
+
+  it 'should throw an error if a required declaration is missing' do
+    block = Proc.new do
+      columns
+      associations
+    end
+    expect { subject.verify!(block) }.to raise_error(Copyable::DeclarationError)
+    block = Proc.new do
+      disable_all_callbacks_and_observers_except_validate
+      associations
+    end
+    expect { subject.verify!(block) }.to raise_error(Copyable::DeclarationError)
+    block = Proc.new do
+      disable_all_callbacks_and_observers_except_validate
+      columns
+    end
+    expect { subject.verify!(block) }.to raise_error(Copyable::DeclarationError)
+  end
+
+end

data/spec/syntax_checking_spec.rb

@@ -0,0 +1,258 @@
+require_relative 'helper/copyable_spec_helper'
+
+# Even though we have good specs that test the syntax checker classes
+# individually, we still need the specs in this file to make sure the syntax
+# checking is hooked up properly to the copyable declaration.
+
+describe 'syntax checking' do
+
+
+
+  #*****************************************************************************
+  # COPYABLE
+
+  context 'copyable' do
+    it 'should throw an error when passed no block' do
+      model_definition = lambda do
+        undefine_copyable_in CopyableCoin
+        class CopyableCoin < ActiveRecord::Base
+          copyable
+        end
+      end
+      expect(model_definition).to raise_error(Copyable::CopyableError)
+    end
+
+    it 'should throw an error when passed an empty block' do
+      model_definition = lambda do
+        undefine_copyable_in CopyableCoin
+        class CopyableCoin < ActiveRecord::Base
+          copyable do
+          end
+        end
+      end
+      expect(model_definition).to raise_error(Copyable::DeclarationError)
+    end
+
+    it 'should not throw an error when all required declarations are present' do
+      model_definition = lambda do
+        undefine_copyable_in CopyableCoin
+        class CopyableCoin < ActiveRecord::Base
+          copyable do
+            disable_all_callbacks_and_observers_except_validate
+            columns({
+              kind:  :copy,
+              year:  :copy,
+            })
+            associations({
+            })
+          end
+        end
+      end
+      expect(model_definition).to_not raise_error
+    end
+
+    it 'should not throw an error when all declarations are present' do
+      model_definition = lambda do
+        undefine_copyable_in CopyableCoin
+        class CopyableCoin < ActiveRecord::Base
+          copyable do
+            disable_all_callbacks_and_observers_except_validate
+            columns({
+              kind:  :copy,
+              year:  :copy,
+            })
+            associations({
+            })
+            after_copy do |original_model, new_model|
+            end
+          end
+        end
+      end
+      expect(model_definition).to_not raise_error
+    end
+
+    it 'should throw an error when an unknown declaration is present' do
+      model_definition = lambda do
+        undefine_copyable_in CopyableCoin
+        class CopyableCoin < ActiveRecord::Base
+          copyable do
+            disable_all_callbacks_and_observers_except_validate
+            columns({
+              kind:  :copy,
+              year:  :copy,
+            })
+            associations({
+            })
+            what_the_heck_is_this_doing_here
+          end
+        end
+      end
+      expect(model_definition).to raise_error(Copyable::DeclarationError)
+    end
+
+    it 'should throw an error if a required declaration is missing' do
+      model_definition = lambda do
+        undefine_copyable_in CopyableCoin
+        class CopyableCoin < ActiveRecord::Base
+          copyable do
+            # MISSING disable_all_callbacks_and_observers_except_validate
+            columns({
+              kind:  :copy,
+              year:  :copy,
+            })
+            associations({
+            })
+          end
+        end
+      end
+      expect(model_definition).to raise_error(Copyable::DeclarationError)
+      model_definition = lambda do
+        undefine_copyable_in CopyableCoin
+        class CopyableCoin < ActiveRecord::Base
+          copyable do
+            disable_all_callbacks_and_observers_except_validate
+            # MISSING columns({
+            #   kind:  :copy,
+            #   year:  :copy,
+            # })
+            associations({
+            })
+          end
+        end
+      end
+      expect(model_definition).to raise_error(Copyable::DeclarationError)
+      model_definition = lambda do
+        undefine_copyable_in CopyableCoin
+        class CopyableCoin < ActiveRecord::Base
+          copyable do
+            disable_all_callbacks_and_observers_except_validate
+            columns({
+              kind:  :copy,
+              year:  :copy,
+            })
+            # MISSING associations({
+            # })
+          end
+        end
+      end
+      expect(model_definition).to raise_error(Copyable::DeclarationError)
+    end
+  end
+
+
+
+  #*****************************************************************************
+  # COLUMNS
+
+  context 'copyable:columns' do
+    context 'when missing columns' do
+      before(:each) do
+        @model_definition = lambda do
+          undefine_copyable_in CopyableCoin
+          class CopyableCoin < ActiveRecord::Base
+            copyable do
+              disable_all_callbacks_and_observers_except_validate
+              columns({
+                kind:  :copy,
+              })
+              associations({
+              })
+            end
+          end
+        end
+      end
+
+      it 'should throw an error' do
+        expect(@model_definition).to raise_error(Copyable::ColumnError)
+      end
+    end
+
+    context 'with unknown columns' do
+      before(:each) do
+        @model_definition = lambda do
+          undefine_copyable_in CopyableCoin
+          class CopyableCoin < ActiveRecord::Base
+            copyable do
+              disable_all_callbacks_and_observers_except_validate
+              columns({
+                what_is_this_column_doing_here:  :copy,
+                kind:                            :copy,
+                year:                            :copy,
+              })
+              associations({
+              })
+            end
+          end
+        end
+      end
+
+      it 'should throw an error' do
+        expect(@model_definition).to raise_error(Copyable::ColumnError)
+      end
+    end
+  end
+
+
+
+  #*****************************************************************************
+  # ASSOCIATIONS
+
+  context 'copyable:associations' do
+    context 'when missing associations' do
+      before(:each) do
+        @model_definition = lambda do
+          class CopyablePet < ActiveRecord::Base
+            copyable do
+              disable_all_callbacks_and_observers_except_validate
+              columns({
+                name:        :copy,
+                kind:        :copy,
+                birth_year:  :copy,
+              })
+              associations({
+                # MISSING copyable_toys:                    :copy,
+                copyable_pet_tag:                 :copy,
+                copyable_pet_profile:             :copy,
+                copyable_pet_foods:               :copy,
+                copyable_pet_sitting_patronages:  :copy,
+              })
+            end
+          end
+        end
+      end
+
+      it 'should throw an error' do
+        expect(@model_definition).to raise_error(Copyable::AssociationError)
+      end
+    end
+
+    context 'with unknown associations' do
+      before(:each) do
+        @model_definition = lambda do
+          class CopyablePet < ActiveRecord::Base
+            copyable do
+              disable_all_callbacks_and_observers_except_validate
+              columns({
+                name:        :copy,
+                kind:        :copy,
+                birth_year:  :copy,
+              })
+              associations({
+                this_assoc_should_not_be_here:    :copy,
+                copyable_toys:                    :copy,
+                copyable_pet_tag:                 :copy,
+                copyable_pet_profile:             :copy,
+                copyable_pet_foods:               :copy,
+                copyable_pet_sitting_patronages:  :copy,
+              })
+            end
+          end
+        end
+      end
+
+      it 'should throw an error' do
+        expect(@model_definition).to raise_error(Copyable::AssociationError)
+      end
+    end
+  end
+end

data/spec/transaction_spec.rb

@@ -0,0 +1,78 @@
+require_relative 'helper/copyable_spec_helper'
+
+describe 'failing' do
+  before(:each) do
+
+    #***************************************************************************
+    #  Define all of the copyable declarations.
+
+    undefine_copyable_in CopyableVehicle
+    class CopyableVehicle < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:               :copy,
+          copyable_owner_id:  :copy,
+        })
+        associations({
+          copyable_amenities:  :copy,
+        })
+      end
+    end
+
+    undefine_copyable_in CopyableAmenity
+    class CopyableAmenity < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:                 :copy,
+          copyable_vehicle_id:  :copy,
+          copyable_owner_id:    :copy,
+        })
+        associations({
+          copyable_warranty:  :copy,
+        })
+      end
+    end
+
+    undefine_copyable_in CopyableWarranty
+    class CopyableWarranty < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:                 lambda { |orig| raise Copyable::CopyableError.new("intentional error") },
+          copyable_amenity_id:  :copy,
+        })
+        associations({
+        })
+      end
+    end
+
+    #***************************************************************************
+    #  Create the models.
+
+    @vehicle1 = CopyableVehicle.create!(name: 'Corvette')
+    @amenity1 = CopyableAmenity.create!(name: 'moon roof', copyable_vehicle: @vehicle1)
+    @warranty1 = CopyableWarranty.create!(name: 'moon roof warranty', copyable_amenity: @amenity1)
+    @amenity2 = CopyableAmenity.create!(name: 'twitter', copyable_vehicle: @vehicle1)
+    @warranty2 = CopyableWarranty.create!(name: 'twitter warranty', copyable_amenity: @amenity2)
+    @amenity3 = CopyableAmenity.create!(name: 'jazz', copyable_vehicle: @vehicle1)
+    @warranty3 = CopyableWarranty.create!(name: 'jazz warranty', copyable_amenity: @amenity3)
+  end
+
+  it 'should be transactional' do
+    expect(CopyableVehicle.count).to eq(1)
+    expect(CopyableAmenity.count).to eq(3)
+    expect(CopyableWarranty.count).to eq(3)
+    begin
+      @vehicle2 = @vehicle1.create_copy!
+    rescue Copyable::CopyableError
+      # swallow the intentional error
+    end
+    # transaction rollback should prevent any new records from actually
+    # being generated
+    expect(CopyableVehicle.count).to eq(1)
+    expect(CopyableAmenity.count).to eq(3)
+    expect(CopyableWarranty.count).to eq(3)
+  end
+end