rspec-sequel_expectations 0.1.0

data/lib/rspec/sequel_expectations/matchers/have_primary_key.rb

@@ -0,0 +1,62 @@
+module RSpec
+  module Matchers
+    module Sequel
+
+      class HavePrimaryKey
+
+        def matches?(subject)
+          @table = subject
+
+          get_keys
+
+          includes_all?
+        end
+
+        def description
+          %(have #{wording(@names)})
+        end
+
+        def failure_message
+          %(expected #{@table} to #{description} but #{@table} have #{wording(@keys)})
+        end
+
+        def failure_message_when_negated
+          %(did not expect #{@table} to #{description})
+        end
+
+      private
+
+        def initialize(*names)
+          @names = names
+          @keys  = []
+        end
+
+        def get_keys
+          @keys = DB.schema(@table).reject { |tuple| !tuple.last[:primary_key] }.map(&:first)
+        end
+
+        def includes_all?
+          @names.reject { |k| @keys.include?(k) }.empty?
+        end
+
+        def wording(arr)
+          case arr.length
+            when 0
+              %(no primary keys)
+            when 1
+              %(primary key "#{arr.first}")
+            else
+              %(primary keys #{arr.inspect})
+          end
+        end
+
+      end
+
+      def have_primary_key(*names)
+        HavePrimaryKey.new(*names)
+      end
+      alias :have_primary_keys :have_primary_key
+
+    end
+  end
+end

data/lib/rspec/sequel_expectations/matchers/refer_to.rb

@@ -0,0 +1,123 @@
+module RSpec
+  module Matchers
+    module Sequel
+      class ReferTo
+        def matches?(subject)
+          get_reference_for(subject)
+
+          refer_to? && correct_fk? && correct_pk? && correct_update? && correct_delete?
+        end
+
+        def from_fk(key)
+          @foreign_key = key
+          self
+        end
+
+        def to_pk(key)
+          @primary_key = key
+          self
+        end
+
+        def on_update(action)
+          @on_update = action
+          self
+        end
+
+        def on_delete(action)
+          @on_delete = action
+          self
+        end
+
+        def description
+          text = [%(have reference to "#{@table}")]
+          text << %(with column "#{@foreign_key}") if @foreign_key
+          text << %(with primary key column "#{@primary_key}") if @primary_key
+          text << %(with "#{@on_update}" action on update) if @on_update
+          text << %(with "#{@on_delete}" action on delete) if @on_delete
+
+          text.join(' ')
+        end
+
+        def failure_message
+          %(expected "#{@relation}" to #{description} but #{@error})
+        end
+
+        def failure_message_when_negated
+          %(did not expect "#{@relation}" to #{description})
+        end
+
+      private
+
+        def initialize(table)
+          @table       = table
+          @foreign_key = nil
+          @primary_key = nil
+          @on_update   = nil
+          @on_delete   = nil
+        end
+
+        def refer_to?
+          if @reference
+            true
+          else
+            @error = %("#{@relation}" does not have a reference to "#{@table}")
+            false
+          end
+        end
+
+        def correct_fk?
+          return true unless @foreign_key
+
+          if @reference[:columns].include?(@foreign_key)
+            true
+          else
+            @error = %("#{@relation}" does not have a foreign key column "#{@foreign_key}")
+            false
+          end
+        end
+
+        def correct_pk?
+          return true unless @primary_key
+
+          if @reference[:key].first == @primary_key
+            true
+          else
+            @error = %("#{@table}" does not have a primary key column "#{@primary_key}")
+            false
+          end
+        end
+
+        def correct_update?
+          return true unless @on_update
+
+          if @reference[:on_update] == @on_update
+            true
+          else
+            @error = %(reference does not have action "#{@on_update}" on update)
+            false
+          end
+        end
+
+        def correct_delete?
+          return true unless @on_delete
+
+          if @reference[:on_delete] == @on_delete
+            true
+          else
+            @error = %(reference does not have action "#{@on_delete}" on delete)
+            false
+          end
+        end
+
+        def get_reference_for(relation)
+          @relation  = relation
+          @reference = DB.foreign_key_list(relation).select { |fk| fk[:table] == @table }.first
+        end
+      end
+
+      def refer_to(table)
+        ReferTo.new(table)
+      end
+    end
+  end
+end

data/lib/rspec/sequel_expectations/version.rb

@@ -0,0 +1,5 @@
+module Rspec
+  module SequelExpectations
+    VERSION = "0.1.0"
+  end
+end

data/rspec-sequel_expectations.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rspec/sequel_expectations/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rspec-sequel_expectations"
+  spec.version       = Rspec::SequelExpectations::VERSION
+  spec.authors       = ["Andrey Savchenko"]
+  spec.email         = ["andrey@aejis.eu"]
+  spec.summary       = %q{RSpec matchers for Sequel}
+  spec.description   = %q{RSpec matchers for Sequel which tests database, not model}
+  spec.homepage      = "https://github.com/Ptico/rspec-sequel_expectations"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sequel", "~> 4.15"
+  spec.add_dependency "rspec-expectations", "~> 3.0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "sequel_pg"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "faker"
+end

data/spec/matchers/have_column_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe RSpec::Matchers::Sequel::HaveColumn do
+  before :all do
+    DB.create_table(:users) do
+      column :full_name, String
+      column :age, Integer, default: 18, null: false
+    end
+  end
+
+  after :all do
+    DB.drop_table(:users)
+  end
+
+  let(:table) { :users }
+
+  let(:result) { matcher.matches?(table) }
+
+  describe 'column exists' do
+    context 'when exists' do
+      let(:matcher) { have_column(:full_name) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have column named "full_name"')
+      end
+    end
+
+    context 'column not exists' do
+      let(:matcher) { have_column(:abyrvalg) }
+
+      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 does not have a column named "abyrvalg")
+      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 'column type' do
+    context 'when correct type' do
+      [String, :string, 'string', 'text'].each do |type|
+        context "with #{type}" do
+          let(:matcher) { have_column(:full_name).of_type(type) }
+
+          it 'should success' do
+            expect(result).to be(true)
+          end
+
+          it 'should have description' do
+            expect(matcher.description).to eql %(have column named "full_name" of type #{type})
+          end
+        end
+      end
+    end
+
+    context 'when incorrect type' do
+      let(:matcher) { have_column(:full_name).of_type(Integer) }
+
+      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 it have type [string, text])
+      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 'with_default' do
+    context 'when match' do
+      let(:matcher) { have_column(:age).with_default(18) }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have column named "age" with default value "18"')
+      end
+    end
+
+    context 'when did not match' do
+      let(:matcher) { have_column(:age).with_default(2) }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have column named "age" with default value "2"')
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected users to #{matcher.description} but it has default value "18")
+      end
+    end
+  end
+
+  describe 'allow_null' do
+    context 'when match' do
+      let(:matcher) { have_column(:full_name).allow_null }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have column named "full_name" allowing null')
+      end
+    end
+
+    context 'when did not match' do
+      let(:matcher) { have_column(:age).allow_null }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have column named "age" allowing null')
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected users to #{matcher.description} but it does not allow null)
+      end
+    end
+  end
+
+  describe 'not_null' do
+    context 'when match' do
+      let(:matcher) { have_column(:age).not_null }
+
+      it 'should success' do
+        expect(result).to be(true)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have column named "age" not allowing null')
+      end
+    end
+
+    context 'when did not match' do
+      let(:matcher) { have_column(:full_name).not_null }
+
+      it 'should fail' do
+        expect(result).to be(false)
+      end
+
+      it 'should have description' do
+        expect(matcher.description).to eql('have column named "full_name" not allowing null')
+      end
+
+      it 'should set error message' do
+        expect { result }.to change {
+          matcher.failure_message
+        }.to %(expected users to #{matcher.description} but it allow null)
+      end
+    end
+  end
+
+
+end

data/spec/matchers/have_enum_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe RSpec::Matchers::Sequel::HaveEnum do
+  before :all do
+    @enum_name = Faker::Lorem.word
+    @values = %w(admin manager user inspector)
+    DB.create_enum(@enum_name, @values)
+  end
+
+  after :all do
+    DB.drop_enum(@enum_name)
+  end
+
+  describe '#have_enum' do 
+    it 'return true if enum exists' do 
+      expect(DB).to have_enum(@enum_name)
+    end
+
+    it 'accept symbol as enum name' do 
+      expect(DB).to have_enum(@enum_name.to_sym)
+    end
+
+    it 'return false if enum does not exists' do 
+      expect(DB).to_not have_enum(@enum_name + "1")
+    end
+  end
+
+  describe '#with_values' do
+
+    it 'returns true if enum have exactly that values' do
+      expect(DB).to have_enum(@enum_name).with_values(@values) 
+    end
+
+    it 'returns false if enum values differ' do
+      expect(DB).not_to have_enum(@enum_name).with_values(@values.dup.push "something_new" ) 
+    end
+  end
+end