rails-bigint-pk 0.0.2

data/spec/integration/schema_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+describe 'Migrations', :integration do
+  after :each do
+    execute_sql %Q{
+      delete from rulers;
+      delete from empires;
+    }
+  end
+
+  describe 'create_table' do
+    before :each do
+      in_directory( RailsDir ) do
+        run 'rails generate bigint_pk:install'
+        FileUtils.rm Dir['./db/migrate/**change_keys_to_bigint*'].first
+      end
+    end
+
+    def self.they_use_bigint_primary_keys
+      describe 'primary keys' do
+        they 'default to 64bit' do
+          expect{
+            execute_sql %Q{
+              insert into empires values(#{2 ** 31 - 1});
+              insert into empires values(#{2 ** 31});
+            }
+          }.to_not raise_error
+
+          expect(
+            execute_ruby 'puts Empire.all.collect(&:id)'
+          ).to eq ["#{2**31-1}", "#{2**31}"].join("\n")
+        end
+      end
+    end
+
+    def self.they_use_bigint_foreign_keys
+      describe 'foreign keys' do
+        they 'can reference 64bit values' do
+          expect{
+            execute_sql %Q{
+              insert into empires values(#{2 ** 31 - 1});
+              insert into empires values(#{2 ** 31});
+              insert into rulers( empire_id ) values(#{2 ** 31 - 1});
+              insert into rulers( empire_id ) values(#{2 ** 31});
+            }
+          }.to_not raise_error
+
+          expect(
+            execute_ruby 'puts Ruler.all.map{|r| r.empire_id}'
+          ).to eq ["#{2**31 - 1}", "#{2**31}"].join("\n")
+        end
+
+        context 'that were added to an existing table' do
+          they 'can reference 64bit values' do
+            expect{
+              execute_sql %Q{
+                insert into rulers( id ) values(#{2 ** 31 - 1});
+                insert into rulers( id ) values(#{2 ** 31});
+
+                insert into rulers( favourite_ruler_id ) values(#{2 ** 31 - 1});
+                insert into rulers( favourite_ruler_id ) values(#{2 ** 31});
+              }
+            }.to_not raise_error
+
+            expect(
+              execute_ruby('puts Ruler.all.map{|r| r.favourite_ruler_id}').split
+            ).to eq ["#{2**31 - 1}", "#{2**31}"]
+          end
+        end
+      end
+    end
+
+    context 'with a mysql database' do
+      before(:each) do
+        use_database! :mysql
+        rake 'db:migrate'
+      end
+
+      they_use_bigint_primary_keys
+      they_use_bigint_foreign_keys
+    end
+
+    context 'with a postgresql database' do
+      before(:each) do
+        use_database! :postgres
+        rake 'db:migrate'
+      end
+
+      they_use_bigint_primary_keys
+      they_use_bigint_foreign_keys
+    end
+
+    context 'with a sqlite3 database' do
+      before(:each) do
+        use_database! :sqlite3
+        rake 'db:migrate'
+      end
+
+      they_use_bigint_primary_keys
+      they_use_bigint_foreign_keys
+    end
+  end
+
+  describe 'existing tables' do
+    InitializerFile = "./config/initializers/bigint_pk.rb"
+
+    before :each do
+      in_directory( RailsDir ) do
+        run 'rails generate bigint_pk:install'
+
+        initializer = File.read InitializerFile
+        initializer.gsub!( /enabled = true/, 'enabled = false' )
+        File.open( InitializerFile, 'w'){|f| f.print initializer }
+      end
+    end
+
+    def self.they_have_their_primary_keys_migrated
+      they 'have their primary keys migrated' do
+        expect{
+          execute_sql %Q{
+            insert into empires values(#{2 ** 31 - 1});
+            insert into empires values(#{2 ** 31});
+          }
+        }.to raise_error
+
+        execute_ruby 'Empire.delete_all'
+        rake 'db:migrate'
+
+        expect{
+          execute_sql %Q{
+            insert into empires values(#{2 ** 31 - 1});
+            insert into empires values(#{2 ** 31});
+          }
+        }.to_not raise_error
+      end
+    end
+
+    def self.they_have_their_foreign_keys_migrated
+      they 'have their foreign keys migrated' do
+        expect{
+          execute_sql %Q{
+            insert into empires values(#{2 ** 31 - 1});
+            insert into empires values(#{2 ** 31});
+            insert into rulers( empire_id ) values(#{2 ** 31});
+            insert into rulers( empire_id ) values(#{2 ** 31 - 1});
+          }
+        }.to raise_error
+
+        execute_ruby 'Ruler.delete_all'
+        execute_ruby 'Empire.delete_all'
+        rake 'db:migrate'
+
+        expect{
+          execute_sql %Q{
+            insert into empires values(#{2 ** 31 - 1});
+            insert into empires values(#{2 ** 31});
+            insert into rulers( empire_id ) values(#{2 ** 31 - 1});
+            insert into rulers( empire_id ) values(#{2 ** 31});
+          }
+        }.to_not raise_error
+
+        expect(
+          execute_ruby 'puts Ruler.all.collect{|r| [r.id, r.empire.id]}'
+        ).to eq [ "1", "#{2**31 - 1}",
+                  "2", "#{2**31}"].join("\n")
+      end
+    end
+
+    context 'with a mysql database' do
+      before(:each) do
+        use_database! :mysql
+        rake 'db:migrate VERSION=19000101100000'
+      end
+
+      they_have_their_primary_keys_migrated
+      they_have_their_foreign_keys_migrated
+    end
+
+    context 'with a postgresql database' do
+      before(:each) do
+        use_database! :postgres
+        rake 'db:migrate VERSION=19000101100000'
+      end
+
+      they_have_their_primary_keys_migrated
+      they_have_their_foreign_keys_migrated
+    end
+  end
+
+  describe "with models & migrations created after bigint migration" do
+    before :each do
+      in_directory( RailsDir ) do
+        run 'rails generate bigint_pk:install'
+        run 'rails generate model subject'
+      end
+    end
+
+    def self.it_completes_migration
+      it "completes the migration" do
+        in_directory( RailsDir ) do
+          run("rake db:migrate")
+        end
+      end
+    end
+    
+    context "with a mysql database" do
+      before(:each) do
+        use_database! :mysql
+      end
+
+      it_completes_migration
+    end
+    
+    context "with a postgresql database" do
+      before(:each) do
+        use_database! :postgres
+      end
+
+      it_completes_migration
+    end
+  end
+end

data/spec/migration_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'generators/bigint_pk/templates/migration'
+
+describe 'ChangeKeysToBigint' do
+  let(:connection) do
+    double('Connection').tap do |c|
+      c.stub(:quote_table_name){|tn| "`#{tn}`"}
+      c.stub(:quote_column_name){|column| "`#{column}`"}
+      c.stub(:table_exists?) { true }
+      c.stub(:execute){|sql| queries << sql }
+      c.stub(:column_exists?) do |table_name, column_name|
+        if table_name.to_s == 'coaches' && column_name == 'team_id'
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+  let(:queries){ [] }
+
+  before do
+    stub_const('Team', double('Team', table_name: 'teams', primary_key: 'id'))
+    stub_const('Player', double('Player', table_name: 'players', primary_key: 'id'))
+    stub_const('Coach', double('Coach', table_name: 'coaches', primary_key: 'id'))
+    Team.stub( reflect_on_all_associations: [])
+    Player.stub( reflect_on_all_associations: [
+      double('belongs_to', macro: :belongs_to, foreign_key: 'team_id')])
+    Coach.stub( reflect_on_all_associations: [
+      double('belongs_to', macro: :belongs_to, foreign_key: 'team_id')])
+
+    stub_const('Rails', double('Rails'))
+    Rails.stub_chain 'application.eager_load!'
+
+    ActiveRecord::Base.stub( subclasses: [ Team, Player, Coach ], connection: connection)
+    ActiveRecord::Base.stub_chain('connection_pool.with_connection') do |&prok|
+      prok.call connection
+    end
+  end
+
+  context 'with a postgres database' do
+    before { connection.stub( adapter_name: 'PostgreSQL') }
+
+    it 'migrates primary keys' do
+      ChangeKeysToBigint.migrate :up
+      expect( queries ).to include(
+        'ALTER TABLE `teams` ALTER COLUMN `id` TYPE bigint',
+        'ALTER TABLE `players` ALTER COLUMN `id` TYPE bigint',
+        'ALTER TABLE `coaches` ALTER COLUMN `id` TYPE bigint'
+      )
+    end
+
+    it 'migrates foreign keys' do
+      ChangeKeysToBigint.migrate :up
+      expect( queries ).to include(
+        'ALTER TABLE `players` ALTER COLUMN `team_id` TYPE bigint'
+      )
+    end
+
+    it 'does not migrate foreign keys that do not exist in database' do
+      ChangeKeysToBigint.migrate :up
+      expect( queries ).to_not include(
+        'ALTER TABLE `coaches` ALTER COLUMN `team_id` TYPE bigint'
+      )
+    end
+  end
+
+  context 'with a mysql database' do
+    before { connection.stub( adapter_name: 'MySQL') }
+
+    it 'migrates primary keys' do
+      ChangeKeysToBigint.migrate :up
+      expect( queries ).to include(
+        'ALTER TABLE `teams` MODIFY COLUMN `id` bigint(20) DEFAULT NULL auto_increment',
+        'ALTER TABLE `players` MODIFY COLUMN `id` bigint(20) DEFAULT NULL auto_increment',
+        'ALTER TABLE `coaches` MODIFY COLUMN `id` bigint(20) DEFAULT NULL auto_increment'
+      )
+    end
+
+    it 'migrates foreign keys' do
+      ChangeKeysToBigint.migrate :up
+      expect( queries ).to include(
+        'ALTER TABLE `players` MODIFY COLUMN `team_id` bigint(20) DEFAULT NULL')
+    end
+
+    it 'does not migrate foreign keys that do not exist in database' do
+      ChangeKeysToBigint.migrate :up
+      expect( queries ).to_not include(
+        'ALTER TABLE `coaches` MODIFY COLUMN `team_id` bigint(20) DEFAULT NULL'
+      )
+    end
+  end
+
+  context 'with a sqlite database' do
+    before { connection.stub( adapter_name: 'SQLite') }
+
+    it 'does not migrate any keys' do
+      ChangeKeysToBigint.migrate :up
+      expect( queries ).to eq []
+    end
+  end
+end

data/spec/monkey_patch/connection_adapters_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+require 'active_record/connection_adapters/postgresql_adapter'
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+
+describe BigintPk do
+  describe '::setup' do
+    def reset_connection_adapters!
+      if defined? ::ActiveRecord::ConnectionAdapters
+        [:PostgreSQLAdapter, :AbstractMysqlAdapter].each do |adapter|
+          if ActiveRecord::ConnectionAdapters.const_defined? adapter
+            ActiveRecord::ConnectionAdapters.send :remove_const, adapter
+          end
+        end
+      end
+      load 'active_record/connection_adapters/postgresql_adapter.rb'
+      load 'active_record/connection_adapters/abstract_mysql_adapter.rb'
+    end
+
+    before do
+      ActiveRecord::Base.class_eval do
+        def self.establish_connection; end
+      end
+
+      reset_connection_adapters!
+      BigintPk.setup &prok
+    end
+
+    context 'when enabled' do
+      let(:prok){ lambda{|c| c.enabled = true }}
+
+      it 'updates the default primary key for the postgres adapter' do
+        expect(
+          ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::
+            NATIVE_DATABASE_TYPES[:primary_key]
+        ).to eq 'bigserial primary key'
+      end
+
+      it 'updates the default primary key for both mysql adapters' do
+        expect(
+          ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::
+            NATIVE_DATABASE_TYPES[:primary_key]
+        ).to eq 'bigint(20) DEFAULT NULL auto_increment PRIMARY KEY'
+      end
+
+      def self.it_makes_references_default_to_64bit
+        describe '#references' do
+          before { abstract_table_class.any_instance.stub :references_without_default_bigint_fk }
+
+
+          let(:args){ ['some_other_table', options ].compact }
+
+          context 'when a limit is specified' do
+            let(:options){{ limit: 6 }}
+
+            it 'uses the specified limit' do
+              abstract_table.should_receive(:references_without_default_bigint_fk).with(
+                'some_other_table', hash_including( limit: 6 )
+              )
+              abstract_table.references *args
+            end
+          end
+
+          context 'when a limit is not specified' do
+            let(:options){}
+
+            it 'defaults the limit to 8' do
+              abstract_table.should_receive(:references_without_default_bigint_fk).with(
+                'some_other_table', hash_including( limit: 8 )
+              )
+              abstract_table.references *args
+            end
+          end
+
+          context 'when reference is polymorphic' do
+            context 'when there is not additional options' do
+              let(:options){{ polymorphic: true }}
+
+              it 'should not contain limit' do
+                abstract_table.should_receive(:references_without_default_bigint_fk).with(
+                  'some_other_table', hash_including( polymorphic: {} )
+                )
+                abstract_table.references *args
+              end
+            end
+
+            context 'when there is common options' do
+              let(:options){{ null: false, polymorphic: true }}
+
+              it "should contain common options" do
+                abstract_table.should_receive(:references_without_default_bigint_fk).with(
+                  'some_other_table', hash_including( polymorphic: { null: false } )
+                )
+                abstract_table.references *args
+              end
+            end
+
+            context "when there is polymorphic options" do
+              let(:options){{ null: false, polymorphic: { limit: 120 } }}
+
+              it "should contain polymorphic options" do
+                abstract_table.should_receive(:references_without_default_bigint_fk).with(
+                  'some_other_table', hash_including( polymorphic: { limit: 120 } )
+                )
+                abstract_table.references *args
+              end
+            end
+          end
+        end
+      end
+
+      describe ActiveRecord::ConnectionAdapters::Table do
+        let(:abstract_table_class){ ActiveRecord::ConnectionAdapters::TableDefinition }
+        let(:abstract_table){ abstract_table_class.new Object.new }
+        it_makes_references_default_to_64bit
+      end
+
+      describe ActiveRecord::ConnectionAdapters::TableDefinition do
+        let(:connection_adapter_double) do
+          double("Connection Adapter").tap do |double|
+            double.stub :add_column
+          end
+        end
+        let(:abstract_table_class){ ActiveRecord::ConnectionAdapters::Table }
+        let(:abstract_table) do
+          abstract_table_class.new 'test_table', connection_adapter_double
+        end
+        it_makes_references_default_to_64bit
+      end
+    end
+
+    context 'when not enabled' do
+      let(:prok){ lambda{|c| c.enabled = false }}
+
+      it 'does not alter the default primary key for the postgres adapter' do
+        expect(
+          ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::
+            NATIVE_DATABASE_TYPES[:primary_key]
+        ).to eq 'serial primary key'
+      end
+
+      it 'does not alter the default primary key for either mysql adapters' do
+        expect(
+          ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::
+            NATIVE_DATABASE_TYPES[:primary_key]
+        ).to eq 'int(11) DEFAULT NULL auto_increment PRIMARY KEY'
+      end
+    end
+  end
+end