declare_schema 1.3.6 → 1.4.0.colin.1

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

@@ -11,7 +11,6 @@ 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
@@ -35,26 +34,103 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
       end
     end
 
-    # TODO: create model_spec.rb and move the Model specs below into it. -Colin
-    context 'Model class methods' do
-      describe '.has index_definitions' do
-        subject { model_class.index_definitions }
+    describe 'instance methods' do
+      let(:model) { model_class.new }
+      let(:fields) { ['last_name', 'first_name'] }
+      let(:options) { {} }
+      subject(:instance) { described_class.new(model_class, fields, **options) }
 
-        it 'returns indexes without primary key' do
-          expect(subject.map(&:to_key)).to eq([
-            ['index_index_definition_test_models_on_name', ['name'], false, nil],
-          ])
+      describe 'attr_readers' do
+        describe '#table' do
+          subject { instance.table }
+
+          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
+        end
+
+        describe '#fields' do
+          subject { instance.fields }
+
+          it { is_expected.to eq(fields) }
+        end
+
+        describe '#explicit_name' do
+          subject { instance.explicit_name }
+
+          it { is_expected.to eq(nil) }
+
+          context 'with name option' do
+            let(:options) { { name: 'index_auth_users_on_last_name_and_first_name' } }
+
+            it { is_expected.to eq('index_auth_users_on_last_name_and_first_name') }
+          end
+        end
+
+        describe '#length' do
+          subject { instance.length }
+          let(:options) { { length: length } }
+
+          context 'with integer length' do
+            let(:length) { 2 }
+
+            it { is_expected.to eq(length) }
+          end
+
+          context 'with Hash length' do
+            let(:length) { { name: 2 } }
+
+            it { is_expected.to eq(length) }
+          end
+        end
+
+        describe '#options' do
+          subject { instance.options }
+          let(:options) { { name: 'my_index', unique: false, where: "(name like 'a%')", length: 10 } }
+
+          it { is_expected.to eq(options) }
+        end
+
+        describe '#with_name' do
+          subject { instance.with_name('new_name') }
+
+          it { is_expected.to be_kind_of(described_class) }
+          it { expect(instance.name).to eq('index_index_definition_test_models_on_last_name_and_first_name') }
+          it { expect(subject.name).to eq('new_name') }
         end
       end
+    end
+
+    describe 'class methods' do
+      let(:model) { model_class.new }
 
-      describe '.has index_definitions_with_primary_key' do
-        subject { model_class.index_definitions_with_primary_key }
+      describe 'index_definitions' do
+        it do
+          expect(model_class.index_definitions.size).to eq(1)
 
-        it 'returns indexes with primary key' do
-          expect(subject.map(&:to_key)).to eq([
-            ['index_index_definition_test_models_on_name', ['name'], false, nil],
-            ['PRIMARY', ['id'], true, nil],
-          ])
+          expect(model_class.index_definitions[0].name).to eq('index_index_definition_test_models_on_name')
+          expect(model_class.index_definitions[0].fields).to eq(['name'])
+          expect(model_class.index_definitions[0].unique).to eq(false)
+        end
+      end
+
+      describe 'has index_definitions_with_primary_key' do
+        it do
+          expect(model_class.index_definitions_with_primary_key).to be_kind_of(Array)
+          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)
+
+          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)
         end
       end
     end
@@ -80,36 +156,29 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         ActiveRecord::Base.connection.schema_cache.clear!
       end
 
-      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) }
+      describe 'for_model' do
+        subject { described_class.for_model(model_class) }
 
         context 'with single-column PK' do
           it 'returns the indexes for the model' do
-            expect(subject.map(&:to_key)).to eq([
-              ["index_definition_test_models_on_name", ["name"], true, nil],
-              ["PRIMARY", ["id"], true, nil]
-            ])
+            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)
           end
         end
 
-        context 'with composite (multi-column) PK' do
+        context 'with compound-column PK' do
           let(:model_class) { IndexDefinitionCompoundIndexModel }
 
           it 'returns the indexes for the model' do
-            expect(subject.map(&:to_key)).to eq([
-              ["PRIMARY", ["fk1_id", "fk2_id"], true, 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([
-              ["PRIMARY", ["id"], true, nil]
-            ])
+            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)
           end
         end
       end

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

@@ -9,8 +9,6 @@ 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
@@ -29,45 +27,27 @@ RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
 
       describe '#to_key' do
         subject { model.to_key }
-        it { is_expected.to eq(['table_options_definition_test_models', "{:charset=>#{charset.inspect}, :collation=>#{collation.inspect}}"]) }
+        it { should eq(['table_options_definition_test_models', '{:charset=>"utf8", :collation=>"utf8_general"}']) }
       end
 
       describe '#settings' do
         subject { model.settings }
-        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
+        it { should eq("CHARACTER SET utf8 COLLATE utf8_general") }
       end
 
       describe '#hash' do
         subject { model.hash }
-        it { is_expected.to eq(['table_options_definition_test_models', "{:charset=>#{charset.inspect}, :collation=>#{collation.inspect}}"].hash) }
+        it { should eq(['table_options_definition_test_models', '{:charset=>"utf8", :collation=>"utf8_general"}'].hash) }
       end
 
       describe '#to_s' do
         subject { model.to_s }
-        it { is_expected.to eq("CHARACTER SET #{charset} COLLATE #{collation}") }
+        it { should eq("CHARACTER SET utf8 COLLATE utf8_general") }
       end
 
       describe '#alter_table_statement' do
         subject { model.alter_table_statement }
-        it { is_expected.to match(/execute "ALTER TABLE .*table_options_definition_test_models.* CHARACTER SET #{charset} COLLATE #{collation}"/) }
+        it { should match(/execute "ALTER TABLE .*table_options_definition_test_models.* CHARACTER SET utf8 COLLATE utf8_general"/) }
       end
     end
 
@@ -87,7 +67,7 @@ RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
             generate_migrations '-n', '-m'
           end
 
-          it { is_expected.to eq(described_class.new(model_class.table_name, **options)) }
+          it { should eq(described_class.new(model_class.table_name, **options)) }
         end
       end
     end

data/spec/lib/declare_schema/schema_change/index_add_spec.rb

@@ -30,7 +30,7 @@ RSpec.describe DeclareSchema::SchemaChange::IndexAdd do
       end
 
       context 'with where:' do
-        let(:where) { "'last_name like 'A%'"}
+        let(:where) { "'last_name like 'A%'" }
         subject { described_class.new(table_name, column_names, name: name, unique: unique, where: where) }
 
         it 'responds with command' do
@@ -45,6 +45,33 @@ RSpec.describe DeclareSchema::SchemaChange::IndexAdd do
           expect(subject.up).to eq("add_index :#{table_name}, #{column_names.map(&:to_sym).inspect}, name: #{name.to_sym.inspect}, unique: true\n")
         end
       end
+
+      context 'with limit: nil' do
+        let(:limit) { nil }
+        subject { described_class.new(table_name, column_names, name: name, unique: unique, limit: limit) }
+
+        it 'responds with command' do
+          expect(subject.up).to eq("add_index :#{table_name}, #{column_names.map(&:to_sym).inspect}, name: #{name.to_sym.inspect}\n")
+        end
+      end
+
+      context 'with limit: 2' do
+        let(:limit) { 2 }
+        subject { described_class.new(table_name, column_names, name: name, unique: unique, limit: limit) }
+
+        it 'responds with command' do
+          expect(subject.up).to eq("add_index :#{table_name}, #{column_names.map(&:to_sym).inspect}, name: #{name.to_sym.inspect}, limit: #{limit}\n")
+        end
+      end
+
+      context 'with limit: hash' do
+        let(:limit) { { last_name: 10, first_name: 1 } }
+        subject { described_class.new(table_name, column_names, name: name, unique: unique, limit: limit) }
+
+        it 'responds with command' do
+          expect(subject.up).to eq("add_index :#{table_name}, #{column_names.map(&:to_sym).inspect}, name: #{name.to_sym.inspect}, limit: { last_name: 10, first_name: 1 }\n")
+        end
+      end
     end
 
     describe '#down' do

data/spec/lib/declare_schema_spec.rb

@@ -8,54 +8,10 @@ RSpec.describe DeclareSchema do
       it { is_expected.to eq("utf8mb4") }
     end
 
-    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
-
-    context 'when MySQL version not known yet' do
-      before { described_class.remove_instance_variable('@mysql_version') rescue nil }
-      after { described_class.remove_instance_variable('@mysql_version') rescue nil }
-
-      context 'when set' do
-        let(:connection) { double("connection", select_value: "8.0.21") }
-
-        it "is lazy, so it doesn't use the database connection until read" do
-          expect(ActiveRecord::Base).to receive(:connection) do
-            @connection_called = true
-            connection
-          end
-          described_class.default_charset = "utf8"
-          expect(@connection_called).to be_falsey
-          described_class.default_charset
-          expect(@connection_called).to be_truthy
-        end
-      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
 
@@ -66,60 +22,10 @@ RSpec.describe DeclareSchema do
       it { is_expected.to eq("utf8mb4_bin") }
     end
 
-    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
-
-    context 'when MySQL version not known yet' do
-      before { described_class.remove_instance_variable('@mysql_version') rescue nil }
-      after { described_class.remove_instance_variable('@mysql_version') rescue nil }
-
-      context 'when set' do
-        let(:connection) { double("connection", select_value: "8.0.21") }
-
-        it "is lazy, so it doesn't use the database connection until read" do
-          expect(ActiveRecord::Base).to receive(:connection) do
-            @connection_called = true
-            connection
-          end
-          described_class.default_collation = "utf8_general_ci"
-          expect(@connection_called).to be_falsey
-          described_class.default_collation
-          expect(@connection_called).to be_truthy
-        end
-      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") }
     end
   end
 

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

@@ -12,8 +12,6 @@ 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
@@ -31,7 +29,7 @@ module Generators
           context 'when explicitly set' do
             before { described_class.default_charset = "utf8" }
             after  { described_class.default_charset = "utf8mb4" }
-            it     { should eq(charset) }
+            it     { should eq("utf8") }
           end
 
           it 'should output deprecation warning' do

data/spec/spec_helper.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
-require 'declare_schema'
-require 'climate_control'
-require 'pry'
+require "bundler/setup"
+require "declare_schema"
+require "climate_control"
 
 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.3.6
+  version: 1.4.0.colin.1
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-23 00:00:00.000000000 Z
+date: 2024-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails