declare_schema 0.8.0.pre.5 → 0.10.0

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

@@ -85,14 +85,6 @@ RSpec.describe DeclareSchema::Model::Column do
   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(:type) { :integer }
     let(:current_table_name) { model.table_name }
@@ -108,18 +100,56 @@ RSpec.describe DeclareSchema::Model::Column do
                           sql_type_metadata: {}) }
     subject { described_class.new(model, current_table_name, column) }
 
-    describe '#type' do
-      it 'returns type' do
-        expect(subject.type).to eq(type)
+    context 'Using fields' do
+      before do
+        class ColumnTestModel < ActiveRecord::Base
+          fields do
+            title :string, limit: 127, null: false
+            count :integer, null: false
+          end
+        end
+      end
+
+      describe '#type' do
+        it 'returns type' do
+          expect(subject.type).to eq(type)
+        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
 
-    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)
+    context 'Using declare_schema' do
+      before do
+        class ColumnTestModel < ActiveRecord::Base
+          declare_schema do
+            string :title, limit: 127, null: false
+            integer :count, null: false
+          end
+        end
+      end
+
+      describe '#type' do
+        it 'returns type' do
+          expect(subject.type).to eq(type)
+        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

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

@@ -3,89 +3,178 @@
 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__)
+  let(:model_class) { Network }
+
+  context 'Using fields' do
+    before do
+      load File.expand_path('../prepare_testapp.rb', __dir__)
 
-    class Network < ActiveRecord::Base
-      fields do
-        name :string, limit: 127, index: true
+      class Network < ActiveRecord::Base
+        fields do
+          name :string, limit: 127, index: true
 
-        timestamps
+          timestamps
+        end
       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 '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)}
 
-    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')
+      before do
+        allow(connection).to receive(:index_name).with('models', column: 'network_id') { 'on_network_id' }
       end
 
-      context 'when most options passed' do
-        let(:options) { { parent_table: :networks, foreign_key: :the_network_id, index_name: :index_on_network_id } }
-
+      describe '#initialize' do
         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 } }
+        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
 
-        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
+        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 '#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")')
+    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
   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' }
+  context 'Using declare_schema' do
     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') { }
+      load File.expand_path('../prepare_testapp.rb', __dir__)
+
+      class Network < ActiveRecord::Base
+        declare_schema do
+          string :name, limit: 127, index: true
+
+          timestamps
+        end
+      end
     end
 
-    describe '.for_model' do
-      subject { described_class.for_model(model, old_table_name) }
+    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
 
-      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')
+        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
   end

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

@@ -88,13 +88,13 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
 
     describe '#primary_key' do
       it 'returns false' do
-        expect(subject.primary_key).to eq(false)
+        expect(subject._defined_primary_key).to eq(false)
       end
     end
 
-    describe '#defined_primary_key' do
+    describe '#_defined_primary_key' do
       it 'returns false' do
-        expect(subject.defined_primary_key).to eq(false)
+        expect(subject._defined_primary_key).to eq(false)
       end
     end
 

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

@@ -10,119 +10,230 @@ require_relative '../../../../lib/declare_schema/model/index_definition'
 # unless you manually create any Sqlite tables with UNIQUE constraints.
 
 RSpec.describe DeclareSchema::Model::IndexDefinition do
-  before do
-    load File.expand_path('../prepare_testapp.rb', __dir__)
+  let(:model_class) { IndexDefinitionTestModel }
+
+  context 'Using fields' do
+    before do
+      load File.expand_path('../prepare_testapp.rb', __dir__)
 
-    class IndexDefinitionTestModel < ActiveRecord::Base
-      fields do
-        name :string, limit: 127, index: true
+      class IndexDefinitionTestModel < ActiveRecord::Base
+        fields do
+          name :string, limit: 127, index: true
 
-        timestamps
+          timestamps
+        end
       end
-    end
 
-    class IndexDefinitionCompoundIndexModel < ActiveRecord::Base
-      fields do
-        fk1_id :integer
-        fk2_id :integer
+      class IndexDefinitionCompoundIndexModel < ActiveRecord::Base
+        fields do
+          fk1_id :integer
+          fk2_id :integer
 
-        timestamps
+          timestamps
+        end
       end
     end
-  end
 
-  let(:model_class) { IndexDefinitionTestModel }
+    describe 'instance methods' do
+      let(:model) { model_class.new }
+      subject { declared_class.new(model_class) }
 
-  describe 'instance methods' do
-    let(:model) { model_class.new }
-    subject { declared_class.new(model_class) }
+      it 'has index_definitions' do
+        expect(model_class.index_definitions).to be_kind_of(Array)
+        expect(model_class.index_definitions.map(&:name)).to eq(['on_name'])
+        expect([:name, :fields, :unique].map { |attr| model_class.index_definitions[0].send(attr)}).to eq(
+          ['on_name', ['name'], false]
+        )
+      end
 
-    it 'has index_definitions' do
-      expect(model_class.index_definitions).to be_kind_of(Array)
-      expect(model_class.index_definitions.map(&:name)).to eq(['on_name'])
-      expect([:name, :fields, :unique].map { |attr| model_class.index_definitions[0].send(attr)}).to eq(
-        ['on_name', ['name'], false]
-      )
+      it 'has index_definitions_with_primary_key' 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.map(&:name)).to eq(['PRIMARY', 'on_name'])
+        expect([:name, :fields, :unique].map { |attr| result[0].send(attr)}).to eq(
+          ['PRIMARY', ['id'], true]
+        )
+        expect([:name, :fields, :unique].map { |attr| result[1].send(attr)}).to eq(
+          ['on_name', ['name'], false]
+        )
+      end
     end
 
-    it 'has index_definitions_with_primary_key' 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.map(&:name)).to eq(['PRIMARY', 'on_name'])
-      expect([:name, :fields, :unique].map { |attr| result[0].send(attr)}).to eq(
-        ['PRIMARY', ['id'], true]
-      )
-      expect([:name, :fields, :unique].map { |attr| result[1].send(attr)}).to eq(
-        ['on_name', ['name'], false]
-      )
+    describe 'class methods' do
+      describe 'index_name' do
+        it 'works with a single column' do
+          expect(described_class.index_name('parent_id')).to eq('on_parent_id')
+        end
+
+        it 'works with many columns' do
+          expect(described_class.index_name(['a', 'b', 'c'])).to eq('on_a_and_b_and_c')
+        end
+      end
+
+      context 'with a migrated database' do
+        before do
+          ActiveRecord::Base.connection.execute <<~EOS
+              CREATE TABLE index_definition_test_models (
+                id INTEGER NOT NULL PRIMARY KEY,
+                name #{if defined?(Sqlite3) then 'TEXT' else 'VARCHAR(255)' end} NOT NULL
+              )
+          EOS
+          ActiveRecord::Base.connection.execute <<~EOS
+            CREATE UNIQUE INDEX index_definition_test_models_on_name ON index_definition_test_models(name)
+          EOS
+          ActiveRecord::Base.connection.execute <<~EOS
+              CREATE TABLE index_definition_compound_index_models (
+                fk1_id INTEGER NOT NULL,
+                fk2_id INTEGER NOT NULL,
+                PRIMARY KEY (fk1_id, fk2_id)
+              )
+          EOS
+          ActiveRecord::Base.connection.schema_cache.clear!
+        end
+
+        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.size).to eq(2), subject.inspect
+              expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
+                ['index_definition_test_models_on_name', ['name'], true]
+              )
+              expect([:name, :columns, :unique].map { |attr| subject[1].send(attr) }).to eq(
+                ['PRIMARY', ['id'], true]
+              )
+            end
+          end
+
+          context 'with compound-column PK' do
+            let(:model_class) { IndexDefinitionCompoundIndexModel }
+
+            it 'returns the indexes for the model' do
+              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::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')])
+
+                expect(model_class.connection).to receive(:dup).and_return(connection_stub)
+              end
+
+              expect(subject.size).to eq(1), subject.inspect
+              expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
+                ['PRIMARY', ['fk1_id', 'fk2_id'], true]
+              )
+            end
+          end
+        end
+      end
     end
   end
 
-  describe 'class methods' do
-    describe 'index_name' do
-      it 'works with a single column' do
-        expect(described_class.index_name('parent_id')).to eq('on_parent_id')
+  context 'Using declare_schema' do
+    before do
+      load File.expand_path('../prepare_testapp.rb', __dir__)
+
+      class IndexDefinitionTestModel < ActiveRecord::Base
+        declare_schema do
+          string :name, limit: 127, index: true
+
+          timestamps
+        end
       end
 
-      it 'works with many columns' do
-        expect(described_class.index_name(['a', 'b', 'c'])).to eq('on_a_and_b_and_c')
+      class IndexDefinitionCompoundIndexModel < ActiveRecord::Base
+        declare_schema do
+          integer :fk1_id
+          integer :fk2_id
+
+          timestamps
+        end
       end
     end
 
-    context 'with a migrated database' do
-      before do
-        ActiveRecord::Base.connection.execute <<~EOS
+    describe 'instance methods' do
+      let(:model) { model_class.new }
+      subject { declared_class.new(model_class) }
+
+      it 'has index_definitions' do
+        expect(model_class.index_definitions).to be_kind_of(Array)
+        expect(model_class.index_definitions.map(&:name)).to eq(['on_name'])
+        expect([:name, :fields, :unique].map { |attr| model_class.index_definitions[0].send(attr)}).to eq(
+                                                                                                           ['on_name', ['name'], false]
+                                                                                                       )
+      end
+
+      it 'has index_definitions_with_primary_key' 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.map(&:name)).to eq(['PRIMARY', 'on_name'])
+        expect([:name, :fields, :unique].map { |attr| result[0].send(attr)}).to eq(
+                                                                                    ['PRIMARY', ['id'], true]
+                                                                                )
+        expect([:name, :fields, :unique].map { |attr| result[1].send(attr)}).to eq(
+                                                                                    ['on_name', ['name'], false]
+                                                                                )
+      end
+    end
+
+    describe 'class << self' do
+      context 'with a migrated database' do
+        before do
+          ActiveRecord::Base.connection.execute <<~EOS
             CREATE TABLE index_definition_test_models (
               id INTEGER NOT NULL PRIMARY KEY,
               name #{if defined?(Sqlite3) then 'TEXT' else 'VARCHAR(255)' end} NOT NULL
             )
-        EOS
-        ActiveRecord::Base.connection.execute <<~EOS
+          EOS
+          ActiveRecord::Base.connection.execute <<~EOS
           CREATE UNIQUE INDEX index_definition_test_models_on_name ON index_definition_test_models(name)
-        EOS
-        ActiveRecord::Base.connection.execute <<~EOS
+          EOS
+          ActiveRecord::Base.connection.execute <<~EOS
             CREATE TABLE index_definition_compound_index_models (
               fk1_id INTEGER NOT NULL,
               fk2_id INTEGER NOT NULL,
               PRIMARY KEY (fk1_id, fk2_id)
             )
-        EOS
-        ActiveRecord::Base.connection.schema_cache.clear!
-      end
-
-      describe 'for_model' do
-        subject { described_class.for_model(model_class) }
+          EOS
+          ActiveRecord::Base.connection.schema_cache.clear!
+        end
 
-        context 'with single-column PK' do
-          it 'returns the indexes for the model' do
-            expect(subject.size).to eq(2), subject.inspect
-            expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
-              ['index_definition_test_models_on_name', ['name'], true]
-            )
-            expect([:name, :columns, :unique].map { |attr| subject[1].send(attr) }).to eq(
-              ['PRIMARY', ['id'], true]
-            )
+        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.size).to eq(2), subject.inspect
+              expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
+                                                                                             ['index_definition_test_models_on_name', ['name'], true]
+                                                                                         )
+              expect([:name, :columns, :unique].map { |attr| subject[1].send(attr) }).to eq(
+                                                                                             ['PRIMARY', ['id'], true]
+                                                                                         )
+            end
           end
-        end
 
-        context 'with compound-column PK' do
-          let(:model_class) { IndexDefinitionCompoundIndexModel }
+          context 'with compound-column PK' do
+            let(:model_class) { IndexDefinitionCompoundIndexModel }
 
-          it 'returns the indexes for the model' do
-            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::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')])
+            it 'returns the indexes for the model' do
+              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::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')])
 
-              expect(model_class.connection).to receive(:dup).and_return(connection_stub)
-            end
+                expect(model_class.connection).to receive(:dup).and_return(connection_stub)
+              end
 
-            expect(subject.size).to eq(1), subject.inspect
-            expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
-              ['PRIMARY', ['fk1_id', 'fk2_id'], true]
-            )
+              expect(subject.size).to eq(1), subject.inspect
+              expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
+                                                                                             ['PRIMARY', ['fk1_id', 'fk2_id'], true]
+                                                                                         )
+            end
           end
         end
       end