declare_schema 0.6.0 → 0.7.0

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+begin
+  require 'mysql2'
+rescue LoadError
+end
+
+require_relative '../../../../lib/declare_schema/model/column'
+
+RSpec.describe DeclareSchema::Model::Column do
+  before do
+    load File.expand_path('../prepare_testapp.rb', __dir__)
+  end
+
+  describe 'class methods' do
+    describe '.native_type?' do
+      if Rails::VERSION::MAJOR >= 5
+        let(:native_types) { [:string, :text, :integer, :float, :decimal, :datetime, :time, :date, :binary, :boolean, :json] }
+      else
+        let(:native_types) { [:string, :text, :integer, :float, :decimal, :datetime, :time, :date, :binary, :boolean] }
+      end
+
+      it 'is falsey for :primary_key' do
+        expect(described_class.native_type?(:primary_key)).to be_falsey
+      end
+
+      it 'is truthy for native types' do
+        native_types.each do |type|
+          expect(described_class.native_type?(type)).to be_truthy, type.inspect
+        end
+      end
+
+      it 'is falsey for other types' do
+        [:email, :url].each do |type|
+          expect(described_class.native_type?(type)).to be_falsey
+        end
+      end
+    end
+
+    describe '.native_types' do
+      subject { described_class.native_types }
+
+      it 'returns the native type for :primary_key' do
+        expect(subject[:primary_key]).to match(/auto_increment PRIMARY KEY|PRIMARY KEY AUTOINCREMENT NOT NULL/)
+      end
+
+      it 'returns the native type for :string' do
+        expect(subject.dig(:string, :name)).to eq('varchar')
+      end
+
+      it 'returns the native type for :integer' do
+        expect(subject.dig(:integer, :name)).to match(/int/)
+      end
+
+      it 'returns the native type for :datetime' do
+        expect(subject.dig(:datetime, :name)).to eq('datetime')
+      end
+    end
+
+    describe '.sql_type' do
+      it 'returns the sql type for :string' do
+        expect(described_class.sql_type(:string)).to eq(:string)
+      end
+
+      it 'returns the sql type for :integer' do
+        expect(described_class.sql_type(:integer)).to match(:integer)
+      end
+
+      it 'returns the sql type for :datetime' do
+        expect(described_class.sql_type(:datetime)).to eq(:datetime)
+      end
+
+      it 'raises UnknownSqlType' do
+        expect do
+          described_class.sql_type(:email)
+        end.to raise_exception(::DeclareSchema::UnknownSqlTypeError, /:email for type :email/)
+      end
+    end
+
+    describe '.deserialize_default_value' do
+      require 'rails'
+
+      if ::Rails::VERSION::MAJOR >= 5
+        it 'deserializes :boolean' do
+          expect(described_class.deserialize_default_value(nil, :boolean, 'true')).to eq(true)
+          expect(described_class.deserialize_default_value(nil, :boolean, 'false')).to eq(false)
+        end
+
+        it 'deserializes :integer' do
+          expect(described_class.deserialize_default_value(nil, :integer, '12')).to eq(12)
+        end
+
+        it 'deserializes :json' do
+          expect(described_class.deserialize_default_value(nil, :json, '{}')).to eq({})
+        end
+      end
+    end
+  end
+
+  describe 'instance methods' do
+    before do
+      class ColumnTestModel < ActiveRecord::Base
+        fields do
+          title :string, limit: 127, null: false
+          count :integer, null: false
+        end
+      end
+    end
+    let(:model) { ColumnTestModel }
+    let(:current_table_name) { model.table_name }
+    let(:column) { double("ActiveRecord Column",
+                          name: 'count',
+                          type: :integer,
+                          limit: nil,
+                          precision: nil,
+                          scale: nil,
+                          type_cast_from_database: nil,
+                          null: false,
+                          default: nil,
+                          sql_type_metadata: {}) }
+    subject { described_class.new(model, current_table_name, column) }
+
+    describe '#sql_type' do
+      it 'returns sql type' do
+        expect(subject.sql_type).to match(/int/)
+      end
+    end
+
+    describe '#schema_attributes' do
+      it 'returns a hash with relevant key/values' do
+        if defined?(Mysql2)
+          expect(subject.schema_attributes).to eq(type: :integer, null: false, limit: 4)
+        else
+          expect(subject.schema_attributes).to eq(type: :integer, null: false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative '../../../../lib/declare_schema/model/foreign_key_definition'
+
+RSpec.describe DeclareSchema::Model::ForeignKeyDefinition do
+  before do
+    load File.expand_path('../prepare_testapp.rb', __dir__)
+
+    class Network < ActiveRecord::Base
+      fields do
+        name :string, limit: 127, index: true
+
+        timestamps
+      end
+    end
+  end
+
+  let(:model_class) { Network }
+
+  describe 'instance methods' do
+    let(:connection) { instance_double(ActiveRecord::Base.connection.class) }
+    let(:model) { instance_double('Model', table_name: 'models', connection: connection) }
+    let(:foreign_key) { :network_id }
+    let(:options) { {} }
+    subject { described_class.new(model, foreign_key, options)}
+
+    before do
+      allow(connection).to receive(:index_name).with('models', column: 'network_id') { 'on_network_id' }
+    end
+
+    describe '#initialize' do
+      it 'normalizes symbols to strings' do
+        expect(subject.foreign_key).to eq('network_id')
+        expect(subject.parent_table_name).to eq('networks')
+      end
+
+      context 'when most options passed' do
+        let(:options) { { parent_table: :networks, foreign_key: :the_network_id, index_name: :index_on_network_id } }
+
+        it 'normalizes symbols to strings' do
+          expect(subject.foreign_key).to eq('network_id')
+          expect(subject.foreign_key_name).to eq('the_network_id')
+          expect(subject.parent_table_name).to eq('networks')
+          expect(subject.foreign_key).to eq('network_id')
+          expect(subject.constraint_name).to eq('index_on_network_id')
+          expect(subject.on_delete_cascade).to be_falsey
+        end
+      end
+
+      context 'when all options passed' do
+        let(:foreign_key) { nil }
+        let(:options) { { parent_table: :networks, foreign_key: :the_network_id, index_name: :index_on_network_id,
+                          constraint_name: :constraint_1, dependent: :delete } }
+
+        it 'normalizes symbols to strings' do
+          expect(subject.foreign_key).to be_nil
+          expect(subject.foreign_key_name).to eq('the_network_id')
+          expect(subject.parent_table_name).to eq('networks')
+          expect(subject.constraint_name).to eq('constraint_1')
+          expect(subject.on_delete_cascade).to be_truthy
+        end
+      end
+    end
+
+    describe '#to_add_statement' do
+      it 'returns add_foreign_key command' do
+        expect(subject.to_add_statement).to eq('add_foreign_key("models", "networks", column: "network_id", name: "on_network_id")')
+      end
+    end
+  end
+
+  describe 'class << self' do
+    let(:connection) { instance_double(ActiveRecord::Base.connection.class) }
+    let(:model) { instance_double('Model', table_name: 'models', connection: connection) }
+    let(:old_table_name) { 'networks' }
+    before do
+      allow(connection).to receive(:quote_table_name).with('networks') { 'networks' }
+      allow(connection).to receive(:select_rows) { [['CONSTRAINT `constraint` FOREIGN KEY (`network_id`) REFERENCES `networks` (`id`)']] }
+      allow(connection).to receive(:index_name).with('models', column: 'network_id') { }
+    end
+
+    describe '.for_model' do
+      subject { described_class.for_model(model, old_table_name) }
+
+      it 'returns new object' do
+        expect(subject.size).to eq(1), subject.inspect
+        expect(subject.first).to be_kind_of(described_class)
+        expect(subject.first.foreign_key).to eq('network_id')
+      end
+    end
+  end
+  # TODO: fill out remaining tests
+end

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

@@ -64,7 +64,7 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         ActiveRecord::Base.connection.execute <<~EOS
             CREATE TABLE index_definition_test_models (
               id INTEGER NOT NULL PRIMARY KEY,
-              name TEXT NOT NULL
+              name #{if defined?(Sqlite3) then 'TEXT' else 'VARCHAR(255)' end} NOT NULL
             )
         EOS
         ActiveRecord::Base.connection.execute <<~EOS
@@ -72,8 +72,8 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         EOS
         ActiveRecord::Base.connection.execute <<~EOS
             CREATE TABLE index_definition_compound_index_models (
-              fk1_id INTEGER NULL,
-              fk2_id INTEGER NULL,
+              fk1_id INTEGER NOT NULL,
+              fk2_id INTEGER NOT NULL,
               PRIMARY KEY (fk1_id, fk2_id)
             )
         EOS
@@ -99,10 +99,9 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
           let(:model_class) { IndexDefinitionCompoundIndexModel }
 
           it 'returns the indexes for the model' do
-            # Simulate MySQL for Rails 4 work-around
             if Rails::VERSION::MAJOR < 5
               expect(model_class.connection).to receive(:primary_key).with('index_definition_compound_index_models').and_return(nil)
-              connection_stub = instance_double(ActiveRecord::ConnectionAdapters::SQLite3Adapter, "connection")
+              connection_stub = instance_double(ActiveRecord::Base.connection.class, "connection")
               expect(connection_stub).to receive(:indexes).
                 with('index_definition_compound_index_models').
                 and_return([DeclareSchema::Model::IndexDefinition.new(model_class, ['fk1_id', 'fk2_id'], name: 'PRIMARY')])

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

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
-require 'active_record/connection_adapters/mysql2_adapter'
+begin
+  require 'mysql2'
+  require 'active_record/connection_adapters/mysql2_adapter'
+rescue LoadError
+end
 require_relative '../../../../lib/declare_schema/model/table_options_definition'
 
 RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
@@ -22,7 +26,7 @@ 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 { should eq(['table_options_definition_test_models', '{:charset=>"utf8", :collation=>"utf8_general"}']) }
     end
 
     describe '#settings' do
@@ -32,7 +36,7 @@ RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
 
     describe '#hash' do
       subject { model.hash }
-      it { should eq(["table_options_definition_test_models", "{:charset=>\"utf8\", :collation=>\"utf8_general\"}"].hash) }
+      it { should eq(['table_options_definition_test_models', '{:charset=>"utf8", :collation=>"utf8_general"}'].hash) }
     end
 
     describe '#to_s' do
@@ -42,42 +46,28 @@ RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
 
     describe '#alter_table_statement' do
       subject { model.alter_table_statement }
-      it { should eq('execute "ALTER TABLE \"table_options_definition_test_models\" CHARACTER SET utf8 COLLATE utf8_general;"') }
+      it { should match(/execute "ALTER TABLE .*table_options_definition_test_models.* CHARACTER SET utf8 COLLATE utf8_general"/) }
     end
   end
 
 
   context 'class << self' do
     describe '#for_model' do
-      context 'when using a SQLite connection' do
+      context 'when database migrated' do
+        let(:options) do
+          if defined?(Mysql2)
+            { charset: "utf8mb4", collation: "utf8mb4_bin" }
+          else
+            { }
+          end
+        end
         subject { described_class.for_model(model_class) }
-        it { should eq(described_class.new(model_class.table_name, {})) }
-      end
-      # TODO: Convert these tests to run against a MySQL database so that we can
-      #       perform them without mocking out so much
-      context 'when using a MySQL connection' do
+
         before do
-          double(ActiveRecord::ConnectionAdapters::Mysql2Adapter).tap do |stub_connection|
-            expect(stub_connection).to receive(:class).and_return(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
-            expect(stub_connection).to receive(:current_database).and_return('test_database')
-            expect(stub_connection).to receive(:quote_string).with('test_database').and_return('test_database')
-            expect(stub_connection).to receive(:quote_string).with(model_class.table_name).and_return(model_class.table_name)
-            expect(stub_connection).to(
-              receive(:select_one).with(<<~EOS)
-                SELECT CCSA.character_set_name, CCSA.collation_name
-                FROM information_schema.`TABLES` T, information_schema.`COLLATION_CHARACTER_SET_APPLICABILITY` CCSA
-                WHERE CCSA.collation_name = T.table_collation AND
-                      T.table_schema = 'test_database' AND
-                      T.table_name = '#{model_class.table_name}';
-              EOS
-              .and_return({ "character_set_name" => "utf8", "collation_name" => "utf8_general" })
-            )
-            allow(model_class).to receive(:connection).and_return(stub_connection)
-          end
+          generate_migrations '-n', '-m'
         end
 
-        subject { described_class.for_model(model_class) }
-        it { should eq(described_class.new(model_class.table_name, { charset: "utf8", collation: "utf8_general" })) }
+        it { should eq(described_class.new(model_class.table_name, options)) }
       end
     end
   end

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

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+begin
+  require 'mysql2'
+rescue LoadError
+end
 require 'rails'
 require 'rails/generators'
 
@@ -14,26 +18,8 @@ module Generators
         subject { described_class.new }
 
         describe 'format_options' do
-          let(:mysql_longtext_limit) { 0xffff_ffff }
-
-          context 'MySQL' do
-            before do
-              expect(::DeclareSchema::Model::FieldSpec).to receive(:mysql_text_limits?).and_return(true)
-            end
-
-            it 'returns text limits' do
-              expect(subject.format_options({ limit: mysql_longtext_limit }, :text)).to eq(["limit: #{mysql_longtext_limit}"])
-            end
-          end
-
-          context 'non-MySQL' do
-            before do
-              expect(::DeclareSchema::Model::FieldSpec).to receive(:mysql_text_limits?).and_return(false)
-            end
-
-            it 'returns text limits' do
-              expect(subject.format_options({ limit: mysql_longtext_limit }, :text)).to eq([])
-            end
+          it 'returns an array of option .inspect strings, with symbols using the modern : hash notation' do
+            expect(subject.format_options({ limit: 4, 'key' => 'value "quoted"' })).to eq(["limit: 4", '"key" => "value \"quoted\""'])
           end
         end
 
@@ -47,13 +33,13 @@ module Generators
           subject { described_class.default_charset }
 
           context 'when not explicitly set' do
-            it { should eq(:utf8mb4) }
+            it { should eq("utf8mb4") }
           end
 
           context 'when explicitly set' do
-            before { described_class.default_charset = :utf8 }
+            before { described_class.default_charset = "utf8" }
             after  { described_class.default_charset = described_class::DEFAULT_CHARSET }
-            it     { should eq(:utf8) }
+            it     { should eq("utf8") }
           end
         end
 
@@ -61,13 +47,13 @@ module Generators
           subject { described_class.default_collation }
 
           context 'when not explicitly set' do
-            it { should eq(:utf8mb4_general) }
+            it { should eq("utf8mb4_bin") }
           end
 
           context 'when explicitly set' do
-            before { described_class.default_collation = :utf8mb4_general_ci }
+            before { described_class.default_collation = "utf8mb4_general_ci" }
             after  { described_class.default_collation = described_class::DEFAULT_COLLATION }
-            it     { should eq(:utf8mb4_general_ci) }
+            it     { should eq("utf8mb4_general_ci") }
           end
         end
 

data/spec/support/acceptance_spec_helpers.rb

@@ -23,7 +23,7 @@ module AcceptanceSpecHelpers
 
   def expect_file_to_eq(file_path, expectation)
     expect(File.exist?(file_path)).to be_truthy
-    expect(File.read(file_path)).to eq(expectation)
+    expect(File.read(file_path).gsub(/require '([^']*)'/, 'require "\1"')).to eq(expectation)
   end
 
   def clean_up_model(model)
@@ -45,13 +45,13 @@ module AcceptanceSpecHelpers
 
   class MigrationUpEquals < RSpec::Matchers::BuiltIn::Eq
     def matches?(subject)
-      super(subject[0])
+      super(subject[0].gsub(/, +([a-z_]+:)/i, ', \1')) # normalize multiple spaces to one
     end
   end
 
   class MigrationDownEquals < RSpec::Matchers::BuiltIn::Eq
     def matches?(subject)
-      super(subject[1])
+      super(subject[1].gsub(/, +([a-z_]+:)/i, ', \1')) # normalize multiple spaces to one
     end
   end
 end