declare_schema 1.4.0.colin.6 → 1.4.0.colin.8

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,18 +59,22 @@ 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(:length) { 2 }
@@ -90,9 +91,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: "(name like 'a%')", length: 10 } }
 
-          it { is_expected.to eq(options) }
+          it { is_expected.to eq(options.except(:table_name)) }
         end
 
         describe '#with_name' do
@@ -105,33 +106,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)
+      describe '.has index_definitions_with_primary_key' do
+        subject { model_class.index_definitions_with_primary_key }
 
-          expect(result[0].name).to eq('PRIMARY')
-          expect(result[0].fields).to eq(['id'])
-          expect(result[0].unique).to eq(true)
-
-          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 +140,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 +155,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: 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: 10 }] if defined?(Mysql2)),
+              ["PRIMARY", ["id"], { length: nil, unique: true, where: nil }]
+            ].compact)
           end
         end
       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

data/spec/spec_helper.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "declare_schema"
-require "climate_control"
+require 'bundler/setup'
+require 'declare_schema'
+require 'climate_control'
+require 'pry'
 
 require_relative "./support/acceptance_spec_helpers"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: declare_schema
 version: !ruby/object:Gem::Version
-  version: 1.4.0.colin.6
+  version: 1.4.0.colin.8
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-16 00:00:00.000000000 Z
+date: 2024-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails