declare_schema 1.4.0.colin.7 → 1.4.0.colin.9

data/spec/lib/declare_schema/model/habtm_model_shim_spec.rb

@@ -8,19 +8,20 @@ end
 require_relative '../../../../lib/declare_schema/model/habtm_model_shim'
 
 RSpec.describe DeclareSchema::Model::HabtmModelShim do
-  let(:join_table) { "parent_1_parent_2" }
-  let(:foreign_keys) { ["parent_1_id", "parent_2_id"] }
-  let(:foreign_key_classes) { [Parent1, Parent2] }
+  let(:join_table) { "customers_users" }
+  let(:foreign_keys) { ["user_id", "customer_id"] }
+  let(:parent_table_names) { ["users", "customers"] }
+  let(:connection) { instance_double(ActiveRecord::Base.connection.class, "connection") }
 
   before do
     load File.expand_path('../prepare_testapp.rb', __dir__)
 
-    class Parent1 < ActiveRecord::Base
-      self.table_name = "parent_1s"
+    class User < ActiveRecord::Base
+      self.table_name = "users"
     end
 
-    class Parent2 < ActiveRecord::Base
-      self.table_name = "parent_2s"
+    class Customer < ActiveRecord::Base
+      self.table_name = "customers"
     end
   end
 
@@ -29,26 +30,33 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       let(:reflection) { double("reflection", join_table: join_table,
                                               foreign_key: foreign_keys.first,
                                               association_foreign_key: foreign_keys.last,
-                                              active_record: foreign_key_classes.first,
-                                              class_name: 'Parent1') }
+                                              active_record: User,
+                                              class_name: 'Customer',
+                                              klass: Customer) }
       it 'returns a new object' do
+        expect(User).to receive(:connection).and_return(connection)
+
         result = described_class.from_reflection(reflection)
 
         expect(result).to be_a(described_class)
+        expect(result.foreign_keys).to eq(foreign_keys.reverse)
+        expect(result.parent_table_names).to eq(parent_table_names.reverse)
       end
     end
   end
 
   describe 'instance methods' do
-    let(:connection) { instance_double(ActiveRecord::Base.connection.class, "connection") }
-
-    subject { described_class.new(join_table, foreign_keys, foreign_key_classes, connection) }
+    subject { described_class.new(join_table, foreign_keys, parent_table_names, connection: connection) }
 
     describe '#initialize' do
       it 'stores initialization attributes' do
         expect(subject.join_table).to eq(join_table)
-        expect(subject.foreign_keys).to eq(foreign_keys)
-        expect(subject.foreign_key_classes).to be(foreign_key_classes)
+        expect(subject.foreign_keys).to eq(foreign_keys.reverse)
+      end
+    end
+
+    describe '#connection' do
+      it 'returns the connection' do
         expect(subject.connection).to be(connection)
       end
     end
@@ -67,51 +75,52 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
 
     describe '#field_specs' do
       it 'returns 2 field specs' do
-        result = subject.field_specs
-        expect(result.size).to eq(2), result.inspect
-
-        expect(result[foreign_keys.first]).to be_a(::DeclareSchema::Model::FieldSpec)
-        expect(result[foreign_keys.first].model).to eq(subject)
-        expect(result[foreign_keys.first].name.to_s).to eq(foreign_keys.first)
-        expect(result[foreign_keys.first].type).to eq(:integer)
-        expect(result[foreign_keys.first].position).to eq(0)
-
-        expect(result[foreign_keys.last]).to be_a(::DeclareSchema::Model::FieldSpec)
-        expect(result[foreign_keys.last].model).to eq(subject)
-        expect(result[foreign_keys.last].name.to_s).to eq(foreign_keys.last)
-        expect(result[foreign_keys.last].type).to eq(:integer)
-        expect(result[foreign_keys.last].position).to eq(1)
+        field_specs = subject.field_specs
+        expect(field_specs.size).to eq(2), field_specs.inspect
+
+        expect(field_specs[foreign_keys.first]).to be_a(::DeclareSchema::Model::FieldSpec)
+        expect(field_specs[foreign_keys.first].model).to eq(subject)
+        expect(field_specs[foreign_keys.first].name.to_s).to eq(foreign_keys.first)
+        expect(field_specs[foreign_keys.first].type).to eq(:integer)
+        expect(field_specs[foreign_keys.first].position).to eq(1)
+
+        expect(field_specs[foreign_keys.last]).to be_a(::DeclareSchema::Model::FieldSpec)
+        expect(field_specs[foreign_keys.last].model).to eq(subject)
+        expect(field_specs[foreign_keys.last].name.to_s).to eq(foreign_keys.last)
+        expect(field_specs[foreign_keys.last].type).to eq(:integer)
+        expect(field_specs[foreign_keys.last].position).to eq(0)
       end
     end
 
     describe '#primary_key' do
-      it 'returns false' do
-        expect(subject._declared_primary_key).to eq(false)
+      it 'returns false because there is no single-column PK for ActiveRecord to use' do
+        expect(subject.primary_key).to eq(false)
       end
     end
 
     describe '#_declared_primary_key' do
-      it 'returns false' do
-        expect(subject._declared_primary_key).to eq(false)
+      it 'returns the foreign key pair that are used as the primary key in the database' do
+        expect(subject._declared_primary_key).to eq(["customer_id", "user_id"])
       end
     end
 
     describe '#index_definitions_with_primary_key' do
       it 'returns 2 index definitions' do
-        result = subject.index_definitions_with_primary_key
-        expect(result.size).to eq(2), result.inspect
+        index_definitions = subject.index_definitions_with_primary_key
+        expect(index_definitions.size).to eq(2), index_definitions.inspect
 
-        expect(result.first).to be_a(::DeclareSchema::Model::IndexDefinition)
-        expect(result.first.name).to eq('PRIMARY')
-        expect(result.first.fields).to eq(['parent_1_id', 'parent_2_id'])
-        expect(result.first.unique).to be_truthy
+        expect(index_definitions.last).to be_a(::DeclareSchema::Model::IndexDefinition)
+        expect(index_definitions.last.name).to eq('PRIMARY')
+        expect(index_definitions.last.fields).to eq(foreign_keys.reverse)
+        expect(index_definitions.last.unique).to be_truthy
       end
     end
 
     context 'when table and foreign key names are long' do
       let(:join_table) { "advertiser_campaigns_tracking_pixels" }
-      let(:foreign_keys) { ['advertiser_campaign', 'tracking_pixel'] }
-      let(:foreign_key_classes) { [Table1, Table2] }
+      let(:foreign_keys_and_table_names) { [["advertiser_id", "advertisers"], ["campaign_id", "campaigns"]] }
+      let(:foreign_keys) { foreign_keys_and_table_names.map(&:first) }
+      let(:parent_table_names) { foreign_keys_and_table_names.map(&:last) }
 
       before do
         class Table1 < ActiveRecord::Base
@@ -124,19 +133,40 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       end
 
       it 'returns two index definitions and does not raise a IndexNameTooLongError' do
-        result = subject.index_definitions_with_primary_key
-        expect(result.size).to eq(2), result.inspect
-        expect(result.first).to be_a(::DeclareSchema::Model::IndexDefinition)
-        expect(result.first.name).to eq('PRIMARY')
-        expect(result.first.fields).to eq(['advertiser_campaign', 'tracking_pixel'])
-        expect(result.first.unique).to be_truthy
+        indexes = subject.index_definitions_with_primary_key.to_a
+        expect(indexes.size).to eq(2), indexes.inspect
+        expect(indexes.last).to be_a(::DeclareSchema::Model::IndexDefinition)
+        expect(indexes.last.name).to eq('PRIMARY')
+        expect(indexes.last.fields).to eq(foreign_keys)
+        expect(indexes.last.unique).to be_truthy
+        expect(indexes.first).to be_a(::DeclareSchema::Model::IndexDefinition)
+        expect(indexes.first.name).to eq('index_advertiser_campaigns_tracking_pixels_on_campaign_id')
+        expect(indexes.first.fields).to eq([foreign_keys.last])
+        expect(indexes.first.unique).to be_falsey
       end
     end
 
     describe '#index_definitions' do
+      it 'returns index_definitions' do
+        indexes = subject.index_definitions
+        expect(indexes.size).to eq(1), indexes.inspect
+        expect(indexes.first.columns).to eq(["user_id"])
+        options = [:name, :unique, :where].map { |k| [k, indexes.first.send(k)] }.to_h
+        expect(options).to eq(name: "index_customers_users_on_user_id",
+                              unique: false,
+                              where: nil)
+      end
+    end
+
+    describe '#index_definitions_with_primary_key' do
       it 'returns index_definitions_with_primary_key' do
-        result = subject.index_definitions
-        expect(result.size).to eq(2), result.inspect
+        indexes = subject.index_definitions_with_primary_key
+        expect(indexes.size).to eq(2), indexes.inspect
+        expect(indexes.last.columns).to eq(["customer_id", "user_id"])
+        options = [:name, :unique, :where].map { |k| [k, indexes.last.send(k)] }.to_h
+        expect(options).to eq(name: "PRIMARY",
+                              unique: true,
+                              where: nil)
       end
     end
 
@@ -146,21 +176,13 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       end
     end
 
-    describe '#constraint_specs' do
+    describe '#constraint_definitions' do
       it 'returns 2 foreign keys' do
-        result = subject.constraint_specs
-        expect(result.size).to eq(2), result.inspect
-
-        expect(result.first).to be_a(::DeclareSchema::Model::ForeignKeyDefinition)
-        expect(result.first.foreign_key).to eq(foreign_keys.first)
-        expect(result.first.parent_table_name).to be(Parent1.table_name)
-        expect(result.first.on_delete_cascade).to be_truthy
-
-        sample = result.to_a.last
-        expect(sample).to be_a(::DeclareSchema::Model::ForeignKeyDefinition)
-        expect(sample.foreign_key).to eq(foreign_keys.last)
-        expect(sample.parent_table_name).to be(Parent2.table_name)
-        expect(sample.on_delete_cascade).to be_truthy
+        constraints = subject.constraint_definitions
+        expect(constraints.map(&:key)).to eq([
+          ["customers_users", "customer_id", :delete],
+          ["customers_users", "user_id", :delete]
+        ])
       end
     end
   end

data/spec/lib/declare_schema/model/index_definition_spec.rb

@@ -11,6 +11,7 @@ require_relative '../../../../lib/declare_schema/model/index_definition'
 
 RSpec.describe DeclareSchema::Model::IndexDefinition do
   let(:model_class) { IndexDefinitionTestModel }
+  let(:table_name) { model_class.table_name }
 
   context 'Using declare_schema' do
     before do
@@ -34,23 +35,19 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
       end
     end
 
+    # TODO: create model_spec.rb and move the Model specs below into it. -Colin
     describe 'instance methods' do
       let(:model) { model_class.new }
+      let(:table_name) { "index_definition_test_models" }
       let(:fields) { ['last_name', 'first_name'] }
-      let(:options) { {} }
-      subject(:instance) { described_class.new(model_class, fields, **options) }
+      let(:options) { { table_name: table_name } }
+      subject(:instance) { described_class.new(fields, **options) }
 
       describe 'attr_readers' do
-        describe '#table' do
-          subject { instance.table }
+        describe '#table_name' do
+          subject { instance.table_name }
 
-          it { is_expected.to eq(model_class.table_name) }
-
-          context 'with table_name option' do
-            let(:options) { { table_name: 'auth_users' } }
-
-            it { is_expected.to eq('auth_users') }
-          end
+          it { is_expected.to eq(table_name) }
         end
 
         describe '#fields' do
@@ -62,27 +59,32 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         describe '#explicit_name' do
           subject { instance.explicit_name }
 
-          it { is_expected.to eq(nil) }
+          context 'with allow_equivalent' do
+            let(:options) { { table_name: table_name, allow_equivalent: true } }
+
+            it { is_expected.to eq(nil) }
+          end
 
           context 'with name option' do
-            let(:options) { { name: 'index_auth_users_on_last_name_and_first_name' } }
+            let(:options) { { table_name: table_name, name: 'index_auth_users_on_names' } }
 
-            it { is_expected.to eq('index_auth_users_on_last_name_and_first_name') }
+            it { is_expected.to eq('index_auth_users_on_names') }
           end
         end
 
         describe '#length' do
           subject { instance.length }
-          let(:options) { { length: length } }
+          let(:options) { { table_name: table_name, length: length } }
 
           context 'with integer length' do
+            let(:fields) { ['last_name'] }
             let(:length) { 2 }
 
-            it { is_expected.to eq(length) }
+            it { is_expected.to eq(last_name: 2) }
           end
 
           context 'with Hash length' do
-            let(:length) { { name: 2 } }
+            let(:length) { { first_name: 2 } }
 
             it { is_expected.to eq(length) }
           end
@@ -90,9 +92,9 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
 
         describe '#options' do
           subject { instance.options }
-          let(:options) { { name: 'my_index', unique: false, where: "(name like 'a%')", length: 10 } }
+          let(:options) { { name: 'my_index', table_name: table_name, unique: false, where: "(last_name like 'a%')", length: { last_name: 10, first_name: 5 } } }
 
-          it { is_expected.to eq(options) }
+          it { is_expected.to eq(options.except(:table_name)) }
         end
 
         describe '#with_name' do
@@ -105,33 +107,25 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
       end
     end
 
-    describe 'class methods' do
-      let(:model) { model_class.new }
-
-      describe 'index_definitions' do
-        it do
-          expect(model_class.index_definitions.size).to eq(1)
+    describe 'Model class methods' do
+      describe '.has index_definitions' do
+        subject { model_class.index_definitions }
 
-          sample = model_class.index_definitions.to_a.first
-          expect(sample.name).to eq('index_index_definition_test_models_on_name')
-          expect(sample.fields).to eq(['name'])
-          expect(sample.unique).to eq(false)
+        it 'returns indexes without primary key' do
+          expect(subject.map(&:to_key)).to eq([
+            ['index_index_definition_test_models_on_name', ['name'], { length: nil, unique: false, where: nil }],
+          ])
         end
       end
 
-      describe 'has index_definitions_with_primary_key' do
-        it do
-          expect(model_class.index_definitions_with_primary_key).to be_kind_of(Set)
-          result = model_class.index_definitions_with_primary_key.sort_by(&:name)
-          expect(result.size).to eq(2)
-
-          expect(result[0].name).to eq('PRIMARY')
-          expect(result[0].fields).to eq(['id'])
-          expect(result[0].unique).to eq(true)
+      describe '.has index_definitions_with_primary_key' do
+        subject { model_class.index_definitions_with_primary_key }
 
-          expect(result[1].name).to eq('index_index_definition_test_models_on_name')
-          expect(result[1].fields).to eq(['name'])
-          expect(result[1].unique).to eq(false)
+        it 'returns indexes with primary key' do
+          expect(subject.map(&:to_key)).to eq([
+            ['index_index_definition_test_models_on_name', ['name'], { length: nil, unique: false, where: nil }],
+            ['PRIMARY', ['id'], { length: nil, unique: true, where: nil }],
+          ])
         end
       end
     end
@@ -147,6 +141,11 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         ActiveRecord::Base.connection.execute <<~EOS
           CREATE UNIQUE INDEX index_definition_test_models_on_name ON index_definition_test_models(name)
         EOS
+        if defined?(Mysql2)
+          ActiveRecord::Base.connection.execute <<~EOS
+            CREATE INDEX index_definition_test_models_on_name_partial ON index_definition_test_models(name(10))
+          EOS
+        end
         ActiveRecord::Base.connection.execute <<~EOS
           CREATE TABLE index_definition_compound_index_models (
             fk1_id INTEGER NOT NULL,
@@ -157,29 +156,38 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         ActiveRecord::Base.connection.schema_cache.clear!
       end
 
-      describe 'for_model' do
-        subject { described_class.for_model(model_class) }
+      describe 'for_table' do
+        let(:ignore_indexes) { model_class.ignore_indexes }
+        subject { described_class.for_table(model_class.table_name, ignore_indexes, model_class.connection) }
 
         context 'with single-column PK' do
           it 'returns the indexes for the model' do
-            expect(subject.size).to eq(2), subject.inspect
-            expect(subject[0].name).to eq('index_definition_test_models_on_name')
-            expect(subject[0].columns).to eq(['name'])
-            expect(subject[0].unique).to eq(true)
-            expect(subject[1].name).to eq('PRIMARY')
-            expect(subject[1].columns).to eq(['id'])
-            expect(subject[1].unique).to eq(true)
+            expect(subject.map(&:to_key)).to eq([
+              ["index_definition_test_models_on_name", ["name"], { unique: true, where: nil, length: nil }],
+              (["index_definition_test_models_on_name_partial", ["name"], { unique: false, where: nil, length: { name: 10 } }] if defined?(Mysql2)),
+              ["PRIMARY", ["id"], { unique: true, where: nil, length: nil }]
+            ].compact)
           end
         end
 
-        context 'with compound-column PK' do
+        context 'with composite (multi-column) PK' do
           let(:model_class) { IndexDefinitionCompoundIndexModel }
 
           it 'returns the indexes for the model' do
-            expect(subject.size).to eq(1), subject.inspect
-            expect(subject[0].name).to eq('PRIMARY')
-            expect(subject[0].columns).to eq(['fk1_id', 'fk2_id'])
-            expect(subject[0].unique).to eq(true)
+            expect(subject.map(&:to_key)).to eq([
+              ["PRIMARY", ["fk1_id", "fk2_id"], { length: nil, unique: true, where: nil }]
+            ])
+          end
+        end
+
+        context 'with ignored_indexes' do
+          let(:ignore_indexes) { ['index_definition_test_models_on_name'] }
+
+          it 'skips the ignored index' do
+            expect(subject.map(&:to_key)).to eq([
+              (["index_definition_test_models_on_name_partial", ["name"], { unique: false, where: nil, length: { name: 10 } }] if defined?(Mysql2)),
+              ["PRIMARY", ["id"], { length: nil, unique: true, where: nil }]
+            ].compact)
           end
         end
       end
@@ -252,6 +260,69 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         end
       end
     end
+
+    describe '.normalize_index_length' do
+      let(:columns) { [:last_name] }
+      subject { described_class.normalize_index_length(length, columns: columns) }
+
+      context 'with nil length' do
+        let(:length) { nil }
+
+        it { is_expected.to eq(nil) }
+      end
+
+      context 'when Integer' do
+        let(:length) { 10 }
+
+        it { is_expected.to eq(last_name: length) }
+
+        context 'with multiple columns' do
+          let(:columns) { ["last_name", "first_name"] }
+
+          it { expect { subject }.to raise_exception(ArgumentError, /Index length of Integer only allowed when exactly one column; got 10 for \["last_name", "first_name"]/i) }
+        end
+      end
+
+      context 'when empty Hash' do
+        let(:length) { {} }
+
+        it { is_expected.to eq(nil) }
+      end
+
+      context 'when Hash' do
+        let(:length) { { last_name: 10 } }
+
+        it { is_expected.to eq(length) }
+      end
+
+      context 'when Hash with String key' do
+        let(:length) { { "last_name" => 10 } }
+
+        it { is_expected.to eq(last_name: 10) }
+      end
+
+      context 'with multiple columns' do
+        let(:columns) { [:last_name, :first_name] }
+
+        context 'when Hash with String keys' do
+          let(:length) { { "last_name" => 10, "first_name" => 5 } }
+
+          it { is_expected.to eq(last_name: 10, first_name: 5) }
+        end
+      end
+
+      context 'with nil length' do
+        let(:length) { nil }
+
+        it { is_expected.to eq(nil) }
+      end
+
+      context 'with an invalid length' do
+        let(:length) { 10.5 }
+
+        it { expect { subject }.to raise_exception(ArgumentError, /length must be nil or Integer or a Hash of column names to lengths; got 10\.5 for \[:last_name]/i) }
+      end
+    end
   end
   # TODO: fill out remaining tests
 end

data/spec/lib/declare_schema/model/table_options_definition_spec.rb

@@ -9,6 +9,8 @@ require_relative '../../../../lib/declare_schema/model/table_options_definition'
 
 RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
   let(:model_class) { TableOptionsDefinitionTestModel }
+  let(:charset) { DeclareSchema.normalize_charset('utf8') }
+  let(:collation) { DeclareSchema.normalize_collation('utf8_general') } # adapt so that tests will pass on MySQL 5.7 or 8+
 
   context 'Using declare_schema' do
     before do
@@ -27,27 +29,45 @@ RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
 
       describe '#to_key' do
         subject { model.to_key }
-        it { should eq(['table_options_definition_test_models', '{:charset=>"utf8", :collation=>"utf8_general"}']) }
+        it { is_expected.to eq(['table_options_definition_test_models', "{:charset=>#{charset.inspect}, :collation=>#{collation.inspect}}"]) }
       end
 
       describe '#settings' do
         subject { model.settings }
-        it { should eq("CHARACTER SET utf8 COLLATE utf8_general") }
+        it { is_expected.to eq("CHARACTER SET #{charset} COLLATE #{collation}") }
+
+        if defined?(Mysql2)
+          context 'when running in MySQL 8' do
+            around do |spec|
+              DeclareSchema.mysql_version = Gem::Version.new('8.0.21')
+              spec.run
+            ensure
+              DeclareSchema.remove_instance_variable('@mysql_version') rescue nil
+            end
+
+            it { is_expected.to eq("CHARACTER SET utf8mb3 COLLATE utf8mb3_general") }
+
+            context 'when _ci collation' do
+              let(:table_options) { { charset: "utf8", collation: "utf8_general_ci"} }
+              it { is_expected.to eq("CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci") }
+            end
+          end
+        end
       end
 
       describe '#hash' do
         subject { model.hash }
-        it { should eq(['table_options_definition_test_models', '{:charset=>"utf8", :collation=>"utf8_general"}'].hash) }
+        it { is_expected.to eq(['table_options_definition_test_models', "{:charset=>#{charset.inspect}, :collation=>#{collation.inspect}}"].hash) }
       end
 
       describe '#to_s' do
         subject { model.to_s }
-        it { should eq("CHARACTER SET utf8 COLLATE utf8_general") }
+        it { is_expected.to eq("CHARACTER SET #{charset} COLLATE #{collation}") }
       end
 
       describe '#alter_table_statement' do
         subject { model.alter_table_statement }
-        it { should match(/execute "ALTER TABLE .*table_options_definition_test_models.* CHARACTER SET utf8 COLLATE utf8_general"/) }
+        it { is_expected.to match(/execute "ALTER TABLE .*table_options_definition_test_models.* CHARACTER SET #{charset} COLLATE #{collation}"/) }
       end
     end
 
@@ -67,7 +87,7 @@ RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
             generate_migrations '-n', '-m'
           end
 
-          it { should eq(described_class.new(model_class.table_name, **options)) }
+          it { is_expected.to eq(described_class.new(model_class.table_name, **options)) }
         end
       end
     end

data/spec/lib/declare_schema_spec.rb

@@ -8,10 +8,34 @@ RSpec.describe DeclareSchema do
       it { is_expected.to eq("utf8mb4") }
     end
 
-    context 'when explicitly set' do
-      before { described_class.default_charset = "utf8" }
-      after  { described_class.default_charset = "utf8mb4" }
-      it     { is_expected.to eq("utf8") }
+    context 'when running on MySQL 5.7' do
+      around do |spec|
+        described_class.mysql_version = Gem::Version.new('5.7.48')
+        spec.run
+      ensure
+        described_class.remove_instance_variable('@mysql_version') rescue nil
+      end
+
+      context 'when explicitly set' do
+        before { described_class.default_charset = "utf8" }
+        after  { described_class.default_charset = "utf8mb4" }
+        it     { is_expected.to eq("utf8") }
+      end
+    end
+
+    context 'when running on MySQL 8.0' do
+      around do |spec|
+        described_class.mysql_version = Gem::Version.new('8.0.21')
+        spec.run
+      ensure
+        described_class.remove_instance_variable('@mysql_version') rescue nil
+      end
+
+      context 'when explicitly set' do
+        before { described_class.default_charset = "utf8" }
+        after  { described_class.default_charset = "utf8mb4" }
+        it     { is_expected.to eq("utf8mb3") }
+      end
     end
   end
 
@@ -22,10 +46,40 @@ RSpec.describe DeclareSchema do
       it { is_expected.to eq("utf8mb4_bin") }
     end
 
-    context 'when explicitly set' do
-      before { described_class.default_collation = "utf8mb4_general_ci" }
-      after  { described_class.default_collation = "utf8mb4_bin" }
-      it     { is_expected.to eq("utf8mb4_general_ci") }
+    context 'when running on MySQL 5.7' do
+      around do |spec|
+        described_class.mysql_version = Gem::Version.new('5.7.48')
+        spec.run
+      ensure
+        described_class.remove_instance_variable('@mysql_version')
+      end
+
+      context 'when explicitly set' do
+        before { described_class.default_collation = "utf8_general_ci" }
+        after  { described_class.default_collation = "utf8mb4_bin" }
+        it     { is_expected.to eq("utf8_general_ci") }
+      end
+    end
+
+    context 'when running on MySQL 8.0' do
+      around do |spec|
+        described_class.mysql_version = Gem::Version.new('8.0.21')
+        spec.run
+      ensure
+        described_class.remove_instance_variable('@mysql_version')
+      end
+
+      context 'when explicitly set without _ci' do
+        before { described_class.default_collation = "utf8_general" }
+        after  { described_class.default_collation = "utf8mb4_bin" }
+        it     { is_expected.to eq("utf8mb3_general") }
+      end
+
+      context 'when explicitly set with _ci' do
+        before { described_class.default_collation = "utf8_general_ci" }
+        after  { described_class.default_collation = "utf8mb4_bin" }
+        it     { is_expected.to eq("utf8mb3_general_ci") }
+      end
     end
   end
 

data/spec/lib/generators/declare_schema/migration/migrator_spec.rb

@@ -12,6 +12,8 @@ module Generators
     module Migration
       RSpec.describe Migrator do
         subject { described_class.new }
+        let(:charset) { ::DeclareSchema.normalize_charset('utf8') }
+        let(:collation) { ::DeclareSchema.normalize_collation('utf8_general') } # adapt so that tests will pass on MySQL 5.7 or 8+
 
         describe '#before_generating_migration' do
           it 'requires a block be passed' do
@@ -29,7 +31,7 @@ module Generators
           context 'when explicitly set' do
             before { described_class.default_charset = "utf8" }
             after  { described_class.default_charset = "utf8mb4" }
-            it     { should eq("utf8") }
+            it     { should eq(charset) }
           end
 
           it 'should output deprecation warning' do