rspec-sequel_expectations 0.1.0

data/spec/matchers/have_index_on_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe RSpec::Matchers::Sequel::HaveIndexOn do
+  before :all do
+    DB.create_table(:users) do
+      column :name, String, index: true
+      column :login, String, index: true, unique: true
+      column :email, String
+      column :company_id, Integer
+      column :department_id, Integer
+      column :created_at, Time
+
+      index :email, unique: true, name: 'users_postbox'
+      index [:company_id, :department_id]
+    end
+  end
+
+  after :all do
+    DB.drop_table(:users)
+  end
+
+  let(:table) { :users }
+
+  let(:result) { matcher.matches?(table) }
+
+  describe 'have_index_on' do
+    context 'single' do
+      context 'when exists' do
+        let(:matcher) { have_index_on(:name) }
+
+        it 'should success' do
+          expect(result).to be(true)
+        end
+
+        it 'should have description' do
+          expect(matcher.description).to eql('have index on [:name]')
+        end
+      end
+
+      context 'when not exists' do
+        let(:matcher) { have_index_on(:created_at) }
+
+        it 'should fail' do
+          expect(result).to be(false)
+        end
+
+        it 'should set error message' do
+          expect { result }.to change {
+            matcher.failure_message
+          }.to %(expected users to #{matcher.description} but none exists)
+        end
+
+        it 'should set negative error message' do
+          expect { result }.to change {
+            matcher.failure_message_when_negated
+          }.to %(did not expect users to #{matcher.description})
+        end
+      end
+    end
+
+    context 'composite' do
+      context 'when exists' do
+        let(:matcher) { have_index_on([:company_id, :department_id]) }
+
+        it 'should success' do
+          expect(result).to be(true)
+        end
+
+        it 'should have description' do
+          expect(matcher.description).to eql('have index on [:company_id, :department_id]')
+        end
+      end
+
+      context 'when not exists' do
+        let(:matcher) { have_index_on([:company_id, :email]) }
+
+        it 'should fail' do
+          expect(result).to be(false)
+        end
+      end
+    end
+  end
+
+  describe 'uniqueness' do
+    context 'when single' do
+      let(:matcher) { have_unique_index_on(:email) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have unique index on [:email]')
+      end
+    end
+
+    context 'when have both index and constraint' do
+      let(:matcher) { have_unique_index_on(:login) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+    end
+
+    context 'when not unique' do
+      let(:matcher) { have_unique_index_on(:name) }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected users to #{matcher.description} but index is non-unique)
+      end
+
+      it 'should set negative error message' do
+        expect { result }.to change {
+          matcher.failure_message_when_negated
+        }.to %(did not expect users to #{matcher.description})
+      end
+    end
+  end
+
+  describe 'index name' do
+    context 'when match' do
+      let(:matcher) { have_unique_index_on(:email).named('users_postbox') }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have unique index on [:email] named "users_postbox"')
+      end
+    end
+
+    context 'when did not match' do
+      let(:matcher) { have_unique_index_on(:email).named('users_email') }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected users to #{matcher.description} but index have name "users_postbox")
+      end
+
+      it 'should set negative error message' do
+        expect { result }.to change {
+          matcher.failure_message_when_negated
+        }.to %(did not expect users to #{matcher.description})
+      end
+    end
+  end
+
+end

data/spec/matchers/have_primary_key_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe RSpec::Matchers::Sequel::HavePrimaryKey do
+  before :all do
+    DB.create_table(:companies) do
+      column :id, Integer
+      column :country_id, Integer
+
+      primary_key [:id, :country_id], name: :companies_pk
+    end
+
+    DB.create_table(:users) do
+      primary_key :id
+    end
+
+    DB.create_table(:sessions) do
+      column :session_id, Integer
+    end
+  end
+
+  after :all do
+    DB.drop_table(:companies)
+    DB.drop_table(:users)
+    DB.drop_table(:sessions)
+  end
+
+  let(:result) { matcher.matches?(table) }
+
+  describe 'have_primary_key' do
+    context 'single key' do
+      let(:table) { :users }
+
+      context 'when match' do
+        let(:matcher) { have_primary_key(:id) }
+
+        it 'should success' do
+          expect(result).to be(true)
+        end
+
+        it 'should have description' do
+          expect(matcher.description).to eql('have primary key "id"')
+        end
+      end
+
+      context 'when did not match' do
+        let(:matcher) { have_primary_key(:user_id) }
+
+        it 'should fail' do
+          expect(result).to be(false)
+        end
+
+        it 'should set error message' do
+          expect { result }.to change {
+            matcher.failure_message
+          }.to %(expected users to #{matcher.description} but users have primary key "id")
+        end
+
+        it 'should set negative error message' do
+          expect { result }.to change {
+            matcher.failure_message_when_negated
+          }.to("did not expect users to #{matcher.description}")
+        end
+      end
+
+      context 'when without keys' do
+        let(:matcher) { have_primary_key(:user_id) }
+        let(:table)   { :sessions }
+
+        it 'should fail' do
+          expect(result).to be(false)
+        end
+
+        it 'should set error message' do
+          expect { result }.to change {
+            matcher.failure_message
+          }.to %(expected sessions to #{matcher.description} but sessions have no primary keys)
+        end
+
+        it 'should set negative error message' do
+          expect { result }.to change {
+            matcher.failure_message_when_negated
+          }.to("did not expect sessions to #{matcher.description}")
+        end
+      end
+    end
+
+    context 'compound key' do
+      let(:table) { :companies }
+
+      context 'when match' do
+        context 'single test' do
+          let(:matcher) { have_primary_key(:country_id) }
+
+          it 'should success' do
+            expect(result).to be(true)
+          end
+
+          it 'should have description' do
+            expect(matcher.description).to eql('have primary key "country_id"')
+          end
+        end
+
+        context 'compound test' do
+          let(:matcher) { have_primary_keys(:id, :country_id) }
+
+          it 'should success' do
+            expect(result).to be(true)
+          end
+
+          it 'should have description' do
+            expect(matcher.description).to eql('have primary keys [:id, :country_id]')
+          end
+        end
+
+      end
+
+      context 'when did not match' do
+        let(:matcher) { have_primary_keys(:id, :city_id) }
+
+        it 'should fail' do
+          expect(result).to be(false)
+        end
+
+        it 'should set error message' do
+          expect { result }.to change {
+            matcher.failure_message
+          }.to %(expected companies to #{matcher.description} but companies have primary keys [:id, :country_id])
+        end
+
+        it 'should set negative error message' do
+          expect { result }.to change {
+            matcher.failure_message_when_negated
+          }.to("did not expect companies to #{matcher.description}")
+        end
+      end
+
+      context 'when without keys' do
+        let(:matcher) { have_primary_keys(:user_id, :id) }
+        let(:table)   { :sessions }
+
+        it 'should fail' do
+          expect(result).to be(false)
+        end
+
+        it 'should set error message' do
+          expect { result }.to change {
+            matcher.failure_message
+          }.to %(expected sessions to #{matcher.description} but sessions have no primary keys)
+        end
+
+      end
+    end
+  end
+
+end

data/spec/matchers/refer_to_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe RSpec::Matchers::Sequel::ReferTo do
+  before :all do
+    DB.create_table(:users) do
+      primary_key :id
+      column :name, String
+    end
+
+    DB.create_table(:posts) do
+      column :text, String
+
+      foreign_key :user_id, :users, on_update: :cascade, key: :id
+    end
+  end
+
+  after :all do
+    DB.drop_table(:posts)
+    DB.drop_table(:users)
+  end
+
+  let(:table) { :posts }
+
+  let(:result) { matcher.matches?(table) }
+
+  describe 'refer_to' do
+    context 'when reference exist' do
+      let(:matcher) { refer_to(:users) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have reference to "users"')
+      end
+    end
+
+    context 'when reference not exist' do
+      let(:matcher) { refer_to(:blabla) }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected "posts" to #{matcher.description} but "posts" does not have a reference to "blabla")
+      end
+
+      it 'should set negative error message' do
+        expect { result }.to change {
+          matcher.failure_message_when_negated
+        }.to %(did not expect "posts" to #{matcher.description})
+      end
+    end
+  end
+
+  describe 'from_fk' do
+    context 'when foreign key column exist' do
+      let(:matcher) { refer_to(:users).from_fk(:user_id) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have reference to "users" with column "user_id"')
+      end
+    end
+
+    context 'when foreign key column not exist' do
+      let(:matcher) { refer_to(:users).from_fk(:blabla_id) }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected "posts" to #{matcher.description} but "posts" does not have a foreign key column "blabla_id")
+      end
+    end
+  end
+
+  describe 'with_pk' do
+    context 'when primary key column exist' do
+      let(:matcher) { refer_to(:users).to_pk(:id) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have reference to "users" with primary key column "id"')
+      end
+    end
+
+    context 'when primary key column not exist' do
+      let(:matcher) { refer_to(:users).to_pk(:blabla) }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected "posts" to #{matcher.description} but "users" does not have a primary key column "blabla")
+      end
+    end
+  end
+
+  describe 'on_update' do
+    context 'when update action right' do
+      let(:matcher) { refer_to(:users).on_update(:cascade) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have reference to "users" with "cascade" action on update')
+      end
+    end
+
+    context 'when update action wrong' do
+      let(:matcher) { refer_to(:users).on_update(:blabla) }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected "posts" to #{matcher.description} but reference does not have action "blabla" on update)
+      end
+    end
+  end
+
+  describe 'on_delete' do
+    context 'when delete action right' do
+      let(:matcher) { refer_to(:users).on_delete(:no_action) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have reference to "users" with "no_action" action on delete')
+      end
+    end
+
+    context 'when update action wrong' do
+      let(:matcher) { refer_to(:users).on_delete(:blabla) }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected "posts" to #{matcher.description} but reference does not have action "blabla" on delete)
+      end
+    end
+  end
+end