minitest-sequel 0.1.0 → 0.2.0

data/Rakefile

@@ -1,10 +1,31 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+OSX = RUBY_PLATFORM.match(/darwin/)
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:spec) do |t|
-  t.libs << "spec"
-  t.libs << "lib"
+  t.libs << 'spec'
+  t.libs << 'lib'
   t.test_files = FileList['spec/**/*_spec.rb']
 end
 
 task :default => :spec
+
+desc "Run specs with coverage"
+task :coverage do
+  ENV['COVERAGE'] = '1'
+  Rake::Task['spec'].invoke
+  `open coverage/index.html` if OSX
+end
+
+
+desc 'Run Rubocop report'
+task :rubocop do
+  res = `which rubocop`
+  if res != ""
+    `rubocop -f html -o ./rubocop/report.html lib/`
+    `open rubocop/report.html` if OSX
+  else
+    puts "\nERROR: 'rubocop' gem is not installed or available. Please install with 'gem install rubocop'."
+  end
+end

data/lib/minitest/sequel/associations.rb

@@ -0,0 +1,183 @@
+require 'minitest/sequel'
+
+# reopening to add association functionality
+module Minitest::Assertions
+  
+  # Test for a :one_to_one association for the current model
+  # 
+  #     let(:m) { Post.first }
+  #     
+  #     it { assert_association_one_to_one(m, :first_comment, { class: :Comment, order: :id }) }
+  #     it { m.must_have_one_to_one_association(:first_comment, { class: :Comment, order: :id }) }
+  # 
+  def assert_association_one_to_one(obj, attribute, opts = {}, msg = nil)
+    assert_association(obj.class, :one_to_one, attribute, opts, msg)
+  end
+  
+  # Test for a :one_to_many association for the current model
+  # 
+  #     let(:m) { Post.first }
+  #     
+  #     it { assert_association_one_to_many(m, :comments) }
+  #     it { m.must_have_one_to_many_association(:comments) }
+  # 
+  def assert_association_one_to_many(obj, attribute, opts = {}, msg = nil)
+    assert_association(obj.class, :one_to_many, attribute, opts, msg)
+  end
+  
+  # Test for a :many_to_one association for the current model
+  # 
+  #     let(:m) { Post.first }
+  #     
+  #     it { assert_association_many_to_one(m, :author) }
+  #     it { m.must_have_many_to_one_association(:author) }
+  # 
+  def assert_association_many_to_one(obj, attribute, opts = {}, msg = nil)
+    assert_association(obj.class, :many_to_one, attribute, opts, msg)
+  end
+  
+  # Test for a :many_to_many association for the current model
+  # 
+  #     let(:m) { Post.first }
+  #     
+  #     it { assert_association_many_to_many(m, :tags) }
+  #     it { m.must_have_many_to_many_association(:tags) }
+  # 
+  def assert_association_many_to_many(obj, attribute, opts = {}, msg = nil)
+    assert_association(obj.class, :many_to_many, attribute, opts, msg)
+  end
+  
+  # Test for associations for the current model by passing the :association_type
+  # 
+  #     it { assert_association(Post, :many_to_many, :tags) }
+  # 
+  def assert_association(klass, association_type, attribute, opts = {}, msg = nil)
+    msg = msg.nil? ? '' : "#{msg}\n"
+    msg << "Expected #{klass.inspect} to have a #{association_type.inspect}"
+    msg << " association #{attribute.inspect}"
+    assoc = klass.association_reflection(attribute) || {}
+    if assoc.empty?
+      msg << " but no association '#{attribute.inspect}' was found"
+      arr = []
+      klass.associations.each do |a|
+        o = klass.association_reflection(a)
+        if o[:type] == :many_to_many
+          arr << { 
+            attribute:    o[:name], 
+            type:         o[:type], 
+            class:        o[:class_name].to_sym, 
+            join_table:   o[:join_table], 
+            left_keys:    o[:left_keys], 
+            right_keys:   o[:right_keys] 
+          }
+        else
+          arr << { 
+            attribute:  o[:name], 
+            type:       o[:type], 
+            class:      o[:class_name].to_sym, 
+            keys:       o[:keys] 
+          }
+        end
+      end
+      msg << " - \navailable associations are: [ #{arr.join(', ')} ]\n"
+      assert(false, msg)
+    else
+      matching = assoc[:type] == association_type
+      err_msg = []
+      conf_msg = []
+      opts.each do |key, value|
+        conf_msg << { key => value } 
+        if assoc[key] != value
+          err_msg << { key => assoc[key] }
+          matching = false
+        end
+      end
+      msg << " with given options: #{conf_msg.join(', ')} but should be #{err_msg.join(', ')}"
+      assert(matching, msg)
+    end
+  end
+  
+  
+  # Test to ensure there is no :one_to_one association for the current model
+  # 
+  #     let(:m) { Post.first }
+  #     
+  #     it { refute_association_one_to_one(m, :first_comment, { class: :Comment, order: :id }) }
+  #     it { m.must_have_one_to_one_association(:first_comment, { class: :Comment, order: :id }) }
+  # 
+  def refute_association_one_to_one(obj, attribute, opts = {}, msg = nil)
+    refute_association(obj.class, :one_to_one, attribute, opts, msg)
+  end
+  
+  # Test to ensure there is no :one_to_many association for the current model
+  # 
+  #     let(:m) { Post.first }
+  #     
+  #     it { refute_association_one_to_many(m, :comments) }
+  #     it { m.must_have_one_to_many_association(:comments) }
+  # 
+  def refute_association_one_to_many(obj, attribute, opts = {}, msg = nil)
+    refute_association(obj.class, :one_to_many, attribute, opts, msg)
+  end
+  
+  # Test to ensure there is no :many_to_one association for the current model
+  # 
+  #     let(:m) { Post.first }
+  #     
+  #     it { refute_association_many_to_one(m, :author) }
+  #     it { m.must_have_many_to_one_association(:author) }
+  # 
+  def refute_association_many_to_one(obj, attribute, opts = {}, msg = nil)
+    refute_association(obj.class, :many_to_one, attribute, opts, msg)
+  end
+  
+  # Test to ensure there is no :many_to_many association for the current model
+  # 
+  #     let(:m) { Post.first }
+  #     
+  #     it { refute_association_many_to_many(m, :tags) }
+  #     it { m.must_have_many_to_many_association(:tags) }
+  # 
+  def refute_association_many_to_many(obj, attribute, opts = {}, msg = nil)
+    refute_association(obj.class, :many_to_many, attribute, opts, msg)
+  end
+  
+  # Test to ensure the current model does NOT have an association by type :association_type
+  # 
+  #     it { refute_association(Post, :many_to_many, :tags) }
+  # 
+  def refute_association(klass, association_type, attribute, opts = {}, msg = nil)
+    msg = msg.nil? ? '' : "#{msg}\n"
+    msg << "Expected #{klass.inspect} to NOT have a #{association_type.inspect}"
+    msg << " association #{attribute.inspect}"
+    assoc = klass.association_reflection(attribute) || {}
+    
+    if assoc.empty?
+      assert(true, msg)
+    else
+      matching = false if assoc[:type] == association_type
+      msg << ", but such an association was found"
+      assert(matching, msg)
+    end
+    
+  end
+  
+end
+
+
+# add support for Spec syntax
+module Minitest::Expectations
+  
+  infect_an_assertion :assert_association,              :must_have_association,             :reverse
+  infect_an_assertion :assert_association_one_to_one,   :must_have_one_to_one_association,  :reverse
+  infect_an_assertion :assert_association_one_to_many,  :must_have_one_to_many_association, :reverse
+  infect_an_assertion :assert_association_many_to_one,  :must_have_many_to_one_association, :reverse
+  infect_an_assertion :assert_association_many_to_many, :must_have_many_to_many_association, :reverse
+  
+  infect_an_assertion :refute_association,              :wont_have_association,             :reverse
+  infect_an_assertion :refute_association_one_to_one,   :wont_have_one_to_one_association,  :reverse
+  infect_an_assertion :refute_association_one_to_many,  :wont_have_one_to_many_association, :reverse
+  infect_an_assertion :refute_association_many_to_one,  :wont_have_many_to_one_association, :reverse
+  infect_an_assertion :refute_association_many_to_many, :wont_have_many_to_many_association, :reverse
+  
+end

data/lib/minitest/sequel/columns.rb

@@ -0,0 +1,161 @@
+require 'minitest/sequel'
+
+# reopening to add schema validation functionality
+module Minitest::Assertions
+  
+  # Conveniently test your Model definitions as follows:
+  #
+  #     let(:m) { Post.first }
+  #
+  #     it { assert_have_column(m, :title, type: :string, db_type: 'varchar(250)') }
+  #     it { m.must_have_column(:title, type: :string, db_type: 'varchar(250)') }
+  #
+  #     # assert_have_column(<instance>, <column_name>, <options>, <custom_error_message>)
+  #     
+  #     # <instance>.must_have_column(<column_name>, <options>, <custom_error_message>)
+  #
+  #
+  # `assert_have_column()` first tests if the column name is defined in the Model and then checks 
+  # all passed options. The following options are valid and checked:
+  #
+  #  * :type
+  #  * :db_type
+  #  * :allow_null
+  #  * :max_length
+  #  * :default
+  #  * :primary_key
+  #  * :auto_increment
+  #
+  # In the event the specs differ from the actual database implementation an extensive error 
+  # message with the differing option(s) is provided to help speed up debugging the issue:
+  #
+  #     Expected Post model to have column: :title with: \
+  #       { type: 'string', db_type: 'varchar(250)', allow_null: 'false' } \
+  #       but found: { db_type: 'varchar(255)' }
+  #
+  #
+  # **Please NOTE!**
+  #
+  # To test options with a value that is either `nil`, `true` or `false`, please use `:nil`, 
+  # `:false` or `:true` and provide numbers as 'strings' instead.
+  #
+  #
+  def assert_have_column(obj, attribute, opts = {}, msg = nil)
+    msg = msg.nil? ? '' : "#{msg}\n"
+    msg << "Expected #{obj.class} model to have column: :#{attribute}"
+    err_msg  = []
+    conf_msg = []
+    # check if column exists
+    col = obj.db.schema(obj.class.table_name).detect { |c| c[0] == attribute }
+    matching = !col.nil?
+    
+    # bail out if no matching column
+    unless matching
+      msg << ' but no such column exists' 
+      assert(false, msg)
+    end
+    
+    # bail out if options provided are invalid
+    val_opts = [:type, :db_type, :allow_null, :max_length, :default, :primary_key, :auto_increment]
+    invalid_opts  = opts.keys.reject { |o| val_opts.include?(o) }
+    unless invalid_opts.empty?
+      msg << ', but the following invalid option(s) was found: { '
+      invalid_opts.each { |o| msg << "#{o.inspect}; " }
+      msg << " }. Valid options are: #{val_opts.inspect}"
+      assert(false, msg)
+    end
+    
+    # TODO: simplify this mess. quick fix didn't work, so look at it again when time permits.
+    
+    unless opts[:type].nil?
+      expected = (col[1][:type].to_s == opts[:type].to_s)
+      conf_msg << "type: '#{opts[:type]}'"
+      unless expected
+        err_msg << "type: '#{col[1][:type]}'"
+      end
+      matching &&= expected
+    end
+    
+    unless opts[:db_type].nil?
+      expected = (col[1][:db_type].to_s == opts[:db_type].to_s)
+      conf_msg << "db_type: '#{opts[:db_type]}'"
+      unless expected
+        err_msg << "db_type: '#{col[1][:db_type]}'"
+      end
+      matching &&= expected
+    end
+    
+    unless opts[:max_length].nil?
+      expected = (col[1][:max_length] === opts[:max_length])
+      conf_msg << "max_length: '#{opts[:max_length]}'"
+      unless expected
+        err_msg << "max_length: '#{col[1][:max_length]}'"
+      end
+      matching &&= expected
+    end
+    
+    unless opts[:allow_null].nil?
+      v = _convert_value(opts[:allow_null])
+      expected = (opts[:allow_null] === v)
+      conf_msg << "allow_null: '#{opts[:allow_null]}'"
+      unless expected
+        err_msg << "allow_null: '#{col[1][:allow_null]}'"
+      end
+      matching &&= expected
+    end
+    
+    unless opts[:default].nil?
+      v = _convert_value(opts[:default])
+      expected = (col[1][:default] === v)
+      conf_msg << "default: '#{opts[:default]}'"
+      unless expected
+        err_msg << "default: '#{col[1][:default].inspect}'"
+      end
+      matching &&= expected
+    end
+    
+    unless opts[:primary_key].nil?
+      v = _convert_value(opts[:primary_key])
+      expected = (col[1][:primary_key] === v)
+      conf_msg << "primary_key: '#{opts[:primary_key]}'"
+      unless expected
+        err_msg << "primary_key: '#{col[1][:primary_key]}'"
+      end
+      matching &&= expected
+    end
+    
+    unless opts[:auto_increment].nil?
+      v = _convert_value(opts[:auto_increment])
+      expected = (col[1][:auto_increment] === v)
+      conf_msg << "auto_increment: '#{opts[:auto_increment]}'"
+      unless expected
+        err_msg << "auto_increment: '#{col[1][:auto_increment]}'"
+      end
+      matching &&= expected
+    end
+    
+    msg = msg << " with: { #{conf_msg.join(', ')} } but found: { #{err_msg.join(', ')} }"
+    assert(matching, msg)
+  end
+  
+  #
+  def refute_have_column(obj, attribute, opts = {}, msg = nil)
+    msg = msg.nil? ? '' : "#{msg}\n"
+    msg << "Expected #{obj.class} model to NOT have column: :#{attribute}"
+    # check if column exists
+    col = obj.db.schema(obj.class.table_name).detect { |col| col[0] == attribute }
+    matching = col.nil?
+    unless matching
+      msg << ' but such a column was found' 
+      assert(matching, msg)
+    end
+  end
+  
+end
+
+
+# add support for Spec syntax
+module Minitest::Expectations
+  infect_an_assertion :assert_have_column, :must_have_column, :reverse
+  infect_an_assertion :refute_have_column, :wont_have_column, :reverse
+end