polymorpheus 2.2.0 → 3.3.0

data/spec/interface/has_many_as_polymorph_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Polymorpheus::Interface::HasManyAsPolymorph do
+  before do
+    create_table :story_arcs do |t|
+      t.references :hero
+      t.references :villain
+      t.references :battle
+      t.references :issue
+    end
+    create_table :battles
+    create_table :heros
+    create_table :issues
+    create_table :villains
+  end
+
+  it 'sets conditions on association to ensure we retrieve correct result' do
+    hero = Hero.create!
+    expect(hero.story_arcs.to_sql).to match_sql <<-EOS
+      SELECT `story_arcs`.* FROM `story_arcs`
+      WHERE `story_arcs`.`hero_id` = #{hero.id}
+      AND `story_arcs`.`villain_id` IS NULL
+    EOS
+  end
+
+  it 'supports existing conditions on the association' do
+    villain = Villain.create!
+    expect(villain.story_arcs.to_sql).to match_sql <<-EOS
+      SELECT `story_arcs`.* FROM `story_arcs`
+      WHERE `story_arcs`.`villain_id` = #{villain.id}
+      AND `story_arcs`.`hero_id` IS NULL
+      ORDER BY id DESC
+    EOS
+  end
+
+  it 'returns the correct result when used with new records' do
+    villain = Villain.create!
+    story_arc = StoryArc.create!(villain: villain, issue_id: 10)
+    expect(Hero.new.story_arcs.where(issue_id: 10)).to eq([])
+  end
+
+  it 'sets conditions on associations with enough specificity that they work
+  in conjunction with has_many :through relationships' do
+    hero = Hero.create!
+    expect(hero.battles.to_sql).to match_sql <<-EOS
+      SELECT `battles`.* FROM `battles`
+      INNER JOIN `story_arcs`
+      ON `battles`.`id` = `story_arcs`.`battle_id`
+      WHERE `story_arcs`.`hero_id` = #{hero.id}
+      AND `story_arcs`.`villain_id` IS NULL
+    EOS
+  end
+
+  it 'uses the correct association table name when used in conjunction with a
+  join condition' do
+    battle = Battle.create!
+    expect(battle.heros.to_sql).to match_sql <<-EOS
+      SELECT `heros`.* FROM `heros`
+      INNER JOIN `story_arcs`
+      ON `heros`.`id` = `story_arcs`.`hero_id`
+      WHERE `story_arcs`.`battle_id` = #{battle.id}
+    EOS
+
+    if ActiveRecord::VERSION::MAJOR >= 6
+      expect(battle.heros.joins(:story_arcs).to_sql).to match_sql <<-EOS
+        SELECT `heros`.* FROM `heros`
+        INNER JOIN `story_arcs`
+        ON `heros`.`id` = `story_arcs`.`hero_id`
+        INNER JOIN `story_arcs` `story_arcs_heros`
+        ON `story_arcs_heros`.`villain_id` IS NULL
+        AND `story_arcs_heros`.`hero_id` = `heros`.`id`
+        WHERE `story_arcs`.`battle_id` = #{battle.id}
+      EOS
+    else
+      expect(battle.heros.joins(:story_arcs).to_sql).to match_sql <<-EOS
+        SELECT `heros`.* FROM `heros`
+        INNER JOIN `story_arcs` `story_arcs_heros`
+        ON `story_arcs_heros`.`hero_id` = `heros`.`id`
+        AND `story_arcs_heros`.`villain_id` IS NULL
+        INNER JOIN `story_arcs`
+        ON `heros`.`id` = `story_arcs`.`hero_id`
+        WHERE `story_arcs`.`battle_id` = #{battle.id}
+      EOS
+    end
+  end
+end

data/spec/interface/validates_polymorph_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Polymorpheus::Interface::ValidatesPolymorph do
+  let(:hero) { Hero.create! }
+  let(:villain) { Villain.create! }
+
+  before do
+    create_table(:story_arcs) do |t|
+      t.references :hero
+      t.references :villain
+    end
+    create_table(:heros)
+    create_table(:villains)
+  end
+
+  specify { expect(StoryArc.new(character: hero).valid?).to eq(true) }
+  specify { expect(StoryArc.new(character: villain).valid?).to eq(true) }
+  specify { expect(StoryArc.new(hero_id: hero.id).valid?).to eq(true) }
+  specify { expect(StoryArc.new(hero: hero).valid?).to eq(true) }
+  specify { expect(StoryArc.new(hero: Hero.new).valid?).to eq(true) }
+
+  it 'is invalid if no association is specified' do
+    story_arc = StoryArc.new
+    expect(story_arc.valid?).to eq(false)
+    expect(story_arc.errors[:base]).to eq(
+      ["You must specify exactly one of the following: {hero, villain}"]
+    )
+  end
+
+  it 'is invalid if multiple associations are specified' do
+    story_arc = StoryArc.new(hero_id: hero.id, villain_id: villain.id)
+    expect(story_arc.valid?).to eq(false)
+    expect(story_arc.errors[:base]).to eq(
+      ["You must specify exactly one of the following: {hero, villain}"]
+    )
+  end
+end

data/spec/interface_spec.rb

@@ -1,200 +1,27 @@
-require 'active_record'
-require 'polymorpheus'
 require 'spec_helper'
-require 'support/class_defs'
 
-describe '.belongs_to_polymorph' do
-  let(:hero) { Hero.create! }
-  let(:villain) { Villain.create! }
-  let(:superhero) { Superhero.create! }
-  let(:alien_demigod) { AlienDemigod.create! }
+describe Polymorpheus::Interface do
+  describe 'association options' do
+    it 'without options' do
+      create_table :drawings
+      create_table :books
+      create_table :binders
 
-  specify { StoryArc::POLYMORPHEUS_ASSOCIATIONS.should == %w[hero villain] }
-  specify { Superpower::POLYMORPHEUS_ASSOCIATIONS.should == %w[superhero
-                                                               supervillain] }
-
-  describe "setter methods for ActiveRecord objects" do
-    let(:story_arc) { StoryArc.new(attributes) }
-    let(:attributes) { {} }
-
-    it "sets the correct attribute value for the setter" do
-      story_arc.character = hero
-      story_arc.hero_id.should == hero.id
-      story_arc.villain_id.should == nil
-    end
-
-    it "sets competing associations to nil" do
-      story_arc.character = hero
-      story_arc.hero_id.should == hero.id
-      story_arc.character = villain
-      story_arc.villain_id.should == villain.id
-      story_arc.hero_id.should == nil
-    end
-
-    it "throws an error if the assigned object isn't a valid type" do
-      tree = Tree.create!
-      expect { story_arc.character = tree }
-        .to raise_error(Polymorpheus::Interface::InvalidTypeError,
-                        "Invalid type. Must be one of {hero, villain}")
-    end
-
-    it "does not throw an error if the assigned object is a subclass of a
-    valid type" do
-      expect { story_arc.character = superhero }.not_to raise_error
-      story_arc.hero_id.should == superhero.id
-    end
-
-    it "does not throw an error if the assigned object is a descendant of a
-    valid type" do
-      expect { story_arc.character = alien_demigod }.not_to raise_error
-      story_arc.hero_id.should == alien_demigod.id
-    end
-  end
-
-  describe "setter methods for objects inheriting from ActiveRecord objects" do
-    let(:superpower) { Superpower.new }
-
-    it "throws an error if the assigned object is an instance of the parent
-    ActiveRecord class" do
-      expect { superpower.wielder = hero }.to raise_error(
-        Polymorpheus::Interface::InvalidTypeError,
-        "Invalid type. Must be one of {superhero, supervillain}"
-      )
-    end
-
-    it "works if the assigned object is of the specified class" do
-      expect { superpower.wielder = superhero }.not_to raise_error
-      superpower.superhero_id.should == superhero.id
-    end
-
-    it "works if the assigned object is an instance of a child class" do
-      expect { superpower.wielder = alien_demigod }.not_to raise_error
-      superpower.superhero_id.should == alien_demigod.id
-    end
-  end
-
-  describe '#polymorpheus exposed interface method' do
-    subject(:interface) { story_arc.polymorpheus }
-
-    context 'when there is no relationship defined' do
-      let(:story_arc) { StoryArc.new }
-
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { should == nil }
-      its(:query_condition) { should == nil }
-    end
-
-    context 'when there is are multiple relationships defined' do
-      let(:story_arc) { StoryArc.new(hero_id: hero.id, villain_id: villain.id) }
-
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { should == nil }
-      its(:query_condition) { should == nil }
+      expect(Drawing.new.association(:book).reflection.inverse_of).to eq(nil)
+      expect(Drawing.new.association(:binder).reflection.inverse_of).to eq(nil)
+      expect(Book.new.association(:drawings).reflection.inverse_of).to eq(nil)
+      expect(Binder.new.association(:drawings).reflection.inverse_of).to eq(nil)
     end
 
-    context 'when there is one relationship defined through the id value' do
-      let(:story_arc) { StoryArc.new(hero_id: hero.id) }
+    it 'with options' do
+      create_table :pictures
+      create_table :web_pages
+      create_table :printed_works
 
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { be_association(:hero) }
-      its(:query_condition) { should == { 'hero_id' => hero.id } }
+      expect(Picture.new.association(:web_page).reflection.inverse_of.name).to eq(:pictures)
+      expect(Picture.new.association(:printed_work).reflection.inverse_of.name).to eq(:pictures)
+      expect(WebPage.new.association(:pictures).reflection.inverse_of.name).to eq(:web_page)
+      expect(PrintedWork.new.association(:pictures).reflection.inverse_of.name).to eq(:printed_work)
     end
-
-    context 'when there is one relationship defined through the setter' do
-      let(:story_arc) { StoryArc.new(character: hero) }
-
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { be_association(:hero) }
-      its(:query_condition) { should == { 'hero_id' => hero.id } }
-    end
-
-    context 'when there is one association, to a new record' do
-      let(:new_hero) { Hero.new }
-      let(:story_arc) { StoryArc.new(character: new_hero) }
-
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { be_association(:hero) }
-      its(:query_condition) { should == nil }
-    end
-  end
-end
-
-describe '.has_many_as_polymorph' do
-  it 'sets conditions on association to ensure we retrieve correct result' do
-    hero = Hero.create!
-    hero.story_arcs.to_sql
-      .should match_sql(%{SELECT `story_arcs`.* FROM `story_arcs`
-                          WHERE `story_arcs`.`hero_id` = #{hero.id}
-                          AND `story_arcs`.`villain_id` IS NULL})
-  end
-
-  it 'supports existing conditions on the association' do
-    villain = Villain.create!
-    villain.story_arcs.to_sql
-      .should match_sql(%{SELECT `story_arcs`.* FROM `story_arcs`
-                          WHERE `story_arcs`.`villain_id` = #{villain.id}
-                          AND `story_arcs`.`hero_id` IS NULL
-                          ORDER BY id DESC})
-  end
-
-  it 'returns the correct result when used with new records' do
-    villain = Villain.create!
-    story_arc = StoryArc.create!(villain: villain, issue_id: 10)
-    Hero.new.story_arcs.where(issue_id: 10).should == []
-  end
-
-  it 'sets conditions on associations with enough specificity that they work
-  in conjunction with has_many :through relationships' do
-    hero = Hero.create!
-    hero.battles.to_sql
-      .should match_sql(%{SELECT `battles`.* FROM `battles`
-                          INNER JOIN `story_arcs`
-                          ON `battles`.`id` = `story_arcs`.`battle_id`
-                          WHERE `story_arcs`.`hero_id` = 16
-                          AND `story_arcs`.`villain_id` IS NULL})
-  end
-
-  it 'uses the correct association table name when used in conjunction with a
-  join condition' do
-    battle = Battle.create!
-    battle.heros.to_sql
-      .should match_sql(%{SELECT `heros`.* FROM `heros`
-                          INNER JOIN `story_arcs`
-                          ON `heros`.`id` = `story_arcs`.`hero_id`
-                          WHERE `story_arcs`.`battle_id` = #{battle.id}})
-
-    battle.heros.joins(:story_arcs).to_sql
-      .should match_sql(%{SELECT `heros`.* FROM `heros`
-                          INNER JOIN `story_arcs` `story_arcs_heros`
-                          ON `story_arcs_heros`.`hero_id` = `heros`.`id`
-                          AND `story_arcs_heros`.`villain_id` IS NULL
-                          INNER JOIN `story_arcs`
-                          ON `heros`.`id` = `story_arcs`.`hero_id`
-                          WHERE `story_arcs`.`battle_id` = #{battle.id}})
-  end
-end
-
-describe '.validates_polymorph' do
-  let(:hero) { Hero.create! }
-  let(:villain) { Villain.create! }
-
-  specify { StoryArc.new(character: hero).valid?.should == true }
-  specify { StoryArc.new(character: villain).valid?.should == true }
-  specify { StoryArc.new(hero_id: hero.id).valid?.should == true }
-  specify { StoryArc.new(hero: hero).valid?.should == true }
-  specify { StoryArc.new(hero: Hero.new).valid?.should == true }
-
-  it 'is invalid if no association is specified' do
-    story_arc = StoryArc.new
-    story_arc.valid?.should == false
-    story_arc.errors[:base].should ==
-      ["You must specify exactly one of the following: {hero, villain}"]
-  end
-
-  it 'is invalid if multiple associations are specified' do
-    story_arc = StoryArc.new(hero_id: hero.id, villain_id: villain.id)
-    story_arc.valid?.should == false
-    story_arc.errors[:base].should ==
-      ["You must specify exactly one of the following: {hero, villain}"]
   end
 end

data/spec/mysql2_adapter_spec.rb

@@ -1,156 +1,317 @@
-require 'active_record'
 require 'spec_helper'
-require 'sql_logger'
-require 'foreigner'
-require 'foreigner/connection_adapters/mysql2_adapter'
-require 'polymorpheus'
-require 'polymorpheus/trigger'
-require 'shared_examples'
-
-Polymorpheus::Adapter.load!
 
 describe Polymorpheus::ConnectionAdapters::MysqlAdapter do
+  # The foreign key name is not truncated, so the maximum column name
+  # length ends up being:  64 - "pets_" - "_fk" == 56
+  #
+  # Using `t.references` also adds an index on this column, with a slightly
+  # longer name: 64 - "index_pets_on_" - "_id" == 46
+  #
+  # Go with the shorter of the two here, since it's still long enough to test
+  # the generation of Polymorpheus' trigger names.
+  let(:long_column1) { ('x' * 46).to_sym }
+  let(:long_column2) { ('y' * 46).to_sym }
 
-  #######################################################
-  # Setup
-  #######################################################
-
-  before(:all) do
-    class << ActiveRecord::Base.connection
-      include Polymorpheus::SqlLogger
-      alias_method :original_execute, :execute
-      alias_method :execute, :log_sql_statements
-    end
-  end
-
-  after(:all) do
-    class << ActiveRecord::Base.connection
-      alias_method :execute, :original_execute
+  before do
+    create_table(:pets) do |t|
+      t.references :cat
+      t.references :dog
+      t.string :name
+      t.string :color
     end
-  end
 
-  let(:connection) { ActiveRecord::Base.connection }
-  let(:sql) { connection.sql_statements }
+    create_table(:cats)
+    create_table(:dogs)
 
-  def clean_sql(sql_string)
-    sql_string.gsub(/^\n\s*/,'').gsub(/\s*\n\s*$/,'')
-      .gsub(/\n\s*/,"\n").gsub(/\s*$/,"")
+    clear_sql_history
   end
 
-  before do
-    connection.clear_sql_history
-    subject
+  after do
+    drop_table :pets
+    drop_table :cats
+    drop_table :dogs
   end
 
   #######################################################
   # Specs
   #######################################################
 
-  describe "migration statements" do
-    context "basic case with no uniqueness constraints" do
-      include_context "columns with short names"
-      let(:options) { {} }
+  describe '#add_polymorphic_constraints' do
+    it 'adds foreign keys with no uniqueness constraints' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' }
+      )
+
+      should_execute_sql <<-EOS
+        DROP TRIGGER IF EXISTS pfki_pets_catid_dogid
+        DROP TRIGGER IF EXISTS pfku_pets_catid_dogid
+        CREATE TRIGGER pfki_pets_catid_dogid BEFORE INSERT ON pets
+          FOR EACH ROW
+            BEGIN
+              IF(IF(NEW.cat_id IS NULL, 0, 1) + IF(NEW.dog_id IS NULL, 0, 1)) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END
+        CREATE TRIGGER pfku_pets_catid_dogid BEFORE UPDATE ON pets
+          FOR EACH ROW
+            BEGIN
+              IF(IF(NEW.cat_id IS NULL, 0, 1) + IF(NEW.dog_id IS NULL, 0, 1)) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END
+
+        ALTER TABLE `pets` ADD CONSTRAINT `pets_cat_id_fk`
+        FOREIGN KEY (`cat_id`)
+        REFERENCES `cats`(id)
 
-      it_behaves_like "mysql2 migration statements"
+        ALTER TABLE `pets` ADD CONSTRAINT `pets_dog_id_fk`
+        FOREIGN KEY (`dog_id`)
+        REFERENCES `dogs`(id)
+      EOS
     end
 
-    context "when uniqueness constraint is specified as true" do
-      include_context "columns with short names"
-      let(:options) { { :unique => true } }
-      let(:unique_key_sql) do
-        %{ CREATE UNIQUE INDEX pfk_pets_dogid ON pets (dog_id)
-           CREATE UNIQUE INDEX pfk_pets_kittyid ON pets (kitty_id) }
-      end
-      let(:remove_indices_sql) do
-        %{ DROP INDEX pfk_pets_kittyid ON pets
-           DROP INDEX pfk_pets_dogid ON pets }
-      end
+    it 'adds uniqueness specified with true' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        unique: true
+      )
 
-      it_behaves_like "mysql2 migration statements"
+      should_execute_sql <<-EOS
+        CREATE UNIQUE INDEX pfk_pets_catid ON pets (cat_id)
+        CREATE UNIQUE INDEX pfk_pets_dogid ON pets (dog_id)
+      EOS
     end
 
-    context "specifying uniqueness constraint as a string" do
-      include_context "columns with short names"
-      let(:options) { { :unique => 'field1' } }
-      let(:unique_key_sql) do
-        %{ CREATE UNIQUE INDEX pfk_pets_dogid_field1 ON pets (dog_id, field1)
-           CREATE UNIQUE INDEX pfk_pets_kittyid_field1 ON pets (kitty_id, field1) }
-      end
-      let(:remove_indices_sql) do
-        %{ DROP INDEX pfk_pets_kittyid_field1 ON pets
-           DROP INDEX pfk_pets_dogid_field1 ON pets }
-      end
+    it 'adds uniqueness specified with a string' do
+      add_polymorphic_constraints('pets', { cat_id: 'cats.id' }, unique: 'name')
+      should_execute_sql <<-EOS
+        CREATE UNIQUE INDEX pfk_pets_catid_name ON pets (cat_id, name)
+      EOS
+    end
 
-      it_behaves_like "mysql2 migration statements"
+    it 'adds uniqueness specified as an array' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id' },
+        unique: [:name, :color]
+      )
+      should_execute_sql <<-EOS
+        CREATE UNIQUE INDEX pfk_pets_catid_name_color ON pets (cat_id, name, color)
+      EOS
     end
 
-    context "specifying uniqueness constraint as an array" do
-      include_context "columns with short names"
-      let(:options) { { :unique => [:foo, :bar] } }
-      let(:unique_key_sql) do
-        %{ CREATE UNIQUE INDEX pfk_pets_dogid_foo_bar ON pets (dog_id, foo, bar)
-           CREATE UNIQUE INDEX pfk_pets_kittyid_foo_bar ON pets (kitty_id, foo, bar) }
-      end
-      let(:remove_indices_sql) do
-        %{ DROP INDEX pfk_pets_kittyid_foo_bar ON pets
-           DROP INDEX pfk_pets_dogid_foo_bar ON pets }
-      end
+    it 'adds an on update constraint' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id' },
+        on_update: :cascade
+      )
+      should_execute_sql <<-EOS
+        ALTER TABLE `pets` ADD CONSTRAINT `pets_cat_id_fk`
+        FOREIGN KEY (`cat_id`)
+        REFERENCES `cats`(id)
+        ON UPDATE CASCADE
+      EOS
+    end
 
-      it_behaves_like "mysql2 migration statements"
+    it 'raises an error when on_update has invalid arguments' do
+      expect do
+        add_polymorphic_constraints(
+          'pets',
+          { cat_id: 'cats.id' },
+          on_update: :invalid
+        )
+      end.to raise_error ArgumentError
     end
 
-    context "specifying an on update constraint" do
-      include_context "columns with short names"
-      let(:options) { { :on_update => :cascade } }
-      let(:fkey_sql) do
-        %{ ALTER TABLE `pets` ADD CONSTRAINT `pets_dog_id_fk` FOREIGN KEY (`dog_id`) REFERENCES `dogs`(id) ON UPDATE CASCADE
-           ALTER TABLE `pets` ADD CONSTRAINT `pets_kitty_id_fk` FOREIGN KEY (`kitty_id`) REFERENCES `cats`(name) ON UPDATE CASCADE }
-      end
+    it 'adds an on delete constraint' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id' },
+        on_delete: :cascade
+      )
+      should_execute_sql <<-EOS
+        ALTER TABLE `pets` ADD CONSTRAINT `pets_cat_id_fk`
+        FOREIGN KEY (`cat_id`)
+        REFERENCES `cats`(id)
+        ON DELETE CASCADE
+      EOS
+    end
 
-      it_behaves_like "mysql2 migration statements"
+    it 'raises an error when on_delete has invalid arguments' do
+      expect do
+        add_polymorphic_constraints(
+          'pets',
+          { cat_id: 'cats.id' },
+          on_update: :invalid
+        )
+      end.to raise_error ArgumentError
     end
 
-    context "specifying on delete and on update constraints" do
-      include_context "columns with short names"
-      let(:options) { { :on_update => :cascade, :on_delete => :restrict } }
-      let(:fkey_sql) do
-        %{ ALTER TABLE `pets` ADD CONSTRAINT `pets_dog_id_fk` FOREIGN KEY (`dog_id`) REFERENCES `dogs`(id) ON DELETE RESTRICT ON UPDATE CASCADE
-           ALTER TABLE `pets` ADD CONSTRAINT `pets_kitty_id_fk` FOREIGN KEY (`kitty_id`) REFERENCES `cats`(name) ON DELETE RESTRICT ON UPDATE CASCADE }
+    it 'truncates long trigger names to 64 characters' do
+      create_table(:pets) do |t|
+        t.references long_column1
+        t.references long_column2
       end
 
-      it_behaves_like "mysql2 migration statements"
+      add_polymorphic_constraints(
+        'pets',
+        { "#{long_column1}_id" => 'cats.id', "#{long_column2}_id" => 'dogs.id' }
+      )
+
+      should_execute_sql <<-EOS
+        DROP TRIGGER IF EXISTS pfki_pets_xxxxxxxxxxxxxxxxxxxxxxxxxx_yyyyyyyyyyyyyyyyyyyyyyyyyy
+        DROP TRIGGER IF EXISTS pfku_pets_xxxxxxxxxxxxxxxxxxxxxxxxxx_yyyyyyyyyyyyyyyyyyyyyyyyyy
+        CREATE TRIGGER pfki_pets_xxxxxxxxxxxxxxxxxxxxxxxxxx_yyyyyyyyyyyyyyyyyyyyyyyyyy BEFORE INSERT ON pets
+          FOR EACH ROW
+            BEGIN
+              IF(IF(NEW.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_id IS NULL, 0, 1) + IF(NEW.yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy_id IS NULL, 0, 1)) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END
+        CREATE TRIGGER pfku_pets_xxxxxxxxxxxxxxxxxxxxxxxxxx_yyyyyyyyyyyyyyyyyyyyyyyyyy BEFORE UPDATE ON pets
+          FOR EACH ROW
+            BEGIN
+              IF(IF(NEW.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_id IS NULL, 0, 1) + IF(NEW.yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy_id IS NULL, 0, 1)) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END
+      EOS
     end
+  end
 
-    context "when on_delete and on_update have invalid arguments" do
-      include_context "columns with short names"
-      let(:options) { { :on_update => :invalid, :on_delete => nil } }
-      let(:fkey_sql) do
-        %{ ALTER TABLE `pets` ADD CONSTRAINT `pets_dog_id_fk` FOREIGN KEY (`dog_id`) REFERENCES `dogs`(id)
-           ALTER TABLE `pets` ADD CONSTRAINT `pets_kitty_id_fk` FOREIGN KEY (`kitty_id`) REFERENCES `cats`(name) }
-      end
+  describe '#remove_polymorphic_constraints' do
+    it 'removes triggers and foreign keys with no uniqueness constraints' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        unique: true
+      )
+      clear_sql_history
 
-      it_behaves_like "mysql2 migration statements"
+      remove_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' }
+      )
+      should_execute_sql <<-EOS
+        DROP TRIGGER IF EXISTS pfki_pets_catid_dogid
+        DROP TRIGGER IF EXISTS pfku_pets_catid_dogid
+      EOS
     end
 
-    context "when table and column names combined are very long" do
-      include_context "columns with long names"
+    it 'removes uniqueness index specified with true' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        unique: true
+      )
+      clear_sql_history
 
-      it_behaves_like "mysql2 migration statements"
+      remove_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        unique: true
+      )
+      should_execute_sql <<-EOS
+        DROP INDEX pfk_pets_catid ON pets
+        DROP INDEX pfk_pets_dogid ON pets
+      EOS
     end
-  end
 
-  describe "#triggers" do
-    let(:trigger1) { double(Trigger, :name => '1') }
-    let(:trigger2) { double(Trigger, :name => '2') }
+    it 'removes uniqueness index specified with a string' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        unique: 'name'
+      )
+      clear_sql_history
+
+      remove_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        unique: 'name'
+      )
+
+    end
+
+    it 'removes uniqueness index specified with an array' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        unique: [:name, :color]
+      )
+      clear_sql_history
+
+      remove_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        unique: [:name, :color]
+      )
+
+    end
+
+    it 'removes an on update constraint' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        on_update: :cascade
+      )
+      clear_sql_history
+
+      remove_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        on_update: :cascade
+      )
+
+    end
+
+    it 'removes an on delete constraint' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        on_delete: :cascade
+      )
+      clear_sql_history
+
+      remove_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' },
+        on_update: :cascade
+      )
 
-    before do
-      connection.stub_sql('show triggers', [:trigger1, :trigger2])
-      Trigger.stub(:new).with(:trigger1).and_return(trigger1)
-      Trigger.stub(:new).with(:trigger2).and_return(trigger2)
     end
 
-    specify do
-      connection.triggers.should == [trigger1, trigger2]
+    it 'truncates long trigger names to 64 characters' do
+      create_table(:pets) do |t|
+        t.references long_column1
+        t.references long_column2
+      end
+      args = [
+        'pets',
+        { "#{long_column1}_id" => 'cats.id', "#{long_column2}_id" => 'dogs.id' }
+      ]
+      add_polymorphic_constraints(*args)
+      clear_sql_history
+      remove_polymorphic_constraints(*args)
+      should_execute_sql <<-EOS
+        DROP TRIGGER IF EXISTS pfki_pets_xxxxxxxxxxxxxxxxxxxxxxxxxx_yyyyyyyyyyyyyyyyyyyyyyyyyy
+        DROP TRIGGER IF EXISTS pfku_pets_xxxxxxxxxxxxxxxxxxxxxxxxxx_yyyyyyyyyyyyyyyyyyyyyyyyyy
+      EOS
+    end
+  end
+
+  describe "#triggers" do
+    it 'returns the triggers for the current schema' do
+      add_polymorphic_constraints(
+        'pets',
+        { cat_id: 'cats.id', dog_id: 'dogs.id' }
+      )
+      expect(triggers.map(&:name)).to eq(
+        ['pfki_pets_catid_dogid', 'pfku_pets_catid_dogid']
+      )
     end
   end
 end